001// Generated from com/puppycrawl/tools/checkstyle/grammars/javadoc/JavadocParser.g4 by ANTLR 4.5.2
002package com.puppycrawl.tools.checkstyle.grammars.javadoc;
003import org.antlr.v4.runtime.atn.*;
004import org.antlr.v4.runtime.dfa.DFA;
005import org.antlr.v4.runtime.*;
006import org.antlr.v4.runtime.misc.*;
007import org.antlr.v4.runtime.tree.*;
008import java.util.List;
009import java.util.Iterator;
010import java.util.ArrayList;
011
012@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
013public class JavadocParser extends Parser {
014        static { RuntimeMetaData.checkVersion("4.5.2", RuntimeMetaData.VERSION); }
015
016        protected static final DFA[] _decisionToDFA;
017        protected static final PredictionContextCache _sharedContextCache =
018                new PredictionContextCache();
019        public static final int
020                LEADING_ASTERISK=1, HTML_COMMENT_START=2, CDATA=3, WS=4, OPEN=5, NEWLINE=6, 
021                AUTHOR_LITERAL=7, DEPRECATED_LITERAL=8, EXCEPTION_LITERAL=9, PARAM_LITERAL=10, 
022                RETURN_LITERAL=11, SEE_LITERAL=12, SERIAL_LITERAL=13, SERIAL_FIELD_LITERAL=14, 
023                SERIAL_DATA_LITERAL=15, SINCE_LITERAL=16, THROWS_LITERAL=17, VERSION_LITERAL=18, 
024                JAVADOC_INLINE_TAG_START=19, JAVADOC_INLINE_TAG_END=20, CUSTOM_NAME=21, 
025                LITERAL_INCLUDE=22, LITERAL_EXCLUDE=23, CHAR=24, PARAMETER_NAME=25, Char1=26, 
026                STRING=27, PACKAGE=28, DOT=29, HASH=30, CLASS=31, Char2=32, MEMBER=33, 
027                LEFT_BRACE=34, RIGHT_BRACE=35, ARGUMENT=36, COMMA=37, Char20=38, FIELD_NAME=39, 
028                Char3=40, FIELD_TYPE=41, Char4=42, CLASS_NAME=43, Char5=44, CODE_LITERAL=45, 
029                DOC_ROOT_LITERAL=46, INHERIT_DOC_LITERAL=47, LINK_LITERAL=48, LINKPLAIN_LITERAL=49, 
030                LITERAL_LITERAL=50, VALUE_LITERAL=51, Char7=52, Char8=53, Char10=54, CLOSE=55, 
031                SLASH_CLOSE=56, SLASH=57, EQUALS=58, P_HTML_TAG_NAME=59, LI_HTML_TAG_NAME=60, 
032                TR_HTML_TAG_NAME=61, TD_HTML_TAG_NAME=62, TH_HTML_TAG_NAME=63, BODY_HTML_TAG_NAME=64, 
033                COLGROUP_HTML_TAG_NAME=65, DD_HTML_TAG_NAME=66, DT_HTML_TAG_NAME=67, HEAD_HTML_TAG_NAME=68, 
034                HTML_HTML_TAG_NAME=69, OPTION_HTML_TAG_NAME=70, TBODY_HTML_TAG_NAME=71, 
035                TFOOT_HTML_TAG_NAME=72, THEAD_HTML_TAG_NAME=73, AREA_HTML_TAG_NAME=74, 
036                BASE_HTML_TAG_NAME=75, BASEFONT_HTML_TAG_NAME=76, BR_HTML_TAG_NAME=77, 
037                COL_HTML_TAG_NAME=78, FRAME_HTML_TAG_NAME=79, HR_HTML_TAG_NAME=80, IMG_HTML_TAG_NAME=81, 
038                INPUT_HTML_TAG_NAME=82, ISINDEX_HTML_TAG_NAME=83, LINK_HTML_TAG_NAME=84, 
039                META_HTML_TAG_NAME=85, PARAM_HTML_TAG_NAME=86, HTML_TAG_NAME=87, Char11=88, 
040                ATTR_VALUE=89, Char12=90, HTML_COMMENT_END=91;
041        public static final int
042                RULE_javadoc = 0, RULE_htmlElement = 1, RULE_htmlElementOpen = 2, RULE_htmlElementClose = 3, 
043                RULE_attribute = 4, RULE_htmlTag = 5, RULE_pTagOpen = 6, RULE_pTagClose = 7, 
044                RULE_paragraph = 8, RULE_liTagOpen = 9, RULE_liTagClose = 10, RULE_li = 11, 
045                RULE_trTagOpen = 12, RULE_trTagClose = 13, RULE_tr = 14, RULE_tdTagOpen = 15, 
046                RULE_tdTagClose = 16, RULE_td = 17, RULE_thTagOpen = 18, RULE_thTagClose = 19, 
047                RULE_th = 20, RULE_bodyTagOpen = 21, RULE_bodyTagClose = 22, RULE_body = 23, 
048                RULE_colgroupTagOpen = 24, RULE_colgroupTagClose = 25, RULE_colgroup = 26, 
049                RULE_ddTagOpen = 27, RULE_ddTagClose = 28, RULE_dd = 29, RULE_dtTagOpen = 30, 
050                RULE_dtTagClose = 31, RULE_dt = 32, RULE_headTagOpen = 33, RULE_headTagClose = 34, 
051                RULE_head = 35, RULE_htmlTagOpen = 36, RULE_htmlTagClose = 37, RULE_html = 38, 
052                RULE_optionTagOpen = 39, RULE_optionTagClose = 40, RULE_option = 41, RULE_tbodyTagOpen = 42, 
053                RULE_tbodyTagClose = 43, RULE_tbody = 44, RULE_tfootTagOpen = 45, RULE_tfootTagClose = 46, 
054                RULE_tfoot = 47, RULE_theadTagOpen = 48, RULE_theadTagClose = 49, RULE_thead = 50, 
055                RULE_singletonElement = 51, RULE_singletonTag = 52, RULE_areaTag = 53, 
056                RULE_baseTag = 54, RULE_basefontTag = 55, RULE_brTag = 56, RULE_colTag = 57, 
057                RULE_frameTag = 58, RULE_hrTag = 59, RULE_imgTag = 60, RULE_inputTag = 61, 
058                RULE_isindexTag = 62, RULE_linkTag = 63, RULE_metaTag = 64, RULE_paramTag = 65, 
059                RULE_wrongSinletonTag = 66, RULE_singletonTagName = 67, RULE_description = 68, 
060                RULE_reference = 69, RULE_parameters = 70, RULE_javadocTag = 71, RULE_javadocInlineTag = 72, 
061                RULE_htmlComment = 73, RULE_text = 74;
062        public static final String[] ruleNames = {
063                "javadoc", "htmlElement", "htmlElementOpen", "htmlElementClose", "attribute", 
064                "htmlTag", "pTagOpen", "pTagClose", "paragraph", "liTagOpen", "liTagClose", 
065                "li", "trTagOpen", "trTagClose", "tr", "tdTagOpen", "tdTagClose", "td", 
066                "thTagOpen", "thTagClose", "th", "bodyTagOpen", "bodyTagClose", "body", 
067                "colgroupTagOpen", "colgroupTagClose", "colgroup", "ddTagOpen", "ddTagClose", 
068                "dd", "dtTagOpen", "dtTagClose", "dt", "headTagOpen", "headTagClose", 
069                "head", "htmlTagOpen", "htmlTagClose", "html", "optionTagOpen", "optionTagClose", 
070                "option", "tbodyTagOpen", "tbodyTagClose", "tbody", "tfootTagOpen", "tfootTagClose", 
071                "tfoot", "theadTagOpen", "theadTagClose", "thead", "singletonElement", 
072                "singletonTag", "areaTag", "baseTag", "basefontTag", "brTag", "colTag", 
073                "frameTag", "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", 
074                "paramTag", "wrongSinletonTag", "singletonTagName", "description", "reference", 
075                "parameters", "javadocTag", "javadocInlineTag", "htmlComment", "text"
076        };
077
078        private static final String[] _LITERAL_NAMES = {
079                null, null, null, null, null, null, null, "'@author'", "'@deprecated'", 
080                null, null, "'@return'", null, "'@serial'", null, "'@serialData'", "'@since'", 
081                null, "'@version'", null, null, null, "'include'", "'exclude'", null, 
082                null, null, null, null, "'.'", null, null, null, null, "'('", "')'", null, 
083                "','", null, null, null, null, null, null, null, null, "'@docRoot'", "'@inheritDoc'", 
084                "'@link'", "'@linkplain'", null, "'@value'", null, null, null, null, null, 
085                "'/'", "'='", null, null, null, null, null, null, null, null, null, null, 
086                null, null, null, null, null, null, null, null, null, null, null, null, 
087                null, null, null, null, null, null, null, null, null, null, "'-->'"
088        };
089        private static final String[] _SYMBOLIC_NAMES = {
090                null, "LEADING_ASTERISK", "HTML_COMMENT_START", "CDATA", "WS", "OPEN", 
091                "NEWLINE", "AUTHOR_LITERAL", "DEPRECATED_LITERAL", "EXCEPTION_LITERAL", 
092                "PARAM_LITERAL", "RETURN_LITERAL", "SEE_LITERAL", "SERIAL_LITERAL", "SERIAL_FIELD_LITERAL", 
093                "SERIAL_DATA_LITERAL", "SINCE_LITERAL", "THROWS_LITERAL", "VERSION_LITERAL", 
094                "JAVADOC_INLINE_TAG_START", "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", "LITERAL_INCLUDE", 
095                "LITERAL_EXCLUDE", "CHAR", "PARAMETER_NAME", "Char1", "STRING", "PACKAGE", 
096                "DOT", "HASH", "CLASS", "Char2", "MEMBER", "LEFT_BRACE", "RIGHT_BRACE", 
097                "ARGUMENT", "COMMA", "Char20", "FIELD_NAME", "Char3", "FIELD_TYPE", "Char4", 
098                "CLASS_NAME", "Char5", "CODE_LITERAL", "DOC_ROOT_LITERAL", "INHERIT_DOC_LITERAL", 
099                "LINK_LITERAL", "LINKPLAIN_LITERAL", "LITERAL_LITERAL", "VALUE_LITERAL", 
100                "Char7", "Char8", "Char10", "CLOSE", "SLASH_CLOSE", "SLASH", "EQUALS", 
101                "P_HTML_TAG_NAME", "LI_HTML_TAG_NAME", "TR_HTML_TAG_NAME", "TD_HTML_TAG_NAME", 
102                "TH_HTML_TAG_NAME", "BODY_HTML_TAG_NAME", "COLGROUP_HTML_TAG_NAME", "DD_HTML_TAG_NAME", 
103                "DT_HTML_TAG_NAME", "HEAD_HTML_TAG_NAME", "HTML_HTML_TAG_NAME", "OPTION_HTML_TAG_NAME", 
104                "TBODY_HTML_TAG_NAME", "TFOOT_HTML_TAG_NAME", "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", 
105                "BASE_HTML_TAG_NAME", "BASEFONT_HTML_TAG_NAME", "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", 
106                "FRAME_HTML_TAG_NAME", "HR_HTML_TAG_NAME", "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", 
107                "ISINDEX_HTML_TAG_NAME", "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", 
108                "HTML_TAG_NAME", "Char11", "ATTR_VALUE", "Char12", "HTML_COMMENT_END"
109        };
110        public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
111
112        /**
113         * @deprecated Use {@link #VOCABULARY} instead.
114         */
115        @Deprecated
116        public static final String[] tokenNames;
117        static {
118                tokenNames = new String[_SYMBOLIC_NAMES.length];
119                for (int i = 0; i < tokenNames.length; i++) {
120                        tokenNames[i] = VOCABULARY.getLiteralName(i);
121                        if (tokenNames[i] == null) {
122                                tokenNames[i] = VOCABULARY.getSymbolicName(i);
123                        }
124
125                        if (tokenNames[i] == null) {
126                                tokenNames[i] = "<INVALID>";
127                        }
128                }
129        }
130
131        @Override
132        @Deprecated
133        public String[] getTokenNames() {
134                return tokenNames;
135        }
136
137        @Override
138
139        public Vocabulary getVocabulary() {
140                return VOCABULARY;
141        }
142
143        @Override
144        public String getGrammarFileName() { return "JavadocParser.g4"; }
145
146        @Override
147        public String[] getRuleNames() { return ruleNames; }
148
149        @Override
150        public String getSerializedATN() { return _serializedATN; }
151
152        @Override
153        public ATN getATN() { return _ATN; }
154
155
156            boolean isNextJavadocTag() {
157                int token1 = _input.LA(2);
158                int token2 = _input.LA(3);
159                return isJavadocTag(token1)
160                    || (token1 == WS && isJavadocTag(token2));
161            }
162
163            boolean isJavadocTag(int type) {
164                switch(type) {
165                    case AUTHOR_LITERAL:
166                    case DEPRECATED_LITERAL:
167                    case EXCEPTION_LITERAL:
168                    case PARAM_LITERAL:
169                    case RETURN_LITERAL:
170                    case SEE_LITERAL:
171                    case SERIAL_LITERAL:
172                    case SERIAL_FIELD_LITERAL:
173                    case SERIAL_DATA_LITERAL:
174                    case SINCE_LITERAL:
175                    case THROWS_LITERAL:
176                    case VERSION_LITERAL:
177                    case CUSTOM_NAME:
178                        return true;
179                    default:
180                        return false;
181                }
182            }
183
184              boolean isSameTagNames(ParserRuleContext htmlTagOpen, ParserRuleContext htmlTagClose) {
185                    String openTag = htmlTagOpen.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
186                    String closeTag = htmlTagClose.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
187                    System.out.println(openTag + " - " + closeTag);
188                    return openTag.equals(closeTag);
189              }
190
191        public JavadocParser(TokenStream input) {
192                super(input);
193                _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
194        }
195        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()
1423                                                                         , "javadoc.missed.html.close", null);
1424                                }
1425                                break;
1426                        }
1427                }
1428                catch (RecognitionException re) {
1429                        _localctx.exception = re;
1430                        _errHandler.reportError(this, re);
1431                        _errHandler.recover(this, re);
1432                }
1433                finally {
1434                        exitRule();
1435                }
1436                return _localctx;
1437        }
1438
1439        public static class PTagOpenContext extends ParserRuleContext {
1440                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1441                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
1442                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1443                public List<AttributeContext> attribute() {
1444                        return getRuleContexts(AttributeContext.class);
1445                }
1446                public AttributeContext attribute(int i) {
1447                        return getRuleContext(AttributeContext.class,i);
1448                }
1449                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1450                public TerminalNode NEWLINE(int i) {
1451                        return getToken(JavadocParser.NEWLINE, i);
1452                }
1453                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1454                public TerminalNode LEADING_ASTERISK(int i) {
1455                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1456                }
1457                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1458                public TerminalNode WS(int i) {
1459                        return getToken(JavadocParser.WS, i);
1460                }
1461                public PTagOpenContext(ParserRuleContext parent, int invokingState) {
1462                        super(parent, invokingState);
1463                }
1464                @Override public int getRuleIndex() { return RULE_pTagOpen; }
1465                @Override
1466                public void enterRule(ParseTreeListener listener) {
1467                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagOpen(this);
1468                }
1469                @Override
1470                public void exitRule(ParseTreeListener listener) {
1471                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagOpen(this);
1472                }
1473                @Override
1474                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1475                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagOpen(this);
1476                        else return visitor.visitChildren(this);
1477                }
1478        }
1479
1480        public final PTagOpenContext pTagOpen() throws RecognitionException {
1481                PTagOpenContext _localctx = new PTagOpenContext(_ctx, getState());
1482                enterRule(_localctx, 12, RULE_pTagOpen);
1483                int _la;
1484                try {
1485                        enterOuterAlt(_localctx, 1);
1486                        {
1487                        setState(306);
1488                        match(OPEN);
1489                        setState(307);
1490                        match(P_HTML_TAG_NAME);
1491                        setState(314);
1492                        _errHandler.sync(this);
1493                        _la = _input.LA(1);
1494                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
1495                                {
1496                                setState(312);
1497                                switch (_input.LA(1)) {
1498                                case HTML_TAG_NAME:
1499                                        {
1500                                        setState(308);
1501                                        attribute();
1502                                        }
1503                                        break;
1504                                case NEWLINE:
1505                                        {
1506                                        setState(309);
1507                                        match(NEWLINE);
1508                                        }
1509                                        break;
1510                                case LEADING_ASTERISK:
1511                                        {
1512                                        setState(310);
1513                                        match(LEADING_ASTERISK);
1514                                        }
1515                                        break;
1516                                case WS:
1517                                        {
1518                                        setState(311);
1519                                        match(WS);
1520                                        }
1521                                        break;
1522                                default:
1523                                        throw new NoViableAltException(this);
1524                                }
1525                                }
1526                                setState(316);
1527                                _errHandler.sync(this);
1528                                _la = _input.LA(1);
1529                        }
1530                        setState(317);
1531                        match(CLOSE);
1532                        }
1533                }
1534                catch (RecognitionException re) {
1535                        _localctx.exception = re;
1536                        _errHandler.reportError(this, re);
1537                        _errHandler.recover(this, re);
1538                }
1539                finally {
1540                        exitRule();
1541                }
1542                return _localctx;
1543        }
1544
1545        public static class PTagCloseContext extends ParserRuleContext {
1546                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1547                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
1548                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
1549                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1550                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1551                public TerminalNode NEWLINE(int i) {
1552                        return getToken(JavadocParser.NEWLINE, i);
1553                }
1554                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1555                public TerminalNode LEADING_ASTERISK(int i) {
1556                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1557                }
1558                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1559                public TerminalNode WS(int i) {
1560                        return getToken(JavadocParser.WS, i);
1561                }
1562                public PTagCloseContext(ParserRuleContext parent, int invokingState) {
1563                        super(parent, invokingState);
1564                }
1565                @Override public int getRuleIndex() { return RULE_pTagClose; }
1566                @Override
1567                public void enterRule(ParseTreeListener listener) {
1568                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagClose(this);
1569                }
1570                @Override
1571                public void exitRule(ParseTreeListener listener) {
1572                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagClose(this);
1573                }
1574                @Override
1575                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1576                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagClose(this);
1577                        else return visitor.visitChildren(this);
1578                }
1579        }
1580
1581        public final PTagCloseContext pTagClose() throws RecognitionException {
1582                PTagCloseContext _localctx = new PTagCloseContext(_ctx, getState());
1583                enterRule(_localctx, 14, RULE_pTagClose);
1584                int _la;
1585                try {
1586                        enterOuterAlt(_localctx, 1);
1587                        {
1588                        setState(319);
1589                        match(OPEN);
1590                        setState(320);
1591                        match(SLASH);
1592                        setState(321);
1593                        match(P_HTML_TAG_NAME);
1594                        setState(325);
1595                        _errHandler.sync(this);
1596                        _la = _input.LA(1);
1597                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1598                                {
1599                                {
1600                                setState(322);
1601                                _la = _input.LA(1);
1602                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1603                                _errHandler.recoverInline(this);
1604                                } else {
1605                                        consume();
1606                                }
1607                                }
1608                                }
1609                                setState(327);
1610                                _errHandler.sync(this);
1611                                _la = _input.LA(1);
1612                        }
1613                        setState(328);
1614                        match(CLOSE);
1615                        }
1616                }
1617                catch (RecognitionException re) {
1618                        _localctx.exception = re;
1619                        _errHandler.reportError(this, re);
1620                        _errHandler.recover(this, re);
1621                }
1622                finally {
1623                        exitRule();
1624                }
1625                return _localctx;
1626        }
1627
1628        public static class ParagraphContext extends ParserRuleContext {
1629                public PTagOpenContext pTagOpen() {
1630                        return getRuleContext(PTagOpenContext.class,0);
1631                }
1632                public PTagCloseContext pTagClose() {
1633                        return getRuleContext(PTagCloseContext.class,0);
1634                }
1635                public List<HtmlTagContext> htmlTag() {
1636                        return getRuleContexts(HtmlTagContext.class);
1637                }
1638                public HtmlTagContext htmlTag(int i) {
1639                        return getRuleContext(HtmlTagContext.class,i);
1640                }
1641                public List<SingletonTagContext> singletonTag() {
1642                        return getRuleContexts(SingletonTagContext.class);
1643                }
1644                public SingletonTagContext singletonTag(int i) {
1645                        return getRuleContext(SingletonTagContext.class,i);
1646                }
1647                public List<LiContext> li() {
1648                        return getRuleContexts(LiContext.class);
1649                }
1650                public LiContext li(int i) {
1651                        return getRuleContext(LiContext.class,i);
1652                }
1653                public List<TrContext> tr() {
1654                        return getRuleContexts(TrContext.class);
1655                }
1656                public TrContext tr(int i) {
1657                        return getRuleContext(TrContext.class,i);
1658                }
1659                public List<TdContext> td() {
1660                        return getRuleContexts(TdContext.class);
1661                }
1662                public TdContext td(int i) {
1663                        return getRuleContext(TdContext.class,i);
1664                }
1665                public List<ThContext> th() {
1666                        return getRuleContexts(ThContext.class);
1667                }
1668                public ThContext th(int i) {
1669                        return getRuleContext(ThContext.class,i);
1670                }
1671                public List<BodyContext> body() {
1672                        return getRuleContexts(BodyContext.class);
1673                }
1674                public BodyContext body(int i) {
1675                        return getRuleContext(BodyContext.class,i);
1676                }
1677                public List<ColgroupContext> colgroup() {
1678                        return getRuleContexts(ColgroupContext.class);
1679                }
1680                public ColgroupContext colgroup(int i) {
1681                        return getRuleContext(ColgroupContext.class,i);
1682                }
1683                public List<DdContext> dd() {
1684                        return getRuleContexts(DdContext.class);
1685                }
1686                public DdContext dd(int i) {
1687                        return getRuleContext(DdContext.class,i);
1688                }
1689                public List<DtContext> dt() {
1690                        return getRuleContexts(DtContext.class);
1691                }
1692                public DtContext dt(int i) {
1693                        return getRuleContext(DtContext.class,i);
1694                }
1695                public List<HeadContext> head() {
1696                        return getRuleContexts(HeadContext.class);
1697                }
1698                public HeadContext head(int i) {
1699                        return getRuleContext(HeadContext.class,i);
1700                }
1701                public List<HtmlContext> html() {
1702                        return getRuleContexts(HtmlContext.class);
1703                }
1704                public HtmlContext html(int i) {
1705                        return getRuleContext(HtmlContext.class,i);
1706                }
1707                public List<OptionContext> option() {
1708                        return getRuleContexts(OptionContext.class);
1709                }
1710                public OptionContext option(int i) {
1711                        return getRuleContext(OptionContext.class,i);
1712                }
1713                public List<TbodyContext> tbody() {
1714                        return getRuleContexts(TbodyContext.class);
1715                }
1716                public TbodyContext tbody(int i) {
1717                        return getRuleContext(TbodyContext.class,i);
1718                }
1719                public List<TheadContext> thead() {
1720                        return getRuleContexts(TheadContext.class);
1721                }
1722                public TheadContext thead(int i) {
1723                        return getRuleContext(TheadContext.class,i);
1724                }
1725                public List<TfootContext> tfoot() {
1726                        return getRuleContexts(TfootContext.class);
1727                }
1728                public TfootContext tfoot(int i) {
1729                        return getRuleContext(TfootContext.class,i);
1730                }
1731                public List<LiTagOpenContext> liTagOpen() {
1732                        return getRuleContexts(LiTagOpenContext.class);
1733                }
1734                public LiTagOpenContext liTagOpen(int i) {
1735                        return getRuleContext(LiTagOpenContext.class,i);
1736                }
1737                public List<TrTagOpenContext> trTagOpen() {
1738                        return getRuleContexts(TrTagOpenContext.class);
1739                }
1740                public TrTagOpenContext trTagOpen(int i) {
1741                        return getRuleContext(TrTagOpenContext.class,i);
1742                }
1743                public List<TdTagOpenContext> tdTagOpen() {
1744                        return getRuleContexts(TdTagOpenContext.class);
1745                }
1746                public TdTagOpenContext tdTagOpen(int i) {
1747                        return getRuleContext(TdTagOpenContext.class,i);
1748                }
1749                public List<ThTagOpenContext> thTagOpen() {
1750                        return getRuleContexts(ThTagOpenContext.class);
1751                }
1752                public ThTagOpenContext thTagOpen(int i) {
1753                        return getRuleContext(ThTagOpenContext.class,i);
1754                }
1755                public List<BodyTagOpenContext> bodyTagOpen() {
1756                        return getRuleContexts(BodyTagOpenContext.class);
1757                }
1758                public BodyTagOpenContext bodyTagOpen(int i) {
1759                        return getRuleContext(BodyTagOpenContext.class,i);
1760                }
1761                public List<ColgroupTagOpenContext> colgroupTagOpen() {
1762                        return getRuleContexts(ColgroupTagOpenContext.class);
1763                }
1764                public ColgroupTagOpenContext colgroupTagOpen(int i) {
1765                        return getRuleContext(ColgroupTagOpenContext.class,i);
1766                }
1767                public List<DdTagOpenContext> ddTagOpen() {
1768                        return getRuleContexts(DdTagOpenContext.class);
1769                }
1770                public DdTagOpenContext ddTagOpen(int i) {
1771                        return getRuleContext(DdTagOpenContext.class,i);
1772                }
1773                public List<DtTagOpenContext> dtTagOpen() {
1774                        return getRuleContexts(DtTagOpenContext.class);
1775                }
1776                public DtTagOpenContext dtTagOpen(int i) {
1777                        return getRuleContext(DtTagOpenContext.class,i);
1778                }
1779                public List<HeadTagOpenContext> headTagOpen() {
1780                        return getRuleContexts(HeadTagOpenContext.class);
1781                }
1782                public HeadTagOpenContext headTagOpen(int i) {
1783                        return getRuleContext(HeadTagOpenContext.class,i);
1784                }
1785                public List<HtmlTagOpenContext> htmlTagOpen() {
1786                        return getRuleContexts(HtmlTagOpenContext.class);
1787                }
1788                public HtmlTagOpenContext htmlTagOpen(int i) {
1789                        return getRuleContext(HtmlTagOpenContext.class,i);
1790                }
1791                public List<OptionTagOpenContext> optionTagOpen() {
1792                        return getRuleContexts(OptionTagOpenContext.class);
1793                }
1794                public OptionTagOpenContext optionTagOpen(int i) {
1795                        return getRuleContext(OptionTagOpenContext.class,i);
1796                }
1797                public List<TbodyTagOpenContext> tbodyTagOpen() {
1798                        return getRuleContexts(TbodyTagOpenContext.class);
1799                }
1800                public TbodyTagOpenContext tbodyTagOpen(int i) {
1801                        return getRuleContext(TbodyTagOpenContext.class,i);
1802                }
1803                public List<TheadTagOpenContext> theadTagOpen() {
1804                        return getRuleContexts(TheadTagOpenContext.class);
1805                }
1806                public TheadTagOpenContext theadTagOpen(int i) {
1807                        return getRuleContext(TheadTagOpenContext.class,i);
1808                }
1809                public List<TfootTagOpenContext> tfootTagOpen() {
1810                        return getRuleContexts(TfootTagOpenContext.class);
1811                }
1812                public TfootTagOpenContext tfootTagOpen(int i) {
1813                        return getRuleContext(TfootTagOpenContext.class,i);
1814                }
1815                public List<HtmlCommentContext> htmlComment() {
1816                        return getRuleContexts(HtmlCommentContext.class);
1817                }
1818                public HtmlCommentContext htmlComment(int i) {
1819                        return getRuleContext(HtmlCommentContext.class,i);
1820                }
1821                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
1822                public TerminalNode CDATA(int i) {
1823                        return getToken(JavadocParser.CDATA, i);
1824                }
1825                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1826                public TerminalNode NEWLINE(int i) {
1827                        return getToken(JavadocParser.NEWLINE, i);
1828                }
1829                public List<TextContext> text() {
1830                        return getRuleContexts(TextContext.class);
1831                }
1832                public TextContext text(int i) {
1833                        return getRuleContext(TextContext.class,i);
1834                }
1835                public List<JavadocInlineTagContext> javadocInlineTag() {
1836                        return getRuleContexts(JavadocInlineTagContext.class);
1837                }
1838                public JavadocInlineTagContext javadocInlineTag(int i) {
1839                        return getRuleContext(JavadocInlineTagContext.class,i);
1840                }
1841                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1842                public TerminalNode LEADING_ASTERISK(int i) {
1843                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1844                }
1845                public ParagraphContext(ParserRuleContext parent, int invokingState) {
1846                        super(parent, invokingState);
1847                }
1848                @Override public int getRuleIndex() { return RULE_paragraph; }
1849                @Override
1850                public void enterRule(ParseTreeListener listener) {
1851                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParagraph(this);
1852                }
1853                @Override
1854                public void exitRule(ParseTreeListener listener) {
1855                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParagraph(this);
1856                }
1857                @Override
1858                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1859                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParagraph(this);
1860                        else return visitor.visitChildren(this);
1861                }
1862        }
1863
1864        public final ParagraphContext paragraph() throws RecognitionException {
1865                ParagraphContext _localctx = new ParagraphContext(_ctx, getState());
1866                enterRule(_localctx, 16, RULE_paragraph);
1867                try {
1868                        int _alt;
1869                        enterOuterAlt(_localctx, 1);
1870                        {
1871                        setState(330);
1872                        pTagOpen();
1873                        setState(370);
1874                        _errHandler.sync(this);
1875                        _alt = getInterpreter().adaptivePredict(_input,21,_ctx);
1876                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1877                                if ( _alt==1 ) {
1878                                        {
1879                                        setState(368);
1880                                        _errHandler.sync(this);
1881                                        switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
1882                                        case 1:
1883                                                {
1884                                                setState(331);
1885                                                htmlTag();
1886                                                }
1887                                                break;
1888                                        case 2:
1889                                                {
1890                                                setState(332);
1891                                                singletonTag();
1892                                                }
1893                                                break;
1894                                        case 3:
1895                                                {
1896                                                setState(333);
1897                                                li();
1898                                                }
1899                                                break;
1900                                        case 4:
1901                                                {
1902                                                setState(334);
1903                                                tr();
1904                                                }
1905                                                break;
1906                                        case 5:
1907                                                {
1908                                                setState(335);
1909                                                td();
1910                                                }
1911                                                break;
1912                                        case 6:
1913                                                {
1914                                                setState(336);
1915                                                th();
1916                                                }
1917                                                break;
1918                                        case 7:
1919                                                {
1920                                                setState(337);
1921                                                body();
1922                                                }
1923                                                break;
1924                                        case 8:
1925                                                {
1926                                                setState(338);
1927                                                colgroup();
1928                                                }
1929                                                break;
1930                                        case 9:
1931                                                {
1932                                                setState(339);
1933                                                dd();
1934                                                }
1935                                                break;
1936                                        case 10:
1937                                                {
1938                                                setState(340);
1939                                                dt();
1940                                                }
1941                                                break;
1942                                        case 11:
1943                                                {
1944                                                setState(341);
1945                                                head();
1946                                                }
1947                                                break;
1948                                        case 12:
1949                                                {
1950                                                setState(342);
1951                                                html();
1952                                                }
1953                                                break;
1954                                        case 13:
1955                                                {
1956                                                setState(343);
1957                                                option();
1958                                                }
1959                                                break;
1960                                        case 14:
1961                                                {
1962                                                setState(344);
1963                                                tbody();
1964                                                }
1965                                                break;
1966                                        case 15:
1967                                                {
1968                                                setState(345);
1969                                                thead();
1970                                                }
1971                                                break;
1972                                        case 16:
1973                                                {
1974                                                setState(346);
1975                                                tfoot();
1976                                                }
1977                                                break;
1978                                        case 17:
1979                                                {
1980                                                setState(347);
1981                                                liTagOpen();
1982                                                }
1983                                                break;
1984                                        case 18:
1985                                                {
1986                                                setState(348);
1987                                                trTagOpen();
1988                                                }
1989                                                break;
1990                                        case 19:
1991                                                {
1992                                                setState(349);
1993                                                tdTagOpen();
1994                                                }
1995                                                break;
1996                                        case 20:
1997                                                {
1998                                                setState(350);
1999                                                thTagOpen();
2000                                                }
2001                                                break;
2002                                        case 21:
2003                                                {
2004                                                setState(351);
2005                                                bodyTagOpen();
2006                                                }
2007                                                break;
2008                                        case 22:
2009                                                {
2010                                                setState(352);
2011                                                colgroupTagOpen();
2012                                                }
2013                                                break;
2014                                        case 23:
2015                                                {
2016                                                setState(353);
2017                                                ddTagOpen();
2018                                                }
2019                                                break;
2020                                        case 24:
2021                                                {
2022                                                setState(354);
2023                                                dtTagOpen();
2024                                                }
2025                                                break;
2026                                        case 25:
2027                                                {
2028                                                setState(355);
2029                                                headTagOpen();
2030                                                }
2031                                                break;
2032                                        case 26:
2033                                                {
2034                                                setState(356);
2035                                                htmlTagOpen();
2036                                                }
2037                                                break;
2038                                        case 27:
2039                                                {
2040                                                setState(357);
2041                                                optionTagOpen();
2042                                                }
2043                                                break;
2044                                        case 28:
2045                                                {
2046                                                setState(358);
2047                                                tbodyTagOpen();
2048                                                }
2049                                                break;
2050                                        case 29:
2051                                                {
2052                                                setState(359);
2053                                                theadTagOpen();
2054                                                }
2055                                                break;
2056                                        case 30:
2057                                                {
2058                                                setState(360);
2059                                                tfootTagOpen();
2060                                                }
2061                                                break;
2062                                        case 31:
2063                                                {
2064                                                {
2065                                                setState(361);
2066                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
2067                                                setState(362);
2068                                                match(LEADING_ASTERISK);
2069                                                }
2070                                                }
2071                                                break;
2072                                        case 32:
2073                                                {
2074                                                setState(363);
2075                                                htmlComment();
2076                                                }
2077                                                break;
2078                                        case 33:
2079                                                {
2080                                                setState(364);
2081                                                match(CDATA);
2082                                                }
2083                                                break;
2084                                        case 34:
2085                                                {
2086                                                setState(365);
2087                                                match(NEWLINE);
2088                                                }
2089                                                break;
2090                                        case 35:
2091                                                {
2092                                                setState(366);
2093                                                text();
2094                                                }
2095                                                break;
2096                                        case 36:
2097                                                {
2098                                                setState(367);
2099                                                javadocInlineTag();
2100                                                }
2101                                                break;
2102                                        }
2103                                        } 
2104                                }
2105                                setState(372);
2106                                _errHandler.sync(this);
2107                                _alt = getInterpreter().adaptivePredict(_input,21,_ctx);
2108                        }
2109                        setState(373);
2110                        pTagClose();
2111                        }
2112                }
2113                catch (RecognitionException re) {
2114                        _localctx.exception = re;
2115                        _errHandler.reportError(this, re);
2116                        _errHandler.recover(this, re);
2117                }
2118                finally {
2119                        exitRule();
2120                }
2121                return _localctx;
2122        }
2123
2124        public static class LiTagOpenContext extends ParserRuleContext {
2125                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2126                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
2127                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2128                public List<AttributeContext> attribute() {
2129                        return getRuleContexts(AttributeContext.class);
2130                }
2131                public AttributeContext attribute(int i) {
2132                        return getRuleContext(AttributeContext.class,i);
2133                }
2134                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2135                public TerminalNode NEWLINE(int i) {
2136                        return getToken(JavadocParser.NEWLINE, i);
2137                }
2138                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2139                public TerminalNode LEADING_ASTERISK(int i) {
2140                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2141                }
2142                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2143                public TerminalNode WS(int i) {
2144                        return getToken(JavadocParser.WS, i);
2145                }
2146                public LiTagOpenContext(ParserRuleContext parent, int invokingState) {
2147                        super(parent, invokingState);
2148                }
2149                @Override public int getRuleIndex() { return RULE_liTagOpen; }
2150                @Override
2151                public void enterRule(ParseTreeListener listener) {
2152                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagOpen(this);
2153                }
2154                @Override
2155                public void exitRule(ParseTreeListener listener) {
2156                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagOpen(this);
2157                }
2158                @Override
2159                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2160                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagOpen(this);
2161                        else return visitor.visitChildren(this);
2162                }
2163        }
2164
2165        public final LiTagOpenContext liTagOpen() throws RecognitionException {
2166                LiTagOpenContext _localctx = new LiTagOpenContext(_ctx, getState());
2167                enterRule(_localctx, 18, RULE_liTagOpen);
2168                int _la;
2169                try {
2170                        enterOuterAlt(_localctx, 1);
2171                        {
2172                        setState(375);
2173                        match(OPEN);
2174                        setState(376);
2175                        match(LI_HTML_TAG_NAME);
2176                        setState(383);
2177                        _errHandler.sync(this);
2178                        _la = _input.LA(1);
2179                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2180                                {
2181                                setState(381);
2182                                switch (_input.LA(1)) {
2183                                case HTML_TAG_NAME:
2184                                        {
2185                                        setState(377);
2186                                        attribute();
2187                                        }
2188                                        break;
2189                                case NEWLINE:
2190                                        {
2191                                        setState(378);
2192                                        match(NEWLINE);
2193                                        }
2194                                        break;
2195                                case LEADING_ASTERISK:
2196                                        {
2197                                        setState(379);
2198                                        match(LEADING_ASTERISK);
2199                                        }
2200                                        break;
2201                                case WS:
2202                                        {
2203                                        setState(380);
2204                                        match(WS);
2205                                        }
2206                                        break;
2207                                default:
2208                                        throw new NoViableAltException(this);
2209                                }
2210                                }
2211                                setState(385);
2212                                _errHandler.sync(this);
2213                                _la = _input.LA(1);
2214                        }
2215                        setState(386);
2216                        match(CLOSE);
2217                        }
2218                }
2219                catch (RecognitionException re) {
2220                        _localctx.exception = re;
2221                        _errHandler.reportError(this, re);
2222                        _errHandler.recover(this, re);
2223                }
2224                finally {
2225                        exitRule();
2226                }
2227                return _localctx;
2228        }
2229
2230        public static class LiTagCloseContext extends ParserRuleContext {
2231                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2232                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
2233                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
2234                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2235                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2236                public TerminalNode NEWLINE(int i) {
2237                        return getToken(JavadocParser.NEWLINE, i);
2238                }
2239                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2240                public TerminalNode LEADING_ASTERISK(int i) {
2241                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2242                }
2243                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2244                public TerminalNode WS(int i) {
2245                        return getToken(JavadocParser.WS, i);
2246                }
2247                public LiTagCloseContext(ParserRuleContext parent, int invokingState) {
2248                        super(parent, invokingState);
2249                }
2250                @Override public int getRuleIndex() { return RULE_liTagClose; }
2251                @Override
2252                public void enterRule(ParseTreeListener listener) {
2253                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagClose(this);
2254                }
2255                @Override
2256                public void exitRule(ParseTreeListener listener) {
2257                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagClose(this);
2258                }
2259                @Override
2260                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2261                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagClose(this);
2262                        else return visitor.visitChildren(this);
2263                }
2264        }
2265
2266        public final LiTagCloseContext liTagClose() throws RecognitionException {
2267                LiTagCloseContext _localctx = new LiTagCloseContext(_ctx, getState());
2268                enterRule(_localctx, 20, RULE_liTagClose);
2269                int _la;
2270                try {
2271                        enterOuterAlt(_localctx, 1);
2272                        {
2273                        setState(388);
2274                        match(OPEN);
2275                        setState(389);
2276                        match(SLASH);
2277                        setState(390);
2278                        match(LI_HTML_TAG_NAME);
2279                        setState(394);
2280                        _errHandler.sync(this);
2281                        _la = _input.LA(1);
2282                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
2283                                {
2284                                {
2285                                setState(391);
2286                                _la = _input.LA(1);
2287                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
2288                                _errHandler.recoverInline(this);
2289                                } else {
2290                                        consume();
2291                                }
2292                                }
2293                                }
2294                                setState(396);
2295                                _errHandler.sync(this);
2296                                _la = _input.LA(1);
2297                        }
2298                        setState(397);
2299                        match(CLOSE);
2300                        }
2301                }
2302                catch (RecognitionException re) {
2303                        _localctx.exception = re;
2304                        _errHandler.reportError(this, re);
2305                        _errHandler.recover(this, re);
2306                }
2307                finally {
2308                        exitRule();
2309                }
2310                return _localctx;
2311        }
2312
2313        public static class LiContext extends ParserRuleContext {
2314                public LiTagOpenContext liTagOpen() {
2315                        return getRuleContext(LiTagOpenContext.class,0);
2316                }
2317                public LiTagCloseContext liTagClose() {
2318                        return getRuleContext(LiTagCloseContext.class,0);
2319                }
2320                public List<HtmlTagContext> htmlTag() {
2321                        return getRuleContexts(HtmlTagContext.class);
2322                }
2323                public HtmlTagContext htmlTag(int i) {
2324                        return getRuleContext(HtmlTagContext.class,i);
2325                }
2326                public List<SingletonTagContext> singletonTag() {
2327                        return getRuleContexts(SingletonTagContext.class);
2328                }
2329                public SingletonTagContext singletonTag(int i) {
2330                        return getRuleContext(SingletonTagContext.class,i);
2331                }
2332                public List<ParagraphContext> paragraph() {
2333                        return getRuleContexts(ParagraphContext.class);
2334                }
2335                public ParagraphContext paragraph(int i) {
2336                        return getRuleContext(ParagraphContext.class,i);
2337                }
2338                public List<TrContext> tr() {
2339                        return getRuleContexts(TrContext.class);
2340                }
2341                public TrContext tr(int i) {
2342                        return getRuleContext(TrContext.class,i);
2343                }
2344                public List<TdContext> td() {
2345                        return getRuleContexts(TdContext.class);
2346                }
2347                public TdContext td(int i) {
2348                        return getRuleContext(TdContext.class,i);
2349                }
2350                public List<ThContext> th() {
2351                        return getRuleContexts(ThContext.class);
2352                }
2353                public ThContext th(int i) {
2354                        return getRuleContext(ThContext.class,i);
2355                }
2356                public List<BodyContext> body() {
2357                        return getRuleContexts(BodyContext.class);
2358                }
2359                public BodyContext body(int i) {
2360                        return getRuleContext(BodyContext.class,i);
2361                }
2362                public List<ColgroupContext> colgroup() {
2363                        return getRuleContexts(ColgroupContext.class);
2364                }
2365                public ColgroupContext colgroup(int i) {
2366                        return getRuleContext(ColgroupContext.class,i);
2367                }
2368                public List<DdContext> dd() {
2369                        return getRuleContexts(DdContext.class);
2370                }
2371                public DdContext dd(int i) {
2372                        return getRuleContext(DdContext.class,i);
2373                }
2374                public List<DtContext> dt() {
2375                        return getRuleContexts(DtContext.class);
2376                }
2377                public DtContext dt(int i) {
2378                        return getRuleContext(DtContext.class,i);
2379                }
2380                public List<HeadContext> head() {
2381                        return getRuleContexts(HeadContext.class);
2382                }
2383                public HeadContext head(int i) {
2384                        return getRuleContext(HeadContext.class,i);
2385                }
2386                public List<HtmlContext> html() {
2387                        return getRuleContexts(HtmlContext.class);
2388                }
2389                public HtmlContext html(int i) {
2390                        return getRuleContext(HtmlContext.class,i);
2391                }
2392                public List<OptionContext> option() {
2393                        return getRuleContexts(OptionContext.class);
2394                }
2395                public OptionContext option(int i) {
2396                        return getRuleContext(OptionContext.class,i);
2397                }
2398                public List<TbodyContext> tbody() {
2399                        return getRuleContexts(TbodyContext.class);
2400                }
2401                public TbodyContext tbody(int i) {
2402                        return getRuleContext(TbodyContext.class,i);
2403                }
2404                public List<TheadContext> thead() {
2405                        return getRuleContexts(TheadContext.class);
2406                }
2407                public TheadContext thead(int i) {
2408                        return getRuleContext(TheadContext.class,i);
2409                }
2410                public List<TfootContext> tfoot() {
2411                        return getRuleContexts(TfootContext.class);
2412                }
2413                public TfootContext tfoot(int i) {
2414                        return getRuleContext(TfootContext.class,i);
2415                }
2416                public List<PTagOpenContext> pTagOpen() {
2417                        return getRuleContexts(PTagOpenContext.class);
2418                }
2419                public PTagOpenContext pTagOpen(int i) {
2420                        return getRuleContext(PTagOpenContext.class,i);
2421                }
2422                public List<TrTagOpenContext> trTagOpen() {
2423                        return getRuleContexts(TrTagOpenContext.class);
2424                }
2425                public TrTagOpenContext trTagOpen(int i) {
2426                        return getRuleContext(TrTagOpenContext.class,i);
2427                }
2428                public List<TdTagOpenContext> tdTagOpen() {
2429                        return getRuleContexts(TdTagOpenContext.class);
2430                }
2431                public TdTagOpenContext tdTagOpen(int i) {
2432                        return getRuleContext(TdTagOpenContext.class,i);
2433                }
2434                public List<ThTagOpenContext> thTagOpen() {
2435                        return getRuleContexts(ThTagOpenContext.class);
2436                }
2437                public ThTagOpenContext thTagOpen(int i) {
2438                        return getRuleContext(ThTagOpenContext.class,i);
2439                }
2440                public List<BodyTagOpenContext> bodyTagOpen() {
2441                        return getRuleContexts(BodyTagOpenContext.class);
2442                }
2443                public BodyTagOpenContext bodyTagOpen(int i) {
2444                        return getRuleContext(BodyTagOpenContext.class,i);
2445                }
2446                public List<ColgroupTagOpenContext> colgroupTagOpen() {
2447                        return getRuleContexts(ColgroupTagOpenContext.class);
2448                }
2449                public ColgroupTagOpenContext colgroupTagOpen(int i) {
2450                        return getRuleContext(ColgroupTagOpenContext.class,i);
2451                }
2452                public List<DdTagOpenContext> ddTagOpen() {
2453                        return getRuleContexts(DdTagOpenContext.class);
2454                }
2455                public DdTagOpenContext ddTagOpen(int i) {
2456                        return getRuleContext(DdTagOpenContext.class,i);
2457                }
2458                public List<DtTagOpenContext> dtTagOpen() {
2459                        return getRuleContexts(DtTagOpenContext.class);
2460                }
2461                public DtTagOpenContext dtTagOpen(int i) {
2462                        return getRuleContext(DtTagOpenContext.class,i);
2463                }
2464                public List<HeadTagOpenContext> headTagOpen() {
2465                        return getRuleContexts(HeadTagOpenContext.class);
2466                }
2467                public HeadTagOpenContext headTagOpen(int i) {
2468                        return getRuleContext(HeadTagOpenContext.class,i);
2469                }
2470                public List<HtmlTagOpenContext> htmlTagOpen() {
2471                        return getRuleContexts(HtmlTagOpenContext.class);
2472                }
2473                public HtmlTagOpenContext htmlTagOpen(int i) {
2474                        return getRuleContext(HtmlTagOpenContext.class,i);
2475                }
2476                public List<OptionTagOpenContext> optionTagOpen() {
2477                        return getRuleContexts(OptionTagOpenContext.class);
2478                }
2479                public OptionTagOpenContext optionTagOpen(int i) {
2480                        return getRuleContext(OptionTagOpenContext.class,i);
2481                }
2482                public List<TbodyTagOpenContext> tbodyTagOpen() {
2483                        return getRuleContexts(TbodyTagOpenContext.class);
2484                }
2485                public TbodyTagOpenContext tbodyTagOpen(int i) {
2486                        return getRuleContext(TbodyTagOpenContext.class,i);
2487                }
2488                public List<TheadTagOpenContext> theadTagOpen() {
2489                        return getRuleContexts(TheadTagOpenContext.class);
2490                }
2491                public TheadTagOpenContext theadTagOpen(int i) {
2492                        return getRuleContext(TheadTagOpenContext.class,i);
2493                }
2494                public List<TfootTagOpenContext> tfootTagOpen() {
2495                        return getRuleContexts(TfootTagOpenContext.class);
2496                }
2497                public TfootTagOpenContext tfootTagOpen(int i) {
2498                        return getRuleContext(TfootTagOpenContext.class,i);
2499                }
2500                public List<HtmlCommentContext> htmlComment() {
2501                        return getRuleContexts(HtmlCommentContext.class);
2502                }
2503                public HtmlCommentContext htmlComment(int i) {
2504                        return getRuleContext(HtmlCommentContext.class,i);
2505                }
2506                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
2507                public TerminalNode CDATA(int i) {
2508                        return getToken(JavadocParser.CDATA, i);
2509                }
2510                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2511                public TerminalNode NEWLINE(int i) {
2512                        return getToken(JavadocParser.NEWLINE, i);
2513                }
2514                public List<TextContext> text() {
2515                        return getRuleContexts(TextContext.class);
2516                }
2517                public TextContext text(int i) {
2518                        return getRuleContext(TextContext.class,i);
2519                }
2520                public List<JavadocInlineTagContext> javadocInlineTag() {
2521                        return getRuleContexts(JavadocInlineTagContext.class);
2522                }
2523                public JavadocInlineTagContext javadocInlineTag(int i) {
2524                        return getRuleContext(JavadocInlineTagContext.class,i);
2525                }
2526                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2527                public TerminalNode LEADING_ASTERISK(int i) {
2528                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2529                }
2530                public LiContext(ParserRuleContext parent, int invokingState) {
2531                        super(parent, invokingState);
2532                }
2533                @Override public int getRuleIndex() { return RULE_li; }
2534                @Override
2535                public void enterRule(ParseTreeListener listener) {
2536                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLi(this);
2537                }
2538                @Override
2539                public void exitRule(ParseTreeListener listener) {
2540                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLi(this);
2541                }
2542                @Override
2543                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2544                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLi(this);
2545                        else return visitor.visitChildren(this);
2546                }
2547        }
2548
2549        public final LiContext li() throws RecognitionException {
2550                LiContext _localctx = new LiContext(_ctx, getState());
2551                enterRule(_localctx, 22, RULE_li);
2552                try {
2553                        int _alt;
2554                        enterOuterAlt(_localctx, 1);
2555                        {
2556                        setState(399);
2557                        liTagOpen();
2558                        setState(439);
2559                        _errHandler.sync(this);
2560                        _alt = getInterpreter().adaptivePredict(_input,26,_ctx);
2561                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
2562                                if ( _alt==1 ) {
2563                                        {
2564                                        setState(437);
2565                                        _errHandler.sync(this);
2566                                        switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
2567                                        case 1:
2568                                                {
2569                                                setState(400);
2570                                                htmlTag();
2571                                                }
2572                                                break;
2573                                        case 2:
2574                                                {
2575                                                setState(401);
2576                                                singletonTag();
2577                                                }
2578                                                break;
2579                                        case 3:
2580                                                {
2581                                                setState(402);
2582                                                paragraph();
2583                                                }
2584                                                break;
2585                                        case 4:
2586                                                {
2587                                                setState(403);
2588                                                tr();
2589                                                }
2590                                                break;
2591                                        case 5:
2592                                                {
2593                                                setState(404);
2594                                                td();
2595                                                }
2596                                                break;
2597                                        case 6:
2598                                                {
2599                                                setState(405);
2600                                                th();
2601                                                }
2602                                                break;
2603                                        case 7:
2604                                                {
2605                                                setState(406);
2606                                                body();
2607                                                }
2608                                                break;
2609                                        case 8:
2610                                                {
2611                                                setState(407);
2612                                                colgroup();
2613                                                }
2614                                                break;
2615                                        case 9:
2616                                                {
2617                                                setState(408);
2618                                                dd();
2619                                                }
2620                                                break;
2621                                        case 10:
2622                                                {
2623                                                setState(409);
2624                                                dt();
2625                                                }
2626                                                break;
2627                                        case 11:
2628                                                {
2629                                                setState(410);
2630                                                head();
2631                                                }
2632                                                break;
2633                                        case 12:
2634                                                {
2635                                                setState(411);
2636                                                html();
2637                                                }
2638                                                break;
2639                                        case 13:
2640                                                {
2641                                                setState(412);
2642                                                option();
2643                                                }
2644                                                break;
2645                                        case 14:
2646                                                {
2647                                                setState(413);
2648                                                tbody();
2649                                                }
2650                                                break;
2651                                        case 15:
2652                                                {
2653                                                setState(414);
2654                                                thead();
2655                                                }
2656                                                break;
2657                                        case 16:
2658                                                {
2659                                                setState(415);
2660                                                tfoot();
2661                                                }
2662                                                break;
2663                                        case 17:
2664                                                {
2665                                                setState(416);
2666                                                pTagOpen();
2667                                                }
2668                                                break;
2669                                        case 18:
2670                                                {
2671                                                setState(417);
2672                                                trTagOpen();
2673                                                }
2674                                                break;
2675                                        case 19:
2676                                                {
2677                                                setState(418);
2678                                                tdTagOpen();
2679                                                }
2680                                                break;
2681                                        case 20:
2682                                                {
2683                                                setState(419);
2684                                                thTagOpen();
2685                                                }
2686                                                break;
2687                                        case 21:
2688                                                {
2689                                                setState(420);
2690                                                bodyTagOpen();
2691                                                }
2692                                                break;
2693                                        case 22:
2694                                                {
2695                                                setState(421);
2696                                                colgroupTagOpen();
2697                                                }
2698                                                break;
2699                                        case 23:
2700                                                {
2701                                                setState(422);
2702                                                ddTagOpen();
2703                                                }
2704                                                break;
2705                                        case 24:
2706                                                {
2707                                                setState(423);
2708                                                dtTagOpen();
2709                                                }
2710                                                break;
2711                                        case 25:
2712                                                {
2713                                                setState(424);
2714                                                headTagOpen();
2715                                                }
2716                                                break;
2717                                        case 26:
2718                                                {
2719                                                setState(425);
2720                                                htmlTagOpen();
2721                                                }
2722                                                break;
2723                                        case 27:
2724                                                {
2725                                                setState(426);
2726                                                optionTagOpen();
2727                                                }
2728                                                break;
2729                                        case 28:
2730                                                {
2731                                                setState(427);
2732                                                tbodyTagOpen();
2733                                                }
2734                                                break;
2735                                        case 29:
2736                                                {
2737                                                setState(428);
2738                                                theadTagOpen();
2739                                                }
2740                                                break;
2741                                        case 30:
2742                                                {
2743                                                setState(429);
2744                                                tfootTagOpen();
2745                                                }
2746                                                break;
2747                                        case 31:
2748                                                {
2749                                                {
2750                                                setState(430);
2751                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
2752                                                setState(431);
2753                                                match(LEADING_ASTERISK);
2754                                                }
2755                                                }
2756                                                break;
2757                                        case 32:
2758                                                {
2759                                                setState(432);
2760                                                htmlComment();
2761                                                }
2762                                                break;
2763                                        case 33:
2764                                                {
2765                                                setState(433);
2766                                                match(CDATA);
2767                                                }
2768                                                break;
2769                                        case 34:
2770                                                {
2771                                                setState(434);
2772                                                match(NEWLINE);
2773                                                }
2774                                                break;
2775                                        case 35:
2776                                                {
2777                                                setState(435);
2778                                                text();
2779                                                }
2780                                                break;
2781                                        case 36:
2782                                                {
2783                                                setState(436);
2784                                                javadocInlineTag();
2785                                                }
2786                                                break;
2787                                        }
2788                                        } 
2789                                }
2790                                setState(441);
2791                                _errHandler.sync(this);
2792                                _alt = getInterpreter().adaptivePredict(_input,26,_ctx);
2793                        }
2794                        setState(442);
2795                        liTagClose();
2796                        }
2797                }
2798                catch (RecognitionException re) {
2799                        _localctx.exception = re;
2800                        _errHandler.reportError(this, re);
2801                        _errHandler.recover(this, re);
2802                }
2803                finally {
2804                        exitRule();
2805                }
2806                return _localctx;
2807        }
2808
2809        public static class TrTagOpenContext extends ParserRuleContext {
2810                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2811                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
2812                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2813                public List<AttributeContext> attribute() {
2814                        return getRuleContexts(AttributeContext.class);
2815                }
2816                public AttributeContext attribute(int i) {
2817                        return getRuleContext(AttributeContext.class,i);
2818                }
2819                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2820                public TerminalNode NEWLINE(int i) {
2821                        return getToken(JavadocParser.NEWLINE, i);
2822                }
2823                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2824                public TerminalNode LEADING_ASTERISK(int i) {
2825                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2826                }
2827                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2828                public TerminalNode WS(int i) {
2829                        return getToken(JavadocParser.WS, i);
2830                }
2831                public TrTagOpenContext(ParserRuleContext parent, int invokingState) {
2832                        super(parent, invokingState);
2833                }
2834                @Override public int getRuleIndex() { return RULE_trTagOpen; }
2835                @Override
2836                public void enterRule(ParseTreeListener listener) {
2837                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagOpen(this);
2838                }
2839                @Override
2840                public void exitRule(ParseTreeListener listener) {
2841                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagOpen(this);
2842                }
2843                @Override
2844                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2845                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagOpen(this);
2846                        else return visitor.visitChildren(this);
2847                }
2848        }
2849
2850        public final TrTagOpenContext trTagOpen() throws RecognitionException {
2851                TrTagOpenContext _localctx = new TrTagOpenContext(_ctx, getState());
2852                enterRule(_localctx, 24, RULE_trTagOpen);
2853                int _la;
2854                try {
2855                        enterOuterAlt(_localctx, 1);
2856                        {
2857                        setState(444);
2858                        match(OPEN);
2859                        setState(445);
2860                        match(TR_HTML_TAG_NAME);
2861                        setState(452);
2862                        _errHandler.sync(this);
2863                        _la = _input.LA(1);
2864                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2865                                {
2866                                setState(450);
2867                                switch (_input.LA(1)) {
2868                                case HTML_TAG_NAME:
2869                                        {
2870                                        setState(446);
2871                                        attribute();
2872                                        }
2873                                        break;
2874                                case NEWLINE:
2875                                        {
2876                                        setState(447);
2877                                        match(NEWLINE);
2878                                        }
2879                                        break;
2880                                case LEADING_ASTERISK:
2881                                        {
2882                                        setState(448);
2883                                        match(LEADING_ASTERISK);
2884                                        }
2885                                        break;
2886                                case WS:
2887                                        {
2888                                        setState(449);
2889                                        match(WS);
2890                                        }
2891                                        break;
2892                                default:
2893                                        throw new NoViableAltException(this);
2894                                }
2895                                }
2896                                setState(454);
2897                                _errHandler.sync(this);
2898                                _la = _input.LA(1);
2899                        }
2900                        setState(455);
2901                        match(CLOSE);
2902                        }
2903                }
2904                catch (RecognitionException re) {
2905                        _localctx.exception = re;
2906                        _errHandler.reportError(this, re);
2907                        _errHandler.recover(this, re);
2908                }
2909                finally {
2910                        exitRule();
2911                }
2912                return _localctx;
2913        }
2914
2915        public static class TrTagCloseContext extends ParserRuleContext {
2916                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2917                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
2918                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
2919                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2920                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2921                public TerminalNode NEWLINE(int i) {
2922                        return getToken(JavadocParser.NEWLINE, i);
2923                }
2924                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2925                public TerminalNode LEADING_ASTERISK(int i) {
2926                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2927                }
2928                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2929                public TerminalNode WS(int i) {
2930                        return getToken(JavadocParser.WS, i);
2931                }
2932                public TrTagCloseContext(ParserRuleContext parent, int invokingState) {
2933                        super(parent, invokingState);
2934                }
2935                @Override public int getRuleIndex() { return RULE_trTagClose; }
2936                @Override
2937                public void enterRule(ParseTreeListener listener) {
2938                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagClose(this);
2939                }
2940                @Override
2941                public void exitRule(ParseTreeListener listener) {
2942                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagClose(this);
2943                }
2944                @Override
2945                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2946                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagClose(this);
2947                        else return visitor.visitChildren(this);
2948                }
2949        }
2950
2951        public final TrTagCloseContext trTagClose() throws RecognitionException {
2952                TrTagCloseContext _localctx = new TrTagCloseContext(_ctx, getState());
2953                enterRule(_localctx, 26, RULE_trTagClose);
2954                int _la;
2955                try {
2956                        enterOuterAlt(_localctx, 1);
2957                        {
2958                        setState(457);
2959                        match(OPEN);
2960                        setState(458);
2961                        match(SLASH);
2962                        setState(459);
2963                        match(TR_HTML_TAG_NAME);
2964                        setState(463);
2965                        _errHandler.sync(this);
2966                        _la = _input.LA(1);
2967                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
2968                                {
2969                                {
2970                                setState(460);
2971                                _la = _input.LA(1);
2972                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
2973                                _errHandler.recoverInline(this);
2974                                } else {
2975                                        consume();
2976                                }
2977                                }
2978                                }
2979                                setState(465);
2980                                _errHandler.sync(this);
2981                                _la = _input.LA(1);
2982                        }
2983                        setState(466);
2984                        match(CLOSE);
2985                        }
2986                }
2987                catch (RecognitionException re) {
2988                        _localctx.exception = re;
2989                        _errHandler.reportError(this, re);
2990                        _errHandler.recover(this, re);
2991                }
2992                finally {
2993                        exitRule();
2994                }
2995                return _localctx;
2996        }
2997
2998        public static class TrContext extends ParserRuleContext {
2999                public TrTagOpenContext trTagOpen() {
3000                        return getRuleContext(TrTagOpenContext.class,0);
3001                }
3002                public TrTagCloseContext trTagClose() {
3003                        return getRuleContext(TrTagCloseContext.class,0);
3004                }
3005                public List<HtmlTagContext> htmlTag() {
3006                        return getRuleContexts(HtmlTagContext.class);
3007                }
3008                public HtmlTagContext htmlTag(int i) {
3009                        return getRuleContext(HtmlTagContext.class,i);
3010                }
3011                public List<SingletonTagContext> singletonTag() {
3012                        return getRuleContexts(SingletonTagContext.class);
3013                }
3014                public SingletonTagContext singletonTag(int i) {
3015                        return getRuleContext(SingletonTagContext.class,i);
3016                }
3017                public List<ParagraphContext> paragraph() {
3018                        return getRuleContexts(ParagraphContext.class);
3019                }
3020                public ParagraphContext paragraph(int i) {
3021                        return getRuleContext(ParagraphContext.class,i);
3022                }
3023                public List<LiContext> li() {
3024                        return getRuleContexts(LiContext.class);
3025                }
3026                public LiContext li(int i) {
3027                        return getRuleContext(LiContext.class,i);
3028                }
3029                public List<TdContext> td() {
3030                        return getRuleContexts(TdContext.class);
3031                }
3032                public TdContext td(int i) {
3033                        return getRuleContext(TdContext.class,i);
3034                }
3035                public List<ThContext> th() {
3036                        return getRuleContexts(ThContext.class);
3037                }
3038                public ThContext th(int i) {
3039                        return getRuleContext(ThContext.class,i);
3040                }
3041                public List<BodyContext> body() {
3042                        return getRuleContexts(BodyContext.class);
3043                }
3044                public BodyContext body(int i) {
3045                        return getRuleContext(BodyContext.class,i);
3046                }
3047                public List<ColgroupContext> colgroup() {
3048                        return getRuleContexts(ColgroupContext.class);
3049                }
3050                public ColgroupContext colgroup(int i) {
3051                        return getRuleContext(ColgroupContext.class,i);
3052                }
3053                public List<DdContext> dd() {
3054                        return getRuleContexts(DdContext.class);
3055                }
3056                public DdContext dd(int i) {
3057                        return getRuleContext(DdContext.class,i);
3058                }
3059                public List<DtContext> dt() {
3060                        return getRuleContexts(DtContext.class);
3061                }
3062                public DtContext dt(int i) {
3063                        return getRuleContext(DtContext.class,i);
3064                }
3065                public List<HeadContext> head() {
3066                        return getRuleContexts(HeadContext.class);
3067                }
3068                public HeadContext head(int i) {
3069                        return getRuleContext(HeadContext.class,i);
3070                }
3071                public List<HtmlContext> html() {
3072                        return getRuleContexts(HtmlContext.class);
3073                }
3074                public HtmlContext html(int i) {
3075                        return getRuleContext(HtmlContext.class,i);
3076                }
3077                public List<OptionContext> option() {
3078                        return getRuleContexts(OptionContext.class);
3079                }
3080                public OptionContext option(int i) {
3081                        return getRuleContext(OptionContext.class,i);
3082                }
3083                public List<TbodyContext> tbody() {
3084                        return getRuleContexts(TbodyContext.class);
3085                }
3086                public TbodyContext tbody(int i) {
3087                        return getRuleContext(TbodyContext.class,i);
3088                }
3089                public List<TheadContext> thead() {
3090                        return getRuleContexts(TheadContext.class);
3091                }
3092                public TheadContext thead(int i) {
3093                        return getRuleContext(TheadContext.class,i);
3094                }
3095                public List<TfootContext> tfoot() {
3096                        return getRuleContexts(TfootContext.class);
3097                }
3098                public TfootContext tfoot(int i) {
3099                        return getRuleContext(TfootContext.class,i);
3100                }
3101                public List<PTagOpenContext> pTagOpen() {
3102                        return getRuleContexts(PTagOpenContext.class);
3103                }
3104                public PTagOpenContext pTagOpen(int i) {
3105                        return getRuleContext(PTagOpenContext.class,i);
3106                }
3107                public List<LiTagOpenContext> liTagOpen() {
3108                        return getRuleContexts(LiTagOpenContext.class);
3109                }
3110                public LiTagOpenContext liTagOpen(int i) {
3111                        return getRuleContext(LiTagOpenContext.class,i);
3112                }
3113                public List<TdTagOpenContext> tdTagOpen() {
3114                        return getRuleContexts(TdTagOpenContext.class);
3115                }
3116                public TdTagOpenContext tdTagOpen(int i) {
3117                        return getRuleContext(TdTagOpenContext.class,i);
3118                }
3119                public List<ThTagOpenContext> thTagOpen() {
3120                        return getRuleContexts(ThTagOpenContext.class);
3121                }
3122                public ThTagOpenContext thTagOpen(int i) {
3123                        return getRuleContext(ThTagOpenContext.class,i);
3124                }
3125                public List<BodyTagOpenContext> bodyTagOpen() {
3126                        return getRuleContexts(BodyTagOpenContext.class);
3127                }
3128                public BodyTagOpenContext bodyTagOpen(int i) {
3129                        return getRuleContext(BodyTagOpenContext.class,i);
3130                }
3131                public List<ColgroupTagOpenContext> colgroupTagOpen() {
3132                        return getRuleContexts(ColgroupTagOpenContext.class);
3133                }
3134                public ColgroupTagOpenContext colgroupTagOpen(int i) {
3135                        return getRuleContext(ColgroupTagOpenContext.class,i);
3136                }
3137                public List<DdTagOpenContext> ddTagOpen() {
3138                        return getRuleContexts(DdTagOpenContext.class);
3139                }
3140                public DdTagOpenContext ddTagOpen(int i) {
3141                        return getRuleContext(DdTagOpenContext.class,i);
3142                }
3143                public List<DtTagOpenContext> dtTagOpen() {
3144                        return getRuleContexts(DtTagOpenContext.class);
3145                }
3146                public DtTagOpenContext dtTagOpen(int i) {
3147                        return getRuleContext(DtTagOpenContext.class,i);
3148                }
3149                public List<HeadTagOpenContext> headTagOpen() {
3150                        return getRuleContexts(HeadTagOpenContext.class);
3151                }
3152                public HeadTagOpenContext headTagOpen(int i) {
3153                        return getRuleContext(HeadTagOpenContext.class,i);
3154                }
3155                public List<HtmlTagOpenContext> htmlTagOpen() {
3156                        return getRuleContexts(HtmlTagOpenContext.class);
3157                }
3158                public HtmlTagOpenContext htmlTagOpen(int i) {
3159                        return getRuleContext(HtmlTagOpenContext.class,i);
3160                }
3161                public List<OptionTagOpenContext> optionTagOpen() {
3162                        return getRuleContexts(OptionTagOpenContext.class);
3163                }
3164                public OptionTagOpenContext optionTagOpen(int i) {
3165                        return getRuleContext(OptionTagOpenContext.class,i);
3166                }
3167                public List<TbodyTagOpenContext> tbodyTagOpen() {
3168                        return getRuleContexts(TbodyTagOpenContext.class);
3169                }
3170                public TbodyTagOpenContext tbodyTagOpen(int i) {
3171                        return getRuleContext(TbodyTagOpenContext.class,i);
3172                }
3173                public List<TheadTagOpenContext> theadTagOpen() {
3174                        return getRuleContexts(TheadTagOpenContext.class);
3175                }
3176                public TheadTagOpenContext theadTagOpen(int i) {
3177                        return getRuleContext(TheadTagOpenContext.class,i);
3178                }
3179                public List<TfootTagOpenContext> tfootTagOpen() {
3180                        return getRuleContexts(TfootTagOpenContext.class);
3181                }
3182                public TfootTagOpenContext tfootTagOpen(int i) {
3183                        return getRuleContext(TfootTagOpenContext.class,i);
3184                }
3185                public List<HtmlCommentContext> htmlComment() {
3186                        return getRuleContexts(HtmlCommentContext.class);
3187                }
3188                public HtmlCommentContext htmlComment(int i) {
3189                        return getRuleContext(HtmlCommentContext.class,i);
3190                }
3191                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
3192                public TerminalNode CDATA(int i) {
3193                        return getToken(JavadocParser.CDATA, i);
3194                }
3195                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3196                public TerminalNode NEWLINE(int i) {
3197                        return getToken(JavadocParser.NEWLINE, i);
3198                }
3199                public List<TextContext> text() {
3200                        return getRuleContexts(TextContext.class);
3201                }
3202                public TextContext text(int i) {
3203                        return getRuleContext(TextContext.class,i);
3204                }
3205                public List<JavadocInlineTagContext> javadocInlineTag() {
3206                        return getRuleContexts(JavadocInlineTagContext.class);
3207                }
3208                public JavadocInlineTagContext javadocInlineTag(int i) {
3209                        return getRuleContext(JavadocInlineTagContext.class,i);
3210                }
3211                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3212                public TerminalNode LEADING_ASTERISK(int i) {
3213                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3214                }
3215                public TrContext(ParserRuleContext parent, int invokingState) {
3216                        super(parent, invokingState);
3217                }
3218                @Override public int getRuleIndex() { return RULE_tr; }
3219                @Override
3220                public void enterRule(ParseTreeListener listener) {
3221                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTr(this);
3222                }
3223                @Override
3224                public void exitRule(ParseTreeListener listener) {
3225                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTr(this);
3226                }
3227                @Override
3228                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3229                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTr(this);
3230                        else return visitor.visitChildren(this);
3231                }
3232        }
3233
3234        public final TrContext tr() throws RecognitionException {
3235                TrContext _localctx = new TrContext(_ctx, getState());
3236                enterRule(_localctx, 28, RULE_tr);
3237                try {
3238                        int _alt;
3239                        enterOuterAlt(_localctx, 1);
3240                        {
3241                        setState(468);
3242                        trTagOpen();
3243                        setState(508);
3244                        _errHandler.sync(this);
3245                        _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
3246                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3247                                if ( _alt==1 ) {
3248                                        {
3249                                        setState(506);
3250                                        _errHandler.sync(this);
3251                                        switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
3252                                        case 1:
3253                                                {
3254                                                setState(469);
3255                                                htmlTag();
3256                                                }
3257                                                break;
3258                                        case 2:
3259                                                {
3260                                                setState(470);
3261                                                singletonTag();
3262                                                }
3263                                                break;
3264                                        case 3:
3265                                                {
3266                                                setState(471);
3267                                                paragraph();
3268                                                }
3269                                                break;
3270                                        case 4:
3271                                                {
3272                                                setState(472);
3273                                                li();
3274                                                }
3275                                                break;
3276                                        case 5:
3277                                                {
3278                                                setState(473);
3279                                                td();
3280                                                }
3281                                                break;
3282                                        case 6:
3283                                                {
3284                                                setState(474);
3285                                                th();
3286                                                }
3287                                                break;
3288                                        case 7:
3289                                                {
3290                                                setState(475);
3291                                                body();
3292                                                }
3293                                                break;
3294                                        case 8:
3295                                                {
3296                                                setState(476);
3297                                                colgroup();
3298                                                }
3299                                                break;
3300                                        case 9:
3301                                                {
3302                                                setState(477);
3303                                                dd();
3304                                                }
3305                                                break;
3306                                        case 10:
3307                                                {
3308                                                setState(478);
3309                                                dt();
3310                                                }
3311                                                break;
3312                                        case 11:
3313                                                {
3314                                                setState(479);
3315                                                head();
3316                                                }
3317                                                break;
3318                                        case 12:
3319                                                {
3320                                                setState(480);
3321                                                html();
3322                                                }
3323                                                break;
3324                                        case 13:
3325                                                {
3326                                                setState(481);
3327                                                option();
3328                                                }
3329                                                break;
3330                                        case 14:
3331                                                {
3332                                                setState(482);
3333                                                tbody();
3334                                                }
3335                                                break;
3336                                        case 15:
3337                                                {
3338                                                setState(483);
3339                                                thead();
3340                                                }
3341                                                break;
3342                                        case 16:
3343                                                {
3344                                                setState(484);
3345                                                tfoot();
3346                                                }
3347                                                break;
3348                                        case 17:
3349                                                {
3350                                                setState(485);
3351                                                pTagOpen();
3352                                                }
3353                                                break;
3354                                        case 18:
3355                                                {
3356                                                setState(486);
3357                                                liTagOpen();
3358                                                }
3359                                                break;
3360                                        case 19:
3361                                                {
3362                                                setState(487);
3363                                                tdTagOpen();
3364                                                }
3365                                                break;
3366                                        case 20:
3367                                                {
3368                                                setState(488);
3369                                                thTagOpen();
3370                                                }
3371                                                break;
3372                                        case 21:
3373                                                {
3374                                                setState(489);
3375                                                bodyTagOpen();
3376                                                }
3377                                                break;
3378                                        case 22:
3379                                                {
3380                                                setState(490);
3381                                                colgroupTagOpen();
3382                                                }
3383                                                break;
3384                                        case 23:
3385                                                {
3386                                                setState(491);
3387                                                ddTagOpen();
3388                                                }
3389                                                break;
3390                                        case 24:
3391                                                {
3392                                                setState(492);
3393                                                dtTagOpen();
3394                                                }
3395                                                break;
3396                                        case 25:
3397                                                {
3398                                                setState(493);
3399                                                headTagOpen();
3400                                                }
3401                                                break;
3402                                        case 26:
3403                                                {
3404                                                setState(494);
3405                                                htmlTagOpen();
3406                                                }
3407                                                break;
3408                                        case 27:
3409                                                {
3410                                                setState(495);
3411                                                optionTagOpen();
3412                                                }
3413                                                break;
3414                                        case 28:
3415                                                {
3416                                                setState(496);
3417                                                tbodyTagOpen();
3418                                                }
3419                                                break;
3420                                        case 29:
3421                                                {
3422                                                setState(497);
3423                                                theadTagOpen();
3424                                                }
3425                                                break;
3426                                        case 30:
3427                                                {
3428                                                setState(498);
3429                                                tfootTagOpen();
3430                                                }
3431                                                break;
3432                                        case 31:
3433                                                {
3434                                                {
3435                                                setState(499);
3436                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
3437                                                setState(500);
3438                                                match(LEADING_ASTERISK);
3439                                                }
3440                                                }
3441                                                break;
3442                                        case 32:
3443                                                {
3444                                                setState(501);
3445                                                htmlComment();
3446                                                }
3447                                                break;
3448                                        case 33:
3449                                                {
3450                                                setState(502);
3451                                                match(CDATA);
3452                                                }
3453                                                break;
3454                                        case 34:
3455                                                {
3456                                                setState(503);
3457                                                match(NEWLINE);
3458                                                }
3459                                                break;
3460                                        case 35:
3461                                                {
3462                                                setState(504);
3463                                                text();
3464                                                }
3465                                                break;
3466                                        case 36:
3467                                                {
3468                                                setState(505);
3469                                                javadocInlineTag();
3470                                                }
3471                                                break;
3472                                        }
3473                                        } 
3474                                }
3475                                setState(510);
3476                                _errHandler.sync(this);
3477                                _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
3478                        }
3479                        setState(511);
3480                        trTagClose();
3481                        }
3482                }
3483                catch (RecognitionException re) {
3484                        _localctx.exception = re;
3485                        _errHandler.reportError(this, re);
3486                        _errHandler.recover(this, re);
3487                }
3488                finally {
3489                        exitRule();
3490                }
3491                return _localctx;
3492        }
3493
3494        public static class TdTagOpenContext extends ParserRuleContext {
3495                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
3496                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
3497                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
3498                public List<AttributeContext> attribute() {
3499                        return getRuleContexts(AttributeContext.class);
3500                }
3501                public AttributeContext attribute(int i) {
3502                        return getRuleContext(AttributeContext.class,i);
3503                }
3504                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3505                public TerminalNode NEWLINE(int i) {
3506                        return getToken(JavadocParser.NEWLINE, i);
3507                }
3508                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3509                public TerminalNode LEADING_ASTERISK(int i) {
3510                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3511                }
3512                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
3513                public TerminalNode WS(int i) {
3514                        return getToken(JavadocParser.WS, i);
3515                }
3516                public TdTagOpenContext(ParserRuleContext parent, int invokingState) {
3517                        super(parent, invokingState);
3518                }
3519                @Override public int getRuleIndex() { return RULE_tdTagOpen; }
3520                @Override
3521                public void enterRule(ParseTreeListener listener) {
3522                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagOpen(this);
3523                }
3524                @Override
3525                public void exitRule(ParseTreeListener listener) {
3526                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagOpen(this);
3527                }
3528                @Override
3529                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3530                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagOpen(this);
3531                        else return visitor.visitChildren(this);
3532                }
3533        }
3534
3535        public final TdTagOpenContext tdTagOpen() throws RecognitionException {
3536                TdTagOpenContext _localctx = new TdTagOpenContext(_ctx, getState());
3537                enterRule(_localctx, 30, RULE_tdTagOpen);
3538                int _la;
3539                try {
3540                        enterOuterAlt(_localctx, 1);
3541                        {
3542                        setState(513);
3543                        match(OPEN);
3544                        setState(514);
3545                        match(TD_HTML_TAG_NAME);
3546                        setState(521);
3547                        _errHandler.sync(this);
3548                        _la = _input.LA(1);
3549                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
3550                                {
3551                                setState(519);
3552                                switch (_input.LA(1)) {
3553                                case HTML_TAG_NAME:
3554                                        {
3555                                        setState(515);
3556                                        attribute();
3557                                        }
3558                                        break;
3559                                case NEWLINE:
3560                                        {
3561                                        setState(516);
3562                                        match(NEWLINE);
3563                                        }
3564                                        break;
3565                                case LEADING_ASTERISK:
3566                                        {
3567                                        setState(517);
3568                                        match(LEADING_ASTERISK);
3569                                        }
3570                                        break;
3571                                case WS:
3572                                        {
3573                                        setState(518);
3574                                        match(WS);
3575                                        }
3576                                        break;
3577                                default:
3578                                        throw new NoViableAltException(this);
3579                                }
3580                                }
3581                                setState(523);
3582                                _errHandler.sync(this);
3583                                _la = _input.LA(1);
3584                        }
3585                        setState(524);
3586                        match(CLOSE);
3587                        }
3588                }
3589                catch (RecognitionException re) {
3590                        _localctx.exception = re;
3591                        _errHandler.reportError(this, re);
3592                        _errHandler.recover(this, re);
3593                }
3594                finally {
3595                        exitRule();
3596                }
3597                return _localctx;
3598        }
3599
3600        public static class TdTagCloseContext extends ParserRuleContext {
3601                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
3602                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
3603                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
3604                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
3605                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3606                public TerminalNode NEWLINE(int i) {
3607                        return getToken(JavadocParser.NEWLINE, i);
3608                }
3609                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3610                public TerminalNode LEADING_ASTERISK(int i) {
3611                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3612                }
3613                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
3614                public TerminalNode WS(int i) {
3615                        return getToken(JavadocParser.WS, i);
3616                }
3617                public TdTagCloseContext(ParserRuleContext parent, int invokingState) {
3618                        super(parent, invokingState);
3619                }
3620                @Override public int getRuleIndex() { return RULE_tdTagClose; }
3621                @Override
3622                public void enterRule(ParseTreeListener listener) {
3623                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagClose(this);
3624                }
3625                @Override
3626                public void exitRule(ParseTreeListener listener) {
3627                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagClose(this);
3628                }
3629                @Override
3630                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3631                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagClose(this);
3632                        else return visitor.visitChildren(this);
3633                }
3634        }
3635
3636        public final TdTagCloseContext tdTagClose() throws RecognitionException {
3637                TdTagCloseContext _localctx = new TdTagCloseContext(_ctx, getState());
3638                enterRule(_localctx, 32, RULE_tdTagClose);
3639                int _la;
3640                try {
3641                        enterOuterAlt(_localctx, 1);
3642                        {
3643                        setState(526);
3644                        match(OPEN);
3645                        setState(527);
3646                        match(SLASH);
3647                        setState(528);
3648                        match(TD_HTML_TAG_NAME);
3649                        setState(532);
3650                        _errHandler.sync(this);
3651                        _la = _input.LA(1);
3652                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
3653                                {
3654                                {
3655                                setState(529);
3656                                _la = _input.LA(1);
3657                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
3658                                _errHandler.recoverInline(this);
3659                                } else {
3660                                        consume();
3661                                }
3662                                }
3663                                }
3664                                setState(534);
3665                                _errHandler.sync(this);
3666                                _la = _input.LA(1);
3667                        }
3668                        setState(535);
3669                        match(CLOSE);
3670                        }
3671                }
3672                catch (RecognitionException re) {
3673                        _localctx.exception = re;
3674                        _errHandler.reportError(this, re);
3675                        _errHandler.recover(this, re);
3676                }
3677                finally {
3678                        exitRule();
3679                }
3680                return _localctx;
3681        }
3682
3683        public static class TdContext extends ParserRuleContext {
3684                public List<TdTagOpenContext> tdTagOpen() {
3685                        return getRuleContexts(TdTagOpenContext.class);
3686                }
3687                public TdTagOpenContext tdTagOpen(int i) {
3688                        return getRuleContext(TdTagOpenContext.class,i);
3689                }
3690                public TdTagCloseContext tdTagClose() {
3691                        return getRuleContext(TdTagCloseContext.class,0);
3692                }
3693                public List<HtmlTagContext> htmlTag() {
3694                        return getRuleContexts(HtmlTagContext.class);
3695                }
3696                public HtmlTagContext htmlTag(int i) {
3697                        return getRuleContext(HtmlTagContext.class,i);
3698                }
3699                public List<SingletonTagContext> singletonTag() {
3700                        return getRuleContexts(SingletonTagContext.class);
3701                }
3702                public SingletonTagContext singletonTag(int i) {
3703                        return getRuleContext(SingletonTagContext.class,i);
3704                }
3705                public List<ParagraphContext> paragraph() {
3706                        return getRuleContexts(ParagraphContext.class);
3707                }
3708                public ParagraphContext paragraph(int i) {
3709                        return getRuleContext(ParagraphContext.class,i);
3710                }
3711                public List<LiContext> li() {
3712                        return getRuleContexts(LiContext.class);
3713                }
3714                public LiContext li(int i) {
3715                        return getRuleContext(LiContext.class,i);
3716                }
3717                public List<TrContext> tr() {
3718                        return getRuleContexts(TrContext.class);
3719                }
3720                public TrContext tr(int i) {
3721                        return getRuleContext(TrContext.class,i);
3722                }
3723                public List<ThContext> th() {
3724                        return getRuleContexts(ThContext.class);
3725                }
3726                public ThContext th(int i) {
3727                        return getRuleContext(ThContext.class,i);
3728                }
3729                public List<BodyContext> body() {
3730                        return getRuleContexts(BodyContext.class);
3731                }
3732                public BodyContext body(int i) {
3733                        return getRuleContext(BodyContext.class,i);
3734                }
3735                public List<ColgroupContext> colgroup() {
3736                        return getRuleContexts(ColgroupContext.class);
3737                }
3738                public ColgroupContext colgroup(int i) {
3739                        return getRuleContext(ColgroupContext.class,i);
3740                }
3741                public List<DdContext> dd() {
3742                        return getRuleContexts(DdContext.class);
3743                }
3744                public DdContext dd(int i) {
3745                        return getRuleContext(DdContext.class,i);
3746                }
3747                public List<DtContext> dt() {
3748                        return getRuleContexts(DtContext.class);
3749                }
3750                public DtContext dt(int i) {
3751                        return getRuleContext(DtContext.class,i);
3752                }
3753                public List<HeadContext> head() {
3754                        return getRuleContexts(HeadContext.class);
3755                }
3756                public HeadContext head(int i) {
3757                        return getRuleContext(HeadContext.class,i);
3758                }
3759                public List<HtmlContext> html() {
3760                        return getRuleContexts(HtmlContext.class);
3761                }
3762                public HtmlContext html(int i) {
3763                        return getRuleContext(HtmlContext.class,i);
3764                }
3765                public List<OptionContext> option() {
3766                        return getRuleContexts(OptionContext.class);
3767                }
3768                public OptionContext option(int i) {
3769                        return getRuleContext(OptionContext.class,i);
3770                }
3771                public List<TbodyContext> tbody() {
3772                        return getRuleContexts(TbodyContext.class);
3773                }
3774                public TbodyContext tbody(int i) {
3775                        return getRuleContext(TbodyContext.class,i);
3776                }
3777                public List<TheadContext> thead() {
3778                        return getRuleContexts(TheadContext.class);
3779                }
3780                public TheadContext thead(int i) {
3781                        return getRuleContext(TheadContext.class,i);
3782                }
3783                public List<TfootContext> tfoot() {
3784                        return getRuleContexts(TfootContext.class);
3785                }
3786                public TfootContext tfoot(int i) {
3787                        return getRuleContext(TfootContext.class,i);
3788                }
3789                public List<PTagOpenContext> pTagOpen() {
3790                        return getRuleContexts(PTagOpenContext.class);
3791                }
3792                public PTagOpenContext pTagOpen(int i) {
3793                        return getRuleContext(PTagOpenContext.class,i);
3794                }
3795                public List<LiTagOpenContext> liTagOpen() {
3796                        return getRuleContexts(LiTagOpenContext.class);
3797                }
3798                public LiTagOpenContext liTagOpen(int i) {
3799                        return getRuleContext(LiTagOpenContext.class,i);
3800                }
3801                public List<ThTagOpenContext> thTagOpen() {
3802                        return getRuleContexts(ThTagOpenContext.class);
3803                }
3804                public ThTagOpenContext thTagOpen(int i) {
3805                        return getRuleContext(ThTagOpenContext.class,i);
3806                }
3807                public List<BodyTagOpenContext> bodyTagOpen() {
3808                        return getRuleContexts(BodyTagOpenContext.class);
3809                }
3810                public BodyTagOpenContext bodyTagOpen(int i) {
3811                        return getRuleContext(BodyTagOpenContext.class,i);
3812                }
3813                public List<ColgroupTagOpenContext> colgroupTagOpen() {
3814                        return getRuleContexts(ColgroupTagOpenContext.class);
3815                }
3816                public ColgroupTagOpenContext colgroupTagOpen(int i) {
3817                        return getRuleContext(ColgroupTagOpenContext.class,i);
3818                }
3819                public List<DdTagOpenContext> ddTagOpen() {
3820                        return getRuleContexts(DdTagOpenContext.class);
3821                }
3822                public DdTagOpenContext ddTagOpen(int i) {
3823                        return getRuleContext(DdTagOpenContext.class,i);
3824                }
3825                public List<DtTagOpenContext> dtTagOpen() {
3826                        return getRuleContexts(DtTagOpenContext.class);
3827                }
3828                public DtTagOpenContext dtTagOpen(int i) {
3829                        return getRuleContext(DtTagOpenContext.class,i);
3830                }
3831                public List<HeadTagOpenContext> headTagOpen() {
3832                        return getRuleContexts(HeadTagOpenContext.class);
3833                }
3834                public HeadTagOpenContext headTagOpen(int i) {
3835                        return getRuleContext(HeadTagOpenContext.class,i);
3836                }
3837                public List<HtmlTagOpenContext> htmlTagOpen() {
3838                        return getRuleContexts(HtmlTagOpenContext.class);
3839                }
3840                public HtmlTagOpenContext htmlTagOpen(int i) {
3841                        return getRuleContext(HtmlTagOpenContext.class,i);
3842                }
3843                public List<OptionTagOpenContext> optionTagOpen() {
3844                        return getRuleContexts(OptionTagOpenContext.class);
3845                }
3846                public OptionTagOpenContext optionTagOpen(int i) {
3847                        return getRuleContext(OptionTagOpenContext.class,i);
3848                }
3849                public List<TbodyTagOpenContext> tbodyTagOpen() {
3850                        return getRuleContexts(TbodyTagOpenContext.class);
3851                }
3852                public TbodyTagOpenContext tbodyTagOpen(int i) {
3853                        return getRuleContext(TbodyTagOpenContext.class,i);
3854                }
3855                public List<TheadTagOpenContext> theadTagOpen() {
3856                        return getRuleContexts(TheadTagOpenContext.class);
3857                }
3858                public TheadTagOpenContext theadTagOpen(int i) {
3859                        return getRuleContext(TheadTagOpenContext.class,i);
3860                }
3861                public List<TfootTagOpenContext> tfootTagOpen() {
3862                        return getRuleContexts(TfootTagOpenContext.class);
3863                }
3864                public TfootTagOpenContext tfootTagOpen(int i) {
3865                        return getRuleContext(TfootTagOpenContext.class,i);
3866                }
3867                public List<HtmlCommentContext> htmlComment() {
3868                        return getRuleContexts(HtmlCommentContext.class);
3869                }
3870                public HtmlCommentContext htmlComment(int i) {
3871                        return getRuleContext(HtmlCommentContext.class,i);
3872                }
3873                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
3874                public TerminalNode CDATA(int i) {
3875                        return getToken(JavadocParser.CDATA, i);
3876                }
3877                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3878                public TerminalNode NEWLINE(int i) {
3879                        return getToken(JavadocParser.NEWLINE, i);
3880                }
3881                public List<TextContext> text() {
3882                        return getRuleContexts(TextContext.class);
3883                }
3884                public TextContext text(int i) {
3885                        return getRuleContext(TextContext.class,i);
3886                }
3887                public List<JavadocInlineTagContext> javadocInlineTag() {
3888                        return getRuleContexts(JavadocInlineTagContext.class);
3889                }
3890                public JavadocInlineTagContext javadocInlineTag(int i) {
3891                        return getRuleContext(JavadocInlineTagContext.class,i);
3892                }
3893                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3894                public TerminalNode LEADING_ASTERISK(int i) {
3895                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3896                }
3897                public TdContext(ParserRuleContext parent, int invokingState) {
3898                        super(parent, invokingState);
3899                }
3900                @Override public int getRuleIndex() { return RULE_td; }
3901                @Override
3902                public void enterRule(ParseTreeListener listener) {
3903                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTd(this);
3904                }
3905                @Override
3906                public void exitRule(ParseTreeListener listener) {
3907                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTd(this);
3908                }
3909                @Override
3910                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3911                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTd(this);
3912                        else return visitor.visitChildren(this);
3913                }
3914        }
3915
3916        public final TdContext td() throws RecognitionException {
3917                TdContext _localctx = new TdContext(_ctx, getState());
3918                enterRule(_localctx, 34, RULE_td);
3919                try {
3920                        int _alt;
3921                        enterOuterAlt(_localctx, 1);
3922                        {
3923                        setState(537);
3924                        tdTagOpen();
3925                        setState(577);
3926                        _errHandler.sync(this);
3927                        _alt = getInterpreter().adaptivePredict(_input,36,_ctx);
3928                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3929                                if ( _alt==1 ) {
3930                                        {
3931                                        setState(575);
3932                                        _errHandler.sync(this);
3933                                        switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
3934                                        case 1:
3935                                                {
3936                                                setState(538);
3937                                                htmlTag();
3938                                                }
3939                                                break;
3940                                        case 2:
3941                                                {
3942                                                setState(539);
3943                                                singletonTag();
3944                                                }
3945                                                break;
3946                                        case 3:
3947                                                {
3948                                                setState(540);
3949                                                paragraph();
3950                                                }
3951                                                break;
3952                                        case 4:
3953                                                {
3954                                                setState(541);
3955                                                li();
3956                                                }
3957                                                break;
3958                                        case 5:
3959                                                {
3960                                                setState(542);
3961                                                tr();
3962                                                }
3963                                                break;
3964                                        case 6:
3965                                                {
3966                                                setState(543);
3967                                                th();
3968                                                }
3969                                                break;
3970                                        case 7:
3971                                                {
3972                                                setState(544);
3973                                                body();
3974                                                }
3975                                                break;
3976                                        case 8:
3977                                                {
3978                                                setState(545);
3979                                                colgroup();
3980                                                }
3981                                                break;
3982                                        case 9:
3983                                                {
3984                                                setState(546);
3985                                                dd();
3986                                                }
3987                                                break;
3988                                        case 10:
3989                                                {
3990                                                setState(547);
3991                                                dt();
3992                                                }
3993                                                break;
3994                                        case 11:
3995                                                {
3996                                                setState(548);
3997                                                head();
3998                                                }
3999                                                break;
4000                                        case 12:
4001                                                {
4002                                                setState(549);
4003                                                html();
4004                                                }
4005                                                break;
4006                                        case 13:
4007                                                {
4008                                                setState(550);
4009                                                option();
4010                                                }
4011                                                break;
4012                                        case 14:
4013                                                {
4014                                                setState(551);
4015                                                tbody();
4016                                                }
4017                                                break;
4018                                        case 15:
4019                                                {
4020                                                setState(552);
4021                                                thead();
4022                                                }
4023                                                break;
4024                                        case 16:
4025                                                {
4026                                                setState(553);
4027                                                tfoot();
4028                                                }
4029                                                break;
4030                                        case 17:
4031                                                {
4032                                                setState(554);
4033                                                pTagOpen();
4034                                                }
4035                                                break;
4036                                        case 18:
4037                                                {
4038                                                setState(555);
4039                                                liTagOpen();
4040                                                }
4041                                                break;
4042                                        case 19:
4043                                                {
4044                                                setState(556);
4045                                                tdTagOpen();
4046                                                }
4047                                                break;
4048                                        case 20:
4049                                                {
4050                                                setState(557);
4051                                                thTagOpen();
4052                                                }
4053                                                break;
4054                                        case 21:
4055                                                {
4056                                                setState(558);
4057                                                bodyTagOpen();
4058                                                }
4059                                                break;
4060                                        case 22:
4061                                                {
4062                                                setState(559);
4063                                                colgroupTagOpen();
4064                                                }
4065                                                break;
4066                                        case 23:
4067                                                {
4068                                                setState(560);
4069                                                ddTagOpen();
4070                                                }
4071                                                break;
4072                                        case 24:
4073                                                {
4074                                                setState(561);
4075                                                dtTagOpen();
4076                                                }
4077                                                break;
4078                                        case 25:
4079                                                {
4080                                                setState(562);
4081                                                headTagOpen();
4082                                                }
4083                                                break;
4084                                        case 26:
4085                                                {
4086                                                setState(563);
4087                                                htmlTagOpen();
4088                                                }
4089                                                break;
4090                                        case 27:
4091                                                {
4092                                                setState(564);
4093                                                optionTagOpen();
4094                                                }
4095                                                break;
4096                                        case 28:
4097                                                {
4098                                                setState(565);
4099                                                tbodyTagOpen();
4100                                                }
4101                                                break;
4102                                        case 29:
4103                                                {
4104                                                setState(566);
4105                                                theadTagOpen();
4106                                                }
4107                                                break;
4108                                        case 30:
4109                                                {
4110                                                setState(567);
4111                                                tfootTagOpen();
4112                                                }
4113                                                break;
4114                                        case 31:
4115                                                {
4116                                                {
4117                                                setState(568);
4118                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
4119                                                setState(569);
4120                                                match(LEADING_ASTERISK);
4121                                                }
4122                                                }
4123                                                break;
4124                                        case 32:
4125                                                {
4126                                                setState(570);
4127                                                htmlComment();
4128                                                }
4129                                                break;
4130                                        case 33:
4131                                                {
4132                                                setState(571);
4133                                                match(CDATA);
4134                                                }
4135                                                break;
4136                                        case 34:
4137                                                {
4138                                                setState(572);
4139                                                match(NEWLINE);
4140                                                }
4141                                                break;
4142                                        case 35:
4143                                                {
4144                                                setState(573);
4145                                                text();
4146                                                }
4147                                                break;
4148                                        case 36:
4149                                                {
4150                                                setState(574);
4151                                                javadocInlineTag();
4152                                                }
4153                                                break;
4154                                        }
4155                                        } 
4156                                }
4157                                setState(579);
4158                                _errHandler.sync(this);
4159                                _alt = getInterpreter().adaptivePredict(_input,36,_ctx);
4160                        }
4161                        setState(580);
4162                        tdTagClose();
4163                        }
4164                }
4165                catch (RecognitionException re) {
4166                        _localctx.exception = re;
4167                        _errHandler.reportError(this, re);
4168                        _errHandler.recover(this, re);
4169                }
4170                finally {
4171                        exitRule();
4172                }
4173                return _localctx;
4174        }
4175
4176        public static class ThTagOpenContext extends ParserRuleContext {
4177                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4178                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
4179                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4180                public List<AttributeContext> attribute() {
4181                        return getRuleContexts(AttributeContext.class);
4182                }
4183                public AttributeContext attribute(int i) {
4184                        return getRuleContext(AttributeContext.class,i);
4185                }
4186                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4187                public TerminalNode NEWLINE(int i) {
4188                        return getToken(JavadocParser.NEWLINE, i);
4189                }
4190                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4191                public TerminalNode LEADING_ASTERISK(int i) {
4192                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4193                }
4194                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4195                public TerminalNode WS(int i) {
4196                        return getToken(JavadocParser.WS, i);
4197                }
4198                public ThTagOpenContext(ParserRuleContext parent, int invokingState) {
4199                        super(parent, invokingState);
4200                }
4201                @Override public int getRuleIndex() { return RULE_thTagOpen; }
4202                @Override
4203                public void enterRule(ParseTreeListener listener) {
4204                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagOpen(this);
4205                }
4206                @Override
4207                public void exitRule(ParseTreeListener listener) {
4208                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagOpen(this);
4209                }
4210                @Override
4211                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4212                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagOpen(this);
4213                        else return visitor.visitChildren(this);
4214                }
4215        }
4216
4217        public final ThTagOpenContext thTagOpen() throws RecognitionException {
4218                ThTagOpenContext _localctx = new ThTagOpenContext(_ctx, getState());
4219                enterRule(_localctx, 36, RULE_thTagOpen);
4220                int _la;
4221                try {
4222                        enterOuterAlt(_localctx, 1);
4223                        {
4224                        setState(582);
4225                        match(OPEN);
4226                        setState(583);
4227                        match(TH_HTML_TAG_NAME);
4228                        setState(590);
4229                        _errHandler.sync(this);
4230                        _la = _input.LA(1);
4231                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
4232                                {
4233                                setState(588);
4234                                switch (_input.LA(1)) {
4235                                case HTML_TAG_NAME:
4236                                        {
4237                                        setState(584);
4238                                        attribute();
4239                                        }
4240                                        break;
4241                                case NEWLINE:
4242                                        {
4243                                        setState(585);
4244                                        match(NEWLINE);
4245                                        }
4246                                        break;
4247                                case LEADING_ASTERISK:
4248                                        {
4249                                        setState(586);
4250                                        match(LEADING_ASTERISK);
4251                                        }
4252                                        break;
4253                                case WS:
4254                                        {
4255                                        setState(587);
4256                                        match(WS);
4257                                        }
4258                                        break;
4259                                default:
4260                                        throw new NoViableAltException(this);
4261                                }
4262                                }
4263                                setState(592);
4264                                _errHandler.sync(this);
4265                                _la = _input.LA(1);
4266                        }
4267                        setState(593);
4268                        match(CLOSE);
4269                        }
4270                }
4271                catch (RecognitionException re) {
4272                        _localctx.exception = re;
4273                        _errHandler.reportError(this, re);
4274                        _errHandler.recover(this, re);
4275                }
4276                finally {
4277                        exitRule();
4278                }
4279                return _localctx;
4280        }
4281
4282        public static class ThTagCloseContext extends ParserRuleContext {
4283                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4284                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
4285                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
4286                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4287                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4288                public TerminalNode NEWLINE(int i) {
4289                        return getToken(JavadocParser.NEWLINE, i);
4290                }
4291                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4292                public TerminalNode LEADING_ASTERISK(int i) {
4293                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4294                }
4295                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4296                public TerminalNode WS(int i) {
4297                        return getToken(JavadocParser.WS, i);
4298                }
4299                public ThTagCloseContext(ParserRuleContext parent, int invokingState) {
4300                        super(parent, invokingState);
4301                }
4302                @Override public int getRuleIndex() { return RULE_thTagClose; }
4303                @Override
4304                public void enterRule(ParseTreeListener listener) {
4305                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagClose(this);
4306                }
4307                @Override
4308                public void exitRule(ParseTreeListener listener) {
4309                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagClose(this);
4310                }
4311                @Override
4312                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4313                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagClose(this);
4314                        else return visitor.visitChildren(this);
4315                }
4316        }
4317
4318        public final ThTagCloseContext thTagClose() throws RecognitionException {
4319                ThTagCloseContext _localctx = new ThTagCloseContext(_ctx, getState());
4320                enterRule(_localctx, 38, RULE_thTagClose);
4321                int _la;
4322                try {
4323                        enterOuterAlt(_localctx, 1);
4324                        {
4325                        setState(595);
4326                        match(OPEN);
4327                        setState(596);
4328                        match(SLASH);
4329                        setState(597);
4330                        match(TH_HTML_TAG_NAME);
4331                        setState(601);
4332                        _errHandler.sync(this);
4333                        _la = _input.LA(1);
4334                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
4335                                {
4336                                {
4337                                setState(598);
4338                                _la = _input.LA(1);
4339                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
4340                                _errHandler.recoverInline(this);
4341                                } else {
4342                                        consume();
4343                                }
4344                                }
4345                                }
4346                                setState(603);
4347                                _errHandler.sync(this);
4348                                _la = _input.LA(1);
4349                        }
4350                        setState(604);
4351                        match(CLOSE);
4352                        }
4353                }
4354                catch (RecognitionException re) {
4355                        _localctx.exception = re;
4356                        _errHandler.reportError(this, re);
4357                        _errHandler.recover(this, re);
4358                }
4359                finally {
4360                        exitRule();
4361                }
4362                return _localctx;
4363        }
4364
4365        public static class ThContext extends ParserRuleContext {
4366                public ThTagOpenContext thTagOpen() {
4367                        return getRuleContext(ThTagOpenContext.class,0);
4368                }
4369                public ThTagCloseContext thTagClose() {
4370                        return getRuleContext(ThTagCloseContext.class,0);
4371                }
4372                public List<HtmlTagContext> htmlTag() {
4373                        return getRuleContexts(HtmlTagContext.class);
4374                }
4375                public HtmlTagContext htmlTag(int i) {
4376                        return getRuleContext(HtmlTagContext.class,i);
4377                }
4378                public List<SingletonTagContext> singletonTag() {
4379                        return getRuleContexts(SingletonTagContext.class);
4380                }
4381                public SingletonTagContext singletonTag(int i) {
4382                        return getRuleContext(SingletonTagContext.class,i);
4383                }
4384                public List<ParagraphContext> paragraph() {
4385                        return getRuleContexts(ParagraphContext.class);
4386                }
4387                public ParagraphContext paragraph(int i) {
4388                        return getRuleContext(ParagraphContext.class,i);
4389                }
4390                public List<LiContext> li() {
4391                        return getRuleContexts(LiContext.class);
4392                }
4393                public LiContext li(int i) {
4394                        return getRuleContext(LiContext.class,i);
4395                }
4396                public List<TrContext> tr() {
4397                        return getRuleContexts(TrContext.class);
4398                }
4399                public TrContext tr(int i) {
4400                        return getRuleContext(TrContext.class,i);
4401                }
4402                public List<TdContext> td() {
4403                        return getRuleContexts(TdContext.class);
4404                }
4405                public TdContext td(int i) {
4406                        return getRuleContext(TdContext.class,i);
4407                }
4408                public List<BodyContext> body() {
4409                        return getRuleContexts(BodyContext.class);
4410                }
4411                public BodyContext body(int i) {
4412                        return getRuleContext(BodyContext.class,i);
4413                }
4414                public List<ColgroupContext> colgroup() {
4415                        return getRuleContexts(ColgroupContext.class);
4416                }
4417                public ColgroupContext colgroup(int i) {
4418                        return getRuleContext(ColgroupContext.class,i);
4419                }
4420                public List<DdContext> dd() {
4421                        return getRuleContexts(DdContext.class);
4422                }
4423                public DdContext dd(int i) {
4424                        return getRuleContext(DdContext.class,i);
4425                }
4426                public List<DtContext> dt() {
4427                        return getRuleContexts(DtContext.class);
4428                }
4429                public DtContext dt(int i) {
4430                        return getRuleContext(DtContext.class,i);
4431                }
4432                public List<HeadContext> head() {
4433                        return getRuleContexts(HeadContext.class);
4434                }
4435                public HeadContext head(int i) {
4436                        return getRuleContext(HeadContext.class,i);
4437                }
4438                public List<HtmlContext> html() {
4439                        return getRuleContexts(HtmlContext.class);
4440                }
4441                public HtmlContext html(int i) {
4442                        return getRuleContext(HtmlContext.class,i);
4443                }
4444                public List<OptionContext> option() {
4445                        return getRuleContexts(OptionContext.class);
4446                }
4447                public OptionContext option(int i) {
4448                        return getRuleContext(OptionContext.class,i);
4449                }
4450                public List<TbodyContext> tbody() {
4451                        return getRuleContexts(TbodyContext.class);
4452                }
4453                public TbodyContext tbody(int i) {
4454                        return getRuleContext(TbodyContext.class,i);
4455                }
4456                public List<TheadContext> thead() {
4457                        return getRuleContexts(TheadContext.class);
4458                }
4459                public TheadContext thead(int i) {
4460                        return getRuleContext(TheadContext.class,i);
4461                }
4462                public List<TfootContext> tfoot() {
4463                        return getRuleContexts(TfootContext.class);
4464                }
4465                public TfootContext tfoot(int i) {
4466                        return getRuleContext(TfootContext.class,i);
4467                }
4468                public List<PTagOpenContext> pTagOpen() {
4469                        return getRuleContexts(PTagOpenContext.class);
4470                }
4471                public PTagOpenContext pTagOpen(int i) {
4472                        return getRuleContext(PTagOpenContext.class,i);
4473                }
4474                public List<LiTagOpenContext> liTagOpen() {
4475                        return getRuleContexts(LiTagOpenContext.class);
4476                }
4477                public LiTagOpenContext liTagOpen(int i) {
4478                        return getRuleContext(LiTagOpenContext.class,i);
4479                }
4480                public List<TrTagOpenContext> trTagOpen() {
4481                        return getRuleContexts(TrTagOpenContext.class);
4482                }
4483                public TrTagOpenContext trTagOpen(int i) {
4484                        return getRuleContext(TrTagOpenContext.class,i);
4485                }
4486                public List<TdTagOpenContext> tdTagOpen() {
4487                        return getRuleContexts(TdTagOpenContext.class);
4488                }
4489                public TdTagOpenContext tdTagOpen(int i) {
4490                        return getRuleContext(TdTagOpenContext.class,i);
4491                }
4492                public List<BodyTagOpenContext> bodyTagOpen() {
4493                        return getRuleContexts(BodyTagOpenContext.class);
4494                }
4495                public BodyTagOpenContext bodyTagOpen(int i) {
4496                        return getRuleContext(BodyTagOpenContext.class,i);
4497                }
4498                public List<ColgroupTagOpenContext> colgroupTagOpen() {
4499                        return getRuleContexts(ColgroupTagOpenContext.class);
4500                }
4501                public ColgroupTagOpenContext colgroupTagOpen(int i) {
4502                        return getRuleContext(ColgroupTagOpenContext.class,i);
4503                }
4504                public List<DdTagOpenContext> ddTagOpen() {
4505                        return getRuleContexts(DdTagOpenContext.class);
4506                }
4507                public DdTagOpenContext ddTagOpen(int i) {
4508                        return getRuleContext(DdTagOpenContext.class,i);
4509                }
4510                public List<DtTagOpenContext> dtTagOpen() {
4511                        return getRuleContexts(DtTagOpenContext.class);
4512                }
4513                public DtTagOpenContext dtTagOpen(int i) {
4514                        return getRuleContext(DtTagOpenContext.class,i);
4515                }
4516                public List<HeadTagOpenContext> headTagOpen() {
4517                        return getRuleContexts(HeadTagOpenContext.class);
4518                }
4519                public HeadTagOpenContext headTagOpen(int i) {
4520                        return getRuleContext(HeadTagOpenContext.class,i);
4521                }
4522                public List<HtmlTagOpenContext> htmlTagOpen() {
4523                        return getRuleContexts(HtmlTagOpenContext.class);
4524                }
4525                public HtmlTagOpenContext htmlTagOpen(int i) {
4526                        return getRuleContext(HtmlTagOpenContext.class,i);
4527                }
4528                public List<OptionTagOpenContext> optionTagOpen() {
4529                        return getRuleContexts(OptionTagOpenContext.class);
4530                }
4531                public OptionTagOpenContext optionTagOpen(int i) {
4532                        return getRuleContext(OptionTagOpenContext.class,i);
4533                }
4534                public List<TbodyTagOpenContext> tbodyTagOpen() {
4535                        return getRuleContexts(TbodyTagOpenContext.class);
4536                }
4537                public TbodyTagOpenContext tbodyTagOpen(int i) {
4538                        return getRuleContext(TbodyTagOpenContext.class,i);
4539                }
4540                public List<TheadTagOpenContext> theadTagOpen() {
4541                        return getRuleContexts(TheadTagOpenContext.class);
4542                }
4543                public TheadTagOpenContext theadTagOpen(int i) {
4544                        return getRuleContext(TheadTagOpenContext.class,i);
4545                }
4546                public List<TfootTagOpenContext> tfootTagOpen() {
4547                        return getRuleContexts(TfootTagOpenContext.class);
4548                }
4549                public TfootTagOpenContext tfootTagOpen(int i) {
4550                        return getRuleContext(TfootTagOpenContext.class,i);
4551                }
4552                public List<HtmlCommentContext> htmlComment() {
4553                        return getRuleContexts(HtmlCommentContext.class);
4554                }
4555                public HtmlCommentContext htmlComment(int i) {
4556                        return getRuleContext(HtmlCommentContext.class,i);
4557                }
4558                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
4559                public TerminalNode CDATA(int i) {
4560                        return getToken(JavadocParser.CDATA, i);
4561                }
4562                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4563                public TerminalNode NEWLINE(int i) {
4564                        return getToken(JavadocParser.NEWLINE, i);
4565                }
4566                public List<TextContext> text() {
4567                        return getRuleContexts(TextContext.class);
4568                }
4569                public TextContext text(int i) {
4570                        return getRuleContext(TextContext.class,i);
4571                }
4572                public List<JavadocInlineTagContext> javadocInlineTag() {
4573                        return getRuleContexts(JavadocInlineTagContext.class);
4574                }
4575                public JavadocInlineTagContext javadocInlineTag(int i) {
4576                        return getRuleContext(JavadocInlineTagContext.class,i);
4577                }
4578                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4579                public TerminalNode LEADING_ASTERISK(int i) {
4580                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4581                }
4582                public ThContext(ParserRuleContext parent, int invokingState) {
4583                        super(parent, invokingState);
4584                }
4585                @Override public int getRuleIndex() { return RULE_th; }
4586                @Override
4587                public void enterRule(ParseTreeListener listener) {
4588                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTh(this);
4589                }
4590                @Override
4591                public void exitRule(ParseTreeListener listener) {
4592                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTh(this);
4593                }
4594                @Override
4595                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4596                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTh(this);
4597                        else return visitor.visitChildren(this);
4598                }
4599        }
4600
4601        public final ThContext th() throws RecognitionException {
4602                ThContext _localctx = new ThContext(_ctx, getState());
4603                enterRule(_localctx, 40, RULE_th);
4604                try {
4605                        int _alt;
4606                        enterOuterAlt(_localctx, 1);
4607                        {
4608                        setState(606);
4609                        thTagOpen();
4610                        setState(646);
4611                        _errHandler.sync(this);
4612                        _alt = getInterpreter().adaptivePredict(_input,41,_ctx);
4613                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
4614                                if ( _alt==1 ) {
4615                                        {
4616                                        setState(644);
4617                                        _errHandler.sync(this);
4618                                        switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
4619                                        case 1:
4620                                                {
4621                                                setState(607);
4622                                                htmlTag();
4623                                                }
4624                                                break;
4625                                        case 2:
4626                                                {
4627                                                setState(608);
4628                                                singletonTag();
4629                                                }
4630                                                break;
4631                                        case 3:
4632                                                {
4633                                                setState(609);
4634                                                paragraph();
4635                                                }
4636                                                break;
4637                                        case 4:
4638                                                {
4639                                                setState(610);
4640                                                li();
4641                                                }
4642                                                break;
4643                                        case 5:
4644                                                {
4645                                                setState(611);
4646                                                tr();
4647                                                }
4648                                                break;
4649                                        case 6:
4650                                                {
4651                                                setState(612);
4652                                                td();
4653                                                }
4654                                                break;
4655                                        case 7:
4656                                                {
4657                                                setState(613);
4658                                                body();
4659                                                }
4660                                                break;
4661                                        case 8:
4662                                                {
4663                                                setState(614);
4664                                                colgroup();
4665                                                }
4666                                                break;
4667                                        case 9:
4668                                                {
4669                                                setState(615);
4670                                                dd();
4671                                                }
4672                                                break;
4673                                        case 10:
4674                                                {
4675                                                setState(616);
4676                                                dt();
4677                                                }
4678                                                break;
4679                                        case 11:
4680                                                {
4681                                                setState(617);
4682                                                head();
4683                                                }
4684                                                break;
4685                                        case 12:
4686                                                {
4687                                                setState(618);
4688                                                html();
4689                                                }
4690                                                break;
4691                                        case 13:
4692                                                {
4693                                                setState(619);
4694                                                option();
4695                                                }
4696                                                break;
4697                                        case 14:
4698                                                {
4699                                                setState(620);
4700                                                tbody();
4701                                                }
4702                                                break;
4703                                        case 15:
4704                                                {
4705                                                setState(621);
4706                                                thead();
4707                                                }
4708                                                break;
4709                                        case 16:
4710                                                {
4711                                                setState(622);
4712                                                tfoot();
4713                                                }
4714                                                break;
4715                                        case 17:
4716                                                {
4717                                                setState(623);
4718                                                pTagOpen();
4719                                                }
4720                                                break;
4721                                        case 18:
4722                                                {
4723                                                setState(624);
4724                                                liTagOpen();
4725                                                }
4726                                                break;
4727                                        case 19:
4728                                                {
4729                                                setState(625);
4730                                                trTagOpen();
4731                                                }
4732                                                break;
4733                                        case 20:
4734                                                {
4735                                                setState(626);
4736                                                tdTagOpen();
4737                                                }
4738                                                break;
4739                                        case 21:
4740                                                {
4741                                                setState(627);
4742                                                bodyTagOpen();
4743                                                }
4744                                                break;
4745                                        case 22:
4746                                                {
4747                                                setState(628);
4748                                                colgroupTagOpen();
4749                                                }
4750                                                break;
4751                                        case 23:
4752                                                {
4753                                                setState(629);
4754                                                ddTagOpen();
4755                                                }
4756                                                break;
4757                                        case 24:
4758                                                {
4759                                                setState(630);
4760                                                dtTagOpen();
4761                                                }
4762                                                break;
4763                                        case 25:
4764                                                {
4765                                                setState(631);
4766                                                headTagOpen();
4767                                                }
4768                                                break;
4769                                        case 26:
4770                                                {
4771                                                setState(632);
4772                                                htmlTagOpen();
4773                                                }
4774                                                break;
4775                                        case 27:
4776                                                {
4777                                                setState(633);
4778                                                optionTagOpen();
4779                                                }
4780                                                break;
4781                                        case 28:
4782                                                {
4783                                                setState(634);
4784                                                tbodyTagOpen();
4785                                                }
4786                                                break;
4787                                        case 29:
4788                                                {
4789                                                setState(635);
4790                                                theadTagOpen();
4791                                                }
4792                                                break;
4793                                        case 30:
4794                                                {
4795                                                setState(636);
4796                                                tfootTagOpen();
4797                                                }
4798                                                break;
4799                                        case 31:
4800                                                {
4801                                                {
4802                                                setState(637);
4803                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
4804                                                setState(638);
4805                                                match(LEADING_ASTERISK);
4806                                                }
4807                                                }
4808                                                break;
4809                                        case 32:
4810                                                {
4811                                                setState(639);
4812                                                htmlComment();
4813                                                }
4814                                                break;
4815                                        case 33:
4816                                                {
4817                                                setState(640);
4818                                                match(CDATA);
4819                                                }
4820                                                break;
4821                                        case 34:
4822                                                {
4823                                                setState(641);
4824                                                match(NEWLINE);
4825                                                }
4826                                                break;
4827                                        case 35:
4828                                                {
4829                                                setState(642);
4830                                                text();
4831                                                }
4832                                                break;
4833                                        case 36:
4834                                                {
4835                                                setState(643);
4836                                                javadocInlineTag();
4837                                                }
4838                                                break;
4839                                        }
4840                                        } 
4841                                }
4842                                setState(648);
4843                                _errHandler.sync(this);
4844                                _alt = getInterpreter().adaptivePredict(_input,41,_ctx);
4845                        }
4846                        setState(649);
4847                        thTagClose();
4848                        }
4849                }
4850                catch (RecognitionException re) {
4851                        _localctx.exception = re;
4852                        _errHandler.reportError(this, re);
4853                        _errHandler.recover(this, re);
4854                }
4855                finally {
4856                        exitRule();
4857                }
4858                return _localctx;
4859        }
4860
4861        public static class BodyTagOpenContext extends ParserRuleContext {
4862                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4863                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
4864                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4865                public List<AttributeContext> attribute() {
4866                        return getRuleContexts(AttributeContext.class);
4867                }
4868                public AttributeContext attribute(int i) {
4869                        return getRuleContext(AttributeContext.class,i);
4870                }
4871                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4872                public TerminalNode NEWLINE(int i) {
4873                        return getToken(JavadocParser.NEWLINE, i);
4874                }
4875                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4876                public TerminalNode LEADING_ASTERISK(int i) {
4877                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4878                }
4879                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4880                public TerminalNode WS(int i) {
4881                        return getToken(JavadocParser.WS, i);
4882                }
4883                public BodyTagOpenContext(ParserRuleContext parent, int invokingState) {
4884                        super(parent, invokingState);
4885                }
4886                @Override public int getRuleIndex() { return RULE_bodyTagOpen; }
4887                @Override
4888                public void enterRule(ParseTreeListener listener) {
4889                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagOpen(this);
4890                }
4891                @Override
4892                public void exitRule(ParseTreeListener listener) {
4893                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagOpen(this);
4894                }
4895                @Override
4896                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4897                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagOpen(this);
4898                        else return visitor.visitChildren(this);
4899                }
4900        }
4901
4902        public final BodyTagOpenContext bodyTagOpen() throws RecognitionException {
4903                BodyTagOpenContext _localctx = new BodyTagOpenContext(_ctx, getState());
4904                enterRule(_localctx, 42, RULE_bodyTagOpen);
4905                int _la;
4906                try {
4907                        enterOuterAlt(_localctx, 1);
4908                        {
4909                        setState(651);
4910                        match(OPEN);
4911                        setState(652);
4912                        match(BODY_HTML_TAG_NAME);
4913                        setState(659);
4914                        _errHandler.sync(this);
4915                        _la = _input.LA(1);
4916                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
4917                                {
4918                                setState(657);
4919                                switch (_input.LA(1)) {
4920                                case HTML_TAG_NAME:
4921                                        {
4922                                        setState(653);
4923                                        attribute();
4924                                        }
4925                                        break;
4926                                case NEWLINE:
4927                                        {
4928                                        setState(654);
4929                                        match(NEWLINE);
4930                                        }
4931                                        break;
4932                                case LEADING_ASTERISK:
4933                                        {
4934                                        setState(655);
4935                                        match(LEADING_ASTERISK);
4936                                        }
4937                                        break;
4938                                case WS:
4939                                        {
4940                                        setState(656);
4941                                        match(WS);
4942                                        }
4943                                        break;
4944                                default:
4945                                        throw new NoViableAltException(this);
4946                                }
4947                                }
4948                                setState(661);
4949                                _errHandler.sync(this);
4950                                _la = _input.LA(1);
4951                        }
4952                        setState(662);
4953                        match(CLOSE);
4954                        }
4955                }
4956                catch (RecognitionException re) {
4957                        _localctx.exception = re;
4958                        _errHandler.reportError(this, re);
4959                        _errHandler.recover(this, re);
4960                }
4961                finally {
4962                        exitRule();
4963                }
4964                return _localctx;
4965        }
4966
4967        public static class BodyTagCloseContext extends ParserRuleContext {
4968                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4969                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
4970                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
4971                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4972                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4973                public TerminalNode NEWLINE(int i) {
4974                        return getToken(JavadocParser.NEWLINE, i);
4975                }
4976                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4977                public TerminalNode LEADING_ASTERISK(int i) {
4978                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4979                }
4980                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4981                public TerminalNode WS(int i) {
4982                        return getToken(JavadocParser.WS, i);
4983                }
4984                public BodyTagCloseContext(ParserRuleContext parent, int invokingState) {
4985                        super(parent, invokingState);
4986                }
4987                @Override public int getRuleIndex() { return RULE_bodyTagClose; }
4988                @Override
4989                public void enterRule(ParseTreeListener listener) {
4990                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagClose(this);
4991                }
4992                @Override
4993                public void exitRule(ParseTreeListener listener) {
4994                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagClose(this);
4995                }
4996                @Override
4997                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4998                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagClose(this);
4999                        else return visitor.visitChildren(this);
5000                }
5001        }
5002
5003        public final BodyTagCloseContext bodyTagClose() throws RecognitionException {
5004                BodyTagCloseContext _localctx = new BodyTagCloseContext(_ctx, getState());
5005                enterRule(_localctx, 44, RULE_bodyTagClose);
5006                int _la;
5007                try {
5008                        enterOuterAlt(_localctx, 1);
5009                        {
5010                        setState(664);
5011                        match(OPEN);
5012                        setState(665);
5013                        match(SLASH);
5014                        setState(666);
5015                        match(BODY_HTML_TAG_NAME);
5016                        setState(670);
5017                        _errHandler.sync(this);
5018                        _la = _input.LA(1);
5019                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
5020                                {
5021                                {
5022                                setState(667);
5023                                _la = _input.LA(1);
5024                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
5025                                _errHandler.recoverInline(this);
5026                                } else {
5027                                        consume();
5028                                }
5029                                }
5030                                }
5031                                setState(672);
5032                                _errHandler.sync(this);
5033                                _la = _input.LA(1);
5034                        }
5035                        setState(673);
5036                        match(CLOSE);
5037                        }
5038                }
5039                catch (RecognitionException re) {
5040                        _localctx.exception = re;
5041                        _errHandler.reportError(this, re);
5042                        _errHandler.recover(this, re);
5043                }
5044                finally {
5045                        exitRule();
5046                }
5047                return _localctx;
5048        }
5049
5050        public static class BodyContext extends ParserRuleContext {
5051                public BodyTagOpenContext bodyTagOpen() {
5052                        return getRuleContext(BodyTagOpenContext.class,0);
5053                }
5054                public BodyTagCloseContext bodyTagClose() {
5055                        return getRuleContext(BodyTagCloseContext.class,0);
5056                }
5057                public List<HtmlTagContext> htmlTag() {
5058                        return getRuleContexts(HtmlTagContext.class);
5059                }
5060                public HtmlTagContext htmlTag(int i) {
5061                        return getRuleContext(HtmlTagContext.class,i);
5062                }
5063                public List<SingletonTagContext> singletonTag() {
5064                        return getRuleContexts(SingletonTagContext.class);
5065                }
5066                public SingletonTagContext singletonTag(int i) {
5067                        return getRuleContext(SingletonTagContext.class,i);
5068                }
5069                public List<ParagraphContext> paragraph() {
5070                        return getRuleContexts(ParagraphContext.class);
5071                }
5072                public ParagraphContext paragraph(int i) {
5073                        return getRuleContext(ParagraphContext.class,i);
5074                }
5075                public List<LiContext> li() {
5076                        return getRuleContexts(LiContext.class);
5077                }
5078                public LiContext li(int i) {
5079                        return getRuleContext(LiContext.class,i);
5080                }
5081                public List<TrContext> tr() {
5082                        return getRuleContexts(TrContext.class);
5083                }
5084                public TrContext tr(int i) {
5085                        return getRuleContext(TrContext.class,i);
5086                }
5087                public List<TdContext> td() {
5088                        return getRuleContexts(TdContext.class);
5089                }
5090                public TdContext td(int i) {
5091                        return getRuleContext(TdContext.class,i);
5092                }
5093                public List<ThContext> th() {
5094                        return getRuleContexts(ThContext.class);
5095                }
5096                public ThContext th(int i) {
5097                        return getRuleContext(ThContext.class,i);
5098                }
5099                public List<ColgroupContext> colgroup() {
5100                        return getRuleContexts(ColgroupContext.class);
5101                }
5102                public ColgroupContext colgroup(int i) {
5103                        return getRuleContext(ColgroupContext.class,i);
5104                }
5105                public List<DdContext> dd() {
5106                        return getRuleContexts(DdContext.class);
5107                }
5108                public DdContext dd(int i) {
5109                        return getRuleContext(DdContext.class,i);
5110                }
5111                public List<DtContext> dt() {
5112                        return getRuleContexts(DtContext.class);
5113                }
5114                public DtContext dt(int i) {
5115                        return getRuleContext(DtContext.class,i);
5116                }
5117                public List<HeadContext> head() {
5118                        return getRuleContexts(HeadContext.class);
5119                }
5120                public HeadContext head(int i) {
5121                        return getRuleContext(HeadContext.class,i);
5122                }
5123                public List<HtmlContext> html() {
5124                        return getRuleContexts(HtmlContext.class);
5125                }
5126                public HtmlContext html(int i) {
5127                        return getRuleContext(HtmlContext.class,i);
5128                }
5129                public List<OptionContext> option() {
5130                        return getRuleContexts(OptionContext.class);
5131                }
5132                public OptionContext option(int i) {
5133                        return getRuleContext(OptionContext.class,i);
5134                }
5135                public List<TbodyContext> tbody() {
5136                        return getRuleContexts(TbodyContext.class);
5137                }
5138                public TbodyContext tbody(int i) {
5139                        return getRuleContext(TbodyContext.class,i);
5140                }
5141                public List<TheadContext> thead() {
5142                        return getRuleContexts(TheadContext.class);
5143                }
5144                public TheadContext thead(int i) {
5145                        return getRuleContext(TheadContext.class,i);
5146                }
5147                public List<TfootContext> tfoot() {
5148                        return getRuleContexts(TfootContext.class);
5149                }
5150                public TfootContext tfoot(int i) {
5151                        return getRuleContext(TfootContext.class,i);
5152                }
5153                public List<PTagOpenContext> pTagOpen() {
5154                        return getRuleContexts(PTagOpenContext.class);
5155                }
5156                public PTagOpenContext pTagOpen(int i) {
5157                        return getRuleContext(PTagOpenContext.class,i);
5158                }
5159                public List<LiTagOpenContext> liTagOpen() {
5160                        return getRuleContexts(LiTagOpenContext.class);
5161                }
5162                public LiTagOpenContext liTagOpen(int i) {
5163                        return getRuleContext(LiTagOpenContext.class,i);
5164                }
5165                public List<TrTagOpenContext> trTagOpen() {
5166                        return getRuleContexts(TrTagOpenContext.class);
5167                }
5168                public TrTagOpenContext trTagOpen(int i) {
5169                        return getRuleContext(TrTagOpenContext.class,i);
5170                }
5171                public List<TdTagOpenContext> tdTagOpen() {
5172                        return getRuleContexts(TdTagOpenContext.class);
5173                }
5174                public TdTagOpenContext tdTagOpen(int i) {
5175                        return getRuleContext(TdTagOpenContext.class,i);
5176                }
5177                public List<ThTagOpenContext> thTagOpen() {
5178                        return getRuleContexts(ThTagOpenContext.class);
5179                }
5180                public ThTagOpenContext thTagOpen(int i) {
5181                        return getRuleContext(ThTagOpenContext.class,i);
5182                }
5183                public List<ColgroupTagOpenContext> colgroupTagOpen() {
5184                        return getRuleContexts(ColgroupTagOpenContext.class);
5185                }
5186                public ColgroupTagOpenContext colgroupTagOpen(int i) {
5187                        return getRuleContext(ColgroupTagOpenContext.class,i);
5188                }
5189                public List<DdTagOpenContext> ddTagOpen() {
5190                        return getRuleContexts(DdTagOpenContext.class);
5191                }
5192                public DdTagOpenContext ddTagOpen(int i) {
5193                        return getRuleContext(DdTagOpenContext.class,i);
5194                }
5195                public List<DtTagOpenContext> dtTagOpen() {
5196                        return getRuleContexts(DtTagOpenContext.class);
5197                }
5198                public DtTagOpenContext dtTagOpen(int i) {
5199                        return getRuleContext(DtTagOpenContext.class,i);
5200                }
5201                public List<HeadTagOpenContext> headTagOpen() {
5202                        return getRuleContexts(HeadTagOpenContext.class);
5203                }
5204                public HeadTagOpenContext headTagOpen(int i) {
5205                        return getRuleContext(HeadTagOpenContext.class,i);
5206                }
5207                public List<HtmlTagOpenContext> htmlTagOpen() {
5208                        return getRuleContexts(HtmlTagOpenContext.class);
5209                }
5210                public HtmlTagOpenContext htmlTagOpen(int i) {
5211                        return getRuleContext(HtmlTagOpenContext.class,i);
5212                }
5213                public List<OptionTagOpenContext> optionTagOpen() {
5214                        return getRuleContexts(OptionTagOpenContext.class);
5215                }
5216                public OptionTagOpenContext optionTagOpen(int i) {
5217                        return getRuleContext(OptionTagOpenContext.class,i);
5218                }
5219                public List<TbodyTagOpenContext> tbodyTagOpen() {
5220                        return getRuleContexts(TbodyTagOpenContext.class);
5221                }
5222                public TbodyTagOpenContext tbodyTagOpen(int i) {
5223                        return getRuleContext(TbodyTagOpenContext.class,i);
5224                }
5225                public List<TheadTagOpenContext> theadTagOpen() {
5226                        return getRuleContexts(TheadTagOpenContext.class);
5227                }
5228                public TheadTagOpenContext theadTagOpen(int i) {
5229                        return getRuleContext(TheadTagOpenContext.class,i);
5230                }
5231                public List<TfootTagOpenContext> tfootTagOpen() {
5232                        return getRuleContexts(TfootTagOpenContext.class);
5233                }
5234                public TfootTagOpenContext tfootTagOpen(int i) {
5235                        return getRuleContext(TfootTagOpenContext.class,i);
5236                }
5237                public List<HtmlCommentContext> htmlComment() {
5238                        return getRuleContexts(HtmlCommentContext.class);
5239                }
5240                public HtmlCommentContext htmlComment(int i) {
5241                        return getRuleContext(HtmlCommentContext.class,i);
5242                }
5243                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
5244                public TerminalNode CDATA(int i) {
5245                        return getToken(JavadocParser.CDATA, i);
5246                }
5247                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5248                public TerminalNode NEWLINE(int i) {
5249                        return getToken(JavadocParser.NEWLINE, i);
5250                }
5251                public List<TextContext> text() {
5252                        return getRuleContexts(TextContext.class);
5253                }
5254                public TextContext text(int i) {
5255                        return getRuleContext(TextContext.class,i);
5256                }
5257                public List<JavadocInlineTagContext> javadocInlineTag() {
5258                        return getRuleContexts(JavadocInlineTagContext.class);
5259                }
5260                public JavadocInlineTagContext javadocInlineTag(int i) {
5261                        return getRuleContext(JavadocInlineTagContext.class,i);
5262                }
5263                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5264                public TerminalNode LEADING_ASTERISK(int i) {
5265                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5266                }
5267                public BodyContext(ParserRuleContext parent, int invokingState) {
5268                        super(parent, invokingState);
5269                }
5270                @Override public int getRuleIndex() { return RULE_body; }
5271                @Override
5272                public void enterRule(ParseTreeListener listener) {
5273                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBody(this);
5274                }
5275                @Override
5276                public void exitRule(ParseTreeListener listener) {
5277                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBody(this);
5278                }
5279                @Override
5280                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5281                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBody(this);
5282                        else return visitor.visitChildren(this);
5283                }
5284        }
5285
5286        public final BodyContext body() throws RecognitionException {
5287                BodyContext _localctx = new BodyContext(_ctx, getState());
5288                enterRule(_localctx, 46, RULE_body);
5289                try {
5290                        int _alt;
5291                        enterOuterAlt(_localctx, 1);
5292                        {
5293                        setState(675);
5294                        bodyTagOpen();
5295                        setState(715);
5296                        _errHandler.sync(this);
5297                        _alt = getInterpreter().adaptivePredict(_input,46,_ctx);
5298                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5299                                if ( _alt==1 ) {
5300                                        {
5301                                        setState(713);
5302                                        _errHandler.sync(this);
5303                                        switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
5304                                        case 1:
5305                                                {
5306                                                setState(676);
5307                                                htmlTag();
5308                                                }
5309                                                break;
5310                                        case 2:
5311                                                {
5312                                                setState(677);
5313                                                singletonTag();
5314                                                }
5315                                                break;
5316                                        case 3:
5317                                                {
5318                                                setState(678);
5319                                                paragraph();
5320                                                }
5321                                                break;
5322                                        case 4:
5323                                                {
5324                                                setState(679);
5325                                                li();
5326                                                }
5327                                                break;
5328                                        case 5:
5329                                                {
5330                                                setState(680);
5331                                                tr();
5332                                                }
5333                                                break;
5334                                        case 6:
5335                                                {
5336                                                setState(681);
5337                                                td();
5338                                                }
5339                                                break;
5340                                        case 7:
5341                                                {
5342                                                setState(682);
5343                                                th();
5344                                                }
5345                                                break;
5346                                        case 8:
5347                                                {
5348                                                setState(683);
5349                                                colgroup();
5350                                                }
5351                                                break;
5352                                        case 9:
5353                                                {
5354                                                setState(684);
5355                                                dd();
5356                                                }
5357                                                break;
5358                                        case 10:
5359                                                {
5360                                                setState(685);
5361                                                dt();
5362                                                }
5363                                                break;
5364                                        case 11:
5365                                                {
5366                                                setState(686);
5367                                                head();
5368                                                }
5369                                                break;
5370                                        case 12:
5371                                                {
5372                                                setState(687);
5373                                                html();
5374                                                }
5375                                                break;
5376                                        case 13:
5377                                                {
5378                                                setState(688);
5379                                                option();
5380                                                }
5381                                                break;
5382                                        case 14:
5383                                                {
5384                                                setState(689);
5385                                                tbody();
5386                                                }
5387                                                break;
5388                                        case 15:
5389                                                {
5390                                                setState(690);
5391                                                thead();
5392                                                }
5393                                                break;
5394                                        case 16:
5395                                                {
5396                                                setState(691);
5397                                                tfoot();
5398                                                }
5399                                                break;
5400                                        case 17:
5401                                                {
5402                                                setState(692);
5403                                                pTagOpen();
5404                                                }
5405                                                break;
5406                                        case 18:
5407                                                {
5408                                                setState(693);
5409                                                liTagOpen();
5410                                                }
5411                                                break;
5412                                        case 19:
5413                                                {
5414                                                setState(694);
5415                                                trTagOpen();
5416                                                }
5417                                                break;
5418                                        case 20:
5419                                                {
5420                                                setState(695);
5421                                                tdTagOpen();
5422                                                }
5423                                                break;
5424                                        case 21:
5425                                                {
5426                                                setState(696);
5427                                                thTagOpen();
5428                                                }
5429                                                break;
5430                                        case 22:
5431                                                {
5432                                                setState(697);
5433                                                colgroupTagOpen();
5434                                                }
5435                                                break;
5436                                        case 23:
5437                                                {
5438                                                setState(698);
5439                                                ddTagOpen();
5440                                                }
5441                                                break;
5442                                        case 24:
5443                                                {
5444                                                setState(699);
5445                                                dtTagOpen();
5446                                                }
5447                                                break;
5448                                        case 25:
5449                                                {
5450                                                setState(700);
5451                                                headTagOpen();
5452                                                }
5453                                                break;
5454                                        case 26:
5455                                                {
5456                                                setState(701);
5457                                                htmlTagOpen();
5458                                                }
5459                                                break;
5460                                        case 27:
5461                                                {
5462                                                setState(702);
5463                                                optionTagOpen();
5464                                                }
5465                                                break;
5466                                        case 28:
5467                                                {
5468                                                setState(703);
5469                                                tbodyTagOpen();
5470                                                }
5471                                                break;
5472                                        case 29:
5473                                                {
5474                                                setState(704);
5475                                                theadTagOpen();
5476                                                }
5477                                                break;
5478                                        case 30:
5479                                                {
5480                                                setState(705);
5481                                                tfootTagOpen();
5482                                                }
5483                                                break;
5484                                        case 31:
5485                                                {
5486                                                {
5487                                                setState(706);
5488                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
5489                                                setState(707);
5490                                                match(LEADING_ASTERISK);
5491                                                }
5492                                                }
5493                                                break;
5494                                        case 32:
5495                                                {
5496                                                setState(708);
5497                                                htmlComment();
5498                                                }
5499                                                break;
5500                                        case 33:
5501                                                {
5502                                                setState(709);
5503                                                match(CDATA);
5504                                                }
5505                                                break;
5506                                        case 34:
5507                                                {
5508                                                setState(710);
5509                                                match(NEWLINE);
5510                                                }
5511                                                break;
5512                                        case 35:
5513                                                {
5514                                                setState(711);
5515                                                text();
5516                                                }
5517                                                break;
5518                                        case 36:
5519                                                {
5520                                                setState(712);
5521                                                javadocInlineTag();
5522                                                }
5523                                                break;
5524                                        }
5525                                        } 
5526                                }
5527                                setState(717);
5528                                _errHandler.sync(this);
5529                                _alt = getInterpreter().adaptivePredict(_input,46,_ctx);
5530                        }
5531                        setState(718);
5532                        bodyTagClose();
5533                        }
5534                }
5535                catch (RecognitionException re) {
5536                        _localctx.exception = re;
5537                        _errHandler.reportError(this, re);
5538                        _errHandler.recover(this, re);
5539                }
5540                finally {
5541                        exitRule();
5542                }
5543                return _localctx;
5544        }
5545
5546        public static class ColgroupTagOpenContext extends ParserRuleContext {
5547                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
5548                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5549                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
5550                public List<AttributeContext> attribute() {
5551                        return getRuleContexts(AttributeContext.class);
5552                }
5553                public AttributeContext attribute(int i) {
5554                        return getRuleContext(AttributeContext.class,i);
5555                }
5556                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5557                public TerminalNode NEWLINE(int i) {
5558                        return getToken(JavadocParser.NEWLINE, i);
5559                }
5560                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5561                public TerminalNode LEADING_ASTERISK(int i) {
5562                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5563                }
5564                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5565                public TerminalNode WS(int i) {
5566                        return getToken(JavadocParser.WS, i);
5567                }
5568                public ColgroupTagOpenContext(ParserRuleContext parent, int invokingState) {
5569                        super(parent, invokingState);
5570                }
5571                @Override public int getRuleIndex() { return RULE_colgroupTagOpen; }
5572                @Override
5573                public void enterRule(ParseTreeListener listener) {
5574                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagOpen(this);
5575                }
5576                @Override
5577                public void exitRule(ParseTreeListener listener) {
5578                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagOpen(this);
5579                }
5580                @Override
5581                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5582                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagOpen(this);
5583                        else return visitor.visitChildren(this);
5584                }
5585        }
5586
5587        public final ColgroupTagOpenContext colgroupTagOpen() throws RecognitionException {
5588                ColgroupTagOpenContext _localctx = new ColgroupTagOpenContext(_ctx, getState());
5589                enterRule(_localctx, 48, RULE_colgroupTagOpen);
5590                int _la;
5591                try {
5592                        enterOuterAlt(_localctx, 1);
5593                        {
5594                        setState(720);
5595                        match(OPEN);
5596                        setState(721);
5597                        match(COLGROUP_HTML_TAG_NAME);
5598                        setState(728);
5599                        _errHandler.sync(this);
5600                        _la = _input.LA(1);
5601                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
5602                                {
5603                                setState(726);
5604                                switch (_input.LA(1)) {
5605                                case HTML_TAG_NAME:
5606                                        {
5607                                        setState(722);
5608                                        attribute();
5609                                        }
5610                                        break;
5611                                case NEWLINE:
5612                                        {
5613                                        setState(723);
5614                                        match(NEWLINE);
5615                                        }
5616                                        break;
5617                                case LEADING_ASTERISK:
5618                                        {
5619                                        setState(724);
5620                                        match(LEADING_ASTERISK);
5621                                        }
5622                                        break;
5623                                case WS:
5624                                        {
5625                                        setState(725);
5626                                        match(WS);
5627                                        }
5628                                        break;
5629                                default:
5630                                        throw new NoViableAltException(this);
5631                                }
5632                                }
5633                                setState(730);
5634                                _errHandler.sync(this);
5635                                _la = _input.LA(1);
5636                        }
5637                        setState(731);
5638                        match(CLOSE);
5639                        }
5640                }
5641                catch (RecognitionException re) {
5642                        _localctx.exception = re;
5643                        _errHandler.reportError(this, re);
5644                        _errHandler.recover(this, re);
5645                }
5646                finally {
5647                        exitRule();
5648                }
5649                return _localctx;
5650        }
5651
5652        public static class ColgroupTagCloseContext extends ParserRuleContext {
5653                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
5654                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
5655                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5656                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
5657                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5658                public TerminalNode NEWLINE(int i) {
5659                        return getToken(JavadocParser.NEWLINE, i);
5660                }
5661                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5662                public TerminalNode LEADING_ASTERISK(int i) {
5663                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5664                }
5665                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5666                public TerminalNode WS(int i) {
5667                        return getToken(JavadocParser.WS, i);
5668                }
5669                public ColgroupTagCloseContext(ParserRuleContext parent, int invokingState) {
5670                        super(parent, invokingState);
5671                }
5672                @Override public int getRuleIndex() { return RULE_colgroupTagClose; }
5673                @Override
5674                public void enterRule(ParseTreeListener listener) {
5675                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagClose(this);
5676                }
5677                @Override
5678                public void exitRule(ParseTreeListener listener) {
5679                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagClose(this);
5680                }
5681                @Override
5682                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5683                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagClose(this);
5684                        else return visitor.visitChildren(this);
5685                }
5686        }
5687
5688        public final ColgroupTagCloseContext colgroupTagClose() throws RecognitionException {
5689                ColgroupTagCloseContext _localctx = new ColgroupTagCloseContext(_ctx, getState());
5690                enterRule(_localctx, 50, RULE_colgroupTagClose);
5691                int _la;
5692                try {
5693                        enterOuterAlt(_localctx, 1);
5694                        {
5695                        setState(733);
5696                        match(OPEN);
5697                        setState(734);
5698                        match(SLASH);
5699                        setState(735);
5700                        match(COLGROUP_HTML_TAG_NAME);
5701                        setState(739);
5702                        _errHandler.sync(this);
5703                        _la = _input.LA(1);
5704                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
5705                                {
5706                                {
5707                                setState(736);
5708                                _la = _input.LA(1);
5709                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
5710                                _errHandler.recoverInline(this);
5711                                } else {
5712                                        consume();
5713                                }
5714                                }
5715                                }
5716                                setState(741);
5717                                _errHandler.sync(this);
5718                                _la = _input.LA(1);
5719                        }
5720                        setState(742);
5721                        match(CLOSE);
5722                        }
5723                }
5724                catch (RecognitionException re) {
5725                        _localctx.exception = re;
5726                        _errHandler.reportError(this, re);
5727                        _errHandler.recover(this, re);
5728                }
5729                finally {
5730                        exitRule();
5731                }
5732                return _localctx;
5733        }
5734
5735        public static class ColgroupContext extends ParserRuleContext {
5736                public ColgroupTagOpenContext colgroupTagOpen() {
5737                        return getRuleContext(ColgroupTagOpenContext.class,0);
5738                }
5739                public ColgroupTagCloseContext colgroupTagClose() {
5740                        return getRuleContext(ColgroupTagCloseContext.class,0);
5741                }
5742                public List<HtmlTagContext> htmlTag() {
5743                        return getRuleContexts(HtmlTagContext.class);
5744                }
5745                public HtmlTagContext htmlTag(int i) {
5746                        return getRuleContext(HtmlTagContext.class,i);
5747                }
5748                public List<SingletonTagContext> singletonTag() {
5749                        return getRuleContexts(SingletonTagContext.class);
5750                }
5751                public SingletonTagContext singletonTag(int i) {
5752                        return getRuleContext(SingletonTagContext.class,i);
5753                }
5754                public List<ParagraphContext> paragraph() {
5755                        return getRuleContexts(ParagraphContext.class);
5756                }
5757                public ParagraphContext paragraph(int i) {
5758                        return getRuleContext(ParagraphContext.class,i);
5759                }
5760                public List<LiContext> li() {
5761                        return getRuleContexts(LiContext.class);
5762                }
5763                public LiContext li(int i) {
5764                        return getRuleContext(LiContext.class,i);
5765                }
5766                public List<TrContext> tr() {
5767                        return getRuleContexts(TrContext.class);
5768                }
5769                public TrContext tr(int i) {
5770                        return getRuleContext(TrContext.class,i);
5771                }
5772                public List<TdContext> td() {
5773                        return getRuleContexts(TdContext.class);
5774                }
5775                public TdContext td(int i) {
5776                        return getRuleContext(TdContext.class,i);
5777                }
5778                public List<ThContext> th() {
5779                        return getRuleContexts(ThContext.class);
5780                }
5781                public ThContext th(int i) {
5782                        return getRuleContext(ThContext.class,i);
5783                }
5784                public List<BodyContext> body() {
5785                        return getRuleContexts(BodyContext.class);
5786                }
5787                public BodyContext body(int i) {
5788                        return getRuleContext(BodyContext.class,i);
5789                }
5790                public List<DdContext> dd() {
5791                        return getRuleContexts(DdContext.class);
5792                }
5793                public DdContext dd(int i) {
5794                        return getRuleContext(DdContext.class,i);
5795                }
5796                public List<DtContext> dt() {
5797                        return getRuleContexts(DtContext.class);
5798                }
5799                public DtContext dt(int i) {
5800                        return getRuleContext(DtContext.class,i);
5801                }
5802                public List<HeadContext> head() {
5803                        return getRuleContexts(HeadContext.class);
5804                }
5805                public HeadContext head(int i) {
5806                        return getRuleContext(HeadContext.class,i);
5807                }
5808                public List<HtmlContext> html() {
5809                        return getRuleContexts(HtmlContext.class);
5810                }
5811                public HtmlContext html(int i) {
5812                        return getRuleContext(HtmlContext.class,i);
5813                }
5814                public List<OptionContext> option() {
5815                        return getRuleContexts(OptionContext.class);
5816                }
5817                public OptionContext option(int i) {
5818                        return getRuleContext(OptionContext.class,i);
5819                }
5820                public List<TbodyContext> tbody() {
5821                        return getRuleContexts(TbodyContext.class);
5822                }
5823                public TbodyContext tbody(int i) {
5824                        return getRuleContext(TbodyContext.class,i);
5825                }
5826                public List<TheadContext> thead() {
5827                        return getRuleContexts(TheadContext.class);
5828                }
5829                public TheadContext thead(int i) {
5830                        return getRuleContext(TheadContext.class,i);
5831                }
5832                public List<TfootContext> tfoot() {
5833                        return getRuleContexts(TfootContext.class);
5834                }
5835                public TfootContext tfoot(int i) {
5836                        return getRuleContext(TfootContext.class,i);
5837                }
5838                public List<PTagOpenContext> pTagOpen() {
5839                        return getRuleContexts(PTagOpenContext.class);
5840                }
5841                public PTagOpenContext pTagOpen(int i) {
5842                        return getRuleContext(PTagOpenContext.class,i);
5843                }
5844                public List<LiTagOpenContext> liTagOpen() {
5845                        return getRuleContexts(LiTagOpenContext.class);
5846                }
5847                public LiTagOpenContext liTagOpen(int i) {
5848                        return getRuleContext(LiTagOpenContext.class,i);
5849                }
5850                public List<TrTagOpenContext> trTagOpen() {
5851                        return getRuleContexts(TrTagOpenContext.class);
5852                }
5853                public TrTagOpenContext trTagOpen(int i) {
5854                        return getRuleContext(TrTagOpenContext.class,i);
5855                }
5856                public List<TdTagOpenContext> tdTagOpen() {
5857                        return getRuleContexts(TdTagOpenContext.class);
5858                }
5859                public TdTagOpenContext tdTagOpen(int i) {
5860                        return getRuleContext(TdTagOpenContext.class,i);
5861                }
5862                public List<ThTagOpenContext> thTagOpen() {
5863                        return getRuleContexts(ThTagOpenContext.class);
5864                }
5865                public ThTagOpenContext thTagOpen(int i) {
5866                        return getRuleContext(ThTagOpenContext.class,i);
5867                }
5868                public List<BodyTagOpenContext> bodyTagOpen() {
5869                        return getRuleContexts(BodyTagOpenContext.class);
5870                }
5871                public BodyTagOpenContext bodyTagOpen(int i) {
5872                        return getRuleContext(BodyTagOpenContext.class,i);
5873                }
5874                public List<DdTagOpenContext> ddTagOpen() {
5875                        return getRuleContexts(DdTagOpenContext.class);
5876                }
5877                public DdTagOpenContext ddTagOpen(int i) {
5878                        return getRuleContext(DdTagOpenContext.class,i);
5879                }
5880                public List<DtTagOpenContext> dtTagOpen() {
5881                        return getRuleContexts(DtTagOpenContext.class);
5882                }
5883                public DtTagOpenContext dtTagOpen(int i) {
5884                        return getRuleContext(DtTagOpenContext.class,i);
5885                }
5886                public List<HeadTagOpenContext> headTagOpen() {
5887                        return getRuleContexts(HeadTagOpenContext.class);
5888                }
5889                public HeadTagOpenContext headTagOpen(int i) {
5890                        return getRuleContext(HeadTagOpenContext.class,i);
5891                }
5892                public List<HtmlTagOpenContext> htmlTagOpen() {
5893                        return getRuleContexts(HtmlTagOpenContext.class);
5894                }
5895                public HtmlTagOpenContext htmlTagOpen(int i) {
5896                        return getRuleContext(HtmlTagOpenContext.class,i);
5897                }
5898                public List<OptionTagOpenContext> optionTagOpen() {
5899                        return getRuleContexts(OptionTagOpenContext.class);
5900                }
5901                public OptionTagOpenContext optionTagOpen(int i) {
5902                        return getRuleContext(OptionTagOpenContext.class,i);
5903                }
5904                public List<TbodyTagOpenContext> tbodyTagOpen() {
5905                        return getRuleContexts(TbodyTagOpenContext.class);
5906                }
5907                public TbodyTagOpenContext tbodyTagOpen(int i) {
5908                        return getRuleContext(TbodyTagOpenContext.class,i);
5909                }
5910                public List<TheadTagOpenContext> theadTagOpen() {
5911                        return getRuleContexts(TheadTagOpenContext.class);
5912                }
5913                public TheadTagOpenContext theadTagOpen(int i) {
5914                        return getRuleContext(TheadTagOpenContext.class,i);
5915                }
5916                public List<TfootTagOpenContext> tfootTagOpen() {
5917                        return getRuleContexts(TfootTagOpenContext.class);
5918                }
5919                public TfootTagOpenContext tfootTagOpen(int i) {
5920                        return getRuleContext(TfootTagOpenContext.class,i);
5921                }
5922                public List<HtmlCommentContext> htmlComment() {
5923                        return getRuleContexts(HtmlCommentContext.class);
5924                }
5925                public HtmlCommentContext htmlComment(int i) {
5926                        return getRuleContext(HtmlCommentContext.class,i);
5927                }
5928                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
5929                public TerminalNode CDATA(int i) {
5930                        return getToken(JavadocParser.CDATA, i);
5931                }
5932                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5933                public TerminalNode NEWLINE(int i) {
5934                        return getToken(JavadocParser.NEWLINE, i);
5935                }
5936                public List<TextContext> text() {
5937                        return getRuleContexts(TextContext.class);
5938                }
5939                public TextContext text(int i) {
5940                        return getRuleContext(TextContext.class,i);
5941                }
5942                public List<JavadocInlineTagContext> javadocInlineTag() {
5943                        return getRuleContexts(JavadocInlineTagContext.class);
5944                }
5945                public JavadocInlineTagContext javadocInlineTag(int i) {
5946                        return getRuleContext(JavadocInlineTagContext.class,i);
5947                }
5948                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5949                public TerminalNode LEADING_ASTERISK(int i) {
5950                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5951                }
5952                public ColgroupContext(ParserRuleContext parent, int invokingState) {
5953                        super(parent, invokingState);
5954                }
5955                @Override public int getRuleIndex() { return RULE_colgroup; }
5956                @Override
5957                public void enterRule(ParseTreeListener listener) {
5958                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroup(this);
5959                }
5960                @Override
5961                public void exitRule(ParseTreeListener listener) {
5962                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroup(this);
5963                }
5964                @Override
5965                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5966                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroup(this);
5967                        else return visitor.visitChildren(this);
5968                }
5969        }
5970
5971        public final ColgroupContext colgroup() throws RecognitionException {
5972                ColgroupContext _localctx = new ColgroupContext(_ctx, getState());
5973                enterRule(_localctx, 52, RULE_colgroup);
5974                try {
5975                        int _alt;
5976                        enterOuterAlt(_localctx, 1);
5977                        {
5978                        setState(744);
5979                        colgroupTagOpen();
5980                        setState(784);
5981                        _errHandler.sync(this);
5982                        _alt = getInterpreter().adaptivePredict(_input,51,_ctx);
5983                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5984                                if ( _alt==1 ) {
5985                                        {
5986                                        setState(782);
5987                                        _errHandler.sync(this);
5988                                        switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
5989                                        case 1:
5990                                                {
5991                                                setState(745);
5992                                                htmlTag();
5993                                                }
5994                                                break;
5995                                        case 2:
5996                                                {
5997                                                setState(746);
5998                                                singletonTag();
5999                                                }
6000                                                break;
6001                                        case 3:
6002                                                {
6003                                                setState(747);
6004                                                paragraph();
6005                                                }
6006                                                break;
6007                                        case 4:
6008                                                {
6009                                                setState(748);
6010                                                li();
6011                                                }
6012                                                break;
6013                                        case 5:
6014                                                {
6015                                                setState(749);
6016                                                tr();
6017                                                }
6018                                                break;
6019                                        case 6:
6020                                                {
6021                                                setState(750);
6022                                                td();
6023                                                }
6024                                                break;
6025                                        case 7:
6026                                                {
6027                                                setState(751);
6028                                                th();
6029                                                }
6030                                                break;
6031                                        case 8:
6032                                                {
6033                                                setState(752);
6034                                                body();
6035                                                }
6036                                                break;
6037                                        case 9:
6038                                                {
6039                                                setState(753);
6040                                                dd();
6041                                                }
6042                                                break;
6043                                        case 10:
6044                                                {
6045                                                setState(754);
6046                                                dt();
6047                                                }
6048                                                break;
6049                                        case 11:
6050                                                {
6051                                                setState(755);
6052                                                head();
6053                                                }
6054                                                break;
6055                                        case 12:
6056                                                {
6057                                                setState(756);
6058                                                html();
6059                                                }
6060                                                break;
6061                                        case 13:
6062                                                {
6063                                                setState(757);
6064                                                option();
6065                                                }
6066                                                break;
6067                                        case 14:
6068                                                {
6069                                                setState(758);
6070                                                tbody();
6071                                                }
6072                                                break;
6073                                        case 15:
6074                                                {
6075                                                setState(759);
6076                                                thead();
6077                                                }
6078                                                break;
6079                                        case 16:
6080                                                {
6081                                                setState(760);
6082                                                tfoot();
6083                                                }
6084                                                break;
6085                                        case 17:
6086                                                {
6087                                                setState(761);
6088                                                pTagOpen();
6089                                                }
6090                                                break;
6091                                        case 18:
6092                                                {
6093                                                setState(762);
6094                                                liTagOpen();
6095                                                }
6096                                                break;
6097                                        case 19:
6098                                                {
6099                                                setState(763);
6100                                                trTagOpen();
6101                                                }
6102                                                break;
6103                                        case 20:
6104                                                {
6105                                                setState(764);
6106                                                tdTagOpen();
6107                                                }
6108                                                break;
6109                                        case 21:
6110                                                {
6111                                                setState(765);
6112                                                thTagOpen();
6113                                                }
6114                                                break;
6115                                        case 22:
6116                                                {
6117                                                setState(766);
6118                                                bodyTagOpen();
6119                                                }
6120                                                break;
6121                                        case 23:
6122                                                {
6123                                                setState(767);
6124                                                ddTagOpen();
6125                                                }
6126                                                break;
6127                                        case 24:
6128                                                {
6129                                                setState(768);
6130                                                dtTagOpen();
6131                                                }
6132                                                break;
6133                                        case 25:
6134                                                {
6135                                                setState(769);
6136                                                headTagOpen();
6137                                                }
6138                                                break;
6139                                        case 26:
6140                                                {
6141                                                setState(770);
6142                                                htmlTagOpen();
6143                                                }
6144                                                break;
6145                                        case 27:
6146                                                {
6147                                                setState(771);
6148                                                optionTagOpen();
6149                                                }
6150                                                break;
6151                                        case 28:
6152                                                {
6153                                                setState(772);
6154                                                tbodyTagOpen();
6155                                                }
6156                                                break;
6157                                        case 29:
6158                                                {
6159                                                setState(773);
6160                                                theadTagOpen();
6161                                                }
6162                                                break;
6163                                        case 30:
6164                                                {
6165                                                setState(774);
6166                                                tfootTagOpen();
6167                                                }
6168                                                break;
6169                                        case 31:
6170                                                {
6171                                                {
6172                                                setState(775);
6173                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
6174                                                setState(776);
6175                                                match(LEADING_ASTERISK);
6176                                                }
6177                                                }
6178                                                break;
6179                                        case 32:
6180                                                {
6181                                                setState(777);
6182                                                htmlComment();
6183                                                }
6184                                                break;
6185                                        case 33:
6186                                                {
6187                                                setState(778);
6188                                                match(CDATA);
6189                                                }
6190                                                break;
6191                                        case 34:
6192                                                {
6193                                                setState(779);
6194                                                match(NEWLINE);
6195                                                }
6196                                                break;
6197                                        case 35:
6198                                                {
6199                                                setState(780);
6200                                                text();
6201                                                }
6202                                                break;
6203                                        case 36:
6204                                                {
6205                                                setState(781);
6206                                                javadocInlineTag();
6207                                                }
6208                                                break;
6209                                        }
6210                                        } 
6211                                }
6212                                setState(786);
6213                                _errHandler.sync(this);
6214                                _alt = getInterpreter().adaptivePredict(_input,51,_ctx);
6215                        }
6216                        setState(787);
6217                        colgroupTagClose();
6218                        }
6219                }
6220                catch (RecognitionException re) {
6221                        _localctx.exception = re;
6222                        _errHandler.reportError(this, re);
6223                        _errHandler.recover(this, re);
6224                }
6225                finally {
6226                        exitRule();
6227                }
6228                return _localctx;
6229        }
6230
6231        public static class DdTagOpenContext extends ParserRuleContext {
6232                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6233                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
6234                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6235                public List<AttributeContext> attribute() {
6236                        return getRuleContexts(AttributeContext.class);
6237                }
6238                public AttributeContext attribute(int i) {
6239                        return getRuleContext(AttributeContext.class,i);
6240                }
6241                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6242                public TerminalNode NEWLINE(int i) {
6243                        return getToken(JavadocParser.NEWLINE, i);
6244                }
6245                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6246                public TerminalNode LEADING_ASTERISK(int i) {
6247                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6248                }
6249                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6250                public TerminalNode WS(int i) {
6251                        return getToken(JavadocParser.WS, i);
6252                }
6253                public DdTagOpenContext(ParserRuleContext parent, int invokingState) {
6254                        super(parent, invokingState);
6255                }
6256                @Override public int getRuleIndex() { return RULE_ddTagOpen; }
6257                @Override
6258                public void enterRule(ParseTreeListener listener) {
6259                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagOpen(this);
6260                }
6261                @Override
6262                public void exitRule(ParseTreeListener listener) {
6263                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagOpen(this);
6264                }
6265                @Override
6266                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6267                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagOpen(this);
6268                        else return visitor.visitChildren(this);
6269                }
6270        }
6271
6272        public final DdTagOpenContext ddTagOpen() throws RecognitionException {
6273                DdTagOpenContext _localctx = new DdTagOpenContext(_ctx, getState());
6274                enterRule(_localctx, 54, RULE_ddTagOpen);
6275                int _la;
6276                try {
6277                        enterOuterAlt(_localctx, 1);
6278                        {
6279                        setState(789);
6280                        match(OPEN);
6281                        setState(790);
6282                        match(DD_HTML_TAG_NAME);
6283                        setState(797);
6284                        _errHandler.sync(this);
6285                        _la = _input.LA(1);
6286                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
6287                                {
6288                                setState(795);
6289                                switch (_input.LA(1)) {
6290                                case HTML_TAG_NAME:
6291                                        {
6292                                        setState(791);
6293                                        attribute();
6294                                        }
6295                                        break;
6296                                case NEWLINE:
6297                                        {
6298                                        setState(792);
6299                                        match(NEWLINE);
6300                                        }
6301                                        break;
6302                                case LEADING_ASTERISK:
6303                                        {
6304                                        setState(793);
6305                                        match(LEADING_ASTERISK);
6306                                        }
6307                                        break;
6308                                case WS:
6309                                        {
6310                                        setState(794);
6311                                        match(WS);
6312                                        }
6313                                        break;
6314                                default:
6315                                        throw new NoViableAltException(this);
6316                                }
6317                                }
6318                                setState(799);
6319                                _errHandler.sync(this);
6320                                _la = _input.LA(1);
6321                        }
6322                        setState(800);
6323                        match(CLOSE);
6324                        }
6325                }
6326                catch (RecognitionException re) {
6327                        _localctx.exception = re;
6328                        _errHandler.reportError(this, re);
6329                        _errHandler.recover(this, re);
6330                }
6331                finally {
6332                        exitRule();
6333                }
6334                return _localctx;
6335        }
6336
6337        public static class DdTagCloseContext extends ParserRuleContext {
6338                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6339                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
6340                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
6341                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6342                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6343                public TerminalNode NEWLINE(int i) {
6344                        return getToken(JavadocParser.NEWLINE, i);
6345                }
6346                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6347                public TerminalNode LEADING_ASTERISK(int i) {
6348                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6349                }
6350                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6351                public TerminalNode WS(int i) {
6352                        return getToken(JavadocParser.WS, i);
6353                }
6354                public DdTagCloseContext(ParserRuleContext parent, int invokingState) {
6355                        super(parent, invokingState);
6356                }
6357                @Override public int getRuleIndex() { return RULE_ddTagClose; }
6358                @Override
6359                public void enterRule(ParseTreeListener listener) {
6360                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagClose(this);
6361                }
6362                @Override
6363                public void exitRule(ParseTreeListener listener) {
6364                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagClose(this);
6365                }
6366                @Override
6367                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6368                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagClose(this);
6369                        else return visitor.visitChildren(this);
6370                }
6371        }
6372
6373        public final DdTagCloseContext ddTagClose() throws RecognitionException {
6374                DdTagCloseContext _localctx = new DdTagCloseContext(_ctx, getState());
6375                enterRule(_localctx, 56, RULE_ddTagClose);
6376                int _la;
6377                try {
6378                        enterOuterAlt(_localctx, 1);
6379                        {
6380                        setState(802);
6381                        match(OPEN);
6382                        setState(803);
6383                        match(SLASH);
6384                        setState(804);
6385                        match(DD_HTML_TAG_NAME);
6386                        setState(808);
6387                        _errHandler.sync(this);
6388                        _la = _input.LA(1);
6389                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
6390                                {
6391                                {
6392                                setState(805);
6393                                _la = _input.LA(1);
6394                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
6395                                _errHandler.recoverInline(this);
6396                                } else {
6397                                        consume();
6398                                }
6399                                }
6400                                }
6401                                setState(810);
6402                                _errHandler.sync(this);
6403                                _la = _input.LA(1);
6404                        }
6405                        setState(811);
6406                        match(CLOSE);
6407                        }
6408                }
6409                catch (RecognitionException re) {
6410                        _localctx.exception = re;
6411                        _errHandler.reportError(this, re);
6412                        _errHandler.recover(this, re);
6413                }
6414                finally {
6415                        exitRule();
6416                }
6417                return _localctx;
6418        }
6419
6420        public static class DdContext extends ParserRuleContext {
6421                public DdTagOpenContext ddTagOpen() {
6422                        return getRuleContext(DdTagOpenContext.class,0);
6423                }
6424                public DdTagCloseContext ddTagClose() {
6425                        return getRuleContext(DdTagCloseContext.class,0);
6426                }
6427                public List<HtmlTagContext> htmlTag() {
6428                        return getRuleContexts(HtmlTagContext.class);
6429                }
6430                public HtmlTagContext htmlTag(int i) {
6431                        return getRuleContext(HtmlTagContext.class,i);
6432                }
6433                public List<SingletonTagContext> singletonTag() {
6434                        return getRuleContexts(SingletonTagContext.class);
6435                }
6436                public SingletonTagContext singletonTag(int i) {
6437                        return getRuleContext(SingletonTagContext.class,i);
6438                }
6439                public List<ParagraphContext> paragraph() {
6440                        return getRuleContexts(ParagraphContext.class);
6441                }
6442                public ParagraphContext paragraph(int i) {
6443                        return getRuleContext(ParagraphContext.class,i);
6444                }
6445                public List<LiContext> li() {
6446                        return getRuleContexts(LiContext.class);
6447                }
6448                public LiContext li(int i) {
6449                        return getRuleContext(LiContext.class,i);
6450                }
6451                public List<TrContext> tr() {
6452                        return getRuleContexts(TrContext.class);
6453                }
6454                public TrContext tr(int i) {
6455                        return getRuleContext(TrContext.class,i);
6456                }
6457                public List<TdContext> td() {
6458                        return getRuleContexts(TdContext.class);
6459                }
6460                public TdContext td(int i) {
6461                        return getRuleContext(TdContext.class,i);
6462                }
6463                public List<ThContext> th() {
6464                        return getRuleContexts(ThContext.class);
6465                }
6466                public ThContext th(int i) {
6467                        return getRuleContext(ThContext.class,i);
6468                }
6469                public List<BodyContext> body() {
6470                        return getRuleContexts(BodyContext.class);
6471                }
6472                public BodyContext body(int i) {
6473                        return getRuleContext(BodyContext.class,i);
6474                }
6475                public List<ColgroupContext> colgroup() {
6476                        return getRuleContexts(ColgroupContext.class);
6477                }
6478                public ColgroupContext colgroup(int i) {
6479                        return getRuleContext(ColgroupContext.class,i);
6480                }
6481                public List<DtContext> dt() {
6482                        return getRuleContexts(DtContext.class);
6483                }
6484                public DtContext dt(int i) {
6485                        return getRuleContext(DtContext.class,i);
6486                }
6487                public List<HeadContext> head() {
6488                        return getRuleContexts(HeadContext.class);
6489                }
6490                public HeadContext head(int i) {
6491                        return getRuleContext(HeadContext.class,i);
6492                }
6493                public List<HtmlContext> html() {
6494                        return getRuleContexts(HtmlContext.class);
6495                }
6496                public HtmlContext html(int i) {
6497                        return getRuleContext(HtmlContext.class,i);
6498                }
6499                public List<OptionContext> option() {
6500                        return getRuleContexts(OptionContext.class);
6501                }
6502                public OptionContext option(int i) {
6503                        return getRuleContext(OptionContext.class,i);
6504                }
6505                public List<TbodyContext> tbody() {
6506                        return getRuleContexts(TbodyContext.class);
6507                }
6508                public TbodyContext tbody(int i) {
6509                        return getRuleContext(TbodyContext.class,i);
6510                }
6511                public List<TheadContext> thead() {
6512                        return getRuleContexts(TheadContext.class);
6513                }
6514                public TheadContext thead(int i) {
6515                        return getRuleContext(TheadContext.class,i);
6516                }
6517                public List<TfootContext> tfoot() {
6518                        return getRuleContexts(TfootContext.class);
6519                }
6520                public TfootContext tfoot(int i) {
6521                        return getRuleContext(TfootContext.class,i);
6522                }
6523                public List<PTagOpenContext> pTagOpen() {
6524                        return getRuleContexts(PTagOpenContext.class);
6525                }
6526                public PTagOpenContext pTagOpen(int i) {
6527                        return getRuleContext(PTagOpenContext.class,i);
6528                }
6529                public List<LiTagOpenContext> liTagOpen() {
6530                        return getRuleContexts(LiTagOpenContext.class);
6531                }
6532                public LiTagOpenContext liTagOpen(int i) {
6533                        return getRuleContext(LiTagOpenContext.class,i);
6534                }
6535                public List<TrTagOpenContext> trTagOpen() {
6536                        return getRuleContexts(TrTagOpenContext.class);
6537                }
6538                public TrTagOpenContext trTagOpen(int i) {
6539                        return getRuleContext(TrTagOpenContext.class,i);
6540                }
6541                public List<TdTagOpenContext> tdTagOpen() {
6542                        return getRuleContexts(TdTagOpenContext.class);
6543                }
6544                public TdTagOpenContext tdTagOpen(int i) {
6545                        return getRuleContext(TdTagOpenContext.class,i);
6546                }
6547                public List<ThTagOpenContext> thTagOpen() {
6548                        return getRuleContexts(ThTagOpenContext.class);
6549                }
6550                public ThTagOpenContext thTagOpen(int i) {
6551                        return getRuleContext(ThTagOpenContext.class,i);
6552                }
6553                public List<BodyTagOpenContext> bodyTagOpen() {
6554                        return getRuleContexts(BodyTagOpenContext.class);
6555                }
6556                public BodyTagOpenContext bodyTagOpen(int i) {
6557                        return getRuleContext(BodyTagOpenContext.class,i);
6558                }
6559                public List<ColgroupTagOpenContext> colgroupTagOpen() {
6560                        return getRuleContexts(ColgroupTagOpenContext.class);
6561                }
6562                public ColgroupTagOpenContext colgroupTagOpen(int i) {
6563                        return getRuleContext(ColgroupTagOpenContext.class,i);
6564                }
6565                public List<DtTagOpenContext> dtTagOpen() {
6566                        return getRuleContexts(DtTagOpenContext.class);
6567                }
6568                public DtTagOpenContext dtTagOpen(int i) {
6569                        return getRuleContext(DtTagOpenContext.class,i);
6570                }
6571                public List<HeadTagOpenContext> headTagOpen() {
6572                        return getRuleContexts(HeadTagOpenContext.class);
6573                }
6574                public HeadTagOpenContext headTagOpen(int i) {
6575                        return getRuleContext(HeadTagOpenContext.class,i);
6576                }
6577                public List<HtmlTagOpenContext> htmlTagOpen() {
6578                        return getRuleContexts(HtmlTagOpenContext.class);
6579                }
6580                public HtmlTagOpenContext htmlTagOpen(int i) {
6581                        return getRuleContext(HtmlTagOpenContext.class,i);
6582                }
6583                public List<OptionTagOpenContext> optionTagOpen() {
6584                        return getRuleContexts(OptionTagOpenContext.class);
6585                }
6586                public OptionTagOpenContext optionTagOpen(int i) {
6587                        return getRuleContext(OptionTagOpenContext.class,i);
6588                }
6589                public List<TbodyTagOpenContext> tbodyTagOpen() {
6590                        return getRuleContexts(TbodyTagOpenContext.class);
6591                }
6592                public TbodyTagOpenContext tbodyTagOpen(int i) {
6593                        return getRuleContext(TbodyTagOpenContext.class,i);
6594                }
6595                public List<TheadTagOpenContext> theadTagOpen() {
6596                        return getRuleContexts(TheadTagOpenContext.class);
6597                }
6598                public TheadTagOpenContext theadTagOpen(int i) {
6599                        return getRuleContext(TheadTagOpenContext.class,i);
6600                }
6601                public List<TfootTagOpenContext> tfootTagOpen() {
6602                        return getRuleContexts(TfootTagOpenContext.class);
6603                }
6604                public TfootTagOpenContext tfootTagOpen(int i) {
6605                        return getRuleContext(TfootTagOpenContext.class,i);
6606                }
6607                public List<HtmlCommentContext> htmlComment() {
6608                        return getRuleContexts(HtmlCommentContext.class);
6609                }
6610                public HtmlCommentContext htmlComment(int i) {
6611                        return getRuleContext(HtmlCommentContext.class,i);
6612                }
6613                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
6614                public TerminalNode CDATA(int i) {
6615                        return getToken(JavadocParser.CDATA, i);
6616                }
6617                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6618                public TerminalNode NEWLINE(int i) {
6619                        return getToken(JavadocParser.NEWLINE, i);
6620                }
6621                public List<TextContext> text() {
6622                        return getRuleContexts(TextContext.class);
6623                }
6624                public TextContext text(int i) {
6625                        return getRuleContext(TextContext.class,i);
6626                }
6627                public List<JavadocInlineTagContext> javadocInlineTag() {
6628                        return getRuleContexts(JavadocInlineTagContext.class);
6629                }
6630                public JavadocInlineTagContext javadocInlineTag(int i) {
6631                        return getRuleContext(JavadocInlineTagContext.class,i);
6632                }
6633                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6634                public TerminalNode LEADING_ASTERISK(int i) {
6635                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6636                }
6637                public DdContext(ParserRuleContext parent, int invokingState) {
6638                        super(parent, invokingState);
6639                }
6640                @Override public int getRuleIndex() { return RULE_dd; }
6641                @Override
6642                public void enterRule(ParseTreeListener listener) {
6643                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDd(this);
6644                }
6645                @Override
6646                public void exitRule(ParseTreeListener listener) {
6647                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDd(this);
6648                }
6649                @Override
6650                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6651                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDd(this);
6652                        else return visitor.visitChildren(this);
6653                }
6654        }
6655
6656        public final DdContext dd() throws RecognitionException {
6657                DdContext _localctx = new DdContext(_ctx, getState());
6658                enterRule(_localctx, 58, RULE_dd);
6659                try {
6660                        int _alt;
6661                        enterOuterAlt(_localctx, 1);
6662                        {
6663                        setState(813);
6664                        ddTagOpen();
6665                        setState(853);
6666                        _errHandler.sync(this);
6667                        _alt = getInterpreter().adaptivePredict(_input,56,_ctx);
6668                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
6669                                if ( _alt==1 ) {
6670                                        {
6671                                        setState(851);
6672                                        _errHandler.sync(this);
6673                                        switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
6674                                        case 1:
6675                                                {
6676                                                setState(814);
6677                                                htmlTag();
6678                                                }
6679                                                break;
6680                                        case 2:
6681                                                {
6682                                                setState(815);
6683                                                singletonTag();
6684                                                }
6685                                                break;
6686                                        case 3:
6687                                                {
6688                                                setState(816);
6689                                                paragraph();
6690                                                }
6691                                                break;
6692                                        case 4:
6693                                                {
6694                                                setState(817);
6695                                                li();
6696                                                }
6697                                                break;
6698                                        case 5:
6699                                                {
6700                                                setState(818);
6701                                                tr();
6702                                                }
6703                                                break;
6704                                        case 6:
6705                                                {
6706                                                setState(819);
6707                                                td();
6708                                                }
6709                                                break;
6710                                        case 7:
6711                                                {
6712                                                setState(820);
6713                                                th();
6714                                                }
6715                                                break;
6716                                        case 8:
6717                                                {
6718                                                setState(821);
6719                                                body();
6720                                                }
6721                                                break;
6722                                        case 9:
6723                                                {
6724                                                setState(822);
6725                                                colgroup();
6726                                                }
6727                                                break;
6728                                        case 10:
6729                                                {
6730                                                setState(823);
6731                                                dt();
6732                                                }
6733                                                break;
6734                                        case 11:
6735                                                {
6736                                                setState(824);
6737                                                head();
6738                                                }
6739                                                break;
6740                                        case 12:
6741                                                {
6742                                                setState(825);
6743                                                html();
6744                                                }
6745                                                break;
6746                                        case 13:
6747                                                {
6748                                                setState(826);
6749                                                option();
6750                                                }
6751                                                break;
6752                                        case 14:
6753                                                {
6754                                                setState(827);
6755                                                tbody();
6756                                                }
6757                                                break;
6758                                        case 15:
6759                                                {
6760                                                setState(828);
6761                                                thead();
6762                                                }
6763                                                break;
6764                                        case 16:
6765                                                {
6766                                                setState(829);
6767                                                tfoot();
6768                                                }
6769                                                break;
6770                                        case 17:
6771                                                {
6772                                                setState(830);
6773                                                pTagOpen();
6774                                                }
6775                                                break;
6776                                        case 18:
6777                                                {
6778                                                setState(831);
6779                                                liTagOpen();
6780                                                }
6781                                                break;
6782                                        case 19:
6783                                                {
6784                                                setState(832);
6785                                                trTagOpen();
6786                                                }
6787                                                break;
6788                                        case 20:
6789                                                {
6790                                                setState(833);
6791                                                tdTagOpen();
6792                                                }
6793                                                break;
6794                                        case 21:
6795                                                {
6796                                                setState(834);
6797                                                thTagOpen();
6798                                                }
6799                                                break;
6800                                        case 22:
6801                                                {
6802                                                setState(835);
6803                                                bodyTagOpen();
6804                                                }
6805                                                break;
6806                                        case 23:
6807                                                {
6808                                                setState(836);
6809                                                colgroupTagOpen();
6810                                                }
6811                                                break;
6812                                        case 24:
6813                                                {
6814                                                setState(837);
6815                                                dtTagOpen();
6816                                                }
6817                                                break;
6818                                        case 25:
6819                                                {
6820                                                setState(838);
6821                                                headTagOpen();
6822                                                }
6823                                                break;
6824                                        case 26:
6825                                                {
6826                                                setState(839);
6827                                                htmlTagOpen();
6828                                                }
6829                                                break;
6830                                        case 27:
6831                                                {
6832                                                setState(840);
6833                                                optionTagOpen();
6834                                                }
6835                                                break;
6836                                        case 28:
6837                                                {
6838                                                setState(841);
6839                                                tbodyTagOpen();
6840                                                }
6841                                                break;
6842                                        case 29:
6843                                                {
6844                                                setState(842);
6845                                                theadTagOpen();
6846                                                }
6847                                                break;
6848                                        case 30:
6849                                                {
6850                                                setState(843);
6851                                                tfootTagOpen();
6852                                                }
6853                                                break;
6854                                        case 31:
6855                                                {
6856                                                {
6857                                                setState(844);
6858                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
6859                                                setState(845);
6860                                                match(LEADING_ASTERISK);
6861                                                }
6862                                                }
6863                                                break;
6864                                        case 32:
6865                                                {
6866                                                setState(846);
6867                                                htmlComment();
6868                                                }
6869                                                break;
6870                                        case 33:
6871                                                {
6872                                                setState(847);
6873                                                match(CDATA);
6874                                                }
6875                                                break;
6876                                        case 34:
6877                                                {
6878                                                setState(848);
6879                                                match(NEWLINE);
6880                                                }
6881                                                break;
6882                                        case 35:
6883                                                {
6884                                                setState(849);
6885                                                text();
6886                                                }
6887                                                break;
6888                                        case 36:
6889                                                {
6890                                                setState(850);
6891                                                javadocInlineTag();
6892                                                }
6893                                                break;
6894                                        }
6895                                        } 
6896                                }
6897                                setState(855);
6898                                _errHandler.sync(this);
6899                                _alt = getInterpreter().adaptivePredict(_input,56,_ctx);
6900                        }
6901                        setState(856);
6902                        ddTagClose();
6903                        }
6904                }
6905                catch (RecognitionException re) {
6906                        _localctx.exception = re;
6907                        _errHandler.reportError(this, re);
6908                        _errHandler.recover(this, re);
6909                }
6910                finally {
6911                        exitRule();
6912                }
6913                return _localctx;
6914        }
6915
6916        public static class DtTagOpenContext extends ParserRuleContext {
6917                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6918                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
6919                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6920                public List<AttributeContext> attribute() {
6921                        return getRuleContexts(AttributeContext.class);
6922                }
6923                public AttributeContext attribute(int i) {
6924                        return getRuleContext(AttributeContext.class,i);
6925                }
6926                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6927                public TerminalNode NEWLINE(int i) {
6928                        return getToken(JavadocParser.NEWLINE, i);
6929                }
6930                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6931                public TerminalNode LEADING_ASTERISK(int i) {
6932                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6933                }
6934                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6935                public TerminalNode WS(int i) {
6936                        return getToken(JavadocParser.WS, i);
6937                }
6938                public DtTagOpenContext(ParserRuleContext parent, int invokingState) {
6939                        super(parent, invokingState);
6940                }
6941                @Override public int getRuleIndex() { return RULE_dtTagOpen; }
6942                @Override
6943                public void enterRule(ParseTreeListener listener) {
6944                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagOpen(this);
6945                }
6946                @Override
6947                public void exitRule(ParseTreeListener listener) {
6948                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagOpen(this);
6949                }
6950                @Override
6951                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6952                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagOpen(this);
6953                        else return visitor.visitChildren(this);
6954                }
6955        }
6956
6957        public final DtTagOpenContext dtTagOpen() throws RecognitionException {
6958                DtTagOpenContext _localctx = new DtTagOpenContext(_ctx, getState());
6959                enterRule(_localctx, 60, RULE_dtTagOpen);
6960                int _la;
6961                try {
6962                        enterOuterAlt(_localctx, 1);
6963                        {
6964                        setState(858);
6965                        match(OPEN);
6966                        setState(859);
6967                        match(DT_HTML_TAG_NAME);
6968                        setState(866);
6969                        _errHandler.sync(this);
6970                        _la = _input.LA(1);
6971                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
6972                                {
6973                                setState(864);
6974                                switch (_input.LA(1)) {
6975                                case HTML_TAG_NAME:
6976                                        {
6977                                        setState(860);
6978                                        attribute();
6979                                        }
6980                                        break;
6981                                case NEWLINE:
6982                                        {
6983                                        setState(861);
6984                                        match(NEWLINE);
6985                                        }
6986                                        break;
6987                                case LEADING_ASTERISK:
6988                                        {
6989                                        setState(862);
6990                                        match(LEADING_ASTERISK);
6991                                        }
6992                                        break;
6993                                case WS:
6994                                        {
6995                                        setState(863);
6996                                        match(WS);
6997                                        }
6998                                        break;
6999                                default:
7000                                        throw new NoViableAltException(this);
7001                                }
7002                                }
7003                                setState(868);
7004                                _errHandler.sync(this);
7005                                _la = _input.LA(1);
7006                        }
7007                        setState(869);
7008                        match(CLOSE);
7009                        }
7010                }
7011                catch (RecognitionException re) {
7012                        _localctx.exception = re;
7013                        _errHandler.reportError(this, re);
7014                        _errHandler.recover(this, re);
7015                }
7016                finally {
7017                        exitRule();
7018                }
7019                return _localctx;
7020        }
7021
7022        public static class DtTagCloseContext extends ParserRuleContext {
7023                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7024                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
7025                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
7026                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7027                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7028                public TerminalNode NEWLINE(int i) {
7029                        return getToken(JavadocParser.NEWLINE, i);
7030                }
7031                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7032                public TerminalNode LEADING_ASTERISK(int i) {
7033                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7034                }
7035                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7036                public TerminalNode WS(int i) {
7037                        return getToken(JavadocParser.WS, i);
7038                }
7039                public DtTagCloseContext(ParserRuleContext parent, int invokingState) {
7040                        super(parent, invokingState);
7041                }
7042                @Override public int getRuleIndex() { return RULE_dtTagClose; }
7043                @Override
7044                public void enterRule(ParseTreeListener listener) {
7045                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagClose(this);
7046                }
7047                @Override
7048                public void exitRule(ParseTreeListener listener) {
7049                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagClose(this);
7050                }
7051                @Override
7052                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7053                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagClose(this);
7054                        else return visitor.visitChildren(this);
7055                }
7056        }
7057
7058        public final DtTagCloseContext dtTagClose() throws RecognitionException {
7059                DtTagCloseContext _localctx = new DtTagCloseContext(_ctx, getState());
7060                enterRule(_localctx, 62, RULE_dtTagClose);
7061                int _la;
7062                try {
7063                        enterOuterAlt(_localctx, 1);
7064                        {
7065                        setState(871);
7066                        match(OPEN);
7067                        setState(872);
7068                        match(SLASH);
7069                        setState(873);
7070                        match(DT_HTML_TAG_NAME);
7071                        setState(877);
7072                        _errHandler.sync(this);
7073                        _la = _input.LA(1);
7074                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
7075                                {
7076                                {
7077                                setState(874);
7078                                _la = _input.LA(1);
7079                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
7080                                _errHandler.recoverInline(this);
7081                                } else {
7082                                        consume();
7083                                }
7084                                }
7085                                }
7086                                setState(879);
7087                                _errHandler.sync(this);
7088                                _la = _input.LA(1);
7089                        }
7090                        setState(880);
7091                        match(CLOSE);
7092                        }
7093                }
7094                catch (RecognitionException re) {
7095                        _localctx.exception = re;
7096                        _errHandler.reportError(this, re);
7097                        _errHandler.recover(this, re);
7098                }
7099                finally {
7100                        exitRule();
7101                }
7102                return _localctx;
7103        }
7104
7105        public static class DtContext extends ParserRuleContext {
7106                public DtTagOpenContext dtTagOpen() {
7107                        return getRuleContext(DtTagOpenContext.class,0);
7108                }
7109                public DtTagCloseContext dtTagClose() {
7110                        return getRuleContext(DtTagCloseContext.class,0);
7111                }
7112                public List<HtmlTagContext> htmlTag() {
7113                        return getRuleContexts(HtmlTagContext.class);
7114                }
7115                public HtmlTagContext htmlTag(int i) {
7116                        return getRuleContext(HtmlTagContext.class,i);
7117                }
7118                public List<SingletonTagContext> singletonTag() {
7119                        return getRuleContexts(SingletonTagContext.class);
7120                }
7121                public SingletonTagContext singletonTag(int i) {
7122                        return getRuleContext(SingletonTagContext.class,i);
7123                }
7124                public List<ParagraphContext> paragraph() {
7125                        return getRuleContexts(ParagraphContext.class);
7126                }
7127                public ParagraphContext paragraph(int i) {
7128                        return getRuleContext(ParagraphContext.class,i);
7129                }
7130                public List<LiContext> li() {
7131                        return getRuleContexts(LiContext.class);
7132                }
7133                public LiContext li(int i) {
7134                        return getRuleContext(LiContext.class,i);
7135                }
7136                public List<TrContext> tr() {
7137                        return getRuleContexts(TrContext.class);
7138                }
7139                public TrContext tr(int i) {
7140                        return getRuleContext(TrContext.class,i);
7141                }
7142                public List<TdContext> td() {
7143                        return getRuleContexts(TdContext.class);
7144                }
7145                public TdContext td(int i) {
7146                        return getRuleContext(TdContext.class,i);
7147                }
7148                public List<ThContext> th() {
7149                        return getRuleContexts(ThContext.class);
7150                }
7151                public ThContext th(int i) {
7152                        return getRuleContext(ThContext.class,i);
7153                }
7154                public List<BodyContext> body() {
7155                        return getRuleContexts(BodyContext.class);
7156                }
7157                public BodyContext body(int i) {
7158                        return getRuleContext(BodyContext.class,i);
7159                }
7160                public List<ColgroupContext> colgroup() {
7161                        return getRuleContexts(ColgroupContext.class);
7162                }
7163                public ColgroupContext colgroup(int i) {
7164                        return getRuleContext(ColgroupContext.class,i);
7165                }
7166                public List<DdContext> dd() {
7167                        return getRuleContexts(DdContext.class);
7168                }
7169                public DdContext dd(int i) {
7170                        return getRuleContext(DdContext.class,i);
7171                }
7172                public List<HeadContext> head() {
7173                        return getRuleContexts(HeadContext.class);
7174                }
7175                public HeadContext head(int i) {
7176                        return getRuleContext(HeadContext.class,i);
7177                }
7178                public List<HtmlContext> html() {
7179                        return getRuleContexts(HtmlContext.class);
7180                }
7181                public HtmlContext html(int i) {
7182                        return getRuleContext(HtmlContext.class,i);
7183                }
7184                public List<OptionContext> option() {
7185                        return getRuleContexts(OptionContext.class);
7186                }
7187                public OptionContext option(int i) {
7188                        return getRuleContext(OptionContext.class,i);
7189                }
7190                public List<TbodyContext> tbody() {
7191                        return getRuleContexts(TbodyContext.class);
7192                }
7193                public TbodyContext tbody(int i) {
7194                        return getRuleContext(TbodyContext.class,i);
7195                }
7196                public List<TheadContext> thead() {
7197                        return getRuleContexts(TheadContext.class);
7198                }
7199                public TheadContext thead(int i) {
7200                        return getRuleContext(TheadContext.class,i);
7201                }
7202                public List<TfootContext> tfoot() {
7203                        return getRuleContexts(TfootContext.class);
7204                }
7205                public TfootContext tfoot(int i) {
7206                        return getRuleContext(TfootContext.class,i);
7207                }
7208                public List<PTagOpenContext> pTagOpen() {
7209                        return getRuleContexts(PTagOpenContext.class);
7210                }
7211                public PTagOpenContext pTagOpen(int i) {
7212                        return getRuleContext(PTagOpenContext.class,i);
7213                }
7214                public List<LiTagOpenContext> liTagOpen() {
7215                        return getRuleContexts(LiTagOpenContext.class);
7216                }
7217                public LiTagOpenContext liTagOpen(int i) {
7218                        return getRuleContext(LiTagOpenContext.class,i);
7219                }
7220                public List<TrTagOpenContext> trTagOpen() {
7221                        return getRuleContexts(TrTagOpenContext.class);
7222                }
7223                public TrTagOpenContext trTagOpen(int i) {
7224                        return getRuleContext(TrTagOpenContext.class,i);
7225                }
7226                public List<TdTagOpenContext> tdTagOpen() {
7227                        return getRuleContexts(TdTagOpenContext.class);
7228                }
7229                public TdTagOpenContext tdTagOpen(int i) {
7230                        return getRuleContext(TdTagOpenContext.class,i);
7231                }
7232                public List<ThTagOpenContext> thTagOpen() {
7233                        return getRuleContexts(ThTagOpenContext.class);
7234                }
7235                public ThTagOpenContext thTagOpen(int i) {
7236                        return getRuleContext(ThTagOpenContext.class,i);
7237                }
7238                public List<BodyTagOpenContext> bodyTagOpen() {
7239                        return getRuleContexts(BodyTagOpenContext.class);
7240                }
7241                public BodyTagOpenContext bodyTagOpen(int i) {
7242                        return getRuleContext(BodyTagOpenContext.class,i);
7243                }
7244                public List<ColgroupTagOpenContext> colgroupTagOpen() {
7245                        return getRuleContexts(ColgroupTagOpenContext.class);
7246                }
7247                public ColgroupTagOpenContext colgroupTagOpen(int i) {
7248                        return getRuleContext(ColgroupTagOpenContext.class,i);
7249                }
7250                public List<DdTagOpenContext> ddTagOpen() {
7251                        return getRuleContexts(DdTagOpenContext.class);
7252                }
7253                public DdTagOpenContext ddTagOpen(int i) {
7254                        return getRuleContext(DdTagOpenContext.class,i);
7255                }
7256                public List<HeadTagOpenContext> headTagOpen() {
7257                        return getRuleContexts(HeadTagOpenContext.class);
7258                }
7259                public HeadTagOpenContext headTagOpen(int i) {
7260                        return getRuleContext(HeadTagOpenContext.class,i);
7261                }
7262                public List<HtmlTagOpenContext> htmlTagOpen() {
7263                        return getRuleContexts(HtmlTagOpenContext.class);
7264                }
7265                public HtmlTagOpenContext htmlTagOpen(int i) {
7266                        return getRuleContext(HtmlTagOpenContext.class,i);
7267                }
7268                public List<OptionTagOpenContext> optionTagOpen() {
7269                        return getRuleContexts(OptionTagOpenContext.class);
7270                }
7271                public OptionTagOpenContext optionTagOpen(int i) {
7272                        return getRuleContext(OptionTagOpenContext.class,i);
7273                }
7274                public List<TbodyTagOpenContext> tbodyTagOpen() {
7275                        return getRuleContexts(TbodyTagOpenContext.class);
7276                }
7277                public TbodyTagOpenContext tbodyTagOpen(int i) {
7278                        return getRuleContext(TbodyTagOpenContext.class,i);
7279                }
7280                public List<TheadTagOpenContext> theadTagOpen() {
7281                        return getRuleContexts(TheadTagOpenContext.class);
7282                }
7283                public TheadTagOpenContext theadTagOpen(int i) {
7284                        return getRuleContext(TheadTagOpenContext.class,i);
7285                }
7286                public List<TfootTagOpenContext> tfootTagOpen() {
7287                        return getRuleContexts(TfootTagOpenContext.class);
7288                }
7289                public TfootTagOpenContext tfootTagOpen(int i) {
7290                        return getRuleContext(TfootTagOpenContext.class,i);
7291                }
7292                public List<HtmlCommentContext> htmlComment() {
7293                        return getRuleContexts(HtmlCommentContext.class);
7294                }
7295                public HtmlCommentContext htmlComment(int i) {
7296                        return getRuleContext(HtmlCommentContext.class,i);
7297                }
7298                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
7299                public TerminalNode CDATA(int i) {
7300                        return getToken(JavadocParser.CDATA, i);
7301                }
7302                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7303                public TerminalNode NEWLINE(int i) {
7304                        return getToken(JavadocParser.NEWLINE, i);
7305                }
7306                public List<TextContext> text() {
7307                        return getRuleContexts(TextContext.class);
7308                }
7309                public TextContext text(int i) {
7310                        return getRuleContext(TextContext.class,i);
7311                }
7312                public List<JavadocInlineTagContext> javadocInlineTag() {
7313                        return getRuleContexts(JavadocInlineTagContext.class);
7314                }
7315                public JavadocInlineTagContext javadocInlineTag(int i) {
7316                        return getRuleContext(JavadocInlineTagContext.class,i);
7317                }
7318                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7319                public TerminalNode LEADING_ASTERISK(int i) {
7320                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7321                }
7322                public DtContext(ParserRuleContext parent, int invokingState) {
7323                        super(parent, invokingState);
7324                }
7325                @Override public int getRuleIndex() { return RULE_dt; }
7326                @Override
7327                public void enterRule(ParseTreeListener listener) {
7328                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDt(this);
7329                }
7330                @Override
7331                public void exitRule(ParseTreeListener listener) {
7332                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDt(this);
7333                }
7334                @Override
7335                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7336                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDt(this);
7337                        else return visitor.visitChildren(this);
7338                }
7339        }
7340
7341        public final DtContext dt() throws RecognitionException {
7342                DtContext _localctx = new DtContext(_ctx, getState());
7343                enterRule(_localctx, 64, RULE_dt);
7344                try {
7345                        int _alt;
7346                        enterOuterAlt(_localctx, 1);
7347                        {
7348                        setState(882);
7349                        dtTagOpen();
7350                        setState(922);
7351                        _errHandler.sync(this);
7352                        _alt = getInterpreter().adaptivePredict(_input,61,_ctx);
7353                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
7354                                if ( _alt==1 ) {
7355                                        {
7356                                        setState(920);
7357                                        _errHandler.sync(this);
7358                                        switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
7359                                        case 1:
7360                                                {
7361                                                setState(883);
7362                                                htmlTag();
7363                                                }
7364                                                break;
7365                                        case 2:
7366                                                {
7367                                                setState(884);
7368                                                singletonTag();
7369                                                }
7370                                                break;
7371                                        case 3:
7372                                                {
7373                                                setState(885);
7374                                                paragraph();
7375                                                }
7376                                                break;
7377                                        case 4:
7378                                                {
7379                                                setState(886);
7380                                                li();
7381                                                }
7382                                                break;
7383                                        case 5:
7384                                                {
7385                                                setState(887);
7386                                                tr();
7387                                                }
7388                                                break;
7389                                        case 6:
7390                                                {
7391                                                setState(888);
7392                                                td();
7393                                                }
7394                                                break;
7395                                        case 7:
7396                                                {
7397                                                setState(889);
7398                                                th();
7399                                                }
7400                                                break;
7401                                        case 8:
7402                                                {
7403                                                setState(890);
7404                                                body();
7405                                                }
7406                                                break;
7407                                        case 9:
7408                                                {
7409                                                setState(891);
7410                                                colgroup();
7411                                                }
7412                                                break;
7413                                        case 10:
7414                                                {
7415                                                setState(892);
7416                                                dd();
7417                                                }
7418                                                break;
7419                                        case 11:
7420                                                {
7421                                                setState(893);
7422                                                head();
7423                                                }
7424                                                break;
7425                                        case 12:
7426                                                {
7427                                                setState(894);
7428                                                html();
7429                                                }
7430                                                break;
7431                                        case 13:
7432                                                {
7433                                                setState(895);
7434                                                option();
7435                                                }
7436                                                break;
7437                                        case 14:
7438                                                {
7439                                                setState(896);
7440                                                tbody();
7441                                                }
7442                                                break;
7443                                        case 15:
7444                                                {
7445                                                setState(897);
7446                                                thead();
7447                                                }
7448                                                break;
7449                                        case 16:
7450                                                {
7451                                                setState(898);
7452                                                tfoot();
7453                                                }
7454                                                break;
7455                                        case 17:
7456                                                {
7457                                                setState(899);
7458                                                pTagOpen();
7459                                                }
7460                                                break;
7461                                        case 18:
7462                                                {
7463                                                setState(900);
7464                                                liTagOpen();
7465                                                }
7466                                                break;
7467                                        case 19:
7468                                                {
7469                                                setState(901);
7470                                                trTagOpen();
7471                                                }
7472                                                break;
7473                                        case 20:
7474                                                {
7475                                                setState(902);
7476                                                tdTagOpen();
7477                                                }
7478                                                break;
7479                                        case 21:
7480                                                {
7481                                                setState(903);
7482                                                thTagOpen();
7483                                                }
7484                                                break;
7485                                        case 22:
7486                                                {
7487                                                setState(904);
7488                                                bodyTagOpen();
7489                                                }
7490                                                break;
7491                                        case 23:
7492                                                {
7493                                                setState(905);
7494                                                colgroupTagOpen();
7495                                                }
7496                                                break;
7497                                        case 24:
7498                                                {
7499                                                setState(906);
7500                                                ddTagOpen();
7501                                                }
7502                                                break;
7503                                        case 25:
7504                                                {
7505                                                setState(907);
7506                                                headTagOpen();
7507                                                }
7508                                                break;
7509                                        case 26:
7510                                                {
7511                                                setState(908);
7512                                                htmlTagOpen();
7513                                                }
7514                                                break;
7515                                        case 27:
7516                                                {
7517                                                setState(909);
7518                                                optionTagOpen();
7519                                                }
7520                                                break;
7521                                        case 28:
7522                                                {
7523                                                setState(910);
7524                                                tbodyTagOpen();
7525                                                }
7526                                                break;
7527                                        case 29:
7528                                                {
7529                                                setState(911);
7530                                                theadTagOpen();
7531                                                }
7532                                                break;
7533                                        case 30:
7534                                                {
7535                                                setState(912);
7536                                                tfootTagOpen();
7537                                                }
7538                                                break;
7539                                        case 31:
7540                                                {
7541                                                {
7542                                                setState(913);
7543                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
7544                                                setState(914);
7545                                                match(LEADING_ASTERISK);
7546                                                }
7547                                                }
7548                                                break;
7549                                        case 32:
7550                                                {
7551                                                setState(915);
7552                                                htmlComment();
7553                                                }
7554                                                break;
7555                                        case 33:
7556                                                {
7557                                                setState(916);
7558                                                match(CDATA);
7559                                                }
7560                                                break;
7561                                        case 34:
7562                                                {
7563                                                setState(917);
7564                                                match(NEWLINE);
7565                                                }
7566                                                break;
7567                                        case 35:
7568                                                {
7569                                                setState(918);
7570                                                text();
7571                                                }
7572                                                break;
7573                                        case 36:
7574                                                {
7575                                                setState(919);
7576                                                javadocInlineTag();
7577                                                }
7578                                                break;
7579                                        }
7580                                        } 
7581                                }
7582                                setState(924);
7583                                _errHandler.sync(this);
7584                                _alt = getInterpreter().adaptivePredict(_input,61,_ctx);
7585                        }
7586                        setState(925);
7587                        dtTagClose();
7588                        }
7589                }
7590                catch (RecognitionException re) {
7591                        _localctx.exception = re;
7592                        _errHandler.reportError(this, re);
7593                        _errHandler.recover(this, re);
7594                }
7595                finally {
7596                        exitRule();
7597                }
7598                return _localctx;
7599        }
7600
7601        public static class HeadTagOpenContext extends ParserRuleContext {
7602                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7603                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7604                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7605                public List<AttributeContext> attribute() {
7606                        return getRuleContexts(AttributeContext.class);
7607                }
7608                public AttributeContext attribute(int i) {
7609                        return getRuleContext(AttributeContext.class,i);
7610                }
7611                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7612                public TerminalNode NEWLINE(int i) {
7613                        return getToken(JavadocParser.NEWLINE, i);
7614                }
7615                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7616                public TerminalNode LEADING_ASTERISK(int i) {
7617                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7618                }
7619                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7620                public TerminalNode WS(int i) {
7621                        return getToken(JavadocParser.WS, i);
7622                }
7623                public HeadTagOpenContext(ParserRuleContext parent, int invokingState) {
7624                        super(parent, invokingState);
7625                }
7626                @Override public int getRuleIndex() { return RULE_headTagOpen; }
7627                @Override
7628                public void enterRule(ParseTreeListener listener) {
7629                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagOpen(this);
7630                }
7631                @Override
7632                public void exitRule(ParseTreeListener listener) {
7633                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagOpen(this);
7634                }
7635                @Override
7636                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7637                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagOpen(this);
7638                        else return visitor.visitChildren(this);
7639                }
7640        }
7641
7642        public final HeadTagOpenContext headTagOpen() throws RecognitionException {
7643                HeadTagOpenContext _localctx = new HeadTagOpenContext(_ctx, getState());
7644                enterRule(_localctx, 66, RULE_headTagOpen);
7645                int _la;
7646                try {
7647                        enterOuterAlt(_localctx, 1);
7648                        {
7649                        setState(927);
7650                        match(OPEN);
7651                        setState(928);
7652                        match(HEAD_HTML_TAG_NAME);
7653                        setState(935);
7654                        _errHandler.sync(this);
7655                        _la = _input.LA(1);
7656                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
7657                                {
7658                                setState(933);
7659                                switch (_input.LA(1)) {
7660                                case HTML_TAG_NAME:
7661                                        {
7662                                        setState(929);
7663                                        attribute();
7664                                        }
7665                                        break;
7666                                case NEWLINE:
7667                                        {
7668                                        setState(930);
7669                                        match(NEWLINE);
7670                                        }
7671                                        break;
7672                                case LEADING_ASTERISK:
7673                                        {
7674                                        setState(931);
7675                                        match(LEADING_ASTERISK);
7676                                        }
7677                                        break;
7678                                case WS:
7679                                        {
7680                                        setState(932);
7681                                        match(WS);
7682                                        }
7683                                        break;
7684                                default:
7685                                        throw new NoViableAltException(this);
7686                                }
7687                                }
7688                                setState(937);
7689                                _errHandler.sync(this);
7690                                _la = _input.LA(1);
7691                        }
7692                        setState(938);
7693                        match(CLOSE);
7694                        }
7695                }
7696                catch (RecognitionException re) {
7697                        _localctx.exception = re;
7698                        _errHandler.reportError(this, re);
7699                        _errHandler.recover(this, re);
7700                }
7701                finally {
7702                        exitRule();
7703                }
7704                return _localctx;
7705        }
7706
7707        public static class HeadTagCloseContext extends ParserRuleContext {
7708                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7709                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
7710                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7711                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7712                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7713                public TerminalNode NEWLINE(int i) {
7714                        return getToken(JavadocParser.NEWLINE, i);
7715                }
7716                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7717                public TerminalNode LEADING_ASTERISK(int i) {
7718                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7719                }
7720                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7721                public TerminalNode WS(int i) {
7722                        return getToken(JavadocParser.WS, i);
7723                }
7724                public HeadTagCloseContext(ParserRuleContext parent, int invokingState) {
7725                        super(parent, invokingState);
7726                }
7727                @Override public int getRuleIndex() { return RULE_headTagClose; }
7728                @Override
7729                public void enterRule(ParseTreeListener listener) {
7730                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagClose(this);
7731                }
7732                @Override
7733                public void exitRule(ParseTreeListener listener) {
7734                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagClose(this);
7735                }
7736                @Override
7737                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7738                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagClose(this);
7739                        else return visitor.visitChildren(this);
7740                }
7741        }
7742
7743        public final HeadTagCloseContext headTagClose() throws RecognitionException {
7744                HeadTagCloseContext _localctx = new HeadTagCloseContext(_ctx, getState());
7745                enterRule(_localctx, 68, RULE_headTagClose);
7746                int _la;
7747                try {
7748                        enterOuterAlt(_localctx, 1);
7749                        {
7750                        setState(940);
7751                        match(OPEN);
7752                        setState(941);
7753                        match(SLASH);
7754                        setState(942);
7755                        match(HEAD_HTML_TAG_NAME);
7756                        setState(946);
7757                        _errHandler.sync(this);
7758                        _la = _input.LA(1);
7759                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
7760                                {
7761                                {
7762                                setState(943);
7763                                _la = _input.LA(1);
7764                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
7765                                _errHandler.recoverInline(this);
7766                                } else {
7767                                        consume();
7768                                }
7769                                }
7770                                }
7771                                setState(948);
7772                                _errHandler.sync(this);
7773                                _la = _input.LA(1);
7774                        }
7775                        setState(949);
7776                        match(CLOSE);
7777                        }
7778                }
7779                catch (RecognitionException re) {
7780                        _localctx.exception = re;
7781                        _errHandler.reportError(this, re);
7782                        _errHandler.recover(this, re);
7783                }
7784                finally {
7785                        exitRule();
7786                }
7787                return _localctx;
7788        }
7789
7790        public static class HeadContext extends ParserRuleContext {
7791                public HeadTagOpenContext headTagOpen() {
7792                        return getRuleContext(HeadTagOpenContext.class,0);
7793                }
7794                public HeadTagCloseContext headTagClose() {
7795                        return getRuleContext(HeadTagCloseContext.class,0);
7796                }
7797                public List<HtmlTagContext> htmlTag() {
7798                        return getRuleContexts(HtmlTagContext.class);
7799                }
7800                public HtmlTagContext htmlTag(int i) {
7801                        return getRuleContext(HtmlTagContext.class,i);
7802                }
7803                public List<SingletonTagContext> singletonTag() {
7804                        return getRuleContexts(SingletonTagContext.class);
7805                }
7806                public SingletonTagContext singletonTag(int i) {
7807                        return getRuleContext(SingletonTagContext.class,i);
7808                }
7809                public List<ParagraphContext> paragraph() {
7810                        return getRuleContexts(ParagraphContext.class);
7811                }
7812                public ParagraphContext paragraph(int i) {
7813                        return getRuleContext(ParagraphContext.class,i);
7814                }
7815                public List<LiContext> li() {
7816                        return getRuleContexts(LiContext.class);
7817                }
7818                public LiContext li(int i) {
7819                        return getRuleContext(LiContext.class,i);
7820                }
7821                public List<TrContext> tr() {
7822                        return getRuleContexts(TrContext.class);
7823                }
7824                public TrContext tr(int i) {
7825                        return getRuleContext(TrContext.class,i);
7826                }
7827                public List<TdContext> td() {
7828                        return getRuleContexts(TdContext.class);
7829                }
7830                public TdContext td(int i) {
7831                        return getRuleContext(TdContext.class,i);
7832                }
7833                public List<ThContext> th() {
7834                        return getRuleContexts(ThContext.class);
7835                }
7836                public ThContext th(int i) {
7837                        return getRuleContext(ThContext.class,i);
7838                }
7839                public List<BodyContext> body() {
7840                        return getRuleContexts(BodyContext.class);
7841                }
7842                public BodyContext body(int i) {
7843                        return getRuleContext(BodyContext.class,i);
7844                }
7845                public List<ColgroupContext> colgroup() {
7846                        return getRuleContexts(ColgroupContext.class);
7847                }
7848                public ColgroupContext colgroup(int i) {
7849                        return getRuleContext(ColgroupContext.class,i);
7850                }
7851                public List<DdContext> dd() {
7852                        return getRuleContexts(DdContext.class);
7853                }
7854                public DdContext dd(int i) {
7855                        return getRuleContext(DdContext.class,i);
7856                }
7857                public List<DtContext> dt() {
7858                        return getRuleContexts(DtContext.class);
7859                }
7860                public DtContext dt(int i) {
7861                        return getRuleContext(DtContext.class,i);
7862                }
7863                public List<HtmlContext> html() {
7864                        return getRuleContexts(HtmlContext.class);
7865                }
7866                public HtmlContext html(int i) {
7867                        return getRuleContext(HtmlContext.class,i);
7868                }
7869                public List<OptionContext> option() {
7870                        return getRuleContexts(OptionContext.class);
7871                }
7872                public OptionContext option(int i) {
7873                        return getRuleContext(OptionContext.class,i);
7874                }
7875                public List<TbodyContext> tbody() {
7876                        return getRuleContexts(TbodyContext.class);
7877                }
7878                public TbodyContext tbody(int i) {
7879                        return getRuleContext(TbodyContext.class,i);
7880                }
7881                public List<TheadContext> thead() {
7882                        return getRuleContexts(TheadContext.class);
7883                }
7884                public TheadContext thead(int i) {
7885                        return getRuleContext(TheadContext.class,i);
7886                }
7887                public List<TfootContext> tfoot() {
7888                        return getRuleContexts(TfootContext.class);
7889                }
7890                public TfootContext tfoot(int i) {
7891                        return getRuleContext(TfootContext.class,i);
7892                }
7893                public List<PTagOpenContext> pTagOpen() {
7894                        return getRuleContexts(PTagOpenContext.class);
7895                }
7896                public PTagOpenContext pTagOpen(int i) {
7897                        return getRuleContext(PTagOpenContext.class,i);
7898                }
7899                public List<LiTagOpenContext> liTagOpen() {
7900                        return getRuleContexts(LiTagOpenContext.class);
7901                }
7902                public LiTagOpenContext liTagOpen(int i) {
7903                        return getRuleContext(LiTagOpenContext.class,i);
7904                }
7905                public List<TrTagOpenContext> trTagOpen() {
7906                        return getRuleContexts(TrTagOpenContext.class);
7907                }
7908                public TrTagOpenContext trTagOpen(int i) {
7909                        return getRuleContext(TrTagOpenContext.class,i);
7910                }
7911                public List<TdTagOpenContext> tdTagOpen() {
7912                        return getRuleContexts(TdTagOpenContext.class);
7913                }
7914                public TdTagOpenContext tdTagOpen(int i) {
7915                        return getRuleContext(TdTagOpenContext.class,i);
7916                }
7917                public List<ThTagOpenContext> thTagOpen() {
7918                        return getRuleContexts(ThTagOpenContext.class);
7919                }
7920                public ThTagOpenContext thTagOpen(int i) {
7921                        return getRuleContext(ThTagOpenContext.class,i);
7922                }
7923                public List<BodyTagOpenContext> bodyTagOpen() {
7924                        return getRuleContexts(BodyTagOpenContext.class);
7925                }
7926                public BodyTagOpenContext bodyTagOpen(int i) {
7927                        return getRuleContext(BodyTagOpenContext.class,i);
7928                }
7929                public List<ColgroupTagOpenContext> colgroupTagOpen() {
7930                        return getRuleContexts(ColgroupTagOpenContext.class);
7931                }
7932                public ColgroupTagOpenContext colgroupTagOpen(int i) {
7933                        return getRuleContext(ColgroupTagOpenContext.class,i);
7934                }
7935                public List<DdTagOpenContext> ddTagOpen() {
7936                        return getRuleContexts(DdTagOpenContext.class);
7937                }
7938                public DdTagOpenContext ddTagOpen(int i) {
7939                        return getRuleContext(DdTagOpenContext.class,i);
7940                }
7941                public List<DtTagOpenContext> dtTagOpen() {
7942                        return getRuleContexts(DtTagOpenContext.class);
7943                }
7944                public DtTagOpenContext dtTagOpen(int i) {
7945                        return getRuleContext(DtTagOpenContext.class,i);
7946                }
7947                public List<HtmlTagOpenContext> htmlTagOpen() {
7948                        return getRuleContexts(HtmlTagOpenContext.class);
7949                }
7950                public HtmlTagOpenContext htmlTagOpen(int i) {
7951                        return getRuleContext(HtmlTagOpenContext.class,i);
7952                }
7953                public List<OptionTagOpenContext> optionTagOpen() {
7954                        return getRuleContexts(OptionTagOpenContext.class);
7955                }
7956                public OptionTagOpenContext optionTagOpen(int i) {
7957                        return getRuleContext(OptionTagOpenContext.class,i);
7958                }
7959                public List<TbodyTagOpenContext> tbodyTagOpen() {
7960                        return getRuleContexts(TbodyTagOpenContext.class);
7961                }
7962                public TbodyTagOpenContext tbodyTagOpen(int i) {
7963                        return getRuleContext(TbodyTagOpenContext.class,i);
7964                }
7965                public List<TheadTagOpenContext> theadTagOpen() {
7966                        return getRuleContexts(TheadTagOpenContext.class);
7967                }
7968                public TheadTagOpenContext theadTagOpen(int i) {
7969                        return getRuleContext(TheadTagOpenContext.class,i);
7970                }
7971                public List<TfootTagOpenContext> tfootTagOpen() {
7972                        return getRuleContexts(TfootTagOpenContext.class);
7973                }
7974                public TfootTagOpenContext tfootTagOpen(int i) {
7975                        return getRuleContext(TfootTagOpenContext.class,i);
7976                }
7977                public List<HtmlCommentContext> htmlComment() {
7978                        return getRuleContexts(HtmlCommentContext.class);
7979                }
7980                public HtmlCommentContext htmlComment(int i) {
7981                        return getRuleContext(HtmlCommentContext.class,i);
7982                }
7983                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
7984                public TerminalNode CDATA(int i) {
7985                        return getToken(JavadocParser.CDATA, i);
7986                }
7987                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7988                public TerminalNode NEWLINE(int i) {
7989                        return getToken(JavadocParser.NEWLINE, i);
7990                }
7991                public List<TextContext> text() {
7992                        return getRuleContexts(TextContext.class);
7993                }
7994                public TextContext text(int i) {
7995                        return getRuleContext(TextContext.class,i);
7996                }
7997                public List<JavadocInlineTagContext> javadocInlineTag() {
7998                        return getRuleContexts(JavadocInlineTagContext.class);
7999                }
8000                public JavadocInlineTagContext javadocInlineTag(int i) {
8001                        return getRuleContext(JavadocInlineTagContext.class,i);
8002                }
8003                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8004                public TerminalNode LEADING_ASTERISK(int i) {
8005                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8006                }
8007                public HeadContext(ParserRuleContext parent, int invokingState) {
8008                        super(parent, invokingState);
8009                }
8010                @Override public int getRuleIndex() { return RULE_head; }
8011                @Override
8012                public void enterRule(ParseTreeListener listener) {
8013                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHead(this);
8014                }
8015                @Override
8016                public void exitRule(ParseTreeListener listener) {
8017                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHead(this);
8018                }
8019                @Override
8020                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8021                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHead(this);
8022                        else return visitor.visitChildren(this);
8023                }
8024        }
8025
8026        public final HeadContext head() throws RecognitionException {
8027                HeadContext _localctx = new HeadContext(_ctx, getState());
8028                enterRule(_localctx, 70, RULE_head);
8029                try {
8030                        int _alt;
8031                        enterOuterAlt(_localctx, 1);
8032                        {
8033                        setState(951);
8034                        headTagOpen();
8035                        setState(991);
8036                        _errHandler.sync(this);
8037                        _alt = getInterpreter().adaptivePredict(_input,66,_ctx);
8038                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8039                                if ( _alt==1 ) {
8040                                        {
8041                                        setState(989);
8042                                        _errHandler.sync(this);
8043                                        switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
8044                                        case 1:
8045                                                {
8046                                                setState(952);
8047                                                htmlTag();
8048                                                }
8049                                                break;
8050                                        case 2:
8051                                                {
8052                                                setState(953);
8053                                                singletonTag();
8054                                                }
8055                                                break;
8056                                        case 3:
8057                                                {
8058                                                setState(954);
8059                                                paragraph();
8060                                                }
8061                                                break;
8062                                        case 4:
8063                                                {
8064                                                setState(955);
8065                                                li();
8066                                                }
8067                                                break;
8068                                        case 5:
8069                                                {
8070                                                setState(956);
8071                                                tr();
8072                                                }
8073                                                break;
8074                                        case 6:
8075                                                {
8076                                                setState(957);
8077                                                td();
8078                                                }
8079                                                break;
8080                                        case 7:
8081                                                {
8082                                                setState(958);
8083                                                th();
8084                                                }
8085                                                break;
8086                                        case 8:
8087                                                {
8088                                                setState(959);
8089                                                body();
8090                                                }
8091                                                break;
8092                                        case 9:
8093                                                {
8094                                                setState(960);
8095                                                colgroup();
8096                                                }
8097                                                break;
8098                                        case 10:
8099                                                {
8100                                                setState(961);
8101                                                dd();
8102                                                }
8103                                                break;
8104                                        case 11:
8105                                                {
8106                                                setState(962);
8107                                                dt();
8108                                                }
8109                                                break;
8110                                        case 12:
8111                                                {
8112                                                setState(963);
8113                                                html();
8114                                                }
8115                                                break;
8116                                        case 13:
8117                                                {
8118                                                setState(964);
8119                                                option();
8120                                                }
8121                                                break;
8122                                        case 14:
8123                                                {
8124                                                setState(965);
8125                                                tbody();
8126                                                }
8127                                                break;
8128                                        case 15:
8129                                                {
8130                                                setState(966);
8131                                                thead();
8132                                                }
8133                                                break;
8134                                        case 16:
8135                                                {
8136                                                setState(967);
8137                                                tfoot();
8138                                                }
8139                                                break;
8140                                        case 17:
8141                                                {
8142                                                setState(968);
8143                                                pTagOpen();
8144                                                }
8145                                                break;
8146                                        case 18:
8147                                                {
8148                                                setState(969);
8149                                                liTagOpen();
8150                                                }
8151                                                break;
8152                                        case 19:
8153                                                {
8154                                                setState(970);
8155                                                trTagOpen();
8156                                                }
8157                                                break;
8158                                        case 20:
8159                                                {
8160                                                setState(971);
8161                                                tdTagOpen();
8162                                                }
8163                                                break;
8164                                        case 21:
8165                                                {
8166                                                setState(972);
8167                                                thTagOpen();
8168                                                }
8169                                                break;
8170                                        case 22:
8171                                                {
8172                                                setState(973);
8173                                                bodyTagOpen();
8174                                                }
8175                                                break;
8176                                        case 23:
8177                                                {
8178                                                setState(974);
8179                                                colgroupTagOpen();
8180                                                }
8181                                                break;
8182                                        case 24:
8183                                                {
8184                                                setState(975);
8185                                                ddTagOpen();
8186                                                }
8187                                                break;
8188                                        case 25:
8189                                                {
8190                                                setState(976);
8191                                                dtTagOpen();
8192                                                }
8193                                                break;
8194                                        case 26:
8195                                                {
8196                                                setState(977);
8197                                                htmlTagOpen();
8198                                                }
8199                                                break;
8200                                        case 27:
8201                                                {
8202                                                setState(978);
8203                                                optionTagOpen();
8204                                                }
8205                                                break;
8206                                        case 28:
8207                                                {
8208                                                setState(979);
8209                                                tbodyTagOpen();
8210                                                }
8211                                                break;
8212                                        case 29:
8213                                                {
8214                                                setState(980);
8215                                                theadTagOpen();
8216                                                }
8217                                                break;
8218                                        case 30:
8219                                                {
8220                                                setState(981);
8221                                                tfootTagOpen();
8222                                                }
8223                                                break;
8224                                        case 31:
8225                                                {
8226                                                {
8227                                                setState(982);
8228                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
8229                                                setState(983);
8230                                                match(LEADING_ASTERISK);
8231                                                }
8232                                                }
8233                                                break;
8234                                        case 32:
8235                                                {
8236                                                setState(984);
8237                                                htmlComment();
8238                                                }
8239                                                break;
8240                                        case 33:
8241                                                {
8242                                                setState(985);
8243                                                match(CDATA);
8244                                                }
8245                                                break;
8246                                        case 34:
8247                                                {
8248                                                setState(986);
8249                                                match(NEWLINE);
8250                                                }
8251                                                break;
8252                                        case 35:
8253                                                {
8254                                                setState(987);
8255                                                text();
8256                                                }
8257                                                break;
8258                                        case 36:
8259                                                {
8260                                                setState(988);
8261                                                javadocInlineTag();
8262                                                }
8263                                                break;
8264                                        }
8265                                        } 
8266                                }
8267                                setState(993);
8268                                _errHandler.sync(this);
8269                                _alt = getInterpreter().adaptivePredict(_input,66,_ctx);
8270                        }
8271                        setState(994);
8272                        headTagClose();
8273                        }
8274                }
8275                catch (RecognitionException re) {
8276                        _localctx.exception = re;
8277                        _errHandler.reportError(this, re);
8278                        _errHandler.recover(this, re);
8279                }
8280                finally {
8281                        exitRule();
8282                }
8283                return _localctx;
8284        }
8285
8286        public static class HtmlTagOpenContext extends ParserRuleContext {
8287                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8288                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
8289                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8290                public List<AttributeContext> attribute() {
8291                        return getRuleContexts(AttributeContext.class);
8292                }
8293                public AttributeContext attribute(int i) {
8294                        return getRuleContext(AttributeContext.class,i);
8295                }
8296                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8297                public TerminalNode NEWLINE(int i) {
8298                        return getToken(JavadocParser.NEWLINE, i);
8299                }
8300                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8301                public TerminalNode LEADING_ASTERISK(int i) {
8302                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8303                }
8304                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8305                public TerminalNode WS(int i) {
8306                        return getToken(JavadocParser.WS, i);
8307                }
8308                public HtmlTagOpenContext(ParserRuleContext parent, int invokingState) {
8309                        super(parent, invokingState);
8310                }
8311                @Override public int getRuleIndex() { return RULE_htmlTagOpen; }
8312                @Override
8313                public void enterRule(ParseTreeListener listener) {
8314                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagOpen(this);
8315                }
8316                @Override
8317                public void exitRule(ParseTreeListener listener) {
8318                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagOpen(this);
8319                }
8320                @Override
8321                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8322                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagOpen(this);
8323                        else return visitor.visitChildren(this);
8324                }
8325        }
8326
8327        public final HtmlTagOpenContext htmlTagOpen() throws RecognitionException {
8328                HtmlTagOpenContext _localctx = new HtmlTagOpenContext(_ctx, getState());
8329                enterRule(_localctx, 72, RULE_htmlTagOpen);
8330                int _la;
8331                try {
8332                        enterOuterAlt(_localctx, 1);
8333                        {
8334                        setState(996);
8335                        match(OPEN);
8336                        setState(997);
8337                        match(HTML_HTML_TAG_NAME);
8338                        setState(1004);
8339                        _errHandler.sync(this);
8340                        _la = _input.LA(1);
8341                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
8342                                {
8343                                setState(1002);
8344                                switch (_input.LA(1)) {
8345                                case HTML_TAG_NAME:
8346                                        {
8347                                        setState(998);
8348                                        attribute();
8349                                        }
8350                                        break;
8351                                case NEWLINE:
8352                                        {
8353                                        setState(999);
8354                                        match(NEWLINE);
8355                                        }
8356                                        break;
8357                                case LEADING_ASTERISK:
8358                                        {
8359                                        setState(1000);
8360                                        match(LEADING_ASTERISK);
8361                                        }
8362                                        break;
8363                                case WS:
8364                                        {
8365                                        setState(1001);
8366                                        match(WS);
8367                                        }
8368                                        break;
8369                                default:
8370                                        throw new NoViableAltException(this);
8371                                }
8372                                }
8373                                setState(1006);
8374                                _errHandler.sync(this);
8375                                _la = _input.LA(1);
8376                        }
8377                        setState(1007);
8378                        match(CLOSE);
8379                        }
8380                }
8381                catch (RecognitionException re) {
8382                        _localctx.exception = re;
8383                        _errHandler.reportError(this, re);
8384                        _errHandler.recover(this, re);
8385                }
8386                finally {
8387                        exitRule();
8388                }
8389                return _localctx;
8390        }
8391
8392        public static class HtmlTagCloseContext extends ParserRuleContext {
8393                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8394                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
8395                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
8396                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8397                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8398                public TerminalNode NEWLINE(int i) {
8399                        return getToken(JavadocParser.NEWLINE, i);
8400                }
8401                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8402                public TerminalNode LEADING_ASTERISK(int i) {
8403                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8404                }
8405                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8406                public TerminalNode WS(int i) {
8407                        return getToken(JavadocParser.WS, i);
8408                }
8409                public HtmlTagCloseContext(ParserRuleContext parent, int invokingState) {
8410                        super(parent, invokingState);
8411                }
8412                @Override public int getRuleIndex() { return RULE_htmlTagClose; }
8413                @Override
8414                public void enterRule(ParseTreeListener listener) {
8415                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagClose(this);
8416                }
8417                @Override
8418                public void exitRule(ParseTreeListener listener) {
8419                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagClose(this);
8420                }
8421                @Override
8422                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8423                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagClose(this);
8424                        else return visitor.visitChildren(this);
8425                }
8426        }
8427
8428        public final HtmlTagCloseContext htmlTagClose() throws RecognitionException {
8429                HtmlTagCloseContext _localctx = new HtmlTagCloseContext(_ctx, getState());
8430                enterRule(_localctx, 74, RULE_htmlTagClose);
8431                int _la;
8432                try {
8433                        enterOuterAlt(_localctx, 1);
8434                        {
8435                        setState(1009);
8436                        match(OPEN);
8437                        setState(1010);
8438                        match(SLASH);
8439                        setState(1011);
8440                        match(HTML_HTML_TAG_NAME);
8441                        setState(1015);
8442                        _errHandler.sync(this);
8443                        _la = _input.LA(1);
8444                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
8445                                {
8446                                {
8447                                setState(1012);
8448                                _la = _input.LA(1);
8449                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
8450                                _errHandler.recoverInline(this);
8451                                } else {
8452                                        consume();
8453                                }
8454                                }
8455                                }
8456                                setState(1017);
8457                                _errHandler.sync(this);
8458                                _la = _input.LA(1);
8459                        }
8460                        setState(1018);
8461                        match(CLOSE);
8462                        }
8463                }
8464                catch (RecognitionException re) {
8465                        _localctx.exception = re;
8466                        _errHandler.reportError(this, re);
8467                        _errHandler.recover(this, re);
8468                }
8469                finally {
8470                        exitRule();
8471                }
8472                return _localctx;
8473        }
8474
8475        public static class HtmlContext extends ParserRuleContext {
8476                public HtmlTagOpenContext htmlTagOpen() {
8477                        return getRuleContext(HtmlTagOpenContext.class,0);
8478                }
8479                public HtmlTagCloseContext htmlTagClose() {
8480                        return getRuleContext(HtmlTagCloseContext.class,0);
8481                }
8482                public List<HtmlTagContext> htmlTag() {
8483                        return getRuleContexts(HtmlTagContext.class);
8484                }
8485                public HtmlTagContext htmlTag(int i) {
8486                        return getRuleContext(HtmlTagContext.class,i);
8487                }
8488                public List<SingletonTagContext> singletonTag() {
8489                        return getRuleContexts(SingletonTagContext.class);
8490                }
8491                public SingletonTagContext singletonTag(int i) {
8492                        return getRuleContext(SingletonTagContext.class,i);
8493                }
8494                public List<ParagraphContext> paragraph() {
8495                        return getRuleContexts(ParagraphContext.class);
8496                }
8497                public ParagraphContext paragraph(int i) {
8498                        return getRuleContext(ParagraphContext.class,i);
8499                }
8500                public List<LiContext> li() {
8501                        return getRuleContexts(LiContext.class);
8502                }
8503                public LiContext li(int i) {
8504                        return getRuleContext(LiContext.class,i);
8505                }
8506                public List<TrContext> tr() {
8507                        return getRuleContexts(TrContext.class);
8508                }
8509                public TrContext tr(int i) {
8510                        return getRuleContext(TrContext.class,i);
8511                }
8512                public List<TdContext> td() {
8513                        return getRuleContexts(TdContext.class);
8514                }
8515                public TdContext td(int i) {
8516                        return getRuleContext(TdContext.class,i);
8517                }
8518                public List<ThContext> th() {
8519                        return getRuleContexts(ThContext.class);
8520                }
8521                public ThContext th(int i) {
8522                        return getRuleContext(ThContext.class,i);
8523                }
8524                public List<BodyContext> body() {
8525                        return getRuleContexts(BodyContext.class);
8526                }
8527                public BodyContext body(int i) {
8528                        return getRuleContext(BodyContext.class,i);
8529                }
8530                public List<ColgroupContext> colgroup() {
8531                        return getRuleContexts(ColgroupContext.class);
8532                }
8533                public ColgroupContext colgroup(int i) {
8534                        return getRuleContext(ColgroupContext.class,i);
8535                }
8536                public List<DdContext> dd() {
8537                        return getRuleContexts(DdContext.class);
8538                }
8539                public DdContext dd(int i) {
8540                        return getRuleContext(DdContext.class,i);
8541                }
8542                public List<DtContext> dt() {
8543                        return getRuleContexts(DtContext.class);
8544                }
8545                public DtContext dt(int i) {
8546                        return getRuleContext(DtContext.class,i);
8547                }
8548                public List<HeadContext> head() {
8549                        return getRuleContexts(HeadContext.class);
8550                }
8551                public HeadContext head(int i) {
8552                        return getRuleContext(HeadContext.class,i);
8553                }
8554                public List<OptionContext> option() {
8555                        return getRuleContexts(OptionContext.class);
8556                }
8557                public OptionContext option(int i) {
8558                        return getRuleContext(OptionContext.class,i);
8559                }
8560                public List<TbodyContext> tbody() {
8561                        return getRuleContexts(TbodyContext.class);
8562                }
8563                public TbodyContext tbody(int i) {
8564                        return getRuleContext(TbodyContext.class,i);
8565                }
8566                public List<TheadContext> thead() {
8567                        return getRuleContexts(TheadContext.class);
8568                }
8569                public TheadContext thead(int i) {
8570                        return getRuleContext(TheadContext.class,i);
8571                }
8572                public List<TfootContext> tfoot() {
8573                        return getRuleContexts(TfootContext.class);
8574                }
8575                public TfootContext tfoot(int i) {
8576                        return getRuleContext(TfootContext.class,i);
8577                }
8578                public List<PTagOpenContext> pTagOpen() {
8579                        return getRuleContexts(PTagOpenContext.class);
8580                }
8581                public PTagOpenContext pTagOpen(int i) {
8582                        return getRuleContext(PTagOpenContext.class,i);
8583                }
8584                public List<LiTagOpenContext> liTagOpen() {
8585                        return getRuleContexts(LiTagOpenContext.class);
8586                }
8587                public LiTagOpenContext liTagOpen(int i) {
8588                        return getRuleContext(LiTagOpenContext.class,i);
8589                }
8590                public List<TrTagOpenContext> trTagOpen() {
8591                        return getRuleContexts(TrTagOpenContext.class);
8592                }
8593                public TrTagOpenContext trTagOpen(int i) {
8594                        return getRuleContext(TrTagOpenContext.class,i);
8595                }
8596                public List<TdTagOpenContext> tdTagOpen() {
8597                        return getRuleContexts(TdTagOpenContext.class);
8598                }
8599                public TdTagOpenContext tdTagOpen(int i) {
8600                        return getRuleContext(TdTagOpenContext.class,i);
8601                }
8602                public List<ThTagOpenContext> thTagOpen() {
8603                        return getRuleContexts(ThTagOpenContext.class);
8604                }
8605                public ThTagOpenContext thTagOpen(int i) {
8606                        return getRuleContext(ThTagOpenContext.class,i);
8607                }
8608                public List<BodyTagOpenContext> bodyTagOpen() {
8609                        return getRuleContexts(BodyTagOpenContext.class);
8610                }
8611                public BodyTagOpenContext bodyTagOpen(int i) {
8612                        return getRuleContext(BodyTagOpenContext.class,i);
8613                }
8614                public List<ColgroupTagOpenContext> colgroupTagOpen() {
8615                        return getRuleContexts(ColgroupTagOpenContext.class);
8616                }
8617                public ColgroupTagOpenContext colgroupTagOpen(int i) {
8618                        return getRuleContext(ColgroupTagOpenContext.class,i);
8619                }
8620                public List<DdTagOpenContext> ddTagOpen() {
8621                        return getRuleContexts(DdTagOpenContext.class);
8622                }
8623                public DdTagOpenContext ddTagOpen(int i) {
8624                        return getRuleContext(DdTagOpenContext.class,i);
8625                }
8626                public List<DtTagOpenContext> dtTagOpen() {
8627                        return getRuleContexts(DtTagOpenContext.class);
8628                }
8629                public DtTagOpenContext dtTagOpen(int i) {
8630                        return getRuleContext(DtTagOpenContext.class,i);
8631                }
8632                public List<HeadTagOpenContext> headTagOpen() {
8633                        return getRuleContexts(HeadTagOpenContext.class);
8634                }
8635                public HeadTagOpenContext headTagOpen(int i) {
8636                        return getRuleContext(HeadTagOpenContext.class,i);
8637                }
8638                public List<OptionTagOpenContext> optionTagOpen() {
8639                        return getRuleContexts(OptionTagOpenContext.class);
8640                }
8641                public OptionTagOpenContext optionTagOpen(int i) {
8642                        return getRuleContext(OptionTagOpenContext.class,i);
8643                }
8644                public List<TbodyTagOpenContext> tbodyTagOpen() {
8645                        return getRuleContexts(TbodyTagOpenContext.class);
8646                }
8647                public TbodyTagOpenContext tbodyTagOpen(int i) {
8648                        return getRuleContext(TbodyTagOpenContext.class,i);
8649                }
8650                public List<TheadTagOpenContext> theadTagOpen() {
8651                        return getRuleContexts(TheadTagOpenContext.class);
8652                }
8653                public TheadTagOpenContext theadTagOpen(int i) {
8654                        return getRuleContext(TheadTagOpenContext.class,i);
8655                }
8656                public List<TfootTagOpenContext> tfootTagOpen() {
8657                        return getRuleContexts(TfootTagOpenContext.class);
8658                }
8659                public TfootTagOpenContext tfootTagOpen(int i) {
8660                        return getRuleContext(TfootTagOpenContext.class,i);
8661                }
8662                public List<HtmlCommentContext> htmlComment() {
8663                        return getRuleContexts(HtmlCommentContext.class);
8664                }
8665                public HtmlCommentContext htmlComment(int i) {
8666                        return getRuleContext(HtmlCommentContext.class,i);
8667                }
8668                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
8669                public TerminalNode CDATA(int i) {
8670                        return getToken(JavadocParser.CDATA, i);
8671                }
8672                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8673                public TerminalNode NEWLINE(int i) {
8674                        return getToken(JavadocParser.NEWLINE, i);
8675                }
8676                public List<TextContext> text() {
8677                        return getRuleContexts(TextContext.class);
8678                }
8679                public TextContext text(int i) {
8680                        return getRuleContext(TextContext.class,i);
8681                }
8682                public List<JavadocInlineTagContext> javadocInlineTag() {
8683                        return getRuleContexts(JavadocInlineTagContext.class);
8684                }
8685                public JavadocInlineTagContext javadocInlineTag(int i) {
8686                        return getRuleContext(JavadocInlineTagContext.class,i);
8687                }
8688                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8689                public TerminalNode LEADING_ASTERISK(int i) {
8690                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8691                }
8692                public HtmlContext(ParserRuleContext parent, int invokingState) {
8693                        super(parent, invokingState);
8694                }
8695                @Override public int getRuleIndex() { return RULE_html; }
8696                @Override
8697                public void enterRule(ParseTreeListener listener) {
8698                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtml(this);
8699                }
8700                @Override
8701                public void exitRule(ParseTreeListener listener) {
8702                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtml(this);
8703                }
8704                @Override
8705                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8706                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtml(this);
8707                        else return visitor.visitChildren(this);
8708                }
8709        }
8710
8711        public final HtmlContext html() throws RecognitionException {
8712                HtmlContext _localctx = new HtmlContext(_ctx, getState());
8713                enterRule(_localctx, 76, RULE_html);
8714                try {
8715                        int _alt;
8716                        enterOuterAlt(_localctx, 1);
8717                        {
8718                        setState(1020);
8719                        htmlTagOpen();
8720                        setState(1060);
8721                        _errHandler.sync(this);
8722                        _alt = getInterpreter().adaptivePredict(_input,71,_ctx);
8723                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8724                                if ( _alt==1 ) {
8725                                        {
8726                                        setState(1058);
8727                                        _errHandler.sync(this);
8728                                        switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
8729                                        case 1:
8730                                                {
8731                                                setState(1021);
8732                                                htmlTag();
8733                                                }
8734                                                break;
8735                                        case 2:
8736                                                {
8737                                                setState(1022);
8738                                                singletonTag();
8739                                                }
8740                                                break;
8741                                        case 3:
8742                                                {
8743                                                setState(1023);
8744                                                paragraph();
8745                                                }
8746                                                break;
8747                                        case 4:
8748                                                {
8749                                                setState(1024);
8750                                                li();
8751                                                }
8752                                                break;
8753                                        case 5:
8754                                                {
8755                                                setState(1025);
8756                                                tr();
8757                                                }
8758                                                break;
8759                                        case 6:
8760                                                {
8761                                                setState(1026);
8762                                                td();
8763                                                }
8764                                                break;
8765                                        case 7:
8766                                                {
8767                                                setState(1027);
8768                                                th();
8769                                                }
8770                                                break;
8771                                        case 8:
8772                                                {
8773                                                setState(1028);
8774                                                body();
8775                                                }
8776                                                break;
8777                                        case 9:
8778                                                {
8779                                                setState(1029);
8780                                                colgroup();
8781                                                }
8782                                                break;
8783                                        case 10:
8784                                                {
8785                                                setState(1030);
8786                                                dd();
8787                                                }
8788                                                break;
8789                                        case 11:
8790                                                {
8791                                                setState(1031);
8792                                                dt();
8793                                                }
8794                                                break;
8795                                        case 12:
8796                                                {
8797                                                setState(1032);
8798                                                head();
8799                                                }
8800                                                break;
8801                                        case 13:
8802                                                {
8803                                                setState(1033);
8804                                                option();
8805                                                }
8806                                                break;
8807                                        case 14:
8808                                                {
8809                                                setState(1034);
8810                                                tbody();
8811                                                }
8812                                                break;
8813                                        case 15:
8814                                                {
8815                                                setState(1035);
8816                                                thead();
8817                                                }
8818                                                break;
8819                                        case 16:
8820                                                {
8821                                                setState(1036);
8822                                                tfoot();
8823                                                }
8824                                                break;
8825                                        case 17:
8826                                                {
8827                                                setState(1037);
8828                                                pTagOpen();
8829                                                }
8830                                                break;
8831                                        case 18:
8832                                                {
8833                                                setState(1038);
8834                                                liTagOpen();
8835                                                }
8836                                                break;
8837                                        case 19:
8838                                                {
8839                                                setState(1039);
8840                                                trTagOpen();
8841                                                }
8842                                                break;
8843                                        case 20:
8844                                                {
8845                                                setState(1040);
8846                                                tdTagOpen();
8847                                                }
8848                                                break;
8849                                        case 21:
8850                                                {
8851                                                setState(1041);
8852                                                thTagOpen();
8853                                                }
8854                                                break;
8855                                        case 22:
8856                                                {
8857                                                setState(1042);
8858                                                bodyTagOpen();
8859                                                }
8860                                                break;
8861                                        case 23:
8862                                                {
8863                                                setState(1043);
8864                                                colgroupTagOpen();
8865                                                }
8866                                                break;
8867                                        case 24:
8868                                                {
8869                                                setState(1044);
8870                                                ddTagOpen();
8871                                                }
8872                                                break;
8873                                        case 25:
8874                                                {
8875                                                setState(1045);
8876                                                dtTagOpen();
8877                                                }
8878                                                break;
8879                                        case 26:
8880                                                {
8881                                                setState(1046);
8882                                                headTagOpen();
8883                                                }
8884                                                break;
8885                                        case 27:
8886                                                {
8887                                                setState(1047);
8888                                                optionTagOpen();
8889                                                }
8890                                                break;
8891                                        case 28:
8892                                                {
8893                                                setState(1048);
8894                                                tbodyTagOpen();
8895                                                }
8896                                                break;
8897                                        case 29:
8898                                                {
8899                                                setState(1049);
8900                                                theadTagOpen();
8901                                                }
8902                                                break;
8903                                        case 30:
8904                                                {
8905                                                setState(1050);
8906                                                tfootTagOpen();
8907                                                }
8908                                                break;
8909                                        case 31:
8910                                                {
8911                                                {
8912                                                setState(1051);
8913                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
8914                                                setState(1052);
8915                                                match(LEADING_ASTERISK);
8916                                                }
8917                                                }
8918                                                break;
8919                                        case 32:
8920                                                {
8921                                                setState(1053);
8922                                                htmlComment();
8923                                                }
8924                                                break;
8925                                        case 33:
8926                                                {
8927                                                setState(1054);
8928                                                match(CDATA);
8929                                                }
8930                                                break;
8931                                        case 34:
8932                                                {
8933                                                setState(1055);
8934                                                match(NEWLINE);
8935                                                }
8936                                                break;
8937                                        case 35:
8938                                                {
8939                                                setState(1056);
8940                                                text();
8941                                                }
8942                                                break;
8943                                        case 36:
8944                                                {
8945                                                setState(1057);
8946                                                javadocInlineTag();
8947                                                }
8948                                                break;
8949                                        }
8950                                        } 
8951                                }
8952                                setState(1062);
8953                                _errHandler.sync(this);
8954                                _alt = getInterpreter().adaptivePredict(_input,71,_ctx);
8955                        }
8956                        setState(1063);
8957                        htmlTagClose();
8958                        }
8959                }
8960                catch (RecognitionException re) {
8961                        _localctx.exception = re;
8962                        _errHandler.reportError(this, re);
8963                        _errHandler.recover(this, re);
8964                }
8965                finally {
8966                        exitRule();
8967                }
8968                return _localctx;
8969        }
8970
8971        public static class OptionTagOpenContext extends ParserRuleContext {
8972                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8973                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
8974                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8975                public List<AttributeContext> attribute() {
8976                        return getRuleContexts(AttributeContext.class);
8977                }
8978                public AttributeContext attribute(int i) {
8979                        return getRuleContext(AttributeContext.class,i);
8980                }
8981                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8982                public TerminalNode NEWLINE(int i) {
8983                        return getToken(JavadocParser.NEWLINE, i);
8984                }
8985                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8986                public TerminalNode LEADING_ASTERISK(int i) {
8987                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8988                }
8989                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8990                public TerminalNode WS(int i) {
8991                        return getToken(JavadocParser.WS, i);
8992                }
8993                public OptionTagOpenContext(ParserRuleContext parent, int invokingState) {
8994                        super(parent, invokingState);
8995                }
8996                @Override public int getRuleIndex() { return RULE_optionTagOpen; }
8997                @Override
8998                public void enterRule(ParseTreeListener listener) {
8999                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagOpen(this);
9000                }
9001                @Override
9002                public void exitRule(ParseTreeListener listener) {
9003                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagOpen(this);
9004                }
9005                @Override
9006                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9007                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagOpen(this);
9008                        else return visitor.visitChildren(this);
9009                }
9010        }
9011
9012        public final OptionTagOpenContext optionTagOpen() throws RecognitionException {
9013                OptionTagOpenContext _localctx = new OptionTagOpenContext(_ctx, getState());
9014                enterRule(_localctx, 78, RULE_optionTagOpen);
9015                int _la;
9016                try {
9017                        enterOuterAlt(_localctx, 1);
9018                        {
9019                        setState(1065);
9020                        match(OPEN);
9021                        setState(1066);
9022                        match(OPTION_HTML_TAG_NAME);
9023                        setState(1073);
9024                        _errHandler.sync(this);
9025                        _la = _input.LA(1);
9026                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
9027                                {
9028                                setState(1071);
9029                                switch (_input.LA(1)) {
9030                                case HTML_TAG_NAME:
9031                                        {
9032                                        setState(1067);
9033                                        attribute();
9034                                        }
9035                                        break;
9036                                case NEWLINE:
9037                                        {
9038                                        setState(1068);
9039                                        match(NEWLINE);
9040                                        }
9041                                        break;
9042                                case LEADING_ASTERISK:
9043                                        {
9044                                        setState(1069);
9045                                        match(LEADING_ASTERISK);
9046                                        }
9047                                        break;
9048                                case WS:
9049                                        {
9050                                        setState(1070);
9051                                        match(WS);
9052                                        }
9053                                        break;
9054                                default:
9055                                        throw new NoViableAltException(this);
9056                                }
9057                                }
9058                                setState(1075);
9059                                _errHandler.sync(this);
9060                                _la = _input.LA(1);
9061                        }
9062                        setState(1076);
9063                        match(CLOSE);
9064                        }
9065                }
9066                catch (RecognitionException re) {
9067                        _localctx.exception = re;
9068                        _errHandler.reportError(this, re);
9069                        _errHandler.recover(this, re);
9070                }
9071                finally {
9072                        exitRule();
9073                }
9074                return _localctx;
9075        }
9076
9077        public static class OptionTagCloseContext extends ParserRuleContext {
9078                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9079                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
9080                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
9081                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9082                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9083                public TerminalNode NEWLINE(int i) {
9084                        return getToken(JavadocParser.NEWLINE, i);
9085                }
9086                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9087                public TerminalNode LEADING_ASTERISK(int i) {
9088                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9089                }
9090                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9091                public TerminalNode WS(int i) {
9092                        return getToken(JavadocParser.WS, i);
9093                }
9094                public OptionTagCloseContext(ParserRuleContext parent, int invokingState) {
9095                        super(parent, invokingState);
9096                }
9097                @Override public int getRuleIndex() { return RULE_optionTagClose; }
9098                @Override
9099                public void enterRule(ParseTreeListener listener) {
9100                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagClose(this);
9101                }
9102                @Override
9103                public void exitRule(ParseTreeListener listener) {
9104                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagClose(this);
9105                }
9106                @Override
9107                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9108                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagClose(this);
9109                        else return visitor.visitChildren(this);
9110                }
9111        }
9112
9113        public final OptionTagCloseContext optionTagClose() throws RecognitionException {
9114                OptionTagCloseContext _localctx = new OptionTagCloseContext(_ctx, getState());
9115                enterRule(_localctx, 80, RULE_optionTagClose);
9116                int _la;
9117                try {
9118                        enterOuterAlt(_localctx, 1);
9119                        {
9120                        setState(1078);
9121                        match(OPEN);
9122                        setState(1079);
9123                        match(SLASH);
9124                        setState(1080);
9125                        match(OPTION_HTML_TAG_NAME);
9126                        setState(1084);
9127                        _errHandler.sync(this);
9128                        _la = _input.LA(1);
9129                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
9130                                {
9131                                {
9132                                setState(1081);
9133                                _la = _input.LA(1);
9134                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
9135                                _errHandler.recoverInline(this);
9136                                } else {
9137                                        consume();
9138                                }
9139                                }
9140                                }
9141                                setState(1086);
9142                                _errHandler.sync(this);
9143                                _la = _input.LA(1);
9144                        }
9145                        setState(1087);
9146                        match(CLOSE);
9147                        }
9148                }
9149                catch (RecognitionException re) {
9150                        _localctx.exception = re;
9151                        _errHandler.reportError(this, re);
9152                        _errHandler.recover(this, re);
9153                }
9154                finally {
9155                        exitRule();
9156                }
9157                return _localctx;
9158        }
9159
9160        public static class OptionContext extends ParserRuleContext {
9161                public OptionTagOpenContext optionTagOpen() {
9162                        return getRuleContext(OptionTagOpenContext.class,0);
9163                }
9164                public OptionTagCloseContext optionTagClose() {
9165                        return getRuleContext(OptionTagCloseContext.class,0);
9166                }
9167                public List<HtmlTagContext> htmlTag() {
9168                        return getRuleContexts(HtmlTagContext.class);
9169                }
9170                public HtmlTagContext htmlTag(int i) {
9171                        return getRuleContext(HtmlTagContext.class,i);
9172                }
9173                public List<SingletonTagContext> singletonTag() {
9174                        return getRuleContexts(SingletonTagContext.class);
9175                }
9176                public SingletonTagContext singletonTag(int i) {
9177                        return getRuleContext(SingletonTagContext.class,i);
9178                }
9179                public List<ParagraphContext> paragraph() {
9180                        return getRuleContexts(ParagraphContext.class);
9181                }
9182                public ParagraphContext paragraph(int i) {
9183                        return getRuleContext(ParagraphContext.class,i);
9184                }
9185                public List<LiContext> li() {
9186                        return getRuleContexts(LiContext.class);
9187                }
9188                public LiContext li(int i) {
9189                        return getRuleContext(LiContext.class,i);
9190                }
9191                public List<TrContext> tr() {
9192                        return getRuleContexts(TrContext.class);
9193                }
9194                public TrContext tr(int i) {
9195                        return getRuleContext(TrContext.class,i);
9196                }
9197                public List<TdContext> td() {
9198                        return getRuleContexts(TdContext.class);
9199                }
9200                public TdContext td(int i) {
9201                        return getRuleContext(TdContext.class,i);
9202                }
9203                public List<ThContext> th() {
9204                        return getRuleContexts(ThContext.class);
9205                }
9206                public ThContext th(int i) {
9207                        return getRuleContext(ThContext.class,i);
9208                }
9209                public List<BodyContext> body() {
9210                        return getRuleContexts(BodyContext.class);
9211                }
9212                public BodyContext body(int i) {
9213                        return getRuleContext(BodyContext.class,i);
9214                }
9215                public List<ColgroupContext> colgroup() {
9216                        return getRuleContexts(ColgroupContext.class);
9217                }
9218                public ColgroupContext colgroup(int i) {
9219                        return getRuleContext(ColgroupContext.class,i);
9220                }
9221                public List<DdContext> dd() {
9222                        return getRuleContexts(DdContext.class);
9223                }
9224                public DdContext dd(int i) {
9225                        return getRuleContext(DdContext.class,i);
9226                }
9227                public List<DtContext> dt() {
9228                        return getRuleContexts(DtContext.class);
9229                }
9230                public DtContext dt(int i) {
9231                        return getRuleContext(DtContext.class,i);
9232                }
9233                public List<HeadContext> head() {
9234                        return getRuleContexts(HeadContext.class);
9235                }
9236                public HeadContext head(int i) {
9237                        return getRuleContext(HeadContext.class,i);
9238                }
9239                public List<HtmlContext> html() {
9240                        return getRuleContexts(HtmlContext.class);
9241                }
9242                public HtmlContext html(int i) {
9243                        return getRuleContext(HtmlContext.class,i);
9244                }
9245                public List<TbodyContext> tbody() {
9246                        return getRuleContexts(TbodyContext.class);
9247                }
9248                public TbodyContext tbody(int i) {
9249                        return getRuleContext(TbodyContext.class,i);
9250                }
9251                public List<TheadContext> thead() {
9252                        return getRuleContexts(TheadContext.class);
9253                }
9254                public TheadContext thead(int i) {
9255                        return getRuleContext(TheadContext.class,i);
9256                }
9257                public List<TfootContext> tfoot() {
9258                        return getRuleContexts(TfootContext.class);
9259                }
9260                public TfootContext tfoot(int i) {
9261                        return getRuleContext(TfootContext.class,i);
9262                }
9263                public List<PTagOpenContext> pTagOpen() {
9264                        return getRuleContexts(PTagOpenContext.class);
9265                }
9266                public PTagOpenContext pTagOpen(int i) {
9267                        return getRuleContext(PTagOpenContext.class,i);
9268                }
9269                public List<LiTagOpenContext> liTagOpen() {
9270                        return getRuleContexts(LiTagOpenContext.class);
9271                }
9272                public LiTagOpenContext liTagOpen(int i) {
9273                        return getRuleContext(LiTagOpenContext.class,i);
9274                }
9275                public List<TrTagOpenContext> trTagOpen() {
9276                        return getRuleContexts(TrTagOpenContext.class);
9277                }
9278                public TrTagOpenContext trTagOpen(int i) {
9279                        return getRuleContext(TrTagOpenContext.class,i);
9280                }
9281                public List<TdTagOpenContext> tdTagOpen() {
9282                        return getRuleContexts(TdTagOpenContext.class);
9283                }
9284                public TdTagOpenContext tdTagOpen(int i) {
9285                        return getRuleContext(TdTagOpenContext.class,i);
9286                }
9287                public List<ThTagOpenContext> thTagOpen() {
9288                        return getRuleContexts(ThTagOpenContext.class);
9289                }
9290                public ThTagOpenContext thTagOpen(int i) {
9291                        return getRuleContext(ThTagOpenContext.class,i);
9292                }
9293                public List<BodyTagOpenContext> bodyTagOpen() {
9294                        return getRuleContexts(BodyTagOpenContext.class);
9295                }
9296                public BodyTagOpenContext bodyTagOpen(int i) {
9297                        return getRuleContext(BodyTagOpenContext.class,i);
9298                }
9299                public List<ColgroupTagOpenContext> colgroupTagOpen() {
9300                        return getRuleContexts(ColgroupTagOpenContext.class);
9301                }
9302                public ColgroupTagOpenContext colgroupTagOpen(int i) {
9303                        return getRuleContext(ColgroupTagOpenContext.class,i);
9304                }
9305                public List<DdTagOpenContext> ddTagOpen() {
9306                        return getRuleContexts(DdTagOpenContext.class);
9307                }
9308                public DdTagOpenContext ddTagOpen(int i) {
9309                        return getRuleContext(DdTagOpenContext.class,i);
9310                }
9311                public List<DtTagOpenContext> dtTagOpen() {
9312                        return getRuleContexts(DtTagOpenContext.class);
9313                }
9314                public DtTagOpenContext dtTagOpen(int i) {
9315                        return getRuleContext(DtTagOpenContext.class,i);
9316                }
9317                public List<HeadTagOpenContext> headTagOpen() {
9318                        return getRuleContexts(HeadTagOpenContext.class);
9319                }
9320                public HeadTagOpenContext headTagOpen(int i) {
9321                        return getRuleContext(HeadTagOpenContext.class,i);
9322                }
9323                public List<HtmlTagOpenContext> htmlTagOpen() {
9324                        return getRuleContexts(HtmlTagOpenContext.class);
9325                }
9326                public HtmlTagOpenContext htmlTagOpen(int i) {
9327                        return getRuleContext(HtmlTagOpenContext.class,i);
9328                }
9329                public List<TbodyTagOpenContext> tbodyTagOpen() {
9330                        return getRuleContexts(TbodyTagOpenContext.class);
9331                }
9332                public TbodyTagOpenContext tbodyTagOpen(int i) {
9333                        return getRuleContext(TbodyTagOpenContext.class,i);
9334                }
9335                public List<TheadTagOpenContext> theadTagOpen() {
9336                        return getRuleContexts(TheadTagOpenContext.class);
9337                }
9338                public TheadTagOpenContext theadTagOpen(int i) {
9339                        return getRuleContext(TheadTagOpenContext.class,i);
9340                }
9341                public List<TfootTagOpenContext> tfootTagOpen() {
9342                        return getRuleContexts(TfootTagOpenContext.class);
9343                }
9344                public TfootTagOpenContext tfootTagOpen(int i) {
9345                        return getRuleContext(TfootTagOpenContext.class,i);
9346                }
9347                public List<HtmlCommentContext> htmlComment() {
9348                        return getRuleContexts(HtmlCommentContext.class);
9349                }
9350                public HtmlCommentContext htmlComment(int i) {
9351                        return getRuleContext(HtmlCommentContext.class,i);
9352                }
9353                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
9354                public TerminalNode CDATA(int i) {
9355                        return getToken(JavadocParser.CDATA, i);
9356                }
9357                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9358                public TerminalNode NEWLINE(int i) {
9359                        return getToken(JavadocParser.NEWLINE, i);
9360                }
9361                public List<TextContext> text() {
9362                        return getRuleContexts(TextContext.class);
9363                }
9364                public TextContext text(int i) {
9365                        return getRuleContext(TextContext.class,i);
9366                }
9367                public List<JavadocInlineTagContext> javadocInlineTag() {
9368                        return getRuleContexts(JavadocInlineTagContext.class);
9369                }
9370                public JavadocInlineTagContext javadocInlineTag(int i) {
9371                        return getRuleContext(JavadocInlineTagContext.class,i);
9372                }
9373                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9374                public TerminalNode LEADING_ASTERISK(int i) {
9375                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9376                }
9377                public OptionContext(ParserRuleContext parent, int invokingState) {
9378                        super(parent, invokingState);
9379                }
9380                @Override public int getRuleIndex() { return RULE_option; }
9381                @Override
9382                public void enterRule(ParseTreeListener listener) {
9383                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOption(this);
9384                }
9385                @Override
9386                public void exitRule(ParseTreeListener listener) {
9387                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOption(this);
9388                }
9389                @Override
9390                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9391                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOption(this);
9392                        else return visitor.visitChildren(this);
9393                }
9394        }
9395
9396        public final OptionContext option() throws RecognitionException {
9397                OptionContext _localctx = new OptionContext(_ctx, getState());
9398                enterRule(_localctx, 82, RULE_option);
9399                try {
9400                        int _alt;
9401                        enterOuterAlt(_localctx, 1);
9402                        {
9403                        setState(1089);
9404                        optionTagOpen();
9405                        setState(1129);
9406                        _errHandler.sync(this);
9407                        _alt = getInterpreter().adaptivePredict(_input,76,_ctx);
9408                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
9409                                if ( _alt==1 ) {
9410                                        {
9411                                        setState(1127);
9412                                        _errHandler.sync(this);
9413                                        switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
9414                                        case 1:
9415                                                {
9416                                                setState(1090);
9417                                                htmlTag();
9418                                                }
9419                                                break;
9420                                        case 2:
9421                                                {
9422                                                setState(1091);
9423                                                singletonTag();
9424                                                }
9425                                                break;
9426                                        case 3:
9427                                                {
9428                                                setState(1092);
9429                                                paragraph();
9430                                                }
9431                                                break;
9432                                        case 4:
9433                                                {
9434                                                setState(1093);
9435                                                li();
9436                                                }
9437                                                break;
9438                                        case 5:
9439                                                {
9440                                                setState(1094);
9441                                                tr();
9442                                                }
9443                                                break;
9444                                        case 6:
9445                                                {
9446                                                setState(1095);
9447                                                td();
9448                                                }
9449                                                break;
9450                                        case 7:
9451                                                {
9452                                                setState(1096);
9453                                                th();
9454                                                }
9455                                                break;
9456                                        case 8:
9457                                                {
9458                                                setState(1097);
9459                                                body();
9460                                                }
9461                                                break;
9462                                        case 9:
9463                                                {
9464                                                setState(1098);
9465                                                colgroup();
9466                                                }
9467                                                break;
9468                                        case 10:
9469                                                {
9470                                                setState(1099);
9471                                                dd();
9472                                                }
9473                                                break;
9474                                        case 11:
9475                                                {
9476                                                setState(1100);
9477                                                dt();
9478                                                }
9479                                                break;
9480                                        case 12:
9481                                                {
9482                                                setState(1101);
9483                                                head();
9484                                                }
9485                                                break;
9486                                        case 13:
9487                                                {
9488                                                setState(1102);
9489                                                html();
9490                                                }
9491                                                break;
9492                                        case 14:
9493                                                {
9494                                                setState(1103);
9495                                                tbody();
9496                                                }
9497                                                break;
9498                                        case 15:
9499                                                {
9500                                                setState(1104);
9501                                                thead();
9502                                                }
9503                                                break;
9504                                        case 16:
9505                                                {
9506                                                setState(1105);
9507                                                tfoot();
9508                                                }
9509                                                break;
9510                                        case 17:
9511                                                {
9512                                                setState(1106);
9513                                                pTagOpen();
9514                                                }
9515                                                break;
9516                                        case 18:
9517                                                {
9518                                                setState(1107);
9519                                                liTagOpen();
9520                                                }
9521                                                break;
9522                                        case 19:
9523                                                {
9524                                                setState(1108);
9525                                                trTagOpen();
9526                                                }
9527                                                break;
9528                                        case 20:
9529                                                {
9530                                                setState(1109);
9531                                                tdTagOpen();
9532                                                }
9533                                                break;
9534                                        case 21:
9535                                                {
9536                                                setState(1110);
9537                                                thTagOpen();
9538                                                }
9539                                                break;
9540                                        case 22:
9541                                                {
9542                                                setState(1111);
9543                                                bodyTagOpen();
9544                                                }
9545                                                break;
9546                                        case 23:
9547                                                {
9548                                                setState(1112);
9549                                                colgroupTagOpen();
9550                                                }
9551                                                break;
9552                                        case 24:
9553                                                {
9554                                                setState(1113);
9555                                                ddTagOpen();
9556                                                }
9557                                                break;
9558                                        case 25:
9559                                                {
9560                                                setState(1114);
9561                                                dtTagOpen();
9562                                                }
9563                                                break;
9564                                        case 26:
9565                                                {
9566                                                setState(1115);
9567                                                headTagOpen();
9568                                                }
9569                                                break;
9570                                        case 27:
9571                                                {
9572                                                setState(1116);
9573                                                htmlTagOpen();
9574                                                }
9575                                                break;
9576                                        case 28:
9577                                                {
9578                                                setState(1117);
9579                                                tbodyTagOpen();
9580                                                }
9581                                                break;
9582                                        case 29:
9583                                                {
9584                                                setState(1118);
9585                                                theadTagOpen();
9586                                                }
9587                                                break;
9588                                        case 30:
9589                                                {
9590                                                setState(1119);
9591                                                tfootTagOpen();
9592                                                }
9593                                                break;
9594                                        case 31:
9595                                                {
9596                                                {
9597                                                setState(1120);
9598                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
9599                                                setState(1121);
9600                                                match(LEADING_ASTERISK);
9601                                                }
9602                                                }
9603                                                break;
9604                                        case 32:
9605                                                {
9606                                                setState(1122);
9607                                                htmlComment();
9608                                                }
9609                                                break;
9610                                        case 33:
9611                                                {
9612                                                setState(1123);
9613                                                match(CDATA);
9614                                                }
9615                                                break;
9616                                        case 34:
9617                                                {
9618                                                setState(1124);
9619                                                match(NEWLINE);
9620                                                }
9621                                                break;
9622                                        case 35:
9623                                                {
9624                                                setState(1125);
9625                                                text();
9626                                                }
9627                                                break;
9628                                        case 36:
9629                                                {
9630                                                setState(1126);
9631                                                javadocInlineTag();
9632                                                }
9633                                                break;
9634                                        }
9635                                        } 
9636                                }
9637                                setState(1131);
9638                                _errHandler.sync(this);
9639                                _alt = getInterpreter().adaptivePredict(_input,76,_ctx);
9640                        }
9641                        setState(1132);
9642                        optionTagClose();
9643                        }
9644                }
9645                catch (RecognitionException re) {
9646                        _localctx.exception = re;
9647                        _errHandler.reportError(this, re);
9648                        _errHandler.recover(this, re);
9649                }
9650                finally {
9651                        exitRule();
9652                }
9653                return _localctx;
9654        }
9655
9656        public static class TbodyTagOpenContext extends ParserRuleContext {
9657                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9658                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
9659                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9660                public List<AttributeContext> attribute() {
9661                        return getRuleContexts(AttributeContext.class);
9662                }
9663                public AttributeContext attribute(int i) {
9664                        return getRuleContext(AttributeContext.class,i);
9665                }
9666                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9667                public TerminalNode NEWLINE(int i) {
9668                        return getToken(JavadocParser.NEWLINE, i);
9669                }
9670                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9671                public TerminalNode LEADING_ASTERISK(int i) {
9672                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9673                }
9674                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9675                public TerminalNode WS(int i) {
9676                        return getToken(JavadocParser.WS, i);
9677                }
9678                public TbodyTagOpenContext(ParserRuleContext parent, int invokingState) {
9679                        super(parent, invokingState);
9680                }
9681                @Override public int getRuleIndex() { return RULE_tbodyTagOpen; }
9682                @Override
9683                public void enterRule(ParseTreeListener listener) {
9684                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagOpen(this);
9685                }
9686                @Override
9687                public void exitRule(ParseTreeListener listener) {
9688                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagOpen(this);
9689                }
9690                @Override
9691                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9692                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagOpen(this);
9693                        else return visitor.visitChildren(this);
9694                }
9695        }
9696
9697        public final TbodyTagOpenContext tbodyTagOpen() throws RecognitionException {
9698                TbodyTagOpenContext _localctx = new TbodyTagOpenContext(_ctx, getState());
9699                enterRule(_localctx, 84, RULE_tbodyTagOpen);
9700                int _la;
9701                try {
9702                        enterOuterAlt(_localctx, 1);
9703                        {
9704                        setState(1134);
9705                        match(OPEN);
9706                        setState(1135);
9707                        match(TBODY_HTML_TAG_NAME);
9708                        setState(1142);
9709                        _errHandler.sync(this);
9710                        _la = _input.LA(1);
9711                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
9712                                {
9713                                setState(1140);
9714                                switch (_input.LA(1)) {
9715                                case HTML_TAG_NAME:
9716                                        {
9717                                        setState(1136);
9718                                        attribute();
9719                                        }
9720                                        break;
9721                                case NEWLINE:
9722                                        {
9723                                        setState(1137);
9724                                        match(NEWLINE);
9725                                        }
9726                                        break;
9727                                case LEADING_ASTERISK:
9728                                        {
9729                                        setState(1138);
9730                                        match(LEADING_ASTERISK);
9731                                        }
9732                                        break;
9733                                case WS:
9734                                        {
9735                                        setState(1139);
9736                                        match(WS);
9737                                        }
9738                                        break;
9739                                default:
9740                                        throw new NoViableAltException(this);
9741                                }
9742                                }
9743                                setState(1144);
9744                                _errHandler.sync(this);
9745                                _la = _input.LA(1);
9746                        }
9747                        setState(1145);
9748                        match(CLOSE);
9749                        }
9750                }
9751                catch (RecognitionException re) {
9752                        _localctx.exception = re;
9753                        _errHandler.reportError(this, re);
9754                        _errHandler.recover(this, re);
9755                }
9756                finally {
9757                        exitRule();
9758                }
9759                return _localctx;
9760        }
9761
9762        public static class TbodyTagCloseContext extends ParserRuleContext {
9763                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9764                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
9765                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
9766                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9767                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9768                public TerminalNode NEWLINE(int i) {
9769                        return getToken(JavadocParser.NEWLINE, i);
9770                }
9771                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9772                public TerminalNode LEADING_ASTERISK(int i) {
9773                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9774                }
9775                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9776                public TerminalNode WS(int i) {
9777                        return getToken(JavadocParser.WS, i);
9778                }
9779                public TbodyTagCloseContext(ParserRuleContext parent, int invokingState) {
9780                        super(parent, invokingState);
9781                }
9782                @Override public int getRuleIndex() { return RULE_tbodyTagClose; }
9783                @Override
9784                public void enterRule(ParseTreeListener listener) {
9785                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagClose(this);
9786                }
9787                @Override
9788                public void exitRule(ParseTreeListener listener) {
9789                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagClose(this);
9790                }
9791                @Override
9792                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9793                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagClose(this);
9794                        else return visitor.visitChildren(this);
9795                }
9796        }
9797
9798        public final TbodyTagCloseContext tbodyTagClose() throws RecognitionException {
9799                TbodyTagCloseContext _localctx = new TbodyTagCloseContext(_ctx, getState());
9800                enterRule(_localctx, 86, RULE_tbodyTagClose);
9801                int _la;
9802                try {
9803                        enterOuterAlt(_localctx, 1);
9804                        {
9805                        setState(1147);
9806                        match(OPEN);
9807                        setState(1148);
9808                        match(SLASH);
9809                        setState(1149);
9810                        match(TBODY_HTML_TAG_NAME);
9811                        setState(1153);
9812                        _errHandler.sync(this);
9813                        _la = _input.LA(1);
9814                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
9815                                {
9816                                {
9817                                setState(1150);
9818                                _la = _input.LA(1);
9819                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
9820                                _errHandler.recoverInline(this);
9821                                } else {
9822                                        consume();
9823                                }
9824                                }
9825                                }
9826                                setState(1155);
9827                                _errHandler.sync(this);
9828                                _la = _input.LA(1);
9829                        }
9830                        setState(1156);
9831                        match(CLOSE);
9832                        }
9833                }
9834                catch (RecognitionException re) {
9835                        _localctx.exception = re;
9836                        _errHandler.reportError(this, re);
9837                        _errHandler.recover(this, re);
9838                }
9839                finally {
9840                        exitRule();
9841                }
9842                return _localctx;
9843        }
9844
9845        public static class TbodyContext extends ParserRuleContext {
9846                public TbodyTagOpenContext tbodyTagOpen() {
9847                        return getRuleContext(TbodyTagOpenContext.class,0);
9848                }
9849                public TbodyTagCloseContext tbodyTagClose() {
9850                        return getRuleContext(TbodyTagCloseContext.class,0);
9851                }
9852                public List<HtmlTagContext> htmlTag() {
9853                        return getRuleContexts(HtmlTagContext.class);
9854                }
9855                public HtmlTagContext htmlTag(int i) {
9856                        return getRuleContext(HtmlTagContext.class,i);
9857                }
9858                public List<SingletonTagContext> singletonTag() {
9859                        return getRuleContexts(SingletonTagContext.class);
9860                }
9861                public SingletonTagContext singletonTag(int i) {
9862                        return getRuleContext(SingletonTagContext.class,i);
9863                }
9864                public List<ParagraphContext> paragraph() {
9865                        return getRuleContexts(ParagraphContext.class);
9866                }
9867                public ParagraphContext paragraph(int i) {
9868                        return getRuleContext(ParagraphContext.class,i);
9869                }
9870                public List<LiContext> li() {
9871                        return getRuleContexts(LiContext.class);
9872                }
9873                public LiContext li(int i) {
9874                        return getRuleContext(LiContext.class,i);
9875                }
9876                public List<TrContext> tr() {
9877                        return getRuleContexts(TrContext.class);
9878                }
9879                public TrContext tr(int i) {
9880                        return getRuleContext(TrContext.class,i);
9881                }
9882                public List<TdContext> td() {
9883                        return getRuleContexts(TdContext.class);
9884                }
9885                public TdContext td(int i) {
9886                        return getRuleContext(TdContext.class,i);
9887                }
9888                public List<ThContext> th() {
9889                        return getRuleContexts(ThContext.class);
9890                }
9891                public ThContext th(int i) {
9892                        return getRuleContext(ThContext.class,i);
9893                }
9894                public List<BodyContext> body() {
9895                        return getRuleContexts(BodyContext.class);
9896                }
9897                public BodyContext body(int i) {
9898                        return getRuleContext(BodyContext.class,i);
9899                }
9900                public List<ColgroupContext> colgroup() {
9901                        return getRuleContexts(ColgroupContext.class);
9902                }
9903                public ColgroupContext colgroup(int i) {
9904                        return getRuleContext(ColgroupContext.class,i);
9905                }
9906                public List<DdContext> dd() {
9907                        return getRuleContexts(DdContext.class);
9908                }
9909                public DdContext dd(int i) {
9910                        return getRuleContext(DdContext.class,i);
9911                }
9912                public List<DtContext> dt() {
9913                        return getRuleContexts(DtContext.class);
9914                }
9915                public DtContext dt(int i) {
9916                        return getRuleContext(DtContext.class,i);
9917                }
9918                public List<HeadContext> head() {
9919                        return getRuleContexts(HeadContext.class);
9920                }
9921                public HeadContext head(int i) {
9922                        return getRuleContext(HeadContext.class,i);
9923                }
9924                public List<HtmlContext> html() {
9925                        return getRuleContexts(HtmlContext.class);
9926                }
9927                public HtmlContext html(int i) {
9928                        return getRuleContext(HtmlContext.class,i);
9929                }
9930                public List<OptionContext> option() {
9931                        return getRuleContexts(OptionContext.class);
9932                }
9933                public OptionContext option(int i) {
9934                        return getRuleContext(OptionContext.class,i);
9935                }
9936                public List<TheadContext> thead() {
9937                        return getRuleContexts(TheadContext.class);
9938                }
9939                public TheadContext thead(int i) {
9940                        return getRuleContext(TheadContext.class,i);
9941                }
9942                public List<TfootContext> tfoot() {
9943                        return getRuleContexts(TfootContext.class);
9944                }
9945                public TfootContext tfoot(int i) {
9946                        return getRuleContext(TfootContext.class,i);
9947                }
9948                public List<PTagOpenContext> pTagOpen() {
9949                        return getRuleContexts(PTagOpenContext.class);
9950                }
9951                public PTagOpenContext pTagOpen(int i) {
9952                        return getRuleContext(PTagOpenContext.class,i);
9953                }
9954                public List<LiTagOpenContext> liTagOpen() {
9955                        return getRuleContexts(LiTagOpenContext.class);
9956                }
9957                public LiTagOpenContext liTagOpen(int i) {
9958                        return getRuleContext(LiTagOpenContext.class,i);
9959                }
9960                public List<TrTagOpenContext> trTagOpen() {
9961                        return getRuleContexts(TrTagOpenContext.class);
9962                }
9963                public TrTagOpenContext trTagOpen(int i) {
9964                        return getRuleContext(TrTagOpenContext.class,i);
9965                }
9966                public List<TdTagOpenContext> tdTagOpen() {
9967                        return getRuleContexts(TdTagOpenContext.class);
9968                }
9969                public TdTagOpenContext tdTagOpen(int i) {
9970                        return getRuleContext(TdTagOpenContext.class,i);
9971                }
9972                public List<ThTagOpenContext> thTagOpen() {
9973                        return getRuleContexts(ThTagOpenContext.class);
9974                }
9975                public ThTagOpenContext thTagOpen(int i) {
9976                        return getRuleContext(ThTagOpenContext.class,i);
9977                }
9978                public List<BodyTagOpenContext> bodyTagOpen() {
9979                        return getRuleContexts(BodyTagOpenContext.class);
9980                }
9981                public BodyTagOpenContext bodyTagOpen(int i) {
9982                        return getRuleContext(BodyTagOpenContext.class,i);
9983                }
9984                public List<ColgroupTagOpenContext> colgroupTagOpen() {
9985                        return getRuleContexts(ColgroupTagOpenContext.class);
9986                }
9987                public ColgroupTagOpenContext colgroupTagOpen(int i) {
9988                        return getRuleContext(ColgroupTagOpenContext.class,i);
9989                }
9990                public List<DdTagOpenContext> ddTagOpen() {
9991                        return getRuleContexts(DdTagOpenContext.class);
9992                }
9993                public DdTagOpenContext ddTagOpen(int i) {
9994                        return getRuleContext(DdTagOpenContext.class,i);
9995                }
9996                public List<DtTagOpenContext> dtTagOpen() {
9997                        return getRuleContexts(DtTagOpenContext.class);
9998                }
9999                public DtTagOpenContext dtTagOpen(int i) {
10000                        return getRuleContext(DtTagOpenContext.class,i);
10001                }
10002                public List<HeadTagOpenContext> headTagOpen() {
10003                        return getRuleContexts(HeadTagOpenContext.class);
10004                }
10005                public HeadTagOpenContext headTagOpen(int i) {
10006                        return getRuleContext(HeadTagOpenContext.class,i);
10007                }
10008                public List<HtmlTagOpenContext> htmlTagOpen() {
10009                        return getRuleContexts(HtmlTagOpenContext.class);
10010                }
10011                public HtmlTagOpenContext htmlTagOpen(int i) {
10012                        return getRuleContext(HtmlTagOpenContext.class,i);
10013                }
10014                public List<OptionTagOpenContext> optionTagOpen() {
10015                        return getRuleContexts(OptionTagOpenContext.class);
10016                }
10017                public OptionTagOpenContext optionTagOpen(int i) {
10018                        return getRuleContext(OptionTagOpenContext.class,i);
10019                }
10020                public List<TheadTagOpenContext> theadTagOpen() {
10021                        return getRuleContexts(TheadTagOpenContext.class);
10022                }
10023                public TheadTagOpenContext theadTagOpen(int i) {
10024                        return getRuleContext(TheadTagOpenContext.class,i);
10025                }
10026                public List<TfootTagOpenContext> tfootTagOpen() {
10027                        return getRuleContexts(TfootTagOpenContext.class);
10028                }
10029                public TfootTagOpenContext tfootTagOpen(int i) {
10030                        return getRuleContext(TfootTagOpenContext.class,i);
10031                }
10032                public List<HtmlCommentContext> htmlComment() {
10033                        return getRuleContexts(HtmlCommentContext.class);
10034                }
10035                public HtmlCommentContext htmlComment(int i) {
10036                        return getRuleContext(HtmlCommentContext.class,i);
10037                }
10038                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
10039                public TerminalNode CDATA(int i) {
10040                        return getToken(JavadocParser.CDATA, i);
10041                }
10042                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10043                public TerminalNode NEWLINE(int i) {
10044                        return getToken(JavadocParser.NEWLINE, i);
10045                }
10046                public List<TextContext> text() {
10047                        return getRuleContexts(TextContext.class);
10048                }
10049                public TextContext text(int i) {
10050                        return getRuleContext(TextContext.class,i);
10051                }
10052                public List<JavadocInlineTagContext> javadocInlineTag() {
10053                        return getRuleContexts(JavadocInlineTagContext.class);
10054                }
10055                public JavadocInlineTagContext javadocInlineTag(int i) {
10056                        return getRuleContext(JavadocInlineTagContext.class,i);
10057                }
10058                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10059                public TerminalNode LEADING_ASTERISK(int i) {
10060                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10061                }
10062                public TbodyContext(ParserRuleContext parent, int invokingState) {
10063                        super(parent, invokingState);
10064                }
10065                @Override public int getRuleIndex() { return RULE_tbody; }
10066                @Override
10067                public void enterRule(ParseTreeListener listener) {
10068                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbody(this);
10069                }
10070                @Override
10071                public void exitRule(ParseTreeListener listener) {
10072                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbody(this);
10073                }
10074                @Override
10075                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10076                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbody(this);
10077                        else return visitor.visitChildren(this);
10078                }
10079        }
10080
10081        public final TbodyContext tbody() throws RecognitionException {
10082                TbodyContext _localctx = new TbodyContext(_ctx, getState());
10083                enterRule(_localctx, 88, RULE_tbody);
10084                try {
10085                        int _alt;
10086                        enterOuterAlt(_localctx, 1);
10087                        {
10088                        setState(1158);
10089                        tbodyTagOpen();
10090                        setState(1198);
10091                        _errHandler.sync(this);
10092                        _alt = getInterpreter().adaptivePredict(_input,81,_ctx);
10093                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
10094                                if ( _alt==1 ) {
10095                                        {
10096                                        setState(1196);
10097                                        _errHandler.sync(this);
10098                                        switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
10099                                        case 1:
10100                                                {
10101                                                setState(1159);
10102                                                htmlTag();
10103                                                }
10104                                                break;
10105                                        case 2:
10106                                                {
10107                                                setState(1160);
10108                                                singletonTag();
10109                                                }
10110                                                break;
10111                                        case 3:
10112                                                {
10113                                                setState(1161);
10114                                                paragraph();
10115                                                }
10116                                                break;
10117                                        case 4:
10118                                                {
10119                                                setState(1162);
10120                                                li();
10121                                                }
10122                                                break;
10123                                        case 5:
10124                                                {
10125                                                setState(1163);
10126                                                tr();
10127                                                }
10128                                                break;
10129                                        case 6:
10130                                                {
10131                                                setState(1164);
10132                                                td();
10133                                                }
10134                                                break;
10135                                        case 7:
10136                                                {
10137                                                setState(1165);
10138                                                th();
10139                                                }
10140                                                break;
10141                                        case 8:
10142                                                {
10143                                                setState(1166);
10144                                                body();
10145                                                }
10146                                                break;
10147                                        case 9:
10148                                                {
10149                                                setState(1167);
10150                                                colgroup();
10151                                                }
10152                                                break;
10153                                        case 10:
10154                                                {
10155                                                setState(1168);
10156                                                dd();
10157                                                }
10158                                                break;
10159                                        case 11:
10160                                                {
10161                                                setState(1169);
10162                                                dt();
10163                                                }
10164                                                break;
10165                                        case 12:
10166                                                {
10167                                                setState(1170);
10168                                                head();
10169                                                }
10170                                                break;
10171                                        case 13:
10172                                                {
10173                                                setState(1171);
10174                                                html();
10175                                                }
10176                                                break;
10177                                        case 14:
10178                                                {
10179                                                setState(1172);
10180                                                option();
10181                                                }
10182                                                break;
10183                                        case 15:
10184                                                {
10185                                                setState(1173);
10186                                                thead();
10187                                                }
10188                                                break;
10189                                        case 16:
10190                                                {
10191                                                setState(1174);
10192                                                tfoot();
10193                                                }
10194                                                break;
10195                                        case 17:
10196                                                {
10197                                                setState(1175);
10198                                                pTagOpen();
10199                                                }
10200                                                break;
10201                                        case 18:
10202                                                {
10203                                                setState(1176);
10204                                                liTagOpen();
10205                                                }
10206                                                break;
10207                                        case 19:
10208                                                {
10209                                                setState(1177);
10210                                                trTagOpen();
10211                                                }
10212                                                break;
10213                                        case 20:
10214                                                {
10215                                                setState(1178);
10216                                                tdTagOpen();
10217                                                }
10218                                                break;
10219                                        case 21:
10220                                                {
10221                                                setState(1179);
10222                                                thTagOpen();
10223                                                }
10224                                                break;
10225                                        case 22:
10226                                                {
10227                                                setState(1180);
10228                                                bodyTagOpen();
10229                                                }
10230                                                break;
10231                                        case 23:
10232                                                {
10233                                                setState(1181);
10234                                                colgroupTagOpen();
10235                                                }
10236                                                break;
10237                                        case 24:
10238                                                {
10239                                                setState(1182);
10240                                                ddTagOpen();
10241                                                }
10242                                                break;
10243                                        case 25:
10244                                                {
10245                                                setState(1183);
10246                                                dtTagOpen();
10247                                                }
10248                                                break;
10249                                        case 26:
10250                                                {
10251                                                setState(1184);
10252                                                headTagOpen();
10253                                                }
10254                                                break;
10255                                        case 27:
10256                                                {
10257                                                setState(1185);
10258                                                htmlTagOpen();
10259                                                }
10260                                                break;
10261                                        case 28:
10262                                                {
10263                                                setState(1186);
10264                                                optionTagOpen();
10265                                                }
10266                                                break;
10267                                        case 29:
10268                                                {
10269                                                setState(1187);
10270                                                theadTagOpen();
10271                                                }
10272                                                break;
10273                                        case 30:
10274                                                {
10275                                                setState(1188);
10276                                                tfootTagOpen();
10277                                                }
10278                                                break;
10279                                        case 31:
10280                                                {
10281                                                {
10282                                                setState(1189);
10283                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
10284                                                setState(1190);
10285                                                match(LEADING_ASTERISK);
10286                                                }
10287                                                }
10288                                                break;
10289                                        case 32:
10290                                                {
10291                                                setState(1191);
10292                                                htmlComment();
10293                                                }
10294                                                break;
10295                                        case 33:
10296                                                {
10297                                                setState(1192);
10298                                                match(CDATA);
10299                                                }
10300                                                break;
10301                                        case 34:
10302                                                {
10303                                                setState(1193);
10304                                                match(NEWLINE);
10305                                                }
10306                                                break;
10307                                        case 35:
10308                                                {
10309                                                setState(1194);
10310                                                text();
10311                                                }
10312                                                break;
10313                                        case 36:
10314                                                {
10315                                                setState(1195);
10316                                                javadocInlineTag();
10317                                                }
10318                                                break;
10319                                        }
10320                                        } 
10321                                }
10322                                setState(1200);
10323                                _errHandler.sync(this);
10324                                _alt = getInterpreter().adaptivePredict(_input,81,_ctx);
10325                        }
10326                        setState(1201);
10327                        tbodyTagClose();
10328                        }
10329                }
10330                catch (RecognitionException re) {
10331                        _localctx.exception = re;
10332                        _errHandler.reportError(this, re);
10333                        _errHandler.recover(this, re);
10334                }
10335                finally {
10336                        exitRule();
10337                }
10338                return _localctx;
10339        }
10340
10341        public static class TfootTagOpenContext extends ParserRuleContext {
10342                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
10343                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
10344                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
10345                public List<AttributeContext> attribute() {
10346                        return getRuleContexts(AttributeContext.class);
10347                }
10348                public AttributeContext attribute(int i) {
10349                        return getRuleContext(AttributeContext.class,i);
10350                }
10351                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10352                public TerminalNode NEWLINE(int i) {
10353                        return getToken(JavadocParser.NEWLINE, i);
10354                }
10355                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10356                public TerminalNode LEADING_ASTERISK(int i) {
10357                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10358                }
10359                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
10360                public TerminalNode WS(int i) {
10361                        return getToken(JavadocParser.WS, i);
10362                }
10363                public TfootTagOpenContext(ParserRuleContext parent, int invokingState) {
10364                        super(parent, invokingState);
10365                }
10366                @Override public int getRuleIndex() { return RULE_tfootTagOpen; }
10367                @Override
10368                public void enterRule(ParseTreeListener listener) {
10369                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagOpen(this);
10370                }
10371                @Override
10372                public void exitRule(ParseTreeListener listener) {
10373                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagOpen(this);
10374                }
10375                @Override
10376                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10377                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagOpen(this);
10378                        else return visitor.visitChildren(this);
10379                }
10380        }
10381
10382        public final TfootTagOpenContext tfootTagOpen() throws RecognitionException {
10383                TfootTagOpenContext _localctx = new TfootTagOpenContext(_ctx, getState());
10384                enterRule(_localctx, 90, RULE_tfootTagOpen);
10385                int _la;
10386                try {
10387                        enterOuterAlt(_localctx, 1);
10388                        {
10389                        setState(1203);
10390                        match(OPEN);
10391                        setState(1204);
10392                        match(TFOOT_HTML_TAG_NAME);
10393                        setState(1211);
10394                        _errHandler.sync(this);
10395                        _la = _input.LA(1);
10396                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
10397                                {
10398                                setState(1209);
10399                                switch (_input.LA(1)) {
10400                                case HTML_TAG_NAME:
10401                                        {
10402                                        setState(1205);
10403                                        attribute();
10404                                        }
10405                                        break;
10406                                case NEWLINE:
10407                                        {
10408                                        setState(1206);
10409                                        match(NEWLINE);
10410                                        }
10411                                        break;
10412                                case LEADING_ASTERISK:
10413                                        {
10414                                        setState(1207);
10415                                        match(LEADING_ASTERISK);
10416                                        }
10417                                        break;
10418                                case WS:
10419                                        {
10420                                        setState(1208);
10421                                        match(WS);
10422                                        }
10423                                        break;
10424                                default:
10425                                        throw new NoViableAltException(this);
10426                                }
10427                                }
10428                                setState(1213);
10429                                _errHandler.sync(this);
10430                                _la = _input.LA(1);
10431                        }
10432                        setState(1214);
10433                        match(CLOSE);
10434                        }
10435                }
10436                catch (RecognitionException re) {
10437                        _localctx.exception = re;
10438                        _errHandler.reportError(this, re);
10439                        _errHandler.recover(this, re);
10440                }
10441                finally {
10442                        exitRule();
10443                }
10444                return _localctx;
10445        }
10446
10447        public static class TfootTagCloseContext extends ParserRuleContext {
10448                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
10449                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
10450                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
10451                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
10452                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10453                public TerminalNode NEWLINE(int i) {
10454                        return getToken(JavadocParser.NEWLINE, i);
10455                }
10456                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10457                public TerminalNode LEADING_ASTERISK(int i) {
10458                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10459                }
10460                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
10461                public TerminalNode WS(int i) {
10462                        return getToken(JavadocParser.WS, i);
10463                }
10464                public TfootTagCloseContext(ParserRuleContext parent, int invokingState) {
10465                        super(parent, invokingState);
10466                }
10467                @Override public int getRuleIndex() { return RULE_tfootTagClose; }
10468                @Override
10469                public void enterRule(ParseTreeListener listener) {
10470                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagClose(this);
10471                }
10472                @Override
10473                public void exitRule(ParseTreeListener listener) {
10474                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagClose(this);
10475                }
10476                @Override
10477                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10478                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagClose(this);
10479                        else return visitor.visitChildren(this);
10480                }
10481        }
10482
10483        public final TfootTagCloseContext tfootTagClose() throws RecognitionException {
10484                TfootTagCloseContext _localctx = new TfootTagCloseContext(_ctx, getState());
10485                enterRule(_localctx, 92, RULE_tfootTagClose);
10486                int _la;
10487                try {
10488                        enterOuterAlt(_localctx, 1);
10489                        {
10490                        setState(1216);
10491                        match(OPEN);
10492                        setState(1217);
10493                        match(SLASH);
10494                        setState(1218);
10495                        match(TFOOT_HTML_TAG_NAME);
10496                        setState(1222);
10497                        _errHandler.sync(this);
10498                        _la = _input.LA(1);
10499                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
10500                                {
10501                                {
10502                                setState(1219);
10503                                _la = _input.LA(1);
10504                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
10505                                _errHandler.recoverInline(this);
10506                                } else {
10507                                        consume();
10508                                }
10509                                }
10510                                }
10511                                setState(1224);
10512                                _errHandler.sync(this);
10513                                _la = _input.LA(1);
10514                        }
10515                        setState(1225);
10516                        match(CLOSE);
10517                        }
10518                }
10519                catch (RecognitionException re) {
10520                        _localctx.exception = re;
10521                        _errHandler.reportError(this, re);
10522                        _errHandler.recover(this, re);
10523                }
10524                finally {
10525                        exitRule();
10526                }
10527                return _localctx;
10528        }
10529
10530        public static class TfootContext extends ParserRuleContext {
10531                public TfootTagOpenContext tfootTagOpen() {
10532                        return getRuleContext(TfootTagOpenContext.class,0);
10533                }
10534                public TfootTagCloseContext tfootTagClose() {
10535                        return getRuleContext(TfootTagCloseContext.class,0);
10536                }
10537                public List<HtmlTagContext> htmlTag() {
10538                        return getRuleContexts(HtmlTagContext.class);
10539                }
10540                public HtmlTagContext htmlTag(int i) {
10541                        return getRuleContext(HtmlTagContext.class,i);
10542                }
10543                public List<SingletonTagContext> singletonTag() {
10544                        return getRuleContexts(SingletonTagContext.class);
10545                }
10546                public SingletonTagContext singletonTag(int i) {
10547                        return getRuleContext(SingletonTagContext.class,i);
10548                }
10549                public List<ParagraphContext> paragraph() {
10550                        return getRuleContexts(ParagraphContext.class);
10551                }
10552                public ParagraphContext paragraph(int i) {
10553                        return getRuleContext(ParagraphContext.class,i);
10554                }
10555                public List<LiContext> li() {
10556                        return getRuleContexts(LiContext.class);
10557                }
10558                public LiContext li(int i) {
10559                        return getRuleContext(LiContext.class,i);
10560                }
10561                public List<TrContext> tr() {
10562                        return getRuleContexts(TrContext.class);
10563                }
10564                public TrContext tr(int i) {
10565                        return getRuleContext(TrContext.class,i);
10566                }
10567                public List<TdContext> td() {
10568                        return getRuleContexts(TdContext.class);
10569                }
10570                public TdContext td(int i) {
10571                        return getRuleContext(TdContext.class,i);
10572                }
10573                public List<ThContext> th() {
10574                        return getRuleContexts(ThContext.class);
10575                }
10576                public ThContext th(int i) {
10577                        return getRuleContext(ThContext.class,i);
10578                }
10579                public List<BodyContext> body() {
10580                        return getRuleContexts(BodyContext.class);
10581                }
10582                public BodyContext body(int i) {
10583                        return getRuleContext(BodyContext.class,i);
10584                }
10585                public List<ColgroupContext> colgroup() {
10586                        return getRuleContexts(ColgroupContext.class);
10587                }
10588                public ColgroupContext colgroup(int i) {
10589                        return getRuleContext(ColgroupContext.class,i);
10590                }
10591                public List<DdContext> dd() {
10592                        return getRuleContexts(DdContext.class);
10593                }
10594                public DdContext dd(int i) {
10595                        return getRuleContext(DdContext.class,i);
10596                }
10597                public List<DtContext> dt() {
10598                        return getRuleContexts(DtContext.class);
10599                }
10600                public DtContext dt(int i) {
10601                        return getRuleContext(DtContext.class,i);
10602                }
10603                public List<HeadContext> head() {
10604                        return getRuleContexts(HeadContext.class);
10605                }
10606                public HeadContext head(int i) {
10607                        return getRuleContext(HeadContext.class,i);
10608                }
10609                public List<HtmlContext> html() {
10610                        return getRuleContexts(HtmlContext.class);
10611                }
10612                public HtmlContext html(int i) {
10613                        return getRuleContext(HtmlContext.class,i);
10614                }
10615                public List<OptionContext> option() {
10616                        return getRuleContexts(OptionContext.class);
10617                }
10618                public OptionContext option(int i) {
10619                        return getRuleContext(OptionContext.class,i);
10620                }
10621                public List<TbodyContext> tbody() {
10622                        return getRuleContexts(TbodyContext.class);
10623                }
10624                public TbodyContext tbody(int i) {
10625                        return getRuleContext(TbodyContext.class,i);
10626                }
10627                public List<TheadContext> thead() {
10628                        return getRuleContexts(TheadContext.class);
10629                }
10630                public TheadContext thead(int i) {
10631                        return getRuleContext(TheadContext.class,i);
10632                }
10633                public List<PTagOpenContext> pTagOpen() {
10634                        return getRuleContexts(PTagOpenContext.class);
10635                }
10636                public PTagOpenContext pTagOpen(int i) {
10637                        return getRuleContext(PTagOpenContext.class,i);
10638                }
10639                public List<LiTagOpenContext> liTagOpen() {
10640                        return getRuleContexts(LiTagOpenContext.class);
10641                }
10642                public LiTagOpenContext liTagOpen(int i) {
10643                        return getRuleContext(LiTagOpenContext.class,i);
10644                }
10645                public List<TrTagOpenContext> trTagOpen() {
10646                        return getRuleContexts(TrTagOpenContext.class);
10647                }
10648                public TrTagOpenContext trTagOpen(int i) {
10649                        return getRuleContext(TrTagOpenContext.class,i);
10650                }
10651                public List<TdTagOpenContext> tdTagOpen() {
10652                        return getRuleContexts(TdTagOpenContext.class);
10653                }
10654                public TdTagOpenContext tdTagOpen(int i) {
10655                        return getRuleContext(TdTagOpenContext.class,i);
10656                }
10657                public List<ThTagOpenContext> thTagOpen() {
10658                        return getRuleContexts(ThTagOpenContext.class);
10659                }
10660                public ThTagOpenContext thTagOpen(int i) {
10661                        return getRuleContext(ThTagOpenContext.class,i);
10662                }
10663                public List<BodyTagOpenContext> bodyTagOpen() {
10664                        return getRuleContexts(BodyTagOpenContext.class);
10665                }
10666                public BodyTagOpenContext bodyTagOpen(int i) {
10667                        return getRuleContext(BodyTagOpenContext.class,i);
10668                }
10669                public List<ColgroupTagOpenContext> colgroupTagOpen() {
10670                        return getRuleContexts(ColgroupTagOpenContext.class);
10671                }
10672                public ColgroupTagOpenContext colgroupTagOpen(int i) {
10673                        return getRuleContext(ColgroupTagOpenContext.class,i);
10674                }
10675                public List<DdTagOpenContext> ddTagOpen() {
10676                        return getRuleContexts(DdTagOpenContext.class);
10677                }
10678                public DdTagOpenContext ddTagOpen(int i) {
10679                        return getRuleContext(DdTagOpenContext.class,i);
10680                }
10681                public List<DtTagOpenContext> dtTagOpen() {
10682                        return getRuleContexts(DtTagOpenContext.class);
10683                }
10684                public DtTagOpenContext dtTagOpen(int i) {
10685                        return getRuleContext(DtTagOpenContext.class,i);
10686                }
10687                public List<HeadTagOpenContext> headTagOpen() {
10688                        return getRuleContexts(HeadTagOpenContext.class);
10689                }
10690                public HeadTagOpenContext headTagOpen(int i) {
10691                        return getRuleContext(HeadTagOpenContext.class,i);
10692                }
10693                public List<HtmlTagOpenContext> htmlTagOpen() {
10694                        return getRuleContexts(HtmlTagOpenContext.class);
10695                }
10696                public HtmlTagOpenContext htmlTagOpen(int i) {
10697                        return getRuleContext(HtmlTagOpenContext.class,i);
10698                }
10699                public List<OptionTagOpenContext> optionTagOpen() {
10700                        return getRuleContexts(OptionTagOpenContext.class);
10701                }
10702                public OptionTagOpenContext optionTagOpen(int i) {
10703                        return getRuleContext(OptionTagOpenContext.class,i);
10704                }
10705                public List<TbodyTagOpenContext> tbodyTagOpen() {
10706                        return getRuleContexts(TbodyTagOpenContext.class);
10707                }
10708                public TbodyTagOpenContext tbodyTagOpen(int i) {
10709                        return getRuleContext(TbodyTagOpenContext.class,i);
10710                }
10711                public List<TheadTagOpenContext> theadTagOpen() {
10712                        return getRuleContexts(TheadTagOpenContext.class);
10713                }
10714                public TheadTagOpenContext theadTagOpen(int i) {
10715                        return getRuleContext(TheadTagOpenContext.class,i);
10716                }
10717                public List<HtmlCommentContext> htmlComment() {
10718                        return getRuleContexts(HtmlCommentContext.class);
10719                }
10720                public HtmlCommentContext htmlComment(int i) {
10721                        return getRuleContext(HtmlCommentContext.class,i);
10722                }
10723                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
10724                public TerminalNode CDATA(int i) {
10725                        return getToken(JavadocParser.CDATA, i);
10726                }
10727                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10728                public TerminalNode NEWLINE(int i) {
10729                        return getToken(JavadocParser.NEWLINE, i);
10730                }
10731                public List<TextContext> text() {
10732                        return getRuleContexts(TextContext.class);
10733                }
10734                public TextContext text(int i) {
10735                        return getRuleContext(TextContext.class,i);
10736                }
10737                public List<JavadocInlineTagContext> javadocInlineTag() {
10738                        return getRuleContexts(JavadocInlineTagContext.class);
10739                }
10740                public JavadocInlineTagContext javadocInlineTag(int i) {
10741                        return getRuleContext(JavadocInlineTagContext.class,i);
10742                }
10743                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10744                public TerminalNode LEADING_ASTERISK(int i) {
10745                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10746                }
10747                public TfootContext(ParserRuleContext parent, int invokingState) {
10748                        super(parent, invokingState);
10749                }
10750                @Override public int getRuleIndex() { return RULE_tfoot; }
10751                @Override
10752                public void enterRule(ParseTreeListener listener) {
10753                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfoot(this);
10754                }
10755                @Override
10756                public void exitRule(ParseTreeListener listener) {
10757                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfoot(this);
10758                }
10759                @Override
10760                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10761                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfoot(this);
10762                        else return visitor.visitChildren(this);
10763                }
10764        }
10765
10766        public final TfootContext tfoot() throws RecognitionException {
10767                TfootContext _localctx = new TfootContext(_ctx, getState());
10768                enterRule(_localctx, 94, RULE_tfoot);
10769                try {
10770                        int _alt;
10771                        enterOuterAlt(_localctx, 1);
10772                        {
10773                        setState(1227);
10774                        tfootTagOpen();
10775                        setState(1267);
10776                        _errHandler.sync(this);
10777                        _alt = getInterpreter().adaptivePredict(_input,86,_ctx);
10778                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
10779                                if ( _alt==1 ) {
10780                                        {
10781                                        setState(1265);
10782                                        _errHandler.sync(this);
10783                                        switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
10784                                        case 1:
10785                                                {
10786                                                setState(1228);
10787                                                htmlTag();
10788                                                }
10789                                                break;
10790                                        case 2:
10791                                                {
10792                                                setState(1229);
10793                                                singletonTag();
10794                                                }
10795                                                break;
10796                                        case 3:
10797                                                {
10798                                                setState(1230);
10799                                                paragraph();
10800                                                }
10801                                                break;
10802                                        case 4:
10803                                                {
10804                                                setState(1231);
10805                                                li();
10806                                                }
10807                                                break;
10808                                        case 5:
10809                                                {
10810                                                setState(1232);
10811                                                tr();
10812                                                }
10813                                                break;
10814                                        case 6:
10815                                                {
10816                                                setState(1233);
10817                                                td();
10818                                                }
10819                                                break;
10820                                        case 7:
10821                                                {
10822                                                setState(1234);
10823                                                th();
10824                                                }
10825                                                break;
10826                                        case 8:
10827                                                {
10828                                                setState(1235);
10829                                                body();
10830                                                }
10831                                                break;
10832                                        case 9:
10833                                                {
10834                                                setState(1236);
10835                                                colgroup();
10836                                                }
10837                                                break;
10838                                        case 10:
10839                                                {
10840                                                setState(1237);
10841                                                dd();
10842                                                }
10843                                                break;
10844                                        case 11:
10845                                                {
10846                                                setState(1238);
10847                                                dt();
10848                                                }
10849                                                break;
10850                                        case 12:
10851                                                {
10852                                                setState(1239);
10853                                                head();
10854                                                }
10855                                                break;
10856                                        case 13:
10857                                                {
10858                                                setState(1240);
10859                                                html();
10860                                                }
10861                                                break;
10862                                        case 14:
10863                                                {
10864                                                setState(1241);
10865                                                option();
10866                                                }
10867                                                break;
10868                                        case 15:
10869                                                {
10870                                                setState(1242);
10871                                                tbody();
10872                                                }
10873                                                break;
10874                                        case 16:
10875                                                {
10876                                                setState(1243);
10877                                                thead();
10878                                                }
10879                                                break;
10880                                        case 17:
10881                                                {
10882                                                setState(1244);
10883                                                pTagOpen();
10884                                                }
10885                                                break;
10886                                        case 18:
10887                                                {
10888                                                setState(1245);
10889                                                liTagOpen();
10890                                                }
10891                                                break;
10892                                        case 19:
10893                                                {
10894                                                setState(1246);
10895                                                trTagOpen();
10896                                                }
10897                                                break;
10898                                        case 20:
10899                                                {
10900                                                setState(1247);
10901                                                tdTagOpen();
10902                                                }
10903                                                break;
10904                                        case 21:
10905                                                {
10906                                                setState(1248);
10907                                                thTagOpen();
10908                                                }
10909                                                break;
10910                                        case 22:
10911                                                {
10912                                                setState(1249);
10913                                                bodyTagOpen();
10914                                                }
10915                                                break;
10916                                        case 23:
10917                                                {
10918                                                setState(1250);
10919                                                colgroupTagOpen();
10920                                                }
10921                                                break;
10922                                        case 24:
10923                                                {
10924                                                setState(1251);
10925                                                ddTagOpen();
10926                                                }
10927                                                break;
10928                                        case 25:
10929                                                {
10930                                                setState(1252);
10931                                                dtTagOpen();
10932                                                }
10933                                                break;
10934                                        case 26:
10935                                                {
10936                                                setState(1253);
10937                                                headTagOpen();
10938                                                }
10939                                                break;
10940                                        case 27:
10941                                                {
10942                                                setState(1254);
10943                                                htmlTagOpen();
10944                                                }
10945                                                break;
10946                                        case 28:
10947                                                {
10948                                                setState(1255);
10949                                                optionTagOpen();
10950                                                }
10951                                                break;
10952                                        case 29:
10953                                                {
10954                                                setState(1256);
10955                                                tbodyTagOpen();
10956                                                }
10957                                                break;
10958                                        case 30:
10959                                                {
10960                                                setState(1257);
10961                                                theadTagOpen();
10962                                                }
10963                                                break;
10964                                        case 31:
10965                                                {
10966                                                {
10967                                                setState(1258);
10968                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
10969                                                setState(1259);
10970                                                match(LEADING_ASTERISK);
10971                                                }
10972                                                }
10973                                                break;
10974                                        case 32:
10975                                                {
10976                                                setState(1260);
10977                                                htmlComment();
10978                                                }
10979                                                break;
10980                                        case 33:
10981                                                {
10982                                                setState(1261);
10983                                                match(CDATA);
10984                                                }
10985                                                break;
10986                                        case 34:
10987                                                {
10988                                                setState(1262);
10989                                                match(NEWLINE);
10990                                                }
10991                                                break;
10992                                        case 35:
10993                                                {
10994                                                setState(1263);
10995                                                text();
10996                                                }
10997                                                break;
10998                                        case 36:
10999                                                {
11000                                                setState(1264);
11001                                                javadocInlineTag();
11002                                                }
11003                                                break;
11004                                        }
11005                                        } 
11006                                }
11007                                setState(1269);
11008                                _errHandler.sync(this);
11009                                _alt = getInterpreter().adaptivePredict(_input,86,_ctx);
11010                        }
11011                        setState(1270);
11012                        tfootTagClose();
11013                        }
11014                }
11015                catch (RecognitionException re) {
11016                        _localctx.exception = re;
11017                        _errHandler.reportError(this, re);
11018                        _errHandler.recover(this, re);
11019                }
11020                finally {
11021                        exitRule();
11022                }
11023                return _localctx;
11024        }
11025
11026        public static class TheadTagOpenContext extends ParserRuleContext {
11027                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11028                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11029                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
11030                public List<AttributeContext> attribute() {
11031                        return getRuleContexts(AttributeContext.class);
11032                }
11033                public AttributeContext attribute(int i) {
11034                        return getRuleContext(AttributeContext.class,i);
11035                }
11036                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11037                public TerminalNode NEWLINE(int i) {
11038                        return getToken(JavadocParser.NEWLINE, i);
11039                }
11040                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11041                public TerminalNode LEADING_ASTERISK(int i) {
11042                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11043                }
11044                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11045                public TerminalNode WS(int i) {
11046                        return getToken(JavadocParser.WS, i);
11047                }
11048                public TheadTagOpenContext(ParserRuleContext parent, int invokingState) {
11049                        super(parent, invokingState);
11050                }
11051                @Override public int getRuleIndex() { return RULE_theadTagOpen; }
11052                @Override
11053                public void enterRule(ParseTreeListener listener) {
11054                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagOpen(this);
11055                }
11056                @Override
11057                public void exitRule(ParseTreeListener listener) {
11058                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagOpen(this);
11059                }
11060                @Override
11061                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11062                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagOpen(this);
11063                        else return visitor.visitChildren(this);
11064                }
11065        }
11066
11067        public final TheadTagOpenContext theadTagOpen() throws RecognitionException {
11068                TheadTagOpenContext _localctx = new TheadTagOpenContext(_ctx, getState());
11069                enterRule(_localctx, 96, RULE_theadTagOpen);
11070                int _la;
11071                try {
11072                        enterOuterAlt(_localctx, 1);
11073                        {
11074                        setState(1272);
11075                        match(OPEN);
11076                        setState(1273);
11077                        match(THEAD_HTML_TAG_NAME);
11078                        setState(1280);
11079                        _errHandler.sync(this);
11080                        _la = _input.LA(1);
11081                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
11082                                {
11083                                setState(1278);
11084                                switch (_input.LA(1)) {
11085                                case HTML_TAG_NAME:
11086                                        {
11087                                        setState(1274);
11088                                        attribute();
11089                                        }
11090                                        break;
11091                                case NEWLINE:
11092                                        {
11093                                        setState(1275);
11094                                        match(NEWLINE);
11095                                        }
11096                                        break;
11097                                case LEADING_ASTERISK:
11098                                        {
11099                                        setState(1276);
11100                                        match(LEADING_ASTERISK);
11101                                        }
11102                                        break;
11103                                case WS:
11104                                        {
11105                                        setState(1277);
11106                                        match(WS);
11107                                        }
11108                                        break;
11109                                default:
11110                                        throw new NoViableAltException(this);
11111                                }
11112                                }
11113                                setState(1282);
11114                                _errHandler.sync(this);
11115                                _la = _input.LA(1);
11116                        }
11117                        setState(1283);
11118                        match(CLOSE);
11119                        }
11120                }
11121                catch (RecognitionException re) {
11122                        _localctx.exception = re;
11123                        _errHandler.reportError(this, re);
11124                        _errHandler.recover(this, re);
11125                }
11126                finally {
11127                        exitRule();
11128                }
11129                return _localctx;
11130        }
11131
11132        public static class TheadTagCloseContext extends ParserRuleContext {
11133                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11134                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
11135                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11136                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
11137                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11138                public TerminalNode NEWLINE(int i) {
11139                        return getToken(JavadocParser.NEWLINE, i);
11140                }
11141                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11142                public TerminalNode LEADING_ASTERISK(int i) {
11143                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11144                }
11145                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11146                public TerminalNode WS(int i) {
11147                        return getToken(JavadocParser.WS, i);
11148                }
11149                public TheadTagCloseContext(ParserRuleContext parent, int invokingState) {
11150                        super(parent, invokingState);
11151                }
11152                @Override public int getRuleIndex() { return RULE_theadTagClose; }
11153                @Override
11154                public void enterRule(ParseTreeListener listener) {
11155                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagClose(this);
11156                }
11157                @Override
11158                public void exitRule(ParseTreeListener listener) {
11159                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagClose(this);
11160                }
11161                @Override
11162                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11163                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagClose(this);
11164                        else return visitor.visitChildren(this);
11165                }
11166        }
11167
11168        public final TheadTagCloseContext theadTagClose() throws RecognitionException {
11169                TheadTagCloseContext _localctx = new TheadTagCloseContext(_ctx, getState());
11170                enterRule(_localctx, 98, RULE_theadTagClose);
11171                int _la;
11172                try {
11173                        enterOuterAlt(_localctx, 1);
11174                        {
11175                        setState(1285);
11176                        match(OPEN);
11177                        setState(1286);
11178                        match(SLASH);
11179                        setState(1287);
11180                        match(THEAD_HTML_TAG_NAME);
11181                        setState(1291);
11182                        _errHandler.sync(this);
11183                        _la = _input.LA(1);
11184                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
11185                                {
11186                                {
11187                                setState(1288);
11188                                _la = _input.LA(1);
11189                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
11190                                _errHandler.recoverInline(this);
11191                                } else {
11192                                        consume();
11193                                }
11194                                }
11195                                }
11196                                setState(1293);
11197                                _errHandler.sync(this);
11198                                _la = _input.LA(1);
11199                        }
11200                        setState(1294);
11201                        match(CLOSE);
11202                        }
11203                }
11204                catch (RecognitionException re) {
11205                        _localctx.exception = re;
11206                        _errHandler.reportError(this, re);
11207                        _errHandler.recover(this, re);
11208                }
11209                finally {
11210                        exitRule();
11211                }
11212                return _localctx;
11213        }
11214
11215        public static class TheadContext extends ParserRuleContext {
11216                public TheadTagOpenContext theadTagOpen() {
11217                        return getRuleContext(TheadTagOpenContext.class,0);
11218                }
11219                public TheadTagCloseContext theadTagClose() {
11220                        return getRuleContext(TheadTagCloseContext.class,0);
11221                }
11222                public List<HtmlTagContext> htmlTag() {
11223                        return getRuleContexts(HtmlTagContext.class);
11224                }
11225                public HtmlTagContext htmlTag(int i) {
11226                        return getRuleContext(HtmlTagContext.class,i);
11227                }
11228                public List<SingletonTagContext> singletonTag() {
11229                        return getRuleContexts(SingletonTagContext.class);
11230                }
11231                public SingletonTagContext singletonTag(int i) {
11232                        return getRuleContext(SingletonTagContext.class,i);
11233                }
11234                public List<ParagraphContext> paragraph() {
11235                        return getRuleContexts(ParagraphContext.class);
11236                }
11237                public ParagraphContext paragraph(int i) {
11238                        return getRuleContext(ParagraphContext.class,i);
11239                }
11240                public List<LiContext> li() {
11241                        return getRuleContexts(LiContext.class);
11242                }
11243                public LiContext li(int i) {
11244                        return getRuleContext(LiContext.class,i);
11245                }
11246                public List<TrContext> tr() {
11247                        return getRuleContexts(TrContext.class);
11248                }
11249                public TrContext tr(int i) {
11250                        return getRuleContext(TrContext.class,i);
11251                }
11252                public List<TdContext> td() {
11253                        return getRuleContexts(TdContext.class);
11254                }
11255                public TdContext td(int i) {
11256                        return getRuleContext(TdContext.class,i);
11257                }
11258                public List<ThContext> th() {
11259                        return getRuleContexts(ThContext.class);
11260                }
11261                public ThContext th(int i) {
11262                        return getRuleContext(ThContext.class,i);
11263                }
11264                public List<BodyContext> body() {
11265                        return getRuleContexts(BodyContext.class);
11266                }
11267                public BodyContext body(int i) {
11268                        return getRuleContext(BodyContext.class,i);
11269                }
11270                public List<ColgroupContext> colgroup() {
11271                        return getRuleContexts(ColgroupContext.class);
11272                }
11273                public ColgroupContext colgroup(int i) {
11274                        return getRuleContext(ColgroupContext.class,i);
11275                }
11276                public List<DdContext> dd() {
11277                        return getRuleContexts(DdContext.class);
11278                }
11279                public DdContext dd(int i) {
11280                        return getRuleContext(DdContext.class,i);
11281                }
11282                public List<DtContext> dt() {
11283                        return getRuleContexts(DtContext.class);
11284                }
11285                public DtContext dt(int i) {
11286                        return getRuleContext(DtContext.class,i);
11287                }
11288                public List<HeadContext> head() {
11289                        return getRuleContexts(HeadContext.class);
11290                }
11291                public HeadContext head(int i) {
11292                        return getRuleContext(HeadContext.class,i);
11293                }
11294                public List<HtmlContext> html() {
11295                        return getRuleContexts(HtmlContext.class);
11296                }
11297                public HtmlContext html(int i) {
11298                        return getRuleContext(HtmlContext.class,i);
11299                }
11300                public List<OptionContext> option() {
11301                        return getRuleContexts(OptionContext.class);
11302                }
11303                public OptionContext option(int i) {
11304                        return getRuleContext(OptionContext.class,i);
11305                }
11306                public List<TbodyContext> tbody() {
11307                        return getRuleContexts(TbodyContext.class);
11308                }
11309                public TbodyContext tbody(int i) {
11310                        return getRuleContext(TbodyContext.class,i);
11311                }
11312                public List<TfootContext> tfoot() {
11313                        return getRuleContexts(TfootContext.class);
11314                }
11315                public TfootContext tfoot(int i) {
11316                        return getRuleContext(TfootContext.class,i);
11317                }
11318                public List<PTagOpenContext> pTagOpen() {
11319                        return getRuleContexts(PTagOpenContext.class);
11320                }
11321                public PTagOpenContext pTagOpen(int i) {
11322                        return getRuleContext(PTagOpenContext.class,i);
11323                }
11324                public List<LiTagOpenContext> liTagOpen() {
11325                        return getRuleContexts(LiTagOpenContext.class);
11326                }
11327                public LiTagOpenContext liTagOpen(int i) {
11328                        return getRuleContext(LiTagOpenContext.class,i);
11329                }
11330                public List<TrTagOpenContext> trTagOpen() {
11331                        return getRuleContexts(TrTagOpenContext.class);
11332                }
11333                public TrTagOpenContext trTagOpen(int i) {
11334                        return getRuleContext(TrTagOpenContext.class,i);
11335                }
11336                public List<TdTagOpenContext> tdTagOpen() {
11337                        return getRuleContexts(TdTagOpenContext.class);
11338                }
11339                public TdTagOpenContext tdTagOpen(int i) {
11340                        return getRuleContext(TdTagOpenContext.class,i);
11341                }
11342                public List<ThTagOpenContext> thTagOpen() {
11343                        return getRuleContexts(ThTagOpenContext.class);
11344                }
11345                public ThTagOpenContext thTagOpen(int i) {
11346                        return getRuleContext(ThTagOpenContext.class,i);
11347                }
11348                public List<BodyTagOpenContext> bodyTagOpen() {
11349                        return getRuleContexts(BodyTagOpenContext.class);
11350                }
11351                public BodyTagOpenContext bodyTagOpen(int i) {
11352                        return getRuleContext(BodyTagOpenContext.class,i);
11353                }
11354                public List<ColgroupTagOpenContext> colgroupTagOpen() {
11355                        return getRuleContexts(ColgroupTagOpenContext.class);
11356                }
11357                public ColgroupTagOpenContext colgroupTagOpen(int i) {
11358                        return getRuleContext(ColgroupTagOpenContext.class,i);
11359                }
11360                public List<DdTagOpenContext> ddTagOpen() {
11361                        return getRuleContexts(DdTagOpenContext.class);
11362                }
11363                public DdTagOpenContext ddTagOpen(int i) {
11364                        return getRuleContext(DdTagOpenContext.class,i);
11365                }
11366                public List<DtTagOpenContext> dtTagOpen() {
11367                        return getRuleContexts(DtTagOpenContext.class);
11368                }
11369                public DtTagOpenContext dtTagOpen(int i) {
11370                        return getRuleContext(DtTagOpenContext.class,i);
11371                }
11372                public List<HeadTagOpenContext> headTagOpen() {
11373                        return getRuleContexts(HeadTagOpenContext.class);
11374                }
11375                public HeadTagOpenContext headTagOpen(int i) {
11376                        return getRuleContext(HeadTagOpenContext.class,i);
11377                }
11378                public List<HtmlTagOpenContext> htmlTagOpen() {
11379                        return getRuleContexts(HtmlTagOpenContext.class);
11380                }
11381                public HtmlTagOpenContext htmlTagOpen(int i) {
11382                        return getRuleContext(HtmlTagOpenContext.class,i);
11383                }
11384                public List<OptionTagOpenContext> optionTagOpen() {
11385                        return getRuleContexts(OptionTagOpenContext.class);
11386                }
11387                public OptionTagOpenContext optionTagOpen(int i) {
11388                        return getRuleContext(OptionTagOpenContext.class,i);
11389                }
11390                public List<TbodyTagOpenContext> tbodyTagOpen() {
11391                        return getRuleContexts(TbodyTagOpenContext.class);
11392                }
11393                public TbodyTagOpenContext tbodyTagOpen(int i) {
11394                        return getRuleContext(TbodyTagOpenContext.class,i);
11395                }
11396                public List<TfootTagOpenContext> tfootTagOpen() {
11397                        return getRuleContexts(TfootTagOpenContext.class);
11398                }
11399                public TfootTagOpenContext tfootTagOpen(int i) {
11400                        return getRuleContext(TfootTagOpenContext.class,i);
11401                }
11402                public List<HtmlCommentContext> htmlComment() {
11403                        return getRuleContexts(HtmlCommentContext.class);
11404                }
11405                public HtmlCommentContext htmlComment(int i) {
11406                        return getRuleContext(HtmlCommentContext.class,i);
11407                }
11408                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
11409                public TerminalNode CDATA(int i) {
11410                        return getToken(JavadocParser.CDATA, i);
11411                }
11412                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11413                public TerminalNode NEWLINE(int i) {
11414                        return getToken(JavadocParser.NEWLINE, i);
11415                }
11416                public List<TextContext> text() {
11417                        return getRuleContexts(TextContext.class);
11418                }
11419                public TextContext text(int i) {
11420                        return getRuleContext(TextContext.class,i);
11421                }
11422                public List<JavadocInlineTagContext> javadocInlineTag() {
11423                        return getRuleContexts(JavadocInlineTagContext.class);
11424                }
11425                public JavadocInlineTagContext javadocInlineTag(int i) {
11426                        return getRuleContext(JavadocInlineTagContext.class,i);
11427                }
11428                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11429                public TerminalNode LEADING_ASTERISK(int i) {
11430                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11431                }
11432                public TheadContext(ParserRuleContext parent, int invokingState) {
11433                        super(parent, invokingState);
11434                }
11435                @Override public int getRuleIndex() { return RULE_thead; }
11436                @Override
11437                public void enterRule(ParseTreeListener listener) {
11438                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThead(this);
11439                }
11440                @Override
11441                public void exitRule(ParseTreeListener listener) {
11442                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThead(this);
11443                }
11444                @Override
11445                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11446                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThead(this);
11447                        else return visitor.visitChildren(this);
11448                }
11449        }
11450
11451        public final TheadContext thead() throws RecognitionException {
11452                TheadContext _localctx = new TheadContext(_ctx, getState());
11453                enterRule(_localctx, 100, RULE_thead);
11454                try {
11455                        int _alt;
11456                        enterOuterAlt(_localctx, 1);
11457                        {
11458                        setState(1296);
11459                        theadTagOpen();
11460                        setState(1336);
11461                        _errHandler.sync(this);
11462                        _alt = getInterpreter().adaptivePredict(_input,91,_ctx);
11463                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
11464                                if ( _alt==1 ) {
11465                                        {
11466                                        setState(1334);
11467                                        _errHandler.sync(this);
11468                                        switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
11469                                        case 1:
11470                                                {
11471                                                setState(1297);
11472                                                htmlTag();
11473                                                }
11474                                                break;
11475                                        case 2:
11476                                                {
11477                                                setState(1298);
11478                                                singletonTag();
11479                                                }
11480                                                break;
11481                                        case 3:
11482                                                {
11483                                                setState(1299);
11484                                                paragraph();
11485                                                }
11486                                                break;
11487                                        case 4:
11488                                                {
11489                                                setState(1300);
11490                                                li();
11491                                                }
11492                                                break;
11493                                        case 5:
11494                                                {
11495                                                setState(1301);
11496                                                tr();
11497                                                }
11498                                                break;
11499                                        case 6:
11500                                                {
11501                                                setState(1302);
11502                                                td();
11503                                                }
11504                                                break;
11505                                        case 7:
11506                                                {
11507                                                setState(1303);
11508                                                th();
11509                                                }
11510                                                break;
11511                                        case 8:
11512                                                {
11513                                                setState(1304);
11514                                                body();
11515                                                }
11516                                                break;
11517                                        case 9:
11518                                                {
11519                                                setState(1305);
11520                                                colgroup();
11521                                                }
11522                                                break;
11523                                        case 10:
11524                                                {
11525                                                setState(1306);
11526                                                dd();
11527                                                }
11528                                                break;
11529                                        case 11:
11530                                                {
11531                                                setState(1307);
11532                                                dt();
11533                                                }
11534                                                break;
11535                                        case 12:
11536                                                {
11537                                                setState(1308);
11538                                                head();
11539                                                }
11540                                                break;
11541                                        case 13:
11542                                                {
11543                                                setState(1309);
11544                                                html();
11545                                                }
11546                                                break;
11547                                        case 14:
11548                                                {
11549                                                setState(1310);
11550                                                option();
11551                                                }
11552                                                break;
11553                                        case 15:
11554                                                {
11555                                                setState(1311);
11556                                                tbody();
11557                                                }
11558                                                break;
11559                                        case 16:
11560                                                {
11561                                                setState(1312);
11562                                                tfoot();
11563                                                }
11564                                                break;
11565                                        case 17:
11566                                                {
11567                                                setState(1313);
11568                                                pTagOpen();
11569                                                }
11570                                                break;
11571                                        case 18:
11572                                                {
11573                                                setState(1314);
11574                                                liTagOpen();
11575                                                }
11576                                                break;
11577                                        case 19:
11578                                                {
11579                                                setState(1315);
11580                                                trTagOpen();
11581                                                }
11582                                                break;
11583                                        case 20:
11584                                                {
11585                                                setState(1316);
11586                                                tdTagOpen();
11587                                                }
11588                                                break;
11589                                        case 21:
11590                                                {
11591                                                setState(1317);
11592                                                thTagOpen();
11593                                                }
11594                                                break;
11595                                        case 22:
11596                                                {
11597                                                setState(1318);
11598                                                bodyTagOpen();
11599                                                }
11600                                                break;
11601                                        case 23:
11602                                                {
11603                                                setState(1319);
11604                                                colgroupTagOpen();
11605                                                }
11606                                                break;
11607                                        case 24:
11608                                                {
11609                                                setState(1320);
11610                                                ddTagOpen();
11611                                                }
11612                                                break;
11613                                        case 25:
11614                                                {
11615                                                setState(1321);
11616                                                dtTagOpen();
11617                                                }
11618                                                break;
11619                                        case 26:
11620                                                {
11621                                                setState(1322);
11622                                                headTagOpen();
11623                                                }
11624                                                break;
11625                                        case 27:
11626                                                {
11627                                                setState(1323);
11628                                                htmlTagOpen();
11629                                                }
11630                                                break;
11631                                        case 28:
11632                                                {
11633                                                setState(1324);
11634                                                optionTagOpen();
11635                                                }
11636                                                break;
11637                                        case 29:
11638                                                {
11639                                                setState(1325);
11640                                                tbodyTagOpen();
11641                                                }
11642                                                break;
11643                                        case 30:
11644                                                {
11645                                                setState(1326);
11646                                                tfootTagOpen();
11647                                                }
11648                                                break;
11649                                        case 31:
11650                                                {
11651                                                {
11652                                                setState(1327);
11653                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
11654                                                setState(1328);
11655                                                match(LEADING_ASTERISK);
11656                                                }
11657                                                }
11658                                                break;
11659                                        case 32:
11660                                                {
11661                                                setState(1329);
11662                                                htmlComment();
11663                                                }
11664                                                break;
11665                                        case 33:
11666                                                {
11667                                                setState(1330);
11668                                                match(CDATA);
11669                                                }
11670                                                break;
11671                                        case 34:
11672                                                {
11673                                                setState(1331);
11674                                                match(NEWLINE);
11675                                                }
11676                                                break;
11677                                        case 35:
11678                                                {
11679                                                setState(1332);
11680                                                text();
11681                                                }
11682                                                break;
11683                                        case 36:
11684                                                {
11685                                                setState(1333);
11686                                                javadocInlineTag();
11687                                                }
11688                                                break;
11689                                        }
11690                                        } 
11691                                }
11692                                setState(1338);
11693                                _errHandler.sync(this);
11694                                _alt = getInterpreter().adaptivePredict(_input,91,_ctx);
11695                        }
11696                        setState(1339);
11697                        theadTagClose();
11698                        }
11699                }
11700                catch (RecognitionException re) {
11701                        _localctx.exception = re;
11702                        _errHandler.reportError(this, re);
11703                        _errHandler.recover(this, re);
11704                }
11705                finally {
11706                        exitRule();
11707                }
11708                return _localctx;
11709        }
11710
11711        public static class SingletonElementContext extends ParserRuleContext {
11712                public SingletonTagContext singletonTag() {
11713                        return getRuleContext(SingletonTagContext.class,0);
11714                }
11715                public AreaTagContext areaTag() {
11716                        return getRuleContext(AreaTagContext.class,0);
11717                }
11718                public BaseTagContext baseTag() {
11719                        return getRuleContext(BaseTagContext.class,0);
11720                }
11721                public BasefontTagContext basefontTag() {
11722                        return getRuleContext(BasefontTagContext.class,0);
11723                }
11724                public BrTagContext brTag() {
11725                        return getRuleContext(BrTagContext.class,0);
11726                }
11727                public ColTagContext colTag() {
11728                        return getRuleContext(ColTagContext.class,0);
11729                }
11730                public FrameTagContext frameTag() {
11731                        return getRuleContext(FrameTagContext.class,0);
11732                }
11733                public HrTagContext hrTag() {
11734                        return getRuleContext(HrTagContext.class,0);
11735                }
11736                public ImgTagContext imgTag() {
11737                        return getRuleContext(ImgTagContext.class,0);
11738                }
11739                public InputTagContext inputTag() {
11740                        return getRuleContext(InputTagContext.class,0);
11741                }
11742                public IsindexTagContext isindexTag() {
11743                        return getRuleContext(IsindexTagContext.class,0);
11744                }
11745                public LinkTagContext linkTag() {
11746                        return getRuleContext(LinkTagContext.class,0);
11747                }
11748                public MetaTagContext metaTag() {
11749                        return getRuleContext(MetaTagContext.class,0);
11750                }
11751                public ParamTagContext paramTag() {
11752                        return getRuleContext(ParamTagContext.class,0);
11753                }
11754                public WrongSinletonTagContext wrongSinletonTag() {
11755                        return getRuleContext(WrongSinletonTagContext.class,0);
11756                }
11757                public SingletonElementContext(ParserRuleContext parent, int invokingState) {
11758                        super(parent, invokingState);
11759                }
11760                @Override public int getRuleIndex() { return RULE_singletonElement; }
11761                @Override
11762                public void enterRule(ParseTreeListener listener) {
11763                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonElement(this);
11764                }
11765                @Override
11766                public void exitRule(ParseTreeListener listener) {
11767                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonElement(this);
11768                }
11769                @Override
11770                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11771                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonElement(this);
11772                        else return visitor.visitChildren(this);
11773                }
11774        }
11775
11776        public final SingletonElementContext singletonElement() throws RecognitionException {
11777                SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState());
11778                enterRule(_localctx, 102, RULE_singletonElement);
11779                try {
11780                        setState(1356);
11781                        _errHandler.sync(this);
11782                        switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
11783                        case 1:
11784                                enterOuterAlt(_localctx, 1);
11785                                {
11786                                setState(1341);
11787                                singletonTag();
11788                                }
11789                                break;
11790                        case 2:
11791                                enterOuterAlt(_localctx, 2);
11792                                {
11793                                setState(1342);
11794                                areaTag();
11795                                }
11796                                break;
11797                        case 3:
11798                                enterOuterAlt(_localctx, 3);
11799                                {
11800                                setState(1343);
11801                                baseTag();
11802                                }
11803                                break;
11804                        case 4:
11805                                enterOuterAlt(_localctx, 4);
11806                                {
11807                                setState(1344);
11808                                basefontTag();
11809                                }
11810                                break;
11811                        case 5:
11812                                enterOuterAlt(_localctx, 5);
11813                                {
11814                                setState(1345);
11815                                brTag();
11816                                }
11817                                break;
11818                        case 6:
11819                                enterOuterAlt(_localctx, 6);
11820                                {
11821                                setState(1346);
11822                                colTag();
11823                                }
11824                                break;
11825                        case 7:
11826                                enterOuterAlt(_localctx, 7);
11827                                {
11828                                setState(1347);
11829                                frameTag();
11830                                }
11831                                break;
11832                        case 8:
11833                                enterOuterAlt(_localctx, 8);
11834                                {
11835                                setState(1348);
11836                                hrTag();
11837                                }
11838                                break;
11839                        case 9:
11840                                enterOuterAlt(_localctx, 9);
11841                                {
11842                                setState(1349);
11843                                imgTag();
11844                                }
11845                                break;
11846                        case 10:
11847                                enterOuterAlt(_localctx, 10);
11848                                {
11849                                setState(1350);
11850                                inputTag();
11851                                }
11852                                break;
11853                        case 11:
11854                                enterOuterAlt(_localctx, 11);
11855                                {
11856                                setState(1351);
11857                                isindexTag();
11858                                }
11859                                break;
11860                        case 12:
11861                                enterOuterAlt(_localctx, 12);
11862                                {
11863                                setState(1352);
11864                                linkTag();
11865                                }
11866                                break;
11867                        case 13:
11868                                enterOuterAlt(_localctx, 13);
11869                                {
11870                                setState(1353);
11871                                metaTag();
11872                                }
11873                                break;
11874                        case 14:
11875                                enterOuterAlt(_localctx, 14);
11876                                {
11877                                setState(1354);
11878                                paramTag();
11879                                }
11880                                break;
11881                        case 15:
11882                                enterOuterAlt(_localctx, 15);
11883                                {
11884                                setState(1355);
11885                                wrongSinletonTag();
11886                                }
11887                                break;
11888                        }
11889                }
11890                catch (RecognitionException re) {
11891                        _localctx.exception = re;
11892                        _errHandler.reportError(this, re);
11893                        _errHandler.recover(this, re);
11894                }
11895                finally {
11896                        exitRule();
11897                }
11898                return _localctx;
11899        }
11900
11901        public static class SingletonTagContext extends ParserRuleContext {
11902                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11903                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
11904                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
11905                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
11906                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
11907                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
11908                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
11909                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
11910                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
11911                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
11912                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
11913                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
11914                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
11915                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
11916                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
11917                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
11918                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
11919                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11920                public List<AttributeContext> attribute() {
11921                        return getRuleContexts(AttributeContext.class);
11922                }
11923                public AttributeContext attribute(int i) {
11924                        return getRuleContext(AttributeContext.class,i);
11925                }
11926                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11927                public TerminalNode NEWLINE(int i) {
11928                        return getToken(JavadocParser.NEWLINE, i);
11929                }
11930                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11931                public TerminalNode LEADING_ASTERISK(int i) {
11932                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11933                }
11934                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11935                public TerminalNode WS(int i) {
11936                        return getToken(JavadocParser.WS, i);
11937                }
11938                public SingletonTagContext(ParserRuleContext parent, int invokingState) {
11939                        super(parent, invokingState);
11940                }
11941                @Override public int getRuleIndex() { return RULE_singletonTag; }
11942                @Override
11943                public void enterRule(ParseTreeListener listener) {
11944                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTag(this);
11945                }
11946                @Override
11947                public void exitRule(ParseTreeListener listener) {
11948                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTag(this);
11949                }
11950                @Override
11951                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11952                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTag(this);
11953                        else return visitor.visitChildren(this);
11954                }
11955        }
11956
11957        public final SingletonTagContext singletonTag() throws RecognitionException {
11958                SingletonTagContext _localctx = new SingletonTagContext(_ctx, getState());
11959                enterRule(_localctx, 104, RULE_singletonTag);
11960                int _la;
11961                try {
11962                        enterOuterAlt(_localctx, 1);
11963                        {
11964                        setState(1358);
11965                        match(OPEN);
11966                        setState(1359);
11967                        _la = _input.LA(1);
11968                        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)) ) {
11969                        _errHandler.recoverInline(this);
11970                        } else {
11971                                consume();
11972                        }
11973                        setState(1366);
11974                        _errHandler.sync(this);
11975                        _la = _input.LA(1);
11976                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
11977                                {
11978                                setState(1364);
11979                                switch (_input.LA(1)) {
11980                                case HTML_TAG_NAME:
11981                                        {
11982                                        setState(1360);
11983                                        attribute();
11984                                        }
11985                                        break;
11986                                case NEWLINE:
11987                                        {
11988                                        setState(1361);
11989                                        match(NEWLINE);
11990                                        }
11991                                        break;
11992                                case LEADING_ASTERISK:
11993                                        {
11994                                        setState(1362);
11995                                        match(LEADING_ASTERISK);
11996                                        }
11997                                        break;
11998                                case WS:
11999                                        {
12000                                        setState(1363);
12001                                        match(WS);
12002                                        }
12003                                        break;
12004                                default:
12005                                        throw new NoViableAltException(this);
12006                                }
12007                                }
12008                                setState(1368);
12009                                _errHandler.sync(this);
12010                                _la = _input.LA(1);
12011                        }
12012                        setState(1369);
12013                        match(SLASH_CLOSE);
12014                        }
12015                }
12016                catch (RecognitionException re) {
12017                        _localctx.exception = re;
12018                        _errHandler.reportError(this, re);
12019                        _errHandler.recover(this, re);
12020                }
12021                finally {
12022                        exitRule();
12023                }
12024                return _localctx;
12025        }
12026
12027        public static class AreaTagContext extends ParserRuleContext {
12028                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12029                public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); }
12030                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12031                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12032                public List<AttributeContext> attribute() {
12033                        return getRuleContexts(AttributeContext.class);
12034                }
12035                public AttributeContext attribute(int i) {
12036                        return getRuleContext(AttributeContext.class,i);
12037                }
12038                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12039                public TerminalNode NEWLINE(int i) {
12040                        return getToken(JavadocParser.NEWLINE, i);
12041                }
12042                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12043                public TerminalNode LEADING_ASTERISK(int i) {
12044                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12045                }
12046                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12047                public TerminalNode WS(int i) {
12048                        return getToken(JavadocParser.WS, i);
12049                }
12050                public AreaTagContext(ParserRuleContext parent, int invokingState) {
12051                        super(parent, invokingState);
12052                }
12053                @Override public int getRuleIndex() { return RULE_areaTag; }
12054                @Override
12055                public void enterRule(ParseTreeListener listener) {
12056                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAreaTag(this);
12057                }
12058                @Override
12059                public void exitRule(ParseTreeListener listener) {
12060                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAreaTag(this);
12061                }
12062                @Override
12063                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12064                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAreaTag(this);
12065                        else return visitor.visitChildren(this);
12066                }
12067        }
12068
12069        public final AreaTagContext areaTag() throws RecognitionException {
12070                AreaTagContext _localctx = new AreaTagContext(_ctx, getState());
12071                enterRule(_localctx, 106, RULE_areaTag);
12072                int _la;
12073                try {
12074                        enterOuterAlt(_localctx, 1);
12075                        {
12076                        setState(1371);
12077                        match(OPEN);
12078                        setState(1372);
12079                        match(AREA_HTML_TAG_NAME);
12080                        setState(1379);
12081                        _errHandler.sync(this);
12082                        _la = _input.LA(1);
12083                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12084                                {
12085                                setState(1377);
12086                                switch (_input.LA(1)) {
12087                                case HTML_TAG_NAME:
12088                                        {
12089                                        setState(1373);
12090                                        attribute();
12091                                        }
12092                                        break;
12093                                case NEWLINE:
12094                                        {
12095                                        setState(1374);
12096                                        match(NEWLINE);
12097                                        }
12098                                        break;
12099                                case LEADING_ASTERISK:
12100                                        {
12101                                        setState(1375);
12102                                        match(LEADING_ASTERISK);
12103                                        }
12104                                        break;
12105                                case WS:
12106                                        {
12107                                        setState(1376);
12108                                        match(WS);
12109                                        }
12110                                        break;
12111                                default:
12112                                        throw new NoViableAltException(this);
12113                                }
12114                                }
12115                                setState(1381);
12116                                _errHandler.sync(this);
12117                                _la = _input.LA(1);
12118                        }
12119                        setState(1382);
12120                        _la = _input.LA(1);
12121                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12122                        _errHandler.recoverInline(this);
12123                        } else {
12124                                consume();
12125                        }
12126                        }
12127                }
12128                catch (RecognitionException re) {
12129                        _localctx.exception = re;
12130                        _errHandler.reportError(this, re);
12131                        _errHandler.recover(this, re);
12132                }
12133                finally {
12134                        exitRule();
12135                }
12136                return _localctx;
12137        }
12138
12139        public static class BaseTagContext extends ParserRuleContext {
12140                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12141                public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); }
12142                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12143                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12144                public List<AttributeContext> attribute() {
12145                        return getRuleContexts(AttributeContext.class);
12146                }
12147                public AttributeContext attribute(int i) {
12148                        return getRuleContext(AttributeContext.class,i);
12149                }
12150                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12151                public TerminalNode NEWLINE(int i) {
12152                        return getToken(JavadocParser.NEWLINE, i);
12153                }
12154                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12155                public TerminalNode LEADING_ASTERISK(int i) {
12156                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12157                }
12158                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12159                public TerminalNode WS(int i) {
12160                        return getToken(JavadocParser.WS, i);
12161                }
12162                public BaseTagContext(ParserRuleContext parent, int invokingState) {
12163                        super(parent, invokingState);
12164                }
12165                @Override public int getRuleIndex() { return RULE_baseTag; }
12166                @Override
12167                public void enterRule(ParseTreeListener listener) {
12168                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBaseTag(this);
12169                }
12170                @Override
12171                public void exitRule(ParseTreeListener listener) {
12172                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBaseTag(this);
12173                }
12174                @Override
12175                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12176                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBaseTag(this);
12177                        else return visitor.visitChildren(this);
12178                }
12179        }
12180
12181        public final BaseTagContext baseTag() throws RecognitionException {
12182                BaseTagContext _localctx = new BaseTagContext(_ctx, getState());
12183                enterRule(_localctx, 108, RULE_baseTag);
12184                int _la;
12185                try {
12186                        enterOuterAlt(_localctx, 1);
12187                        {
12188                        setState(1384);
12189                        match(OPEN);
12190                        setState(1385);
12191                        match(BASE_HTML_TAG_NAME);
12192                        setState(1392);
12193                        _errHandler.sync(this);
12194                        _la = _input.LA(1);
12195                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12196                                {
12197                                setState(1390);
12198                                switch (_input.LA(1)) {
12199                                case HTML_TAG_NAME:
12200                                        {
12201                                        setState(1386);
12202                                        attribute();
12203                                        }
12204                                        break;
12205                                case NEWLINE:
12206                                        {
12207                                        setState(1387);
12208                                        match(NEWLINE);
12209                                        }
12210                                        break;
12211                                case LEADING_ASTERISK:
12212                                        {
12213                                        setState(1388);
12214                                        match(LEADING_ASTERISK);
12215                                        }
12216                                        break;
12217                                case WS:
12218                                        {
12219                                        setState(1389);
12220                                        match(WS);
12221                                        }
12222                                        break;
12223                                default:
12224                                        throw new NoViableAltException(this);
12225                                }
12226                                }
12227                                setState(1394);
12228                                _errHandler.sync(this);
12229                                _la = _input.LA(1);
12230                        }
12231                        setState(1395);
12232                        _la = _input.LA(1);
12233                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12234                        _errHandler.recoverInline(this);
12235                        } else {
12236                                consume();
12237                        }
12238                        }
12239                }
12240                catch (RecognitionException re) {
12241                        _localctx.exception = re;
12242                        _errHandler.reportError(this, re);
12243                        _errHandler.recover(this, re);
12244                }
12245                finally {
12246                        exitRule();
12247                }
12248                return _localctx;
12249        }
12250
12251        public static class BasefontTagContext extends ParserRuleContext {
12252                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12253                public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); }
12254                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12255                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12256                public List<AttributeContext> attribute() {
12257                        return getRuleContexts(AttributeContext.class);
12258                }
12259                public AttributeContext attribute(int i) {
12260                        return getRuleContext(AttributeContext.class,i);
12261                }
12262                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12263                public TerminalNode NEWLINE(int i) {
12264                        return getToken(JavadocParser.NEWLINE, i);
12265                }
12266                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12267                public TerminalNode LEADING_ASTERISK(int i) {
12268                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12269                }
12270                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12271                public TerminalNode WS(int i) {
12272                        return getToken(JavadocParser.WS, i);
12273                }
12274                public BasefontTagContext(ParserRuleContext parent, int invokingState) {
12275                        super(parent, invokingState);
12276                }
12277                @Override public int getRuleIndex() { return RULE_basefontTag; }
12278                @Override
12279                public void enterRule(ParseTreeListener listener) {
12280                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBasefontTag(this);
12281                }
12282                @Override
12283                public void exitRule(ParseTreeListener listener) {
12284                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBasefontTag(this);
12285                }
12286                @Override
12287                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12288                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBasefontTag(this);
12289                        else return visitor.visitChildren(this);
12290                }
12291        }
12292
12293        public final BasefontTagContext basefontTag() throws RecognitionException {
12294                BasefontTagContext _localctx = new BasefontTagContext(_ctx, getState());
12295                enterRule(_localctx, 110, RULE_basefontTag);
12296                int _la;
12297                try {
12298                        enterOuterAlt(_localctx, 1);
12299                        {
12300                        setState(1397);
12301                        match(OPEN);
12302                        setState(1398);
12303                        match(BASEFONT_HTML_TAG_NAME);
12304                        setState(1405);
12305                        _errHandler.sync(this);
12306                        _la = _input.LA(1);
12307                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12308                                {
12309                                setState(1403);
12310                                switch (_input.LA(1)) {
12311                                case HTML_TAG_NAME:
12312                                        {
12313                                        setState(1399);
12314                                        attribute();
12315                                        }
12316                                        break;
12317                                case NEWLINE:
12318                                        {
12319                                        setState(1400);
12320                                        match(NEWLINE);
12321                                        }
12322                                        break;
12323                                case LEADING_ASTERISK:
12324                                        {
12325                                        setState(1401);
12326                                        match(LEADING_ASTERISK);
12327                                        }
12328                                        break;
12329                                case WS:
12330                                        {
12331                                        setState(1402);
12332                                        match(WS);
12333                                        }
12334                                        break;
12335                                default:
12336                                        throw new NoViableAltException(this);
12337                                }
12338                                }
12339                                setState(1407);
12340                                _errHandler.sync(this);
12341                                _la = _input.LA(1);
12342                        }
12343                        setState(1408);
12344                        _la = _input.LA(1);
12345                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12346                        _errHandler.recoverInline(this);
12347                        } else {
12348                                consume();
12349                        }
12350                        }
12351                }
12352                catch (RecognitionException re) {
12353                        _localctx.exception = re;
12354                        _errHandler.reportError(this, re);
12355                        _errHandler.recover(this, re);
12356                }
12357                finally {
12358                        exitRule();
12359                }
12360                return _localctx;
12361        }
12362
12363        public static class BrTagContext extends ParserRuleContext {
12364                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12365                public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); }
12366                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12367                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12368                public List<AttributeContext> attribute() {
12369                        return getRuleContexts(AttributeContext.class);
12370                }
12371                public AttributeContext attribute(int i) {
12372                        return getRuleContext(AttributeContext.class,i);
12373                }
12374                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12375                public TerminalNode NEWLINE(int i) {
12376                        return getToken(JavadocParser.NEWLINE, i);
12377                }
12378                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12379                public TerminalNode LEADING_ASTERISK(int i) {
12380                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12381                }
12382                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12383                public TerminalNode WS(int i) {
12384                        return getToken(JavadocParser.WS, i);
12385                }
12386                public BrTagContext(ParserRuleContext parent, int invokingState) {
12387                        super(parent, invokingState);
12388                }
12389                @Override public int getRuleIndex() { return RULE_brTag; }
12390                @Override
12391                public void enterRule(ParseTreeListener listener) {
12392                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBrTag(this);
12393                }
12394                @Override
12395                public void exitRule(ParseTreeListener listener) {
12396                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBrTag(this);
12397                }
12398                @Override
12399                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12400                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBrTag(this);
12401                        else return visitor.visitChildren(this);
12402                }
12403        }
12404
12405        public final BrTagContext brTag() throws RecognitionException {
12406                BrTagContext _localctx = new BrTagContext(_ctx, getState());
12407                enterRule(_localctx, 112, RULE_brTag);
12408                int _la;
12409                try {
12410                        enterOuterAlt(_localctx, 1);
12411                        {
12412                        setState(1410);
12413                        match(OPEN);
12414                        setState(1411);
12415                        match(BR_HTML_TAG_NAME);
12416                        setState(1418);
12417                        _errHandler.sync(this);
12418                        _la = _input.LA(1);
12419                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12420                                {
12421                                setState(1416);
12422                                switch (_input.LA(1)) {
12423                                case HTML_TAG_NAME:
12424                                        {
12425                                        setState(1412);
12426                                        attribute();
12427                                        }
12428                                        break;
12429                                case NEWLINE:
12430                                        {
12431                                        setState(1413);
12432                                        match(NEWLINE);
12433                                        }
12434                                        break;
12435                                case LEADING_ASTERISK:
12436                                        {
12437                                        setState(1414);
12438                                        match(LEADING_ASTERISK);
12439                                        }
12440                                        break;
12441                                case WS:
12442                                        {
12443                                        setState(1415);
12444                                        match(WS);
12445                                        }
12446                                        break;
12447                                default:
12448                                        throw new NoViableAltException(this);
12449                                }
12450                                }
12451                                setState(1420);
12452                                _errHandler.sync(this);
12453                                _la = _input.LA(1);
12454                        }
12455                        setState(1421);
12456                        _la = _input.LA(1);
12457                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12458                        _errHandler.recoverInline(this);
12459                        } else {
12460                                consume();
12461                        }
12462                        }
12463                }
12464                catch (RecognitionException re) {
12465                        _localctx.exception = re;
12466                        _errHandler.reportError(this, re);
12467                        _errHandler.recover(this, re);
12468                }
12469                finally {
12470                        exitRule();
12471                }
12472                return _localctx;
12473        }
12474
12475        public static class ColTagContext extends ParserRuleContext {
12476                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12477                public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); }
12478                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12479                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12480                public List<AttributeContext> attribute() {
12481                        return getRuleContexts(AttributeContext.class);
12482                }
12483                public AttributeContext attribute(int i) {
12484                        return getRuleContext(AttributeContext.class,i);
12485                }
12486                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12487                public TerminalNode NEWLINE(int i) {
12488                        return getToken(JavadocParser.NEWLINE, i);
12489                }
12490                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12491                public TerminalNode LEADING_ASTERISK(int i) {
12492                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12493                }
12494                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12495                public TerminalNode WS(int i) {
12496                        return getToken(JavadocParser.WS, i);
12497                }
12498                public ColTagContext(ParserRuleContext parent, int invokingState) {
12499                        super(parent, invokingState);
12500                }
12501                @Override public int getRuleIndex() { return RULE_colTag; }
12502                @Override
12503                public void enterRule(ParseTreeListener listener) {
12504                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColTag(this);
12505                }
12506                @Override
12507                public void exitRule(ParseTreeListener listener) {
12508                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColTag(this);
12509                }
12510                @Override
12511                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12512                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColTag(this);
12513                        else return visitor.visitChildren(this);
12514                }
12515        }
12516
12517        public final ColTagContext colTag() throws RecognitionException {
12518                ColTagContext _localctx = new ColTagContext(_ctx, getState());
12519                enterRule(_localctx, 114, RULE_colTag);
12520                int _la;
12521                try {
12522                        enterOuterAlt(_localctx, 1);
12523                        {
12524                        setState(1423);
12525                        match(OPEN);
12526                        setState(1424);
12527                        match(COL_HTML_TAG_NAME);
12528                        setState(1431);
12529                        _errHandler.sync(this);
12530                        _la = _input.LA(1);
12531                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12532                                {
12533                                setState(1429);
12534                                switch (_input.LA(1)) {
12535                                case HTML_TAG_NAME:
12536                                        {
12537                                        setState(1425);
12538                                        attribute();
12539                                        }
12540                                        break;
12541                                case NEWLINE:
12542                                        {
12543                                        setState(1426);
12544                                        match(NEWLINE);
12545                                        }
12546                                        break;
12547                                case LEADING_ASTERISK:
12548                                        {
12549                                        setState(1427);
12550                                        match(LEADING_ASTERISK);
12551                                        }
12552                                        break;
12553                                case WS:
12554                                        {
12555                                        setState(1428);
12556                                        match(WS);
12557                                        }
12558                                        break;
12559                                default:
12560                                        throw new NoViableAltException(this);
12561                                }
12562                                }
12563                                setState(1433);
12564                                _errHandler.sync(this);
12565                                _la = _input.LA(1);
12566                        }
12567                        setState(1434);
12568                        _la = _input.LA(1);
12569                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12570                        _errHandler.recoverInline(this);
12571                        } else {
12572                                consume();
12573                        }
12574                        }
12575                }
12576                catch (RecognitionException re) {
12577                        _localctx.exception = re;
12578                        _errHandler.reportError(this, re);
12579                        _errHandler.recover(this, re);
12580                }
12581                finally {
12582                        exitRule();
12583                }
12584                return _localctx;
12585        }
12586
12587        public static class FrameTagContext extends ParserRuleContext {
12588                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12589                public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); }
12590                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12591                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12592                public List<AttributeContext> attribute() {
12593                        return getRuleContexts(AttributeContext.class);
12594                }
12595                public AttributeContext attribute(int i) {
12596                        return getRuleContext(AttributeContext.class,i);
12597                }
12598                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12599                public TerminalNode NEWLINE(int i) {
12600                        return getToken(JavadocParser.NEWLINE, i);
12601                }
12602                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12603                public TerminalNode LEADING_ASTERISK(int i) {
12604                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12605                }
12606                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12607                public TerminalNode WS(int i) {
12608                        return getToken(JavadocParser.WS, i);
12609                }
12610                public FrameTagContext(ParserRuleContext parent, int invokingState) {
12611                        super(parent, invokingState);
12612                }
12613                @Override public int getRuleIndex() { return RULE_frameTag; }
12614                @Override
12615                public void enterRule(ParseTreeListener listener) {
12616                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterFrameTag(this);
12617                }
12618                @Override
12619                public void exitRule(ParseTreeListener listener) {
12620                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitFrameTag(this);
12621                }
12622                @Override
12623                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12624                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitFrameTag(this);
12625                        else return visitor.visitChildren(this);
12626                }
12627        }
12628
12629        public final FrameTagContext frameTag() throws RecognitionException {
12630                FrameTagContext _localctx = new FrameTagContext(_ctx, getState());
12631                enterRule(_localctx, 116, RULE_frameTag);
12632                int _la;
12633                try {
12634                        enterOuterAlt(_localctx, 1);
12635                        {
12636                        setState(1436);
12637                        match(OPEN);
12638                        setState(1437);
12639                        match(FRAME_HTML_TAG_NAME);
12640                        setState(1444);
12641                        _errHandler.sync(this);
12642                        _la = _input.LA(1);
12643                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12644                                {
12645                                setState(1442);
12646                                switch (_input.LA(1)) {
12647                                case HTML_TAG_NAME:
12648                                        {
12649                                        setState(1438);
12650                                        attribute();
12651                                        }
12652                                        break;
12653                                case NEWLINE:
12654                                        {
12655                                        setState(1439);
12656                                        match(NEWLINE);
12657                                        }
12658                                        break;
12659                                case LEADING_ASTERISK:
12660                                        {
12661                                        setState(1440);
12662                                        match(LEADING_ASTERISK);
12663                                        }
12664                                        break;
12665                                case WS:
12666                                        {
12667                                        setState(1441);
12668                                        match(WS);
12669                                        }
12670                                        break;
12671                                default:
12672                                        throw new NoViableAltException(this);
12673                                }
12674                                }
12675                                setState(1446);
12676                                _errHandler.sync(this);
12677                                _la = _input.LA(1);
12678                        }
12679                        setState(1447);
12680                        _la = _input.LA(1);
12681                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12682                        _errHandler.recoverInline(this);
12683                        } else {
12684                                consume();
12685                        }
12686                        }
12687                }
12688                catch (RecognitionException re) {
12689                        _localctx.exception = re;
12690                        _errHandler.reportError(this, re);
12691                        _errHandler.recover(this, re);
12692                }
12693                finally {
12694                        exitRule();
12695                }
12696                return _localctx;
12697        }
12698
12699        public static class HrTagContext extends ParserRuleContext {
12700                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12701                public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); }
12702                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12703                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12704                public List<AttributeContext> attribute() {
12705                        return getRuleContexts(AttributeContext.class);
12706                }
12707                public AttributeContext attribute(int i) {
12708                        return getRuleContext(AttributeContext.class,i);
12709                }
12710                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12711                public TerminalNode NEWLINE(int i) {
12712                        return getToken(JavadocParser.NEWLINE, i);
12713                }
12714                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12715                public TerminalNode LEADING_ASTERISK(int i) {
12716                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12717                }
12718                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12719                public TerminalNode WS(int i) {
12720                        return getToken(JavadocParser.WS, i);
12721                }
12722                public HrTagContext(ParserRuleContext parent, int invokingState) {
12723                        super(parent, invokingState);
12724                }
12725                @Override public int getRuleIndex() { return RULE_hrTag; }
12726                @Override
12727                public void enterRule(ParseTreeListener listener) {
12728                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHrTag(this);
12729                }
12730                @Override
12731                public void exitRule(ParseTreeListener listener) {
12732                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHrTag(this);
12733                }
12734                @Override
12735                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12736                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHrTag(this);
12737                        else return visitor.visitChildren(this);
12738                }
12739        }
12740
12741        public final HrTagContext hrTag() throws RecognitionException {
12742                HrTagContext _localctx = new HrTagContext(_ctx, getState());
12743                enterRule(_localctx, 118, RULE_hrTag);
12744                int _la;
12745                try {
12746                        enterOuterAlt(_localctx, 1);
12747                        {
12748                        setState(1449);
12749                        match(OPEN);
12750                        setState(1450);
12751                        match(HR_HTML_TAG_NAME);
12752                        setState(1457);
12753                        _errHandler.sync(this);
12754                        _la = _input.LA(1);
12755                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12756                                {
12757                                setState(1455);
12758                                switch (_input.LA(1)) {
12759                                case HTML_TAG_NAME:
12760                                        {
12761                                        setState(1451);
12762                                        attribute();
12763                                        }
12764                                        break;
12765                                case NEWLINE:
12766                                        {
12767                                        setState(1452);
12768                                        match(NEWLINE);
12769                                        }
12770                                        break;
12771                                case LEADING_ASTERISK:
12772                                        {
12773                                        setState(1453);
12774                                        match(LEADING_ASTERISK);
12775                                        }
12776                                        break;
12777                                case WS:
12778                                        {
12779                                        setState(1454);
12780                                        match(WS);
12781                                        }
12782                                        break;
12783                                default:
12784                                        throw new NoViableAltException(this);
12785                                }
12786                                }
12787                                setState(1459);
12788                                _errHandler.sync(this);
12789                                _la = _input.LA(1);
12790                        }
12791                        setState(1460);
12792                        _la = _input.LA(1);
12793                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12794                        _errHandler.recoverInline(this);
12795                        } else {
12796                                consume();
12797                        }
12798                        }
12799                }
12800                catch (RecognitionException re) {
12801                        _localctx.exception = re;
12802                        _errHandler.reportError(this, re);
12803                        _errHandler.recover(this, re);
12804                }
12805                finally {
12806                        exitRule();
12807                }
12808                return _localctx;
12809        }
12810
12811        public static class ImgTagContext extends ParserRuleContext {
12812                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12813                public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); }
12814                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12815                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12816                public List<AttributeContext> attribute() {
12817                        return getRuleContexts(AttributeContext.class);
12818                }
12819                public AttributeContext attribute(int i) {
12820                        return getRuleContext(AttributeContext.class,i);
12821                }
12822                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12823                public TerminalNode NEWLINE(int i) {
12824                        return getToken(JavadocParser.NEWLINE, i);
12825                }
12826                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12827                public TerminalNode LEADING_ASTERISK(int i) {
12828                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12829                }
12830                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12831                public TerminalNode WS(int i) {
12832                        return getToken(JavadocParser.WS, i);
12833                }
12834                public ImgTagContext(ParserRuleContext parent, int invokingState) {
12835                        super(parent, invokingState);
12836                }
12837                @Override public int getRuleIndex() { return RULE_imgTag; }
12838                @Override
12839                public void enterRule(ParseTreeListener listener) {
12840                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterImgTag(this);
12841                }
12842                @Override
12843                public void exitRule(ParseTreeListener listener) {
12844                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitImgTag(this);
12845                }
12846                @Override
12847                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12848                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitImgTag(this);
12849                        else return visitor.visitChildren(this);
12850                }
12851        }
12852
12853        public final ImgTagContext imgTag() throws RecognitionException {
12854                ImgTagContext _localctx = new ImgTagContext(_ctx, getState());
12855                enterRule(_localctx, 120, RULE_imgTag);
12856                int _la;
12857                try {
12858                        enterOuterAlt(_localctx, 1);
12859                        {
12860                        setState(1462);
12861                        match(OPEN);
12862                        setState(1463);
12863                        match(IMG_HTML_TAG_NAME);
12864                        setState(1470);
12865                        _errHandler.sync(this);
12866                        _la = _input.LA(1);
12867                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12868                                {
12869                                setState(1468);
12870                                switch (_input.LA(1)) {
12871                                case HTML_TAG_NAME:
12872                                        {
12873                                        setState(1464);
12874                                        attribute();
12875                                        }
12876                                        break;
12877                                case NEWLINE:
12878                                        {
12879                                        setState(1465);
12880                                        match(NEWLINE);
12881                                        }
12882                                        break;
12883                                case LEADING_ASTERISK:
12884                                        {
12885                                        setState(1466);
12886                                        match(LEADING_ASTERISK);
12887                                        }
12888                                        break;
12889                                case WS:
12890                                        {
12891                                        setState(1467);
12892                                        match(WS);
12893                                        }
12894                                        break;
12895                                default:
12896                                        throw new NoViableAltException(this);
12897                                }
12898                                }
12899                                setState(1472);
12900                                _errHandler.sync(this);
12901                                _la = _input.LA(1);
12902                        }
12903                        setState(1473);
12904                        _la = _input.LA(1);
12905                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12906                        _errHandler.recoverInline(this);
12907                        } else {
12908                                consume();
12909                        }
12910                        }
12911                }
12912                catch (RecognitionException re) {
12913                        _localctx.exception = re;
12914                        _errHandler.reportError(this, re);
12915                        _errHandler.recover(this, re);
12916                }
12917                finally {
12918                        exitRule();
12919                }
12920                return _localctx;
12921        }
12922
12923        public static class InputTagContext extends ParserRuleContext {
12924                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12925                public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); }
12926                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12927                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12928                public List<AttributeContext> attribute() {
12929                        return getRuleContexts(AttributeContext.class);
12930                }
12931                public AttributeContext attribute(int i) {
12932                        return getRuleContext(AttributeContext.class,i);
12933                }
12934                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12935                public TerminalNode NEWLINE(int i) {
12936                        return getToken(JavadocParser.NEWLINE, i);
12937                }
12938                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12939                public TerminalNode LEADING_ASTERISK(int i) {
12940                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12941                }
12942                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12943                public TerminalNode WS(int i) {
12944                        return getToken(JavadocParser.WS, i);
12945                }
12946                public InputTagContext(ParserRuleContext parent, int invokingState) {
12947                        super(parent, invokingState);
12948                }
12949                @Override public int getRuleIndex() { return RULE_inputTag; }
12950                @Override
12951                public void enterRule(ParseTreeListener listener) {
12952                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInputTag(this);
12953                }
12954                @Override
12955                public void exitRule(ParseTreeListener listener) {
12956                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInputTag(this);
12957                }
12958                @Override
12959                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12960                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInputTag(this);
12961                        else return visitor.visitChildren(this);
12962                }
12963        }
12964
12965        public final InputTagContext inputTag() throws RecognitionException {
12966                InputTagContext _localctx = new InputTagContext(_ctx, getState());
12967                enterRule(_localctx, 122, RULE_inputTag);
12968                int _la;
12969                try {
12970                        enterOuterAlt(_localctx, 1);
12971                        {
12972                        setState(1475);
12973                        match(OPEN);
12974                        setState(1476);
12975                        match(INPUT_HTML_TAG_NAME);
12976                        setState(1483);
12977                        _errHandler.sync(this);
12978                        _la = _input.LA(1);
12979                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12980                                {
12981                                setState(1481);
12982                                switch (_input.LA(1)) {
12983                                case HTML_TAG_NAME:
12984                                        {
12985                                        setState(1477);
12986                                        attribute();
12987                                        }
12988                                        break;
12989                                case NEWLINE:
12990                                        {
12991                                        setState(1478);
12992                                        match(NEWLINE);
12993                                        }
12994                                        break;
12995                                case LEADING_ASTERISK:
12996                                        {
12997                                        setState(1479);
12998                                        match(LEADING_ASTERISK);
12999                                        }
13000                                        break;
13001                                case WS:
13002                                        {
13003                                        setState(1480);
13004                                        match(WS);
13005                                        }
13006                                        break;
13007                                default:
13008                                        throw new NoViableAltException(this);
13009                                }
13010                                }
13011                                setState(1485);
13012                                _errHandler.sync(this);
13013                                _la = _input.LA(1);
13014                        }
13015                        setState(1486);
13016                        _la = _input.LA(1);
13017                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13018                        _errHandler.recoverInline(this);
13019                        } else {
13020                                consume();
13021                        }
13022                        }
13023                }
13024                catch (RecognitionException re) {
13025                        _localctx.exception = re;
13026                        _errHandler.reportError(this, re);
13027                        _errHandler.recover(this, re);
13028                }
13029                finally {
13030                        exitRule();
13031                }
13032                return _localctx;
13033        }
13034
13035        public static class IsindexTagContext extends ParserRuleContext {
13036                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13037                public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); }
13038                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13039                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13040                public List<AttributeContext> attribute() {
13041                        return getRuleContexts(AttributeContext.class);
13042                }
13043                public AttributeContext attribute(int i) {
13044                        return getRuleContext(AttributeContext.class,i);
13045                }
13046                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13047                public TerminalNode NEWLINE(int i) {
13048                        return getToken(JavadocParser.NEWLINE, i);
13049                }
13050                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13051                public TerminalNode LEADING_ASTERISK(int i) {
13052                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13053                }
13054                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13055                public TerminalNode WS(int i) {
13056                        return getToken(JavadocParser.WS, i);
13057                }
13058                public IsindexTagContext(ParserRuleContext parent, int invokingState) {
13059                        super(parent, invokingState);
13060                }
13061                @Override public int getRuleIndex() { return RULE_isindexTag; }
13062                @Override
13063                public void enterRule(ParseTreeListener listener) {
13064                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterIsindexTag(this);
13065                }
13066                @Override
13067                public void exitRule(ParseTreeListener listener) {
13068                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitIsindexTag(this);
13069                }
13070                @Override
13071                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13072                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitIsindexTag(this);
13073                        else return visitor.visitChildren(this);
13074                }
13075        }
13076
13077        public final IsindexTagContext isindexTag() throws RecognitionException {
13078                IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState());
13079                enterRule(_localctx, 124, RULE_isindexTag);
13080                int _la;
13081                try {
13082                        enterOuterAlt(_localctx, 1);
13083                        {
13084                        setState(1488);
13085                        match(OPEN);
13086                        setState(1489);
13087                        match(ISINDEX_HTML_TAG_NAME);
13088                        setState(1496);
13089                        _errHandler.sync(this);
13090                        _la = _input.LA(1);
13091                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13092                                {
13093                                setState(1494);
13094                                switch (_input.LA(1)) {
13095                                case HTML_TAG_NAME:
13096                                        {
13097                                        setState(1490);
13098                                        attribute();
13099                                        }
13100                                        break;
13101                                case NEWLINE:
13102                                        {
13103                                        setState(1491);
13104                                        match(NEWLINE);
13105                                        }
13106                                        break;
13107                                case LEADING_ASTERISK:
13108                                        {
13109                                        setState(1492);
13110                                        match(LEADING_ASTERISK);
13111                                        }
13112                                        break;
13113                                case WS:
13114                                        {
13115                                        setState(1493);
13116                                        match(WS);
13117                                        }
13118                                        break;
13119                                default:
13120                                        throw new NoViableAltException(this);
13121                                }
13122                                }
13123                                setState(1498);
13124                                _errHandler.sync(this);
13125                                _la = _input.LA(1);
13126                        }
13127                        setState(1499);
13128                        _la = _input.LA(1);
13129                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13130                        _errHandler.recoverInline(this);
13131                        } else {
13132                                consume();
13133                        }
13134                        }
13135                }
13136                catch (RecognitionException re) {
13137                        _localctx.exception = re;
13138                        _errHandler.reportError(this, re);
13139                        _errHandler.recover(this, re);
13140                }
13141                finally {
13142                        exitRule();
13143                }
13144                return _localctx;
13145        }
13146
13147        public static class LinkTagContext extends ParserRuleContext {
13148                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13149                public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); }
13150                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13151                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13152                public List<AttributeContext> attribute() {
13153                        return getRuleContexts(AttributeContext.class);
13154                }
13155                public AttributeContext attribute(int i) {
13156                        return getRuleContext(AttributeContext.class,i);
13157                }
13158                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13159                public TerminalNode NEWLINE(int i) {
13160                        return getToken(JavadocParser.NEWLINE, i);
13161                }
13162                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13163                public TerminalNode LEADING_ASTERISK(int i) {
13164                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13165                }
13166                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13167                public TerminalNode WS(int i) {
13168                        return getToken(JavadocParser.WS, i);
13169                }
13170                public LinkTagContext(ParserRuleContext parent, int invokingState) {
13171                        super(parent, invokingState);
13172                }
13173                @Override public int getRuleIndex() { return RULE_linkTag; }
13174                @Override
13175                public void enterRule(ParseTreeListener listener) {
13176                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLinkTag(this);
13177                }
13178                @Override
13179                public void exitRule(ParseTreeListener listener) {
13180                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLinkTag(this);
13181                }
13182                @Override
13183                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13184                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLinkTag(this);
13185                        else return visitor.visitChildren(this);
13186                }
13187        }
13188
13189        public final LinkTagContext linkTag() throws RecognitionException {
13190                LinkTagContext _localctx = new LinkTagContext(_ctx, getState());
13191                enterRule(_localctx, 126, RULE_linkTag);
13192                int _la;
13193                try {
13194                        enterOuterAlt(_localctx, 1);
13195                        {
13196                        setState(1501);
13197                        match(OPEN);
13198                        setState(1502);
13199                        match(LINK_HTML_TAG_NAME);
13200                        setState(1509);
13201                        _errHandler.sync(this);
13202                        _la = _input.LA(1);
13203                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13204                                {
13205                                setState(1507);
13206                                switch (_input.LA(1)) {
13207                                case HTML_TAG_NAME:
13208                                        {
13209                                        setState(1503);
13210                                        attribute();
13211                                        }
13212                                        break;
13213                                case NEWLINE:
13214                                        {
13215                                        setState(1504);
13216                                        match(NEWLINE);
13217                                        }
13218                                        break;
13219                                case LEADING_ASTERISK:
13220                                        {
13221                                        setState(1505);
13222                                        match(LEADING_ASTERISK);
13223                                        }
13224                                        break;
13225                                case WS:
13226                                        {
13227                                        setState(1506);
13228                                        match(WS);
13229                                        }
13230                                        break;
13231                                default:
13232                                        throw new NoViableAltException(this);
13233                                }
13234                                }
13235                                setState(1511);
13236                                _errHandler.sync(this);
13237                                _la = _input.LA(1);
13238                        }
13239                        setState(1512);
13240                        _la = _input.LA(1);
13241                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13242                        _errHandler.recoverInline(this);
13243                        } else {
13244                                consume();
13245                        }
13246                        }
13247                }
13248                catch (RecognitionException re) {
13249                        _localctx.exception = re;
13250                        _errHandler.reportError(this, re);
13251                        _errHandler.recover(this, re);
13252                }
13253                finally {
13254                        exitRule();
13255                }
13256                return _localctx;
13257        }
13258
13259        public static class MetaTagContext extends ParserRuleContext {
13260                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13261                public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); }
13262                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13263                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13264                public List<AttributeContext> attribute() {
13265                        return getRuleContexts(AttributeContext.class);
13266                }
13267                public AttributeContext attribute(int i) {
13268                        return getRuleContext(AttributeContext.class,i);
13269                }
13270                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13271                public TerminalNode NEWLINE(int i) {
13272                        return getToken(JavadocParser.NEWLINE, i);
13273                }
13274                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13275                public TerminalNode LEADING_ASTERISK(int i) {
13276                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13277                }
13278                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13279                public TerminalNode WS(int i) {
13280                        return getToken(JavadocParser.WS, i);
13281                }
13282                public MetaTagContext(ParserRuleContext parent, int invokingState) {
13283                        super(parent, invokingState);
13284                }
13285                @Override public int getRuleIndex() { return RULE_metaTag; }
13286                @Override
13287                public void enterRule(ParseTreeListener listener) {
13288                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterMetaTag(this);
13289                }
13290                @Override
13291                public void exitRule(ParseTreeListener listener) {
13292                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitMetaTag(this);
13293                }
13294                @Override
13295                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13296                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitMetaTag(this);
13297                        else return visitor.visitChildren(this);
13298                }
13299        }
13300
13301        public final MetaTagContext metaTag() throws RecognitionException {
13302                MetaTagContext _localctx = new MetaTagContext(_ctx, getState());
13303                enterRule(_localctx, 128, RULE_metaTag);
13304                int _la;
13305                try {
13306                        enterOuterAlt(_localctx, 1);
13307                        {
13308                        setState(1514);
13309                        match(OPEN);
13310                        setState(1515);
13311                        match(META_HTML_TAG_NAME);
13312                        setState(1522);
13313                        _errHandler.sync(this);
13314                        _la = _input.LA(1);
13315                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13316                                {
13317                                setState(1520);
13318                                switch (_input.LA(1)) {
13319                                case HTML_TAG_NAME:
13320                                        {
13321                                        setState(1516);
13322                                        attribute();
13323                                        }
13324                                        break;
13325                                case NEWLINE:
13326                                        {
13327                                        setState(1517);
13328                                        match(NEWLINE);
13329                                        }
13330                                        break;
13331                                case LEADING_ASTERISK:
13332                                        {
13333                                        setState(1518);
13334                                        match(LEADING_ASTERISK);
13335                                        }
13336                                        break;
13337                                case WS:
13338                                        {
13339                                        setState(1519);
13340                                        match(WS);
13341                                        }
13342                                        break;
13343                                default:
13344                                        throw new NoViableAltException(this);
13345                                }
13346                                }
13347                                setState(1524);
13348                                _errHandler.sync(this);
13349                                _la = _input.LA(1);
13350                        }
13351                        setState(1525);
13352                        _la = _input.LA(1);
13353                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13354                        _errHandler.recoverInline(this);
13355                        } else {
13356                                consume();
13357                        }
13358                        }
13359                }
13360                catch (RecognitionException re) {
13361                        _localctx.exception = re;
13362                        _errHandler.reportError(this, re);
13363                        _errHandler.recover(this, re);
13364                }
13365                finally {
13366                        exitRule();
13367                }
13368                return _localctx;
13369        }
13370
13371        public static class ParamTagContext extends ParserRuleContext {
13372                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13373                public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); }
13374                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13375                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13376                public List<AttributeContext> attribute() {
13377                        return getRuleContexts(AttributeContext.class);
13378                }
13379                public AttributeContext attribute(int i) {
13380                        return getRuleContext(AttributeContext.class,i);
13381                }
13382                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13383                public TerminalNode NEWLINE(int i) {
13384                        return getToken(JavadocParser.NEWLINE, i);
13385                }
13386                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13387                public TerminalNode LEADING_ASTERISK(int i) {
13388                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13389                }
13390                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13391                public TerminalNode WS(int i) {
13392                        return getToken(JavadocParser.WS, i);
13393                }
13394                public ParamTagContext(ParserRuleContext parent, int invokingState) {
13395                        super(parent, invokingState);
13396                }
13397                @Override public int getRuleIndex() { return RULE_paramTag; }
13398                @Override
13399                public void enterRule(ParseTreeListener listener) {
13400                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParamTag(this);
13401                }
13402                @Override
13403                public void exitRule(ParseTreeListener listener) {
13404                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParamTag(this);
13405                }
13406                @Override
13407                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13408                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParamTag(this);
13409                        else return visitor.visitChildren(this);
13410                }
13411        }
13412
13413        public final ParamTagContext paramTag() throws RecognitionException {
13414                ParamTagContext _localctx = new ParamTagContext(_ctx, getState());
13415                enterRule(_localctx, 130, RULE_paramTag);
13416                int _la;
13417                try {
13418                        enterOuterAlt(_localctx, 1);
13419                        {
13420                        setState(1527);
13421                        match(OPEN);
13422                        setState(1528);
13423                        match(PARAM_HTML_TAG_NAME);
13424                        setState(1535);
13425                        _errHandler.sync(this);
13426                        _la = _input.LA(1);
13427                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13428                                {
13429                                setState(1533);
13430                                switch (_input.LA(1)) {
13431                                case HTML_TAG_NAME:
13432                                        {
13433                                        setState(1529);
13434                                        attribute();
13435                                        }
13436                                        break;
13437                                case NEWLINE:
13438                                        {
13439                                        setState(1530);
13440                                        match(NEWLINE);
13441                                        }
13442                                        break;
13443                                case LEADING_ASTERISK:
13444                                        {
13445                                        setState(1531);
13446                                        match(LEADING_ASTERISK);
13447                                        }
13448                                        break;
13449                                case WS:
13450                                        {
13451                                        setState(1532);
13452                                        match(WS);
13453                                        }
13454                                        break;
13455                                default:
13456                                        throw new NoViableAltException(this);
13457                                }
13458                                }
13459                                setState(1537);
13460                                _errHandler.sync(this);
13461                                _la = _input.LA(1);
13462                        }
13463                        setState(1538);
13464                        _la = _input.LA(1);
13465                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13466                        _errHandler.recoverInline(this);
13467                        } else {
13468                                consume();
13469                        }
13470                        }
13471                }
13472                catch (RecognitionException re) {
13473                        _localctx.exception = re;
13474                        _errHandler.reportError(this, re);
13475                        _errHandler.recover(this, re);
13476                }
13477                finally {
13478                        exitRule();
13479                }
13480                return _localctx;
13481        }
13482
13483        public static class WrongSinletonTagContext extends ParserRuleContext {
13484                public SingletonTagNameContext singletonTagName;
13485                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13486                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
13487                public SingletonTagNameContext singletonTagName() {
13488                        return getRuleContext(SingletonTagNameContext.class,0);
13489                }
13490                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13491                public WrongSinletonTagContext(ParserRuleContext parent, int invokingState) {
13492                        super(parent, invokingState);
13493                }
13494                @Override public int getRuleIndex() { return RULE_wrongSinletonTag; }
13495                @Override
13496                public void enterRule(ParseTreeListener listener) {
13497                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterWrongSinletonTag(this);
13498                }
13499                @Override
13500                public void exitRule(ParseTreeListener listener) {
13501                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitWrongSinletonTag(this);
13502                }
13503                @Override
13504                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13505                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitWrongSinletonTag(this);
13506                        else return visitor.visitChildren(this);
13507                }
13508        }
13509
13510        public final WrongSinletonTagContext wrongSinletonTag() throws RecognitionException {
13511                WrongSinletonTagContext _localctx = new WrongSinletonTagContext(_ctx, getState());
13512                enterRule(_localctx, 132, RULE_wrongSinletonTag);
13513                try {
13514                        enterOuterAlt(_localctx, 1);
13515                        {
13516                        setState(1540);
13517                        match(OPEN);
13518                        setState(1541);
13519                        match(SLASH);
13520                        setState(1542);
13521                        ((WrongSinletonTagContext)_localctx).singletonTagName = singletonTagName();
13522                        setState(1543);
13523                        match(CLOSE);
13524                        notifyErrorListeners((((WrongSinletonTagContext)_localctx).singletonTagName!=null?(((WrongSinletonTagContext)_localctx).singletonTagName.start):null),
13525                                                     "javadoc.wrong.singleton.html.tag", null);
13526                        }
13527                }
13528                catch (RecognitionException re) {
13529                        _localctx.exception = re;
13530                        _errHandler.reportError(this, re);
13531                        _errHandler.recover(this, re);
13532                }
13533                finally {
13534                        exitRule();
13535                }
13536                return _localctx;
13537        }
13538
13539        public static class SingletonTagNameContext extends ParserRuleContext {
13540                public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); }
13541                public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); }
13542                public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); }
13543                public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); }
13544                public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); }
13545                public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); }
13546                public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); }
13547                public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); }
13548                public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); }
13549                public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); }
13550                public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); }
13551                public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); }
13552                public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); }
13553                public SingletonTagNameContext(ParserRuleContext parent, int invokingState) {
13554                        super(parent, invokingState);
13555                }
13556                @Override public int getRuleIndex() { return RULE_singletonTagName; }
13557                @Override
13558                public void enterRule(ParseTreeListener listener) {
13559                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTagName(this);
13560                }
13561                @Override
13562                public void exitRule(ParseTreeListener listener) {
13563                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTagName(this);
13564                }
13565                @Override
13566                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13567                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTagName(this);
13568                        else return visitor.visitChildren(this);
13569                }
13570        }
13571
13572        public final SingletonTagNameContext singletonTagName() throws RecognitionException {
13573                SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState());
13574                enterRule(_localctx, 134, RULE_singletonTagName);
13575                int _la;
13576                try {
13577                        enterOuterAlt(_localctx, 1);
13578                        {
13579                        setState(1546);
13580                        _la = _input.LA(1);
13581                        if ( !(((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (AREA_HTML_TAG_NAME - 74)) | (1L << (BASE_HTML_TAG_NAME - 74)) | (1L << (BASEFONT_HTML_TAG_NAME - 74)) | (1L << (BR_HTML_TAG_NAME - 74)) | (1L << (COL_HTML_TAG_NAME - 74)) | (1L << (FRAME_HTML_TAG_NAME - 74)) | (1L << (HR_HTML_TAG_NAME - 74)) | (1L << (IMG_HTML_TAG_NAME - 74)) | (1L << (INPUT_HTML_TAG_NAME - 74)) | (1L << (ISINDEX_HTML_TAG_NAME - 74)) | (1L << (LINK_HTML_TAG_NAME - 74)) | (1L << (META_HTML_TAG_NAME - 74)) | (1L << (PARAM_HTML_TAG_NAME - 74)))) != 0)) ) {
13582                        _errHandler.recoverInline(this);
13583                        } else {
13584                                consume();
13585                        }
13586                        }
13587                }
13588                catch (RecognitionException re) {
13589                        _localctx.exception = re;
13590                        _errHandler.reportError(this, re);
13591                        _errHandler.recover(this, re);
13592                }
13593                finally {
13594                        exitRule();
13595                }
13596                return _localctx;
13597        }
13598
13599        public static class DescriptionContext extends ParserRuleContext {
13600                public List<HtmlCommentContext> htmlComment() {
13601                        return getRuleContexts(HtmlCommentContext.class);
13602                }
13603                public HtmlCommentContext htmlComment(int i) {
13604                        return getRuleContext(HtmlCommentContext.class,i);
13605                }
13606                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
13607                public TerminalNode CDATA(int i) {
13608                        return getToken(JavadocParser.CDATA, i);
13609                }
13610                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13611                public TerminalNode NEWLINE(int i) {
13612                        return getToken(JavadocParser.NEWLINE, i);
13613                }
13614                public List<TextContext> text() {
13615                        return getRuleContexts(TextContext.class);
13616                }
13617                public TextContext text(int i) {
13618                        return getRuleContext(TextContext.class,i);
13619                }
13620                public List<JavadocInlineTagContext> javadocInlineTag() {
13621                        return getRuleContexts(JavadocInlineTagContext.class);
13622                }
13623                public JavadocInlineTagContext javadocInlineTag(int i) {
13624                        return getRuleContext(JavadocInlineTagContext.class,i);
13625                }
13626                public List<HtmlElementContext> htmlElement() {
13627                        return getRuleContexts(HtmlElementContext.class);
13628                }
13629                public HtmlElementContext htmlElement(int i) {
13630                        return getRuleContext(HtmlElementContext.class,i);
13631                }
13632                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13633                public TerminalNode LEADING_ASTERISK(int i) {
13634                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13635                }
13636                public DescriptionContext(ParserRuleContext parent, int invokingState) {
13637                        super(parent, invokingState);
13638                }
13639                @Override public int getRuleIndex() { return RULE_description; }
13640                @Override
13641                public void enterRule(ParseTreeListener listener) {
13642                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescription(this);
13643                }
13644                @Override
13645                public void exitRule(ParseTreeListener listener) {
13646                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescription(this);
13647                }
13648                @Override
13649                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13650                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescription(this);
13651                        else return visitor.visitChildren(this);
13652                }
13653        }
13654
13655        public final DescriptionContext description() throws RecognitionException {
13656                DescriptionContext _localctx = new DescriptionContext(_ctx, getState());
13657                enterRule(_localctx, 136, RULE_description);
13658                try {
13659                        int _alt;
13660                        enterOuterAlt(_localctx, 1);
13661                        {
13662                        setState(1556); 
13663                        _errHandler.sync(this);
13664                        _alt = 1;
13665                        do {
13666                                switch (_alt) {
13667                                case 1:
13668                                        {
13669                                        setState(1556);
13670                                        _errHandler.sync(this);
13671                                        switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
13672                                        case 1:
13673                                                {
13674                                                {
13675                                                setState(1548);
13676                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
13677                                                setState(1549);
13678                                                match(LEADING_ASTERISK);
13679                                                }
13680                                                }
13681                                                break;
13682                                        case 2:
13683                                                {
13684                                                setState(1550);
13685                                                htmlComment();
13686                                                }
13687                                                break;
13688                                        case 3:
13689                                                {
13690                                                setState(1551);
13691                                                match(CDATA);
13692                                                }
13693                                                break;
13694                                        case 4:
13695                                                {
13696                                                setState(1552);
13697                                                match(NEWLINE);
13698                                                }
13699                                                break;
13700                                        case 5:
13701                                                {
13702                                                setState(1553);
13703                                                text();
13704                                                }
13705                                                break;
13706                                        case 6:
13707                                                {
13708                                                setState(1554);
13709                                                javadocInlineTag();
13710                                                }
13711                                                break;
13712                                        case 7:
13713                                                {
13714                                                setState(1555);
13715                                                htmlElement();
13716                                                }
13717                                                break;
13718                                        }
13719                                        }
13720                                        break;
13721                                default:
13722                                        throw new NoViableAltException(this);
13723                                }
13724                                setState(1558); 
13725                                _errHandler.sync(this);
13726                                _alt = getInterpreter().adaptivePredict(_input,122,_ctx);
13727                        } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
13728                        }
13729                }
13730                catch (RecognitionException re) {
13731                        _localctx.exception = re;
13732                        _errHandler.reportError(this, re);
13733                        _errHandler.recover(this, re);
13734                }
13735                finally {
13736                        exitRule();
13737                }
13738                return _localctx;
13739        }
13740
13741        public static class ReferenceContext extends ParserRuleContext {
13742                public TerminalNode PACKAGE() { return getToken(JavadocParser.PACKAGE, 0); }
13743                public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); }
13744                public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); }
13745                public ParametersContext parameters() {
13746                        return getRuleContext(ParametersContext.class,0);
13747                }
13748                public List<TerminalNode> DOT() { return getTokens(JavadocParser.DOT); }
13749                public TerminalNode DOT(int i) {
13750                        return getToken(JavadocParser.DOT, i);
13751                }
13752                public List<TerminalNode> CLASS() { return getTokens(JavadocParser.CLASS); }
13753                public TerminalNode CLASS(int i) {
13754                        return getToken(JavadocParser.CLASS, i);
13755                }
13756                public ReferenceContext(ParserRuleContext parent, int invokingState) {
13757                        super(parent, invokingState);
13758                }
13759                @Override public int getRuleIndex() { return RULE_reference; }
13760                @Override
13761                public void enterRule(ParseTreeListener listener) {
13762                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterReference(this);
13763                }
13764                @Override
13765                public void exitRule(ParseTreeListener listener) {
13766                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitReference(this);
13767                }
13768                @Override
13769                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13770                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitReference(this);
13771                        else return visitor.visitChildren(this);
13772                }
13773        }
13774
13775        public final ReferenceContext reference() throws RecognitionException {
13776                ReferenceContext _localctx = new ReferenceContext(_ctx, getState());
13777                enterRule(_localctx, 138, RULE_reference);
13778                int _la;
13779                try {
13780                        int _alt;
13781                        enterOuterAlt(_localctx, 1);
13782                        {
13783                        setState(1597);
13784                        switch (_input.LA(1)) {
13785                        case PACKAGE:
13786                                {
13787                                setState(1560);
13788                                match(PACKAGE);
13789                                setState(1564);
13790                                _errHandler.sync(this);
13791                                _alt = getInterpreter().adaptivePredict(_input,123,_ctx);
13792                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13793                                        if ( _alt==1 ) {
13794                                                {
13795                                                {
13796                                                setState(1561);
13797                                                _la = _input.LA(1);
13798                                                if ( !(_la==DOT || _la==CLASS) ) {
13799                                                _errHandler.recoverInline(this);
13800                                                } else {
13801                                                        consume();
13802                                                }
13803                                                }
13804                                                } 
13805                                        }
13806                                        setState(1566);
13807                                        _errHandler.sync(this);
13808                                        _alt = getInterpreter().adaptivePredict(_input,123,_ctx);
13809                                }
13810                                setState(1568);
13811                                _errHandler.sync(this);
13812                                switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
13813                                case 1:
13814                                        {
13815                                        setState(1567);
13816                                        match(HASH);
13817                                        }
13818                                        break;
13819                                }
13820                                setState(1571);
13821                                _errHandler.sync(this);
13822                                switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
13823                                case 1:
13824                                        {
13825                                        setState(1570);
13826                                        match(MEMBER);
13827                                        }
13828                                        break;
13829                                }
13830                                setState(1574);
13831                                _errHandler.sync(this);
13832                                switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
13833                                case 1:
13834                                        {
13835                                        setState(1573);
13836                                        parameters();
13837                                        }
13838                                        break;
13839                                }
13840                                }
13841                                break;
13842                        case DOT:
13843                        case CLASS:
13844                                {
13845                                setState(1577); 
13846                                _errHandler.sync(this);
13847                                _alt = 1;
13848                                do {
13849                                        switch (_alt) {
13850                                        case 1:
13851                                                {
13852                                                {
13853                                                setState(1576);
13854                                                _la = _input.LA(1);
13855                                                if ( !(_la==DOT || _la==CLASS) ) {
13856                                                _errHandler.recoverInline(this);
13857                                                } else {
13858                                                        consume();
13859                                                }
13860                                                }
13861                                                }
13862                                                break;
13863                                        default:
13864                                                throw new NoViableAltException(this);
13865                                        }
13866                                        setState(1579); 
13867                                        _errHandler.sync(this);
13868                                        _alt = getInterpreter().adaptivePredict(_input,127,_ctx);
13869                                } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
13870                                setState(1582);
13871                                _errHandler.sync(this);
13872                                switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) {
13873                                case 1:
13874                                        {
13875                                        setState(1581);
13876                                        match(HASH);
13877                                        }
13878                                        break;
13879                                }
13880                                setState(1585);
13881                                _errHandler.sync(this);
13882                                switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
13883                                case 1:
13884                                        {
13885                                        setState(1584);
13886                                        match(MEMBER);
13887                                        }
13888                                        break;
13889                                }
13890                                setState(1588);
13891                                _errHandler.sync(this);
13892                                switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
13893                                case 1:
13894                                        {
13895                                        setState(1587);
13896                                        parameters();
13897                                        }
13898                                        break;
13899                                }
13900                                }
13901                                break;
13902                        case HASH:
13903                        case MEMBER:
13904                                {
13905                                setState(1591);
13906                                _la = _input.LA(1);
13907                                if (_la==HASH) {
13908                                        {
13909                                        setState(1590);
13910                                        match(HASH);
13911                                        }
13912                                }
13913
13914                                setState(1593);
13915                                match(MEMBER);
13916                                setState(1595);
13917                                _errHandler.sync(this);
13918                                switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
13919                                case 1:
13920                                        {
13921                                        setState(1594);
13922                                        parameters();
13923                                        }
13924                                        break;
13925                                }
13926                                }
13927                                break;
13928                        default:
13929                                throw new NoViableAltException(this);
13930                        }
13931                        }
13932                }
13933                catch (RecognitionException re) {
13934                        _localctx.exception = re;
13935                        _errHandler.reportError(this, re);
13936                        _errHandler.recover(this, re);
13937                }
13938                finally {
13939                        exitRule();
13940                }
13941                return _localctx;
13942        }
13943
13944        public static class ParametersContext extends ParserRuleContext {
13945                public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); }
13946                public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); }
13947                public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); }
13948                public TerminalNode ARGUMENT(int i) {
13949                        return getToken(JavadocParser.ARGUMENT, i);
13950                }
13951                public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); }
13952                public TerminalNode COMMA(int i) {
13953                        return getToken(JavadocParser.COMMA, i);
13954                }
13955                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13956                public TerminalNode WS(int i) {
13957                        return getToken(JavadocParser.WS, i);
13958                }
13959                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13960                public TerminalNode NEWLINE(int i) {
13961                        return getToken(JavadocParser.NEWLINE, i);
13962                }
13963                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13964                public TerminalNode LEADING_ASTERISK(int i) {
13965                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13966                }
13967                public ParametersContext(ParserRuleContext parent, int invokingState) {
13968                        super(parent, invokingState);
13969                }
13970                @Override public int getRuleIndex() { return RULE_parameters; }
13971                @Override
13972                public void enterRule(ParseTreeListener listener) {
13973                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParameters(this);
13974                }
13975                @Override
13976                public void exitRule(ParseTreeListener listener) {
13977                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParameters(this);
13978                }
13979                @Override
13980                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13981                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParameters(this);
13982                        else return visitor.visitChildren(this);
13983                }
13984        }
13985
13986        public final ParametersContext parameters() throws RecognitionException {
13987                ParametersContext _localctx = new ParametersContext(_ctx, getState());
13988                enterRule(_localctx, 140, RULE_parameters);
13989                int _la;
13990                try {
13991                        enterOuterAlt(_localctx, 1);
13992                        {
13993                        setState(1599);
13994                        match(LEFT_BRACE);
13995                        setState(1603);
13996                        _errHandler.sync(this);
13997                        _la = _input.LA(1);
13998                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) {
13999                                {
14000                                {
14001                                setState(1600);
14002                                _la = _input.LA(1);
14003                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) {
14004                                _errHandler.recoverInline(this);
14005                                } else {
14006                                        consume();
14007                                }
14008                                }
14009                                }
14010                                setState(1605);
14011                                _errHandler.sync(this);
14012                                _la = _input.LA(1);
14013                        }
14014                        setState(1606);
14015                        match(RIGHT_BRACE);
14016                        }
14017                }
14018                catch (RecognitionException re) {
14019                        _localctx.exception = re;
14020                        _errHandler.reportError(this, re);
14021                        _errHandler.recover(this, re);
14022                }
14023                finally {
14024                        exitRule();
14025                }
14026                return _localctx;
14027        }
14028
14029        public static class JavadocTagContext extends ParserRuleContext {
14030                public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); }
14031                public DescriptionContext description() {
14032                        return getRuleContext(DescriptionContext.class,0);
14033                }
14034                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
14035                public TerminalNode WS(int i) {
14036                        return getToken(JavadocParser.WS, i);
14037                }
14038                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
14039                public TerminalNode NEWLINE(int i) {
14040                        return getToken(JavadocParser.NEWLINE, i);
14041                }
14042                public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); }
14043                public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); }
14044                public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); }
14045                public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); }
14046                public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); }
14047                public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); }
14048                public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); }
14049                public ReferenceContext reference() {
14050                        return getRuleContext(ReferenceContext.class,0);
14051                }
14052                public List<TerminalNode> STRING() { return getTokens(JavadocParser.STRING); }
14053                public TerminalNode STRING(int i) {
14054                        return getToken(JavadocParser.STRING, i);
14055                }
14056                public List<HtmlElementContext> htmlElement() {
14057                        return getRuleContexts(HtmlElementContext.class);
14058                }
14059                public HtmlElementContext htmlElement(int i) {
14060                        return getRuleContext(HtmlElementContext.class,i);
14061                }
14062                public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); }
14063                public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); }
14064                public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); }
14065                public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); }
14066                public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); }
14067                public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); }
14068                public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); }
14069                public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); }
14070                public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); }
14071                public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); }
14072                public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); }
14073                public JavadocTagContext(ParserRuleContext parent, int invokingState) {
14074                        super(parent, invokingState);
14075                }
14076                @Override public int getRuleIndex() { return RULE_javadocTag; }
14077                @Override
14078                public void enterRule(ParseTreeListener listener) {
14079                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocTag(this);
14080                }
14081                @Override
14082                public void exitRule(ParseTreeListener listener) {
14083                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocTag(this);
14084                }
14085                @Override
14086                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
14087                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocTag(this);
14088                        else return visitor.visitChildren(this);
14089                }
14090        }
14091
14092        public final JavadocTagContext javadocTag() throws RecognitionException {
14093                JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState());
14094                enterRule(_localctx, 142, RULE_javadocTag);
14095                int _la;
14096                try {
14097                        int _alt;
14098                        setState(1802);
14099                        switch (_input.LA(1)) {
14100                        case AUTHOR_LITERAL:
14101                                enterOuterAlt(_localctx, 1);
14102                                {
14103                                setState(1608);
14104                                match(AUTHOR_LITERAL);
14105                                setState(1612);
14106                                _errHandler.sync(this);
14107                                _alt = getInterpreter().adaptivePredict(_input,135,_ctx);
14108                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14109                                        if ( _alt==1 ) {
14110                                                {
14111                                                {
14112                                                setState(1609);
14113                                                _la = _input.LA(1);
14114                                                if ( !(_la==WS || _la==NEWLINE) ) {
14115                                                _errHandler.recoverInline(this);
14116                                                } else {
14117                                                        consume();
14118                                                }
14119                                                }
14120                                                } 
14121                                        }
14122                                        setState(1614);
14123                                        _errHandler.sync(this);
14124                                        _alt = getInterpreter().adaptivePredict(_input,135,_ctx);
14125                                }
14126                                setState(1616);
14127                                _errHandler.sync(this);
14128                                switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
14129                                case 1:
14130                                        {
14131                                        setState(1615);
14132                                        description();
14133                                        }
14134                                        break;
14135                                }
14136                                }
14137                                break;
14138                        case DEPRECATED_LITERAL:
14139                                enterOuterAlt(_localctx, 2);
14140                                {
14141                                setState(1618);
14142                                match(DEPRECATED_LITERAL);
14143                                setState(1622);
14144                                _errHandler.sync(this);
14145                                _alt = getInterpreter().adaptivePredict(_input,137,_ctx);
14146                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14147                                        if ( _alt==1 ) {
14148                                                {
14149                                                {
14150                                                setState(1619);
14151                                                _la = _input.LA(1);
14152                                                if ( !(_la==WS || _la==NEWLINE) ) {
14153                                                _errHandler.recoverInline(this);
14154                                                } else {
14155                                                        consume();
14156                                                }
14157                                                }
14158                                                } 
14159                                        }
14160                                        setState(1624);
14161                                        _errHandler.sync(this);
14162                                        _alt = getInterpreter().adaptivePredict(_input,137,_ctx);
14163                                }
14164                                setState(1626);
14165                                _errHandler.sync(this);
14166                                switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) {
14167                                case 1:
14168                                        {
14169                                        setState(1625);
14170                                        description();
14171                                        }
14172                                        break;
14173                                }
14174                                }
14175                                break;
14176                        case EXCEPTION_LITERAL:
14177                                enterOuterAlt(_localctx, 3);
14178                                {
14179                                setState(1628);
14180                                match(EXCEPTION_LITERAL);
14181                                setState(1632);
14182                                _errHandler.sync(this);
14183                                _alt = getInterpreter().adaptivePredict(_input,139,_ctx);
14184                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14185                                        if ( _alt==1 ) {
14186                                                {
14187                                                {
14188                                                setState(1629);
14189                                                _la = _input.LA(1);
14190                                                if ( !(_la==WS || _la==NEWLINE) ) {
14191                                                _errHandler.recoverInline(this);
14192                                                } else {
14193                                                        consume();
14194                                                }
14195                                                }
14196                                                } 
14197                                        }
14198                                        setState(1634);
14199                                        _errHandler.sync(this);
14200                                        _alt = getInterpreter().adaptivePredict(_input,139,_ctx);
14201                                }
14202                                setState(1636);
14203                                _errHandler.sync(this);
14204                                switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
14205                                case 1:
14206                                        {
14207                                        setState(1635);
14208                                        match(CLASS_NAME);
14209                                        }
14210                                        break;
14211                                }
14212                                setState(1641);
14213                                _errHandler.sync(this);
14214                                _alt = getInterpreter().adaptivePredict(_input,141,_ctx);
14215                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14216                                        if ( _alt==1 ) {
14217                                                {
14218                                                {
14219                                                setState(1638);
14220                                                _la = _input.LA(1);
14221                                                if ( !(_la==WS || _la==NEWLINE) ) {
14222                                                _errHandler.recoverInline(this);
14223                                                } else {
14224                                                        consume();
14225                                                }
14226                                                }
14227                                                } 
14228                                        }
14229                                        setState(1643);
14230                                        _errHandler.sync(this);
14231                                        _alt = getInterpreter().adaptivePredict(_input,141,_ctx);
14232                                }
14233                                setState(1645);
14234                                _errHandler.sync(this);
14235                                switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
14236                                case 1:
14237                                        {
14238                                        setState(1644);
14239                                        description();
14240                                        }
14241                                        break;
14242                                }
14243                                }
14244                                break;
14245                        case PARAM_LITERAL:
14246                                enterOuterAlt(_localctx, 4);
14247                                {
14248                                setState(1647);
14249                                match(PARAM_LITERAL);
14250                                setState(1651);
14251                                _errHandler.sync(this);
14252                                _alt = getInterpreter().adaptivePredict(_input,143,_ctx);
14253                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14254                                        if ( _alt==1 ) {
14255                                                {
14256                                                {
14257                                                setState(1648);
14258                                                _la = _input.LA(1);
14259                                                if ( !(_la==WS || _la==NEWLINE) ) {
14260                                                _errHandler.recoverInline(this);
14261                                                } else {
14262                                                        consume();
14263                                                }
14264                                                }
14265                                                } 
14266                                        }
14267                                        setState(1653);
14268                                        _errHandler.sync(this);
14269                                        _alt = getInterpreter().adaptivePredict(_input,143,_ctx);
14270                                }
14271                                setState(1655);
14272                                _errHandler.sync(this);
14273                                switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) {
14274                                case 1:
14275                                        {
14276                                        setState(1654);
14277                                        match(PARAMETER_NAME);
14278                                        }
14279                                        break;
14280                                }
14281                                setState(1660);
14282                                _errHandler.sync(this);
14283                                _alt = getInterpreter().adaptivePredict(_input,145,_ctx);
14284                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14285                                        if ( _alt==1 ) {
14286                                                {
14287                                                {
14288                                                setState(1657);
14289                                                _la = _input.LA(1);
14290                                                if ( !(_la==WS || _la==NEWLINE) ) {
14291                                                _errHandler.recoverInline(this);
14292                                                } else {
14293                                                        consume();
14294                                                }
14295                                                }
14296                                                } 
14297                                        }
14298                                        setState(1662);
14299                                        _errHandler.sync(this);
14300                                        _alt = getInterpreter().adaptivePredict(_input,145,_ctx);
14301                                }
14302                                setState(1664);
14303                                _errHandler.sync(this);
14304                                switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
14305                                case 1:
14306                                        {
14307                                        setState(1663);
14308                                        description();
14309                                        }
14310                                        break;
14311                                }
14312                                }
14313                                break;
14314                        case RETURN_LITERAL:
14315                                enterOuterAlt(_localctx, 5);
14316                                {
14317                                setState(1666);
14318                                match(RETURN_LITERAL);
14319                                setState(1670);
14320                                _errHandler.sync(this);
14321                                _alt = getInterpreter().adaptivePredict(_input,147,_ctx);
14322                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14323                                        if ( _alt==1 ) {
14324                                                {
14325                                                {
14326                                                setState(1667);
14327                                                _la = _input.LA(1);
14328                                                if ( !(_la==WS || _la==NEWLINE) ) {
14329                                                _errHandler.recoverInline(this);
14330                                                } else {
14331                                                        consume();
14332                                                }
14333                                                }
14334                                                } 
14335                                        }
14336                                        setState(1672);
14337                                        _errHandler.sync(this);
14338                                        _alt = getInterpreter().adaptivePredict(_input,147,_ctx);
14339                                }
14340                                setState(1674);
14341                                _errHandler.sync(this);
14342                                switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) {
14343                                case 1:
14344                                        {
14345                                        setState(1673);
14346                                        description();
14347                                        }
14348                                        break;
14349                                }
14350                                }
14351                                break;
14352                        case SEE_LITERAL:
14353                                enterOuterAlt(_localctx, 6);
14354                                {
14355                                setState(1676);
14356                                match(SEE_LITERAL);
14357                                setState(1680);
14358                                _errHandler.sync(this);
14359                                _alt = getInterpreter().adaptivePredict(_input,149,_ctx);
14360                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14361                                        if ( _alt==1 ) {
14362                                                {
14363                                                {
14364                                                setState(1677);
14365                                                _la = _input.LA(1);
14366                                                if ( !(_la==WS || _la==NEWLINE) ) {
14367                                                _errHandler.recoverInline(this);
14368                                                } else {
14369                                                        consume();
14370                                                }
14371                                                }
14372                                                } 
14373                                        }
14374                                        setState(1682);
14375                                        _errHandler.sync(this);
14376                                        _alt = getInterpreter().adaptivePredict(_input,149,_ctx);
14377                                }
14378                                setState(1684);
14379                                _errHandler.sync(this);
14380                                switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
14381                                case 1:
14382                                        {
14383                                        setState(1683);
14384                                        reference();
14385                                        }
14386                                        break;
14387                                }
14388                                setState(1690);
14389                                _errHandler.sync(this);
14390                                _alt = getInterpreter().adaptivePredict(_input,152,_ctx);
14391                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14392                                        if ( _alt==1 ) {
14393                                                {
14394                                                setState(1688);
14395                                                switch (_input.LA(1)) {
14396                                                case STRING:
14397                                                        {
14398                                                        setState(1686);
14399                                                        match(STRING);
14400                                                        }
14401                                                        break;
14402                                                case OPEN:
14403                                                        {
14404                                                        setState(1687);
14405                                                        htmlElement();
14406                                                        }
14407                                                        break;
14408                                                default:
14409                                                        throw new NoViableAltException(this);
14410                                                }
14411                                                } 
14412                                        }
14413                                        setState(1692);
14414                                        _errHandler.sync(this);
14415                                        _alt = getInterpreter().adaptivePredict(_input,152,_ctx);
14416                                }
14417                                setState(1696);
14418                                _errHandler.sync(this);
14419                                _alt = getInterpreter().adaptivePredict(_input,153,_ctx);
14420                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14421                                        if ( _alt==1 ) {
14422                                                {
14423                                                {
14424                                                setState(1693);
14425                                                _la = _input.LA(1);
14426                                                if ( !(_la==WS || _la==NEWLINE) ) {
14427                                                _errHandler.recoverInline(this);
14428                                                } else {
14429                                                        consume();
14430                                                }
14431                                                }
14432                                                } 
14433                                        }
14434                                        setState(1698);
14435                                        _errHandler.sync(this);
14436                                        _alt = getInterpreter().adaptivePredict(_input,153,_ctx);
14437                                }
14438                                setState(1700);
14439                                _errHandler.sync(this);
14440                                switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
14441                                case 1:
14442                                        {
14443                                        setState(1699);
14444                                        description();
14445                                        }
14446                                        break;
14447                                }
14448                                }
14449                                break;
14450                        case SERIAL_LITERAL:
14451                                enterOuterAlt(_localctx, 7);
14452                                {
14453                                setState(1702);
14454                                match(SERIAL_LITERAL);
14455                                setState(1706);
14456                                _errHandler.sync(this);
14457                                _alt = getInterpreter().adaptivePredict(_input,155,_ctx);
14458                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14459                                        if ( _alt==1 ) {
14460                                                {
14461                                                {
14462                                                setState(1703);
14463                                                _la = _input.LA(1);
14464                                                if ( !(_la==WS || _la==NEWLINE) ) {
14465                                                _errHandler.recoverInline(this);
14466                                                } else {
14467                                                        consume();
14468                                                }
14469                                                }
14470                                                } 
14471                                        }
14472                                        setState(1708);
14473                                        _errHandler.sync(this);
14474                                        _alt = getInterpreter().adaptivePredict(_input,155,_ctx);
14475                                }
14476                                setState(1710);
14477                                _errHandler.sync(this);
14478                                switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) {
14479                                case 1:
14480                                        {
14481                                        setState(1709);
14482                                        _la = _input.LA(1);
14483                                        if ( !(_la==LITERAL_INCLUDE || _la==LITERAL_EXCLUDE) ) {
14484                                        _errHandler.recoverInline(this);
14485                                        } else {
14486                                                consume();
14487                                        }
14488                                        }
14489                                        break;
14490                                }
14491                                setState(1713);
14492                                _errHandler.sync(this);
14493                                switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) {
14494                                case 1:
14495                                        {
14496                                        setState(1712);
14497                                        description();
14498                                        }
14499                                        break;
14500                                }
14501                                }
14502                                break;
14503                        case SERIAL_DATA_LITERAL:
14504                                enterOuterAlt(_localctx, 8);
14505                                {
14506                                setState(1715);
14507                                match(SERIAL_DATA_LITERAL);
14508                                setState(1719);
14509                                _errHandler.sync(this);
14510                                _alt = getInterpreter().adaptivePredict(_input,158,_ctx);
14511                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14512                                        if ( _alt==1 ) {
14513                                                {
14514                                                {
14515                                                setState(1716);
14516                                                _la = _input.LA(1);
14517                                                if ( !(_la==WS || _la==NEWLINE) ) {
14518                                                _errHandler.recoverInline(this);
14519                                                } else {
14520                                                        consume();
14521                                                }
14522                                                }
14523                                                } 
14524                                        }
14525                                        setState(1721);
14526                                        _errHandler.sync(this);
14527                                        _alt = getInterpreter().adaptivePredict(_input,158,_ctx);
14528                                }
14529                                setState(1723);
14530                                _errHandler.sync(this);
14531                                switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
14532                                case 1:
14533                                        {
14534                                        setState(1722);
14535                                        description();
14536                                        }
14537                                        break;
14538                                }
14539                                }
14540                                break;
14541                        case SERIAL_FIELD_LITERAL:
14542                                enterOuterAlt(_localctx, 9);
14543                                {
14544                                setState(1725);
14545                                match(SERIAL_FIELD_LITERAL);
14546                                setState(1729);
14547                                _errHandler.sync(this);
14548                                _alt = getInterpreter().adaptivePredict(_input,160,_ctx);
14549                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14550                                        if ( _alt==1 ) {
14551                                                {
14552                                                {
14553                                                setState(1726);
14554                                                _la = _input.LA(1);
14555                                                if ( !(_la==WS || _la==NEWLINE) ) {
14556                                                _errHandler.recoverInline(this);
14557                                                } else {
14558                                                        consume();
14559                                                }
14560                                                }
14561                                                } 
14562                                        }
14563                                        setState(1731);
14564                                        _errHandler.sync(this);
14565                                        _alt = getInterpreter().adaptivePredict(_input,160,_ctx);
14566                                }
14567                                setState(1733);
14568                                _errHandler.sync(this);
14569                                switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) {
14570                                case 1:
14571                                        {
14572                                        setState(1732);
14573                                        match(FIELD_NAME);
14574                                        }
14575                                        break;
14576                                }
14577                                setState(1738);
14578                                _errHandler.sync(this);
14579                                _alt = getInterpreter().adaptivePredict(_input,162,_ctx);
14580                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14581                                        if ( _alt==1 ) {
14582                                                {
14583                                                {
14584                                                setState(1735);
14585                                                _la = _input.LA(1);
14586                                                if ( !(_la==WS || _la==NEWLINE) ) {
14587                                                _errHandler.recoverInline(this);
14588                                                } else {
14589                                                        consume();
14590                                                }
14591                                                }
14592                                                } 
14593                                        }
14594                                        setState(1740);
14595                                        _errHandler.sync(this);
14596                                        _alt = getInterpreter().adaptivePredict(_input,162,_ctx);
14597                                }
14598                                setState(1742);
14599                                _errHandler.sync(this);
14600                                switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) {
14601                                case 1:
14602                                        {
14603                                        setState(1741);
14604                                        match(FIELD_TYPE);
14605                                        }
14606                                        break;
14607                                }
14608                                setState(1747);
14609                                _errHandler.sync(this);
14610                                _alt = getInterpreter().adaptivePredict(_input,164,_ctx);
14611                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14612                                        if ( _alt==1 ) {
14613                                                {
14614                                                {
14615                                                setState(1744);
14616                                                _la = _input.LA(1);
14617                                                if ( !(_la==WS || _la==NEWLINE) ) {
14618                                                _errHandler.recoverInline(this);
14619                                                } else {
14620                                                        consume();
14621                                                }
14622                                                }
14623                                                } 
14624                                        }
14625                                        setState(1749);
14626                                        _errHandler.sync(this);
14627                                        _alt = getInterpreter().adaptivePredict(_input,164,_ctx);
14628                                }
14629                                setState(1751);
14630                                _errHandler.sync(this);
14631                                switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) {
14632                                case 1:
14633                                        {
14634                                        setState(1750);
14635                                        description();
14636                                        }
14637                                        break;
14638                                }
14639                                }
14640                                break;
14641                        case SINCE_LITERAL:
14642                                enterOuterAlt(_localctx, 10);
14643                                {
14644                                setState(1753);
14645                                match(SINCE_LITERAL);
14646                                setState(1757);
14647                                _errHandler.sync(this);
14648                                _alt = getInterpreter().adaptivePredict(_input,166,_ctx);
14649                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14650                                        if ( _alt==1 ) {
14651                                                {
14652                                                {
14653                                                setState(1754);
14654                                                _la = _input.LA(1);
14655                                                if ( !(_la==WS || _la==NEWLINE) ) {
14656                                                _errHandler.recoverInline(this);
14657                                                } else {
14658                                                        consume();
14659                                                }
14660                                                }
14661                                                } 
14662                                        }
14663                                        setState(1759);
14664                                        _errHandler.sync(this);
14665                                        _alt = getInterpreter().adaptivePredict(_input,166,_ctx);
14666                                }
14667                                setState(1761);
14668                                _errHandler.sync(this);
14669                                switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) {
14670                                case 1:
14671                                        {
14672                                        setState(1760);
14673                                        description();
14674                                        }
14675                                        break;
14676                                }
14677                                }
14678                                break;
14679                        case THROWS_LITERAL:
14680                                enterOuterAlt(_localctx, 11);
14681                                {
14682                                setState(1763);
14683                                match(THROWS_LITERAL);
14684                                setState(1767);
14685                                _errHandler.sync(this);
14686                                _alt = getInterpreter().adaptivePredict(_input,168,_ctx);
14687                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14688                                        if ( _alt==1 ) {
14689                                                {
14690                                                {
14691                                                setState(1764);
14692                                                _la = _input.LA(1);
14693                                                if ( !(_la==WS || _la==NEWLINE) ) {
14694                                                _errHandler.recoverInline(this);
14695                                                } else {
14696                                                        consume();
14697                                                }
14698                                                }
14699                                                } 
14700                                        }
14701                                        setState(1769);
14702                                        _errHandler.sync(this);
14703                                        _alt = getInterpreter().adaptivePredict(_input,168,_ctx);
14704                                }
14705                                setState(1771);
14706                                _errHandler.sync(this);
14707                                switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
14708                                case 1:
14709                                        {
14710                                        setState(1770);
14711                                        match(CLASS_NAME);
14712                                        }
14713                                        break;
14714                                }
14715                                setState(1776);
14716                                _errHandler.sync(this);
14717                                _alt = getInterpreter().adaptivePredict(_input,170,_ctx);
14718                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14719                                        if ( _alt==1 ) {
14720                                                {
14721                                                {
14722                                                setState(1773);
14723                                                _la = _input.LA(1);
14724                                                if ( !(_la==WS || _la==NEWLINE) ) {
14725                                                _errHandler.recoverInline(this);
14726                                                } else {
14727                                                        consume();
14728                                                }
14729                                                }
14730                                                } 
14731                                        }
14732                                        setState(1778);
14733                                        _errHandler.sync(this);
14734                                        _alt = getInterpreter().adaptivePredict(_input,170,_ctx);
14735                                }
14736                                setState(1780);
14737                                _errHandler.sync(this);
14738                                switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) {
14739                                case 1:
14740                                        {
14741                                        setState(1779);
14742                                        description();
14743                                        }
14744                                        break;
14745                                }
14746                                }
14747                                break;
14748                        case VERSION_LITERAL:
14749                                enterOuterAlt(_localctx, 12);
14750                                {
14751                                setState(1782);
14752                                match(VERSION_LITERAL);
14753                                setState(1786);
14754                                _errHandler.sync(this);
14755                                _alt = getInterpreter().adaptivePredict(_input,172,_ctx);
14756                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14757                                        if ( _alt==1 ) {
14758                                                {
14759                                                {
14760                                                setState(1783);
14761                                                _la = _input.LA(1);
14762                                                if ( !(_la==WS || _la==NEWLINE) ) {
14763                                                _errHandler.recoverInline(this);
14764                                                } else {
14765                                                        consume();
14766                                                }
14767                                                }
14768                                                } 
14769                                        }
14770                                        setState(1788);
14771                                        _errHandler.sync(this);
14772                                        _alt = getInterpreter().adaptivePredict(_input,172,_ctx);
14773                                }
14774                                setState(1790);
14775                                _errHandler.sync(this);
14776                                switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) {
14777                                case 1:
14778                                        {
14779                                        setState(1789);
14780                                        description();
14781                                        }
14782                                        break;
14783                                }
14784                                }
14785                                break;
14786                        case CUSTOM_NAME:
14787                                enterOuterAlt(_localctx, 13);
14788                                {
14789                                setState(1792);
14790                                match(CUSTOM_NAME);
14791                                setState(1796);
14792                                _errHandler.sync(this);
14793                                _alt = getInterpreter().adaptivePredict(_input,174,_ctx);
14794                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14795                                        if ( _alt==1 ) {
14796                                                {
14797                                                {
14798                                                setState(1793);
14799                                                _la = _input.LA(1);
14800                                                if ( !(_la==WS || _la==NEWLINE) ) {
14801                                                _errHandler.recoverInline(this);
14802                                                } else {
14803                                                        consume();
14804                                                }
14805                                                }
14806                                                } 
14807                                        }
14808                                        setState(1798);
14809                                        _errHandler.sync(this);
14810                                        _alt = getInterpreter().adaptivePredict(_input,174,_ctx);
14811                                }
14812                                setState(1800);
14813                                _errHandler.sync(this);
14814                                switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) {
14815                                case 1:
14816                                        {
14817                                        setState(1799);
14818                                        description();
14819                                        }
14820                                        break;
14821                                }
14822                                }
14823                                break;
14824                        default:
14825                                throw new NoViableAltException(this);
14826                        }
14827                }
14828                catch (RecognitionException re) {
14829                        _localctx.exception = re;
14830                        _errHandler.reportError(this, re);
14831                        _errHandler.recover(this, re);
14832                }
14833                finally {
14834                        exitRule();
14835                }
14836                return _localctx;
14837        }
14838
14839        public static class JavadocInlineTagContext extends ParserRuleContext {
14840                public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); }
14841                public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); }
14842                public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); }
14843                public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); }
14844                public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); }
14845                public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); }
14846                public ReferenceContext reference() {
14847                        return getRuleContext(ReferenceContext.class,0);
14848                }
14849                public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); }
14850                public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); }
14851                public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); }
14852                public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); }
14853                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
14854                public TerminalNode WS(int i) {
14855                        return getToken(JavadocParser.WS, i);
14856                }
14857                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
14858                public TerminalNode NEWLINE(int i) {
14859                        return getToken(JavadocParser.NEWLINE, i);
14860                }
14861                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
14862                public TerminalNode LEADING_ASTERISK(int i) {
14863                        return getToken(JavadocParser.LEADING_ASTERISK, i);
14864                }
14865                public List<TextContext> text() {
14866                        return getRuleContexts(TextContext.class);
14867                }
14868                public TextContext text(int i) {
14869                        return getRuleContext(TextContext.class,i);
14870                }
14871                public DescriptionContext description() {
14872                        return getRuleContext(DescriptionContext.class,0);
14873                }
14874                public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) {
14875                        super(parent, invokingState);
14876                }
14877                @Override public int getRuleIndex() { return RULE_javadocInlineTag; }
14878                @Override
14879                public void enterRule(ParseTreeListener listener) {
14880                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocInlineTag(this);
14881                }
14882                @Override
14883                public void exitRule(ParseTreeListener listener) {
14884                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocInlineTag(this);
14885                }
14886                @Override
14887                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
14888                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocInlineTag(this);
14889                        else return visitor.visitChildren(this);
14890                }
14891        }
14892
14893        public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException {
14894                JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState());
14895                enterRule(_localctx, 144, RULE_javadocInlineTag);
14896                int _la;
14897                try {
14898                        int _alt;
14899                        enterOuterAlt(_localctx, 1);
14900                        {
14901                        setState(1804);
14902                        match(JAVADOC_INLINE_TAG_START);
14903                        setState(1881);
14904                        switch (_input.LA(1)) {
14905                        case CODE_LITERAL:
14906                                {
14907                                setState(1805);
14908                                match(CODE_LITERAL);
14909                                setState(1812);
14910                                _errHandler.sync(this);
14911                                _la = _input.LA(1);
14912                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
14913                                        {
14914                                        setState(1810);
14915                                        _errHandler.sync(this);
14916                                        switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) {
14917                                        case 1:
14918                                                {
14919                                                setState(1806);
14920                                                match(WS);
14921                                                }
14922                                                break;
14923                                        case 2:
14924                                                {
14925                                                setState(1807);
14926                                                match(NEWLINE);
14927                                                }
14928                                                break;
14929                                        case 3:
14930                                                {
14931                                                setState(1808);
14932                                                match(LEADING_ASTERISK);
14933                                                }
14934                                                break;
14935                                        case 4:
14936                                                {
14937                                                setState(1809);
14938                                                text();
14939                                                }
14940                                                break;
14941                                        }
14942                                        }
14943                                        setState(1814);
14944                                        _errHandler.sync(this);
14945                                        _la = _input.LA(1);
14946                                }
14947                                }
14948                                break;
14949                        case DOC_ROOT_LITERAL:
14950                                {
14951                                setState(1815);
14952                                match(DOC_ROOT_LITERAL);
14953                                setState(1819);
14954                                _errHandler.sync(this);
14955                                _la = _input.LA(1);
14956                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
14957                                        {
14958                                        {
14959                                        setState(1816);
14960                                        _la = _input.LA(1);
14961                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
14962                                        _errHandler.recoverInline(this);
14963                                        } else {
14964                                                consume();
14965                                        }
14966                                        }
14967                                        }
14968                                        setState(1821);
14969                                        _errHandler.sync(this);
14970                                        _la = _input.LA(1);
14971                                }
14972                                }
14973                                break;
14974                        case INHERIT_DOC_LITERAL:
14975                                {
14976                                setState(1822);
14977                                match(INHERIT_DOC_LITERAL);
14978                                setState(1826);
14979                                _errHandler.sync(this);
14980                                _la = _input.LA(1);
14981                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
14982                                        {
14983                                        {
14984                                        setState(1823);
14985                                        _la = _input.LA(1);
14986                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
14987                                        _errHandler.recoverInline(this);
14988                                        } else {
14989                                                consume();
14990                                        }
14991                                        }
14992                                        }
14993                                        setState(1828);
14994                                        _errHandler.sync(this);
14995                                        _la = _input.LA(1);
14996                                }
14997                                }
14998                                break;
14999                        case LINK_LITERAL:
15000                                {
15001                                setState(1829);
15002                                match(LINK_LITERAL);
15003                                setState(1833);
15004                                _errHandler.sync(this);
15005                                _la = _input.LA(1);
15006                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15007                                        {
15008                                        {
15009                                        setState(1830);
15010                                        _la = _input.LA(1);
15011                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15012                                        _errHandler.recoverInline(this);
15013                                        } else {
15014                                                consume();
15015                                        }
15016                                        }
15017                                        }
15018                                        setState(1835);
15019                                        _errHandler.sync(this);
15020                                        _la = _input.LA(1);
15021                                }
15022                                setState(1836);
15023                                reference();
15024                                setState(1838);
15025                                _errHandler.sync(this);
15026                                switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) {
15027                                case 1:
15028                                        {
15029                                        setState(1837);
15030                                        description();
15031                                        }
15032                                        break;
15033                                }
15034                                }
15035                                break;
15036                        case LINKPLAIN_LITERAL:
15037                                {
15038                                setState(1840);
15039                                match(LINKPLAIN_LITERAL);
15040                                setState(1844);
15041                                _errHandler.sync(this);
15042                                _la = _input.LA(1);
15043                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15044                                        {
15045                                        {
15046                                        setState(1841);
15047                                        _la = _input.LA(1);
15048                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15049                                        _errHandler.recoverInline(this);
15050                                        } else {
15051                                                consume();
15052                                        }
15053                                        }
15054                                        }
15055                                        setState(1846);
15056                                        _errHandler.sync(this);
15057                                        _la = _input.LA(1);
15058                                }
15059                                setState(1847);
15060                                reference();
15061                                setState(1849);
15062                                _errHandler.sync(this);
15063                                switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) {
15064                                case 1:
15065                                        {
15066                                        setState(1848);
15067                                        description();
15068                                        }
15069                                        break;
15070                                }
15071                                }
15072                                break;
15073                        case LITERAL_LITERAL:
15074                                {
15075                                setState(1851);
15076                                match(LITERAL_LITERAL);
15077                                setState(1858);
15078                                _errHandler.sync(this);
15079                                _la = _input.LA(1);
15080                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
15081                                        {
15082                                        setState(1856);
15083                                        _errHandler.sync(this);
15084                                        switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) {
15085                                        case 1:
15086                                                {
15087                                                setState(1852);
15088                                                match(WS);
15089                                                }
15090                                                break;
15091                                        case 2:
15092                                                {
15093                                                setState(1853);
15094                                                match(NEWLINE);
15095                                                }
15096                                                break;
15097                                        case 3:
15098                                                {
15099                                                setState(1854);
15100                                                match(LEADING_ASTERISK);
15101                                                }
15102                                                break;
15103                                        case 4:
15104                                                {
15105                                                setState(1855);
15106                                                text();
15107                                                }
15108                                                break;
15109                                        }
15110                                        }
15111                                        setState(1860);
15112                                        _errHandler.sync(this);
15113                                        _la = _input.LA(1);
15114                                }
15115                                }
15116                                break;
15117                        case VALUE_LITERAL:
15118                                {
15119                                setState(1861);
15120                                match(VALUE_LITERAL);
15121                                setState(1865);
15122                                _errHandler.sync(this);
15123                                _la = _input.LA(1);
15124                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15125                                        {
15126                                        {
15127                                        setState(1862);
15128                                        _la = _input.LA(1);
15129                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15130                                        _errHandler.recoverInline(this);
15131                                        } else {
15132                                                consume();
15133                                        }
15134                                        }
15135                                        }
15136                                        setState(1867);
15137                                        _errHandler.sync(this);
15138                                        _la = _input.LA(1);
15139                                }
15140                                setState(1869);
15141                                _la = _input.LA(1);
15142                                if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << DOT) | (1L << HASH) | (1L << CLASS) | (1L << MEMBER))) != 0)) {
15143                                        {
15144                                        setState(1868);
15145                                        reference();
15146                                        }
15147                                }
15148
15149                                }
15150                                break;
15151                        case CUSTOM_NAME:
15152                                {
15153                                setState(1871);
15154                                match(CUSTOM_NAME);
15155                                setState(1875);
15156                                _errHandler.sync(this);
15157                                _alt = getInterpreter().adaptivePredict(_input,189,_ctx);
15158                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
15159                                        if ( _alt==1 ) {
15160                                                {
15161                                                {
15162                                                setState(1872);
15163                                                _la = _input.LA(1);
15164                                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15165                                                _errHandler.recoverInline(this);
15166                                                } else {
15167                                                        consume();
15168                                                }
15169                                                }
15170                                                } 
15171                                        }
15172                                        setState(1877);
15173                                        _errHandler.sync(this);
15174                                        _alt = getInterpreter().adaptivePredict(_input,189,_ctx);
15175                                }
15176                                setState(1879);
15177                                _errHandler.sync(this);
15178                                switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) {
15179                                case 1:
15180                                        {
15181                                        setState(1878);
15182                                        description();
15183                                        }
15184                                        break;
15185                                }
15186                                }
15187                                break;
15188                        default:
15189                                throw new NoViableAltException(this);
15190                        }
15191                        setState(1883);
15192                        match(JAVADOC_INLINE_TAG_END);
15193                        }
15194                }
15195                catch (RecognitionException re) {
15196                        _localctx.exception = re;
15197                        _errHandler.reportError(this, re);
15198                        _errHandler.recover(this, re);
15199                }
15200                finally {
15201                        exitRule();
15202                }
15203                return _localctx;
15204        }
15205
15206        public static class HtmlCommentContext extends ParserRuleContext {
15207                public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); }
15208                public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); }
15209                public List<TextContext> text() {
15210                        return getRuleContexts(TextContext.class);
15211                }
15212                public TextContext text(int i) {
15213                        return getRuleContext(TextContext.class,i);
15214                }
15215                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
15216                public TerminalNode NEWLINE(int i) {
15217                        return getToken(JavadocParser.NEWLINE, i);
15218                }
15219                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
15220                public TerminalNode LEADING_ASTERISK(int i) {
15221                        return getToken(JavadocParser.LEADING_ASTERISK, i);
15222                }
15223                public HtmlCommentContext(ParserRuleContext parent, int invokingState) {
15224                        super(parent, invokingState);
15225                }
15226                @Override public int getRuleIndex() { return RULE_htmlComment; }
15227                @Override
15228                public void enterRule(ParseTreeListener listener) {
15229                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlComment(this);
15230                }
15231                @Override
15232                public void exitRule(ParseTreeListener listener) {
15233                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlComment(this);
15234                }
15235                @Override
15236                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
15237                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlComment(this);
15238                        else return visitor.visitChildren(this);
15239                }
15240        }
15241
15242        public final HtmlCommentContext htmlComment() throws RecognitionException {
15243                HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState());
15244                enterRule(_localctx, 146, RULE_htmlComment);
15245                int _la;
15246                try {
15247                        enterOuterAlt(_localctx, 1);
15248                        {
15249                        setState(1885);
15250                        match(HTML_COMMENT_START);
15251                        setState(1891);
15252                        _errHandler.sync(this);
15253                        _la = _input.LA(1);
15254                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
15255                                {
15256                                setState(1889);
15257                                switch (_input.LA(1)) {
15258                                case WS:
15259                                case CHAR:
15260                                        {
15261                                        setState(1886);
15262                                        text();
15263                                        }
15264                                        break;
15265                                case NEWLINE:
15266                                        {
15267                                        setState(1887);
15268                                        match(NEWLINE);
15269                                        }
15270                                        break;
15271                                case LEADING_ASTERISK:
15272                                        {
15273                                        setState(1888);
15274                                        match(LEADING_ASTERISK);
15275                                        }
15276                                        break;
15277                                default:
15278                                        throw new NoViableAltException(this);
15279                                }
15280                                }
15281                                setState(1893);
15282                                _errHandler.sync(this);
15283                                _la = _input.LA(1);
15284                        }
15285                        setState(1894);
15286                        match(HTML_COMMENT_END);
15287                        }
15288                }
15289                catch (RecognitionException re) {
15290                        _localctx.exception = re;
15291                        _errHandler.reportError(this, re);
15292                        _errHandler.recover(this, re);
15293                }
15294                finally {
15295                        exitRule();
15296                }
15297                return _localctx;
15298        }
15299
15300        public static class TextContext extends ParserRuleContext {
15301                public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); }
15302                public TerminalNode CHAR(int i) {
15303                        return getToken(JavadocParser.CHAR, i);
15304                }
15305                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
15306                public TerminalNode WS(int i) {
15307                        return getToken(JavadocParser.WS, i);
15308                }
15309                public TextContext(ParserRuleContext parent, int invokingState) {
15310                        super(parent, invokingState);
15311                }
15312                @Override public int getRuleIndex() { return RULE_text; }
15313                @Override
15314                public void enterRule(ParseTreeListener listener) {
15315                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterText(this);
15316                }
15317                @Override
15318                public void exitRule(ParseTreeListener listener) {
15319                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitText(this);
15320                }
15321                @Override
15322                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
15323                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitText(this);
15324                        else return visitor.visitChildren(this);
15325                }
15326        }
15327
15328        public final TextContext text() throws RecognitionException {
15329                TextContext _localctx = new TextContext(_ctx, getState());
15330                enterRule(_localctx, 148, RULE_text);
15331                int _la;
15332                try {
15333                        int _alt;
15334                        enterOuterAlt(_localctx, 1);
15335                        {
15336                        setState(1898); 
15337                        _errHandler.sync(this);
15338                        _alt = 1;
15339                        do {
15340                                switch (_alt) {
15341                                case 1:
15342                                        {
15343                                        {
15344                                        setState(1896);
15345                                        _la = _input.LA(1);
15346                                        if ( !(_la==WS || _la==CHAR) ) {
15347                                        _errHandler.recoverInline(this);
15348                                        } else {
15349                                                consume();
15350                                        }
15351
15352                                          _la = _input.LA(1);
15353                                          if ((_la != WS) && (_la != CHAR)) return _localctx;
15354                                          else if (_alt == 1) continue;
15355                                         
15356                                        }
15357                                        }
15358                                        break;
15359                                default:
15360                                        throw new NoViableAltException(this);
15361                                }
15362                                setState(1900); 
15363                                _errHandler.sync(this);
15364                                _alt = getInterpreter().adaptivePredict(_input,194,_ctx);
15365                        } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
15366                        }
15367                }
15368                catch (RecognitionException re) {
15369                        _localctx.exception = re;
15370                        _errHandler.reportError(this, re);
15371                        _errHandler.recover(this, re);
15372                }
15373                finally {
15374                        exitRule();
15375                }
15376                return _localctx;
15377        }
15378
15379        public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
15380                switch (ruleIndex) {
15381                case 0:
15382                        return javadoc_sempred((JavadocContext)_localctx, predIndex);
15383                case 5:
15384                        return htmlTag_sempred((HtmlTagContext)_localctx, predIndex);
15385                case 8:
15386                        return paragraph_sempred((ParagraphContext)_localctx, predIndex);
15387                case 11:
15388                        return li_sempred((LiContext)_localctx, predIndex);
15389                case 14:
15390                        return tr_sempred((TrContext)_localctx, predIndex);
15391                case 17:
15392                        return td_sempred((TdContext)_localctx, predIndex);
15393                case 20:
15394                        return th_sempred((ThContext)_localctx, predIndex);
15395                case 23:
15396                        return body_sempred((BodyContext)_localctx, predIndex);
15397                case 26:
15398                        return colgroup_sempred((ColgroupContext)_localctx, predIndex);
15399                case 29:
15400                        return dd_sempred((DdContext)_localctx, predIndex);
15401                case 32:
15402                        return dt_sempred((DtContext)_localctx, predIndex);
15403                case 35:
15404                        return head_sempred((HeadContext)_localctx, predIndex);
15405                case 38:
15406                        return html_sempred((HtmlContext)_localctx, predIndex);
15407                case 41:
15408                        return option_sempred((OptionContext)_localctx, predIndex);
15409                case 44:
15410                        return tbody_sempred((TbodyContext)_localctx, predIndex);
15411                case 47:
15412                        return tfoot_sempred((TfootContext)_localctx, predIndex);
15413                case 50:
15414                        return thead_sempred((TheadContext)_localctx, predIndex);
15415                case 68:
15416                        return description_sempred((DescriptionContext)_localctx, predIndex);
15417                }
15418                return true;
15419        }
15420        private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) {
15421                switch (predIndex) {
15422                case 0:
15423                        return !isNextJavadocTag();
15424                }
15425                return true;
15426        }
15427        private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) {
15428                switch (predIndex) {
15429                case 1:
15430                        return !isNextJavadocTag();
15431                case 2:
15432                        return !isNextJavadocTag();
15433                }
15434                return true;
15435        }
15436        private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) {
15437                switch (predIndex) {
15438                case 3:
15439                        return !isNextJavadocTag();
15440                }
15441                return true;
15442        }
15443        private boolean li_sempred(LiContext _localctx, int predIndex) {
15444                switch (predIndex) {
15445                case 4:
15446                        return !isNextJavadocTag();
15447                }
15448                return true;
15449        }
15450        private boolean tr_sempred(TrContext _localctx, int predIndex) {
15451                switch (predIndex) {
15452                case 5:
15453                        return !isNextJavadocTag();
15454                }
15455                return true;
15456        }
15457        private boolean td_sempred(TdContext _localctx, int predIndex) {
15458                switch (predIndex) {
15459                case 6:
15460                        return !isNextJavadocTag();
15461                }
15462                return true;
15463        }
15464        private boolean th_sempred(ThContext _localctx, int predIndex) {
15465                switch (predIndex) {
15466                case 7:
15467                        return !isNextJavadocTag();
15468                }
15469                return true;
15470        }
15471        private boolean body_sempred(BodyContext _localctx, int predIndex) {
15472                switch (predIndex) {
15473                case 8:
15474                        return !isNextJavadocTag();
15475                }
15476                return true;
15477        }
15478        private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) {
15479                switch (predIndex) {
15480                case 9:
15481                        return !isNextJavadocTag();
15482                }
15483                return true;
15484        }
15485        private boolean dd_sempred(DdContext _localctx, int predIndex) {
15486                switch (predIndex) {
15487                case 10:
15488                        return !isNextJavadocTag();
15489                }
15490                return true;
15491        }
15492        private boolean dt_sempred(DtContext _localctx, int predIndex) {
15493                switch (predIndex) {
15494                case 11:
15495                        return !isNextJavadocTag();
15496                }
15497                return true;
15498        }
15499        private boolean head_sempred(HeadContext _localctx, int predIndex) {
15500                switch (predIndex) {
15501                case 12:
15502                        return !isNextJavadocTag();
15503                }
15504                return true;
15505        }
15506        private boolean html_sempred(HtmlContext _localctx, int predIndex) {
15507                switch (predIndex) {
15508                case 13:
15509                        return !isNextJavadocTag();
15510                }
15511                return true;
15512        }
15513        private boolean option_sempred(OptionContext _localctx, int predIndex) {
15514                switch (predIndex) {
15515                case 14:
15516                        return !isNextJavadocTag();
15517                }
15518                return true;
15519        }
15520        private boolean tbody_sempred(TbodyContext _localctx, int predIndex) {
15521                switch (predIndex) {
15522                case 15:
15523                        return !isNextJavadocTag();
15524                }
15525                return true;
15526        }
15527        private boolean tfoot_sempred(TfootContext _localctx, int predIndex) {
15528                switch (predIndex) {
15529                case 16:
15530                        return !isNextJavadocTag();
15531                }
15532                return true;
15533        }
15534        private boolean thead_sempred(TheadContext _localctx, int predIndex) {
15535                switch (predIndex) {
15536                case 17:
15537                        return !isNextJavadocTag();
15538                }
15539                return true;
15540        }
15541        private boolean description_sempred(DescriptionContext _localctx, int predIndex) {
15542                switch (predIndex) {
15543                case 18:
15544                        return !isNextJavadocTag();
15545                }
15546                return true;
15547        }
15548
15549        public static final String _serializedATN =
15550                "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3]\u0771\4\2\t\2\4"+
15551                "\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"+
15552                "\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"+
15553                "\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"+
15554                "\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!"+
15555                "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
15556                ",\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"+
15557                "\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="+
15558                "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
15559                "\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"+
15560                "\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"+
15561                "\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"+
15562                "\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"+
15563                "\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
15564                "\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u00e6\n\3\3\4\3\4\3\4\3\4\3\4\3\4\7"+
15565                "\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"+
15566                "\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"+
15567                "\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"+
15568                "\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"+
15569                "\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"+
15570                "\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"+
15571                "\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"+
15572                "\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"+
15573                "\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"+
15574                "\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"+
15575                "\13\3\13\3\13\3\13\3\13\3\13\7\13\u0180\n\13\f\13\16\13\u0183\13\13\3"+
15576                "\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"+
15577                "\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"+
15578                "\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"+
15579                "\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"+
15580                "\3\16\3\16\7\16\u01c5\n\16\f\16\16\16\u01c8\13\16\3\16\3\16\3\17\3\17"+
15581                "\3\17\3\17\7\17\u01d0\n\17\f\17\16\17\u01d3\13\17\3\17\3\17\3\20\3\20"+
15582                "\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"+
15583                "\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20"+
15584                "\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u01fd\n\20\f\20\16\20\u0200"+
15585                "\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"+
15586                "\21\u020d\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0215\n\22\f\22\16"+
15587                "\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"+
15588                "\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"+
15589                "\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23"+
15590                "\3\23\7\23\u0242\n\23\f\23\16\23\u0245\13\23\3\23\3\23\3\24\3\24\3\24"+
15591                "\3\24\3\24\3\24\7\24\u024f\n\24\f\24\16\24\u0252\13\24\3\24\3\24\3\25"+
15592                "\3\25\3\25\3\25\7\25\u025a\n\25\f\25\16\25\u025d\13\25\3\25\3\25\3\26"+
15593                "\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"+
15594                "\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26"+
15595                "\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\7\26\u0287\n\26\f\26\16"+
15596                "\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"+
15597                "\f\27\16\27\u0297\13\27\3\27\3\27\3\30\3\30\3\30\3\30\7\30\u029f\n\30"+
15598                "\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"+
15599                "\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"+
15600                "\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3"+
15601                "\31\3\31\3\31\7\31\u02cc\n\31\f\31\16\31\u02cf\13\31\3\31\3\31\3\32\3"+
15602                "\32\3\32\3\32\3\32\3\32\7\32\u02d9\n\32\f\32\16\32\u02dc\13\32\3\32\3"+
15603                "\32\3\33\3\33\3\33\3\33\7\33\u02e4\n\33\f\33\16\33\u02e7\13\33\3\33\3"+
15604                "\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"+
15605                "\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"+
15606                "\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"+
15607                "\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"+
15608                "\n\35\f\35\16\35\u0321\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u0329"+
15609                "\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"+
15610                "\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"+
15611                "\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3"+
15612                "\37\3\37\3\37\3\37\7\37\u0356\n\37\f\37\16\37\u0359\13\37\3\37\3\37\3"+
15613                " \3 \3 \3 \3 \3 \7 \u0363\n \f \16 \u0366\13 \3 \3 \3!\3!\3!\3!\7!\u036e"+
15614                "\n!\f!\16!\u0371\13!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+
15615                "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+
15616                "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u039b\n\"\f\"\16\"\u039e\13"+
15617                "\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u03a8\n#\f#\16#\u03ab\13#\3#\3#\3$\3$"+
15618                "\3$\3$\7$\u03b3\n$\f$\16$\u03b6\13$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+
15619                "%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+
15620                "%\3%\3%\3%\3%\3%\7%\u03e0\n%\f%\16%\u03e3\13%\3%\3%\3&\3&\3&\3&\3&\3&"+
15621                "\7&\u03ed\n&\f&\16&\u03f0\13&\3&\3&\3\'\3\'\3\'\3\'\7\'\u03f8\n\'\f\'"+
15622                "\16\'\u03fb\13\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\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                "\7(\u0425\n(\f(\16(\u0428\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u0432\n)\f)\16"+
15625                ")\u0435\13)\3)\3)\3*\3*\3*\3*\7*\u043d\n*\f*\16*\u0440\13*\3*\3*\3+\3"+
15626                "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\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+\7+\u046a\n+\f+\16+\u046d\13+"+
15628                "\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0477\n,\f,\16,\u047a\13,\3,\3,\3-\3-\3-\3"+
15629                "-\7-\u0482\n-\f-\16-\u0485\13-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+
15630                "\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+
15631                "\3.\3.\3.\3.\7.\u04af\n.\f.\16.\u04b2\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/\u04bc"+
15632                "\n/\f/\16/\u04bf\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u04c7\n\60\f\60\16"+
15633                "\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"+
15634                "\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"+
15635                "\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61"+
15636                "\3\61\7\61\u04f4\n\61\f\61\16\61\u04f7\13\61\3\61\3\61\3\62\3\62\3\62"+
15637                "\3\62\3\62\3\62\7\62\u0501\n\62\f\62\16\62\u0504\13\62\3\62\3\62\3\63"+
15638                "\3\63\3\63\3\63\7\63\u050c\n\63\f\63\16\63\u050f\13\63\3\63\3\63\3\64"+
15639                "\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"+
15640                "\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64"+
15641                "\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\7\64\u0539\n\64\f\64\16"+
15642                "\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"+
15643                "\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"+
15644                "\3\66\7\66\u0557\n\66\f\66\16\66\u055a\13\66\3\66\3\66\3\67\3\67\3\67"+
15645                "\3\67\3\67\3\67\7\67\u0564\n\67\f\67\16\67\u0567\13\67\3\67\3\67\38\3"+
15646                "8\38\38\38\38\78\u0571\n8\f8\168\u0574\138\38\38\39\39\39\39\39\39\79"+
15647                "\u057e\n9\f9\169\u0581\139\39\39\3:\3:\3:\3:\3:\3:\7:\u058b\n:\f:\16:"+
15648                "\u058e\13:\3:\3:\3;\3;\3;\3;\3;\3;\7;\u0598\n;\f;\16;\u059b\13;\3;\3;"+
15649                "\3<\3<\3<\3<\3<\3<\7<\u05a5\n<\f<\16<\u05a8\13<\3<\3<\3=\3=\3=\3=\3=\3"+
15650                "=\7=\u05b2\n=\f=\16=\u05b5\13=\3=\3=\3>\3>\3>\3>\3>\3>\7>\u05bf\n>\f>"+
15651                "\16>\u05c2\13>\3>\3>\3?\3?\3?\3?\3?\3?\7?\u05cc\n?\f?\16?\u05cf\13?\3"+
15652                "?\3?\3@\3@\3@\3@\3@\3@\7@\u05d9\n@\f@\16@\u05dc\13@\3@\3@\3A\3A\3A\3A"+
15653                "\3A\3A\7A\u05e6\nA\fA\16A\u05e9\13A\3A\3A\3B\3B\3B\3B\3B\3B\7B\u05f3\n"+
15654                "B\fB\16B\u05f6\13B\3B\3B\3C\3C\3C\3C\3C\3C\7C\u0600\nC\fC\16C\u0603\13"+
15655                "C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\6F\u0617\nF\r"+
15656                "F\16F\u0618\3G\3G\7G\u061d\nG\fG\16G\u0620\13G\3G\5G\u0623\nG\3G\5G\u0626"+
15657                "\nG\3G\5G\u0629\nG\3G\6G\u062c\nG\rG\16G\u062d\3G\5G\u0631\nG\3G\5G\u0634"+
15658                "\nG\3G\5G\u0637\nG\3G\5G\u063a\nG\3G\3G\5G\u063e\nG\5G\u0640\nG\3H\3H"+
15659                "\7H\u0644\nH\fH\16H\u0647\13H\3H\3H\3I\3I\7I\u064d\nI\fI\16I\u0650\13"+
15660                "I\3I\5I\u0653\nI\3I\3I\7I\u0657\nI\fI\16I\u065a\13I\3I\5I\u065d\nI\3I"+
15661                "\3I\7I\u0661\nI\fI\16I\u0664\13I\3I\5I\u0667\nI\3I\7I\u066a\nI\fI\16I"+
15662                "\u066d\13I\3I\5I\u0670\nI\3I\3I\7I\u0674\nI\fI\16I\u0677\13I\3I\5I\u067a"+
15663                "\nI\3I\7I\u067d\nI\fI\16I\u0680\13I\3I\5I\u0683\nI\3I\3I\7I\u0687\nI\f"+
15664                "I\16I\u068a\13I\3I\5I\u068d\nI\3I\3I\7I\u0691\nI\fI\16I\u0694\13I\3I\5"+
15665                "I\u0697\nI\3I\3I\7I\u069b\nI\fI\16I\u069e\13I\3I\7I\u06a1\nI\fI\16I\u06a4"+
15666                "\13I\3I\5I\u06a7\nI\3I\3I\7I\u06ab\nI\fI\16I\u06ae\13I\3I\5I\u06b1\nI"+
15667                "\3I\5I\u06b4\nI\3I\3I\7I\u06b8\nI\fI\16I\u06bb\13I\3I\5I\u06be\nI\3I\3"+
15668                "I\7I\u06c2\nI\fI\16I\u06c5\13I\3I\5I\u06c8\nI\3I\7I\u06cb\nI\fI\16I\u06ce"+
15669                "\13I\3I\5I\u06d1\nI\3I\7I\u06d4\nI\fI\16I\u06d7\13I\3I\5I\u06da\nI\3I"+
15670                "\3I\7I\u06de\nI\fI\16I\u06e1\13I\3I\5I\u06e4\nI\3I\3I\7I\u06e8\nI\fI\16"+
15671                "I\u06eb\13I\3I\5I\u06ee\nI\3I\7I\u06f1\nI\fI\16I\u06f4\13I\3I\5I\u06f7"+
15672                "\nI\3I\3I\7I\u06fb\nI\fI\16I\u06fe\13I\3I\5I\u0701\nI\3I\3I\7I\u0705\n"+
15673                "I\fI\16I\u0708\13I\3I\5I\u070b\nI\5I\u070d\nI\3J\3J\3J\3J\3J\3J\7J\u0715"+
15674                "\nJ\fJ\16J\u0718\13J\3J\3J\7J\u071c\nJ\fJ\16J\u071f\13J\3J\3J\7J\u0723"+
15675                "\nJ\fJ\16J\u0726\13J\3J\3J\7J\u072a\nJ\fJ\16J\u072d\13J\3J\3J\5J\u0731"+
15676                "\nJ\3J\3J\7J\u0735\nJ\fJ\16J\u0738\13J\3J\3J\5J\u073c\nJ\3J\3J\3J\3J\3"+
15677                "J\7J\u0743\nJ\fJ\16J\u0746\13J\3J\3J\7J\u074a\nJ\fJ\16J\u074d\13J\3J\5"+
15678                "J\u0750\nJ\3J\3J\7J\u0754\nJ\fJ\16J\u0757\13J\3J\5J\u075a\nJ\5J\u075c"+
15679                "\nJ\3J\3J\3K\3K\3K\3K\7K\u0764\nK\fK\16K\u0767\13K\3K\3K\3L\3L\6L\u076d"+
15680                "\nL\rL\16L\u076e\3L\2\2M\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&("+
15681                "*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084"+
15682                "\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\2\13\5\2\3\3\6"+
15683                "\6\b\b\4\2=KYY\3\29:\3\2LX\4\2\37\37!!\6\2\3\3\6\6\b\b&\'\4\2\6\6\b\b"+
15684                "\3\2\30\31\4\2\6\6\32\32\u0a88\2\u00a2\3\2\2\2\4\u00e5\3\2\2\2\6\u00e7"+
15685                "\3\2\2\2\b\u00f4\3\2\2\2\n\u00ff\3\2\2\2\f\u0132\3\2\2\2\16\u0134\3\2"+
15686                "\2\2\20\u0141\3\2\2\2\22\u014c\3\2\2\2\24\u0179\3\2\2\2\26\u0186\3\2\2"+
15687                "\2\30\u0191\3\2\2\2\32\u01be\3\2\2\2\34\u01cb\3\2\2\2\36\u01d6\3\2\2\2"+
15688                " \u0203\3\2\2\2\"\u0210\3\2\2\2$\u021b\3\2\2\2&\u0248\3\2\2\2(\u0255\3"+
15689                "\2\2\2*\u0260\3\2\2\2,\u028d\3\2\2\2.\u029a\3\2\2\2\60\u02a5\3\2\2\2\62"+
15690                "\u02d2\3\2\2\2\64\u02df\3\2\2\2\66\u02ea\3\2\2\28\u0317\3\2\2\2:\u0324"+
15691                "\3\2\2\2<\u032f\3\2\2\2>\u035c\3\2\2\2@\u0369\3\2\2\2B\u0374\3\2\2\2D"+
15692                "\u03a1\3\2\2\2F\u03ae\3\2\2\2H\u03b9\3\2\2\2J\u03e6\3\2\2\2L\u03f3\3\2"+
15693                "\2\2N\u03fe\3\2\2\2P\u042b\3\2\2\2R\u0438\3\2\2\2T\u0443\3\2\2\2V\u0470"+
15694                "\3\2\2\2X\u047d\3\2\2\2Z\u0488\3\2\2\2\\\u04b5\3\2\2\2^\u04c2\3\2\2\2"+
15695                "`\u04cd\3\2\2\2b\u04fa\3\2\2\2d\u0507\3\2\2\2f\u0512\3\2\2\2h\u054e\3"+
15696                "\2\2\2j\u0550\3\2\2\2l\u055d\3\2\2\2n\u056a\3\2\2\2p\u0577\3\2\2\2r\u0584"+
15697                "\3\2\2\2t\u0591\3\2\2\2v\u059e\3\2\2\2x\u05ab\3\2\2\2z\u05b8\3\2\2\2|"+
15698                "\u05c5\3\2\2\2~\u05d2\3\2\2\2\u0080\u05df\3\2\2\2\u0082\u05ec\3\2\2\2"+
15699                "\u0084\u05f9\3\2\2\2\u0086\u0606\3\2\2\2\u0088\u060c\3\2\2\2\u008a\u0616"+
15700                "\3\2\2\2\u008c\u063f\3\2\2\2\u008e\u0641\3\2\2\2\u0090\u070c\3\2\2\2\u0092"+
15701                "\u070e\3\2\2\2\u0094\u075f\3\2\2\2\u0096\u076c\3\2\2\2\u0098\u00a1\5\4"+
15702                "\3\2\u0099\u009a\6\2\2\2\u009a\u00a1\7\3\2\2\u009b\u00a1\5\u0094K\2\u009c"+
15703                "\u00a1\7\5\2\2\u009d\u00a1\7\b\2\2\u009e\u00a1\5\u0096L\2\u009f\u00a1"+
15704                "\5\u0092J\2\u00a0\u0098\3\2\2\2\u00a0\u0099\3\2\2\2\u00a0\u009b\3\2\2"+
15705                "\2\u00a0\u009c\3\2\2\2\u00a0\u009d\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u009f"+
15706                "\3\2\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3"+
15707                "\u00b1\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5\u00a7\7\3\2\2\u00a6\u00a5\3\2"+
15708                "\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00ab\3\2\2\2\u00a8\u00aa\7\6\2\2\u00a9"+
15709                "\u00a8\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00ac\3\2"+
15710                "\2\2\u00ac\u00ae\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00b0\5\u0090I\2\u00af"+
15711                "\u00a6\3\2\2\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2"+
15712                "\2\2\u00b2\u00b4\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4\u00b5\7\2\2\3\u00b5"+
15713                "\3\3\2\2\2\u00b6\u00e6\5\f\7\2\u00b7\u00e6\5h\65\2\u00b8\u00e6\5\22\n"+
15714                "\2\u00b9\u00e6\5\30\r\2\u00ba\u00e6\5\36\20\2\u00bb\u00e6\5$\23\2\u00bc"+
15715                "\u00e6\5*\26\2\u00bd\u00e6\5\60\31\2\u00be\u00e6\5\66\34\2\u00bf\u00e6"+
15716                "\5<\37\2\u00c0\u00e6\5B\"\2\u00c1\u00e6\5H%\2\u00c2\u00e6\5N(\2\u00c3"+
15717                "\u00e6\5T+\2\u00c4\u00e6\5Z.\2\u00c5\u00e6\5f\64\2\u00c6\u00e6\5`\61\2"+
15718                "\u00c7\u00e6\5\16\b\2\u00c8\u00e6\5\24\13\2\u00c9\u00e6\5\32\16\2\u00ca"+
15719                "\u00e6\5 \21\2\u00cb\u00e6\5&\24\2\u00cc\u00e6\5,\27\2\u00cd\u00e6\5\62"+
15720                "\32\2\u00ce\u00e6\58\35\2\u00cf\u00e6\5> \2\u00d0\u00e6\5D#\2\u00d1\u00e6"+
15721                "\5J&\2\u00d2\u00e6\5P)\2\u00d3\u00e6\5V,\2\u00d4\u00e6\5b\62\2\u00d5\u00e6"+
15722                "\5\\/\2\u00d6\u00e6\5\20\t\2\u00d7\u00e6\5\26\f\2\u00d8\u00e6\5\34\17"+
15723                "\2\u00d9\u00e6\5\"\22\2\u00da\u00e6\5(\25\2\u00db\u00e6\5.\30\2\u00dc"+
15724                "\u00e6\5\64\33\2\u00dd\u00e6\5:\36\2\u00de\u00e6\5@!\2\u00df\u00e6\5F"+
15725                "$\2\u00e0\u00e6\5L\'\2\u00e1\u00e6\5R*\2\u00e2\u00e6\5X-\2\u00e3\u00e6"+
15726                "\5d\63\2\u00e4\u00e6\5^\60\2\u00e5\u00b6\3\2\2\2\u00e5\u00b7\3\2\2\2\u00e5"+
15727                "\u00b8\3\2\2\2\u00e5\u00b9\3\2\2\2\u00e5\u00ba\3\2\2\2\u00e5\u00bb\3\2"+
15728                "\2\2\u00e5\u00bc\3\2\2\2\u00e5\u00bd\3\2\2\2\u00e5\u00be\3\2\2\2\u00e5"+
15729                "\u00bf\3\2\2\2\u00e5\u00c0\3\2\2\2\u00e5\u00c1\3\2\2\2\u00e5\u00c2\3\2"+
15730                "\2\2\u00e5\u00c3\3\2\2\2\u00e5\u00c4\3\2\2\2\u00e5\u00c5\3\2\2\2\u00e5"+
15731                "\u00c6\3\2\2\2\u00e5\u00c7\3\2\2\2\u00e5\u00c8\3\2\2\2\u00e5\u00c9\3\2"+
15732                "\2\2\u00e5\u00ca\3\2\2\2\u00e5\u00cb\3\2\2\2\u00e5\u00cc\3\2\2\2\u00e5"+
15733                "\u00cd\3\2\2\2\u00e5\u00ce\3\2\2\2\u00e5\u00cf\3\2\2\2\u00e5\u00d0\3\2"+
15734                "\2\2\u00e5\u00d1\3\2\2\2\u00e5\u00d2\3\2\2\2\u00e5\u00d3\3\2\2\2\u00e5"+
15735                "\u00d4\3\2\2\2\u00e5\u00d5\3\2\2\2\u00e5\u00d6\3\2\2\2\u00e5\u00d7\3\2"+
15736                "\2\2\u00e5\u00d8\3\2\2\2\u00e5\u00d9\3\2\2\2\u00e5\u00da\3\2\2\2\u00e5"+
15737                "\u00db\3\2\2\2\u00e5\u00dc\3\2\2\2\u00e5\u00dd\3\2\2\2\u00e5\u00de\3\2"+
15738                "\2\2\u00e5\u00df\3\2\2\2\u00e5\u00e0\3\2\2\2\u00e5\u00e1\3\2\2\2\u00e5"+
15739                "\u00e2\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e4\3\2\2\2\u00e6\5\3\2\2\2"+
15740                "\u00e7\u00e8\7\7\2\2\u00e8\u00ef\7Y\2\2\u00e9\u00ee\5\n\6\2\u00ea\u00ee"+
15741                "\7\b\2\2\u00eb\u00ee\7\3\2\2\u00ec\u00ee\7\6\2\2\u00ed\u00e9\3\2\2\2\u00ed"+
15742                "\u00ea\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ec\3\2\2\2\u00ee\u00f1\3\2"+
15743                "\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\3\2\2\2\u00f1"+
15744                "\u00ef\3\2\2\2\u00f2\u00f3\79\2\2\u00f3\7\3\2\2\2\u00f4\u00f5\7\7\2\2"+
15745                "\u00f5\u00f6\7;\2\2\u00f6\u00fa\7Y\2\2\u00f7\u00f9\t\2\2\2\u00f8\u00f7"+
15746                "\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb"+
15747                "\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\79\2\2\u00fe\t\3\2\2\2"+
15748                "\u00ff\u0103\7Y\2\2\u0100\u0102\t\2\2\2\u0101\u0100\3\2\2\2\u0102\u0105"+
15749                "\3\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105"+
15750                "\u0103\3\2\2\2\u0106\u010a\7<\2\2\u0107\u0109\t\2\2\2\u0108\u0107\3\2"+
15751                "\2\2\u0109\u010c\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b"+
15752                "\u0110\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u0111\7[\2\2\u010e\u0111\5\u0096"+
15753                "L\2\u010f\u0111\7Y\2\2\u0110\u010d\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u010f"+
15754                "\3\2\2\2\u0111\13\3\2\2\2\u0112\u011d\5\6\4\2\u0113\u011c\5\4\3\2\u0114"+
15755                "\u0115\6\7\3\2\u0115\u011c\7\3\2\2\u0116\u011c\5\u0094K\2\u0117\u011c"+
15756                "\7\5\2\2\u0118\u011c\7\b\2\2\u0119\u011c\5\u0096L\2\u011a\u011c\5\u0092"+
15757                "J\2\u011b\u0113\3\2\2\2\u011b\u0114\3\2\2\2\u011b\u0116\3\2\2\2\u011b"+
15758                "\u0117\3\2\2\2\u011b\u0118\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2"+
15759                "\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+
15760                "\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0121\5\b\5\2\u0121\u0133\3\2"+
15761                "\2\2\u0122\u012d\5\6\4\2\u0123\u012c\5\4\3\2\u0124\u0125\6\7\4\2\u0125"+
15762                "\u012c\7\3\2\2\u0126\u012c\5\u0094K\2\u0127\u012c\7\5\2\2\u0128\u012c"+
15763                "\7\b\2\2\u0129\u012c\5\u0096L\2\u012a\u012c\5\u0092J\2\u012b\u0123\3\2"+
15764                "\2\2\u012b\u0124\3\2\2\2\u012b\u0126\3\2\2\2\u012b\u0127\3\2\2\2\u012b"+
15765                "\u0128\3\2\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u012f\3\2"+
15766                "\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0130\3\2\2\2\u012f"+
15767                "\u012d\3\2\2\2\u0130\u0131\b\7\1\2\u0131\u0133\3\2\2\2\u0132\u0112\3\2"+
15768                "\2\2\u0132\u0122\3\2\2\2\u0133\r\3\2\2\2\u0134\u0135\7\7\2\2\u0135\u013c"+
15769                "\7=\2\2\u0136\u013b\5\n\6\2\u0137\u013b\7\b\2\2\u0138\u013b\7\3\2\2\u0139"+
15770                "\u013b\7\6\2\2\u013a\u0136\3\2\2\2\u013a\u0137\3\2\2\2\u013a\u0138\3\2"+
15771                "\2\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c"+
15772                "\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0140\79"+
15773                "\2\2\u0140\17\3\2\2\2\u0141\u0142\7\7\2\2\u0142\u0143\7;\2\2\u0143\u0147"+
15774                "\7=\2\2\u0144\u0146\t\2\2\2\u0145\u0144\3\2\2\2\u0146\u0149\3\2\2\2\u0147"+
15775                "\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2\u0149\u0147\3\2"+
15776                "\2\2\u014a\u014b\79\2\2\u014b\21\3\2\2\2\u014c\u0174\5\16\b\2\u014d\u0173"+
15777                "\5\f\7\2\u014e\u0173\5j\66\2\u014f\u0173\5\30\r\2\u0150\u0173\5\36\20"+
15778                "\2\u0151\u0173\5$\23\2\u0152\u0173\5*\26\2\u0153\u0173\5\60\31\2\u0154"+
15779                "\u0173\5\66\34\2\u0155\u0173\5<\37\2\u0156\u0173\5B\"\2\u0157\u0173\5"+
15780                "H%\2\u0158\u0173\5N(\2\u0159\u0173\5T+\2\u015a\u0173\5Z.\2\u015b\u0173"+
15781                "\5f\64\2\u015c\u0173\5`\61\2\u015d\u0173\5\24\13\2\u015e\u0173\5\32\16"+
15782                "\2\u015f\u0173\5 \21\2\u0160\u0173\5&\24\2\u0161\u0173\5,\27\2\u0162\u0173"+
15783                "\5\62\32\2\u0163\u0173\58\35\2\u0164\u0173\5> \2\u0165\u0173\5D#\2\u0166"+
15784                "\u0173\5J&\2\u0167\u0173\5P)\2\u0168\u0173\5V,\2\u0169\u0173\5b\62\2\u016a"+
15785                "\u0173\5\\/\2\u016b\u016c\6\n\5\2\u016c\u0173\7\3\2\2\u016d\u0173\5\u0094"+
15786                "K\2\u016e\u0173\7\5\2\2\u016f\u0173\7\b\2\2\u0170\u0173\5\u0096L\2\u0171"+
15787                "\u0173\5\u0092J\2\u0172\u014d\3\2\2\2\u0172\u014e\3\2\2\2\u0172\u014f"+
15788                "\3\2\2\2\u0172\u0150\3\2\2\2\u0172\u0151\3\2\2\2\u0172\u0152\3\2\2\2\u0172"+
15789                "\u0153\3\2\2\2\u0172\u0154\3\2\2\2\u0172\u0155\3\2\2\2\u0172\u0156\3\2"+
15790                "\2\2\u0172\u0157\3\2\2\2\u0172\u0158\3\2\2\2\u0172\u0159\3\2\2\2\u0172"+
15791                "\u015a\3\2\2\2\u0172\u015b\3\2\2\2\u0172\u015c\3\2\2\2\u0172\u015d\3\2"+
15792                "\2\2\u0172\u015e\3\2\2\2\u0172\u015f\3\2\2\2\u0172\u0160\3\2\2\2\u0172"+
15793                "\u0161\3\2\2\2\u0172\u0162\3\2\2\2\u0172\u0163\3\2\2\2\u0172\u0164\3\2"+
15794                "\2\2\u0172\u0165\3\2\2\2\u0172\u0166\3\2\2\2\u0172\u0167\3\2\2\2\u0172"+
15795                "\u0168\3\2\2\2\u0172\u0169\3\2\2\2\u0172\u016a\3\2\2\2\u0172\u016b\3\2"+
15796                "\2\2\u0172\u016d\3\2\2\2\u0172\u016e\3\2\2\2\u0172\u016f\3\2\2\2\u0172"+
15797                "\u0170\3\2\2\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2"+
15798                "\2\2\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2\u0177"+
15799                "\u0178\5\20\t\2\u0178\23\3\2\2\2\u0179\u017a\7\7\2\2\u017a\u0181\7>\2"+
15800                "\2\u017b\u0180\5\n\6\2\u017c\u0180\7\b\2\2\u017d\u0180\7\3\2\2\u017e\u0180"+
15801                "\7\6\2\2\u017f\u017b\3\2\2\2\u017f\u017c\3\2\2\2\u017f\u017d\3\2\2\2\u017f"+
15802                "\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2"+
15803                "\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0185\79\2\2\u0185"+
15804                "\25\3\2\2\2\u0186\u0187\7\7\2\2\u0187\u0188\7;\2\2\u0188\u018c\7>\2\2"+
15805                "\u0189\u018b\t\2\2\2\u018a\u0189\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a"+
15806                "\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f"+
15807                "\u0190\79\2\2\u0190\27\3\2\2\2\u0191\u01b9\5\24\13\2\u0192\u01b8\5\f\7"+
15808                "\2\u0193\u01b8\5j\66\2\u0194\u01b8\5\22\n\2\u0195\u01b8\5\36\20\2\u0196"+
15809                "\u01b8\5$\23\2\u0197\u01b8\5*\26\2\u0198\u01b8\5\60\31\2\u0199\u01b8\5"+
15810                "\66\34\2\u019a\u01b8\5<\37\2\u019b\u01b8\5B\"\2\u019c\u01b8\5H%\2\u019d"+
15811                "\u01b8\5N(\2\u019e\u01b8\5T+\2\u019f\u01b8\5Z.\2\u01a0\u01b8\5f\64\2\u01a1"+
15812                "\u01b8\5`\61\2\u01a2\u01b8\5\16\b\2\u01a3\u01b8\5\32\16\2\u01a4\u01b8"+
15813                "\5 \21\2\u01a5\u01b8\5&\24\2\u01a6\u01b8\5,\27\2\u01a7\u01b8\5\62\32\2"+
15814                "\u01a8\u01b8\58\35\2\u01a9\u01b8\5> \2\u01aa\u01b8\5D#\2\u01ab\u01b8\5"+
15815                "J&\2\u01ac\u01b8\5P)\2\u01ad\u01b8\5V,\2\u01ae\u01b8\5b\62\2\u01af\u01b8"+
15816                "\5\\/\2\u01b0\u01b1\6\r\6\2\u01b1\u01b8\7\3\2\2\u01b2\u01b8\5\u0094K\2"+
15817                "\u01b3\u01b8\7\5\2\2\u01b4\u01b8\7\b\2\2\u01b5\u01b8\5\u0096L\2\u01b6"+
15818                "\u01b8\5\u0092J\2\u01b7\u0192\3\2\2\2\u01b7\u0193\3\2\2\2\u01b7\u0194"+
15819                "\3\2\2\2\u01b7\u0195\3\2\2\2\u01b7\u0196\3\2\2\2\u01b7\u0197\3\2\2\2\u01b7"+
15820                "\u0198\3\2\2\2\u01b7\u0199\3\2\2\2\u01b7\u019a\3\2\2\2\u01b7\u019b\3\2"+
15821                "\2\2\u01b7\u019c\3\2\2\2\u01b7\u019d\3\2\2\2\u01b7\u019e\3\2\2\2\u01b7"+
15822                "\u019f\3\2\2\2\u01b7\u01a0\3\2\2\2\u01b7\u01a1\3\2\2\2\u01b7\u01a2\3\2"+
15823                "\2\2\u01b7\u01a3\3\2\2\2\u01b7\u01a4\3\2\2\2\u01b7\u01a5\3\2\2\2\u01b7"+
15824                "\u01a6\3\2\2\2\u01b7\u01a7\3\2\2\2\u01b7\u01a8\3\2\2\2\u01b7\u01a9\3\2"+
15825                "\2\2\u01b7\u01aa\3\2\2\2\u01b7\u01ab\3\2\2\2\u01b7\u01ac\3\2\2\2\u01b7"+
15826                "\u01ad\3\2\2\2\u01b7\u01ae\3\2\2\2\u01b7\u01af\3\2\2\2\u01b7\u01b0\3\2"+
15827                "\2\2\u01b7\u01b2\3\2\2\2\u01b7\u01b3\3\2\2\2\u01b7\u01b4\3\2\2\2\u01b7"+
15828                "\u01b5\3\2\2\2\u01b7\u01b6\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9\u01b7\3\2"+
15829                "\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bc"+
15830                "\u01bd\5\26\f\2\u01bd\31\3\2\2\2\u01be\u01bf\7\7\2\2\u01bf\u01c6\7?\2"+
15831                "\2\u01c0\u01c5\5\n\6\2\u01c1\u01c5\7\b\2\2\u01c2\u01c5\7\3\2\2\u01c3\u01c5"+
15832                "\7\6\2\2\u01c4\u01c0\3\2\2\2\u01c4\u01c1\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c4"+
15833                "\u01c3\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2"+
15834                "\2\2\u01c7\u01c9\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01ca\79\2\2\u01ca"+
15835                "\33\3\2\2\2\u01cb\u01cc\7\7\2\2\u01cc\u01cd\7;\2\2\u01cd\u01d1\7?\2\2"+
15836                "\u01ce\u01d0\t\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf"+
15837                "\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d4\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4"+
15838                "\u01d5\79\2\2\u01d5\35\3\2\2\2\u01d6\u01fe\5\32\16\2\u01d7\u01fd\5\f\7"+
15839                "\2\u01d8\u01fd\5j\66\2\u01d9\u01fd\5\22\n\2\u01da\u01fd\5\30\r\2\u01db"+
15840                "\u01fd\5$\23\2\u01dc\u01fd\5*\26\2\u01dd\u01fd\5\60\31\2\u01de\u01fd\5"+
15841                "\66\34\2\u01df\u01fd\5<\37\2\u01e0\u01fd\5B\"\2\u01e1\u01fd\5H%\2\u01e2"+
15842                "\u01fd\5N(\2\u01e3\u01fd\5T+\2\u01e4\u01fd\5Z.\2\u01e5\u01fd\5f\64\2\u01e6"+
15843                "\u01fd\5`\61\2\u01e7\u01fd\5\16\b\2\u01e8\u01fd\5\24\13\2\u01e9\u01fd"+
15844                "\5 \21\2\u01ea\u01fd\5&\24\2\u01eb\u01fd\5,\27\2\u01ec\u01fd\5\62\32\2"+
15845                "\u01ed\u01fd\58\35\2\u01ee\u01fd\5> \2\u01ef\u01fd\5D#\2\u01f0\u01fd\5"+
15846                "J&\2\u01f1\u01fd\5P)\2\u01f2\u01fd\5V,\2\u01f3\u01fd\5b\62\2\u01f4\u01fd"+
15847                "\5\\/\2\u01f5\u01f6\6\20\7\2\u01f6\u01fd\7\3\2\2\u01f7\u01fd\5\u0094K"+
15848                "\2\u01f8\u01fd\7\5\2\2\u01f9\u01fd\7\b\2\2\u01fa\u01fd\5\u0096L\2\u01fb"+
15849                "\u01fd\5\u0092J\2\u01fc\u01d7\3\2\2\2\u01fc\u01d8\3\2\2\2\u01fc\u01d9"+
15850                "\3\2\2\2\u01fc\u01da\3\2\2\2\u01fc\u01db\3\2\2\2\u01fc\u01dc\3\2\2\2\u01fc"+
15851                "\u01dd\3\2\2\2\u01fc\u01de\3\2\2\2\u01fc\u01df\3\2\2\2\u01fc\u01e0\3\2"+
15852                "\2\2\u01fc\u01e1\3\2\2\2\u01fc\u01e2\3\2\2\2\u01fc\u01e3\3\2\2\2\u01fc"+
15853                "\u01e4\3\2\2\2\u01fc\u01e5\3\2\2\2\u01fc\u01e6\3\2\2\2\u01fc\u01e7\3\2"+
15854                "\2\2\u01fc\u01e8\3\2\2\2\u01fc\u01e9\3\2\2\2\u01fc\u01ea\3\2\2\2\u01fc"+
15855                "\u01eb\3\2\2\2\u01fc\u01ec\3\2\2\2\u01fc\u01ed\3\2\2\2\u01fc\u01ee\3\2"+
15856                "\2\2\u01fc\u01ef\3\2\2\2\u01fc\u01f0\3\2\2\2\u01fc\u01f1\3\2\2\2\u01fc"+
15857                "\u01f2\3\2\2\2\u01fc\u01f3\3\2\2\2\u01fc\u01f4\3\2\2\2\u01fc\u01f5\3\2"+
15858                "\2\2\u01fc\u01f7\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fc\u01f9\3\2\2\2\u01fc"+
15859                "\u01fa\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fd\u0200\3\2\2\2\u01fe\u01fc\3\2"+
15860                "\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0201\3\2\2\2\u0200\u01fe\3\2\2\2\u0201"+
15861                "\u0202\5\34\17\2\u0202\37\3\2\2\2\u0203\u0204\7\7\2\2\u0204\u020b\7@\2"+
15862                "\2\u0205\u020a\5\n\6\2\u0206\u020a\7\b\2\2\u0207\u020a\7\3\2\2\u0208\u020a"+
15863                "\7\6\2\2\u0209\u0205\3\2\2\2\u0209\u0206\3\2\2\2\u0209\u0207\3\2\2\2\u0209"+
15864                "\u0208\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2"+
15865                "\2\2\u020c\u020e\3\2\2\2\u020d\u020b\3\2\2\2\u020e\u020f\79\2\2\u020f"+
15866                "!\3\2\2\2\u0210\u0211\7\7\2\2\u0211\u0212\7;\2\2\u0212\u0216\7@\2\2\u0213"+
15867                "\u0215\t\2\2\2\u0214\u0213\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2"+
15868                "\2\2\u0216\u0217\3\2\2\2\u0217\u0219\3\2\2\2\u0218\u0216\3\2\2\2\u0219"+
15869                "\u021a\79\2\2\u021a#\3\2\2\2\u021b\u0243\5 \21\2\u021c\u0242\5\f\7\2\u021d"+
15870                "\u0242\5j\66\2\u021e\u0242\5\22\n\2\u021f\u0242\5\30\r\2\u0220\u0242\5"+
15871                "\36\20\2\u0221\u0242\5*\26\2\u0222\u0242\5\60\31\2\u0223\u0242\5\66\34"+
15872                "\2\u0224\u0242\5<\37\2\u0225\u0242\5B\"\2\u0226\u0242\5H%\2\u0227\u0242"+
15873                "\5N(\2\u0228\u0242\5T+\2\u0229\u0242\5Z.\2\u022a\u0242\5f\64\2\u022b\u0242"+
15874                "\5`\61\2\u022c\u0242\5\16\b\2\u022d\u0242\5\24\13\2\u022e\u0242\5 \21"+
15875                "\2\u022f\u0242\5&\24\2\u0230\u0242\5,\27\2\u0231\u0242\5\62\32\2\u0232"+
15876                "\u0242\58\35\2\u0233\u0242\5> \2\u0234\u0242\5D#\2\u0235\u0242\5J&\2\u0236"+
15877                "\u0242\5P)\2\u0237\u0242\5V,\2\u0238\u0242\5b\62\2\u0239\u0242\5\\/\2"+
15878                "\u023a\u023b\6\23\b\2\u023b\u0242\7\3\2\2\u023c\u0242\5\u0094K\2\u023d"+
15879                "\u0242\7\5\2\2\u023e\u0242\7\b\2\2\u023f\u0242\5\u0096L\2\u0240\u0242"+
15880                "\5\u0092J\2\u0241\u021c\3\2\2\2\u0241\u021d\3\2\2\2\u0241\u021e\3\2\2"+
15881                "\2\u0241\u021f\3\2\2\2\u0241\u0220\3\2\2\2\u0241\u0221\3\2\2\2\u0241\u0222"+
15882                "\3\2\2\2\u0241\u0223\3\2\2\2\u0241\u0224\3\2\2\2\u0241\u0225\3\2\2\2\u0241"+
15883                "\u0226\3\2\2\2\u0241\u0227\3\2\2\2\u0241\u0228\3\2\2\2\u0241\u0229\3\2"+
15884                "\2\2\u0241\u022a\3\2\2\2\u0241\u022b\3\2\2\2\u0241\u022c\3\2\2\2\u0241"+
15885                "\u022d\3\2\2\2\u0241\u022e\3\2\2\2\u0241\u022f\3\2\2\2\u0241\u0230\3\2"+
15886                "\2\2\u0241\u0231\3\2\2\2\u0241\u0232\3\2\2\2\u0241\u0233\3\2\2\2\u0241"+
15887                "\u0234\3\2\2\2\u0241\u0235\3\2\2\2\u0241\u0236\3\2\2\2\u0241\u0237\3\2"+
15888                "\2\2\u0241\u0238\3\2\2\2\u0241\u0239\3\2\2\2\u0241\u023a\3\2\2\2\u0241"+
15889                "\u023c\3\2\2\2\u0241\u023d\3\2\2\2\u0241\u023e\3\2\2\2\u0241\u023f\3\2"+
15890                "\2\2\u0241\u0240\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243"+
15891                "\u0244\3\2\2\2\u0244\u0246\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\5\""+
15892                "\22\2\u0247%\3\2\2\2\u0248\u0249\7\7\2\2\u0249\u0250\7A\2\2\u024a\u024f"+
15893                "\5\n\6\2\u024b\u024f\7\b\2\2\u024c\u024f\7\3\2\2\u024d\u024f\7\6\2\2\u024e"+
15894                "\u024a\3\2\2\2\u024e\u024b\3\2\2\2\u024e\u024c\3\2\2\2\u024e\u024d\3\2"+
15895                "\2\2\u024f\u0252\3\2\2\2\u0250\u024e\3\2\2\2\u0250\u0251\3\2\2\2\u0251"+
15896                "\u0253\3\2\2\2\u0252\u0250\3\2\2\2\u0253\u0254\79\2\2\u0254\'\3\2\2\2"+
15897                "\u0255\u0256\7\7\2\2\u0256\u0257\7;\2\2\u0257\u025b\7A\2\2\u0258\u025a"+
15898                "\t\2\2\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2\2\u025b"+
15899                "\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f\79"+
15900                "\2\2\u025f)\3\2\2\2\u0260\u0288\5&\24\2\u0261\u0287\5\f\7\2\u0262\u0287"+
15901                "\5j\66\2\u0263\u0287\5\22\n\2\u0264\u0287\5\30\r\2\u0265\u0287\5\36\20"+
15902                "\2\u0266\u0287\5$\23\2\u0267\u0287\5\60\31\2\u0268\u0287\5\66\34\2\u0269"+
15903                "\u0287\5<\37\2\u026a\u0287\5B\"\2\u026b\u0287\5H%\2\u026c\u0287\5N(\2"+
15904                "\u026d\u0287\5T+\2\u026e\u0287\5Z.\2\u026f\u0287\5f\64\2\u0270\u0287\5"+
15905                "`\61\2\u0271\u0287\5\16\b\2\u0272\u0287\5\24\13\2\u0273\u0287\5\32\16"+
15906                "\2\u0274\u0287\5 \21\2\u0275\u0287\5,\27\2\u0276\u0287\5\62\32\2\u0277"+
15907                "\u0287\58\35\2\u0278\u0287\5> \2\u0279\u0287\5D#\2\u027a\u0287\5J&\2\u027b"+
15908                "\u0287\5P)\2\u027c\u0287\5V,\2\u027d\u0287\5b\62\2\u027e\u0287\5\\/\2"+
15909                "\u027f\u0280\6\26\t\2\u0280\u0287\7\3\2\2\u0281\u0287\5\u0094K\2\u0282"+
15910                "\u0287\7\5\2\2\u0283\u0287\7\b\2\2\u0284\u0287\5\u0096L\2\u0285\u0287"+
15911                "\5\u0092J\2\u0286\u0261\3\2\2\2\u0286\u0262\3\2\2\2\u0286\u0263\3\2\2"+
15912                "\2\u0286\u0264\3\2\2\2\u0286\u0265\3\2\2\2\u0286\u0266\3\2\2\2\u0286\u0267"+
15913                "\3\2\2\2\u0286\u0268\3\2\2\2\u0286\u0269\3\2\2\2\u0286\u026a\3\2\2\2\u0286"+
15914                "\u026b\3\2\2\2\u0286\u026c\3\2\2\2\u0286\u026d\3\2\2\2\u0286\u026e\3\2"+
15915                "\2\2\u0286\u026f\3\2\2\2\u0286\u0270\3\2\2\2\u0286\u0271\3\2\2\2\u0286"+
15916                "\u0272\3\2\2\2\u0286\u0273\3\2\2\2\u0286\u0274\3\2\2\2\u0286\u0275\3\2"+
15917                "\2\2\u0286\u0276\3\2\2\2\u0286\u0277\3\2\2\2\u0286\u0278\3\2\2\2\u0286"+
15918                "\u0279\3\2\2\2\u0286\u027a\3\2\2\2\u0286\u027b\3\2\2\2\u0286\u027c\3\2"+
15919                "\2\2\u0286\u027d\3\2\2\2\u0286\u027e\3\2\2\2\u0286\u027f\3\2\2\2\u0286"+
15920                "\u0281\3\2\2\2\u0286\u0282\3\2\2\2\u0286\u0283\3\2\2\2\u0286\u0284\3\2"+
15921                "\2\2\u0286\u0285\3\2\2\2\u0287\u028a\3\2\2\2\u0288\u0286\3\2\2\2\u0288"+
15922                "\u0289\3\2\2\2\u0289\u028b\3\2\2\2\u028a\u0288\3\2\2\2\u028b\u028c\5("+
15923                "\25\2\u028c+\3\2\2\2\u028d\u028e\7\7\2\2\u028e\u0295\7B\2\2\u028f\u0294"+
15924                "\5\n\6\2\u0290\u0294\7\b\2\2\u0291\u0294\7\3\2\2\u0292\u0294\7\6\2\2\u0293"+
15925                "\u028f\3\2\2\2\u0293\u0290\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0292\3\2"+
15926                "\2\2\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296"+
15927                "\u0298\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u0299\79\2\2\u0299-\3\2\2\2\u029a"+
15928                "\u029b\7\7\2\2\u029b\u029c\7;\2\2\u029c\u02a0\7B\2\2\u029d\u029f\t\2\2"+
15929                "\2\u029e\u029d\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0\u029e\3\2\2\2\u02a0\u02a1"+
15930                "\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a3\u02a4\79\2\2\u02a4"+
15931                "/\3\2\2\2\u02a5\u02cd\5,\27\2\u02a6\u02cc\5\f\7\2\u02a7\u02cc\5j\66\2"+
15932                "\u02a8\u02cc\5\22\n\2\u02a9\u02cc\5\30\r\2\u02aa\u02cc\5\36\20\2\u02ab"+
15933                "\u02cc\5$\23\2\u02ac\u02cc\5*\26\2\u02ad\u02cc\5\66\34\2\u02ae\u02cc\5"+
15934                "<\37\2\u02af\u02cc\5B\"\2\u02b0\u02cc\5H%\2\u02b1\u02cc\5N(\2\u02b2\u02cc"+
15935                "\5T+\2\u02b3\u02cc\5Z.\2\u02b4\u02cc\5f\64\2\u02b5\u02cc\5`\61\2\u02b6"+
15936                "\u02cc\5\16\b\2\u02b7\u02cc\5\24\13\2\u02b8\u02cc\5\32\16\2\u02b9\u02cc"+
15937                "\5 \21\2\u02ba\u02cc\5&\24\2\u02bb\u02cc\5\62\32\2\u02bc\u02cc\58\35\2"+
15938                "\u02bd\u02cc\5> \2\u02be\u02cc\5D#\2\u02bf\u02cc\5J&\2\u02c0\u02cc\5P"+
15939                ")\2\u02c1\u02cc\5V,\2\u02c2\u02cc\5b\62\2\u02c3\u02cc\5\\/\2\u02c4\u02c5"+
15940                "\6\31\n\2\u02c5\u02cc\7\3\2\2\u02c6\u02cc\5\u0094K\2\u02c7\u02cc\7\5\2"+
15941                "\2\u02c8\u02cc\7\b\2\2\u02c9\u02cc\5\u0096L\2\u02ca\u02cc\5\u0092J\2\u02cb"+
15942                "\u02a6\3\2\2\2\u02cb\u02a7\3\2\2\2\u02cb\u02a8\3\2\2\2\u02cb\u02a9\3\2"+
15943                "\2\2\u02cb\u02aa\3\2\2\2\u02cb\u02ab\3\2\2\2\u02cb\u02ac\3\2\2\2\u02cb"+
15944                "\u02ad\3\2\2\2\u02cb\u02ae\3\2\2\2\u02cb\u02af\3\2\2\2\u02cb\u02b0\3\2"+
15945                "\2\2\u02cb\u02b1\3\2\2\2\u02cb\u02b2\3\2\2\2\u02cb\u02b3\3\2\2\2\u02cb"+
15946                "\u02b4\3\2\2\2\u02cb\u02b5\3\2\2\2\u02cb\u02b6\3\2\2\2\u02cb\u02b7\3\2"+
15947                "\2\2\u02cb\u02b8\3\2\2\2\u02cb\u02b9\3\2\2\2\u02cb\u02ba\3\2\2\2\u02cb"+
15948                "\u02bb\3\2\2\2\u02cb\u02bc\3\2\2\2\u02cb\u02bd\3\2\2\2\u02cb\u02be\3\2"+
15949                "\2\2\u02cb\u02bf\3\2\2\2\u02cb\u02c0\3\2\2\2\u02cb\u02c1\3\2\2\2\u02cb"+
15950                "\u02c2\3\2\2\2\u02cb\u02c3\3\2\2\2\u02cb\u02c4\3\2\2\2\u02cb\u02c6\3\2"+
15951                "\2\2\u02cb\u02c7\3\2\2\2\u02cb\u02c8\3\2\2\2\u02cb\u02c9\3\2\2\2\u02cb"+
15952                "\u02ca\3\2\2\2\u02cc\u02cf\3\2\2\2\u02cd\u02cb\3\2\2\2\u02cd\u02ce\3\2"+
15953                "\2\2\u02ce\u02d0\3\2\2\2\u02cf\u02cd\3\2\2\2\u02d0\u02d1\5.\30\2\u02d1"+
15954                "\61\3\2\2\2\u02d2\u02d3\7\7\2\2\u02d3\u02da\7C\2\2\u02d4\u02d9\5\n\6\2"+
15955                "\u02d5\u02d9\7\b\2\2\u02d6\u02d9\7\3\2\2\u02d7\u02d9\7\6\2\2\u02d8\u02d4"+
15956                "\3\2\2\2\u02d8\u02d5\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d8\u02d7\3\2\2\2\u02d9"+
15957                "\u02dc\3\2\2\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\3\2"+
15958                "\2\2\u02dc\u02da\3\2\2\2\u02dd\u02de\79\2\2\u02de\63\3\2\2\2\u02df\u02e0"+
15959                "\7\7\2\2\u02e0\u02e1\7;\2\2\u02e1\u02e5\7C\2\2\u02e2\u02e4\t\2\2\2\u02e3"+
15960                "\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5\u02e6\3\2"+
15961                "\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\79\2\2\u02e9"+
15962                "\65\3\2\2\2\u02ea\u0312\5\62\32\2\u02eb\u0311\5\f\7\2\u02ec\u0311\5j\66"+
15963                "\2\u02ed\u0311\5\22\n\2\u02ee\u0311\5\30\r\2\u02ef\u0311\5\36\20\2\u02f0"+
15964                "\u0311\5$\23\2\u02f1\u0311\5*\26\2\u02f2\u0311\5\60\31\2\u02f3\u0311\5"+
15965                "<\37\2\u02f4\u0311\5B\"\2\u02f5\u0311\5H%\2\u02f6\u0311\5N(\2\u02f7\u0311"+
15966                "\5T+\2\u02f8\u0311\5Z.\2\u02f9\u0311\5f\64\2\u02fa\u0311\5`\61\2\u02fb"+
15967                "\u0311\5\16\b\2\u02fc\u0311\5\24\13\2\u02fd\u0311\5\32\16\2\u02fe\u0311"+
15968                "\5 \21\2\u02ff\u0311\5&\24\2\u0300\u0311\5,\27\2\u0301\u0311\58\35\2\u0302"+
15969                "\u0311\5> \2\u0303\u0311\5D#\2\u0304\u0311\5J&\2\u0305\u0311\5P)\2\u0306"+
15970                "\u0311\5V,\2\u0307\u0311\5b\62\2\u0308\u0311\5\\/\2\u0309\u030a\6\34\13"+
15971                "\2\u030a\u0311\7\3\2\2\u030b\u0311\5\u0094K\2\u030c\u0311\7\5\2\2\u030d"+
15972                "\u0311\7\b\2\2\u030e\u0311\5\u0096L\2\u030f\u0311\5\u0092J\2\u0310\u02eb"+
15973                "\3\2\2\2\u0310\u02ec\3\2\2\2\u0310\u02ed\3\2\2\2\u0310\u02ee\3\2\2\2\u0310"+
15974                "\u02ef\3\2\2\2\u0310\u02f0\3\2\2\2\u0310\u02f1\3\2\2\2\u0310\u02f2\3\2"+
15975                "\2\2\u0310\u02f3\3\2\2\2\u0310\u02f4\3\2\2\2\u0310\u02f5\3\2\2\2\u0310"+
15976                "\u02f6\3\2\2\2\u0310\u02f7\3\2\2\2\u0310\u02f8\3\2\2\2\u0310\u02f9\3\2"+
15977                "\2\2\u0310\u02fa\3\2\2\2\u0310\u02fb\3\2\2\2\u0310\u02fc\3\2\2\2\u0310"+
15978                "\u02fd\3\2\2\2\u0310\u02fe\3\2\2\2\u0310\u02ff\3\2\2\2\u0310\u0300\3\2"+
15979                "\2\2\u0310\u0301\3\2\2\2\u0310\u0302\3\2\2\2\u0310\u0303\3\2\2\2\u0310"+
15980                "\u0304\3\2\2\2\u0310\u0305\3\2\2\2\u0310\u0306\3\2\2\2\u0310\u0307\3\2"+
15981                "\2\2\u0310\u0308\3\2\2\2\u0310\u0309\3\2\2\2\u0310\u030b\3\2\2\2\u0310"+
15982                "\u030c\3\2\2\2\u0310\u030d\3\2\2\2\u0310\u030e\3\2\2\2\u0310\u030f\3\2"+
15983                "\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+
15984                "\u0315\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0316\5\64\33\2\u0316\67\3\2"+
15985                "\2\2\u0317\u0318\7\7\2\2\u0318\u031f\7D\2\2\u0319\u031e\5\n\6\2\u031a"+
15986                "\u031e\7\b\2\2\u031b\u031e\7\3\2\2\u031c\u031e\7\6\2\2\u031d\u0319\3\2"+
15987                "\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031c\3\2\2\2\u031e"+
15988                "\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0322\3\2"+
15989                "\2\2\u0321\u031f\3\2\2\2\u0322\u0323\79\2\2\u03239\3\2\2\2\u0324\u0325"+
15990                "\7\7\2\2\u0325\u0326\7;\2\2\u0326\u032a\7D\2\2\u0327\u0329\t\2\2\2\u0328"+
15991                "\u0327\3\2\2\2\u0329\u032c\3\2\2\2\u032a\u0328\3\2\2\2\u032a\u032b\3\2"+
15992                "\2\2\u032b\u032d\3\2\2\2\u032c\u032a\3\2\2\2\u032d\u032e\79\2\2\u032e"+
15993                ";\3\2\2\2\u032f\u0357\58\35\2\u0330\u0356\5\f\7\2\u0331\u0356\5j\66\2"+
15994                "\u0332\u0356\5\22\n\2\u0333\u0356\5\30\r\2\u0334\u0356\5\36\20\2\u0335"+
15995                "\u0356\5$\23\2\u0336\u0356\5*\26\2\u0337\u0356\5\60\31\2\u0338\u0356\5"+
15996                "\66\34\2\u0339\u0356\5B\"\2\u033a\u0356\5H%\2\u033b\u0356\5N(\2\u033c"+
15997                "\u0356\5T+\2\u033d\u0356\5Z.\2\u033e\u0356\5f\64\2\u033f\u0356\5`\61\2"+
15998                "\u0340\u0356\5\16\b\2\u0341\u0356\5\24\13\2\u0342\u0356\5\32\16\2\u0343"+
15999                "\u0356\5 \21\2\u0344\u0356\5&\24\2\u0345\u0356\5,\27\2\u0346\u0356\5\62"+
16000                "\32\2\u0347\u0356\5> \2\u0348\u0356\5D#\2\u0349\u0356\5J&\2\u034a\u0356"+
16001                "\5P)\2\u034b\u0356\5V,\2\u034c\u0356\5b\62\2\u034d\u0356\5\\/\2\u034e"+
16002                "\u034f\6\37\f\2\u034f\u0356\7\3\2\2\u0350\u0356\5\u0094K\2\u0351\u0356"+
16003                "\7\5\2\2\u0352\u0356\7\b\2\2\u0353\u0356\5\u0096L\2\u0354\u0356\5\u0092"+
16004                "J\2\u0355\u0330\3\2\2\2\u0355\u0331\3\2\2\2\u0355\u0332\3\2\2\2\u0355"+
16005                "\u0333\3\2\2\2\u0355\u0334\3\2\2\2\u0355\u0335\3\2\2\2\u0355\u0336\3\2"+
16006                "\2\2\u0355\u0337\3\2\2\2\u0355\u0338\3\2\2\2\u0355\u0339\3\2\2\2\u0355"+
16007                "\u033a\3\2\2\2\u0355\u033b\3\2\2\2\u0355\u033c\3\2\2\2\u0355\u033d\3\2"+
16008                "\2\2\u0355\u033e\3\2\2\2\u0355\u033f\3\2\2\2\u0355\u0340\3\2\2\2\u0355"+
16009                "\u0341\3\2\2\2\u0355\u0342\3\2\2\2\u0355\u0343\3\2\2\2\u0355\u0344\3\2"+
16010                "\2\2\u0355\u0345\3\2\2\2\u0355\u0346\3\2\2\2\u0355\u0347\3\2\2\2\u0355"+
16011                "\u0348\3\2\2\2\u0355\u0349\3\2\2\2\u0355\u034a\3\2\2\2\u0355\u034b\3\2"+
16012                "\2\2\u0355\u034c\3\2\2\2\u0355\u034d\3\2\2\2\u0355\u034e\3\2\2\2\u0355"+
16013                "\u0350\3\2\2\2\u0355\u0351\3\2\2\2\u0355\u0352\3\2\2\2\u0355\u0353\3\2"+
16014                "\2\2\u0355\u0354\3\2\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357"+
16015                "\u0358\3\2\2\2\u0358\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\5:"+
16016                "\36\2\u035b=\3\2\2\2\u035c\u035d\7\7\2\2\u035d\u0364\7E\2\2\u035e\u0363"+
16017                "\5\n\6\2\u035f\u0363\7\b\2\2\u0360\u0363\7\3\2\2\u0361\u0363\7\6\2\2\u0362"+
16018                "\u035e\3\2\2\2\u0362\u035f\3\2\2\2\u0362\u0360\3\2\2\2\u0362\u0361\3\2"+
16019                "\2\2\u0363\u0366\3\2\2\2\u0364\u0362\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+
16020                "\u0367\3\2\2\2\u0366\u0364\3\2\2\2\u0367\u0368\79\2\2\u0368?\3\2\2\2\u0369"+
16021                "\u036a\7\7\2\2\u036a\u036b\7;\2\2\u036b\u036f\7E\2\2\u036c\u036e\t\2\2"+
16022                "\2\u036d\u036c\3\2\2\2\u036e\u0371\3\2\2\2\u036f\u036d\3\2\2\2\u036f\u0370"+
16023                "\3\2\2\2\u0370\u0372\3\2\2\2\u0371\u036f\3\2\2\2\u0372\u0373\79\2\2\u0373"+
16024                "A\3\2\2\2\u0374\u039c\5> \2\u0375\u039b\5\f\7\2\u0376\u039b\5j\66\2\u0377"+
16025                "\u039b\5\22\n\2\u0378\u039b\5\30\r\2\u0379\u039b\5\36\20\2\u037a\u039b"+
16026                "\5$\23\2\u037b\u039b\5*\26\2\u037c\u039b\5\60\31\2\u037d\u039b\5\66\34"+
16027                "\2\u037e\u039b\5<\37\2\u037f\u039b\5H%\2\u0380\u039b\5N(\2\u0381\u039b"+
16028                "\5T+\2\u0382\u039b\5Z.\2\u0383\u039b\5f\64\2\u0384\u039b\5`\61\2\u0385"+
16029                "\u039b\5\16\b\2\u0386\u039b\5\24\13\2\u0387\u039b\5\32\16\2\u0388\u039b"+
16030                "\5 \21\2\u0389\u039b\5&\24\2\u038a\u039b\5,\27\2\u038b\u039b\5\62\32\2"+
16031                "\u038c\u039b\58\35\2\u038d\u039b\5D#\2\u038e\u039b\5J&\2\u038f\u039b\5"+
16032                "P)\2\u0390\u039b\5V,\2\u0391\u039b\5b\62\2\u0392\u039b\5\\/\2\u0393\u0394"+
16033                "\6\"\r\2\u0394\u039b\7\3\2\2\u0395\u039b\5\u0094K\2\u0396\u039b\7\5\2"+
16034                "\2\u0397\u039b\7\b\2\2\u0398\u039b\5\u0096L\2\u0399\u039b\5\u0092J\2\u039a"+
16035                "\u0375\3\2\2\2\u039a\u0376\3\2\2\2\u039a\u0377\3\2\2\2\u039a\u0378\3\2"+
16036                "\2\2\u039a\u0379\3\2\2\2\u039a\u037a\3\2\2\2\u039a\u037b\3\2\2\2\u039a"+
16037                "\u037c\3\2\2\2\u039a\u037d\3\2\2\2\u039a\u037e\3\2\2\2\u039a\u037f\3\2"+
16038                "\2\2\u039a\u0380\3\2\2\2\u039a\u0381\3\2\2\2\u039a\u0382\3\2\2\2\u039a"+
16039                "\u0383\3\2\2\2\u039a\u0384\3\2\2\2\u039a\u0385\3\2\2\2\u039a\u0386\3\2"+
16040                "\2\2\u039a\u0387\3\2\2\2\u039a\u0388\3\2\2\2\u039a\u0389\3\2\2\2\u039a"+
16041                "\u038a\3\2\2\2\u039a\u038b\3\2\2\2\u039a\u038c\3\2\2\2\u039a\u038d\3\2"+
16042                "\2\2\u039a\u038e\3\2\2\2\u039a\u038f\3\2\2\2\u039a\u0390\3\2\2\2\u039a"+
16043                "\u0391\3\2\2\2\u039a\u0392\3\2\2\2\u039a\u0393\3\2\2\2\u039a\u0395\3\2"+
16044                "\2\2\u039a\u0396\3\2\2\2\u039a\u0397\3\2\2\2\u039a\u0398\3\2\2\2\u039a"+
16045                "\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2"+
16046                "\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a0\5@!\2\u03a0C"+
16047                "\3\2\2\2\u03a1\u03a2\7\7\2\2\u03a2\u03a9\7F\2\2\u03a3\u03a8\5\n\6\2\u03a4"+
16048                "\u03a8\7\b\2\2\u03a5\u03a8\7\3\2\2\u03a6\u03a8\7\6\2\2\u03a7\u03a3\3\2"+
16049                "\2\2\u03a7\u03a4\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a6\3\2\2\2\u03a8"+
16050                "\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa\u03ac\3\2"+
16051                "\2\2\u03ab\u03a9\3\2\2\2\u03ac\u03ad\79\2\2\u03adE\3\2\2\2\u03ae\u03af"+
16052                "\7\7\2\2\u03af\u03b0\7;\2\2\u03b0\u03b4\7F\2\2\u03b1\u03b3\t\2\2\2\u03b2"+
16053                "\u03b1\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2"+
16054                "\2\2\u03b5\u03b7\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03b8\79\2\2\u03b8"+
16055                "G\3\2\2\2\u03b9\u03e1\5D#\2\u03ba\u03e0\5\f\7\2\u03bb\u03e0\5j\66\2\u03bc"+
16056                "\u03e0\5\22\n\2\u03bd\u03e0\5\30\r\2\u03be\u03e0\5\36\20\2\u03bf\u03e0"+
16057                "\5$\23\2\u03c0\u03e0\5*\26\2\u03c1\u03e0\5\60\31\2\u03c2\u03e0\5\66\34"+
16058                "\2\u03c3\u03e0\5<\37\2\u03c4\u03e0\5B\"\2\u03c5\u03e0\5N(\2\u03c6\u03e0"+
16059                "\5T+\2\u03c7\u03e0\5Z.\2\u03c8\u03e0\5f\64\2\u03c9\u03e0\5`\61\2\u03ca"+
16060                "\u03e0\5\16\b\2\u03cb\u03e0\5\24\13\2\u03cc\u03e0\5\32\16\2\u03cd\u03e0"+
16061                "\5 \21\2\u03ce\u03e0\5&\24\2\u03cf\u03e0\5,\27\2\u03d0\u03e0\5\62\32\2"+
16062                "\u03d1\u03e0\58\35\2\u03d2\u03e0\5> \2\u03d3\u03e0\5J&\2\u03d4\u03e0\5"+
16063                "P)\2\u03d5\u03e0\5V,\2\u03d6\u03e0\5b\62\2\u03d7\u03e0\5\\/\2\u03d8\u03d9"+
16064                "\6%\16\2\u03d9\u03e0\7\3\2\2\u03da\u03e0\5\u0094K\2\u03db\u03e0\7\5\2"+
16065                "\2\u03dc\u03e0\7\b\2\2\u03dd\u03e0\5\u0096L\2\u03de\u03e0\5\u0092J\2\u03df"+
16066                "\u03ba\3\2\2\2\u03df\u03bb\3\2\2\2\u03df\u03bc\3\2\2\2\u03df\u03bd\3\2"+
16067                "\2\2\u03df\u03be\3\2\2\2\u03df\u03bf\3\2\2\2\u03df\u03c0\3\2\2\2\u03df"+
16068                "\u03c1\3\2\2\2\u03df\u03c2\3\2\2\2\u03df\u03c3\3\2\2\2\u03df\u03c4\3\2"+
16069                "\2\2\u03df\u03c5\3\2\2\2\u03df\u03c6\3\2\2\2\u03df\u03c7\3\2\2\2\u03df"+
16070                "\u03c8\3\2\2\2\u03df\u03c9\3\2\2\2\u03df\u03ca\3\2\2\2\u03df\u03cb\3\2"+
16071                "\2\2\u03df\u03cc\3\2\2\2\u03df\u03cd\3\2\2\2\u03df\u03ce\3\2\2\2\u03df"+
16072                "\u03cf\3\2\2\2\u03df\u03d0\3\2\2\2\u03df\u03d1\3\2\2\2\u03df\u03d2\3\2"+
16073                "\2\2\u03df\u03d3\3\2\2\2\u03df\u03d4\3\2\2\2\u03df\u03d5\3\2\2\2\u03df"+
16074                "\u03d6\3\2\2\2\u03df\u03d7\3\2\2\2\u03df\u03d8\3\2\2\2\u03df\u03da\3\2"+
16075                "\2\2\u03df\u03db\3\2\2\2\u03df\u03dc\3\2\2\2\u03df\u03dd\3\2\2\2\u03df"+
16076                "\u03de\3\2\2\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2"+
16077                "\2\2\u03e2\u03e4\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5F$\2\u03e5I"+
16078                "\3\2\2\2\u03e6\u03e7\7\7\2\2\u03e7\u03ee\7G\2\2\u03e8\u03ed\5\n\6\2\u03e9"+
16079                "\u03ed\7\b\2\2\u03ea\u03ed\7\3\2\2\u03eb\u03ed\7\6\2\2\u03ec\u03e8\3\2"+
16080                "\2\2\u03ec\u03e9\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03eb\3\2\2\2\u03ed"+
16081                "\u03f0\3\2\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f1\3\2"+
16082                "\2\2\u03f0\u03ee\3\2\2\2\u03f1\u03f2\79\2\2\u03f2K\3\2\2\2\u03f3\u03f4"+
16083                "\7\7\2\2\u03f4\u03f5\7;\2\2\u03f5\u03f9\7G\2\2\u03f6\u03f8\t\2\2\2\u03f7"+
16084                "\u03f6\3\2\2\2\u03f8\u03fb\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2"+
16085                "\2\2\u03fa\u03fc\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u03fd\79\2\2\u03fd"+
16086                "M\3\2\2\2\u03fe\u0426\5J&\2\u03ff\u0425\5\f\7\2\u0400\u0425\5j\66\2\u0401"+
16087                "\u0425\5\22\n\2\u0402\u0425\5\30\r\2\u0403\u0425\5\36\20\2\u0404\u0425"+
16088                "\5$\23\2\u0405\u0425\5*\26\2\u0406\u0425\5\60\31\2\u0407\u0425\5\66\34"+
16089                "\2\u0408\u0425\5<\37\2\u0409\u0425\5B\"\2\u040a\u0425\5H%\2\u040b\u0425"+
16090                "\5T+\2\u040c\u0425\5Z.\2\u040d\u0425\5f\64\2\u040e\u0425\5`\61\2\u040f"+
16091                "\u0425\5\16\b\2\u0410\u0425\5\24\13\2\u0411\u0425\5\32\16\2\u0412\u0425"+
16092                "\5 \21\2\u0413\u0425\5&\24\2\u0414\u0425\5,\27\2\u0415\u0425\5\62\32\2"+
16093                "\u0416\u0425\58\35\2\u0417\u0425\5> \2\u0418\u0425\5D#\2\u0419\u0425\5"+
16094                "P)\2\u041a\u0425\5V,\2\u041b\u0425\5b\62\2\u041c\u0425\5\\/\2\u041d\u041e"+
16095                "\6(\17\2\u041e\u0425\7\3\2\2\u041f\u0425\5\u0094K\2\u0420\u0425\7\5\2"+
16096                "\2\u0421\u0425\7\b\2\2\u0422\u0425\5\u0096L\2\u0423\u0425\5\u0092J\2\u0424"+
16097                "\u03ff\3\2\2\2\u0424\u0400\3\2\2\2\u0424\u0401\3\2\2\2\u0424\u0402\3\2"+
16098                "\2\2\u0424\u0403\3\2\2\2\u0424\u0404\3\2\2\2\u0424\u0405\3\2\2\2\u0424"+
16099                "\u0406\3\2\2\2\u0424\u0407\3\2\2\2\u0424\u0408\3\2\2\2\u0424\u0409\3\2"+
16100                "\2\2\u0424\u040a\3\2\2\2\u0424\u040b\3\2\2\2\u0424\u040c\3\2\2\2\u0424"+
16101                "\u040d\3\2\2\2\u0424\u040e\3\2\2\2\u0424\u040f\3\2\2\2\u0424\u0410\3\2"+
16102                "\2\2\u0424\u0411\3\2\2\2\u0424\u0412\3\2\2\2\u0424\u0413\3\2\2\2\u0424"+
16103                "\u0414\3\2\2\2\u0424\u0415\3\2\2\2\u0424\u0416\3\2\2\2\u0424\u0417\3\2"+
16104                "\2\2\u0424\u0418\3\2\2\2\u0424\u0419\3\2\2\2\u0424\u041a\3\2\2\2\u0424"+
16105                "\u041b\3\2\2\2\u0424\u041c\3\2\2\2\u0424\u041d\3\2\2\2\u0424\u041f\3\2"+
16106                "\2\2\u0424\u0420\3\2\2\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424"+
16107                "\u0423\3\2\2\2\u0425\u0428\3\2\2\2\u0426\u0424\3\2\2\2\u0426\u0427\3\2"+
16108                "\2\2\u0427\u0429\3\2\2\2\u0428\u0426\3\2\2\2\u0429\u042a\5L\'\2\u042a"+
16109                "O\3\2\2\2\u042b\u042c\7\7\2\2\u042c\u0433\7H\2\2\u042d\u0432\5\n\6\2\u042e"+
16110                "\u0432\7\b\2\2\u042f\u0432\7\3\2\2\u0430\u0432\7\6\2\2\u0431\u042d\3\2"+
16111                "\2\2\u0431\u042e\3\2\2\2\u0431\u042f\3\2\2\2\u0431\u0430\3\2\2\2\u0432"+
16112                "\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434\u0436\3\2"+
16113                "\2\2\u0435\u0433\3\2\2\2\u0436\u0437\79\2\2\u0437Q\3\2\2\2\u0438\u0439"+
16114                "\7\7\2\2\u0439\u043a\7;\2\2\u043a\u043e\7H\2\2\u043b\u043d\t\2\2\2\u043c"+
16115                "\u043b\3\2\2\2\u043d\u0440\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2"+
16116                "\2\2\u043f\u0441\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0442\79\2\2\u0442"+
16117                "S\3\2\2\2\u0443\u046b\5P)\2\u0444\u046a\5\f\7\2\u0445\u046a\5j\66\2\u0446"+
16118                "\u046a\5\22\n\2\u0447\u046a\5\30\r\2\u0448\u046a\5\36\20\2\u0449\u046a"+
16119                "\5$\23\2\u044a\u046a\5*\26\2\u044b\u046a\5\60\31\2\u044c\u046a\5\66\34"+
16120                "\2\u044d\u046a\5<\37\2\u044e\u046a\5B\"\2\u044f\u046a\5H%\2\u0450\u046a"+
16121                "\5N(\2\u0451\u046a\5Z.\2\u0452\u046a\5f\64\2\u0453\u046a\5`\61\2\u0454"+
16122                "\u046a\5\16\b\2\u0455\u046a\5\24\13\2\u0456\u046a\5\32\16\2\u0457\u046a"+
16123                "\5 \21\2\u0458\u046a\5&\24\2\u0459\u046a\5,\27\2\u045a\u046a\5\62\32\2"+
16124                "\u045b\u046a\58\35\2\u045c\u046a\5> \2\u045d\u046a\5D#\2\u045e\u046a\5"+
16125                "J&\2\u045f\u046a\5V,\2\u0460\u046a\5b\62\2\u0461\u046a\5\\/\2\u0462\u0463"+
16126                "\6+\20\2\u0463\u046a\7\3\2\2\u0464\u046a\5\u0094K\2\u0465\u046a\7\5\2"+
16127                "\2\u0466\u046a\7\b\2\2\u0467\u046a\5\u0096L\2\u0468\u046a\5\u0092J\2\u0469"+
16128                "\u0444\3\2\2\2\u0469\u0445\3\2\2\2\u0469\u0446\3\2\2\2\u0469\u0447\3\2"+
16129                "\2\2\u0469\u0448\3\2\2\2\u0469\u0449\3\2\2\2\u0469\u044a\3\2\2\2\u0469"+
16130                "\u044b\3\2\2\2\u0469\u044c\3\2\2\2\u0469\u044d\3\2\2\2\u0469\u044e\3\2"+
16131                "\2\2\u0469\u044f\3\2\2\2\u0469\u0450\3\2\2\2\u0469\u0451\3\2\2\2\u0469"+
16132                "\u0452\3\2\2\2\u0469\u0453\3\2\2\2\u0469\u0454\3\2\2\2\u0469\u0455\3\2"+
16133                "\2\2\u0469\u0456\3\2\2\2\u0469\u0457\3\2\2\2\u0469\u0458\3\2\2\2\u0469"+
16134                "\u0459\3\2\2\2\u0469\u045a\3\2\2\2\u0469\u045b\3\2\2\2\u0469\u045c\3\2"+
16135                "\2\2\u0469\u045d\3\2\2\2\u0469\u045e\3\2\2\2\u0469\u045f\3\2\2\2\u0469"+
16136                "\u0460\3\2\2\2\u0469\u0461\3\2\2\2\u0469\u0462\3\2\2\2\u0469\u0464\3\2"+
16137                "\2\2\u0469\u0465\3\2\2\2\u0469\u0466\3\2\2\2\u0469\u0467\3\2\2\2\u0469"+
16138                "\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b\u046c\3\2"+
16139                "\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u046f\5R*\2\u046fU"+
16140                "\3\2\2\2\u0470\u0471\7\7\2\2\u0471\u0478\7I\2\2\u0472\u0477\5\n\6\2\u0473"+
16141                "\u0477\7\b\2\2\u0474\u0477\7\3\2\2\u0475\u0477\7\6\2\2\u0476\u0472\3\2"+
16142                "\2\2\u0476\u0473\3\2\2\2\u0476\u0474\3\2\2\2\u0476\u0475\3\2\2\2\u0477"+
16143                "\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3\2\2\2\u0479\u047b\3\2"+
16144                "\2\2\u047a\u0478\3\2\2\2\u047b\u047c\79\2\2\u047cW\3\2\2\2\u047d\u047e"+
16145                "\7\7\2\2\u047e\u047f\7;\2\2\u047f\u0483\7I\2\2\u0480\u0482\t\2\2\2\u0481"+
16146                "\u0480\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484\3\2"+
16147                "\2\2\u0484\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0487\79\2\2\u0487"+
16148                "Y\3\2\2\2\u0488\u04b0\5V,\2\u0489\u04af\5\f\7\2\u048a\u04af\5j\66\2\u048b"+
16149                "\u04af\5\22\n\2\u048c\u04af\5\30\r\2\u048d\u04af\5\36\20\2\u048e\u04af"+
16150                "\5$\23\2\u048f\u04af\5*\26\2\u0490\u04af\5\60\31\2\u0491\u04af\5\66\34"+
16151                "\2\u0492\u04af\5<\37\2\u0493\u04af\5B\"\2\u0494\u04af\5H%\2\u0495\u04af"+
16152                "\5N(\2\u0496\u04af\5T+\2\u0497\u04af\5f\64\2\u0498\u04af\5`\61\2\u0499"+
16153                "\u04af\5\16\b\2\u049a\u04af\5\24\13\2\u049b\u04af\5\32\16\2\u049c\u04af"+
16154                "\5 \21\2\u049d\u04af\5&\24\2\u049e\u04af\5,\27\2\u049f\u04af\5\62\32\2"+
16155                "\u04a0\u04af\58\35\2\u04a1\u04af\5> \2\u04a2\u04af\5D#\2\u04a3\u04af\5"+
16156                "J&\2\u04a4\u04af\5P)\2\u04a5\u04af\5b\62\2\u04a6\u04af\5\\/\2\u04a7\u04a8"+
16157                "\6.\21\2\u04a8\u04af\7\3\2\2\u04a9\u04af\5\u0094K\2\u04aa\u04af\7\5\2"+
16158                "\2\u04ab\u04af\7\b\2\2\u04ac\u04af\5\u0096L\2\u04ad\u04af\5\u0092J\2\u04ae"+
16159                "\u0489\3\2\2\2\u04ae\u048a\3\2\2\2\u04ae\u048b\3\2\2\2\u04ae\u048c\3\2"+
16160                "\2\2\u04ae\u048d\3\2\2\2\u04ae\u048e\3\2\2\2\u04ae\u048f\3\2\2\2\u04ae"+
16161                "\u0490\3\2\2\2\u04ae\u0491\3\2\2\2\u04ae\u0492\3\2\2\2\u04ae\u0493\3\2"+
16162                "\2\2\u04ae\u0494\3\2\2\2\u04ae\u0495\3\2\2\2\u04ae\u0496\3\2\2\2\u04ae"+
16163                "\u0497\3\2\2\2\u04ae\u0498\3\2\2\2\u04ae\u0499\3\2\2\2\u04ae\u049a\3\2"+
16164                "\2\2\u04ae\u049b\3\2\2\2\u04ae\u049c\3\2\2\2\u04ae\u049d\3\2\2\2\u04ae"+
16165                "\u049e\3\2\2\2\u04ae\u049f\3\2\2\2\u04ae\u04a0\3\2\2\2\u04ae\u04a1\3\2"+
16166                "\2\2\u04ae\u04a2\3\2\2\2\u04ae\u04a3\3\2\2\2\u04ae\u04a4\3\2\2\2\u04ae"+
16167                "\u04a5\3\2\2\2\u04ae\u04a6\3\2\2\2\u04ae\u04a7\3\2\2\2\u04ae\u04a9\3\2"+
16168                "\2\2\u04ae\u04aa\3\2\2\2\u04ae\u04ab\3\2\2\2\u04ae\u04ac\3\2\2\2\u04ae"+
16169                "\u04ad\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b0\u04b1\3\2"+
16170                "\2\2\u04b1\u04b3\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3\u04b4\5X-\2\u04b4["+
16171                "\3\2\2\2\u04b5\u04b6\7\7\2\2\u04b6\u04bd\7J\2\2\u04b7\u04bc\5\n\6\2\u04b8"+
16172                "\u04bc\7\b\2\2\u04b9\u04bc\7\3\2\2\u04ba\u04bc\7\6\2\2\u04bb\u04b7\3\2"+
16173                "\2\2\u04bb\u04b8\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bb\u04ba\3\2\2\2\u04bc"+
16174                "\u04bf\3\2\2\2\u04bd\u04bb\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04c0\3\2"+
16175                "\2\2\u04bf\u04bd\3\2\2\2\u04c0\u04c1\79\2\2\u04c1]\3\2\2\2\u04c2\u04c3"+
16176                "\7\7\2\2\u04c3\u04c4\7;\2\2\u04c4\u04c8\7J\2\2\u04c5\u04c7\t\2\2\2\u04c6"+
16177                "\u04c5\3\2\2\2\u04c7\u04ca\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c8\u04c9\3\2"+
16178                "\2\2\u04c9\u04cb\3\2\2\2\u04ca\u04c8\3\2\2\2\u04cb\u04cc\79\2\2\u04cc"+
16179                "_\3\2\2\2\u04cd\u04f5\5\\/\2\u04ce\u04f4\5\f\7\2\u04cf\u04f4\5j\66\2\u04d0"+
16180                "\u04f4\5\22\n\2\u04d1\u04f4\5\30\r\2\u04d2\u04f4\5\36\20\2\u04d3\u04f4"+
16181                "\5$\23\2\u04d4\u04f4\5*\26\2\u04d5\u04f4\5\60\31\2\u04d6\u04f4\5\66\34"+
16182                "\2\u04d7\u04f4\5<\37\2\u04d8\u04f4\5B\"\2\u04d9\u04f4\5H%\2\u04da\u04f4"+
16183                "\5N(\2\u04db\u04f4\5T+\2\u04dc\u04f4\5Z.\2\u04dd\u04f4\5f\64\2\u04de\u04f4"+
16184                "\5\16\b\2\u04df\u04f4\5\24\13\2\u04e0\u04f4\5\32\16\2\u04e1\u04f4\5 \21"+
16185                "\2\u04e2\u04f4\5&\24\2\u04e3\u04f4\5,\27\2\u04e4\u04f4\5\62\32\2\u04e5"+
16186                "\u04f4\58\35\2\u04e6\u04f4\5> \2\u04e7\u04f4\5D#\2\u04e8\u04f4\5J&\2\u04e9"+
16187                "\u04f4\5P)\2\u04ea\u04f4\5V,\2\u04eb\u04f4\5b\62\2\u04ec\u04ed\6\61\22"+
16188                "\2\u04ed\u04f4\7\3\2\2\u04ee\u04f4\5\u0094K\2\u04ef\u04f4\7\5\2\2\u04f0"+
16189                "\u04f4\7\b\2\2\u04f1\u04f4\5\u0096L\2\u04f2\u04f4\5\u0092J\2\u04f3\u04ce"+
16190                "\3\2\2\2\u04f3\u04cf\3\2\2\2\u04f3\u04d0\3\2\2\2\u04f3\u04d1\3\2\2\2\u04f3"+
16191                "\u04d2\3\2\2\2\u04f3\u04d3\3\2\2\2\u04f3\u04d4\3\2\2\2\u04f3\u04d5\3\2"+
16192                "\2\2\u04f3\u04d6\3\2\2\2\u04f3\u04d7\3\2\2\2\u04f3\u04d8\3\2\2\2\u04f3"+
16193                "\u04d9\3\2\2\2\u04f3\u04da\3\2\2\2\u04f3\u04db\3\2\2\2\u04f3\u04dc\3\2"+
16194                "\2\2\u04f3\u04dd\3\2\2\2\u04f3\u04de\3\2\2\2\u04f3\u04df\3\2\2\2\u04f3"+
16195                "\u04e0\3\2\2\2\u04f3\u04e1\3\2\2\2\u04f3\u04e2\3\2\2\2\u04f3\u04e3\3\2"+
16196                "\2\2\u04f3\u04e4\3\2\2\2\u04f3\u04e5\3\2\2\2\u04f3\u04e6\3\2\2\2\u04f3"+
16197                "\u04e7\3\2\2\2\u04f3\u04e8\3\2\2\2\u04f3\u04e9\3\2\2\2\u04f3\u04ea\3\2"+
16198                "\2\2\u04f3\u04eb\3\2\2\2\u04f3\u04ec\3\2\2\2\u04f3\u04ee\3\2\2\2\u04f3"+
16199                "\u04ef\3\2\2\2\u04f3\u04f0\3\2\2\2\u04f3\u04f1\3\2\2\2\u04f3\u04f2\3\2"+
16200                "\2\2\u04f4\u04f7\3\2\2\2\u04f5\u04f3\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6"+
16201                "\u04f8\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f8\u04f9\5^\60\2\u04f9a\3\2\2\2"+
16202                "\u04fa\u04fb\7\7\2\2\u04fb\u0502\7K\2\2\u04fc\u0501\5\n\6\2\u04fd\u0501"+
16203                "\7\b\2\2\u04fe\u0501\7\3\2\2\u04ff\u0501\7\6\2\2\u0500\u04fc\3\2\2\2\u0500"+
16204                "\u04fd\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u04ff\3\2\2\2\u0501\u0504\3\2"+
16205                "\2\2\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0505\3\2\2\2\u0504"+
16206                "\u0502\3\2\2\2\u0505\u0506\79\2\2\u0506c\3\2\2\2\u0507\u0508\7\7\2\2\u0508"+
16207                "\u0509\7;\2\2\u0509\u050d\7K\2\2\u050a\u050c\t\2\2\2\u050b\u050a\3\2\2"+
16208                "\2\u050c\u050f\3\2\2\2\u050d\u050b\3\2\2\2\u050d\u050e\3\2\2\2\u050e\u0510"+
16209                "\3\2\2\2\u050f\u050d\3\2\2\2\u0510\u0511\79\2\2\u0511e\3\2\2\2\u0512\u053a"+
16210                "\5b\62\2\u0513\u0539\5\f\7\2\u0514\u0539\5j\66\2\u0515\u0539\5\22\n\2"+
16211                "\u0516\u0539\5\30\r\2\u0517\u0539\5\36\20\2\u0518\u0539\5$\23\2\u0519"+
16212                "\u0539\5*\26\2\u051a\u0539\5\60\31\2\u051b\u0539\5\66\34\2\u051c\u0539"+
16213                "\5<\37\2\u051d\u0539\5B\"\2\u051e\u0539\5H%\2\u051f\u0539\5N(\2\u0520"+
16214                "\u0539\5T+\2\u0521\u0539\5Z.\2\u0522\u0539\5`\61\2\u0523\u0539\5\16\b"+
16215                "\2\u0524\u0539\5\24\13\2\u0525\u0539\5\32\16\2\u0526\u0539\5 \21\2\u0527"+
16216                "\u0539\5&\24\2\u0528\u0539\5,\27\2\u0529\u0539\5\62\32\2\u052a\u0539\5"+
16217                "8\35\2\u052b\u0539\5> \2\u052c\u0539\5D#\2\u052d\u0539\5J&\2\u052e\u0539"+
16218                "\5P)\2\u052f\u0539\5V,\2\u0530\u0539\5\\/\2\u0531\u0532\6\64\23\2\u0532"+
16219                "\u0539\7\3\2\2\u0533\u0539\5\u0094K\2\u0534\u0539\7\5\2\2\u0535\u0539"+
16220                "\7\b\2\2\u0536\u0539\5\u0096L\2\u0537\u0539\5\u0092J\2\u0538\u0513\3\2"+
16221                "\2\2\u0538\u0514\3\2\2\2\u0538\u0515\3\2\2\2\u0538\u0516\3\2\2\2\u0538"+
16222                "\u0517\3\2\2\2\u0538\u0518\3\2\2\2\u0538\u0519\3\2\2\2\u0538\u051a\3\2"+
16223                "\2\2\u0538\u051b\3\2\2\2\u0538\u051c\3\2\2\2\u0538\u051d\3\2\2\2\u0538"+
16224                "\u051e\3\2\2\2\u0538\u051f\3\2\2\2\u0538\u0520\3\2\2\2\u0538\u0521\3\2"+
16225                "\2\2\u0538\u0522\3\2\2\2\u0538\u0523\3\2\2\2\u0538\u0524\3\2\2\2\u0538"+
16226                "\u0525\3\2\2\2\u0538\u0526\3\2\2\2\u0538\u0527\3\2\2\2\u0538\u0528\3\2"+
16227                "\2\2\u0538\u0529\3\2\2\2\u0538\u052a\3\2\2\2\u0538\u052b\3\2\2\2\u0538"+
16228                "\u052c\3\2\2\2\u0538\u052d\3\2\2\2\u0538\u052e\3\2\2\2\u0538\u052f\3\2"+
16229                "\2\2\u0538\u0530\3\2\2\2\u0538\u0531\3\2\2\2\u0538\u0533\3\2\2\2\u0538"+
16230                "\u0534\3\2\2\2\u0538\u0535\3\2\2\2\u0538\u0536\3\2\2\2\u0538\u0537\3\2"+
16231                "\2\2\u0539\u053c\3\2\2\2\u053a\u0538\3\2\2\2\u053a\u053b\3\2\2\2\u053b"+
16232                "\u053d\3\2\2\2\u053c\u053a\3\2\2\2\u053d\u053e\5d\63\2\u053eg\3\2\2\2"+
16233                "\u053f\u054f\5j\66\2\u0540\u054f\5l\67\2\u0541\u054f\5n8\2\u0542\u054f"+
16234                "\5p9\2\u0543\u054f\5r:\2\u0544\u054f\5t;\2\u0545\u054f\5v<\2\u0546\u054f"+
16235                "\5x=\2\u0547\u054f\5z>\2\u0548\u054f\5|?\2\u0549\u054f\5~@\2\u054a\u054f"+
16236                "\5\u0080A\2\u054b\u054f\5\u0082B\2\u054c\u054f\5\u0084C\2\u054d\u054f"+
16237                "\5\u0086D\2\u054e\u053f\3\2\2\2\u054e\u0540\3\2\2\2\u054e\u0541\3\2\2"+
16238                "\2\u054e\u0542\3\2\2\2\u054e\u0543\3\2\2\2\u054e\u0544\3\2\2\2\u054e\u0545"+
16239                "\3\2\2\2\u054e\u0546\3\2\2\2\u054e\u0547\3\2\2\2\u054e\u0548\3\2\2\2\u054e"+
16240                "\u0549\3\2\2\2\u054e\u054a\3\2\2\2\u054e\u054b\3\2\2\2\u054e\u054c\3\2"+
16241                "\2\2\u054e\u054d\3\2\2\2\u054fi\3\2\2\2\u0550\u0551\7\7\2\2\u0551\u0558"+
16242                "\t\3\2\2\u0552\u0557\5\n\6\2\u0553\u0557\7\b\2\2\u0554\u0557\7\3\2\2\u0555"+
16243                "\u0557\7\6\2\2\u0556\u0552\3\2\2\2\u0556\u0553\3\2\2\2\u0556\u0554\3\2"+
16244                "\2\2\u0556\u0555\3\2\2\2\u0557\u055a\3\2\2\2\u0558\u0556\3\2\2\2\u0558"+
16245                "\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7:"+
16246                "\2\2\u055ck\3\2\2\2\u055d\u055e\7\7\2\2\u055e\u0565\7L\2\2\u055f\u0564"+
16247                "\5\n\6\2\u0560\u0564\7\b\2\2\u0561\u0564\7\3\2\2\u0562\u0564\7\6\2\2\u0563"+
16248                "\u055f\3\2\2\2\u0563\u0560\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0562\3\2"+
16249                "\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0565\u0566\3\2\2\2\u0566"+
16250                "\u0568\3\2\2\2\u0567\u0565\3\2\2\2\u0568\u0569\t\4\2\2\u0569m\3\2\2\2"+
16251                "\u056a\u056b\7\7\2\2\u056b\u0572\7M\2\2\u056c\u0571\5\n\6\2\u056d\u0571"+
16252                "\7\b\2\2\u056e\u0571\7\3\2\2\u056f\u0571\7\6\2\2\u0570\u056c\3\2\2\2\u0570"+
16253                "\u056d\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2"+
16254                "\2\2\u0572\u0570\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574"+
16255                "\u0572\3\2\2\2\u0575\u0576\t\4\2\2\u0576o\3\2\2\2\u0577\u0578\7\7\2\2"+
16256                "\u0578\u057f\7N\2\2\u0579\u057e\5\n\6\2\u057a\u057e\7\b\2\2\u057b\u057e"+
16257                "\7\3\2\2\u057c\u057e\7\6\2\2\u057d\u0579\3\2\2\2\u057d\u057a\3\2\2\2\u057d"+
16258                "\u057b\3\2\2\2\u057d\u057c\3\2\2\2\u057e\u0581\3\2\2\2\u057f\u057d\3\2"+
16259                "\2\2\u057f\u0580\3\2\2\2\u0580\u0582\3\2\2\2\u0581\u057f\3\2\2\2\u0582"+
16260                "\u0583\t\4\2\2\u0583q\3\2\2\2\u0584\u0585\7\7\2\2\u0585\u058c\7O\2\2\u0586"+
16261                "\u058b\5\n\6\2\u0587\u058b\7\b\2\2\u0588\u058b\7\3\2\2\u0589\u058b\7\6"+
16262                "\2\2\u058a\u0586\3\2\2\2\u058a\u0587\3\2\2\2\u058a\u0588\3\2\2\2\u058a"+
16263                "\u0589\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3\2\2\2\u058c\u058d\3\2"+
16264                "\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f\u0590\t\4\2\2\u0590"+
16265                "s\3\2\2\2\u0591\u0592\7\7\2\2\u0592\u0599\7P\2\2\u0593\u0598\5\n\6\2\u0594"+
16266                "\u0598\7\b\2\2\u0595\u0598\7\3\2\2\u0596\u0598\7\6\2\2\u0597\u0593\3\2"+
16267                "\2\2\u0597\u0594\3\2\2\2\u0597\u0595\3\2\2\2\u0597\u0596\3\2\2\2\u0598"+
16268                "\u059b\3\2\2\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059c\3\2"+
16269                "\2\2\u059b\u0599\3\2\2\2\u059c\u059d\t\4\2\2\u059du\3\2\2\2\u059e\u059f"+
16270                "\7\7\2\2\u059f\u05a6\7Q\2\2\u05a0\u05a5\5\n\6\2\u05a1\u05a5\7\b\2\2\u05a2"+
16271                "\u05a5\7\3\2\2\u05a3\u05a5\7\6\2\2\u05a4\u05a0\3\2\2\2\u05a4\u05a1\3\2"+
16272                "\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a3\3\2\2\2\u05a5\u05a8\3\2\2\2\u05a6"+
16273                "\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7\u05a9\3\2\2\2\u05a8\u05a6\3\2"+
16274                "\2\2\u05a9\u05aa\t\4\2\2\u05aaw\3\2\2\2\u05ab\u05ac\7\7\2\2\u05ac\u05b3"+
16275                "\7R\2\2\u05ad\u05b2\5\n\6\2\u05ae\u05b2\7\b\2\2\u05af\u05b2\7\3\2\2\u05b0"+
16276                "\u05b2\7\6\2\2\u05b1\u05ad\3\2\2\2\u05b1\u05ae\3\2\2\2\u05b1\u05af\3\2"+
16277                "\2\2\u05b1\u05b0\3\2\2\2\u05b2\u05b5\3\2\2\2\u05b3\u05b1\3\2\2\2\u05b3"+
16278                "\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05b3\3\2\2\2\u05b6\u05b7\t\4"+
16279                "\2\2\u05b7y\3\2\2\2\u05b8\u05b9\7\7\2\2\u05b9\u05c0\7S\2\2\u05ba\u05bf"+
16280                "\5\n\6\2\u05bb\u05bf\7\b\2\2\u05bc\u05bf\7\3\2\2\u05bd\u05bf\7\6\2\2\u05be"+
16281                "\u05ba\3\2\2\2\u05be\u05bb\3\2\2\2\u05be\u05bc\3\2\2\2\u05be\u05bd\3\2"+
16282                "\2\2\u05bf\u05c2\3\2\2\2\u05c0\u05be\3\2\2\2\u05c0\u05c1\3\2\2\2\u05c1"+
16283                "\u05c3\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c3\u05c4\t\4\2\2\u05c4{\3\2\2\2"+
16284                "\u05c5\u05c6\7\7\2\2\u05c6\u05cd\7T\2\2\u05c7\u05cc\5\n\6\2\u05c8\u05cc"+
16285                "\7\b\2\2\u05c9\u05cc\7\3\2\2\u05ca\u05cc\7\6\2\2\u05cb\u05c7\3\2\2\2\u05cb"+
16286                "\u05c8\3\2\2\2\u05cb\u05c9\3\2\2\2\u05cb\u05ca\3\2\2\2\u05cc\u05cf\3\2"+
16287                "\2\2\u05cd\u05cb\3\2\2\2\u05cd\u05ce\3\2\2\2\u05ce\u05d0\3\2\2\2\u05cf"+
16288                "\u05cd\3\2\2\2\u05d0\u05d1\t\4\2\2\u05d1}\3\2\2\2\u05d2\u05d3\7\7\2\2"+
16289                "\u05d3\u05da\7U\2\2\u05d4\u05d9\5\n\6\2\u05d5\u05d9\7\b\2\2\u05d6\u05d9"+
16290                "\7\3\2\2\u05d7\u05d9\7\6\2\2\u05d8\u05d4\3\2\2\2\u05d8\u05d5\3\2\2\2\u05d8"+
16291                "\u05d6\3\2\2\2\u05d8\u05d7\3\2\2\2\u05d9\u05dc\3\2\2\2\u05da\u05d8\3\2"+
16292                "\2\2\u05da\u05db\3\2\2\2\u05db\u05dd\3\2\2\2\u05dc\u05da\3\2\2\2\u05dd"+
16293                "\u05de\t\4\2\2\u05de\177\3\2\2\2\u05df\u05e0\7\7\2\2\u05e0\u05e7\7V\2"+
16294                "\2\u05e1\u05e6\5\n\6\2\u05e2\u05e6\7\b\2\2\u05e3\u05e6\7\3\2\2\u05e4\u05e6"+
16295                "\7\6\2\2\u05e5\u05e1\3\2\2\2\u05e5\u05e2\3\2\2\2\u05e5\u05e3\3\2\2\2\u05e5"+
16296                "\u05e4\3\2\2\2\u05e6\u05e9\3\2\2\2\u05e7\u05e5\3\2\2\2\u05e7\u05e8\3\2"+
16297                "\2\2\u05e8\u05ea\3\2\2\2\u05e9\u05e7\3\2\2\2\u05ea\u05eb\t\4\2\2\u05eb"+
16298                "\u0081\3\2\2\2\u05ec\u05ed\7\7\2\2\u05ed\u05f4\7W\2\2\u05ee\u05f3\5\n"+
16299                "\6\2\u05ef\u05f3\7\b\2\2\u05f0\u05f3\7\3\2\2\u05f1\u05f3\7\6\2\2\u05f2"+
16300                "\u05ee\3\2\2\2\u05f2\u05ef\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f2\u05f1\3\2"+
16301                "\2\2\u05f3\u05f6\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5"+
16302                "\u05f7\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f7\u05f8\t\4\2\2\u05f8\u0083\3\2"+
16303                "\2\2\u05f9\u05fa\7\7\2\2\u05fa\u0601\7X\2\2\u05fb\u0600\5\n\6\2\u05fc"+
16304                "\u0600\7\b\2\2\u05fd\u0600\7\3\2\2\u05fe\u0600\7\6\2\2\u05ff\u05fb\3\2"+
16305                "\2\2\u05ff\u05fc\3\2\2\2\u05ff\u05fd\3\2\2\2\u05ff\u05fe\3\2\2\2\u0600"+
16306                "\u0603\3\2\2\2\u0601\u05ff\3\2\2\2\u0601\u0602\3\2\2\2\u0602\u0604\3\2"+
16307                "\2\2\u0603\u0601\3\2\2\2\u0604\u0605\t\4\2\2\u0605\u0085\3\2\2\2\u0606"+
16308                "\u0607\7\7\2\2\u0607\u0608\7;\2\2\u0608\u0609\5\u0088E\2\u0609\u060a\7"+
16309                "9\2\2\u060a\u060b\bD\1\2\u060b\u0087\3\2\2\2\u060c\u060d\t\5\2\2\u060d"+
16310                "\u0089\3\2\2\2\u060e\u060f\6F\24\2\u060f\u0617\7\3\2\2\u0610\u0617\5\u0094"+
16311                "K\2\u0611\u0617\7\5\2\2\u0612\u0617\7\b\2\2\u0613\u0617\5\u0096L\2\u0614"+
16312                "\u0617\5\u0092J\2\u0615\u0617\5\4\3\2\u0616\u060e\3\2\2\2\u0616\u0610"+
16313                "\3\2\2\2\u0616\u0611\3\2\2\2\u0616\u0612\3\2\2\2\u0616\u0613\3\2\2\2\u0616"+
16314                "\u0614\3\2\2\2\u0616\u0615\3\2\2\2\u0617\u0618\3\2\2\2\u0618\u0616\3\2"+
16315                "\2\2\u0618\u0619\3\2\2\2\u0619\u008b\3\2\2\2\u061a\u061e\7\36\2\2\u061b"+
16316                "\u061d\t\6\2\2\u061c\u061b\3\2\2\2\u061d\u0620\3\2\2\2\u061e\u061c\3\2"+
16317                "\2\2\u061e\u061f\3\2\2\2\u061f\u0622\3\2\2\2\u0620\u061e\3\2\2\2\u0621"+
16318                "\u0623\7 \2\2\u0622\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2"+
16319                "\2\2\u0624\u0626\7#\2\2\u0625\u0624\3\2\2\2\u0625\u0626\3\2\2\2\u0626"+
16320                "\u0628\3\2\2\2\u0627\u0629\5\u008eH\2\u0628\u0627\3\2\2\2\u0628\u0629"+
16321                "\3\2\2\2\u0629\u0640\3\2\2\2\u062a\u062c\t\6\2\2\u062b\u062a\3\2\2\2\u062c"+
16322                "\u062d\3\2\2\2\u062d\u062b\3\2\2\2\u062d\u062e\3\2\2\2\u062e\u0630\3\2"+
16323                "\2\2\u062f\u0631\7 \2\2\u0630\u062f\3\2\2\2\u0630\u0631\3\2\2\2\u0631"+
16324                "\u0633\3\2\2\2\u0632\u0634\7#\2\2\u0633\u0632\3\2\2\2\u0633\u0634\3\2"+
16325                "\2\2\u0634\u0636\3\2\2\2\u0635\u0637\5\u008eH\2\u0636\u0635\3\2\2\2\u0636"+
16326                "\u0637\3\2\2\2\u0637\u0640\3\2\2\2\u0638\u063a\7 \2\2\u0639\u0638\3\2"+
16327                "\2\2\u0639\u063a\3\2\2\2\u063a\u063b\3\2\2\2\u063b\u063d\7#\2\2\u063c"+
16328                "\u063e\5\u008eH\2\u063d\u063c\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u0640"+
16329                "\3\2\2\2\u063f\u061a\3\2\2\2\u063f\u062b\3\2\2\2\u063f\u0639\3\2\2\2\u0640"+
16330                "\u008d\3\2\2\2\u0641\u0645\7$\2\2\u0642\u0644\t\7\2\2\u0643\u0642\3\2"+
16331                "\2\2\u0644\u0647\3\2\2\2\u0645\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646"+
16332                "\u0648\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649\7%\2\2\u0649\u008f\3\2"+
16333                "\2\2\u064a\u064e\7\t\2\2\u064b\u064d\t\b\2\2\u064c\u064b\3\2\2\2\u064d"+
16334                "\u0650\3\2\2\2\u064e\u064c\3\2\2\2\u064e\u064f\3\2\2\2\u064f\u0652\3\2"+
16335                "\2\2\u0650\u064e\3\2\2\2\u0651\u0653\5\u008aF\2\u0652\u0651\3\2\2\2\u0652"+
16336                "\u0653\3\2\2\2\u0653\u070d\3\2\2\2\u0654\u0658\7\n\2\2\u0655\u0657\t\b"+
16337                "\2\2\u0656\u0655\3\2\2\2\u0657\u065a\3\2\2\2\u0658\u0656\3\2\2\2\u0658"+
16338                "\u0659\3\2\2\2\u0659\u065c\3\2\2\2\u065a\u0658\3\2\2\2\u065b\u065d\5\u008a"+
16339                "F\2\u065c\u065b\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u070d\3\2\2\2\u065e"+
16340                "\u0662\7\13\2\2\u065f\u0661\t\b\2\2\u0660\u065f\3\2\2\2\u0661\u0664\3"+
16341                "\2\2\2\u0662\u0660\3\2\2\2\u0662\u0663\3\2\2\2\u0663\u0666\3\2\2\2\u0664"+
16342                "\u0662\3\2\2\2\u0665\u0667\7-\2\2\u0666\u0665\3\2\2\2\u0666\u0667\3\2"+
16343                "\2\2\u0667\u066b\3\2\2\2\u0668\u066a\t\b\2\2\u0669\u0668\3\2\2\2\u066a"+
16344                "\u066d\3\2\2\2\u066b\u0669\3\2\2\2\u066b\u066c\3\2\2\2\u066c\u066f\3\2"+
16345                "\2\2\u066d\u066b\3\2\2\2\u066e\u0670\5\u008aF\2\u066f\u066e\3\2\2\2\u066f"+
16346                "\u0670\3\2\2\2\u0670\u070d\3\2\2\2\u0671\u0675\7\f\2\2\u0672\u0674\t\b"+
16347                "\2\2\u0673\u0672\3\2\2\2\u0674\u0677\3\2\2\2\u0675\u0673\3\2\2\2\u0675"+
16348                "\u0676\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0675\3\2\2\2\u0678\u067a\7\33"+
16349                "\2\2\u0679\u0678\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067e\3\2\2\2\u067b"+
16350                "\u067d\t\b\2\2\u067c\u067b\3\2\2\2\u067d\u0680\3\2\2\2\u067e\u067c\3\2"+
16351                "\2\2\u067e\u067f\3\2\2\2\u067f\u0682\3\2\2\2\u0680\u067e\3\2\2\2\u0681"+
16352                "\u0683\5\u008aF\2\u0682\u0681\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u070d"+
16353                "\3\2\2\2\u0684\u0688\7\r\2\2\u0685\u0687\t\b\2\2\u0686\u0685\3\2\2\2\u0687"+
16354                "\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068c\3\2"+
16355                "\2\2\u068a\u0688\3\2\2\2\u068b\u068d\5\u008aF\2\u068c\u068b\3\2\2\2\u068c"+
16356                "\u068d\3\2\2\2\u068d\u070d\3\2\2\2\u068e\u0692\7\16\2\2\u068f\u0691\t"+
16357                "\b\2\2\u0690\u068f\3\2\2\2\u0691\u0694\3\2\2\2\u0692\u0690\3\2\2\2\u0692"+
16358                "\u0693\3\2\2\2\u0693\u0696\3\2\2\2\u0694\u0692\3\2\2\2\u0695\u0697\5\u008c"+
16359                "G\2\u0696\u0695\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u069c\3\2\2\2\u0698"+
16360                "\u069b\7\35\2\2\u0699\u069b\5\4\3\2\u069a\u0698\3\2\2\2\u069a\u0699\3"+
16361                "\2\2\2\u069b\u069e\3\2\2\2\u069c\u069a\3\2\2\2\u069c\u069d\3\2\2\2\u069d"+
16362                "\u06a2\3\2\2\2\u069e\u069c\3\2\2\2\u069f\u06a1\t\b\2\2\u06a0\u069f\3\2"+
16363                "\2\2\u06a1\u06a4\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3"+
16364                "\u06a6\3\2\2\2\u06a4\u06a2\3\2\2\2\u06a5\u06a7\5\u008aF\2\u06a6\u06a5"+
16365                "\3\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u070d\3\2\2\2\u06a8\u06ac\7\17\2\2"+
16366                "\u06a9\u06ab\t\b\2\2\u06aa\u06a9\3\2\2\2\u06ab\u06ae\3\2\2\2\u06ac\u06aa"+
16367                "\3\2\2\2\u06ac\u06ad\3\2\2\2\u06ad\u06b0\3\2\2\2\u06ae\u06ac\3\2\2\2\u06af"+
16368                "\u06b1\t\t\2\2\u06b0\u06af\3\2\2\2\u06b0\u06b1\3\2\2\2\u06b1\u06b3\3\2"+
16369                "\2\2\u06b2\u06b4\5\u008aF\2\u06b3\u06b2\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4"+
16370                "\u070d\3\2\2\2\u06b5\u06b9\7\21\2\2\u06b6\u06b8\t\b\2\2\u06b7\u06b6\3"+
16371                "\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba"+
16372                "\u06bd\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06be\5\u008aF\2\u06bd\u06bc"+
16373                "\3\2\2\2\u06bd\u06be\3\2\2\2\u06be\u070d\3\2\2\2\u06bf\u06c3\7\20\2\2"+
16374                "\u06c0\u06c2\t\b\2\2\u06c1\u06c0\3\2\2\2\u06c2\u06c5\3\2\2\2\u06c3\u06c1"+
16375                "\3\2\2\2\u06c3\u06c4\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5\u06c3\3\2\2\2\u06c6"+
16376                "\u06c8\7)\2\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06cc\3\2"+
16377                "\2\2\u06c9\u06cb\t\b\2\2\u06ca\u06c9\3\2\2\2\u06cb\u06ce\3\2\2\2\u06cc"+
16378                "\u06ca\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd\u06d0\3\2\2\2\u06ce\u06cc\3\2"+
16379                "\2\2\u06cf\u06d1\7+\2\2\u06d0\u06cf\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1"+
16380                "\u06d5\3\2\2\2\u06d2\u06d4\t\b\2\2\u06d3\u06d2\3\2\2\2\u06d4\u06d7\3\2"+
16381                "\2\2\u06d5\u06d3\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06d9\3\2\2\2\u06d7"+
16382                "\u06d5\3\2\2\2\u06d8\u06da\5\u008aF\2\u06d9\u06d8\3\2\2\2\u06d9\u06da"+
16383                "\3\2\2\2\u06da\u070d\3\2\2\2\u06db\u06df\7\22\2\2\u06dc\u06de\t\b\2\2"+
16384                "\u06dd\u06dc\3\2\2\2\u06de\u06e1\3\2\2\2\u06df\u06dd\3\2\2\2\u06df\u06e0"+
16385                "\3\2\2\2\u06e0\u06e3\3\2\2\2\u06e1\u06df\3\2\2\2\u06e2\u06e4\5\u008aF"+
16386                "\2\u06e3\u06e2\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u070d\3\2\2\2\u06e5\u06e9"+
16387                "\7\23\2\2\u06e6\u06e8\t\b\2\2\u06e7\u06e6\3\2\2\2\u06e8\u06eb\3\2\2\2"+
16388                "\u06e9\u06e7\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06ed\3\2\2\2\u06eb\u06e9"+
16389                "\3\2\2\2\u06ec\u06ee\7-\2\2\u06ed\u06ec\3\2\2\2\u06ed\u06ee\3\2\2\2\u06ee"+
16390                "\u06f2\3\2\2\2\u06ef\u06f1\t\b\2\2\u06f0\u06ef\3\2\2\2\u06f1\u06f4\3\2"+
16391                "\2\2\u06f2\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f6\3\2\2\2\u06f4"+
16392                "\u06f2\3\2\2\2\u06f5\u06f7\5\u008aF\2\u06f6\u06f5\3\2\2\2\u06f6\u06f7"+
16393                "\3\2\2\2\u06f7\u070d\3\2\2\2\u06f8\u06fc\7\24\2\2\u06f9\u06fb\t\b\2\2"+
16394                "\u06fa\u06f9\3\2\2\2\u06fb\u06fe\3\2\2\2\u06fc\u06fa\3\2\2\2\u06fc\u06fd"+
16395                "\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3\2\2\2\u06ff\u0701\5\u008aF"+
16396                "\2\u0700\u06ff\3\2\2\2\u0700\u0701\3\2\2\2\u0701\u070d\3\2\2\2\u0702\u0706"+
16397                "\7\27\2\2\u0703\u0705\t\b\2\2\u0704\u0703\3\2\2\2\u0705\u0708\3\2\2\2"+
16398                "\u0706\u0704\3\2\2\2\u0706\u0707\3\2\2\2\u0707\u070a\3\2\2\2\u0708\u0706"+
16399                "\3\2\2\2\u0709\u070b\5\u008aF\2\u070a\u0709\3\2\2\2\u070a\u070b\3\2\2"+
16400                "\2\u070b\u070d\3\2\2\2\u070c\u064a\3\2\2\2\u070c\u0654\3\2\2\2\u070c\u065e"+
16401                "\3\2\2\2\u070c\u0671\3\2\2\2\u070c\u0684\3\2\2\2\u070c\u068e\3\2\2\2\u070c"+
16402                "\u06a8\3\2\2\2\u070c\u06b5\3\2\2\2\u070c\u06bf\3\2\2\2\u070c\u06db\3\2"+
16403                "\2\2\u070c\u06e5\3\2\2\2\u070c\u06f8\3\2\2\2\u070c\u0702\3\2\2\2\u070d"+
16404                "\u0091\3\2\2\2\u070e\u075b\7\25\2\2\u070f\u0716\7/\2\2\u0710\u0715\7\6"+
16405                "\2\2\u0711\u0715\7\b\2\2\u0712\u0715\7\3\2\2\u0713\u0715\5\u0096L\2\u0714"+
16406                "\u0710\3\2\2\2\u0714\u0711\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0713\3\2"+
16407                "\2\2\u0715\u0718\3\2\2\2\u0716\u0714\3\2\2\2\u0716\u0717\3\2\2\2\u0717"+
16408                "\u075c\3\2\2\2\u0718\u0716\3\2\2\2\u0719\u071d\7\60\2\2\u071a\u071c\t"+
16409                "\2\2\2\u071b\u071a\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2\2\2\u071d"+
16410                "\u071e\3\2\2\2\u071e\u075c\3\2\2\2\u071f\u071d\3\2\2\2\u0720\u0724\7\61"+
16411                "\2\2\u0721\u0723\t\2\2\2\u0722\u0721\3\2\2\2\u0723\u0726\3\2\2\2\u0724"+
16412                "\u0722\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u075c\3\2\2\2\u0726\u0724\3\2"+
16413                "\2\2\u0727\u072b\7\62\2\2\u0728\u072a\t\2\2\2\u0729\u0728\3\2\2\2\u072a"+
16414                "\u072d\3\2\2\2\u072b\u0729\3\2\2\2\u072b\u072c\3\2\2\2\u072c\u072e\3\2"+
16415                "\2\2\u072d\u072b\3\2\2\2\u072e\u0730\5\u008cG\2\u072f\u0731\5\u008aF\2"+
16416                "\u0730\u072f\3\2\2\2\u0730\u0731\3\2\2\2\u0731\u075c\3\2\2\2\u0732\u0736"+
16417                "\7\63\2\2\u0733\u0735\t\2\2\2\u0734\u0733\3\2\2\2\u0735\u0738\3\2\2\2"+
16418                "\u0736\u0734\3\2\2\2\u0736\u0737\3\2\2\2\u0737\u0739\3\2\2\2\u0738\u0736"+
16419                "\3\2\2\2\u0739\u073b\5\u008cG\2\u073a\u073c\5\u008aF\2\u073b\u073a\3\2"+
16420                "\2\2\u073b\u073c\3\2\2\2\u073c\u075c\3\2\2\2\u073d\u0744\7\64\2\2\u073e"+
16421                "\u0743\7\6\2\2\u073f\u0743\7\b\2\2\u0740\u0743\7\3\2\2\u0741\u0743\5\u0096"+
16422                "L\2\u0742\u073e\3\2\2\2\u0742\u073f\3\2\2\2\u0742\u0740\3\2\2\2\u0742"+
16423                "\u0741\3\2\2\2\u0743\u0746\3\2\2\2\u0744\u0742\3\2\2\2\u0744\u0745\3\2"+
16424                "\2\2\u0745\u075c\3\2\2\2\u0746\u0744\3\2\2\2\u0747\u074b\7\65\2\2\u0748"+
16425                "\u074a\t\2\2\2\u0749\u0748\3\2\2\2\u074a\u074d\3\2\2\2\u074b\u0749\3\2"+
16426                "\2\2\u074b\u074c\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b\3\2\2\2\u074e"+
16427                "\u0750\5\u008cG\2\u074f\u074e\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u075c"+
16428                "\3\2\2\2\u0751\u0755\7\27\2\2\u0752\u0754\t\2\2\2\u0753\u0752\3\2\2\2"+
16429                "\u0754\u0757\3\2\2\2\u0755\u0753\3\2\2\2\u0755\u0756\3\2\2\2\u0756\u0759"+
16430                "\3\2\2\2\u0757\u0755\3\2\2\2\u0758\u075a\5\u008aF\2\u0759\u0758\3\2\2"+
16431                "\2\u0759\u075a\3\2\2\2\u075a\u075c\3\2\2\2\u075b\u070f\3\2\2\2\u075b\u0719"+
16432                "\3\2\2\2\u075b\u0720\3\2\2\2\u075b\u0727\3\2\2\2\u075b\u0732\3\2\2\2\u075b"+
16433                "\u073d\3\2\2\2\u075b\u0747\3\2\2\2\u075b\u0751\3\2\2\2\u075c\u075d\3\2"+
16434                "\2\2\u075d\u075e\7\26\2\2\u075e\u0093\3\2\2\2\u075f\u0765\7\4\2\2\u0760"+
16435                "\u0764\5\u0096L\2\u0761\u0764\7\b\2\2\u0762\u0764\7\3\2\2\u0763\u0760"+
16436                "\3\2\2\2\u0763\u0761\3\2\2\2\u0763\u0762\3\2\2\2\u0764\u0767\3\2\2\2\u0765"+
16437                "\u0763\3\2\2\2\u0765\u0766\3\2\2\2\u0766\u0768\3\2\2\2\u0767\u0765\3\2"+
16438                "\2\2\u0768\u0769\7]\2\2\u0769\u0095\3\2\2\2\u076a\u076b\t\n\2\2\u076b"+
16439                "\u076d\bL\1\2\u076c\u076a\3\2\2\2\u076d\u076e\3\2\2\2\u076e\u076c\3\2"+
16440                "\2\2\u076e\u076f\3\2\2\2\u076f\u0097\3\2\2\2\u00c5\u00a0\u00a2\u00a6\u00ab"+
16441                "\u00b1\u00e5\u00ed\u00ef\u00fa\u0103\u010a\u0110\u011b\u011d\u012b\u012d"+
16442                "\u0132\u013a\u013c\u0147\u0172\u0174\u017f\u0181\u018c\u01b7\u01b9\u01c4"+
16443                "\u01c6\u01d1\u01fc\u01fe\u0209\u020b\u0216\u0241\u0243\u024e\u0250\u025b"+
16444                "\u0286\u0288\u0293\u0295\u02a0\u02cb\u02cd\u02d8\u02da\u02e5\u0310\u0312"+
16445                "\u031d\u031f\u032a\u0355\u0357\u0362\u0364\u036f\u039a\u039c\u03a7\u03a9"+
16446                "\u03b4\u03df\u03e1\u03ec\u03ee\u03f9\u0424\u0426\u0431\u0433\u043e\u0469"+
16447                "\u046b\u0476\u0478\u0483\u04ae\u04b0\u04bb\u04bd\u04c8\u04f3\u04f5\u0500"+
16448                "\u0502\u050d\u0538\u053a\u054e\u0556\u0558\u0563\u0565\u0570\u0572\u057d"+
16449                "\u057f\u058a\u058c\u0597\u0599\u05a4\u05a6\u05b1\u05b3\u05be\u05c0\u05cb"+
16450                "\u05cd\u05d8\u05da\u05e5\u05e7\u05f2\u05f4\u05ff\u0601\u0616\u0618\u061e"+
16451                "\u0622\u0625\u0628\u062d\u0630\u0633\u0636\u0639\u063d\u063f\u0645\u064e"+
16452                "\u0652\u0658\u065c\u0662\u0666\u066b\u066f\u0675\u0679\u067e\u0682\u0688"+
16453                "\u068c\u0692\u0696\u069a\u069c\u06a2\u06a6\u06ac\u06b0\u06b3\u06b9\u06bd"+
16454                "\u06c3\u06c7\u06cc\u06d0\u06d5\u06d9\u06df\u06e3\u06e9\u06ed\u06f2\u06f6"+
16455                "\u06fc\u0700\u0706\u070a\u070c\u0714\u0716\u071d\u0724\u072b\u0730\u0736"+
16456                "\u073b\u0742\u0744\u074b\u074f\u0755\u0759\u075b\u0763\u0765\u076e";
16457        public static final ATN _ATN =
16458                new ATNDeserializer().deserialize(_serializedATN.toCharArray());
16459        static {
16460                _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
16461                for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
16462                        _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
16463                }
16464        }
16465}