001// Generated from JavadocParser.g4 by ANTLR 4.3
002
003package com.puppycrawl.tools.checkstyle.grammars.javadoc;
004
005import org.antlr.v4.runtime.atn.*;
006import org.antlr.v4.runtime.dfa.DFA;
007import org.antlr.v4.runtime.*;
008import org.antlr.v4.runtime.misc.*;
009import org.antlr.v4.runtime.tree.*;
010import java.util.List;
011import java.util.Iterator;
012import java.util.ArrayList;
013
014@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
015public class JavadocParser extends Parser {
016        static { RuntimeMetaData.checkVersion("4.3", RuntimeMetaData.VERSION); }
017
018        protected static final DFA[] _decisionToDFA;
019        protected static final PredictionContextCache _sharedContextCache =
020                new PredictionContextCache();
021        public static final int
022                LINK_HTML_TAG_NAME=84, PACKAGE=28, CDATA=3, CLASS=31, MEMBER=33, Char11=88, 
023                Char12=90, Char10=54, TBODY_HTML_TAG_NAME=71, CHAR=24, FIELD_TYPE=41, 
024                FRAME_HTML_TAG_NAME=79, EQUALS=58, VERSION_LITERAL=18, INHERIT_DOC_LITERAL=47, 
025                META_HTML_TAG_NAME=85, JAVADOC_INLINE_TAG_END=20, SERIAL_FIELD_LITERAL=14, 
026                Char7=52, COL_HTML_TAG_NAME=78, Char8=53, DOC_ROOT_LITERAL=46, PARAM_HTML_TAG_NAME=86, 
027                SINCE_LITERAL=16, RETURN_LITERAL=11, CODE_LITERAL=45, LITERAL_INCLUDE=22, 
028                LI_HTML_TAG_NAME=60, SLASH=57, HTML_TAG_NAME=87, Char20=38, COMMA=37, 
029                LINK_LITERAL=48, PARAM_LITERAL=10, ARGUMENT=36, TH_HTML_TAG_NAME=63, BASEFRONT_HTML_TAG_NAME=76, 
030                THROWS_LITERAL=17, VALUE_LITERAL=51, EXCEPTION_LITERAL=9, INPUT_HTML_TAG_NAME=82, 
031                DOT=29, SERIAL_LITERAL=13, TD_HTML_TAG_NAME=62, RIGHT_BRACE=35, DD_HTML_TAG_NAME=66, 
032                FIELD_NAME=39, HTML_COMMENT_START=2, CLASS_NAME=43, PARAMETER_NAME=25, 
033                TFOOT_HTML_TAG_NAME=72, ISINDEX_HTML_TAG_NAME=83, AUTHOR_LITERAL=7, JAVADOC_INLINE_TAG_START=19, 
034                HASH=30, LEADING_ASTERISK=1, CUSTOM_NAME=21, HTML_COMMENT_END=91, LINKPLAIN_LITERAL=49, 
035                LITERAL_EXCLUDE=23, THEAD_HTML_TAG_NAME=73, AREA_HTML_TAG_NAME=74, BODY_HTML_TAG_NAME=64, 
036                HR_HTML_TAG_NAME=80, DT_HTML_TAG_NAME=67, OPEN=5, WS=4, NEWLINE=6, CLOSE=55, 
037                Char4=42, SEE_LITERAL=12, Char5=44, TR_HTML_TAG_NAME=61, Char2=32, HEAD_HTML_TAG_NAME=68, 
038                LEFT_BRACE=34, Char3=40, OPTION_HTML_TAG_NAME=70, BASE_HTML_TAG_NAME=75, 
039                Char1=26, IMG_HTML_TAG_NAME=81, LITERAL_LITERAL=50, ATTR_VALUE=89, HTML_HTML_TAG_NAME=69, 
040                SLASH_CLOSE=56, P_HTML_TAG_NAME=59, COLGROUP_HTML_TAG_NAME=65, SERIAL_DATA_LITERAL=15, 
041                BR_HTML_TAG_NAME=77, DEPRECATED_LITERAL=8, STRING=27;
042        public static final String[] tokenNames = {
043                "<INVALID>", "LEADING_ASTERISK", "HTML_COMMENT_START", "CDATA", "WS", 
044                "OPEN", "'\n'", "'@author'", "'@deprecated'", "EXCEPTION_LITERAL", "PARAM_LITERAL", 
045                "'@return'", "SEE_LITERAL", "'@serial'", "SERIAL_FIELD_LITERAL", "'@serialData'", 
046                "'@since'", "THROWS_LITERAL", "'@version'", "JAVADOC_INLINE_TAG_START", 
047                "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", "'include'", "'exclude'", "CHAR", 
048                "PARAMETER_NAME", "Char1", "STRING", "PACKAGE", "'.'", "HASH", "CLASS", 
049                "Char2", "MEMBER", "'('", "')'", "ARGUMENT", "','", "Char20", "FIELD_NAME", 
050                "Char3", "FIELD_TYPE", "Char4", "CLASS_NAME", "Char5", "CODE_LITERAL", 
051                "'@docRoot'", "'@inheritDoc'", "'@link'", "'@linkplain'", "LITERAL_LITERAL", 
052                "'@value'", "Char7", "Char8", "Char10", "CLOSE", "SLASH_CLOSE", "'/'", 
053                "'='", "P_HTML_TAG_NAME", "LI_HTML_TAG_NAME", "TR_HTML_TAG_NAME", "TD_HTML_TAG_NAME", 
054                "TH_HTML_TAG_NAME", "BODY_HTML_TAG_NAME", "COLGROUP_HTML_TAG_NAME", "DD_HTML_TAG_NAME", 
055                "DT_HTML_TAG_NAME", "HEAD_HTML_TAG_NAME", "HTML_HTML_TAG_NAME", "OPTION_HTML_TAG_NAME", 
056                "TBODY_HTML_TAG_NAME", "TFOOT_HTML_TAG_NAME", "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", 
057                "BASE_HTML_TAG_NAME", "BASEFRONT_HTML_TAG_NAME", "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", 
058                "FRAME_HTML_TAG_NAME", "HR_HTML_TAG_NAME", "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", 
059                "ISINDEX_HTML_TAG_NAME", "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", 
060                "HTML_TAG_NAME", "Char11", "ATTR_VALUE", "Char12", "'-->'"
061        };
062        public static final int
063                RULE_javadoc = 0, RULE_htmlElement = 1, RULE_htmlElementOpen = 2, RULE_htmlElementClose = 3, 
064                RULE_attribute = 4, RULE_htmlTag = 5, RULE_pTagOpen = 6, RULE_pTagClose = 7, 
065                RULE_paragraph = 8, RULE_liTagOpen = 9, RULE_liTagClose = 10, RULE_li = 11, 
066                RULE_trTagOpen = 12, RULE_trTagClose = 13, RULE_tr = 14, RULE_tdTagOpen = 15, 
067                RULE_tdTagClose = 16, RULE_td = 17, RULE_thTagOpen = 18, RULE_thTagClose = 19, 
068                RULE_th = 20, RULE_bodyTagOpen = 21, RULE_bodyTagClose = 22, RULE_body = 23, 
069                RULE_colgroupTagOpen = 24, RULE_colgroupTagClose = 25, RULE_colgroup = 26, 
070                RULE_ddTagOpen = 27, RULE_ddTagClose = 28, RULE_dd = 29, RULE_dtTagOpen = 30, 
071                RULE_dtTagClose = 31, RULE_dt = 32, RULE_headTagOpen = 33, RULE_headTagClose = 34, 
072                RULE_head = 35, RULE_htmlTagOpen = 36, RULE_htmlTagClose = 37, RULE_html = 38, 
073                RULE_optionTagOpen = 39, RULE_optionTagClose = 40, RULE_option = 41, RULE_tbodyTagOpen = 42, 
074                RULE_tbodyTagClose = 43, RULE_tbody = 44, RULE_tfootTagOpen = 45, RULE_tfootTagClose = 46, 
075                RULE_tfoot = 47, RULE_theadTagOpen = 48, RULE_theadTagClose = 49, RULE_thead = 50, 
076                RULE_singletonElement = 51, RULE_singletonTag = 52, RULE_areaTag = 53, 
077                RULE_baseTag = 54, RULE_basefrontTag = 55, RULE_brTag = 56, RULE_colTag = 57, 
078                RULE_frameTag = 58, RULE_hrTag = 59, RULE_imgTag = 60, RULE_inputTag = 61, 
079                RULE_isindexTag = 62, RULE_linkTag = 63, RULE_metaTag = 64, RULE_paramTag = 65, 
080                RULE_wrongSinletonTag = 66, RULE_singletonTagName = 67, RULE_description = 68, 
081                RULE_reference = 69, RULE_parameters = 70, RULE_javadocTag = 71, RULE_javadocInlineTag = 72, 
082                RULE_htmlComment = 73, RULE_text = 74;
083        public static final String[] ruleNames = {
084                "javadoc", "htmlElement", "htmlElementOpen", "htmlElementClose", "attribute", 
085                "htmlTag", "pTagOpen", "pTagClose", "paragraph", "liTagOpen", "liTagClose", 
086                "li", "trTagOpen", "trTagClose", "tr", "tdTagOpen", "tdTagClose", "td", 
087                "thTagOpen", "thTagClose", "th", "bodyTagOpen", "bodyTagClose", "body", 
088                "colgroupTagOpen", "colgroupTagClose", "colgroup", "ddTagOpen", "ddTagClose", 
089                "dd", "dtTagOpen", "dtTagClose", "dt", "headTagOpen", "headTagClose", 
090                "head", "htmlTagOpen", "htmlTagClose", "html", "optionTagOpen", "optionTagClose", 
091                "option", "tbodyTagOpen", "tbodyTagClose", "tbody", "tfootTagOpen", "tfootTagClose", 
092                "tfoot", "theadTagOpen", "theadTagClose", "thead", "singletonElement", 
093                "singletonTag", "areaTag", "baseTag", "basefrontTag", "brTag", "colTag", 
094                "frameTag", "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", 
095                "paramTag", "wrongSinletonTag", "singletonTagName", "description", "reference", 
096                "parameters", "javadocTag", "javadocInlineTag", "htmlComment", "text"
097        };
098
099        @Override
100        public String getGrammarFileName() { return "JavadocParser.g4"; }
101
102        @Override
103        public String[] getTokenNames() { return tokenNames; }
104
105        @Override
106        public String[] getRuleNames() { return ruleNames; }
107
108        @Override
109        public String getSerializedATN() { return _serializedATN; }
110
111        @Override
112        public ATN getATN() { return _ATN; }
113
114
115                boolean isNextJavadocTag() {
116                        int token1 = _input.LA(2);
117                        int token2 = _input.LA(3);
118                        return isJavadocTag(token1)
119                                || (token1 == WS && isJavadocTag(token2));
120                }
121
122                boolean isJavadocTag(int type) {
123                        switch(type) {
124                                case AUTHOR_LITERAL:
125                                case DEPRECATED_LITERAL:
126                                case EXCEPTION_LITERAL: 
127                                case PARAM_LITERAL:
128                                case RETURN_LITERAL:
129                                case SEE_LITERAL:
130                                case SERIAL_LITERAL:
131                                case SERIAL_FIELD_LITERAL:
132                                case SERIAL_DATA_LITERAL:
133                                case SINCE_LITERAL:
134                                case THROWS_LITERAL:
135                                case VERSION_LITERAL:
136                                case CUSTOM_NAME:
137                                        return true;
138                                default:
139                                        return false;
140                        }
141                }
142
143              boolean isSameTagNames(ParserRuleContext htmlTagOpen, ParserRuleContext htmlTagClose) {
144                    String openTag = htmlTagOpen.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
145                    String closeTag = htmlTagClose.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
146                    System.out.println(openTag + " - " + closeTag);
147                    return openTag.equals(closeTag);
148              }
149
150        public JavadocParser(TokenStream input) {
151                super(input);
152                _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
153        }
154        public static class JavadocContext extends ParserRuleContext {
155                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
156                public JavadocTagContext javadocTag(int i) {
157                        return getRuleContext(JavadocTagContext.class,i);
158                }
159                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
160                public TerminalNode NEWLINE(int i) {
161                        return getToken(JavadocParser.NEWLINE, i);
162                }
163                public List<HtmlElementContext> htmlElement() {
164                        return getRuleContexts(HtmlElementContext.class);
165                }
166                public TextContext text(int i) {
167                        return getRuleContext(TextContext.class,i);
168                }
169                public List<JavadocInlineTagContext> javadocInlineTag() {
170                        return getRuleContexts(JavadocInlineTagContext.class);
171                }
172                public List<HtmlCommentContext> htmlComment() {
173                        return getRuleContexts(HtmlCommentContext.class);
174                }
175                public TerminalNode CDATA(int i) {
176                        return getToken(JavadocParser.CDATA, i);
177                }
178                public TerminalNode WS(int i) {
179                        return getToken(JavadocParser.WS, i);
180                }
181                public HtmlCommentContext htmlComment(int i) {
182                        return getRuleContext(HtmlCommentContext.class,i);
183                }
184                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
185                public List<TextContext> text() {
186                        return getRuleContexts(TextContext.class);
187                }
188                public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); }
189                public HtmlElementContext htmlElement(int i) {
190                        return getRuleContext(HtmlElementContext.class,i);
191                }
192                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
193                public List<JavadocTagContext> javadocTag() {
194                        return getRuleContexts(JavadocTagContext.class);
195                }
196                public JavadocInlineTagContext javadocInlineTag(int i) {
197                        return getRuleContext(JavadocInlineTagContext.class,i);
198                }
199                public TerminalNode LEADING_ASTERISK(int i) {
200                        return getToken(JavadocParser.LEADING_ASTERISK, i);
201                }
202                public JavadocContext(ParserRuleContext parent, int invokingState) {
203                        super(parent, invokingState);
204                }
205                @Override public int getRuleIndex() { return RULE_javadoc; }
206                @Override
207                public void enterRule(ParseTreeListener listener) {
208                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadoc(this);
209                }
210                @Override
211                public void exitRule(ParseTreeListener listener) {
212                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadoc(this);
213                }
214                @Override
215                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
216                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadoc(this);
217                        else return visitor.visitChildren(this);
218                }
219        }
220
221        public final JavadocContext javadoc() throws RecognitionException {
222                JavadocContext _localctx = new JavadocContext(_ctx, getState());
223                enterRule(_localctx, 0, RULE_javadoc);
224                int _la;
225                try {
226                        int _alt;
227                        enterOuterAlt(_localctx, 1);
228                        {
229                        setState(160);
230                        _errHandler.sync(this);
231                        _alt = getInterpreter().adaptivePredict(_input,1,_ctx);
232                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
233                                if ( _alt==1 ) {
234                                        {
235                                        setState(158);
236                                        switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
237                                        case 1:
238                                                {
239                                                setState(150); htmlElement();
240                                                }
241                                                break;
242
243                                        case 2:
244                                                {
245                                                {
246                                                setState(151);
247                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
248                                                setState(152); match(LEADING_ASTERISK);
249                                                }
250                                                }
251                                                break;
252
253                                        case 3:
254                                                {
255                                                setState(153); htmlComment();
256                                                }
257                                                break;
258
259                                        case 4:
260                                                {
261                                                setState(154); match(CDATA);
262                                                }
263                                                break;
264
265                                        case 5:
266                                                {
267                                                setState(155); match(NEWLINE);
268                                                }
269                                                break;
270
271                                        case 6:
272                                                {
273                                                setState(156); text();
274                                                }
275                                                break;
276
277                                        case 7:
278                                                {
279                                                setState(157); javadocInlineTag();
280                                                }
281                                                break;
282                                        }
283                                        } 
284                                }
285                                setState(162);
286                                _errHandler.sync(this);
287                                _alt = getInterpreter().adaptivePredict(_input,1,_ctx);
288                        }
289                        setState(175);
290                        _errHandler.sync(this);
291                        _la = _input.LA(1);
292                        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)) {
293                                {
294                                {
295                                setState(164);
296                                _la = _input.LA(1);
297                                if (_la==LEADING_ASTERISK) {
298                                        {
299                                        setState(163); match(LEADING_ASTERISK);
300                                        }
301                                }
302
303                                setState(169);
304                                _errHandler.sync(this);
305                                _la = _input.LA(1);
306                                while (_la==WS) {
307                                        {
308                                        {
309                                        setState(166); match(WS);
310                                        }
311                                        }
312                                        setState(171);
313                                        _errHandler.sync(this);
314                                        _la = _input.LA(1);
315                                }
316                                setState(172); javadocTag();
317                                }
318                                }
319                                setState(177);
320                                _errHandler.sync(this);
321                                _la = _input.LA(1);
322                        }
323                        setState(178); match(EOF);
324                        }
325                }
326                catch (RecognitionException re) {
327                        _localctx.exception = re;
328                        _errHandler.reportError(this, re);
329                        _errHandler.recover(this, re);
330                }
331                finally {
332                        exitRule();
333                }
334                return _localctx;
335        }
336
337        public static class HtmlElementContext extends ParserRuleContext {
338                public TheadTagCloseContext theadTagClose() {
339                        return getRuleContext(TheadTagCloseContext.class,0);
340                }
341                public ColgroupTagOpenContext colgroupTagOpen() {
342                        return getRuleContext(ColgroupTagOpenContext.class,0);
343                }
344                public TbodyTagCloseContext tbodyTagClose() {
345                        return getRuleContext(TbodyTagCloseContext.class,0);
346                }
347                public ThTagCloseContext thTagClose() {
348                        return getRuleContext(ThTagCloseContext.class,0);
349                }
350                public PTagCloseContext pTagClose() {
351                        return getRuleContext(PTagCloseContext.class,0);
352                }
353                public HtmlTagCloseContext htmlTagClose() {
354                        return getRuleContext(HtmlTagCloseContext.class,0);
355                }
356                public ParagraphContext paragraph() {
357                        return getRuleContext(ParagraphContext.class,0);
358                }
359                public DdTagCloseContext ddTagClose() {
360                        return getRuleContext(DdTagCloseContext.class,0);
361                }
362                public DtTagOpenContext dtTagOpen() {
363                        return getRuleContext(DtTagOpenContext.class,0);
364                }
365                public ColgroupContext colgroup() {
366                        return getRuleContext(ColgroupContext.class,0);
367                }
368                public TrContext tr() {
369                        return getRuleContext(TrContext.class,0);
370                }
371                public LiContext li() {
372                        return getRuleContext(LiContext.class,0);
373                }
374                public HtmlContext html() {
375                        return getRuleContext(HtmlContext.class,0);
376                }
377                public ThContext th() {
378                        return getRuleContext(ThContext.class,0);
379                }
380                public DdTagOpenContext ddTagOpen() {
381                        return getRuleContext(DdTagOpenContext.class,0);
382                }
383                public HeadTagCloseContext headTagClose() {
384                        return getRuleContext(HeadTagCloseContext.class,0);
385                }
386                public ThTagOpenContext thTagOpen() {
387                        return getRuleContext(ThTagOpenContext.class,0);
388                }
389                public HeadTagOpenContext headTagOpen() {
390                        return getRuleContext(HeadTagOpenContext.class,0);
391                }
392                public HtmlTagOpenContext htmlTagOpen() {
393                        return getRuleContext(HtmlTagOpenContext.class,0);
394                }
395                public TrTagOpenContext trTagOpen() {
396                        return getRuleContext(TrTagOpenContext.class,0);
397                }
398                public TbodyTagOpenContext tbodyTagOpen() {
399                        return getRuleContext(TbodyTagOpenContext.class,0);
400                }
401                public TbodyContext tbody() {
402                        return getRuleContext(TbodyContext.class,0);
403                }
404                public TheadContext thead() {
405                        return getRuleContext(TheadContext.class,0);
406                }
407                public TheadTagOpenContext theadTagOpen() {
408                        return getRuleContext(TheadTagOpenContext.class,0);
409                }
410                public HeadContext head() {
411                        return getRuleContext(HeadContext.class,0);
412                }
413                public TfootTagOpenContext tfootTagOpen() {
414                        return getRuleContext(TfootTagOpenContext.class,0);
415                }
416                public TfootContext tfoot() {
417                        return getRuleContext(TfootContext.class,0);
418                }
419                public LiTagCloseContext liTagClose() {
420                        return getRuleContext(LiTagCloseContext.class,0);
421                }
422                public BodyContext body() {
423                        return getRuleContext(BodyContext.class,0);
424                }
425                public BodyTagCloseContext bodyTagClose() {
426                        return getRuleContext(BodyTagCloseContext.class,0);
427                }
428                public OptionTagOpenContext optionTagOpen() {
429                        return getRuleContext(OptionTagOpenContext.class,0);
430                }
431                public TfootTagCloseContext tfootTagClose() {
432                        return getRuleContext(TfootTagCloseContext.class,0);
433                }
434                public DtContext dt() {
435                        return getRuleContext(DtContext.class,0);
436                }
437                public DdContext dd() {
438                        return getRuleContext(DdContext.class,0);
439                }
440                public TdContext td() {
441                        return getRuleContext(TdContext.class,0);
442                }
443                public BodyTagOpenContext bodyTagOpen() {
444                        return getRuleContext(BodyTagOpenContext.class,0);
445                }
446                public ColgroupTagCloseContext colgroupTagClose() {
447                        return getRuleContext(ColgroupTagCloseContext.class,0);
448                }
449                public TdTagCloseContext tdTagClose() {
450                        return getRuleContext(TdTagCloseContext.class,0);
451                }
452                public SingletonElementContext singletonElement() {
453                        return getRuleContext(SingletonElementContext.class,0);
454                }
455                public LiTagOpenContext liTagOpen() {
456                        return getRuleContext(LiTagOpenContext.class,0);
457                }
458                public OptionContext option() {
459                        return getRuleContext(OptionContext.class,0);
460                }
461                public PTagOpenContext pTagOpen() {
462                        return getRuleContext(PTagOpenContext.class,0);
463                }
464                public DtTagCloseContext dtTagClose() {
465                        return getRuleContext(DtTagCloseContext.class,0);
466                }
467                public TrTagCloseContext trTagClose() {
468                        return getRuleContext(TrTagCloseContext.class,0);
469                }
470                public OptionTagCloseContext optionTagClose() {
471                        return getRuleContext(OptionTagCloseContext.class,0);
472                }
473                public HtmlTagContext htmlTag() {
474                        return getRuleContext(HtmlTagContext.class,0);
475                }
476                public TdTagOpenContext tdTagOpen() {
477                        return getRuleContext(TdTagOpenContext.class,0);
478                }
479                public HtmlElementContext(ParserRuleContext parent, int invokingState) {
480                        super(parent, invokingState);
481                }
482                @Override public int getRuleIndex() { return RULE_htmlElement; }
483                @Override
484                public void enterRule(ParseTreeListener listener) {
485                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElement(this);
486                }
487                @Override
488                public void exitRule(ParseTreeListener listener) {
489                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElement(this);
490                }
491                @Override
492                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
493                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElement(this);
494                        else return visitor.visitChildren(this);
495                }
496        }
497
498        public final HtmlElementContext htmlElement() throws RecognitionException {
499                HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState());
500                enterRule(_localctx, 2, RULE_htmlElement);
501                try {
502                        setState(227);
503                        switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
504                        case 1:
505                                enterOuterAlt(_localctx, 1);
506                                {
507                                setState(180); htmlTag();
508                                }
509                                break;
510
511                        case 2:
512                                enterOuterAlt(_localctx, 2);
513                                {
514                                setState(181); singletonElement();
515                                }
516                                break;
517
518                        case 3:
519                                enterOuterAlt(_localctx, 3);
520                                {
521                                setState(182); paragraph();
522                                }
523                                break;
524
525                        case 4:
526                                enterOuterAlt(_localctx, 4);
527                                {
528                                setState(183); li();
529                                }
530                                break;
531
532                        case 5:
533                                enterOuterAlt(_localctx, 5);
534                                {
535                                setState(184); tr();
536                                }
537                                break;
538
539                        case 6:
540                                enterOuterAlt(_localctx, 6);
541                                {
542                                setState(185); td();
543                                }
544                                break;
545
546                        case 7:
547                                enterOuterAlt(_localctx, 7);
548                                {
549                                setState(186); th();
550                                }
551                                break;
552
553                        case 8:
554                                enterOuterAlt(_localctx, 8);
555                                {
556                                setState(187); body();
557                                }
558                                break;
559
560                        case 9:
561                                enterOuterAlt(_localctx, 9);
562                                {
563                                setState(188); colgroup();
564                                }
565                                break;
566
567                        case 10:
568                                enterOuterAlt(_localctx, 10);
569                                {
570                                setState(189); dd();
571                                }
572                                break;
573
574                        case 11:
575                                enterOuterAlt(_localctx, 11);
576                                {
577                                setState(190); dt();
578                                }
579                                break;
580
581                        case 12:
582                                enterOuterAlt(_localctx, 12);
583                                {
584                                setState(191); head();
585                                }
586                                break;
587
588                        case 13:
589                                enterOuterAlt(_localctx, 13);
590                                {
591                                setState(192); html();
592                                }
593                                break;
594
595                        case 14:
596                                enterOuterAlt(_localctx, 14);
597                                {
598                                setState(193); option();
599                                }
600                                break;
601
602                        case 15:
603                                enterOuterAlt(_localctx, 15);
604                                {
605                                setState(194); tbody();
606                                }
607                                break;
608
609                        case 16:
610                                enterOuterAlt(_localctx, 16);
611                                {
612                                setState(195); thead();
613                                }
614                                break;
615
616                        case 17:
617                                enterOuterAlt(_localctx, 17);
618                                {
619                                setState(196); tfoot();
620                                }
621                                break;
622
623                        case 18:
624                                enterOuterAlt(_localctx, 18);
625                                {
626                                setState(197); pTagOpen();
627                                }
628                                break;
629
630                        case 19:
631                                enterOuterAlt(_localctx, 19);
632                                {
633                                setState(198); liTagOpen();
634                                }
635                                break;
636
637                        case 20:
638                                enterOuterAlt(_localctx, 20);
639                                {
640                                setState(199); trTagOpen();
641                                }
642                                break;
643
644                        case 21:
645                                enterOuterAlt(_localctx, 21);
646                                {
647                                setState(200); tdTagOpen();
648                                }
649                                break;
650
651                        case 22:
652                                enterOuterAlt(_localctx, 22);
653                                {
654                                setState(201); thTagOpen();
655                                }
656                                break;
657
658                        case 23:
659                                enterOuterAlt(_localctx, 23);
660                                {
661                                setState(202); bodyTagOpen();
662                                }
663                                break;
664
665                        case 24:
666                                enterOuterAlt(_localctx, 24);
667                                {
668                                setState(203); colgroupTagOpen();
669                                }
670                                break;
671
672                        case 25:
673                                enterOuterAlt(_localctx, 25);
674                                {
675                                setState(204); ddTagOpen();
676                                }
677                                break;
678
679                        case 26:
680                                enterOuterAlt(_localctx, 26);
681                                {
682                                setState(205); dtTagOpen();
683                                }
684                                break;
685
686                        case 27:
687                                enterOuterAlt(_localctx, 27);
688                                {
689                                setState(206); headTagOpen();
690                                }
691                                break;
692
693                        case 28:
694                                enterOuterAlt(_localctx, 28);
695                                {
696                                setState(207); htmlTagOpen();
697                                }
698                                break;
699
700                        case 29:
701                                enterOuterAlt(_localctx, 29);
702                                {
703                                setState(208); optionTagOpen();
704                                }
705                                break;
706
707                        case 30:
708                                enterOuterAlt(_localctx, 30);
709                                {
710                                setState(209); tbodyTagOpen();
711                                }
712                                break;
713
714                        case 31:
715                                enterOuterAlt(_localctx, 31);
716                                {
717                                setState(210); theadTagOpen();
718                                }
719                                break;
720
721                        case 32:
722                                enterOuterAlt(_localctx, 32);
723                                {
724                                setState(211); tfootTagOpen();
725                                }
726                                break;
727
728                        case 33:
729                                enterOuterAlt(_localctx, 33);
730                                {
731                                setState(212); pTagClose();
732                                }
733                                break;
734
735                        case 34:
736                                enterOuterAlt(_localctx, 34);
737                                {
738                                setState(213); liTagClose();
739                                }
740                                break;
741
742                        case 35:
743                                enterOuterAlt(_localctx, 35);
744                                {
745                                setState(214); trTagClose();
746                                }
747                                break;
748
749                        case 36:
750                                enterOuterAlt(_localctx, 36);
751                                {
752                                setState(215); tdTagClose();
753                                }
754                                break;
755
756                        case 37:
757                                enterOuterAlt(_localctx, 37);
758                                {
759                                setState(216); thTagClose();
760                                }
761                                break;
762
763                        case 38:
764                                enterOuterAlt(_localctx, 38);
765                                {
766                                setState(217); bodyTagClose();
767                                }
768                                break;
769
770                        case 39:
771                                enterOuterAlt(_localctx, 39);
772                                {
773                                setState(218); colgroupTagClose();
774                                }
775                                break;
776
777                        case 40:
778                                enterOuterAlt(_localctx, 40);
779                                {
780                                setState(219); ddTagClose();
781                                }
782                                break;
783
784                        case 41:
785                                enterOuterAlt(_localctx, 41);
786                                {
787                                setState(220); dtTagClose();
788                                }
789                                break;
790
791                        case 42:
792                                enterOuterAlt(_localctx, 42);
793                                {
794                                setState(221); headTagClose();
795                                }
796                                break;
797
798                        case 43:
799                                enterOuterAlt(_localctx, 43);
800                                {
801                                setState(222); htmlTagClose();
802                                }
803                                break;
804
805                        case 44:
806                                enterOuterAlt(_localctx, 44);
807                                {
808                                setState(223); optionTagClose();
809                                }
810                                break;
811
812                        case 45:
813                                enterOuterAlt(_localctx, 45);
814                                {
815                                setState(224); tbodyTagClose();
816                                }
817                                break;
818
819                        case 46:
820                                enterOuterAlt(_localctx, 46);
821                                {
822                                setState(225); theadTagClose();
823                                }
824                                break;
825
826                        case 47:
827                                enterOuterAlt(_localctx, 47);
828                                {
829                                setState(226); tfootTagClose();
830                                }
831                                break;
832                        }
833                }
834                catch (RecognitionException re) {
835                        _localctx.exception = re;
836                        _errHandler.reportError(this, re);
837                        _errHandler.recover(this, re);
838                }
839                finally {
840                        exitRule();
841                }
842                return _localctx;
843        }
844
845        public static class HtmlElementOpenContext extends ParserRuleContext {
846                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
847                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
848                public TerminalNode NEWLINE(int i) {
849                        return getToken(JavadocParser.NEWLINE, i);
850                }
851                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
852                public List<AttributeContext> attribute() {
853                        return getRuleContexts(AttributeContext.class);
854                }
855                public AttributeContext attribute(int i) {
856                        return getRuleContext(AttributeContext.class,i);
857                }
858                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
859                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
860                public TerminalNode LEADING_ASTERISK(int i) {
861                        return getToken(JavadocParser.LEADING_ASTERISK, i);
862                }
863                public TerminalNode WS(int i) {
864                        return getToken(JavadocParser.WS, i);
865                }
866                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
867                public HtmlElementOpenContext(ParserRuleContext parent, int invokingState) {
868                        super(parent, invokingState);
869                }
870                @Override public int getRuleIndex() { return RULE_htmlElementOpen; }
871                @Override
872                public void enterRule(ParseTreeListener listener) {
873                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementOpen(this);
874                }
875                @Override
876                public void exitRule(ParseTreeListener listener) {
877                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementOpen(this);
878                }
879                @Override
880                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
881                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementOpen(this);
882                        else return visitor.visitChildren(this);
883                }
884        }
885
886        public final HtmlElementOpenContext htmlElementOpen() throws RecognitionException {
887                HtmlElementOpenContext _localctx = new HtmlElementOpenContext(_ctx, getState());
888                enterRule(_localctx, 4, RULE_htmlElementOpen);
889                int _la;
890                try {
891                        enterOuterAlt(_localctx, 1);
892                        {
893                        setState(229); match(OPEN);
894                        setState(230); match(HTML_TAG_NAME);
895                        setState(237);
896                        _errHandler.sync(this);
897                        _la = _input.LA(1);
898                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
899                                {
900                                setState(235);
901                                switch (_input.LA(1)) {
902                                case HTML_TAG_NAME:
903                                        {
904                                        setState(231); attribute();
905                                        }
906                                        break;
907                                case NEWLINE:
908                                        {
909                                        setState(232); match(NEWLINE);
910                                        }
911                                        break;
912                                case LEADING_ASTERISK:
913                                        {
914                                        setState(233); match(LEADING_ASTERISK);
915                                        }
916                                        break;
917                                case WS:
918                                        {
919                                        setState(234); match(WS);
920                                        }
921                                        break;
922                                default:
923                                        throw new NoViableAltException(this);
924                                }
925                                }
926                                setState(239);
927                                _errHandler.sync(this);
928                                _la = _input.LA(1);
929                        }
930                        setState(240); match(CLOSE);
931                        }
932                }
933                catch (RecognitionException re) {
934                        _localctx.exception = re;
935                        _errHandler.reportError(this, re);
936                        _errHandler.recover(this, re);
937                }
938                finally {
939                        exitRule();
940                }
941                return _localctx;
942        }
943
944        public static class HtmlElementCloseContext extends ParserRuleContext {
945                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
946                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
947                public TerminalNode NEWLINE(int i) {
948                        return getToken(JavadocParser.NEWLINE, i);
949                }
950                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
951                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
952                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
953                public TerminalNode LEADING_ASTERISK(int i) {
954                        return getToken(JavadocParser.LEADING_ASTERISK, i);
955                }
956                public TerminalNode WS(int i) {
957                        return getToken(JavadocParser.WS, i);
958                }
959                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
960                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
961                public HtmlElementCloseContext(ParserRuleContext parent, int invokingState) {
962                        super(parent, invokingState);
963                }
964                @Override public int getRuleIndex() { return RULE_htmlElementClose; }
965                @Override
966                public void enterRule(ParseTreeListener listener) {
967                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementClose(this);
968                }
969                @Override
970                public void exitRule(ParseTreeListener listener) {
971                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementClose(this);
972                }
973                @Override
974                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
975                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementClose(this);
976                        else return visitor.visitChildren(this);
977                }
978        }
979
980        public final HtmlElementCloseContext htmlElementClose() throws RecognitionException {
981                HtmlElementCloseContext _localctx = new HtmlElementCloseContext(_ctx, getState());
982                enterRule(_localctx, 6, RULE_htmlElementClose);
983                int _la;
984                try {
985                        enterOuterAlt(_localctx, 1);
986                        {
987                        setState(242); match(OPEN);
988                        setState(243); match(SLASH);
989                        setState(244); match(HTML_TAG_NAME);
990                        setState(248);
991                        _errHandler.sync(this);
992                        _la = _input.LA(1);
993                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
994                                {
995                                {
996                                setState(245);
997                                _la = _input.LA(1);
998                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
999                                _errHandler.recoverInline(this);
1000                                }
1001                                consume();
1002                                }
1003                                }
1004                                setState(250);
1005                                _errHandler.sync(this);
1006                                _la = _input.LA(1);
1007                        }
1008                        setState(251); match(CLOSE);
1009                        }
1010                }
1011                catch (RecognitionException re) {
1012                        _localctx.exception = re;
1013                        _errHandler.reportError(this, re);
1014                        _errHandler.recover(this, re);
1015                }
1016                finally {
1017                        exitRule();
1018                }
1019                return _localctx;
1020        }
1021
1022        public static class AttributeContext extends ParserRuleContext {
1023                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1024                public TextContext text() {
1025                        return getRuleContext(TextContext.class,0);
1026                }
1027                public TerminalNode HTML_TAG_NAME(int i) {
1028                        return getToken(JavadocParser.HTML_TAG_NAME, i);
1029                }
1030                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1031                public TerminalNode NEWLINE(int i) {
1032                        return getToken(JavadocParser.NEWLINE, i);
1033                }
1034                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1035                public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); }
1036                public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); }
1037                public TerminalNode LEADING_ASTERISK(int i) {
1038                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1039                }
1040                public TerminalNode WS(int i) {
1041                        return getToken(JavadocParser.WS, i);
1042                }
1043                public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); }
1044                public AttributeContext(ParserRuleContext parent, int invokingState) {
1045                        super(parent, invokingState);
1046                }
1047                @Override public int getRuleIndex() { return RULE_attribute; }
1048                @Override
1049                public void enterRule(ParseTreeListener listener) {
1050                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAttribute(this);
1051                }
1052                @Override
1053                public void exitRule(ParseTreeListener listener) {
1054                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAttribute(this);
1055                }
1056                @Override
1057                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1058                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAttribute(this);
1059                        else return visitor.visitChildren(this);
1060                }
1061        }
1062
1063        public final AttributeContext attribute() throws RecognitionException {
1064                AttributeContext _localctx = new AttributeContext(_ctx, getState());
1065                enterRule(_localctx, 8, RULE_attribute);
1066                int _la;
1067                try {
1068                        int _alt;
1069                        enterOuterAlt(_localctx, 1);
1070                        {
1071                        setState(253); match(HTML_TAG_NAME);
1072                        setState(257);
1073                        _errHandler.sync(this);
1074                        _la = _input.LA(1);
1075                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1076                                {
1077                                {
1078                                setState(254);
1079                                _la = _input.LA(1);
1080                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1081                                _errHandler.recoverInline(this);
1082                                }
1083                                consume();
1084                                }
1085                                }
1086                                setState(259);
1087                                _errHandler.sync(this);
1088                                _la = _input.LA(1);
1089                        }
1090                        setState(260); match(EQUALS);
1091                        setState(264);
1092                        _errHandler.sync(this);
1093                        _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
1094                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1095                                if ( _alt==1 ) {
1096                                        {
1097                                        {
1098                                        setState(261);
1099                                        _la = _input.LA(1);
1100                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1101                                        _errHandler.recoverInline(this);
1102                                        }
1103                                        consume();
1104                                        }
1105                                        } 
1106                                }
1107                                setState(266);
1108                                _errHandler.sync(this);
1109                                _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
1110                        }
1111                        setState(270);
1112                        switch (_input.LA(1)) {
1113                        case ATTR_VALUE:
1114                                {
1115                                setState(267); match(ATTR_VALUE);
1116                                }
1117                                break;
1118                        case WS:
1119                        case CHAR:
1120                                {
1121                                setState(268); text();
1122                                }
1123                                break;
1124                        case HTML_TAG_NAME:
1125                                {
1126                                setState(269); match(HTML_TAG_NAME);
1127                                }
1128                                break;
1129                        default:
1130                                throw new NoViableAltException(this);
1131                        }
1132                        }
1133                }
1134                catch (RecognitionException re) {
1135                        _localctx.exception = re;
1136                        _errHandler.reportError(this, re);
1137                        _errHandler.recover(this, re);
1138                }
1139                finally {
1140                        exitRule();
1141                }
1142                return _localctx;
1143        }
1144
1145        public static class HtmlTagContext extends ParserRuleContext {
1146                public HtmlElementOpenContext htmlElementOpen;
1147                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
1148                public TerminalNode NEWLINE(int i) {
1149                        return getToken(JavadocParser.NEWLINE, i);
1150                }
1151                public List<JavadocInlineTagContext> javadocInlineTag() {
1152                        return getRuleContexts(JavadocInlineTagContext.class);
1153                }
1154                public List<HtmlElementContext> htmlElement() {
1155                        return getRuleContexts(HtmlElementContext.class);
1156                }
1157                public TextContext text(int i) {
1158                        return getRuleContext(TextContext.class,i);
1159                }
1160                public List<HtmlCommentContext> htmlComment() {
1161                        return getRuleContexts(HtmlCommentContext.class);
1162                }
1163                public TerminalNode CDATA(int i) {
1164                        return getToken(JavadocParser.CDATA, i);
1165                }
1166                public HtmlCommentContext htmlComment(int i) {
1167                        return getRuleContext(HtmlCommentContext.class,i);
1168                }
1169                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1170                public List<TextContext> text() {
1171                        return getRuleContexts(TextContext.class);
1172                }
1173                public HtmlElementContext htmlElement(int i) {
1174                        return getRuleContext(HtmlElementContext.class,i);
1175                }
1176                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1177                public HtmlElementOpenContext htmlElementOpen() {
1178                        return getRuleContext(HtmlElementOpenContext.class,0);
1179                }
1180                public JavadocInlineTagContext javadocInlineTag(int i) {
1181                        return getRuleContext(JavadocInlineTagContext.class,i);
1182                }
1183                public HtmlElementCloseContext htmlElementClose() {
1184                        return getRuleContext(HtmlElementCloseContext.class,0);
1185                }
1186                public TerminalNode LEADING_ASTERISK(int i) {
1187                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1188                }
1189                public HtmlTagContext(ParserRuleContext parent, int invokingState) {
1190                        super(parent, invokingState);
1191                }
1192                @Override public int getRuleIndex() { return RULE_htmlTag; }
1193                @Override
1194                public void enterRule(ParseTreeListener listener) {
1195                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTag(this);
1196                }
1197                @Override
1198                public void exitRule(ParseTreeListener listener) {
1199                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTag(this);
1200                }
1201                @Override
1202                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1203                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTag(this);
1204                        else return visitor.visitChildren(this);
1205                }
1206        }
1207
1208        public final HtmlTagContext htmlTag() throws RecognitionException {
1209                HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState());
1210                enterRule(_localctx, 10, RULE_htmlTag);
1211                try {
1212                        int _alt;
1213                        setState(304);
1214                        switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
1215                        case 1:
1216                                enterOuterAlt(_localctx, 1);
1217                                {
1218                                setState(272); htmlElementOpen();
1219                                setState(283);
1220                                _errHandler.sync(this);
1221                                _alt = getInterpreter().adaptivePredict(_input,13,_ctx);
1222                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1223                                        if ( _alt==1 ) {
1224                                                {
1225                                                setState(281);
1226                                                switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
1227                                                case 1:
1228                                                        {
1229                                                        setState(273); htmlElement();
1230                                                        }
1231                                                        break;
1232
1233                                                case 2:
1234                                                        {
1235                                                        {
1236                                                        setState(274);
1237                                                        if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
1238                                                        setState(275); match(LEADING_ASTERISK);
1239                                                        }
1240                                                        }
1241                                                        break;
1242
1243                                                case 3:
1244                                                        {
1245                                                        setState(276); htmlComment();
1246                                                        }
1247                                                        break;
1248
1249                                                case 4:
1250                                                        {
1251                                                        setState(277); match(CDATA);
1252                                                        }
1253                                                        break;
1254
1255                                                case 5:
1256                                                        {
1257                                                        setState(278); match(NEWLINE);
1258                                                        }
1259                                                        break;
1260
1261                                                case 6:
1262                                                        {
1263                                                        setState(279); text();
1264                                                        }
1265                                                        break;
1266
1267                                                case 7:
1268                                                        {
1269                                                        setState(280); javadocInlineTag();
1270                                                        }
1271                                                        break;
1272                                                }
1273                                                } 
1274                                        }
1275                                        setState(285);
1276                                        _errHandler.sync(this);
1277                                        _alt = getInterpreter().adaptivePredict(_input,13,_ctx);
1278                                }
1279                                setState(286); htmlElementClose();
1280                                }
1281                                break;
1282
1283                        case 2:
1284                                enterOuterAlt(_localctx, 2);
1285                                {
1286                                setState(288); ((HtmlTagContext)_localctx).htmlElementOpen = htmlElementOpen();
1287                                setState(299);
1288                                _errHandler.sync(this);
1289                                _alt = getInterpreter().adaptivePredict(_input,15,_ctx);
1290                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1291                                        if ( _alt==1 ) {
1292                                                {
1293                                                setState(297);
1294                                                switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
1295                                                case 1:
1296                                                        {
1297                                                        setState(289); htmlElement();
1298                                                        }
1299                                                        break;
1300
1301                                                case 2:
1302                                                        {
1303                                                        {
1304                                                        setState(290);
1305                                                        if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
1306                                                        setState(291); match(LEADING_ASTERISK);
1307                                                        }
1308                                                        }
1309                                                        break;
1310
1311                                                case 3:
1312                                                        {
1313                                                        setState(292); htmlComment();
1314                                                        }
1315                                                        break;
1316
1317                                                case 4:
1318                                                        {
1319                                                        setState(293); match(CDATA);
1320                                                        }
1321                                                        break;
1322
1323                                                case 5:
1324                                                        {
1325                                                        setState(294); match(NEWLINE);
1326                                                        }
1327                                                        break;
1328
1329                                                case 6:
1330                                                        {
1331                                                        setState(295); text();
1332                                                        }
1333                                                        break;
1334
1335                                                case 7:
1336                                                        {
1337                                                        setState(296); javadocInlineTag();
1338                                                        }
1339                                                        break;
1340                                                }
1341                                                } 
1342                                        }
1343                                        setState(301);
1344                                        _errHandler.sync(this);
1345                                        _alt = getInterpreter().adaptivePredict(_input,15,_ctx);
1346                                }
1347                                notifyErrorListeners(((HtmlTagContext)_localctx).htmlElementOpen.getToken(HTML_TAG_NAME, 0).getSymbol(), "javadoc.missed.html.close", null);
1348                                }
1349                                break;
1350                        }
1351                }
1352                catch (RecognitionException re) {
1353                        _localctx.exception = re;
1354                        _errHandler.reportError(this, re);
1355                        _errHandler.recover(this, re);
1356                }
1357                finally {
1358                        exitRule();
1359                }
1360                return _localctx;
1361        }
1362
1363        public static class PTagOpenContext extends ParserRuleContext {
1364                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1365                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1366                public TerminalNode NEWLINE(int i) {
1367                        return getToken(JavadocParser.NEWLINE, i);
1368                }
1369                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1370                public List<AttributeContext> attribute() {
1371                        return getRuleContexts(AttributeContext.class);
1372                }
1373                public AttributeContext attribute(int i) {
1374                        return getRuleContext(AttributeContext.class,i);
1375                }
1376                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1377                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1378                public TerminalNode LEADING_ASTERISK(int i) {
1379                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1380                }
1381                public TerminalNode WS(int i) {
1382                        return getToken(JavadocParser.WS, i);
1383                }
1384                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
1385                public PTagOpenContext(ParserRuleContext parent, int invokingState) {
1386                        super(parent, invokingState);
1387                }
1388                @Override public int getRuleIndex() { return RULE_pTagOpen; }
1389                @Override
1390                public void enterRule(ParseTreeListener listener) {
1391                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagOpen(this);
1392                }
1393                @Override
1394                public void exitRule(ParseTreeListener listener) {
1395                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagOpen(this);
1396                }
1397                @Override
1398                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1399                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagOpen(this);
1400                        else return visitor.visitChildren(this);
1401                }
1402        }
1403
1404        public final PTagOpenContext pTagOpen() throws RecognitionException {
1405                PTagOpenContext _localctx = new PTagOpenContext(_ctx, getState());
1406                enterRule(_localctx, 12, RULE_pTagOpen);
1407                int _la;
1408                try {
1409                        enterOuterAlt(_localctx, 1);
1410                        {
1411                        setState(306); match(OPEN);
1412                        setState(307); match(P_HTML_TAG_NAME);
1413                        setState(314);
1414                        _errHandler.sync(this);
1415                        _la = _input.LA(1);
1416                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
1417                                {
1418                                setState(312);
1419                                switch (_input.LA(1)) {
1420                                case HTML_TAG_NAME:
1421                                        {
1422                                        setState(308); attribute();
1423                                        }
1424                                        break;
1425                                case NEWLINE:
1426                                        {
1427                                        setState(309); match(NEWLINE);
1428                                        }
1429                                        break;
1430                                case LEADING_ASTERISK:
1431                                        {
1432                                        setState(310); match(LEADING_ASTERISK);
1433                                        }
1434                                        break;
1435                                case WS:
1436                                        {
1437                                        setState(311); match(WS);
1438                                        }
1439                                        break;
1440                                default:
1441                                        throw new NoViableAltException(this);
1442                                }
1443                                }
1444                                setState(316);
1445                                _errHandler.sync(this);
1446                                _la = _input.LA(1);
1447                        }
1448                        setState(317); match(CLOSE);
1449                        }
1450                }
1451                catch (RecognitionException re) {
1452                        _localctx.exception = re;
1453                        _errHandler.reportError(this, re);
1454                        _errHandler.recover(this, re);
1455                }
1456                finally {
1457                        exitRule();
1458                }
1459                return _localctx;
1460        }
1461
1462        public static class PTagCloseContext extends ParserRuleContext {
1463                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1464                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1465                public TerminalNode NEWLINE(int i) {
1466                        return getToken(JavadocParser.NEWLINE, i);
1467                }
1468                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1469                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1470                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1471                public TerminalNode LEADING_ASTERISK(int i) {
1472                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1473                }
1474                public TerminalNode WS(int i) {
1475                        return getToken(JavadocParser.WS, i);
1476                }
1477                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
1478                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
1479                public PTagCloseContext(ParserRuleContext parent, int invokingState) {
1480                        super(parent, invokingState);
1481                }
1482                @Override public int getRuleIndex() { return RULE_pTagClose; }
1483                @Override
1484                public void enterRule(ParseTreeListener listener) {
1485                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagClose(this);
1486                }
1487                @Override
1488                public void exitRule(ParseTreeListener listener) {
1489                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagClose(this);
1490                }
1491                @Override
1492                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1493                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagClose(this);
1494                        else return visitor.visitChildren(this);
1495                }
1496        }
1497
1498        public final PTagCloseContext pTagClose() throws RecognitionException {
1499                PTagCloseContext _localctx = new PTagCloseContext(_ctx, getState());
1500                enterRule(_localctx, 14, RULE_pTagClose);
1501                int _la;
1502                try {
1503                        enterOuterAlt(_localctx, 1);
1504                        {
1505                        setState(319); match(OPEN);
1506                        setState(320); match(SLASH);
1507                        setState(321); match(P_HTML_TAG_NAME);
1508                        setState(325);
1509                        _errHandler.sync(this);
1510                        _la = _input.LA(1);
1511                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1512                                {
1513                                {
1514                                setState(322);
1515                                _la = _input.LA(1);
1516                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1517                                _errHandler.recoverInline(this);
1518                                }
1519                                consume();
1520                                }
1521                                }
1522                                setState(327);
1523                                _errHandler.sync(this);
1524                                _la = _input.LA(1);
1525                        }
1526                        setState(328); match(CLOSE);
1527                        }
1528                }
1529                catch (RecognitionException re) {
1530                        _localctx.exception = re;
1531                        _errHandler.reportError(this, re);
1532                        _errHandler.recover(this, re);
1533                }
1534                finally {
1535                        exitRule();
1536                }
1537                return _localctx;
1538        }
1539
1540        public static class ParagraphContext extends ParserRuleContext {
1541                public List<ColgroupTagOpenContext> colgroupTagOpen() {
1542                        return getRuleContexts(ColgroupTagOpenContext.class);
1543                }
1544                public TbodyContext tbody(int i) {
1545                        return getRuleContext(TbodyContext.class,i);
1546                }
1547                public TerminalNode CDATA(int i) {
1548                        return getToken(JavadocParser.CDATA, i);
1549                }
1550                public TfootTagOpenContext tfootTagOpen(int i) {
1551                        return getRuleContext(TfootTagOpenContext.class,i);
1552                }
1553                public List<DtTagOpenContext> dtTagOpen() {
1554                        return getRuleContexts(DtTagOpenContext.class);
1555                }
1556                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1557                public HeadContext head(int i) {
1558                        return getRuleContext(HeadContext.class,i);
1559                }
1560                public List<ColgroupContext> colgroup() {
1561                        return getRuleContexts(ColgroupContext.class);
1562                }
1563                public List<TrContext> tr() {
1564                        return getRuleContexts(TrContext.class);
1565                }
1566                public List<LiContext> li() {
1567                        return getRuleContexts(LiContext.class);
1568                }
1569                public ThTagOpenContext thTagOpen(int i) {
1570                        return getRuleContext(ThTagOpenContext.class,i);
1571                }
1572                public List<DdTagOpenContext> ddTagOpen() {
1573                        return getRuleContexts(DdTagOpenContext.class);
1574                }
1575                public ColgroupContext colgroup(int i) {
1576                        return getRuleContext(ColgroupContext.class,i);
1577                }
1578                public TdTagOpenContext tdTagOpen(int i) {
1579                        return getRuleContext(TdTagOpenContext.class,i);
1580                }
1581                public List<ThTagOpenContext> thTagOpen() {
1582                        return getRuleContexts(ThTagOpenContext.class);
1583                }
1584                public List<HeadTagOpenContext> headTagOpen() {
1585                        return getRuleContexts(HeadTagOpenContext.class);
1586                }
1587                public List<HtmlTagOpenContext> htmlTagOpen() {
1588                        return getRuleContexts(HtmlTagOpenContext.class);
1589                }
1590                public List<TbodyTagOpenContext> tbodyTagOpen() {
1591                        return getRuleContexts(TbodyTagOpenContext.class);
1592                }
1593                public List<TheadContext> thead() {
1594                        return getRuleContexts(TheadContext.class);
1595                }
1596                public LiContext li(int i) {
1597                        return getRuleContext(LiContext.class,i);
1598                }
1599                public List<TfootTagOpenContext> tfootTagOpen() {
1600                        return getRuleContexts(TfootTagOpenContext.class);
1601                }
1602                public List<TfootContext> tfoot() {
1603                        return getRuleContexts(TfootContext.class);
1604                }
1605                public List<JavadocInlineTagContext> javadocInlineTag() {
1606                        return getRuleContexts(JavadocInlineTagContext.class);
1607                }
1608                public List<HtmlCommentContext> htmlComment() {
1609                        return getRuleContexts(HtmlCommentContext.class);
1610                }
1611                public OptionContext option(int i) {
1612                        return getRuleContext(OptionContext.class,i);
1613                }
1614                public TrContext tr(int i) {
1615                        return getRuleContext(TrContext.class,i);
1616                }
1617                public List<DtContext> dt() {
1618                        return getRuleContexts(DtContext.class);
1619                }
1620                public HtmlCommentContext htmlComment(int i) {
1621                        return getRuleContext(HtmlCommentContext.class,i);
1622                }
1623                public List<TdContext> td() {
1624                        return getRuleContexts(TdContext.class);
1625                }
1626                public List<BodyTagOpenContext> bodyTagOpen() {
1627                        return getRuleContexts(BodyTagOpenContext.class);
1628                }
1629                public DtTagOpenContext dtTagOpen(int i) {
1630                        return getRuleContext(DtTagOpenContext.class,i);
1631                }
1632                public HtmlContext html(int i) {
1633                        return getRuleContext(HtmlContext.class,i);
1634                }
1635                public BodyTagOpenContext bodyTagOpen(int i) {
1636                        return getRuleContext(BodyTagOpenContext.class,i);
1637                }
1638                public DdTagOpenContext ddTagOpen(int i) {
1639                        return getRuleContext(DdTagOpenContext.class,i);
1640                }
1641                public List<HtmlTagContext> htmlTag() {
1642                        return getRuleContexts(HtmlTagContext.class);
1643                }
1644                public List<TdTagOpenContext> tdTagOpen() {
1645                        return getRuleContexts(TdTagOpenContext.class);
1646                }
1647                public OptionTagOpenContext optionTagOpen(int i) {
1648                        return getRuleContext(OptionTagOpenContext.class,i);
1649                }
1650                public PTagCloseContext pTagClose() {
1651                        return getRuleContext(PTagCloseContext.class,0);
1652                }
1653                public LiTagOpenContext liTagOpen(int i) {
1654                        return getRuleContext(LiTagOpenContext.class,i);
1655                }
1656                public TdContext td(int i) {
1657                        return getRuleContext(TdContext.class,i);
1658                }
1659                public HtmlTagContext htmlTag(int i) {
1660                        return getRuleContext(HtmlTagContext.class,i);
1661                }
1662                public List<SingletonTagContext> singletonTag() {
1663                        return getRuleContexts(SingletonTagContext.class);
1664                }
1665                public HeadTagOpenContext headTagOpen(int i) {
1666                        return getRuleContext(HeadTagOpenContext.class,i);
1667                }
1668                public TrTagOpenContext trTagOpen(int i) {
1669                        return getRuleContext(TrTagOpenContext.class,i);
1670                }
1671                public List<HtmlContext> html() {
1672                        return getRuleContexts(HtmlContext.class);
1673                }
1674                public JavadocInlineTagContext javadocInlineTag(int i) {
1675                        return getRuleContext(JavadocInlineTagContext.class,i);
1676                }
1677                public List<ThContext> th() {
1678                        return getRuleContexts(ThContext.class);
1679                }
1680                public DtContext dt(int i) {
1681                        return getRuleContext(DtContext.class,i);
1682                }
1683                public TerminalNode LEADING_ASTERISK(int i) {
1684                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1685                }
1686                public List<TrTagOpenContext> trTagOpen() {
1687                        return getRuleContexts(TrTagOpenContext.class);
1688                }
1689                public List<TbodyContext> tbody() {
1690                        return getRuleContexts(TbodyContext.class);
1691                }
1692                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
1693                public List<TheadTagOpenContext> theadTagOpen() {
1694                        return getRuleContexts(TheadTagOpenContext.class);
1695                }
1696                public List<HeadContext> head() {
1697                        return getRuleContexts(HeadContext.class);
1698                }
1699                public TerminalNode NEWLINE(int i) {
1700                        return getToken(JavadocParser.NEWLINE, i);
1701                }
1702                public TextContext text(int i) {
1703                        return getRuleContext(TextContext.class,i);
1704                }
1705                public List<BodyContext> body() {
1706                        return getRuleContexts(BodyContext.class);
1707                }
1708                public List<OptionTagOpenContext> optionTagOpen() {
1709                        return getRuleContexts(OptionTagOpenContext.class);
1710                }
1711                public List<TextContext> text() {
1712                        return getRuleContexts(TextContext.class);
1713                }
1714                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1715                public TbodyTagOpenContext tbodyTagOpen(int i) {
1716                        return getRuleContext(TbodyTagOpenContext.class,i);
1717                }
1718                public List<DdContext> dd() {
1719                        return getRuleContexts(DdContext.class);
1720                }
1721                public TheadTagOpenContext theadTagOpen(int i) {
1722                        return getRuleContext(TheadTagOpenContext.class,i);
1723                }
1724                public ColgroupTagOpenContext colgroupTagOpen(int i) {
1725                        return getRuleContext(ColgroupTagOpenContext.class,i);
1726                }
1727                public List<LiTagOpenContext> liTagOpen() {
1728                        return getRuleContexts(LiTagOpenContext.class);
1729                }
1730                public DdContext dd(int i) {
1731                        return getRuleContext(DdContext.class,i);
1732                }
1733                public List<OptionContext> option() {
1734                        return getRuleContexts(OptionContext.class);
1735                }
1736                public TheadContext thead(int i) {
1737                        return getRuleContext(TheadContext.class,i);
1738                }
1739                public BodyContext body(int i) {
1740                        return getRuleContext(BodyContext.class,i);
1741                }
1742                public ThContext th(int i) {
1743                        return getRuleContext(ThContext.class,i);
1744                }
1745                public PTagOpenContext pTagOpen() {
1746                        return getRuleContext(PTagOpenContext.class,0);
1747                }
1748                public HtmlTagOpenContext htmlTagOpen(int i) {
1749                        return getRuleContext(HtmlTagOpenContext.class,i);
1750                }
1751                public SingletonTagContext singletonTag(int i) {
1752                        return getRuleContext(SingletonTagContext.class,i);
1753                }
1754                public TfootContext tfoot(int i) {
1755                        return getRuleContext(TfootContext.class,i);
1756                }
1757                public ParagraphContext(ParserRuleContext parent, int invokingState) {
1758                        super(parent, invokingState);
1759                }
1760                @Override public int getRuleIndex() { return RULE_paragraph; }
1761                @Override
1762                public void enterRule(ParseTreeListener listener) {
1763                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParagraph(this);
1764                }
1765                @Override
1766                public void exitRule(ParseTreeListener listener) {
1767                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParagraph(this);
1768                }
1769                @Override
1770                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1771                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParagraph(this);
1772                        else return visitor.visitChildren(this);
1773                }
1774        }
1775
1776        public final ParagraphContext paragraph() throws RecognitionException {
1777                ParagraphContext _localctx = new ParagraphContext(_ctx, getState());
1778                enterRule(_localctx, 16, RULE_paragraph);
1779                try {
1780                        int _alt;
1781                        enterOuterAlt(_localctx, 1);
1782                        {
1783                        setState(330); pTagOpen();
1784                        setState(370);
1785                        _errHandler.sync(this);
1786                        _alt = getInterpreter().adaptivePredict(_input,21,_ctx);
1787                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1788                                if ( _alt==1 ) {
1789                                        {
1790                                        setState(368);
1791                                        switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
1792                                        case 1:
1793                                                {
1794                                                setState(331); htmlTag();
1795                                                }
1796                                                break;
1797
1798                                        case 2:
1799                                                {
1800                                                setState(332); singletonTag();
1801                                                }
1802                                                break;
1803
1804                                        case 3:
1805                                                {
1806                                                setState(333); li();
1807                                                }
1808                                                break;
1809
1810                                        case 4:
1811                                                {
1812                                                setState(334); tr();
1813                                                }
1814                                                break;
1815
1816                                        case 5:
1817                                                {
1818                                                setState(335); td();
1819                                                }
1820                                                break;
1821
1822                                        case 6:
1823                                                {
1824                                                setState(336); th();
1825                                                }
1826                                                break;
1827
1828                                        case 7:
1829                                                {
1830                                                setState(337); body();
1831                                                }
1832                                                break;
1833
1834                                        case 8:
1835                                                {
1836                                                setState(338); colgroup();
1837                                                }
1838                                                break;
1839
1840                                        case 9:
1841                                                {
1842                                                setState(339); dd();
1843                                                }
1844                                                break;
1845
1846                                        case 10:
1847                                                {
1848                                                setState(340); dt();
1849                                                }
1850                                                break;
1851
1852                                        case 11:
1853                                                {
1854                                                setState(341); head();
1855                                                }
1856                                                break;
1857
1858                                        case 12:
1859                                                {
1860                                                setState(342); html();
1861                                                }
1862                                                break;
1863
1864                                        case 13:
1865                                                {
1866                                                setState(343); option();
1867                                                }
1868                                                break;
1869
1870                                        case 14:
1871                                                {
1872                                                setState(344); tbody();
1873                                                }
1874                                                break;
1875
1876                                        case 15:
1877                                                {
1878                                                setState(345); thead();
1879                                                }
1880                                                break;
1881
1882                                        case 16:
1883                                                {
1884                                                setState(346); tfoot();
1885                                                }
1886                                                break;
1887
1888                                        case 17:
1889                                                {
1890                                                setState(347); liTagOpen();
1891                                                }
1892                                                break;
1893
1894                                        case 18:
1895                                                {
1896                                                setState(348); trTagOpen();
1897                                                }
1898                                                break;
1899
1900                                        case 19:
1901                                                {
1902                                                setState(349); tdTagOpen();
1903                                                }
1904                                                break;
1905
1906                                        case 20:
1907                                                {
1908                                                setState(350); thTagOpen();
1909                                                }
1910                                                break;
1911
1912                                        case 21:
1913                                                {
1914                                                setState(351); bodyTagOpen();
1915                                                }
1916                                                break;
1917
1918                                        case 22:
1919                                                {
1920                                                setState(352); colgroupTagOpen();
1921                                                }
1922                                                break;
1923
1924                                        case 23:
1925                                                {
1926                                                setState(353); ddTagOpen();
1927                                                }
1928                                                break;
1929
1930                                        case 24:
1931                                                {
1932                                                setState(354); dtTagOpen();
1933                                                }
1934                                                break;
1935
1936                                        case 25:
1937                                                {
1938                                                setState(355); headTagOpen();
1939                                                }
1940                                                break;
1941
1942                                        case 26:
1943                                                {
1944                                                setState(356); htmlTagOpen();
1945                                                }
1946                                                break;
1947
1948                                        case 27:
1949                                                {
1950                                                setState(357); optionTagOpen();
1951                                                }
1952                                                break;
1953
1954                                        case 28:
1955                                                {
1956                                                setState(358); tbodyTagOpen();
1957                                                }
1958                                                break;
1959
1960                                        case 29:
1961                                                {
1962                                                setState(359); theadTagOpen();
1963                                                }
1964                                                break;
1965
1966                                        case 30:
1967                                                {
1968                                                setState(360); tfootTagOpen();
1969                                                }
1970                                                break;
1971
1972                                        case 31:
1973                                                {
1974                                                {
1975                                                setState(361);
1976                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
1977                                                setState(362); match(LEADING_ASTERISK);
1978                                                }
1979                                                }
1980                                                break;
1981
1982                                        case 32:
1983                                                {
1984                                                setState(363); htmlComment();
1985                                                }
1986                                                break;
1987
1988                                        case 33:
1989                                                {
1990                                                setState(364); match(CDATA);
1991                                                }
1992                                                break;
1993
1994                                        case 34:
1995                                                {
1996                                                setState(365); match(NEWLINE);
1997                                                }
1998                                                break;
1999
2000                                        case 35:
2001                                                {
2002                                                setState(366); text();
2003                                                }
2004                                                break;
2005
2006                                        case 36:
2007                                                {
2008                                                setState(367); javadocInlineTag();
2009                                                }
2010                                                break;
2011                                        }
2012                                        } 
2013                                }
2014                                setState(372);
2015                                _errHandler.sync(this);
2016                                _alt = getInterpreter().adaptivePredict(_input,21,_ctx);
2017                        }
2018                        setState(373); pTagClose();
2019                        }
2020                }
2021                catch (RecognitionException re) {
2022                        _localctx.exception = re;
2023                        _errHandler.reportError(this, re);
2024                        _errHandler.recover(this, re);
2025                }
2026                finally {
2027                        exitRule();
2028                }
2029                return _localctx;
2030        }
2031
2032        public static class LiTagOpenContext extends ParserRuleContext {
2033                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2034                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
2035                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2036                public TerminalNode NEWLINE(int i) {
2037                        return getToken(JavadocParser.NEWLINE, i);
2038                }
2039                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2040                public List<AttributeContext> attribute() {
2041                        return getRuleContexts(AttributeContext.class);
2042                }
2043                public AttributeContext attribute(int i) {
2044                        return getRuleContext(AttributeContext.class,i);
2045                }
2046                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2047                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2048                public TerminalNode LEADING_ASTERISK(int i) {
2049                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2050                }
2051                public TerminalNode WS(int i) {
2052                        return getToken(JavadocParser.WS, i);
2053                }
2054                public LiTagOpenContext(ParserRuleContext parent, int invokingState) {
2055                        super(parent, invokingState);
2056                }
2057                @Override public int getRuleIndex() { return RULE_liTagOpen; }
2058                @Override
2059                public void enterRule(ParseTreeListener listener) {
2060                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagOpen(this);
2061                }
2062                @Override
2063                public void exitRule(ParseTreeListener listener) {
2064                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagOpen(this);
2065                }
2066                @Override
2067                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2068                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagOpen(this);
2069                        else return visitor.visitChildren(this);
2070                }
2071        }
2072
2073        public final LiTagOpenContext liTagOpen() throws RecognitionException {
2074                LiTagOpenContext _localctx = new LiTagOpenContext(_ctx, getState());
2075                enterRule(_localctx, 18, RULE_liTagOpen);
2076                int _la;
2077                try {
2078                        enterOuterAlt(_localctx, 1);
2079                        {
2080                        setState(375); match(OPEN);
2081                        setState(376); match(LI_HTML_TAG_NAME);
2082                        setState(383);
2083                        _errHandler.sync(this);
2084                        _la = _input.LA(1);
2085                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2086                                {
2087                                setState(381);
2088                                switch (_input.LA(1)) {
2089                                case HTML_TAG_NAME:
2090                                        {
2091                                        setState(377); attribute();
2092                                        }
2093                                        break;
2094                                case NEWLINE:
2095                                        {
2096                                        setState(378); match(NEWLINE);
2097                                        }
2098                                        break;
2099                                case LEADING_ASTERISK:
2100                                        {
2101                                        setState(379); match(LEADING_ASTERISK);
2102                                        }
2103                                        break;
2104                                case WS:
2105                                        {
2106                                        setState(380); match(WS);
2107                                        }
2108                                        break;
2109                                default:
2110                                        throw new NoViableAltException(this);
2111                                }
2112                                }
2113                                setState(385);
2114                                _errHandler.sync(this);
2115                                _la = _input.LA(1);
2116                        }
2117                        setState(386); match(CLOSE);
2118                        }
2119                }
2120                catch (RecognitionException re) {
2121                        _localctx.exception = re;
2122                        _errHandler.reportError(this, re);
2123                        _errHandler.recover(this, re);
2124                }
2125                finally {
2126                        exitRule();
2127                }
2128                return _localctx;
2129        }
2130
2131        public static class LiTagCloseContext extends ParserRuleContext {
2132                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2133                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
2134                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
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 CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2140                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2141                public TerminalNode LEADING_ASTERISK(int i) {
2142                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2143                }
2144                public TerminalNode WS(int i) {
2145                        return getToken(JavadocParser.WS, i);
2146                }
2147                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
2148                public LiTagCloseContext(ParserRuleContext parent, int invokingState) {
2149                        super(parent, invokingState);
2150                }
2151                @Override public int getRuleIndex() { return RULE_liTagClose; }
2152                @Override
2153                public void enterRule(ParseTreeListener listener) {
2154                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagClose(this);
2155                }
2156                @Override
2157                public void exitRule(ParseTreeListener listener) {
2158                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagClose(this);
2159                }
2160                @Override
2161                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2162                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagClose(this);
2163                        else return visitor.visitChildren(this);
2164                }
2165        }
2166
2167        public final LiTagCloseContext liTagClose() throws RecognitionException {
2168                LiTagCloseContext _localctx = new LiTagCloseContext(_ctx, getState());
2169                enterRule(_localctx, 20, RULE_liTagClose);
2170                int _la;
2171                try {
2172                        enterOuterAlt(_localctx, 1);
2173                        {
2174                        setState(388); match(OPEN);
2175                        setState(389); match(SLASH);
2176                        setState(390); match(LI_HTML_TAG_NAME);
2177                        setState(394);
2178                        _errHandler.sync(this);
2179                        _la = _input.LA(1);
2180                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
2181                                {
2182                                {
2183                                setState(391);
2184                                _la = _input.LA(1);
2185                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
2186                                _errHandler.recoverInline(this);
2187                                }
2188                                consume();
2189                                }
2190                                }
2191                                setState(396);
2192                                _errHandler.sync(this);
2193                                _la = _input.LA(1);
2194                        }
2195                        setState(397); match(CLOSE);
2196                        }
2197                }
2198                catch (RecognitionException re) {
2199                        _localctx.exception = re;
2200                        _errHandler.reportError(this, re);
2201                        _errHandler.recover(this, re);
2202                }
2203                finally {
2204                        exitRule();
2205                }
2206                return _localctx;
2207        }
2208
2209        public static class LiContext extends ParserRuleContext {
2210                public List<ColgroupTagOpenContext> colgroupTagOpen() {
2211                        return getRuleContexts(ColgroupTagOpenContext.class);
2212                }
2213                public TbodyContext tbody(int i) {
2214                        return getRuleContext(TbodyContext.class,i);
2215                }
2216                public TerminalNode CDATA(int i) {
2217                        return getToken(JavadocParser.CDATA, i);
2218                }
2219                public TfootTagOpenContext tfootTagOpen(int i) {
2220                        return getRuleContext(TfootTagOpenContext.class,i);
2221                }
2222                public List<DtTagOpenContext> dtTagOpen() {
2223                        return getRuleContexts(DtTagOpenContext.class);
2224                }
2225                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2226                public HeadContext head(int i) {
2227                        return getRuleContext(HeadContext.class,i);
2228                }
2229                public List<ColgroupContext> colgroup() {
2230                        return getRuleContexts(ColgroupContext.class);
2231                }
2232                public List<TrContext> tr() {
2233                        return getRuleContexts(TrContext.class);
2234                }
2235                public ThTagOpenContext thTagOpen(int i) {
2236                        return getRuleContext(ThTagOpenContext.class,i);
2237                }
2238                public List<DdTagOpenContext> ddTagOpen() {
2239                        return getRuleContexts(DdTagOpenContext.class);
2240                }
2241                public ColgroupContext colgroup(int i) {
2242                        return getRuleContext(ColgroupContext.class,i);
2243                }
2244                public TdTagOpenContext tdTagOpen(int i) {
2245                        return getRuleContext(TdTagOpenContext.class,i);
2246                }
2247                public List<ThTagOpenContext> thTagOpen() {
2248                        return getRuleContexts(ThTagOpenContext.class);
2249                }
2250                public List<HeadTagOpenContext> headTagOpen() {
2251                        return getRuleContexts(HeadTagOpenContext.class);
2252                }
2253                public List<HtmlTagOpenContext> htmlTagOpen() {
2254                        return getRuleContexts(HtmlTagOpenContext.class);
2255                }
2256                public List<TbodyTagOpenContext> tbodyTagOpen() {
2257                        return getRuleContexts(TbodyTagOpenContext.class);
2258                }
2259                public List<TheadContext> thead() {
2260                        return getRuleContexts(TheadContext.class);
2261                }
2262                public List<TfootTagOpenContext> tfootTagOpen() {
2263                        return getRuleContexts(TfootTagOpenContext.class);
2264                }
2265                public List<TfootContext> tfoot() {
2266                        return getRuleContexts(TfootContext.class);
2267                }
2268                public List<JavadocInlineTagContext> javadocInlineTag() {
2269                        return getRuleContexts(JavadocInlineTagContext.class);
2270                }
2271                public LiTagCloseContext liTagClose() {
2272                        return getRuleContext(LiTagCloseContext.class,0);
2273                }
2274                public List<HtmlCommentContext> htmlComment() {
2275                        return getRuleContexts(HtmlCommentContext.class);
2276                }
2277                public OptionContext option(int i) {
2278                        return getRuleContext(OptionContext.class,i);
2279                }
2280                public TrContext tr(int i) {
2281                        return getRuleContext(TrContext.class,i);
2282                }
2283                public List<DtContext> dt() {
2284                        return getRuleContexts(DtContext.class);
2285                }
2286                public HtmlCommentContext htmlComment(int i) {
2287                        return getRuleContext(HtmlCommentContext.class,i);
2288                }
2289                public List<TdContext> td() {
2290                        return getRuleContexts(TdContext.class);
2291                }
2292                public List<BodyTagOpenContext> bodyTagOpen() {
2293                        return getRuleContexts(BodyTagOpenContext.class);
2294                }
2295                public DtTagOpenContext dtTagOpen(int i) {
2296                        return getRuleContext(DtTagOpenContext.class,i);
2297                }
2298                public HtmlContext html(int i) {
2299                        return getRuleContext(HtmlContext.class,i);
2300                }
2301                public BodyTagOpenContext bodyTagOpen(int i) {
2302                        return getRuleContext(BodyTagOpenContext.class,i);
2303                }
2304                public DdTagOpenContext ddTagOpen(int i) {
2305                        return getRuleContext(DdTagOpenContext.class,i);
2306                }
2307                public List<HtmlTagContext> htmlTag() {
2308                        return getRuleContexts(HtmlTagContext.class);
2309                }
2310                public ParagraphContext paragraph(int i) {
2311                        return getRuleContext(ParagraphContext.class,i);
2312                }
2313                public List<TdTagOpenContext> tdTagOpen() {
2314                        return getRuleContexts(TdTagOpenContext.class);
2315                }
2316                public OptionTagOpenContext optionTagOpen(int i) {
2317                        return getRuleContext(OptionTagOpenContext.class,i);
2318                }
2319                public List<ParagraphContext> paragraph() {
2320                        return getRuleContexts(ParagraphContext.class);
2321                }
2322                public TdContext td(int i) {
2323                        return getRuleContext(TdContext.class,i);
2324                }
2325                public HtmlTagContext htmlTag(int i) {
2326                        return getRuleContext(HtmlTagContext.class,i);
2327                }
2328                public List<SingletonTagContext> singletonTag() {
2329                        return getRuleContexts(SingletonTagContext.class);
2330                }
2331                public HeadTagOpenContext headTagOpen(int i) {
2332                        return getRuleContext(HeadTagOpenContext.class,i);
2333                }
2334                public TrTagOpenContext trTagOpen(int i) {
2335                        return getRuleContext(TrTagOpenContext.class,i);
2336                }
2337                public List<HtmlContext> html() {
2338                        return getRuleContexts(HtmlContext.class);
2339                }
2340                public JavadocInlineTagContext javadocInlineTag(int i) {
2341                        return getRuleContext(JavadocInlineTagContext.class,i);
2342                }
2343                public List<ThContext> th() {
2344                        return getRuleContexts(ThContext.class);
2345                }
2346                public DtContext dt(int i) {
2347                        return getRuleContext(DtContext.class,i);
2348                }
2349                public PTagOpenContext pTagOpen(int i) {
2350                        return getRuleContext(PTagOpenContext.class,i);
2351                }
2352                public TerminalNode LEADING_ASTERISK(int i) {
2353                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2354                }
2355                public List<TrTagOpenContext> trTagOpen() {
2356                        return getRuleContexts(TrTagOpenContext.class);
2357                }
2358                public List<TbodyContext> tbody() {
2359                        return getRuleContexts(TbodyContext.class);
2360                }
2361                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
2362                public List<TheadTagOpenContext> theadTagOpen() {
2363                        return getRuleContexts(TheadTagOpenContext.class);
2364                }
2365                public List<HeadContext> head() {
2366                        return getRuleContexts(HeadContext.class);
2367                }
2368                public TerminalNode NEWLINE(int i) {
2369                        return getToken(JavadocParser.NEWLINE, i);
2370                }
2371                public TextContext text(int i) {
2372                        return getRuleContext(TextContext.class,i);
2373                }
2374                public List<BodyContext> body() {
2375                        return getRuleContexts(BodyContext.class);
2376                }
2377                public List<OptionTagOpenContext> optionTagOpen() {
2378                        return getRuleContexts(OptionTagOpenContext.class);
2379                }
2380                public List<TextContext> text() {
2381                        return getRuleContexts(TextContext.class);
2382                }
2383                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2384                public TbodyTagOpenContext tbodyTagOpen(int i) {
2385                        return getRuleContext(TbodyTagOpenContext.class,i);
2386                }
2387                public List<DdContext> dd() {
2388                        return getRuleContexts(DdContext.class);
2389                }
2390                public TheadTagOpenContext theadTagOpen(int i) {
2391                        return getRuleContext(TheadTagOpenContext.class,i);
2392                }
2393                public ColgroupTagOpenContext colgroupTagOpen(int i) {
2394                        return getRuleContext(ColgroupTagOpenContext.class,i);
2395                }
2396                public LiTagOpenContext liTagOpen() {
2397                        return getRuleContext(LiTagOpenContext.class,0);
2398                }
2399                public DdContext dd(int i) {
2400                        return getRuleContext(DdContext.class,i);
2401                }
2402                public List<OptionContext> option() {
2403                        return getRuleContexts(OptionContext.class);
2404                }
2405                public TheadContext thead(int i) {
2406                        return getRuleContext(TheadContext.class,i);
2407                }
2408                public BodyContext body(int i) {
2409                        return getRuleContext(BodyContext.class,i);
2410                }
2411                public ThContext th(int i) {
2412                        return getRuleContext(ThContext.class,i);
2413                }
2414                public List<PTagOpenContext> pTagOpen() {
2415                        return getRuleContexts(PTagOpenContext.class);
2416                }
2417                public HtmlTagOpenContext htmlTagOpen(int i) {
2418                        return getRuleContext(HtmlTagOpenContext.class,i);
2419                }
2420                public SingletonTagContext singletonTag(int i) {
2421                        return getRuleContext(SingletonTagContext.class,i);
2422                }
2423                public TfootContext tfoot(int i) {
2424                        return getRuleContext(TfootContext.class,i);
2425                }
2426                public LiContext(ParserRuleContext parent, int invokingState) {
2427                        super(parent, invokingState);
2428                }
2429                @Override public int getRuleIndex() { return RULE_li; }
2430                @Override
2431                public void enterRule(ParseTreeListener listener) {
2432                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLi(this);
2433                }
2434                @Override
2435                public void exitRule(ParseTreeListener listener) {
2436                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLi(this);
2437                }
2438                @Override
2439                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2440                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLi(this);
2441                        else return visitor.visitChildren(this);
2442                }
2443        }
2444
2445        public final LiContext li() throws RecognitionException {
2446                LiContext _localctx = new LiContext(_ctx, getState());
2447                enterRule(_localctx, 22, RULE_li);
2448                try {
2449                        int _alt;
2450                        enterOuterAlt(_localctx, 1);
2451                        {
2452                        setState(399); liTagOpen();
2453                        setState(439);
2454                        _errHandler.sync(this);
2455                        _alt = getInterpreter().adaptivePredict(_input,26,_ctx);
2456                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
2457                                if ( _alt==1 ) {
2458                                        {
2459                                        setState(437);
2460                                        switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
2461                                        case 1:
2462                                                {
2463                                                setState(400); htmlTag();
2464                                                }
2465                                                break;
2466
2467                                        case 2:
2468                                                {
2469                                                setState(401); singletonTag();
2470                                                }
2471                                                break;
2472
2473                                        case 3:
2474                                                {
2475                                                setState(402); paragraph();
2476                                                }
2477                                                break;
2478
2479                                        case 4:
2480                                                {
2481                                                setState(403); tr();
2482                                                }
2483                                                break;
2484
2485                                        case 5:
2486                                                {
2487                                                setState(404); td();
2488                                                }
2489                                                break;
2490
2491                                        case 6:
2492                                                {
2493                                                setState(405); th();
2494                                                }
2495                                                break;
2496
2497                                        case 7:
2498                                                {
2499                                                setState(406); body();
2500                                                }
2501                                                break;
2502
2503                                        case 8:
2504                                                {
2505                                                setState(407); colgroup();
2506                                                }
2507                                                break;
2508
2509                                        case 9:
2510                                                {
2511                                                setState(408); dd();
2512                                                }
2513                                                break;
2514
2515                                        case 10:
2516                                                {
2517                                                setState(409); dt();
2518                                                }
2519                                                break;
2520
2521                                        case 11:
2522                                                {
2523                                                setState(410); head();
2524                                                }
2525                                                break;
2526
2527                                        case 12:
2528                                                {
2529                                                setState(411); html();
2530                                                }
2531                                                break;
2532
2533                                        case 13:
2534                                                {
2535                                                setState(412); option();
2536                                                }
2537                                                break;
2538
2539                                        case 14:
2540                                                {
2541                                                setState(413); tbody();
2542                                                }
2543                                                break;
2544
2545                                        case 15:
2546                                                {
2547                                                setState(414); thead();
2548                                                }
2549                                                break;
2550
2551                                        case 16:
2552                                                {
2553                                                setState(415); tfoot();
2554                                                }
2555                                                break;
2556
2557                                        case 17:
2558                                                {
2559                                                setState(416); pTagOpen();
2560                                                }
2561                                                break;
2562
2563                                        case 18:
2564                                                {
2565                                                setState(417); trTagOpen();
2566                                                }
2567                                                break;
2568
2569                                        case 19:
2570                                                {
2571                                                setState(418); tdTagOpen();
2572                                                }
2573                                                break;
2574
2575                                        case 20:
2576                                                {
2577                                                setState(419); thTagOpen();
2578                                                }
2579                                                break;
2580
2581                                        case 21:
2582                                                {
2583                                                setState(420); bodyTagOpen();
2584                                                }
2585                                                break;
2586
2587                                        case 22:
2588                                                {
2589                                                setState(421); colgroupTagOpen();
2590                                                }
2591                                                break;
2592
2593                                        case 23:
2594                                                {
2595                                                setState(422); ddTagOpen();
2596                                                }
2597                                                break;
2598
2599                                        case 24:
2600                                                {
2601                                                setState(423); dtTagOpen();
2602                                                }
2603                                                break;
2604
2605                                        case 25:
2606                                                {
2607                                                setState(424); headTagOpen();
2608                                                }
2609                                                break;
2610
2611                                        case 26:
2612                                                {
2613                                                setState(425); htmlTagOpen();
2614                                                }
2615                                                break;
2616
2617                                        case 27:
2618                                                {
2619                                                setState(426); optionTagOpen();
2620                                                }
2621                                                break;
2622
2623                                        case 28:
2624                                                {
2625                                                setState(427); tbodyTagOpen();
2626                                                }
2627                                                break;
2628
2629                                        case 29:
2630                                                {
2631                                                setState(428); theadTagOpen();
2632                                                }
2633                                                break;
2634
2635                                        case 30:
2636                                                {
2637                                                setState(429); tfootTagOpen();
2638                                                }
2639                                                break;
2640
2641                                        case 31:
2642                                                {
2643                                                {
2644                                                setState(430);
2645                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
2646                                                setState(431); match(LEADING_ASTERISK);
2647                                                }
2648                                                }
2649                                                break;
2650
2651                                        case 32:
2652                                                {
2653                                                setState(432); htmlComment();
2654                                                }
2655                                                break;
2656
2657                                        case 33:
2658                                                {
2659                                                setState(433); match(CDATA);
2660                                                }
2661                                                break;
2662
2663                                        case 34:
2664                                                {
2665                                                setState(434); match(NEWLINE);
2666                                                }
2667                                                break;
2668
2669                                        case 35:
2670                                                {
2671                                                setState(435); text();
2672                                                }
2673                                                break;
2674
2675                                        case 36:
2676                                                {
2677                                                setState(436); javadocInlineTag();
2678                                                }
2679                                                break;
2680                                        }
2681                                        } 
2682                                }
2683                                setState(441);
2684                                _errHandler.sync(this);
2685                                _alt = getInterpreter().adaptivePredict(_input,26,_ctx);
2686                        }
2687                        setState(442); liTagClose();
2688                        }
2689                }
2690                catch (RecognitionException re) {
2691                        _localctx.exception = re;
2692                        _errHandler.reportError(this, re);
2693                        _errHandler.recover(this, re);
2694                }
2695                finally {
2696                        exitRule();
2697                }
2698                return _localctx;
2699        }
2700
2701        public static class TrTagOpenContext extends ParserRuleContext {
2702                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2703                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2704                public TerminalNode NEWLINE(int i) {
2705                        return getToken(JavadocParser.NEWLINE, i);
2706                }
2707                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2708                public List<AttributeContext> attribute() {
2709                        return getRuleContexts(AttributeContext.class);
2710                }
2711                public AttributeContext attribute(int i) {
2712                        return getRuleContext(AttributeContext.class,i);
2713                }
2714                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2715                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2716                public TerminalNode LEADING_ASTERISK(int i) {
2717                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2718                }
2719                public TerminalNode WS(int i) {
2720                        return getToken(JavadocParser.WS, i);
2721                }
2722                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
2723                public TrTagOpenContext(ParserRuleContext parent, int invokingState) {
2724                        super(parent, invokingState);
2725                }
2726                @Override public int getRuleIndex() { return RULE_trTagOpen; }
2727                @Override
2728                public void enterRule(ParseTreeListener listener) {
2729                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagOpen(this);
2730                }
2731                @Override
2732                public void exitRule(ParseTreeListener listener) {
2733                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagOpen(this);
2734                }
2735                @Override
2736                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2737                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagOpen(this);
2738                        else return visitor.visitChildren(this);
2739                }
2740        }
2741
2742        public final TrTagOpenContext trTagOpen() throws RecognitionException {
2743                TrTagOpenContext _localctx = new TrTagOpenContext(_ctx, getState());
2744                enterRule(_localctx, 24, RULE_trTagOpen);
2745                int _la;
2746                try {
2747                        enterOuterAlt(_localctx, 1);
2748                        {
2749                        setState(444); match(OPEN);
2750                        setState(445); match(TR_HTML_TAG_NAME);
2751                        setState(452);
2752                        _errHandler.sync(this);
2753                        _la = _input.LA(1);
2754                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2755                                {
2756                                setState(450);
2757                                switch (_input.LA(1)) {
2758                                case HTML_TAG_NAME:
2759                                        {
2760                                        setState(446); attribute();
2761                                        }
2762                                        break;
2763                                case NEWLINE:
2764                                        {
2765                                        setState(447); match(NEWLINE);
2766                                        }
2767                                        break;
2768                                case LEADING_ASTERISK:
2769                                        {
2770                                        setState(448); match(LEADING_ASTERISK);
2771                                        }
2772                                        break;
2773                                case WS:
2774                                        {
2775                                        setState(449); match(WS);
2776                                        }
2777                                        break;
2778                                default:
2779                                        throw new NoViableAltException(this);
2780                                }
2781                                }
2782                                setState(454);
2783                                _errHandler.sync(this);
2784                                _la = _input.LA(1);
2785                        }
2786                        setState(455); match(CLOSE);
2787                        }
2788                }
2789                catch (RecognitionException re) {
2790                        _localctx.exception = re;
2791                        _errHandler.reportError(this, re);
2792                        _errHandler.recover(this, re);
2793                }
2794                finally {
2795                        exitRule();
2796                }
2797                return _localctx;
2798        }
2799
2800        public static class TrTagCloseContext extends ParserRuleContext {
2801                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2802                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2803                public TerminalNode NEWLINE(int i) {
2804                        return getToken(JavadocParser.NEWLINE, i);
2805                }
2806                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2807                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2808                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2809                public TerminalNode LEADING_ASTERISK(int i) {
2810                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2811                }
2812                public TerminalNode WS(int i) {
2813                        return getToken(JavadocParser.WS, i);
2814                }
2815                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
2816                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
2817                public TrTagCloseContext(ParserRuleContext parent, int invokingState) {
2818                        super(parent, invokingState);
2819                }
2820                @Override public int getRuleIndex() { return RULE_trTagClose; }
2821                @Override
2822                public void enterRule(ParseTreeListener listener) {
2823                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagClose(this);
2824                }
2825                @Override
2826                public void exitRule(ParseTreeListener listener) {
2827                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagClose(this);
2828                }
2829                @Override
2830                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2831                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagClose(this);
2832                        else return visitor.visitChildren(this);
2833                }
2834        }
2835
2836        public final TrTagCloseContext trTagClose() throws RecognitionException {
2837                TrTagCloseContext _localctx = new TrTagCloseContext(_ctx, getState());
2838                enterRule(_localctx, 26, RULE_trTagClose);
2839                int _la;
2840                try {
2841                        enterOuterAlt(_localctx, 1);
2842                        {
2843                        setState(457); match(OPEN);
2844                        setState(458); match(SLASH);
2845                        setState(459); match(TR_HTML_TAG_NAME);
2846                        setState(463);
2847                        _errHandler.sync(this);
2848                        _la = _input.LA(1);
2849                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
2850                                {
2851                                {
2852                                setState(460);
2853                                _la = _input.LA(1);
2854                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
2855                                _errHandler.recoverInline(this);
2856                                }
2857                                consume();
2858                                }
2859                                }
2860                                setState(465);
2861                                _errHandler.sync(this);
2862                                _la = _input.LA(1);
2863                        }
2864                        setState(466); match(CLOSE);
2865                        }
2866                }
2867                catch (RecognitionException re) {
2868                        _localctx.exception = re;
2869                        _errHandler.reportError(this, re);
2870                        _errHandler.recover(this, re);
2871                }
2872                finally {
2873                        exitRule();
2874                }
2875                return _localctx;
2876        }
2877
2878        public static class TrContext extends ParserRuleContext {
2879                public List<ColgroupTagOpenContext> colgroupTagOpen() {
2880                        return getRuleContexts(ColgroupTagOpenContext.class);
2881                }
2882                public TbodyContext tbody(int i) {
2883                        return getRuleContext(TbodyContext.class,i);
2884                }
2885                public TerminalNode CDATA(int i) {
2886                        return getToken(JavadocParser.CDATA, i);
2887                }
2888                public TfootTagOpenContext tfootTagOpen(int i) {
2889                        return getRuleContext(TfootTagOpenContext.class,i);
2890                }
2891                public List<DtTagOpenContext> dtTagOpen() {
2892                        return getRuleContexts(DtTagOpenContext.class);
2893                }
2894                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2895                public HeadContext head(int i) {
2896                        return getRuleContext(HeadContext.class,i);
2897                }
2898                public List<ColgroupContext> colgroup() {
2899                        return getRuleContexts(ColgroupContext.class);
2900                }
2901                public List<LiContext> li() {
2902                        return getRuleContexts(LiContext.class);
2903                }
2904                public ThTagOpenContext thTagOpen(int i) {
2905                        return getRuleContext(ThTagOpenContext.class,i);
2906                }
2907                public List<DdTagOpenContext> ddTagOpen() {
2908                        return getRuleContexts(DdTagOpenContext.class);
2909                }
2910                public ColgroupContext colgroup(int i) {
2911                        return getRuleContext(ColgroupContext.class,i);
2912                }
2913                public TdTagOpenContext tdTagOpen(int i) {
2914                        return getRuleContext(TdTagOpenContext.class,i);
2915                }
2916                public List<ThTagOpenContext> thTagOpen() {
2917                        return getRuleContexts(ThTagOpenContext.class);
2918                }
2919                public List<HeadTagOpenContext> headTagOpen() {
2920                        return getRuleContexts(HeadTagOpenContext.class);
2921                }
2922                public List<HtmlTagOpenContext> htmlTagOpen() {
2923                        return getRuleContexts(HtmlTagOpenContext.class);
2924                }
2925                public List<TbodyTagOpenContext> tbodyTagOpen() {
2926                        return getRuleContexts(TbodyTagOpenContext.class);
2927                }
2928                public List<TheadContext> thead() {
2929                        return getRuleContexts(TheadContext.class);
2930                }
2931                public LiContext li(int i) {
2932                        return getRuleContext(LiContext.class,i);
2933                }
2934                public List<TfootTagOpenContext> tfootTagOpen() {
2935                        return getRuleContexts(TfootTagOpenContext.class);
2936                }
2937                public List<TfootContext> tfoot() {
2938                        return getRuleContexts(TfootContext.class);
2939                }
2940                public List<JavadocInlineTagContext> javadocInlineTag() {
2941                        return getRuleContexts(JavadocInlineTagContext.class);
2942                }
2943                public List<HtmlCommentContext> htmlComment() {
2944                        return getRuleContexts(HtmlCommentContext.class);
2945                }
2946                public OptionContext option(int i) {
2947                        return getRuleContext(OptionContext.class,i);
2948                }
2949                public List<DtContext> dt() {
2950                        return getRuleContexts(DtContext.class);
2951                }
2952                public HtmlCommentContext htmlComment(int i) {
2953                        return getRuleContext(HtmlCommentContext.class,i);
2954                }
2955                public List<TdContext> td() {
2956                        return getRuleContexts(TdContext.class);
2957                }
2958                public List<BodyTagOpenContext> bodyTagOpen() {
2959                        return getRuleContexts(BodyTagOpenContext.class);
2960                }
2961                public DtTagOpenContext dtTagOpen(int i) {
2962                        return getRuleContext(DtTagOpenContext.class,i);
2963                }
2964                public HtmlContext html(int i) {
2965                        return getRuleContext(HtmlContext.class,i);
2966                }
2967                public BodyTagOpenContext bodyTagOpen(int i) {
2968                        return getRuleContext(BodyTagOpenContext.class,i);
2969                }
2970                public DdTagOpenContext ddTagOpen(int i) {
2971                        return getRuleContext(DdTagOpenContext.class,i);
2972                }
2973                public TrTagCloseContext trTagClose() {
2974                        return getRuleContext(TrTagCloseContext.class,0);
2975                }
2976                public List<HtmlTagContext> htmlTag() {
2977                        return getRuleContexts(HtmlTagContext.class);
2978                }
2979                public ParagraphContext paragraph(int i) {
2980                        return getRuleContext(ParagraphContext.class,i);
2981                }
2982                public List<TdTagOpenContext> tdTagOpen() {
2983                        return getRuleContexts(TdTagOpenContext.class);
2984                }
2985                public OptionTagOpenContext optionTagOpen(int i) {
2986                        return getRuleContext(OptionTagOpenContext.class,i);
2987                }
2988                public LiTagOpenContext liTagOpen(int i) {
2989                        return getRuleContext(LiTagOpenContext.class,i);
2990                }
2991                public List<ParagraphContext> paragraph() {
2992                        return getRuleContexts(ParagraphContext.class);
2993                }
2994                public TdContext td(int i) {
2995                        return getRuleContext(TdContext.class,i);
2996                }
2997                public HtmlTagContext htmlTag(int i) {
2998                        return getRuleContext(HtmlTagContext.class,i);
2999                }
3000                public List<SingletonTagContext> singletonTag() {
3001                        return getRuleContexts(SingletonTagContext.class);
3002                }
3003                public HeadTagOpenContext headTagOpen(int i) {
3004                        return getRuleContext(HeadTagOpenContext.class,i);
3005                }
3006                public List<HtmlContext> html() {
3007                        return getRuleContexts(HtmlContext.class);
3008                }
3009                public JavadocInlineTagContext javadocInlineTag(int i) {
3010                        return getRuleContext(JavadocInlineTagContext.class,i);
3011                }
3012                public List<ThContext> th() {
3013                        return getRuleContexts(ThContext.class);
3014                }
3015                public DtContext dt(int i) {
3016                        return getRuleContext(DtContext.class,i);
3017                }
3018                public PTagOpenContext pTagOpen(int i) {
3019                        return getRuleContext(PTagOpenContext.class,i);
3020                }
3021                public TerminalNode LEADING_ASTERISK(int i) {
3022                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3023                }
3024                public TrTagOpenContext trTagOpen() {
3025                        return getRuleContext(TrTagOpenContext.class,0);
3026                }
3027                public List<TbodyContext> tbody() {
3028                        return getRuleContexts(TbodyContext.class);
3029                }
3030                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
3031                public List<TheadTagOpenContext> theadTagOpen() {
3032                        return getRuleContexts(TheadTagOpenContext.class);
3033                }
3034                public List<HeadContext> head() {
3035                        return getRuleContexts(HeadContext.class);
3036                }
3037                public TerminalNode NEWLINE(int i) {
3038                        return getToken(JavadocParser.NEWLINE, i);
3039                }
3040                public TextContext text(int i) {
3041                        return getRuleContext(TextContext.class,i);
3042                }
3043                public List<BodyContext> body() {
3044                        return getRuleContexts(BodyContext.class);
3045                }
3046                public List<OptionTagOpenContext> optionTagOpen() {
3047                        return getRuleContexts(OptionTagOpenContext.class);
3048                }
3049                public List<TextContext> text() {
3050                        return getRuleContexts(TextContext.class);
3051                }
3052                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3053                public TbodyTagOpenContext tbodyTagOpen(int i) {
3054                        return getRuleContext(TbodyTagOpenContext.class,i);
3055                }
3056                public List<DdContext> dd() {
3057                        return getRuleContexts(DdContext.class);
3058                }
3059                public TheadTagOpenContext theadTagOpen(int i) {
3060                        return getRuleContext(TheadTagOpenContext.class,i);
3061                }
3062                public ColgroupTagOpenContext colgroupTagOpen(int i) {
3063                        return getRuleContext(ColgroupTagOpenContext.class,i);
3064                }
3065                public List<LiTagOpenContext> liTagOpen() {
3066                        return getRuleContexts(LiTagOpenContext.class);
3067                }
3068                public DdContext dd(int i) {
3069                        return getRuleContext(DdContext.class,i);
3070                }
3071                public List<OptionContext> option() {
3072                        return getRuleContexts(OptionContext.class);
3073                }
3074                public TheadContext thead(int i) {
3075                        return getRuleContext(TheadContext.class,i);
3076                }
3077                public BodyContext body(int i) {
3078                        return getRuleContext(BodyContext.class,i);
3079                }
3080                public ThContext th(int i) {
3081                        return getRuleContext(ThContext.class,i);
3082                }
3083                public List<PTagOpenContext> pTagOpen() {
3084                        return getRuleContexts(PTagOpenContext.class);
3085                }
3086                public HtmlTagOpenContext htmlTagOpen(int i) {
3087                        return getRuleContext(HtmlTagOpenContext.class,i);
3088                }
3089                public SingletonTagContext singletonTag(int i) {
3090                        return getRuleContext(SingletonTagContext.class,i);
3091                }
3092                public TfootContext tfoot(int i) {
3093                        return getRuleContext(TfootContext.class,i);
3094                }
3095                public TrContext(ParserRuleContext parent, int invokingState) {
3096                        super(parent, invokingState);
3097                }
3098                @Override public int getRuleIndex() { return RULE_tr; }
3099                @Override
3100                public void enterRule(ParseTreeListener listener) {
3101                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTr(this);
3102                }
3103                @Override
3104                public void exitRule(ParseTreeListener listener) {
3105                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTr(this);
3106                }
3107                @Override
3108                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3109                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTr(this);
3110                        else return visitor.visitChildren(this);
3111                }
3112        }
3113
3114        public final TrContext tr() throws RecognitionException {
3115                TrContext _localctx = new TrContext(_ctx, getState());
3116                enterRule(_localctx, 28, RULE_tr);
3117                try {
3118                        int _alt;
3119                        enterOuterAlt(_localctx, 1);
3120                        {
3121                        setState(468); trTagOpen();
3122                        setState(508);
3123                        _errHandler.sync(this);
3124                        _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
3125                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3126                                if ( _alt==1 ) {
3127                                        {
3128                                        setState(506);
3129                                        switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
3130                                        case 1:
3131                                                {
3132                                                setState(469); htmlTag();
3133                                                }
3134                                                break;
3135
3136                                        case 2:
3137                                                {
3138                                                setState(470); singletonTag();
3139                                                }
3140                                                break;
3141
3142                                        case 3:
3143                                                {
3144                                                setState(471); paragraph();
3145                                                }
3146                                                break;
3147
3148                                        case 4:
3149                                                {
3150                                                setState(472); li();
3151                                                }
3152                                                break;
3153
3154                                        case 5:
3155                                                {
3156                                                setState(473); td();
3157                                                }
3158                                                break;
3159
3160                                        case 6:
3161                                                {
3162                                                setState(474); th();
3163                                                }
3164                                                break;
3165
3166                                        case 7:
3167                                                {
3168                                                setState(475); body();
3169                                                }
3170                                                break;
3171
3172                                        case 8:
3173                                                {
3174                                                setState(476); colgroup();
3175                                                }
3176                                                break;
3177
3178                                        case 9:
3179                                                {
3180                                                setState(477); dd();
3181                                                }
3182                                                break;
3183
3184                                        case 10:
3185                                                {
3186                                                setState(478); dt();
3187                                                }
3188                                                break;
3189
3190                                        case 11:
3191                                                {
3192                                                setState(479); head();
3193                                                }
3194                                                break;
3195
3196                                        case 12:
3197                                                {
3198                                                setState(480); html();
3199                                                }
3200                                                break;
3201
3202                                        case 13:
3203                                                {
3204                                                setState(481); option();
3205                                                }
3206                                                break;
3207
3208                                        case 14:
3209                                                {
3210                                                setState(482); tbody();
3211                                                }
3212                                                break;
3213
3214                                        case 15:
3215                                                {
3216                                                setState(483); thead();
3217                                                }
3218                                                break;
3219
3220                                        case 16:
3221                                                {
3222                                                setState(484); tfoot();
3223                                                }
3224                                                break;
3225
3226                                        case 17:
3227                                                {
3228                                                setState(485); pTagOpen();
3229                                                }
3230                                                break;
3231
3232                                        case 18:
3233                                                {
3234                                                setState(486); liTagOpen();
3235                                                }
3236                                                break;
3237
3238                                        case 19:
3239                                                {
3240                                                setState(487); tdTagOpen();
3241                                                }
3242                                                break;
3243
3244                                        case 20:
3245                                                {
3246                                                setState(488); thTagOpen();
3247                                                }
3248                                                break;
3249
3250                                        case 21:
3251                                                {
3252                                                setState(489); bodyTagOpen();
3253                                                }
3254                                                break;
3255
3256                                        case 22:
3257                                                {
3258                                                setState(490); colgroupTagOpen();
3259                                                }
3260                                                break;
3261
3262                                        case 23:
3263                                                {
3264                                                setState(491); ddTagOpen();
3265                                                }
3266                                                break;
3267
3268                                        case 24:
3269                                                {
3270                                                setState(492); dtTagOpen();
3271                                                }
3272                                                break;
3273
3274                                        case 25:
3275                                                {
3276                                                setState(493); headTagOpen();
3277                                                }
3278                                                break;
3279
3280                                        case 26:
3281                                                {
3282                                                setState(494); htmlTagOpen();
3283                                                }
3284                                                break;
3285
3286                                        case 27:
3287                                                {
3288                                                setState(495); optionTagOpen();
3289                                                }
3290                                                break;
3291
3292                                        case 28:
3293                                                {
3294                                                setState(496); tbodyTagOpen();
3295                                                }
3296                                                break;
3297
3298                                        case 29:
3299                                                {
3300                                                setState(497); theadTagOpen();
3301                                                }
3302                                                break;
3303
3304                                        case 30:
3305                                                {
3306                                                setState(498); tfootTagOpen();
3307                                                }
3308                                                break;
3309
3310                                        case 31:
3311                                                {
3312                                                {
3313                                                setState(499);
3314                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
3315                                                setState(500); match(LEADING_ASTERISK);
3316                                                }
3317                                                }
3318                                                break;
3319
3320                                        case 32:
3321                                                {
3322                                                setState(501); htmlComment();
3323                                                }
3324                                                break;
3325
3326                                        case 33:
3327                                                {
3328                                                setState(502); match(CDATA);
3329                                                }
3330                                                break;
3331
3332                                        case 34:
3333                                                {
3334                                                setState(503); match(NEWLINE);
3335                                                }
3336                                                break;
3337
3338                                        case 35:
3339                                                {
3340                                                setState(504); text();
3341                                                }
3342                                                break;
3343
3344                                        case 36:
3345                                                {
3346                                                setState(505); javadocInlineTag();
3347                                                }
3348                                                break;
3349                                        }
3350                                        } 
3351                                }
3352                                setState(510);
3353                                _errHandler.sync(this);
3354                                _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
3355                        }
3356                        setState(511); trTagClose();
3357                        }
3358                }
3359                catch (RecognitionException re) {
3360                        _localctx.exception = re;
3361                        _errHandler.reportError(this, re);
3362                        _errHandler.recover(this, re);
3363                }
3364                finally {
3365                        exitRule();
3366                }
3367                return _localctx;
3368        }
3369
3370        public static class TdTagOpenContext extends ParserRuleContext {
3371                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3372                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
3373                public TerminalNode NEWLINE(int i) {
3374                        return getToken(JavadocParser.NEWLINE, i);
3375                }
3376                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3377                public List<AttributeContext> attribute() {
3378                        return getRuleContexts(AttributeContext.class);
3379                }
3380                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
3381                public AttributeContext attribute(int i) {
3382                        return getRuleContext(AttributeContext.class,i);
3383                }
3384                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
3385                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
3386                public TerminalNode LEADING_ASTERISK(int i) {
3387                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3388                }
3389                public TerminalNode WS(int i) {
3390                        return getToken(JavadocParser.WS, i);
3391                }
3392                public TdTagOpenContext(ParserRuleContext parent, int invokingState) {
3393                        super(parent, invokingState);
3394                }
3395                @Override public int getRuleIndex() { return RULE_tdTagOpen; }
3396                @Override
3397                public void enterRule(ParseTreeListener listener) {
3398                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagOpen(this);
3399                }
3400                @Override
3401                public void exitRule(ParseTreeListener listener) {
3402                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagOpen(this);
3403                }
3404                @Override
3405                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3406                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagOpen(this);
3407                        else return visitor.visitChildren(this);
3408                }
3409        }
3410
3411        public final TdTagOpenContext tdTagOpen() throws RecognitionException {
3412                TdTagOpenContext _localctx = new TdTagOpenContext(_ctx, getState());
3413                enterRule(_localctx, 30, RULE_tdTagOpen);
3414                int _la;
3415                try {
3416                        enterOuterAlt(_localctx, 1);
3417                        {
3418                        setState(513); match(OPEN);
3419                        setState(514); match(TD_HTML_TAG_NAME);
3420                        setState(521);
3421                        _errHandler.sync(this);
3422                        _la = _input.LA(1);
3423                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
3424                                {
3425                                setState(519);
3426                                switch (_input.LA(1)) {
3427                                case HTML_TAG_NAME:
3428                                        {
3429                                        setState(515); attribute();
3430                                        }
3431                                        break;
3432                                case NEWLINE:
3433                                        {
3434                                        setState(516); match(NEWLINE);
3435                                        }
3436                                        break;
3437                                case LEADING_ASTERISK:
3438                                        {
3439                                        setState(517); match(LEADING_ASTERISK);
3440                                        }
3441                                        break;
3442                                case WS:
3443                                        {
3444                                        setState(518); match(WS);
3445                                        }
3446                                        break;
3447                                default:
3448                                        throw new NoViableAltException(this);
3449                                }
3450                                }
3451                                setState(523);
3452                                _errHandler.sync(this);
3453                                _la = _input.LA(1);
3454                        }
3455                        setState(524); match(CLOSE);
3456                        }
3457                }
3458                catch (RecognitionException re) {
3459                        _localctx.exception = re;
3460                        _errHandler.reportError(this, re);
3461                        _errHandler.recover(this, re);
3462                }
3463                finally {
3464                        exitRule();
3465                }
3466                return _localctx;
3467        }
3468
3469        public static class TdTagCloseContext extends ParserRuleContext {
3470                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3471                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
3472                public TerminalNode NEWLINE(int i) {
3473                        return getToken(JavadocParser.NEWLINE, i);
3474                }
3475                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3476                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
3477                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
3478                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
3479                public TerminalNode LEADING_ASTERISK(int i) {
3480                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3481                }
3482                public TerminalNode WS(int i) {
3483                        return getToken(JavadocParser.WS, i);
3484                }
3485                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
3486                public TdTagCloseContext(ParserRuleContext parent, int invokingState) {
3487                        super(parent, invokingState);
3488                }
3489                @Override public int getRuleIndex() { return RULE_tdTagClose; }
3490                @Override
3491                public void enterRule(ParseTreeListener listener) {
3492                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagClose(this);
3493                }
3494                @Override
3495                public void exitRule(ParseTreeListener listener) {
3496                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagClose(this);
3497                }
3498                @Override
3499                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3500                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagClose(this);
3501                        else return visitor.visitChildren(this);
3502                }
3503        }
3504
3505        public final TdTagCloseContext tdTagClose() throws RecognitionException {
3506                TdTagCloseContext _localctx = new TdTagCloseContext(_ctx, getState());
3507                enterRule(_localctx, 32, RULE_tdTagClose);
3508                int _la;
3509                try {
3510                        enterOuterAlt(_localctx, 1);
3511                        {
3512                        setState(526); match(OPEN);
3513                        setState(527); match(SLASH);
3514                        setState(528); match(TD_HTML_TAG_NAME);
3515                        setState(532);
3516                        _errHandler.sync(this);
3517                        _la = _input.LA(1);
3518                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
3519                                {
3520                                {
3521                                setState(529);
3522                                _la = _input.LA(1);
3523                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
3524                                _errHandler.recoverInline(this);
3525                                }
3526                                consume();
3527                                }
3528                                }
3529                                setState(534);
3530                                _errHandler.sync(this);
3531                                _la = _input.LA(1);
3532                        }
3533                        setState(535); match(CLOSE);
3534                        }
3535                }
3536                catch (RecognitionException re) {
3537                        _localctx.exception = re;
3538                        _errHandler.reportError(this, re);
3539                        _errHandler.recover(this, re);
3540                }
3541                finally {
3542                        exitRule();
3543                }
3544                return _localctx;
3545        }
3546
3547        public static class TdContext extends ParserRuleContext {
3548                public List<ColgroupTagOpenContext> colgroupTagOpen() {
3549                        return getRuleContexts(ColgroupTagOpenContext.class);
3550                }
3551                public TbodyContext tbody(int i) {
3552                        return getRuleContext(TbodyContext.class,i);
3553                }
3554                public TerminalNode CDATA(int i) {
3555                        return getToken(JavadocParser.CDATA, i);
3556                }
3557                public TfootTagOpenContext tfootTagOpen(int i) {
3558                        return getRuleContext(TfootTagOpenContext.class,i);
3559                }
3560                public List<DtTagOpenContext> dtTagOpen() {
3561                        return getRuleContexts(DtTagOpenContext.class);
3562                }
3563                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3564                public List<ColgroupContext> colgroup() {
3565                        return getRuleContexts(ColgroupContext.class);
3566                }
3567                public HeadContext head(int i) {
3568                        return getRuleContext(HeadContext.class,i);
3569                }
3570                public List<TrContext> tr() {
3571                        return getRuleContexts(TrContext.class);
3572                }
3573                public List<LiContext> li() {
3574                        return getRuleContexts(LiContext.class);
3575                }
3576                public ThTagOpenContext thTagOpen(int i) {
3577                        return getRuleContext(ThTagOpenContext.class,i);
3578                }
3579                public List<DdTagOpenContext> ddTagOpen() {
3580                        return getRuleContexts(DdTagOpenContext.class);
3581                }
3582                public ColgroupContext colgroup(int i) {
3583                        return getRuleContext(ColgroupContext.class,i);
3584                }
3585                public TdTagOpenContext tdTagOpen(int i) {
3586                        return getRuleContext(TdTagOpenContext.class,i);
3587                }
3588                public List<ThTagOpenContext> thTagOpen() {
3589                        return getRuleContexts(ThTagOpenContext.class);
3590                }
3591                public List<HeadTagOpenContext> headTagOpen() {
3592                        return getRuleContexts(HeadTagOpenContext.class);
3593                }
3594                public List<HtmlTagOpenContext> htmlTagOpen() {
3595                        return getRuleContexts(HtmlTagOpenContext.class);
3596                }
3597                public List<TbodyTagOpenContext> tbodyTagOpen() {
3598                        return getRuleContexts(TbodyTagOpenContext.class);
3599                }
3600                public List<TheadContext> thead() {
3601                        return getRuleContexts(TheadContext.class);
3602                }
3603                public LiContext li(int i) {
3604                        return getRuleContext(LiContext.class,i);
3605                }
3606                public List<TfootTagOpenContext> tfootTagOpen() {
3607                        return getRuleContexts(TfootTagOpenContext.class);
3608                }
3609                public List<TfootContext> tfoot() {
3610                        return getRuleContexts(TfootContext.class);
3611                }
3612                public List<JavadocInlineTagContext> javadocInlineTag() {
3613                        return getRuleContexts(JavadocInlineTagContext.class);
3614                }
3615                public List<HtmlCommentContext> htmlComment() {
3616                        return getRuleContexts(HtmlCommentContext.class);
3617                }
3618                public OptionContext option(int i) {
3619                        return getRuleContext(OptionContext.class,i);
3620                }
3621                public TrContext tr(int i) {
3622                        return getRuleContext(TrContext.class,i);
3623                }
3624                public List<DtContext> dt() {
3625                        return getRuleContexts(DtContext.class);
3626                }
3627                public HtmlCommentContext htmlComment(int i) {
3628                        return getRuleContext(HtmlCommentContext.class,i);
3629                }
3630                public List<BodyTagOpenContext> bodyTagOpen() {
3631                        return getRuleContexts(BodyTagOpenContext.class);
3632                }
3633                public DtTagOpenContext dtTagOpen(int i) {
3634                        return getRuleContext(DtTagOpenContext.class,i);
3635                }
3636                public HtmlContext html(int i) {
3637                        return getRuleContext(HtmlContext.class,i);
3638                }
3639                public BodyTagOpenContext bodyTagOpen(int i) {
3640                        return getRuleContext(BodyTagOpenContext.class,i);
3641                }
3642                public DdTagOpenContext ddTagOpen(int i) {
3643                        return getRuleContext(DdTagOpenContext.class,i);
3644                }
3645                public List<TdTagOpenContext> tdTagOpen() {
3646                        return getRuleContexts(TdTagOpenContext.class);
3647                }
3648                public List<HtmlTagContext> htmlTag() {
3649                        return getRuleContexts(HtmlTagContext.class);
3650                }
3651                public ParagraphContext paragraph(int i) {
3652                        return getRuleContext(ParagraphContext.class,i);
3653                }
3654                public OptionTagOpenContext optionTagOpen(int i) {
3655                        return getRuleContext(OptionTagOpenContext.class,i);
3656                }
3657                public LiTagOpenContext liTagOpen(int i) {
3658                        return getRuleContext(LiTagOpenContext.class,i);
3659                }
3660                public List<ParagraphContext> paragraph() {
3661                        return getRuleContexts(ParagraphContext.class);
3662                }
3663                public HtmlTagContext htmlTag(int i) {
3664                        return getRuleContext(HtmlTagContext.class,i);
3665                }
3666                public List<SingletonTagContext> singletonTag() {
3667                        return getRuleContexts(SingletonTagContext.class);
3668                }
3669                public HeadTagOpenContext headTagOpen(int i) {
3670                        return getRuleContext(HeadTagOpenContext.class,i);
3671                }
3672                public List<HtmlContext> html() {
3673                        return getRuleContexts(HtmlContext.class);
3674                }
3675                public JavadocInlineTagContext javadocInlineTag(int i) {
3676                        return getRuleContext(JavadocInlineTagContext.class,i);
3677                }
3678                public List<ThContext> th() {
3679                        return getRuleContexts(ThContext.class);
3680                }
3681                public DtContext dt(int i) {
3682                        return getRuleContext(DtContext.class,i);
3683                }
3684                public PTagOpenContext pTagOpen(int i) {
3685                        return getRuleContext(PTagOpenContext.class,i);
3686                }
3687                public TerminalNode LEADING_ASTERISK(int i) {
3688                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3689                }
3690                public List<TbodyContext> tbody() {
3691                        return getRuleContexts(TbodyContext.class);
3692                }
3693                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
3694                public List<TheadTagOpenContext> theadTagOpen() {
3695                        return getRuleContexts(TheadTagOpenContext.class);
3696                }
3697                public List<HeadContext> head() {
3698                        return getRuleContexts(HeadContext.class);
3699                }
3700                public TerminalNode NEWLINE(int i) {
3701                        return getToken(JavadocParser.NEWLINE, i);
3702                }
3703                public TextContext text(int i) {
3704                        return getRuleContext(TextContext.class,i);
3705                }
3706                public List<BodyContext> body() {
3707                        return getRuleContexts(BodyContext.class);
3708                }
3709                public List<OptionTagOpenContext> optionTagOpen() {
3710                        return getRuleContexts(OptionTagOpenContext.class);
3711                }
3712                public List<TextContext> text() {
3713                        return getRuleContexts(TextContext.class);
3714                }
3715                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3716                public TbodyTagOpenContext tbodyTagOpen(int i) {
3717                        return getRuleContext(TbodyTagOpenContext.class,i);
3718                }
3719                public List<DdContext> dd() {
3720                        return getRuleContexts(DdContext.class);
3721                }
3722                public TheadTagOpenContext theadTagOpen(int i) {
3723                        return getRuleContext(TheadTagOpenContext.class,i);
3724                }
3725                public ColgroupTagOpenContext colgroupTagOpen(int i) {
3726                        return getRuleContext(ColgroupTagOpenContext.class,i);
3727                }
3728                public TdTagCloseContext tdTagClose() {
3729                        return getRuleContext(TdTagCloseContext.class,0);
3730                }
3731                public List<LiTagOpenContext> liTagOpen() {
3732                        return getRuleContexts(LiTagOpenContext.class);
3733                }
3734                public DdContext dd(int i) {
3735                        return getRuleContext(DdContext.class,i);
3736                }
3737                public List<OptionContext> option() {
3738                        return getRuleContexts(OptionContext.class);
3739                }
3740                public TheadContext thead(int i) {
3741                        return getRuleContext(TheadContext.class,i);
3742                }
3743                public BodyContext body(int i) {
3744                        return getRuleContext(BodyContext.class,i);
3745                }
3746                public ThContext th(int i) {
3747                        return getRuleContext(ThContext.class,i);
3748                }
3749                public List<PTagOpenContext> pTagOpen() {
3750                        return getRuleContexts(PTagOpenContext.class);
3751                }
3752                public HtmlTagOpenContext htmlTagOpen(int i) {
3753                        return getRuleContext(HtmlTagOpenContext.class,i);
3754                }
3755                public SingletonTagContext singletonTag(int i) {
3756                        return getRuleContext(SingletonTagContext.class,i);
3757                }
3758                public TfootContext tfoot(int i) {
3759                        return getRuleContext(TfootContext.class,i);
3760                }
3761                public TdContext(ParserRuleContext parent, int invokingState) {
3762                        super(parent, invokingState);
3763                }
3764                @Override public int getRuleIndex() { return RULE_td; }
3765                @Override
3766                public void enterRule(ParseTreeListener listener) {
3767                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTd(this);
3768                }
3769                @Override
3770                public void exitRule(ParseTreeListener listener) {
3771                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTd(this);
3772                }
3773                @Override
3774                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3775                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTd(this);
3776                        else return visitor.visitChildren(this);
3777                }
3778        }
3779
3780        public final TdContext td() throws RecognitionException {
3781                TdContext _localctx = new TdContext(_ctx, getState());
3782                enterRule(_localctx, 34, RULE_td);
3783                try {
3784                        int _alt;
3785                        enterOuterAlt(_localctx, 1);
3786                        {
3787                        setState(537); tdTagOpen();
3788                        setState(577);
3789                        _errHandler.sync(this);
3790                        _alt = getInterpreter().adaptivePredict(_input,36,_ctx);
3791                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3792                                if ( _alt==1 ) {
3793                                        {
3794                                        setState(575);
3795                                        switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
3796                                        case 1:
3797                                                {
3798                                                setState(538); htmlTag();
3799                                                }
3800                                                break;
3801
3802                                        case 2:
3803                                                {
3804                                                setState(539); singletonTag();
3805                                                }
3806                                                break;
3807
3808                                        case 3:
3809                                                {
3810                                                setState(540); paragraph();
3811                                                }
3812                                                break;
3813
3814                                        case 4:
3815                                                {
3816                                                setState(541); li();
3817                                                }
3818                                                break;
3819
3820                                        case 5:
3821                                                {
3822                                                setState(542); tr();
3823                                                }
3824                                                break;
3825
3826                                        case 6:
3827                                                {
3828                                                setState(543); th();
3829                                                }
3830                                                break;
3831
3832                                        case 7:
3833                                                {
3834                                                setState(544); body();
3835                                                }
3836                                                break;
3837
3838                                        case 8:
3839                                                {
3840                                                setState(545); colgroup();
3841                                                }
3842                                                break;
3843
3844                                        case 9:
3845                                                {
3846                                                setState(546); dd();
3847                                                }
3848                                                break;
3849
3850                                        case 10:
3851                                                {
3852                                                setState(547); dt();
3853                                                }
3854                                                break;
3855
3856                                        case 11:
3857                                                {
3858                                                setState(548); head();
3859                                                }
3860                                                break;
3861
3862                                        case 12:
3863                                                {
3864                                                setState(549); html();
3865                                                }
3866                                                break;
3867
3868                                        case 13:
3869                                                {
3870                                                setState(550); option();
3871                                                }
3872                                                break;
3873
3874                                        case 14:
3875                                                {
3876                                                setState(551); tbody();
3877                                                }
3878                                                break;
3879
3880                                        case 15:
3881                                                {
3882                                                setState(552); thead();
3883                                                }
3884                                                break;
3885
3886                                        case 16:
3887                                                {
3888                                                setState(553); tfoot();
3889                                                }
3890                                                break;
3891
3892                                        case 17:
3893                                                {
3894                                                setState(554); pTagOpen();
3895                                                }
3896                                                break;
3897
3898                                        case 18:
3899                                                {
3900                                                setState(555); liTagOpen();
3901                                                }
3902                                                break;
3903
3904                                        case 19:
3905                                                {
3906                                                setState(556); tdTagOpen();
3907                                                }
3908                                                break;
3909
3910                                        case 20:
3911                                                {
3912                                                setState(557); thTagOpen();
3913                                                }
3914                                                break;
3915
3916                                        case 21:
3917                                                {
3918                                                setState(558); bodyTagOpen();
3919                                                }
3920                                                break;
3921
3922                                        case 22:
3923                                                {
3924                                                setState(559); colgroupTagOpen();
3925                                                }
3926                                                break;
3927
3928                                        case 23:
3929                                                {
3930                                                setState(560); ddTagOpen();
3931                                                }
3932                                                break;
3933
3934                                        case 24:
3935                                                {
3936                                                setState(561); dtTagOpen();
3937                                                }
3938                                                break;
3939
3940                                        case 25:
3941                                                {
3942                                                setState(562); headTagOpen();
3943                                                }
3944                                                break;
3945
3946                                        case 26:
3947                                                {
3948                                                setState(563); htmlTagOpen();
3949                                                }
3950                                                break;
3951
3952                                        case 27:
3953                                                {
3954                                                setState(564); optionTagOpen();
3955                                                }
3956                                                break;
3957
3958                                        case 28:
3959                                                {
3960                                                setState(565); tbodyTagOpen();
3961                                                }
3962                                                break;
3963
3964                                        case 29:
3965                                                {
3966                                                setState(566); theadTagOpen();
3967                                                }
3968                                                break;
3969
3970                                        case 30:
3971                                                {
3972                                                setState(567); tfootTagOpen();
3973                                                }
3974                                                break;
3975
3976                                        case 31:
3977                                                {
3978                                                {
3979                                                setState(568);
3980                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
3981                                                setState(569); match(LEADING_ASTERISK);
3982                                                }
3983                                                }
3984                                                break;
3985
3986                                        case 32:
3987                                                {
3988                                                setState(570); htmlComment();
3989                                                }
3990                                                break;
3991
3992                                        case 33:
3993                                                {
3994                                                setState(571); match(CDATA);
3995                                                }
3996                                                break;
3997
3998                                        case 34:
3999                                                {
4000                                                setState(572); match(NEWLINE);
4001                                                }
4002                                                break;
4003
4004                                        case 35:
4005                                                {
4006                                                setState(573); text();
4007                                                }
4008                                                break;
4009
4010                                        case 36:
4011                                                {
4012                                                setState(574); javadocInlineTag();
4013                                                }
4014                                                break;
4015                                        }
4016                                        } 
4017                                }
4018                                setState(579);
4019                                _errHandler.sync(this);
4020                                _alt = getInterpreter().adaptivePredict(_input,36,_ctx);
4021                        }
4022                        setState(580); tdTagClose();
4023                        }
4024                }
4025                catch (RecognitionException re) {
4026                        _localctx.exception = re;
4027                        _errHandler.reportError(this, re);
4028                        _errHandler.recover(this, re);
4029                }
4030                finally {
4031                        exitRule();
4032                }
4033                return _localctx;
4034        }
4035
4036        public static class ThTagOpenContext extends ParserRuleContext {
4037                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4038                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4039                public TerminalNode NEWLINE(int i) {
4040                        return getToken(JavadocParser.NEWLINE, i);
4041                }
4042                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4043                public List<AttributeContext> attribute() {
4044                        return getRuleContexts(AttributeContext.class);
4045                }
4046                public AttributeContext attribute(int i) {
4047                        return getRuleContext(AttributeContext.class,i);
4048                }
4049                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4050                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4051                public TerminalNode LEADING_ASTERISK(int i) {
4052                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4053                }
4054                public TerminalNode WS(int i) {
4055                        return getToken(JavadocParser.WS, i);
4056                }
4057                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
4058                public ThTagOpenContext(ParserRuleContext parent, int invokingState) {
4059                        super(parent, invokingState);
4060                }
4061                @Override public int getRuleIndex() { return RULE_thTagOpen; }
4062                @Override
4063                public void enterRule(ParseTreeListener listener) {
4064                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagOpen(this);
4065                }
4066                @Override
4067                public void exitRule(ParseTreeListener listener) {
4068                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagOpen(this);
4069                }
4070                @Override
4071                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4072                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagOpen(this);
4073                        else return visitor.visitChildren(this);
4074                }
4075        }
4076
4077        public final ThTagOpenContext thTagOpen() throws RecognitionException {
4078                ThTagOpenContext _localctx = new ThTagOpenContext(_ctx, getState());
4079                enterRule(_localctx, 36, RULE_thTagOpen);
4080                int _la;
4081                try {
4082                        enterOuterAlt(_localctx, 1);
4083                        {
4084                        setState(582); match(OPEN);
4085                        setState(583); match(TH_HTML_TAG_NAME);
4086                        setState(590);
4087                        _errHandler.sync(this);
4088                        _la = _input.LA(1);
4089                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
4090                                {
4091                                setState(588);
4092                                switch (_input.LA(1)) {
4093                                case HTML_TAG_NAME:
4094                                        {
4095                                        setState(584); attribute();
4096                                        }
4097                                        break;
4098                                case NEWLINE:
4099                                        {
4100                                        setState(585); match(NEWLINE);
4101                                        }
4102                                        break;
4103                                case LEADING_ASTERISK:
4104                                        {
4105                                        setState(586); match(LEADING_ASTERISK);
4106                                        }
4107                                        break;
4108                                case WS:
4109                                        {
4110                                        setState(587); match(WS);
4111                                        }
4112                                        break;
4113                                default:
4114                                        throw new NoViableAltException(this);
4115                                }
4116                                }
4117                                setState(592);
4118                                _errHandler.sync(this);
4119                                _la = _input.LA(1);
4120                        }
4121                        setState(593); match(CLOSE);
4122                        }
4123                }
4124                catch (RecognitionException re) {
4125                        _localctx.exception = re;
4126                        _errHandler.reportError(this, re);
4127                        _errHandler.recover(this, re);
4128                }
4129                finally {
4130                        exitRule();
4131                }
4132                return _localctx;
4133        }
4134
4135        public static class ThTagCloseContext extends ParserRuleContext {
4136                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4137                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4138                public TerminalNode NEWLINE(int i) {
4139                        return getToken(JavadocParser.NEWLINE, i);
4140                }
4141                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4142                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4143                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4144                public TerminalNode LEADING_ASTERISK(int i) {
4145                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4146                }
4147                public TerminalNode WS(int i) {
4148                        return getToken(JavadocParser.WS, i);
4149                }
4150                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
4151                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
4152                public ThTagCloseContext(ParserRuleContext parent, int invokingState) {
4153                        super(parent, invokingState);
4154                }
4155                @Override public int getRuleIndex() { return RULE_thTagClose; }
4156                @Override
4157                public void enterRule(ParseTreeListener listener) {
4158                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagClose(this);
4159                }
4160                @Override
4161                public void exitRule(ParseTreeListener listener) {
4162                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagClose(this);
4163                }
4164                @Override
4165                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4166                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagClose(this);
4167                        else return visitor.visitChildren(this);
4168                }
4169        }
4170
4171        public final ThTagCloseContext thTagClose() throws RecognitionException {
4172                ThTagCloseContext _localctx = new ThTagCloseContext(_ctx, getState());
4173                enterRule(_localctx, 38, RULE_thTagClose);
4174                int _la;
4175                try {
4176                        enterOuterAlt(_localctx, 1);
4177                        {
4178                        setState(595); match(OPEN);
4179                        setState(596); match(SLASH);
4180                        setState(597); match(TH_HTML_TAG_NAME);
4181                        setState(601);
4182                        _errHandler.sync(this);
4183                        _la = _input.LA(1);
4184                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
4185                                {
4186                                {
4187                                setState(598);
4188                                _la = _input.LA(1);
4189                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
4190                                _errHandler.recoverInline(this);
4191                                }
4192                                consume();
4193                                }
4194                                }
4195                                setState(603);
4196                                _errHandler.sync(this);
4197                                _la = _input.LA(1);
4198                        }
4199                        setState(604); match(CLOSE);
4200                        }
4201                }
4202                catch (RecognitionException re) {
4203                        _localctx.exception = re;
4204                        _errHandler.reportError(this, re);
4205                        _errHandler.recover(this, re);
4206                }
4207                finally {
4208                        exitRule();
4209                }
4210                return _localctx;
4211        }
4212
4213        public static class ThContext extends ParserRuleContext {
4214                public List<ColgroupTagOpenContext> colgroupTagOpen() {
4215                        return getRuleContexts(ColgroupTagOpenContext.class);
4216                }
4217                public ThTagCloseContext thTagClose() {
4218                        return getRuleContext(ThTagCloseContext.class,0);
4219                }
4220                public TbodyContext tbody(int i) {
4221                        return getRuleContext(TbodyContext.class,i);
4222                }
4223                public TerminalNode CDATA(int i) {
4224                        return getToken(JavadocParser.CDATA, i);
4225                }
4226                public TfootTagOpenContext tfootTagOpen(int i) {
4227                        return getRuleContext(TfootTagOpenContext.class,i);
4228                }
4229                public List<DtTagOpenContext> dtTagOpen() {
4230                        return getRuleContexts(DtTagOpenContext.class);
4231                }
4232                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4233                public HeadContext head(int i) {
4234                        return getRuleContext(HeadContext.class,i);
4235                }
4236                public List<ColgroupContext> colgroup() {
4237                        return getRuleContexts(ColgroupContext.class);
4238                }
4239                public List<TrContext> tr() {
4240                        return getRuleContexts(TrContext.class);
4241                }
4242                public List<LiContext> li() {
4243                        return getRuleContexts(LiContext.class);
4244                }
4245                public List<DdTagOpenContext> ddTagOpen() {
4246                        return getRuleContexts(DdTagOpenContext.class);
4247                }
4248                public ColgroupContext colgroup(int i) {
4249                        return getRuleContext(ColgroupContext.class,i);
4250                }
4251                public ThTagOpenContext thTagOpen() {
4252                        return getRuleContext(ThTagOpenContext.class,0);
4253                }
4254                public TdTagOpenContext tdTagOpen(int i) {
4255                        return getRuleContext(TdTagOpenContext.class,i);
4256                }
4257                public List<HeadTagOpenContext> headTagOpen() {
4258                        return getRuleContexts(HeadTagOpenContext.class);
4259                }
4260                public List<HtmlTagOpenContext> htmlTagOpen() {
4261                        return getRuleContexts(HtmlTagOpenContext.class);
4262                }
4263                public List<TbodyTagOpenContext> tbodyTagOpen() {
4264                        return getRuleContexts(TbodyTagOpenContext.class);
4265                }
4266                public List<TheadContext> thead() {
4267                        return getRuleContexts(TheadContext.class);
4268                }
4269                public LiContext li(int i) {
4270                        return getRuleContext(LiContext.class,i);
4271                }
4272                public List<TfootTagOpenContext> tfootTagOpen() {
4273                        return getRuleContexts(TfootTagOpenContext.class);
4274                }
4275                public List<TfootContext> tfoot() {
4276                        return getRuleContexts(TfootContext.class);
4277                }
4278                public List<JavadocInlineTagContext> javadocInlineTag() {
4279                        return getRuleContexts(JavadocInlineTagContext.class);
4280                }
4281                public List<HtmlCommentContext> htmlComment() {
4282                        return getRuleContexts(HtmlCommentContext.class);
4283                }
4284                public OptionContext option(int i) {
4285                        return getRuleContext(OptionContext.class,i);
4286                }
4287                public TrContext tr(int i) {
4288                        return getRuleContext(TrContext.class,i);
4289                }
4290                public List<DtContext> dt() {
4291                        return getRuleContexts(DtContext.class);
4292                }
4293                public HtmlCommentContext htmlComment(int i) {
4294                        return getRuleContext(HtmlCommentContext.class,i);
4295                }
4296                public List<TdContext> td() {
4297                        return getRuleContexts(TdContext.class);
4298                }
4299                public List<BodyTagOpenContext> bodyTagOpen() {
4300                        return getRuleContexts(BodyTagOpenContext.class);
4301                }
4302                public DtTagOpenContext dtTagOpen(int i) {
4303                        return getRuleContext(DtTagOpenContext.class,i);
4304                }
4305                public HtmlContext html(int i) {
4306                        return getRuleContext(HtmlContext.class,i);
4307                }
4308                public BodyTagOpenContext bodyTagOpen(int i) {
4309                        return getRuleContext(BodyTagOpenContext.class,i);
4310                }
4311                public DdTagOpenContext ddTagOpen(int i) {
4312                        return getRuleContext(DdTagOpenContext.class,i);
4313                }
4314                public List<HtmlTagContext> htmlTag() {
4315                        return getRuleContexts(HtmlTagContext.class);
4316                }
4317                public ParagraphContext paragraph(int i) {
4318                        return getRuleContext(ParagraphContext.class,i);
4319                }
4320                public List<TdTagOpenContext> tdTagOpen() {
4321                        return getRuleContexts(TdTagOpenContext.class);
4322                }
4323                public OptionTagOpenContext optionTagOpen(int i) {
4324                        return getRuleContext(OptionTagOpenContext.class,i);
4325                }
4326                public LiTagOpenContext liTagOpen(int i) {
4327                        return getRuleContext(LiTagOpenContext.class,i);
4328                }
4329                public TdContext td(int i) {
4330                        return getRuleContext(TdContext.class,i);
4331                }
4332                public List<ParagraphContext> paragraph() {
4333                        return getRuleContexts(ParagraphContext.class);
4334                }
4335                public HtmlTagContext htmlTag(int i) {
4336                        return getRuleContext(HtmlTagContext.class,i);
4337                }
4338                public List<SingletonTagContext> singletonTag() {
4339                        return getRuleContexts(SingletonTagContext.class);
4340                }
4341                public HeadTagOpenContext headTagOpen(int i) {
4342                        return getRuleContext(HeadTagOpenContext.class,i);
4343                }
4344                public TrTagOpenContext trTagOpen(int i) {
4345                        return getRuleContext(TrTagOpenContext.class,i);
4346                }
4347                public List<HtmlContext> html() {
4348                        return getRuleContexts(HtmlContext.class);
4349                }
4350                public JavadocInlineTagContext javadocInlineTag(int i) {
4351                        return getRuleContext(JavadocInlineTagContext.class,i);
4352                }
4353                public DtContext dt(int i) {
4354                        return getRuleContext(DtContext.class,i);
4355                }
4356                public PTagOpenContext pTagOpen(int i) {
4357                        return getRuleContext(PTagOpenContext.class,i);
4358                }
4359                public TerminalNode LEADING_ASTERISK(int i) {
4360                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4361                }
4362                public List<TrTagOpenContext> trTagOpen() {
4363                        return getRuleContexts(TrTagOpenContext.class);
4364                }
4365                public List<TbodyContext> tbody() {
4366                        return getRuleContexts(TbodyContext.class);
4367                }
4368                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
4369                public List<TheadTagOpenContext> theadTagOpen() {
4370                        return getRuleContexts(TheadTagOpenContext.class);
4371                }
4372                public List<HeadContext> head() {
4373                        return getRuleContexts(HeadContext.class);
4374                }
4375                public TerminalNode NEWLINE(int i) {
4376                        return getToken(JavadocParser.NEWLINE, i);
4377                }
4378                public TextContext text(int i) {
4379                        return getRuleContext(TextContext.class,i);
4380                }
4381                public List<BodyContext> body() {
4382                        return getRuleContexts(BodyContext.class);
4383                }
4384                public List<OptionTagOpenContext> optionTagOpen() {
4385                        return getRuleContexts(OptionTagOpenContext.class);
4386                }
4387                public List<TextContext> text() {
4388                        return getRuleContexts(TextContext.class);
4389                }
4390                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4391                public TbodyTagOpenContext tbodyTagOpen(int i) {
4392                        return getRuleContext(TbodyTagOpenContext.class,i);
4393                }
4394                public List<DdContext> dd() {
4395                        return getRuleContexts(DdContext.class);
4396                }
4397                public TheadTagOpenContext theadTagOpen(int i) {
4398                        return getRuleContext(TheadTagOpenContext.class,i);
4399                }
4400                public ColgroupTagOpenContext colgroupTagOpen(int i) {
4401                        return getRuleContext(ColgroupTagOpenContext.class,i);
4402                }
4403                public List<LiTagOpenContext> liTagOpen() {
4404                        return getRuleContexts(LiTagOpenContext.class);
4405                }
4406                public DdContext dd(int i) {
4407                        return getRuleContext(DdContext.class,i);
4408                }
4409                public List<OptionContext> option() {
4410                        return getRuleContexts(OptionContext.class);
4411                }
4412                public TheadContext thead(int i) {
4413                        return getRuleContext(TheadContext.class,i);
4414                }
4415                public BodyContext body(int i) {
4416                        return getRuleContext(BodyContext.class,i);
4417                }
4418                public List<PTagOpenContext> pTagOpen() {
4419                        return getRuleContexts(PTagOpenContext.class);
4420                }
4421                public HtmlTagOpenContext htmlTagOpen(int i) {
4422                        return getRuleContext(HtmlTagOpenContext.class,i);
4423                }
4424                public SingletonTagContext singletonTag(int i) {
4425                        return getRuleContext(SingletonTagContext.class,i);
4426                }
4427                public TfootContext tfoot(int i) {
4428                        return getRuleContext(TfootContext.class,i);
4429                }
4430                public ThContext(ParserRuleContext parent, int invokingState) {
4431                        super(parent, invokingState);
4432                }
4433                @Override public int getRuleIndex() { return RULE_th; }
4434                @Override
4435                public void enterRule(ParseTreeListener listener) {
4436                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTh(this);
4437                }
4438                @Override
4439                public void exitRule(ParseTreeListener listener) {
4440                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTh(this);
4441                }
4442                @Override
4443                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4444                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTh(this);
4445                        else return visitor.visitChildren(this);
4446                }
4447        }
4448
4449        public final ThContext th() throws RecognitionException {
4450                ThContext _localctx = new ThContext(_ctx, getState());
4451                enterRule(_localctx, 40, RULE_th);
4452                try {
4453                        int _alt;
4454                        enterOuterAlt(_localctx, 1);
4455                        {
4456                        setState(606); thTagOpen();
4457                        setState(646);
4458                        _errHandler.sync(this);
4459                        _alt = getInterpreter().adaptivePredict(_input,41,_ctx);
4460                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
4461                                if ( _alt==1 ) {
4462                                        {
4463                                        setState(644);
4464                                        switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
4465                                        case 1:
4466                                                {
4467                                                setState(607); htmlTag();
4468                                                }
4469                                                break;
4470
4471                                        case 2:
4472                                                {
4473                                                setState(608); singletonTag();
4474                                                }
4475                                                break;
4476
4477                                        case 3:
4478                                                {
4479                                                setState(609); paragraph();
4480                                                }
4481                                                break;
4482
4483                                        case 4:
4484                                                {
4485                                                setState(610); li();
4486                                                }
4487                                                break;
4488
4489                                        case 5:
4490                                                {
4491                                                setState(611); tr();
4492                                                }
4493                                                break;
4494
4495                                        case 6:
4496                                                {
4497                                                setState(612); td();
4498                                                }
4499                                                break;
4500
4501                                        case 7:
4502                                                {
4503                                                setState(613); body();
4504                                                }
4505                                                break;
4506
4507                                        case 8:
4508                                                {
4509                                                setState(614); colgroup();
4510                                                }
4511                                                break;
4512
4513                                        case 9:
4514                                                {
4515                                                setState(615); dd();
4516                                                }
4517                                                break;
4518
4519                                        case 10:
4520                                                {
4521                                                setState(616); dt();
4522                                                }
4523                                                break;
4524
4525                                        case 11:
4526                                                {
4527                                                setState(617); head();
4528                                                }
4529                                                break;
4530
4531                                        case 12:
4532                                                {
4533                                                setState(618); html();
4534                                                }
4535                                                break;
4536
4537                                        case 13:
4538                                                {
4539                                                setState(619); option();
4540                                                }
4541                                                break;
4542
4543                                        case 14:
4544                                                {
4545                                                setState(620); tbody();
4546                                                }
4547                                                break;
4548
4549                                        case 15:
4550                                                {
4551                                                setState(621); thead();
4552                                                }
4553                                                break;
4554
4555                                        case 16:
4556                                                {
4557                                                setState(622); tfoot();
4558                                                }
4559                                                break;
4560
4561                                        case 17:
4562                                                {
4563                                                setState(623); pTagOpen();
4564                                                }
4565                                                break;
4566
4567                                        case 18:
4568                                                {
4569                                                setState(624); liTagOpen();
4570                                                }
4571                                                break;
4572
4573                                        case 19:
4574                                                {
4575                                                setState(625); trTagOpen();
4576                                                }
4577                                                break;
4578
4579                                        case 20:
4580                                                {
4581                                                setState(626); tdTagOpen();
4582                                                }
4583                                                break;
4584
4585                                        case 21:
4586                                                {
4587                                                setState(627); bodyTagOpen();
4588                                                }
4589                                                break;
4590
4591                                        case 22:
4592                                                {
4593                                                setState(628); colgroupTagOpen();
4594                                                }
4595                                                break;
4596
4597                                        case 23:
4598                                                {
4599                                                setState(629); ddTagOpen();
4600                                                }
4601                                                break;
4602
4603                                        case 24:
4604                                                {
4605                                                setState(630); dtTagOpen();
4606                                                }
4607                                                break;
4608
4609                                        case 25:
4610                                                {
4611                                                setState(631); headTagOpen();
4612                                                }
4613                                                break;
4614
4615                                        case 26:
4616                                                {
4617                                                setState(632); htmlTagOpen();
4618                                                }
4619                                                break;
4620
4621                                        case 27:
4622                                                {
4623                                                setState(633); optionTagOpen();
4624                                                }
4625                                                break;
4626
4627                                        case 28:
4628                                                {
4629                                                setState(634); tbodyTagOpen();
4630                                                }
4631                                                break;
4632
4633                                        case 29:
4634                                                {
4635                                                setState(635); theadTagOpen();
4636                                                }
4637                                                break;
4638
4639                                        case 30:
4640                                                {
4641                                                setState(636); tfootTagOpen();
4642                                                }
4643                                                break;
4644
4645                                        case 31:
4646                                                {
4647                                                {
4648                                                setState(637);
4649                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
4650                                                setState(638); match(LEADING_ASTERISK);
4651                                                }
4652                                                }
4653                                                break;
4654
4655                                        case 32:
4656                                                {
4657                                                setState(639); htmlComment();
4658                                                }
4659                                                break;
4660
4661                                        case 33:
4662                                                {
4663                                                setState(640); match(CDATA);
4664                                                }
4665                                                break;
4666
4667                                        case 34:
4668                                                {
4669                                                setState(641); match(NEWLINE);
4670                                                }
4671                                                break;
4672
4673                                        case 35:
4674                                                {
4675                                                setState(642); text();
4676                                                }
4677                                                break;
4678
4679                                        case 36:
4680                                                {
4681                                                setState(643); javadocInlineTag();
4682                                                }
4683                                                break;
4684                                        }
4685                                        } 
4686                                }
4687                                setState(648);
4688                                _errHandler.sync(this);
4689                                _alt = getInterpreter().adaptivePredict(_input,41,_ctx);
4690                        }
4691                        setState(649); thTagClose();
4692                        }
4693                }
4694                catch (RecognitionException re) {
4695                        _localctx.exception = re;
4696                        _errHandler.reportError(this, re);
4697                        _errHandler.recover(this, re);
4698                }
4699                finally {
4700                        exitRule();
4701                }
4702                return _localctx;
4703        }
4704
4705        public static class BodyTagOpenContext extends ParserRuleContext {
4706                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4707                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
4708                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4709                public TerminalNode NEWLINE(int i) {
4710                        return getToken(JavadocParser.NEWLINE, i);
4711                }
4712                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4713                public List<AttributeContext> attribute() {
4714                        return getRuleContexts(AttributeContext.class);
4715                }
4716                public AttributeContext attribute(int i) {
4717                        return getRuleContext(AttributeContext.class,i);
4718                }
4719                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4720                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4721                public TerminalNode LEADING_ASTERISK(int i) {
4722                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4723                }
4724                public TerminalNode WS(int i) {
4725                        return getToken(JavadocParser.WS, i);
4726                }
4727                public BodyTagOpenContext(ParserRuleContext parent, int invokingState) {
4728                        super(parent, invokingState);
4729                }
4730                @Override public int getRuleIndex() { return RULE_bodyTagOpen; }
4731                @Override
4732                public void enterRule(ParseTreeListener listener) {
4733                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagOpen(this);
4734                }
4735                @Override
4736                public void exitRule(ParseTreeListener listener) {
4737                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagOpen(this);
4738                }
4739                @Override
4740                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4741                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagOpen(this);
4742                        else return visitor.visitChildren(this);
4743                }
4744        }
4745
4746        public final BodyTagOpenContext bodyTagOpen() throws RecognitionException {
4747                BodyTagOpenContext _localctx = new BodyTagOpenContext(_ctx, getState());
4748                enterRule(_localctx, 42, RULE_bodyTagOpen);
4749                int _la;
4750                try {
4751                        enterOuterAlt(_localctx, 1);
4752                        {
4753                        setState(651); match(OPEN);
4754                        setState(652); match(BODY_HTML_TAG_NAME);
4755                        setState(659);
4756                        _errHandler.sync(this);
4757                        _la = _input.LA(1);
4758                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
4759                                {
4760                                setState(657);
4761                                switch (_input.LA(1)) {
4762                                case HTML_TAG_NAME:
4763                                        {
4764                                        setState(653); attribute();
4765                                        }
4766                                        break;
4767                                case NEWLINE:
4768                                        {
4769                                        setState(654); match(NEWLINE);
4770                                        }
4771                                        break;
4772                                case LEADING_ASTERISK:
4773                                        {
4774                                        setState(655); match(LEADING_ASTERISK);
4775                                        }
4776                                        break;
4777                                case WS:
4778                                        {
4779                                        setState(656); match(WS);
4780                                        }
4781                                        break;
4782                                default:
4783                                        throw new NoViableAltException(this);
4784                                }
4785                                }
4786                                setState(661);
4787                                _errHandler.sync(this);
4788                                _la = _input.LA(1);
4789                        }
4790                        setState(662); match(CLOSE);
4791                        }
4792                }
4793                catch (RecognitionException re) {
4794                        _localctx.exception = re;
4795                        _errHandler.reportError(this, re);
4796                        _errHandler.recover(this, re);
4797                }
4798                finally {
4799                        exitRule();
4800                }
4801                return _localctx;
4802        }
4803
4804        public static class BodyTagCloseContext extends ParserRuleContext {
4805                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4806                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
4807                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4808                public TerminalNode NEWLINE(int i) {
4809                        return getToken(JavadocParser.NEWLINE, i);
4810                }
4811                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4812                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4813                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4814                public TerminalNode LEADING_ASTERISK(int i) {
4815                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4816                }
4817                public TerminalNode WS(int i) {
4818                        return getToken(JavadocParser.WS, i);
4819                }
4820                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
4821                public BodyTagCloseContext(ParserRuleContext parent, int invokingState) {
4822                        super(parent, invokingState);
4823                }
4824                @Override public int getRuleIndex() { return RULE_bodyTagClose; }
4825                @Override
4826                public void enterRule(ParseTreeListener listener) {
4827                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagClose(this);
4828                }
4829                @Override
4830                public void exitRule(ParseTreeListener listener) {
4831                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagClose(this);
4832                }
4833                @Override
4834                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4835                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagClose(this);
4836                        else return visitor.visitChildren(this);
4837                }
4838        }
4839
4840        public final BodyTagCloseContext bodyTagClose() throws RecognitionException {
4841                BodyTagCloseContext _localctx = new BodyTagCloseContext(_ctx, getState());
4842                enterRule(_localctx, 44, RULE_bodyTagClose);
4843                int _la;
4844                try {
4845                        enterOuterAlt(_localctx, 1);
4846                        {
4847                        setState(664); match(OPEN);
4848                        setState(665); match(SLASH);
4849                        setState(666); match(BODY_HTML_TAG_NAME);
4850                        setState(670);
4851                        _errHandler.sync(this);
4852                        _la = _input.LA(1);
4853                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
4854                                {
4855                                {
4856                                setState(667);
4857                                _la = _input.LA(1);
4858                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
4859                                _errHandler.recoverInline(this);
4860                                }
4861                                consume();
4862                                }
4863                                }
4864                                setState(672);
4865                                _errHandler.sync(this);
4866                                _la = _input.LA(1);
4867                        }
4868                        setState(673); match(CLOSE);
4869                        }
4870                }
4871                catch (RecognitionException re) {
4872                        _localctx.exception = re;
4873                        _errHandler.reportError(this, re);
4874                        _errHandler.recover(this, re);
4875                }
4876                finally {
4877                        exitRule();
4878                }
4879                return _localctx;
4880        }
4881
4882        public static class BodyContext extends ParserRuleContext {
4883                public List<ColgroupTagOpenContext> colgroupTagOpen() {
4884                        return getRuleContexts(ColgroupTagOpenContext.class);
4885                }
4886                public TbodyContext tbody(int i) {
4887                        return getRuleContext(TbodyContext.class,i);
4888                }
4889                public TerminalNode CDATA(int i) {
4890                        return getToken(JavadocParser.CDATA, i);
4891                }
4892                public TfootTagOpenContext tfootTagOpen(int i) {
4893                        return getRuleContext(TfootTagOpenContext.class,i);
4894                }
4895                public List<DtTagOpenContext> dtTagOpen() {
4896                        return getRuleContexts(DtTagOpenContext.class);
4897                }
4898                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4899                public HeadContext head(int i) {
4900                        return getRuleContext(HeadContext.class,i);
4901                }
4902                public List<ColgroupContext> colgroup() {
4903                        return getRuleContexts(ColgroupContext.class);
4904                }
4905                public List<TrContext> tr() {
4906                        return getRuleContexts(TrContext.class);
4907                }
4908                public List<LiContext> li() {
4909                        return getRuleContexts(LiContext.class);
4910                }
4911                public ThTagOpenContext thTagOpen(int i) {
4912                        return getRuleContext(ThTagOpenContext.class,i);
4913                }
4914                public List<DdTagOpenContext> ddTagOpen() {
4915                        return getRuleContexts(DdTagOpenContext.class);
4916                }
4917                public ColgroupContext colgroup(int i) {
4918                        return getRuleContext(ColgroupContext.class,i);
4919                }
4920                public TdTagOpenContext tdTagOpen(int i) {
4921                        return getRuleContext(TdTagOpenContext.class,i);
4922                }
4923                public List<ThTagOpenContext> thTagOpen() {
4924                        return getRuleContexts(ThTagOpenContext.class);
4925                }
4926                public List<HeadTagOpenContext> headTagOpen() {
4927                        return getRuleContexts(HeadTagOpenContext.class);
4928                }
4929                public List<HtmlTagOpenContext> htmlTagOpen() {
4930                        return getRuleContexts(HtmlTagOpenContext.class);
4931                }
4932                public List<TbodyTagOpenContext> tbodyTagOpen() {
4933                        return getRuleContexts(TbodyTagOpenContext.class);
4934                }
4935                public List<TheadContext> thead() {
4936                        return getRuleContexts(TheadContext.class);
4937                }
4938                public LiContext li(int i) {
4939                        return getRuleContext(LiContext.class,i);
4940                }
4941                public List<TfootTagOpenContext> tfootTagOpen() {
4942                        return getRuleContexts(TfootTagOpenContext.class);
4943                }
4944                public List<TfootContext> tfoot() {
4945                        return getRuleContexts(TfootContext.class);
4946                }
4947                public List<JavadocInlineTagContext> javadocInlineTag() {
4948                        return getRuleContexts(JavadocInlineTagContext.class);
4949                }
4950                public List<HtmlCommentContext> htmlComment() {
4951                        return getRuleContexts(HtmlCommentContext.class);
4952                }
4953                public OptionContext option(int i) {
4954                        return getRuleContext(OptionContext.class,i);
4955                }
4956                public BodyTagCloseContext bodyTagClose() {
4957                        return getRuleContext(BodyTagCloseContext.class,0);
4958                }
4959                public TrContext tr(int i) {
4960                        return getRuleContext(TrContext.class,i);
4961                }
4962                public List<DtContext> dt() {
4963                        return getRuleContexts(DtContext.class);
4964                }
4965                public HtmlCommentContext htmlComment(int i) {
4966                        return getRuleContext(HtmlCommentContext.class,i);
4967                }
4968                public List<TdContext> td() {
4969                        return getRuleContexts(TdContext.class);
4970                }
4971                public BodyTagOpenContext bodyTagOpen() {
4972                        return getRuleContext(BodyTagOpenContext.class,0);
4973                }
4974                public DtTagOpenContext dtTagOpen(int i) {
4975                        return getRuleContext(DtTagOpenContext.class,i);
4976                }
4977                public HtmlContext html(int i) {
4978                        return getRuleContext(HtmlContext.class,i);
4979                }
4980                public DdTagOpenContext ddTagOpen(int i) {
4981                        return getRuleContext(DdTagOpenContext.class,i);
4982                }
4983                public List<HtmlTagContext> htmlTag() {
4984                        return getRuleContexts(HtmlTagContext.class);
4985                }
4986                public ParagraphContext paragraph(int i) {
4987                        return getRuleContext(ParagraphContext.class,i);
4988                }
4989                public List<TdTagOpenContext> tdTagOpen() {
4990                        return getRuleContexts(TdTagOpenContext.class);
4991                }
4992                public OptionTagOpenContext optionTagOpen(int i) {
4993                        return getRuleContext(OptionTagOpenContext.class,i);
4994                }
4995                public LiTagOpenContext liTagOpen(int i) {
4996                        return getRuleContext(LiTagOpenContext.class,i);
4997                }
4998                public TdContext td(int i) {
4999                        return getRuleContext(TdContext.class,i);
5000                }
5001                public List<ParagraphContext> paragraph() {
5002                        return getRuleContexts(ParagraphContext.class);
5003                }
5004                public HtmlTagContext htmlTag(int i) {
5005                        return getRuleContext(HtmlTagContext.class,i);
5006                }
5007                public List<SingletonTagContext> singletonTag() {
5008                        return getRuleContexts(SingletonTagContext.class);
5009                }
5010                public HeadTagOpenContext headTagOpen(int i) {
5011                        return getRuleContext(HeadTagOpenContext.class,i);
5012                }
5013                public TrTagOpenContext trTagOpen(int i) {
5014                        return getRuleContext(TrTagOpenContext.class,i);
5015                }
5016                public List<HtmlContext> html() {
5017                        return getRuleContexts(HtmlContext.class);
5018                }
5019                public JavadocInlineTagContext javadocInlineTag(int i) {
5020                        return getRuleContext(JavadocInlineTagContext.class,i);
5021                }
5022                public List<ThContext> th() {
5023                        return getRuleContexts(ThContext.class);
5024                }
5025                public DtContext dt(int i) {
5026                        return getRuleContext(DtContext.class,i);
5027                }
5028                public PTagOpenContext pTagOpen(int i) {
5029                        return getRuleContext(PTagOpenContext.class,i);
5030                }
5031                public TerminalNode LEADING_ASTERISK(int i) {
5032                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5033                }
5034                public List<TrTagOpenContext> trTagOpen() {
5035                        return getRuleContexts(TrTagOpenContext.class);
5036                }
5037                public List<TbodyContext> tbody() {
5038                        return getRuleContexts(TbodyContext.class);
5039                }
5040                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
5041                public List<TheadTagOpenContext> theadTagOpen() {
5042                        return getRuleContexts(TheadTagOpenContext.class);
5043                }
5044                public List<HeadContext> head() {
5045                        return getRuleContexts(HeadContext.class);
5046                }
5047                public TerminalNode NEWLINE(int i) {
5048                        return getToken(JavadocParser.NEWLINE, i);
5049                }
5050                public TextContext text(int i) {
5051                        return getRuleContext(TextContext.class,i);
5052                }
5053                public List<OptionTagOpenContext> optionTagOpen() {
5054                        return getRuleContexts(OptionTagOpenContext.class);
5055                }
5056                public List<TextContext> text() {
5057                        return getRuleContexts(TextContext.class);
5058                }
5059                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5060                public TbodyTagOpenContext tbodyTagOpen(int i) {
5061                        return getRuleContext(TbodyTagOpenContext.class,i);
5062                }
5063                public List<DdContext> dd() {
5064                        return getRuleContexts(DdContext.class);
5065                }
5066                public TheadTagOpenContext theadTagOpen(int i) {
5067                        return getRuleContext(TheadTagOpenContext.class,i);
5068                }
5069                public ColgroupTagOpenContext colgroupTagOpen(int i) {
5070                        return getRuleContext(ColgroupTagOpenContext.class,i);
5071                }
5072                public List<LiTagOpenContext> liTagOpen() {
5073                        return getRuleContexts(LiTagOpenContext.class);
5074                }
5075                public DdContext dd(int i) {
5076                        return getRuleContext(DdContext.class,i);
5077                }
5078                public List<OptionContext> option() {
5079                        return getRuleContexts(OptionContext.class);
5080                }
5081                public TheadContext thead(int i) {
5082                        return getRuleContext(TheadContext.class,i);
5083                }
5084                public ThContext th(int i) {
5085                        return getRuleContext(ThContext.class,i);
5086                }
5087                public List<PTagOpenContext> pTagOpen() {
5088                        return getRuleContexts(PTagOpenContext.class);
5089                }
5090                public HtmlTagOpenContext htmlTagOpen(int i) {
5091                        return getRuleContext(HtmlTagOpenContext.class,i);
5092                }
5093                public SingletonTagContext singletonTag(int i) {
5094                        return getRuleContext(SingletonTagContext.class,i);
5095                }
5096                public TfootContext tfoot(int i) {
5097                        return getRuleContext(TfootContext.class,i);
5098                }
5099                public BodyContext(ParserRuleContext parent, int invokingState) {
5100                        super(parent, invokingState);
5101                }
5102                @Override public int getRuleIndex() { return RULE_body; }
5103                @Override
5104                public void enterRule(ParseTreeListener listener) {
5105                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBody(this);
5106                }
5107                @Override
5108                public void exitRule(ParseTreeListener listener) {
5109                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBody(this);
5110                }
5111                @Override
5112                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5113                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBody(this);
5114                        else return visitor.visitChildren(this);
5115                }
5116        }
5117
5118        public final BodyContext body() throws RecognitionException {
5119                BodyContext _localctx = new BodyContext(_ctx, getState());
5120                enterRule(_localctx, 46, RULE_body);
5121                try {
5122                        int _alt;
5123                        enterOuterAlt(_localctx, 1);
5124                        {
5125                        setState(675); bodyTagOpen();
5126                        setState(715);
5127                        _errHandler.sync(this);
5128                        _alt = getInterpreter().adaptivePredict(_input,46,_ctx);
5129                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5130                                if ( _alt==1 ) {
5131                                        {
5132                                        setState(713);
5133                                        switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
5134                                        case 1:
5135                                                {
5136                                                setState(676); htmlTag();
5137                                                }
5138                                                break;
5139
5140                                        case 2:
5141                                                {
5142                                                setState(677); singletonTag();
5143                                                }
5144                                                break;
5145
5146                                        case 3:
5147                                                {
5148                                                setState(678); paragraph();
5149                                                }
5150                                                break;
5151
5152                                        case 4:
5153                                                {
5154                                                setState(679); li();
5155                                                }
5156                                                break;
5157
5158                                        case 5:
5159                                                {
5160                                                setState(680); tr();
5161                                                }
5162                                                break;
5163
5164                                        case 6:
5165                                                {
5166                                                setState(681); td();
5167                                                }
5168                                                break;
5169
5170                                        case 7:
5171                                                {
5172                                                setState(682); th();
5173                                                }
5174                                                break;
5175
5176                                        case 8:
5177                                                {
5178                                                setState(683); colgroup();
5179                                                }
5180                                                break;
5181
5182                                        case 9:
5183                                                {
5184                                                setState(684); dd();
5185                                                }
5186                                                break;
5187
5188                                        case 10:
5189                                                {
5190                                                setState(685); dt();
5191                                                }
5192                                                break;
5193
5194                                        case 11:
5195                                                {
5196                                                setState(686); head();
5197                                                }
5198                                                break;
5199
5200                                        case 12:
5201                                                {
5202                                                setState(687); html();
5203                                                }
5204                                                break;
5205
5206                                        case 13:
5207                                                {
5208                                                setState(688); option();
5209                                                }
5210                                                break;
5211
5212                                        case 14:
5213                                                {
5214                                                setState(689); tbody();
5215                                                }
5216                                                break;
5217
5218                                        case 15:
5219                                                {
5220                                                setState(690); thead();
5221                                                }
5222                                                break;
5223
5224                                        case 16:
5225                                                {
5226                                                setState(691); tfoot();
5227                                                }
5228                                                break;
5229
5230                                        case 17:
5231                                                {
5232                                                setState(692); pTagOpen();
5233                                                }
5234                                                break;
5235
5236                                        case 18:
5237                                                {
5238                                                setState(693); liTagOpen();
5239                                                }
5240                                                break;
5241
5242                                        case 19:
5243                                                {
5244                                                setState(694); trTagOpen();
5245                                                }
5246                                                break;
5247
5248                                        case 20:
5249                                                {
5250                                                setState(695); tdTagOpen();
5251                                                }
5252                                                break;
5253
5254                                        case 21:
5255                                                {
5256                                                setState(696); thTagOpen();
5257                                                }
5258                                                break;
5259
5260                                        case 22:
5261                                                {
5262                                                setState(697); colgroupTagOpen();
5263                                                }
5264                                                break;
5265
5266                                        case 23:
5267                                                {
5268                                                setState(698); ddTagOpen();
5269                                                }
5270                                                break;
5271
5272                                        case 24:
5273                                                {
5274                                                setState(699); dtTagOpen();
5275                                                }
5276                                                break;
5277
5278                                        case 25:
5279                                                {
5280                                                setState(700); headTagOpen();
5281                                                }
5282                                                break;
5283
5284                                        case 26:
5285                                                {
5286                                                setState(701); htmlTagOpen();
5287                                                }
5288                                                break;
5289
5290                                        case 27:
5291                                                {
5292                                                setState(702); optionTagOpen();
5293                                                }
5294                                                break;
5295
5296                                        case 28:
5297                                                {
5298                                                setState(703); tbodyTagOpen();
5299                                                }
5300                                                break;
5301
5302                                        case 29:
5303                                                {
5304                                                setState(704); theadTagOpen();
5305                                                }
5306                                                break;
5307
5308                                        case 30:
5309                                                {
5310                                                setState(705); tfootTagOpen();
5311                                                }
5312                                                break;
5313
5314                                        case 31:
5315                                                {
5316                                                {
5317                                                setState(706);
5318                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
5319                                                setState(707); match(LEADING_ASTERISK);
5320                                                }
5321                                                }
5322                                                break;
5323
5324                                        case 32:
5325                                                {
5326                                                setState(708); htmlComment();
5327                                                }
5328                                                break;
5329
5330                                        case 33:
5331                                                {
5332                                                setState(709); match(CDATA);
5333                                                }
5334                                                break;
5335
5336                                        case 34:
5337                                                {
5338                                                setState(710); match(NEWLINE);
5339                                                }
5340                                                break;
5341
5342                                        case 35:
5343                                                {
5344                                                setState(711); text();
5345                                                }
5346                                                break;
5347
5348                                        case 36:
5349                                                {
5350                                                setState(712); javadocInlineTag();
5351                                                }
5352                                                break;
5353                                        }
5354                                        } 
5355                                }
5356                                setState(717);
5357                                _errHandler.sync(this);
5358                                _alt = getInterpreter().adaptivePredict(_input,46,_ctx);
5359                        }
5360                        setState(718); bodyTagClose();
5361                        }
5362                }
5363                catch (RecognitionException re) {
5364                        _localctx.exception = re;
5365                        _errHandler.reportError(this, re);
5366                        _errHandler.recover(this, re);
5367                }
5368                finally {
5369                        exitRule();
5370                }
5371                return _localctx;
5372        }
5373
5374        public static class ColgroupTagOpenContext extends ParserRuleContext {
5375                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5376                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5377                public TerminalNode NEWLINE(int i) {
5378                        return getToken(JavadocParser.NEWLINE, i);
5379                }
5380                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5381                public List<AttributeContext> attribute() {
5382                        return getRuleContexts(AttributeContext.class);
5383                }
5384                public AttributeContext attribute(int i) {
5385                        return getRuleContext(AttributeContext.class,i);
5386                }
5387                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
5388                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5389                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
5390                public TerminalNode LEADING_ASTERISK(int i) {
5391                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5392                }
5393                public TerminalNode WS(int i) {
5394                        return getToken(JavadocParser.WS, i);
5395                }
5396                public ColgroupTagOpenContext(ParserRuleContext parent, int invokingState) {
5397                        super(parent, invokingState);
5398                }
5399                @Override public int getRuleIndex() { return RULE_colgroupTagOpen; }
5400                @Override
5401                public void enterRule(ParseTreeListener listener) {
5402                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagOpen(this);
5403                }
5404                @Override
5405                public void exitRule(ParseTreeListener listener) {
5406                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagOpen(this);
5407                }
5408                @Override
5409                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5410                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagOpen(this);
5411                        else return visitor.visitChildren(this);
5412                }
5413        }
5414
5415        public final ColgroupTagOpenContext colgroupTagOpen() throws RecognitionException {
5416                ColgroupTagOpenContext _localctx = new ColgroupTagOpenContext(_ctx, getState());
5417                enterRule(_localctx, 48, RULE_colgroupTagOpen);
5418                int _la;
5419                try {
5420                        enterOuterAlt(_localctx, 1);
5421                        {
5422                        setState(720); match(OPEN);
5423                        setState(721); match(COLGROUP_HTML_TAG_NAME);
5424                        setState(728);
5425                        _errHandler.sync(this);
5426                        _la = _input.LA(1);
5427                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
5428                                {
5429                                setState(726);
5430                                switch (_input.LA(1)) {
5431                                case HTML_TAG_NAME:
5432                                        {
5433                                        setState(722); attribute();
5434                                        }
5435                                        break;
5436                                case NEWLINE:
5437                                        {
5438                                        setState(723); match(NEWLINE);
5439                                        }
5440                                        break;
5441                                case LEADING_ASTERISK:
5442                                        {
5443                                        setState(724); match(LEADING_ASTERISK);
5444                                        }
5445                                        break;
5446                                case WS:
5447                                        {
5448                                        setState(725); match(WS);
5449                                        }
5450                                        break;
5451                                default:
5452                                        throw new NoViableAltException(this);
5453                                }
5454                                }
5455                                setState(730);
5456                                _errHandler.sync(this);
5457                                _la = _input.LA(1);
5458                        }
5459                        setState(731); match(CLOSE);
5460                        }
5461                }
5462                catch (RecognitionException re) {
5463                        _localctx.exception = re;
5464                        _errHandler.reportError(this, re);
5465                        _errHandler.recover(this, re);
5466                }
5467                finally {
5468                        exitRule();
5469                }
5470                return _localctx;
5471        }
5472
5473        public static class ColgroupTagCloseContext extends ParserRuleContext {
5474                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5475                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5476                public TerminalNode NEWLINE(int i) {
5477                        return getToken(JavadocParser.NEWLINE, i);
5478                }
5479                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5480                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
5481                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5482                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
5483                public TerminalNode LEADING_ASTERISK(int i) {
5484                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5485                }
5486                public TerminalNode WS(int i) {
5487                        return getToken(JavadocParser.WS, i);
5488                }
5489                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
5490                public ColgroupTagCloseContext(ParserRuleContext parent, int invokingState) {
5491                        super(parent, invokingState);
5492                }
5493                @Override public int getRuleIndex() { return RULE_colgroupTagClose; }
5494                @Override
5495                public void enterRule(ParseTreeListener listener) {
5496                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagClose(this);
5497                }
5498                @Override
5499                public void exitRule(ParseTreeListener listener) {
5500                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagClose(this);
5501                }
5502                @Override
5503                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5504                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagClose(this);
5505                        else return visitor.visitChildren(this);
5506                }
5507        }
5508
5509        public final ColgroupTagCloseContext colgroupTagClose() throws RecognitionException {
5510                ColgroupTagCloseContext _localctx = new ColgroupTagCloseContext(_ctx, getState());
5511                enterRule(_localctx, 50, RULE_colgroupTagClose);
5512                int _la;
5513                try {
5514                        enterOuterAlt(_localctx, 1);
5515                        {
5516                        setState(733); match(OPEN);
5517                        setState(734); match(SLASH);
5518                        setState(735); match(COLGROUP_HTML_TAG_NAME);
5519                        setState(739);
5520                        _errHandler.sync(this);
5521                        _la = _input.LA(1);
5522                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
5523                                {
5524                                {
5525                                setState(736);
5526                                _la = _input.LA(1);
5527                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
5528                                _errHandler.recoverInline(this);
5529                                }
5530                                consume();
5531                                }
5532                                }
5533                                setState(741);
5534                                _errHandler.sync(this);
5535                                _la = _input.LA(1);
5536                        }
5537                        setState(742); match(CLOSE);
5538                        }
5539                }
5540                catch (RecognitionException re) {
5541                        _localctx.exception = re;
5542                        _errHandler.reportError(this, re);
5543                        _errHandler.recover(this, re);
5544                }
5545                finally {
5546                        exitRule();
5547                }
5548                return _localctx;
5549        }
5550
5551        public static class ColgroupContext extends ParserRuleContext {
5552                public ColgroupTagOpenContext colgroupTagOpen() {
5553                        return getRuleContext(ColgroupTagOpenContext.class,0);
5554                }
5555                public TbodyContext tbody(int i) {
5556                        return getRuleContext(TbodyContext.class,i);
5557                }
5558                public TerminalNode CDATA(int i) {
5559                        return getToken(JavadocParser.CDATA, i);
5560                }
5561                public TfootTagOpenContext tfootTagOpen(int i) {
5562                        return getRuleContext(TfootTagOpenContext.class,i);
5563                }
5564                public List<DtTagOpenContext> dtTagOpen() {
5565                        return getRuleContexts(DtTagOpenContext.class);
5566                }
5567                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5568                public HeadContext head(int i) {
5569                        return getRuleContext(HeadContext.class,i);
5570                }
5571                public List<TrContext> tr() {
5572                        return getRuleContexts(TrContext.class);
5573                }
5574                public List<LiContext> li() {
5575                        return getRuleContexts(LiContext.class);
5576                }
5577                public ThTagOpenContext thTagOpen(int i) {
5578                        return getRuleContext(ThTagOpenContext.class,i);
5579                }
5580                public List<DdTagOpenContext> ddTagOpen() {
5581                        return getRuleContexts(DdTagOpenContext.class);
5582                }
5583                public TdTagOpenContext tdTagOpen(int i) {
5584                        return getRuleContext(TdTagOpenContext.class,i);
5585                }
5586                public List<ThTagOpenContext> thTagOpen() {
5587                        return getRuleContexts(ThTagOpenContext.class);
5588                }
5589                public List<HeadTagOpenContext> headTagOpen() {
5590                        return getRuleContexts(HeadTagOpenContext.class);
5591                }
5592                public List<HtmlTagOpenContext> htmlTagOpen() {
5593                        return getRuleContexts(HtmlTagOpenContext.class);
5594                }
5595                public List<TbodyTagOpenContext> tbodyTagOpen() {
5596                        return getRuleContexts(TbodyTagOpenContext.class);
5597                }
5598                public List<TheadContext> thead() {
5599                        return getRuleContexts(TheadContext.class);
5600                }
5601                public LiContext li(int i) {
5602                        return getRuleContext(LiContext.class,i);
5603                }
5604                public List<TfootTagOpenContext> tfootTagOpen() {
5605                        return getRuleContexts(TfootTagOpenContext.class);
5606                }
5607                public List<TfootContext> tfoot() {
5608                        return getRuleContexts(TfootContext.class);
5609                }
5610                public List<JavadocInlineTagContext> javadocInlineTag() {
5611                        return getRuleContexts(JavadocInlineTagContext.class);
5612                }
5613                public List<HtmlCommentContext> htmlComment() {
5614                        return getRuleContexts(HtmlCommentContext.class);
5615                }
5616                public OptionContext option(int i) {
5617                        return getRuleContext(OptionContext.class,i);
5618                }
5619                public TrContext tr(int i) {
5620                        return getRuleContext(TrContext.class,i);
5621                }
5622                public List<DtContext> dt() {
5623                        return getRuleContexts(DtContext.class);
5624                }
5625                public HtmlCommentContext htmlComment(int i) {
5626                        return getRuleContext(HtmlCommentContext.class,i);
5627                }
5628                public List<TdContext> td() {
5629                        return getRuleContexts(TdContext.class);
5630                }
5631                public List<BodyTagOpenContext> bodyTagOpen() {
5632                        return getRuleContexts(BodyTagOpenContext.class);
5633                }
5634                public DtTagOpenContext dtTagOpen(int i) {
5635                        return getRuleContext(DtTagOpenContext.class,i);
5636                }
5637                public HtmlContext html(int i) {
5638                        return getRuleContext(HtmlContext.class,i);
5639                }
5640                public BodyTagOpenContext bodyTagOpen(int i) {
5641                        return getRuleContext(BodyTagOpenContext.class,i);
5642                }
5643                public DdTagOpenContext ddTagOpen(int i) {
5644                        return getRuleContext(DdTagOpenContext.class,i);
5645                }
5646                public List<HtmlTagContext> htmlTag() {
5647                        return getRuleContexts(HtmlTagContext.class);
5648                }
5649                public ParagraphContext paragraph(int i) {
5650                        return getRuleContext(ParagraphContext.class,i);
5651                }
5652                public List<TdTagOpenContext> tdTagOpen() {
5653                        return getRuleContexts(TdTagOpenContext.class);
5654                }
5655                public OptionTagOpenContext optionTagOpen(int i) {
5656                        return getRuleContext(OptionTagOpenContext.class,i);
5657                }
5658                public LiTagOpenContext liTagOpen(int i) {
5659                        return getRuleContext(LiTagOpenContext.class,i);
5660                }
5661                public TdContext td(int i) {
5662                        return getRuleContext(TdContext.class,i);
5663                }
5664                public List<ParagraphContext> paragraph() {
5665                        return getRuleContexts(ParagraphContext.class);
5666                }
5667                public HtmlTagContext htmlTag(int i) {
5668                        return getRuleContext(HtmlTagContext.class,i);
5669                }
5670                public List<SingletonTagContext> singletonTag() {
5671                        return getRuleContexts(SingletonTagContext.class);
5672                }
5673                public HeadTagOpenContext headTagOpen(int i) {
5674                        return getRuleContext(HeadTagOpenContext.class,i);
5675                }
5676                public TrTagOpenContext trTagOpen(int i) {
5677                        return getRuleContext(TrTagOpenContext.class,i);
5678                }
5679                public List<HtmlContext> html() {
5680                        return getRuleContexts(HtmlContext.class);
5681                }
5682                public JavadocInlineTagContext javadocInlineTag(int i) {
5683                        return getRuleContext(JavadocInlineTagContext.class,i);
5684                }
5685                public List<ThContext> th() {
5686                        return getRuleContexts(ThContext.class);
5687                }
5688                public DtContext dt(int i) {
5689                        return getRuleContext(DtContext.class,i);
5690                }
5691                public PTagOpenContext pTagOpen(int i) {
5692                        return getRuleContext(PTagOpenContext.class,i);
5693                }
5694                public TerminalNode LEADING_ASTERISK(int i) {
5695                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5696                }
5697                public List<TrTagOpenContext> trTagOpen() {
5698                        return getRuleContexts(TrTagOpenContext.class);
5699                }
5700                public List<TbodyContext> tbody() {
5701                        return getRuleContexts(TbodyContext.class);
5702                }
5703                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
5704                public List<TheadTagOpenContext> theadTagOpen() {
5705                        return getRuleContexts(TheadTagOpenContext.class);
5706                }
5707                public List<HeadContext> head() {
5708                        return getRuleContexts(HeadContext.class);
5709                }
5710                public TerminalNode NEWLINE(int i) {
5711                        return getToken(JavadocParser.NEWLINE, i);
5712                }
5713                public TextContext text(int i) {
5714                        return getRuleContext(TextContext.class,i);
5715                }
5716                public List<BodyContext> body() {
5717                        return getRuleContexts(BodyContext.class);
5718                }
5719                public List<OptionTagOpenContext> optionTagOpen() {
5720                        return getRuleContexts(OptionTagOpenContext.class);
5721                }
5722                public List<TextContext> text() {
5723                        return getRuleContexts(TextContext.class);
5724                }
5725                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5726                public TbodyTagOpenContext tbodyTagOpen(int i) {
5727                        return getRuleContext(TbodyTagOpenContext.class,i);
5728                }
5729                public List<DdContext> dd() {
5730                        return getRuleContexts(DdContext.class);
5731                }
5732                public TheadTagOpenContext theadTagOpen(int i) {
5733                        return getRuleContext(TheadTagOpenContext.class,i);
5734                }
5735                public ColgroupTagCloseContext colgroupTagClose() {
5736                        return getRuleContext(ColgroupTagCloseContext.class,0);
5737                }
5738                public List<LiTagOpenContext> liTagOpen() {
5739                        return getRuleContexts(LiTagOpenContext.class);
5740                }
5741                public DdContext dd(int i) {
5742                        return getRuleContext(DdContext.class,i);
5743                }
5744                public List<OptionContext> option() {
5745                        return getRuleContexts(OptionContext.class);
5746                }
5747                public TheadContext thead(int i) {
5748                        return getRuleContext(TheadContext.class,i);
5749                }
5750                public BodyContext body(int i) {
5751                        return getRuleContext(BodyContext.class,i);
5752                }
5753                public ThContext th(int i) {
5754                        return getRuleContext(ThContext.class,i);
5755                }
5756                public List<PTagOpenContext> pTagOpen() {
5757                        return getRuleContexts(PTagOpenContext.class);
5758                }
5759                public HtmlTagOpenContext htmlTagOpen(int i) {
5760                        return getRuleContext(HtmlTagOpenContext.class,i);
5761                }
5762                public SingletonTagContext singletonTag(int i) {
5763                        return getRuleContext(SingletonTagContext.class,i);
5764                }
5765                public TfootContext tfoot(int i) {
5766                        return getRuleContext(TfootContext.class,i);
5767                }
5768                public ColgroupContext(ParserRuleContext parent, int invokingState) {
5769                        super(parent, invokingState);
5770                }
5771                @Override public int getRuleIndex() { return RULE_colgroup; }
5772                @Override
5773                public void enterRule(ParseTreeListener listener) {
5774                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroup(this);
5775                }
5776                @Override
5777                public void exitRule(ParseTreeListener listener) {
5778                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroup(this);
5779                }
5780                @Override
5781                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5782                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroup(this);
5783                        else return visitor.visitChildren(this);
5784                }
5785        }
5786
5787        public final ColgroupContext colgroup() throws RecognitionException {
5788                ColgroupContext _localctx = new ColgroupContext(_ctx, getState());
5789                enterRule(_localctx, 52, RULE_colgroup);
5790                try {
5791                        int _alt;
5792                        enterOuterAlt(_localctx, 1);
5793                        {
5794                        setState(744); colgroupTagOpen();
5795                        setState(784);
5796                        _errHandler.sync(this);
5797                        _alt = getInterpreter().adaptivePredict(_input,51,_ctx);
5798                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5799                                if ( _alt==1 ) {
5800                                        {
5801                                        setState(782);
5802                                        switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
5803                                        case 1:
5804                                                {
5805                                                setState(745); htmlTag();
5806                                                }
5807                                                break;
5808
5809                                        case 2:
5810                                                {
5811                                                setState(746); singletonTag();
5812                                                }
5813                                                break;
5814
5815                                        case 3:
5816                                                {
5817                                                setState(747); paragraph();
5818                                                }
5819                                                break;
5820
5821                                        case 4:
5822                                                {
5823                                                setState(748); li();
5824                                                }
5825                                                break;
5826
5827                                        case 5:
5828                                                {
5829                                                setState(749); tr();
5830                                                }
5831                                                break;
5832
5833                                        case 6:
5834                                                {
5835                                                setState(750); td();
5836                                                }
5837                                                break;
5838
5839                                        case 7:
5840                                                {
5841                                                setState(751); th();
5842                                                }
5843                                                break;
5844
5845                                        case 8:
5846                                                {
5847                                                setState(752); body();
5848                                                }
5849                                                break;
5850
5851                                        case 9:
5852                                                {
5853                                                setState(753); dd();
5854                                                }
5855                                                break;
5856
5857                                        case 10:
5858                                                {
5859                                                setState(754); dt();
5860                                                }
5861                                                break;
5862
5863                                        case 11:
5864                                                {
5865                                                setState(755); head();
5866                                                }
5867                                                break;
5868
5869                                        case 12:
5870                                                {
5871                                                setState(756); html();
5872                                                }
5873                                                break;
5874
5875                                        case 13:
5876                                                {
5877                                                setState(757); option();
5878                                                }
5879                                                break;
5880
5881                                        case 14:
5882                                                {
5883                                                setState(758); tbody();
5884                                                }
5885                                                break;
5886
5887                                        case 15:
5888                                                {
5889                                                setState(759); thead();
5890                                                }
5891                                                break;
5892
5893                                        case 16:
5894                                                {
5895                                                setState(760); tfoot();
5896                                                }
5897                                                break;
5898
5899                                        case 17:
5900                                                {
5901                                                setState(761); pTagOpen();
5902                                                }
5903                                                break;
5904
5905                                        case 18:
5906                                                {
5907                                                setState(762); liTagOpen();
5908                                                }
5909                                                break;
5910
5911                                        case 19:
5912                                                {
5913                                                setState(763); trTagOpen();
5914                                                }
5915                                                break;
5916
5917                                        case 20:
5918                                                {
5919                                                setState(764); tdTagOpen();
5920                                                }
5921                                                break;
5922
5923                                        case 21:
5924                                                {
5925                                                setState(765); thTagOpen();
5926                                                }
5927                                                break;
5928
5929                                        case 22:
5930                                                {
5931                                                setState(766); bodyTagOpen();
5932                                                }
5933                                                break;
5934
5935                                        case 23:
5936                                                {
5937                                                setState(767); ddTagOpen();
5938                                                }
5939                                                break;
5940
5941                                        case 24:
5942                                                {
5943                                                setState(768); dtTagOpen();
5944                                                }
5945                                                break;
5946
5947                                        case 25:
5948                                                {
5949                                                setState(769); headTagOpen();
5950                                                }
5951                                                break;
5952
5953                                        case 26:
5954                                                {
5955                                                setState(770); htmlTagOpen();
5956                                                }
5957                                                break;
5958
5959                                        case 27:
5960                                                {
5961                                                setState(771); optionTagOpen();
5962                                                }
5963                                                break;
5964
5965                                        case 28:
5966                                                {
5967                                                setState(772); tbodyTagOpen();
5968                                                }
5969                                                break;
5970
5971                                        case 29:
5972                                                {
5973                                                setState(773); theadTagOpen();
5974                                                }
5975                                                break;
5976
5977                                        case 30:
5978                                                {
5979                                                setState(774); tfootTagOpen();
5980                                                }
5981                                                break;
5982
5983                                        case 31:
5984                                                {
5985                                                {
5986                                                setState(775);
5987                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
5988                                                setState(776); match(LEADING_ASTERISK);
5989                                                }
5990                                                }
5991                                                break;
5992
5993                                        case 32:
5994                                                {
5995                                                setState(777); htmlComment();
5996                                                }
5997                                                break;
5998
5999                                        case 33:
6000                                                {
6001                                                setState(778); match(CDATA);
6002                                                }
6003                                                break;
6004
6005                                        case 34:
6006                                                {
6007                                                setState(779); match(NEWLINE);
6008                                                }
6009                                                break;
6010
6011                                        case 35:
6012                                                {
6013                                                setState(780); text();
6014                                                }
6015                                                break;
6016
6017                                        case 36:
6018                                                {
6019                                                setState(781); javadocInlineTag();
6020                                                }
6021                                                break;
6022                                        }
6023                                        } 
6024                                }
6025                                setState(786);
6026                                _errHandler.sync(this);
6027                                _alt = getInterpreter().adaptivePredict(_input,51,_ctx);
6028                        }
6029                        setState(787); colgroupTagClose();
6030                        }
6031                }
6032                catch (RecognitionException re) {
6033                        _localctx.exception = re;
6034                        _errHandler.reportError(this, re);
6035                        _errHandler.recover(this, re);
6036                }
6037                finally {
6038                        exitRule();
6039                }
6040                return _localctx;
6041        }
6042
6043        public static class DdTagOpenContext extends ParserRuleContext {
6044                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6045                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
6046                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6047                public TerminalNode NEWLINE(int i) {
6048                        return getToken(JavadocParser.NEWLINE, i);
6049                }
6050                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6051                public List<AttributeContext> attribute() {
6052                        return getRuleContexts(AttributeContext.class);
6053                }
6054                public AttributeContext attribute(int i) {
6055                        return getRuleContext(AttributeContext.class,i);
6056                }
6057                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6058                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6059                public TerminalNode LEADING_ASTERISK(int i) {
6060                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6061                }
6062                public TerminalNode WS(int i) {
6063                        return getToken(JavadocParser.WS, i);
6064                }
6065                public DdTagOpenContext(ParserRuleContext parent, int invokingState) {
6066                        super(parent, invokingState);
6067                }
6068                @Override public int getRuleIndex() { return RULE_ddTagOpen; }
6069                @Override
6070                public void enterRule(ParseTreeListener listener) {
6071                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagOpen(this);
6072                }
6073                @Override
6074                public void exitRule(ParseTreeListener listener) {
6075                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagOpen(this);
6076                }
6077                @Override
6078                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6079                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagOpen(this);
6080                        else return visitor.visitChildren(this);
6081                }
6082        }
6083
6084        public final DdTagOpenContext ddTagOpen() throws RecognitionException {
6085                DdTagOpenContext _localctx = new DdTagOpenContext(_ctx, getState());
6086                enterRule(_localctx, 54, RULE_ddTagOpen);
6087                int _la;
6088                try {
6089                        enterOuterAlt(_localctx, 1);
6090                        {
6091                        setState(789); match(OPEN);
6092                        setState(790); match(DD_HTML_TAG_NAME);
6093                        setState(797);
6094                        _errHandler.sync(this);
6095                        _la = _input.LA(1);
6096                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
6097                                {
6098                                setState(795);
6099                                switch (_input.LA(1)) {
6100                                case HTML_TAG_NAME:
6101                                        {
6102                                        setState(791); attribute();
6103                                        }
6104                                        break;
6105                                case NEWLINE:
6106                                        {
6107                                        setState(792); match(NEWLINE);
6108                                        }
6109                                        break;
6110                                case LEADING_ASTERISK:
6111                                        {
6112                                        setState(793); match(LEADING_ASTERISK);
6113                                        }
6114                                        break;
6115                                case WS:
6116                                        {
6117                                        setState(794); match(WS);
6118                                        }
6119                                        break;
6120                                default:
6121                                        throw new NoViableAltException(this);
6122                                }
6123                                }
6124                                setState(799);
6125                                _errHandler.sync(this);
6126                                _la = _input.LA(1);
6127                        }
6128                        setState(800); match(CLOSE);
6129                        }
6130                }
6131                catch (RecognitionException re) {
6132                        _localctx.exception = re;
6133                        _errHandler.reportError(this, re);
6134                        _errHandler.recover(this, re);
6135                }
6136                finally {
6137                        exitRule();
6138                }
6139                return _localctx;
6140        }
6141
6142        public static class DdTagCloseContext extends ParserRuleContext {
6143                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6144                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
6145                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6146                public TerminalNode NEWLINE(int i) {
6147                        return getToken(JavadocParser.NEWLINE, i);
6148                }
6149                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6150                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6151                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6152                public TerminalNode LEADING_ASTERISK(int i) {
6153                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6154                }
6155                public TerminalNode WS(int i) {
6156                        return getToken(JavadocParser.WS, i);
6157                }
6158                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
6159                public DdTagCloseContext(ParserRuleContext parent, int invokingState) {
6160                        super(parent, invokingState);
6161                }
6162                @Override public int getRuleIndex() { return RULE_ddTagClose; }
6163                @Override
6164                public void enterRule(ParseTreeListener listener) {
6165                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagClose(this);
6166                }
6167                @Override
6168                public void exitRule(ParseTreeListener listener) {
6169                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagClose(this);
6170                }
6171                @Override
6172                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6173                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagClose(this);
6174                        else return visitor.visitChildren(this);
6175                }
6176        }
6177
6178        public final DdTagCloseContext ddTagClose() throws RecognitionException {
6179                DdTagCloseContext _localctx = new DdTagCloseContext(_ctx, getState());
6180                enterRule(_localctx, 56, RULE_ddTagClose);
6181                int _la;
6182                try {
6183                        enterOuterAlt(_localctx, 1);
6184                        {
6185                        setState(802); match(OPEN);
6186                        setState(803); match(SLASH);
6187                        setState(804); match(DD_HTML_TAG_NAME);
6188                        setState(808);
6189                        _errHandler.sync(this);
6190                        _la = _input.LA(1);
6191                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
6192                                {
6193                                {
6194                                setState(805);
6195                                _la = _input.LA(1);
6196                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
6197                                _errHandler.recoverInline(this);
6198                                }
6199                                consume();
6200                                }
6201                                }
6202                                setState(810);
6203                                _errHandler.sync(this);
6204                                _la = _input.LA(1);
6205                        }
6206                        setState(811); match(CLOSE);
6207                        }
6208                }
6209                catch (RecognitionException re) {
6210                        _localctx.exception = re;
6211                        _errHandler.reportError(this, re);
6212                        _errHandler.recover(this, re);
6213                }
6214                finally {
6215                        exitRule();
6216                }
6217                return _localctx;
6218        }
6219
6220        public static class DdContext extends ParserRuleContext {
6221                public List<ColgroupTagOpenContext> colgroupTagOpen() {
6222                        return getRuleContexts(ColgroupTagOpenContext.class);
6223                }
6224                public TbodyContext tbody(int i) {
6225                        return getRuleContext(TbodyContext.class,i);
6226                }
6227                public TerminalNode CDATA(int i) {
6228                        return getToken(JavadocParser.CDATA, i);
6229                }
6230                public TfootTagOpenContext tfootTagOpen(int i) {
6231                        return getRuleContext(TfootTagOpenContext.class,i);
6232                }
6233                public DdTagCloseContext ddTagClose() {
6234                        return getRuleContext(DdTagCloseContext.class,0);
6235                }
6236                public List<DtTagOpenContext> dtTagOpen() {
6237                        return getRuleContexts(DtTagOpenContext.class);
6238                }
6239                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6240                public HeadContext head(int i) {
6241                        return getRuleContext(HeadContext.class,i);
6242                }
6243                public List<ColgroupContext> colgroup() {
6244                        return getRuleContexts(ColgroupContext.class);
6245                }
6246                public List<TrContext> tr() {
6247                        return getRuleContexts(TrContext.class);
6248                }
6249                public List<LiContext> li() {
6250                        return getRuleContexts(LiContext.class);
6251                }
6252                public ThTagOpenContext thTagOpen(int i) {
6253                        return getRuleContext(ThTagOpenContext.class,i);
6254                }
6255                public DdTagOpenContext ddTagOpen() {
6256                        return getRuleContext(DdTagOpenContext.class,0);
6257                }
6258                public ColgroupContext colgroup(int i) {
6259                        return getRuleContext(ColgroupContext.class,i);
6260                }
6261                public TdTagOpenContext tdTagOpen(int i) {
6262                        return getRuleContext(TdTagOpenContext.class,i);
6263                }
6264                public List<ThTagOpenContext> thTagOpen() {
6265                        return getRuleContexts(ThTagOpenContext.class);
6266                }
6267                public List<HeadTagOpenContext> headTagOpen() {
6268                        return getRuleContexts(HeadTagOpenContext.class);
6269                }
6270                public List<HtmlTagOpenContext> htmlTagOpen() {
6271                        return getRuleContexts(HtmlTagOpenContext.class);
6272                }
6273                public List<TbodyTagOpenContext> tbodyTagOpen() {
6274                        return getRuleContexts(TbodyTagOpenContext.class);
6275                }
6276                public List<TheadContext> thead() {
6277                        return getRuleContexts(TheadContext.class);
6278                }
6279                public LiContext li(int i) {
6280                        return getRuleContext(LiContext.class,i);
6281                }
6282                public List<TfootTagOpenContext> tfootTagOpen() {
6283                        return getRuleContexts(TfootTagOpenContext.class);
6284                }
6285                public List<TfootContext> tfoot() {
6286                        return getRuleContexts(TfootContext.class);
6287                }
6288                public List<JavadocInlineTagContext> javadocInlineTag() {
6289                        return getRuleContexts(JavadocInlineTagContext.class);
6290                }
6291                public List<HtmlCommentContext> htmlComment() {
6292                        return getRuleContexts(HtmlCommentContext.class);
6293                }
6294                public OptionContext option(int i) {
6295                        return getRuleContext(OptionContext.class,i);
6296                }
6297                public TrContext tr(int i) {
6298                        return getRuleContext(TrContext.class,i);
6299                }
6300                public List<DtContext> dt() {
6301                        return getRuleContexts(DtContext.class);
6302                }
6303                public HtmlCommentContext htmlComment(int i) {
6304                        return getRuleContext(HtmlCommentContext.class,i);
6305                }
6306                public List<TdContext> td() {
6307                        return getRuleContexts(TdContext.class);
6308                }
6309                public List<BodyTagOpenContext> bodyTagOpen() {
6310                        return getRuleContexts(BodyTagOpenContext.class);
6311                }
6312                public DtTagOpenContext dtTagOpen(int i) {
6313                        return getRuleContext(DtTagOpenContext.class,i);
6314                }
6315                public HtmlContext html(int i) {
6316                        return getRuleContext(HtmlContext.class,i);
6317                }
6318                public BodyTagOpenContext bodyTagOpen(int i) {
6319                        return getRuleContext(BodyTagOpenContext.class,i);
6320                }
6321                public List<HtmlTagContext> htmlTag() {
6322                        return getRuleContexts(HtmlTagContext.class);
6323                }
6324                public ParagraphContext paragraph(int i) {
6325                        return getRuleContext(ParagraphContext.class,i);
6326                }
6327                public List<TdTagOpenContext> tdTagOpen() {
6328                        return getRuleContexts(TdTagOpenContext.class);
6329                }
6330                public OptionTagOpenContext optionTagOpen(int i) {
6331                        return getRuleContext(OptionTagOpenContext.class,i);
6332                }
6333                public LiTagOpenContext liTagOpen(int i) {
6334                        return getRuleContext(LiTagOpenContext.class,i);
6335                }
6336                public TdContext td(int i) {
6337                        return getRuleContext(TdContext.class,i);
6338                }
6339                public List<ParagraphContext> paragraph() {
6340                        return getRuleContexts(ParagraphContext.class);
6341                }
6342                public HtmlTagContext htmlTag(int i) {
6343                        return getRuleContext(HtmlTagContext.class,i);
6344                }
6345                public List<SingletonTagContext> singletonTag() {
6346                        return getRuleContexts(SingletonTagContext.class);
6347                }
6348                public HeadTagOpenContext headTagOpen(int i) {
6349                        return getRuleContext(HeadTagOpenContext.class,i);
6350                }
6351                public TrTagOpenContext trTagOpen(int i) {
6352                        return getRuleContext(TrTagOpenContext.class,i);
6353                }
6354                public List<HtmlContext> html() {
6355                        return getRuleContexts(HtmlContext.class);
6356                }
6357                public JavadocInlineTagContext javadocInlineTag(int i) {
6358                        return getRuleContext(JavadocInlineTagContext.class,i);
6359                }
6360                public List<ThContext> th() {
6361                        return getRuleContexts(ThContext.class);
6362                }
6363                public DtContext dt(int i) {
6364                        return getRuleContext(DtContext.class,i);
6365                }
6366                public PTagOpenContext pTagOpen(int i) {
6367                        return getRuleContext(PTagOpenContext.class,i);
6368                }
6369                public TerminalNode LEADING_ASTERISK(int i) {
6370                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6371                }
6372                public List<TrTagOpenContext> trTagOpen() {
6373                        return getRuleContexts(TrTagOpenContext.class);
6374                }
6375                public List<TbodyContext> tbody() {
6376                        return getRuleContexts(TbodyContext.class);
6377                }
6378                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
6379                public List<TheadTagOpenContext> theadTagOpen() {
6380                        return getRuleContexts(TheadTagOpenContext.class);
6381                }
6382                public List<HeadContext> head() {
6383                        return getRuleContexts(HeadContext.class);
6384                }
6385                public TerminalNode NEWLINE(int i) {
6386                        return getToken(JavadocParser.NEWLINE, i);
6387                }
6388                public TextContext text(int i) {
6389                        return getRuleContext(TextContext.class,i);
6390                }
6391                public List<BodyContext> body() {
6392                        return getRuleContexts(BodyContext.class);
6393                }
6394                public List<OptionTagOpenContext> optionTagOpen() {
6395                        return getRuleContexts(OptionTagOpenContext.class);
6396                }
6397                public List<TextContext> text() {
6398                        return getRuleContexts(TextContext.class);
6399                }
6400                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6401                public TbodyTagOpenContext tbodyTagOpen(int i) {
6402                        return getRuleContext(TbodyTagOpenContext.class,i);
6403                }
6404                public TheadTagOpenContext theadTagOpen(int i) {
6405                        return getRuleContext(TheadTagOpenContext.class,i);
6406                }
6407                public ColgroupTagOpenContext colgroupTagOpen(int i) {
6408                        return getRuleContext(ColgroupTagOpenContext.class,i);
6409                }
6410                public List<LiTagOpenContext> liTagOpen() {
6411                        return getRuleContexts(LiTagOpenContext.class);
6412                }
6413                public List<OptionContext> option() {
6414                        return getRuleContexts(OptionContext.class);
6415                }
6416                public TheadContext thead(int i) {
6417                        return getRuleContext(TheadContext.class,i);
6418                }
6419                public BodyContext body(int i) {
6420                        return getRuleContext(BodyContext.class,i);
6421                }
6422                public ThContext th(int i) {
6423                        return getRuleContext(ThContext.class,i);
6424                }
6425                public List<PTagOpenContext> pTagOpen() {
6426                        return getRuleContexts(PTagOpenContext.class);
6427                }
6428                public HtmlTagOpenContext htmlTagOpen(int i) {
6429                        return getRuleContext(HtmlTagOpenContext.class,i);
6430                }
6431                public SingletonTagContext singletonTag(int i) {
6432                        return getRuleContext(SingletonTagContext.class,i);
6433                }
6434                public TfootContext tfoot(int i) {
6435                        return getRuleContext(TfootContext.class,i);
6436                }
6437                public DdContext(ParserRuleContext parent, int invokingState) {
6438                        super(parent, invokingState);
6439                }
6440                @Override public int getRuleIndex() { return RULE_dd; }
6441                @Override
6442                public void enterRule(ParseTreeListener listener) {
6443                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDd(this);
6444                }
6445                @Override
6446                public void exitRule(ParseTreeListener listener) {
6447                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDd(this);
6448                }
6449                @Override
6450                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6451                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDd(this);
6452                        else return visitor.visitChildren(this);
6453                }
6454        }
6455
6456        public final DdContext dd() throws RecognitionException {
6457                DdContext _localctx = new DdContext(_ctx, getState());
6458                enterRule(_localctx, 58, RULE_dd);
6459                try {
6460                        int _alt;
6461                        enterOuterAlt(_localctx, 1);
6462                        {
6463                        setState(813); ddTagOpen();
6464                        setState(853);
6465                        _errHandler.sync(this);
6466                        _alt = getInterpreter().adaptivePredict(_input,56,_ctx);
6467                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
6468                                if ( _alt==1 ) {
6469                                        {
6470                                        setState(851);
6471                                        switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
6472                                        case 1:
6473                                                {
6474                                                setState(814); htmlTag();
6475                                                }
6476                                                break;
6477
6478                                        case 2:
6479                                                {
6480                                                setState(815); singletonTag();
6481                                                }
6482                                                break;
6483
6484                                        case 3:
6485                                                {
6486                                                setState(816); paragraph();
6487                                                }
6488                                                break;
6489
6490                                        case 4:
6491                                                {
6492                                                setState(817); li();
6493                                                }
6494                                                break;
6495
6496                                        case 5:
6497                                                {
6498                                                setState(818); tr();
6499                                                }
6500                                                break;
6501
6502                                        case 6:
6503                                                {
6504                                                setState(819); td();
6505                                                }
6506                                                break;
6507
6508                                        case 7:
6509                                                {
6510                                                setState(820); th();
6511                                                }
6512                                                break;
6513
6514                                        case 8:
6515                                                {
6516                                                setState(821); body();
6517                                                }
6518                                                break;
6519
6520                                        case 9:
6521                                                {
6522                                                setState(822); colgroup();
6523                                                }
6524                                                break;
6525
6526                                        case 10:
6527                                                {
6528                                                setState(823); dt();
6529                                                }
6530                                                break;
6531
6532                                        case 11:
6533                                                {
6534                                                setState(824); head();
6535                                                }
6536                                                break;
6537
6538                                        case 12:
6539                                                {
6540                                                setState(825); html();
6541                                                }
6542                                                break;
6543
6544                                        case 13:
6545                                                {
6546                                                setState(826); option();
6547                                                }
6548                                                break;
6549
6550                                        case 14:
6551                                                {
6552                                                setState(827); tbody();
6553                                                }
6554                                                break;
6555
6556                                        case 15:
6557                                                {
6558                                                setState(828); thead();
6559                                                }
6560                                                break;
6561
6562                                        case 16:
6563                                                {
6564                                                setState(829); tfoot();
6565                                                }
6566                                                break;
6567
6568                                        case 17:
6569                                                {
6570                                                setState(830); pTagOpen();
6571                                                }
6572                                                break;
6573
6574                                        case 18:
6575                                                {
6576                                                setState(831); liTagOpen();
6577                                                }
6578                                                break;
6579
6580                                        case 19:
6581                                                {
6582                                                setState(832); trTagOpen();
6583                                                }
6584                                                break;
6585
6586                                        case 20:
6587                                                {
6588                                                setState(833); tdTagOpen();
6589                                                }
6590                                                break;
6591
6592                                        case 21:
6593                                                {
6594                                                setState(834); thTagOpen();
6595                                                }
6596                                                break;
6597
6598                                        case 22:
6599                                                {
6600                                                setState(835); bodyTagOpen();
6601                                                }
6602                                                break;
6603
6604                                        case 23:
6605                                                {
6606                                                setState(836); colgroupTagOpen();
6607                                                }
6608                                                break;
6609
6610                                        case 24:
6611                                                {
6612                                                setState(837); dtTagOpen();
6613                                                }
6614                                                break;
6615
6616                                        case 25:
6617                                                {
6618                                                setState(838); headTagOpen();
6619                                                }
6620                                                break;
6621
6622                                        case 26:
6623                                                {
6624                                                setState(839); htmlTagOpen();
6625                                                }
6626                                                break;
6627
6628                                        case 27:
6629                                                {
6630                                                setState(840); optionTagOpen();
6631                                                }
6632                                                break;
6633
6634                                        case 28:
6635                                                {
6636                                                setState(841); tbodyTagOpen();
6637                                                }
6638                                                break;
6639
6640                                        case 29:
6641                                                {
6642                                                setState(842); theadTagOpen();
6643                                                }
6644                                                break;
6645
6646                                        case 30:
6647                                                {
6648                                                setState(843); tfootTagOpen();
6649                                                }
6650                                                break;
6651
6652                                        case 31:
6653                                                {
6654                                                {
6655                                                setState(844);
6656                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
6657                                                setState(845); match(LEADING_ASTERISK);
6658                                                }
6659                                                }
6660                                                break;
6661
6662                                        case 32:
6663                                                {
6664                                                setState(846); htmlComment();
6665                                                }
6666                                                break;
6667
6668                                        case 33:
6669                                                {
6670                                                setState(847); match(CDATA);
6671                                                }
6672                                                break;
6673
6674                                        case 34:
6675                                                {
6676                                                setState(848); match(NEWLINE);
6677                                                }
6678                                                break;
6679
6680                                        case 35:
6681                                                {
6682                                                setState(849); text();
6683                                                }
6684                                                break;
6685
6686                                        case 36:
6687                                                {
6688                                                setState(850); javadocInlineTag();
6689                                                }
6690                                                break;
6691                                        }
6692                                        } 
6693                                }
6694                                setState(855);
6695                                _errHandler.sync(this);
6696                                _alt = getInterpreter().adaptivePredict(_input,56,_ctx);
6697                        }
6698                        setState(856); ddTagClose();
6699                        }
6700                }
6701                catch (RecognitionException re) {
6702                        _localctx.exception = re;
6703                        _errHandler.reportError(this, re);
6704                        _errHandler.recover(this, re);
6705                }
6706                finally {
6707                        exitRule();
6708                }
6709                return _localctx;
6710        }
6711
6712        public static class DtTagOpenContext extends ParserRuleContext {
6713                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6714                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
6715                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6716                public TerminalNode NEWLINE(int i) {
6717                        return getToken(JavadocParser.NEWLINE, i);
6718                }
6719                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6720                public List<AttributeContext> attribute() {
6721                        return getRuleContexts(AttributeContext.class);
6722                }
6723                public AttributeContext attribute(int i) {
6724                        return getRuleContext(AttributeContext.class,i);
6725                }
6726                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6727                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6728                public TerminalNode LEADING_ASTERISK(int i) {
6729                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6730                }
6731                public TerminalNode WS(int i) {
6732                        return getToken(JavadocParser.WS, i);
6733                }
6734                public DtTagOpenContext(ParserRuleContext parent, int invokingState) {
6735                        super(parent, invokingState);
6736                }
6737                @Override public int getRuleIndex() { return RULE_dtTagOpen; }
6738                @Override
6739                public void enterRule(ParseTreeListener listener) {
6740                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagOpen(this);
6741                }
6742                @Override
6743                public void exitRule(ParseTreeListener listener) {
6744                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagOpen(this);
6745                }
6746                @Override
6747                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6748                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagOpen(this);
6749                        else return visitor.visitChildren(this);
6750                }
6751        }
6752
6753        public final DtTagOpenContext dtTagOpen() throws RecognitionException {
6754                DtTagOpenContext _localctx = new DtTagOpenContext(_ctx, getState());
6755                enterRule(_localctx, 60, RULE_dtTagOpen);
6756                int _la;
6757                try {
6758                        enterOuterAlt(_localctx, 1);
6759                        {
6760                        setState(858); match(OPEN);
6761                        setState(859); match(DT_HTML_TAG_NAME);
6762                        setState(866);
6763                        _errHandler.sync(this);
6764                        _la = _input.LA(1);
6765                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
6766                                {
6767                                setState(864);
6768                                switch (_input.LA(1)) {
6769                                case HTML_TAG_NAME:
6770                                        {
6771                                        setState(860); attribute();
6772                                        }
6773                                        break;
6774                                case NEWLINE:
6775                                        {
6776                                        setState(861); match(NEWLINE);
6777                                        }
6778                                        break;
6779                                case LEADING_ASTERISK:
6780                                        {
6781                                        setState(862); match(LEADING_ASTERISK);
6782                                        }
6783                                        break;
6784                                case WS:
6785                                        {
6786                                        setState(863); match(WS);
6787                                        }
6788                                        break;
6789                                default:
6790                                        throw new NoViableAltException(this);
6791                                }
6792                                }
6793                                setState(868);
6794                                _errHandler.sync(this);
6795                                _la = _input.LA(1);
6796                        }
6797                        setState(869); match(CLOSE);
6798                        }
6799                }
6800                catch (RecognitionException re) {
6801                        _localctx.exception = re;
6802                        _errHandler.reportError(this, re);
6803                        _errHandler.recover(this, re);
6804                }
6805                finally {
6806                        exitRule();
6807                }
6808                return _localctx;
6809        }
6810
6811        public static class DtTagCloseContext extends ParserRuleContext {
6812                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6813                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
6814                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6815                public TerminalNode NEWLINE(int i) {
6816                        return getToken(JavadocParser.NEWLINE, i);
6817                }
6818                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6819                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6820                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6821                public TerminalNode LEADING_ASTERISK(int i) {
6822                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6823                }
6824                public TerminalNode WS(int i) {
6825                        return getToken(JavadocParser.WS, i);
6826                }
6827                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
6828                public DtTagCloseContext(ParserRuleContext parent, int invokingState) {
6829                        super(parent, invokingState);
6830                }
6831                @Override public int getRuleIndex() { return RULE_dtTagClose; }
6832                @Override
6833                public void enterRule(ParseTreeListener listener) {
6834                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagClose(this);
6835                }
6836                @Override
6837                public void exitRule(ParseTreeListener listener) {
6838                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagClose(this);
6839                }
6840                @Override
6841                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6842                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagClose(this);
6843                        else return visitor.visitChildren(this);
6844                }
6845        }
6846
6847        public final DtTagCloseContext dtTagClose() throws RecognitionException {
6848                DtTagCloseContext _localctx = new DtTagCloseContext(_ctx, getState());
6849                enterRule(_localctx, 62, RULE_dtTagClose);
6850                int _la;
6851                try {
6852                        enterOuterAlt(_localctx, 1);
6853                        {
6854                        setState(871); match(OPEN);
6855                        setState(872); match(SLASH);
6856                        setState(873); match(DT_HTML_TAG_NAME);
6857                        setState(877);
6858                        _errHandler.sync(this);
6859                        _la = _input.LA(1);
6860                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
6861                                {
6862                                {
6863                                setState(874);
6864                                _la = _input.LA(1);
6865                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
6866                                _errHandler.recoverInline(this);
6867                                }
6868                                consume();
6869                                }
6870                                }
6871                                setState(879);
6872                                _errHandler.sync(this);
6873                                _la = _input.LA(1);
6874                        }
6875                        setState(880); match(CLOSE);
6876                        }
6877                }
6878                catch (RecognitionException re) {
6879                        _localctx.exception = re;
6880                        _errHandler.reportError(this, re);
6881                        _errHandler.recover(this, re);
6882                }
6883                finally {
6884                        exitRule();
6885                }
6886                return _localctx;
6887        }
6888
6889        public static class DtContext extends ParserRuleContext {
6890                public List<ColgroupTagOpenContext> colgroupTagOpen() {
6891                        return getRuleContexts(ColgroupTagOpenContext.class);
6892                }
6893                public TbodyContext tbody(int i) {
6894                        return getRuleContext(TbodyContext.class,i);
6895                }
6896                public TerminalNode CDATA(int i) {
6897                        return getToken(JavadocParser.CDATA, i);
6898                }
6899                public TfootTagOpenContext tfootTagOpen(int i) {
6900                        return getRuleContext(TfootTagOpenContext.class,i);
6901                }
6902                public DtTagOpenContext dtTagOpen() {
6903                        return getRuleContext(DtTagOpenContext.class,0);
6904                }
6905                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6906                public HeadContext head(int i) {
6907                        return getRuleContext(HeadContext.class,i);
6908                }
6909                public List<ColgroupContext> colgroup() {
6910                        return getRuleContexts(ColgroupContext.class);
6911                }
6912                public List<TrContext> tr() {
6913                        return getRuleContexts(TrContext.class);
6914                }
6915                public List<LiContext> li() {
6916                        return getRuleContexts(LiContext.class);
6917                }
6918                public ThTagOpenContext thTagOpen(int i) {
6919                        return getRuleContext(ThTagOpenContext.class,i);
6920                }
6921                public List<DdTagOpenContext> ddTagOpen() {
6922                        return getRuleContexts(DdTagOpenContext.class);
6923                }
6924                public ColgroupContext colgroup(int i) {
6925                        return getRuleContext(ColgroupContext.class,i);
6926                }
6927                public TdTagOpenContext tdTagOpen(int i) {
6928                        return getRuleContext(TdTagOpenContext.class,i);
6929                }
6930                public List<ThTagOpenContext> thTagOpen() {
6931                        return getRuleContexts(ThTagOpenContext.class);
6932                }
6933                public List<HeadTagOpenContext> headTagOpen() {
6934                        return getRuleContexts(HeadTagOpenContext.class);
6935                }
6936                public List<HtmlTagOpenContext> htmlTagOpen() {
6937                        return getRuleContexts(HtmlTagOpenContext.class);
6938                }
6939                public List<TbodyTagOpenContext> tbodyTagOpen() {
6940                        return getRuleContexts(TbodyTagOpenContext.class);
6941                }
6942                public List<TheadContext> thead() {
6943                        return getRuleContexts(TheadContext.class);
6944                }
6945                public LiContext li(int i) {
6946                        return getRuleContext(LiContext.class,i);
6947                }
6948                public List<TfootTagOpenContext> tfootTagOpen() {
6949                        return getRuleContexts(TfootTagOpenContext.class);
6950                }
6951                public List<TfootContext> tfoot() {
6952                        return getRuleContexts(TfootContext.class);
6953                }
6954                public List<JavadocInlineTagContext> javadocInlineTag() {
6955                        return getRuleContexts(JavadocInlineTagContext.class);
6956                }
6957                public List<HtmlCommentContext> htmlComment() {
6958                        return getRuleContexts(HtmlCommentContext.class);
6959                }
6960                public OptionContext option(int i) {
6961                        return getRuleContext(OptionContext.class,i);
6962                }
6963                public TrContext tr(int i) {
6964                        return getRuleContext(TrContext.class,i);
6965                }
6966                public HtmlCommentContext htmlComment(int i) {
6967                        return getRuleContext(HtmlCommentContext.class,i);
6968                }
6969                public List<TdContext> td() {
6970                        return getRuleContexts(TdContext.class);
6971                }
6972                public List<BodyTagOpenContext> bodyTagOpen() {
6973                        return getRuleContexts(BodyTagOpenContext.class);
6974                }
6975                public HtmlContext html(int i) {
6976                        return getRuleContext(HtmlContext.class,i);
6977                }
6978                public BodyTagOpenContext bodyTagOpen(int i) {
6979                        return getRuleContext(BodyTagOpenContext.class,i);
6980                }
6981                public DdTagOpenContext ddTagOpen(int i) {
6982                        return getRuleContext(DdTagOpenContext.class,i);
6983                }
6984                public List<HtmlTagContext> htmlTag() {
6985                        return getRuleContexts(HtmlTagContext.class);
6986                }
6987                public ParagraphContext paragraph(int i) {
6988                        return getRuleContext(ParagraphContext.class,i);
6989                }
6990                public List<TdTagOpenContext> tdTagOpen() {
6991                        return getRuleContexts(TdTagOpenContext.class);
6992                }
6993                public OptionTagOpenContext optionTagOpen(int i) {
6994                        return getRuleContext(OptionTagOpenContext.class,i);
6995                }
6996                public LiTagOpenContext liTagOpen(int i) {
6997                        return getRuleContext(LiTagOpenContext.class,i);
6998                }
6999                public TdContext td(int i) {
7000                        return getRuleContext(TdContext.class,i);
7001                }
7002                public List<ParagraphContext> paragraph() {
7003                        return getRuleContexts(ParagraphContext.class);
7004                }
7005                public HtmlTagContext htmlTag(int i) {
7006                        return getRuleContext(HtmlTagContext.class,i);
7007                }
7008                public List<SingletonTagContext> singletonTag() {
7009                        return getRuleContexts(SingletonTagContext.class);
7010                }
7011                public HeadTagOpenContext headTagOpen(int i) {
7012                        return getRuleContext(HeadTagOpenContext.class,i);
7013                }
7014                public TrTagOpenContext trTagOpen(int i) {
7015                        return getRuleContext(TrTagOpenContext.class,i);
7016                }
7017                public List<HtmlContext> html() {
7018                        return getRuleContexts(HtmlContext.class);
7019                }
7020                public JavadocInlineTagContext javadocInlineTag(int i) {
7021                        return getRuleContext(JavadocInlineTagContext.class,i);
7022                }
7023                public List<ThContext> th() {
7024                        return getRuleContexts(ThContext.class);
7025                }
7026                public PTagOpenContext pTagOpen(int i) {
7027                        return getRuleContext(PTagOpenContext.class,i);
7028                }
7029                public TerminalNode LEADING_ASTERISK(int i) {
7030                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7031                }
7032                public List<TrTagOpenContext> trTagOpen() {
7033                        return getRuleContexts(TrTagOpenContext.class);
7034                }
7035                public List<TbodyContext> tbody() {
7036                        return getRuleContexts(TbodyContext.class);
7037                }
7038                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
7039                public List<TheadTagOpenContext> theadTagOpen() {
7040                        return getRuleContexts(TheadTagOpenContext.class);
7041                }
7042                public List<HeadContext> head() {
7043                        return getRuleContexts(HeadContext.class);
7044                }
7045                public TerminalNode NEWLINE(int i) {
7046                        return getToken(JavadocParser.NEWLINE, i);
7047                }
7048                public TextContext text(int i) {
7049                        return getRuleContext(TextContext.class,i);
7050                }
7051                public List<BodyContext> body() {
7052                        return getRuleContexts(BodyContext.class);
7053                }
7054                public List<OptionTagOpenContext> optionTagOpen() {
7055                        return getRuleContexts(OptionTagOpenContext.class);
7056                }
7057                public List<TextContext> text() {
7058                        return getRuleContexts(TextContext.class);
7059                }
7060                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7061                public TbodyTagOpenContext tbodyTagOpen(int i) {
7062                        return getRuleContext(TbodyTagOpenContext.class,i);
7063                }
7064                public List<DdContext> dd() {
7065                        return getRuleContexts(DdContext.class);
7066                }
7067                public TheadTagOpenContext theadTagOpen(int i) {
7068                        return getRuleContext(TheadTagOpenContext.class,i);
7069                }
7070                public ColgroupTagOpenContext colgroupTagOpen(int i) {
7071                        return getRuleContext(ColgroupTagOpenContext.class,i);
7072                }
7073                public List<LiTagOpenContext> liTagOpen() {
7074                        return getRuleContexts(LiTagOpenContext.class);
7075                }
7076                public DdContext dd(int i) {
7077                        return getRuleContext(DdContext.class,i);
7078                }
7079                public List<OptionContext> option() {
7080                        return getRuleContexts(OptionContext.class);
7081                }
7082                public TheadContext thead(int i) {
7083                        return getRuleContext(TheadContext.class,i);
7084                }
7085                public BodyContext body(int i) {
7086                        return getRuleContext(BodyContext.class,i);
7087                }
7088                public ThContext th(int i) {
7089                        return getRuleContext(ThContext.class,i);
7090                }
7091                public List<PTagOpenContext> pTagOpen() {
7092                        return getRuleContexts(PTagOpenContext.class);
7093                }
7094                public HtmlTagOpenContext htmlTagOpen(int i) {
7095                        return getRuleContext(HtmlTagOpenContext.class,i);
7096                }
7097                public SingletonTagContext singletonTag(int i) {
7098                        return getRuleContext(SingletonTagContext.class,i);
7099                }
7100                public DtTagCloseContext dtTagClose() {
7101                        return getRuleContext(DtTagCloseContext.class,0);
7102                }
7103                public TfootContext tfoot(int i) {
7104                        return getRuleContext(TfootContext.class,i);
7105                }
7106                public DtContext(ParserRuleContext parent, int invokingState) {
7107                        super(parent, invokingState);
7108                }
7109                @Override public int getRuleIndex() { return RULE_dt; }
7110                @Override
7111                public void enterRule(ParseTreeListener listener) {
7112                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDt(this);
7113                }
7114                @Override
7115                public void exitRule(ParseTreeListener listener) {
7116                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDt(this);
7117                }
7118                @Override
7119                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7120                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDt(this);
7121                        else return visitor.visitChildren(this);
7122                }
7123        }
7124
7125        public final DtContext dt() throws RecognitionException {
7126                DtContext _localctx = new DtContext(_ctx, getState());
7127                enterRule(_localctx, 64, RULE_dt);
7128                try {
7129                        int _alt;
7130                        enterOuterAlt(_localctx, 1);
7131                        {
7132                        setState(882); dtTagOpen();
7133                        setState(922);
7134                        _errHandler.sync(this);
7135                        _alt = getInterpreter().adaptivePredict(_input,61,_ctx);
7136                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
7137                                if ( _alt==1 ) {
7138                                        {
7139                                        setState(920);
7140                                        switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
7141                                        case 1:
7142                                                {
7143                                                setState(883); htmlTag();
7144                                                }
7145                                                break;
7146
7147                                        case 2:
7148                                                {
7149                                                setState(884); singletonTag();
7150                                                }
7151                                                break;
7152
7153                                        case 3:
7154                                                {
7155                                                setState(885); paragraph();
7156                                                }
7157                                                break;
7158
7159                                        case 4:
7160                                                {
7161                                                setState(886); li();
7162                                                }
7163                                                break;
7164
7165                                        case 5:
7166                                                {
7167                                                setState(887); tr();
7168                                                }
7169                                                break;
7170
7171                                        case 6:
7172                                                {
7173                                                setState(888); td();
7174                                                }
7175                                                break;
7176
7177                                        case 7:
7178                                                {
7179                                                setState(889); th();
7180                                                }
7181                                                break;
7182
7183                                        case 8:
7184                                                {
7185                                                setState(890); body();
7186                                                }
7187                                                break;
7188
7189                                        case 9:
7190                                                {
7191                                                setState(891); colgroup();
7192                                                }
7193                                                break;
7194
7195                                        case 10:
7196                                                {
7197                                                setState(892); dd();
7198                                                }
7199                                                break;
7200
7201                                        case 11:
7202                                                {
7203                                                setState(893); head();
7204                                                }
7205                                                break;
7206
7207                                        case 12:
7208                                                {
7209                                                setState(894); html();
7210                                                }
7211                                                break;
7212
7213                                        case 13:
7214                                                {
7215                                                setState(895); option();
7216                                                }
7217                                                break;
7218
7219                                        case 14:
7220                                                {
7221                                                setState(896); tbody();
7222                                                }
7223                                                break;
7224
7225                                        case 15:
7226                                                {
7227                                                setState(897); thead();
7228                                                }
7229                                                break;
7230
7231                                        case 16:
7232                                                {
7233                                                setState(898); tfoot();
7234                                                }
7235                                                break;
7236
7237                                        case 17:
7238                                                {
7239                                                setState(899); pTagOpen();
7240                                                }
7241                                                break;
7242
7243                                        case 18:
7244                                                {
7245                                                setState(900); liTagOpen();
7246                                                }
7247                                                break;
7248
7249                                        case 19:
7250                                                {
7251                                                setState(901); trTagOpen();
7252                                                }
7253                                                break;
7254
7255                                        case 20:
7256                                                {
7257                                                setState(902); tdTagOpen();
7258                                                }
7259                                                break;
7260
7261                                        case 21:
7262                                                {
7263                                                setState(903); thTagOpen();
7264                                                }
7265                                                break;
7266
7267                                        case 22:
7268                                                {
7269                                                setState(904); bodyTagOpen();
7270                                                }
7271                                                break;
7272
7273                                        case 23:
7274                                                {
7275                                                setState(905); colgroupTagOpen();
7276                                                }
7277                                                break;
7278
7279                                        case 24:
7280                                                {
7281                                                setState(906); ddTagOpen();
7282                                                }
7283                                                break;
7284
7285                                        case 25:
7286                                                {
7287                                                setState(907); headTagOpen();
7288                                                }
7289                                                break;
7290
7291                                        case 26:
7292                                                {
7293                                                setState(908); htmlTagOpen();
7294                                                }
7295                                                break;
7296
7297                                        case 27:
7298                                                {
7299                                                setState(909); optionTagOpen();
7300                                                }
7301                                                break;
7302
7303                                        case 28:
7304                                                {
7305                                                setState(910); tbodyTagOpen();
7306                                                }
7307                                                break;
7308
7309                                        case 29:
7310                                                {
7311                                                setState(911); theadTagOpen();
7312                                                }
7313                                                break;
7314
7315                                        case 30:
7316                                                {
7317                                                setState(912); tfootTagOpen();
7318                                                }
7319                                                break;
7320
7321                                        case 31:
7322                                                {
7323                                                {
7324                                                setState(913);
7325                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
7326                                                setState(914); match(LEADING_ASTERISK);
7327                                                }
7328                                                }
7329                                                break;
7330
7331                                        case 32:
7332                                                {
7333                                                setState(915); htmlComment();
7334                                                }
7335                                                break;
7336
7337                                        case 33:
7338                                                {
7339                                                setState(916); match(CDATA);
7340                                                }
7341                                                break;
7342
7343                                        case 34:
7344                                                {
7345                                                setState(917); match(NEWLINE);
7346                                                }
7347                                                break;
7348
7349                                        case 35:
7350                                                {
7351                                                setState(918); text();
7352                                                }
7353                                                break;
7354
7355                                        case 36:
7356                                                {
7357                                                setState(919); javadocInlineTag();
7358                                                }
7359                                                break;
7360                                        }
7361                                        } 
7362                                }
7363                                setState(924);
7364                                _errHandler.sync(this);
7365                                _alt = getInterpreter().adaptivePredict(_input,61,_ctx);
7366                        }
7367                        setState(925); dtTagClose();
7368                        }
7369                }
7370                catch (RecognitionException re) {
7371                        _localctx.exception = re;
7372                        _errHandler.reportError(this, re);
7373                        _errHandler.recover(this, re);
7374                }
7375                finally {
7376                        exitRule();
7377                }
7378                return _localctx;
7379        }
7380
7381        public static class HeadTagOpenContext extends ParserRuleContext {
7382                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7383                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7384                public TerminalNode NEWLINE(int i) {
7385                        return getToken(JavadocParser.NEWLINE, i);
7386                }
7387                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7388                public List<AttributeContext> attribute() {
7389                        return getRuleContexts(AttributeContext.class);
7390                }
7391                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7392                public AttributeContext attribute(int i) {
7393                        return getRuleContext(AttributeContext.class,i);
7394                }
7395                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7396                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7397                public TerminalNode LEADING_ASTERISK(int i) {
7398                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7399                }
7400                public TerminalNode WS(int i) {
7401                        return getToken(JavadocParser.WS, i);
7402                }
7403                public HeadTagOpenContext(ParserRuleContext parent, int invokingState) {
7404                        super(parent, invokingState);
7405                }
7406                @Override public int getRuleIndex() { return RULE_headTagOpen; }
7407                @Override
7408                public void enterRule(ParseTreeListener listener) {
7409                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagOpen(this);
7410                }
7411                @Override
7412                public void exitRule(ParseTreeListener listener) {
7413                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagOpen(this);
7414                }
7415                @Override
7416                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7417                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagOpen(this);
7418                        else return visitor.visitChildren(this);
7419                }
7420        }
7421
7422        public final HeadTagOpenContext headTagOpen() throws RecognitionException {
7423                HeadTagOpenContext _localctx = new HeadTagOpenContext(_ctx, getState());
7424                enterRule(_localctx, 66, RULE_headTagOpen);
7425                int _la;
7426                try {
7427                        enterOuterAlt(_localctx, 1);
7428                        {
7429                        setState(927); match(OPEN);
7430                        setState(928); match(HEAD_HTML_TAG_NAME);
7431                        setState(935);
7432                        _errHandler.sync(this);
7433                        _la = _input.LA(1);
7434                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
7435                                {
7436                                setState(933);
7437                                switch (_input.LA(1)) {
7438                                case HTML_TAG_NAME:
7439                                        {
7440                                        setState(929); attribute();
7441                                        }
7442                                        break;
7443                                case NEWLINE:
7444                                        {
7445                                        setState(930); match(NEWLINE);
7446                                        }
7447                                        break;
7448                                case LEADING_ASTERISK:
7449                                        {
7450                                        setState(931); match(LEADING_ASTERISK);
7451                                        }
7452                                        break;
7453                                case WS:
7454                                        {
7455                                        setState(932); match(WS);
7456                                        }
7457                                        break;
7458                                default:
7459                                        throw new NoViableAltException(this);
7460                                }
7461                                }
7462                                setState(937);
7463                                _errHandler.sync(this);
7464                                _la = _input.LA(1);
7465                        }
7466                        setState(938); match(CLOSE);
7467                        }
7468                }
7469                catch (RecognitionException re) {
7470                        _localctx.exception = re;
7471                        _errHandler.reportError(this, re);
7472                        _errHandler.recover(this, re);
7473                }
7474                finally {
7475                        exitRule();
7476                }
7477                return _localctx;
7478        }
7479
7480        public static class HeadTagCloseContext extends ParserRuleContext {
7481                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7482                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7483                public TerminalNode NEWLINE(int i) {
7484                        return getToken(JavadocParser.NEWLINE, i);
7485                }
7486                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7487                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7488                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7489                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7490                public TerminalNode LEADING_ASTERISK(int i) {
7491                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7492                }
7493                public TerminalNode WS(int i) {
7494                        return getToken(JavadocParser.WS, i);
7495                }
7496                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
7497                public HeadTagCloseContext(ParserRuleContext parent, int invokingState) {
7498                        super(parent, invokingState);
7499                }
7500                @Override public int getRuleIndex() { return RULE_headTagClose; }
7501                @Override
7502                public void enterRule(ParseTreeListener listener) {
7503                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagClose(this);
7504                }
7505                @Override
7506                public void exitRule(ParseTreeListener listener) {
7507                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagClose(this);
7508                }
7509                @Override
7510                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7511                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagClose(this);
7512                        else return visitor.visitChildren(this);
7513                }
7514        }
7515
7516        public final HeadTagCloseContext headTagClose() throws RecognitionException {
7517                HeadTagCloseContext _localctx = new HeadTagCloseContext(_ctx, getState());
7518                enterRule(_localctx, 68, RULE_headTagClose);
7519                int _la;
7520                try {
7521                        enterOuterAlt(_localctx, 1);
7522                        {
7523                        setState(940); match(OPEN);
7524                        setState(941); match(SLASH);
7525                        setState(942); match(HEAD_HTML_TAG_NAME);
7526                        setState(946);
7527                        _errHandler.sync(this);
7528                        _la = _input.LA(1);
7529                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
7530                                {
7531                                {
7532                                setState(943);
7533                                _la = _input.LA(1);
7534                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
7535                                _errHandler.recoverInline(this);
7536                                }
7537                                consume();
7538                                }
7539                                }
7540                                setState(948);
7541                                _errHandler.sync(this);
7542                                _la = _input.LA(1);
7543                        }
7544                        setState(949); match(CLOSE);
7545                        }
7546                }
7547                catch (RecognitionException re) {
7548                        _localctx.exception = re;
7549                        _errHandler.reportError(this, re);
7550                        _errHandler.recover(this, re);
7551                }
7552                finally {
7553                        exitRule();
7554                }
7555                return _localctx;
7556        }
7557
7558        public static class HeadContext extends ParserRuleContext {
7559                public List<ColgroupTagOpenContext> colgroupTagOpen() {
7560                        return getRuleContexts(ColgroupTagOpenContext.class);
7561                }
7562                public TbodyContext tbody(int i) {
7563                        return getRuleContext(TbodyContext.class,i);
7564                }
7565                public TerminalNode CDATA(int i) {
7566                        return getToken(JavadocParser.CDATA, i);
7567                }
7568                public TfootTagOpenContext tfootTagOpen(int i) {
7569                        return getRuleContext(TfootTagOpenContext.class,i);
7570                }
7571                public List<DtTagOpenContext> dtTagOpen() {
7572                        return getRuleContexts(DtTagOpenContext.class);
7573                }
7574                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7575                public List<ColgroupContext> colgroup() {
7576                        return getRuleContexts(ColgroupContext.class);
7577                }
7578                public List<TrContext> tr() {
7579                        return getRuleContexts(TrContext.class);
7580                }
7581                public List<LiContext> li() {
7582                        return getRuleContexts(LiContext.class);
7583                }
7584                public ThTagOpenContext thTagOpen(int i) {
7585                        return getRuleContext(ThTagOpenContext.class,i);
7586                }
7587                public List<DdTagOpenContext> ddTagOpen() {
7588                        return getRuleContexts(DdTagOpenContext.class);
7589                }
7590                public ColgroupContext colgroup(int i) {
7591                        return getRuleContext(ColgroupContext.class,i);
7592                }
7593                public TdTagOpenContext tdTagOpen(int i) {
7594                        return getRuleContext(TdTagOpenContext.class,i);
7595                }
7596                public List<ThTagOpenContext> thTagOpen() {
7597                        return getRuleContexts(ThTagOpenContext.class);
7598                }
7599                public HeadTagOpenContext headTagOpen() {
7600                        return getRuleContext(HeadTagOpenContext.class,0);
7601                }
7602                public List<HtmlTagOpenContext> htmlTagOpen() {
7603                        return getRuleContexts(HtmlTagOpenContext.class);
7604                }
7605                public List<TbodyTagOpenContext> tbodyTagOpen() {
7606                        return getRuleContexts(TbodyTagOpenContext.class);
7607                }
7608                public List<TheadContext> thead() {
7609                        return getRuleContexts(TheadContext.class);
7610                }
7611                public LiContext li(int i) {
7612                        return getRuleContext(LiContext.class,i);
7613                }
7614                public List<TfootTagOpenContext> tfootTagOpen() {
7615                        return getRuleContexts(TfootTagOpenContext.class);
7616                }
7617                public List<TfootContext> tfoot() {
7618                        return getRuleContexts(TfootContext.class);
7619                }
7620                public List<JavadocInlineTagContext> javadocInlineTag() {
7621                        return getRuleContexts(JavadocInlineTagContext.class);
7622                }
7623                public List<HtmlCommentContext> htmlComment() {
7624                        return getRuleContexts(HtmlCommentContext.class);
7625                }
7626                public OptionContext option(int i) {
7627                        return getRuleContext(OptionContext.class,i);
7628                }
7629                public TrContext tr(int i) {
7630                        return getRuleContext(TrContext.class,i);
7631                }
7632                public List<DtContext> dt() {
7633                        return getRuleContexts(DtContext.class);
7634                }
7635                public HtmlCommentContext htmlComment(int i) {
7636                        return getRuleContext(HtmlCommentContext.class,i);
7637                }
7638                public List<TdContext> td() {
7639                        return getRuleContexts(TdContext.class);
7640                }
7641                public List<BodyTagOpenContext> bodyTagOpen() {
7642                        return getRuleContexts(BodyTagOpenContext.class);
7643                }
7644                public DtTagOpenContext dtTagOpen(int i) {
7645                        return getRuleContext(DtTagOpenContext.class,i);
7646                }
7647                public HtmlContext html(int i) {
7648                        return getRuleContext(HtmlContext.class,i);
7649                }
7650                public BodyTagOpenContext bodyTagOpen(int i) {
7651                        return getRuleContext(BodyTagOpenContext.class,i);
7652                }
7653                public DdTagOpenContext ddTagOpen(int i) {
7654                        return getRuleContext(DdTagOpenContext.class,i);
7655                }
7656                public List<HtmlTagContext> htmlTag() {
7657                        return getRuleContexts(HtmlTagContext.class);
7658                }
7659                public ParagraphContext paragraph(int i) {
7660                        return getRuleContext(ParagraphContext.class,i);
7661                }
7662                public List<TdTagOpenContext> tdTagOpen() {
7663                        return getRuleContexts(TdTagOpenContext.class);
7664                }
7665                public OptionTagOpenContext optionTagOpen(int i) {
7666                        return getRuleContext(OptionTagOpenContext.class,i);
7667                }
7668                public LiTagOpenContext liTagOpen(int i) {
7669                        return getRuleContext(LiTagOpenContext.class,i);
7670                }
7671                public TdContext td(int i) {
7672                        return getRuleContext(TdContext.class,i);
7673                }
7674                public List<ParagraphContext> paragraph() {
7675                        return getRuleContexts(ParagraphContext.class);
7676                }
7677                public HtmlTagContext htmlTag(int i) {
7678                        return getRuleContext(HtmlTagContext.class,i);
7679                }
7680                public List<SingletonTagContext> singletonTag() {
7681                        return getRuleContexts(SingletonTagContext.class);
7682                }
7683                public TrTagOpenContext trTagOpen(int i) {
7684                        return getRuleContext(TrTagOpenContext.class,i);
7685                }
7686                public List<HtmlContext> html() {
7687                        return getRuleContexts(HtmlContext.class);
7688                }
7689                public JavadocInlineTagContext javadocInlineTag(int i) {
7690                        return getRuleContext(JavadocInlineTagContext.class,i);
7691                }
7692                public List<ThContext> th() {
7693                        return getRuleContexts(ThContext.class);
7694                }
7695                public DtContext dt(int i) {
7696                        return getRuleContext(DtContext.class,i);
7697                }
7698                public PTagOpenContext pTagOpen(int i) {
7699                        return getRuleContext(PTagOpenContext.class,i);
7700                }
7701                public TerminalNode LEADING_ASTERISK(int i) {
7702                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7703                }
7704                public HeadTagCloseContext headTagClose() {
7705                        return getRuleContext(HeadTagCloseContext.class,0);
7706                }
7707                public List<TrTagOpenContext> trTagOpen() {
7708                        return getRuleContexts(TrTagOpenContext.class);
7709                }
7710                public List<TbodyContext> tbody() {
7711                        return getRuleContexts(TbodyContext.class);
7712                }
7713                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
7714                public List<TheadTagOpenContext> theadTagOpen() {
7715                        return getRuleContexts(TheadTagOpenContext.class);
7716                }
7717                public TerminalNode NEWLINE(int i) {
7718                        return getToken(JavadocParser.NEWLINE, i);
7719                }
7720                public TextContext text(int i) {
7721                        return getRuleContext(TextContext.class,i);
7722                }
7723                public List<BodyContext> body() {
7724                        return getRuleContexts(BodyContext.class);
7725                }
7726                public List<OptionTagOpenContext> optionTagOpen() {
7727                        return getRuleContexts(OptionTagOpenContext.class);
7728                }
7729                public List<TextContext> text() {
7730                        return getRuleContexts(TextContext.class);
7731                }
7732                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7733                public TbodyTagOpenContext tbodyTagOpen(int i) {
7734                        return getRuleContext(TbodyTagOpenContext.class,i);
7735                }
7736                public List<DdContext> dd() {
7737                        return getRuleContexts(DdContext.class);
7738                }
7739                public TheadTagOpenContext theadTagOpen(int i) {
7740                        return getRuleContext(TheadTagOpenContext.class,i);
7741                }
7742                public ColgroupTagOpenContext colgroupTagOpen(int i) {
7743                        return getRuleContext(ColgroupTagOpenContext.class,i);
7744                }
7745                public List<LiTagOpenContext> liTagOpen() {
7746                        return getRuleContexts(LiTagOpenContext.class);
7747                }
7748                public DdContext dd(int i) {
7749                        return getRuleContext(DdContext.class,i);
7750                }
7751                public List<OptionContext> option() {
7752                        return getRuleContexts(OptionContext.class);
7753                }
7754                public TheadContext thead(int i) {
7755                        return getRuleContext(TheadContext.class,i);
7756                }
7757                public BodyContext body(int i) {
7758                        return getRuleContext(BodyContext.class,i);
7759                }
7760                public ThContext th(int i) {
7761                        return getRuleContext(ThContext.class,i);
7762                }
7763                public List<PTagOpenContext> pTagOpen() {
7764                        return getRuleContexts(PTagOpenContext.class);
7765                }
7766                public HtmlTagOpenContext htmlTagOpen(int i) {
7767                        return getRuleContext(HtmlTagOpenContext.class,i);
7768                }
7769                public SingletonTagContext singletonTag(int i) {
7770                        return getRuleContext(SingletonTagContext.class,i);
7771                }
7772                public TfootContext tfoot(int i) {
7773                        return getRuleContext(TfootContext.class,i);
7774                }
7775                public HeadContext(ParserRuleContext parent, int invokingState) {
7776                        super(parent, invokingState);
7777                }
7778                @Override public int getRuleIndex() { return RULE_head; }
7779                @Override
7780                public void enterRule(ParseTreeListener listener) {
7781                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHead(this);
7782                }
7783                @Override
7784                public void exitRule(ParseTreeListener listener) {
7785                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHead(this);
7786                }
7787                @Override
7788                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7789                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHead(this);
7790                        else return visitor.visitChildren(this);
7791                }
7792        }
7793
7794        public final HeadContext head() throws RecognitionException {
7795                HeadContext _localctx = new HeadContext(_ctx, getState());
7796                enterRule(_localctx, 70, RULE_head);
7797                try {
7798                        int _alt;
7799                        enterOuterAlt(_localctx, 1);
7800                        {
7801                        setState(951); headTagOpen();
7802                        setState(991);
7803                        _errHandler.sync(this);
7804                        _alt = getInterpreter().adaptivePredict(_input,66,_ctx);
7805                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
7806                                if ( _alt==1 ) {
7807                                        {
7808                                        setState(989);
7809                                        switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
7810                                        case 1:
7811                                                {
7812                                                setState(952); htmlTag();
7813                                                }
7814                                                break;
7815
7816                                        case 2:
7817                                                {
7818                                                setState(953); singletonTag();
7819                                                }
7820                                                break;
7821
7822                                        case 3:
7823                                                {
7824                                                setState(954); paragraph();
7825                                                }
7826                                                break;
7827
7828                                        case 4:
7829                                                {
7830                                                setState(955); li();
7831                                                }
7832                                                break;
7833
7834                                        case 5:
7835                                                {
7836                                                setState(956); tr();
7837                                                }
7838                                                break;
7839
7840                                        case 6:
7841                                                {
7842                                                setState(957); td();
7843                                                }
7844                                                break;
7845
7846                                        case 7:
7847                                                {
7848                                                setState(958); th();
7849                                                }
7850                                                break;
7851
7852                                        case 8:
7853                                                {
7854                                                setState(959); body();
7855                                                }
7856                                                break;
7857
7858                                        case 9:
7859                                                {
7860                                                setState(960); colgroup();
7861                                                }
7862                                                break;
7863
7864                                        case 10:
7865                                                {
7866                                                setState(961); dd();
7867                                                }
7868                                                break;
7869
7870                                        case 11:
7871                                                {
7872                                                setState(962); dt();
7873                                                }
7874                                                break;
7875
7876                                        case 12:
7877                                                {
7878                                                setState(963); html();
7879                                                }
7880                                                break;
7881
7882                                        case 13:
7883                                                {
7884                                                setState(964); option();
7885                                                }
7886                                                break;
7887
7888                                        case 14:
7889                                                {
7890                                                setState(965); tbody();
7891                                                }
7892                                                break;
7893
7894                                        case 15:
7895                                                {
7896                                                setState(966); thead();
7897                                                }
7898                                                break;
7899
7900                                        case 16:
7901                                                {
7902                                                setState(967); tfoot();
7903                                                }
7904                                                break;
7905
7906                                        case 17:
7907                                                {
7908                                                setState(968); pTagOpen();
7909                                                }
7910                                                break;
7911
7912                                        case 18:
7913                                                {
7914                                                setState(969); liTagOpen();
7915                                                }
7916                                                break;
7917
7918                                        case 19:
7919                                                {
7920                                                setState(970); trTagOpen();
7921                                                }
7922                                                break;
7923
7924                                        case 20:
7925                                                {
7926                                                setState(971); tdTagOpen();
7927                                                }
7928                                                break;
7929
7930                                        case 21:
7931                                                {
7932                                                setState(972); thTagOpen();
7933                                                }
7934                                                break;
7935
7936                                        case 22:
7937                                                {
7938                                                setState(973); bodyTagOpen();
7939                                                }
7940                                                break;
7941
7942                                        case 23:
7943                                                {
7944                                                setState(974); colgroupTagOpen();
7945                                                }
7946                                                break;
7947
7948                                        case 24:
7949                                                {
7950                                                setState(975); ddTagOpen();
7951                                                }
7952                                                break;
7953
7954                                        case 25:
7955                                                {
7956                                                setState(976); dtTagOpen();
7957                                                }
7958                                                break;
7959
7960                                        case 26:
7961                                                {
7962                                                setState(977); htmlTagOpen();
7963                                                }
7964                                                break;
7965
7966                                        case 27:
7967                                                {
7968                                                setState(978); optionTagOpen();
7969                                                }
7970                                                break;
7971
7972                                        case 28:
7973                                                {
7974                                                setState(979); tbodyTagOpen();
7975                                                }
7976                                                break;
7977
7978                                        case 29:
7979                                                {
7980                                                setState(980); theadTagOpen();
7981                                                }
7982                                                break;
7983
7984                                        case 30:
7985                                                {
7986                                                setState(981); tfootTagOpen();
7987                                                }
7988                                                break;
7989
7990                                        case 31:
7991                                                {
7992                                                {
7993                                                setState(982);
7994                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
7995                                                setState(983); match(LEADING_ASTERISK);
7996                                                }
7997                                                }
7998                                                break;
7999
8000                                        case 32:
8001                                                {
8002                                                setState(984); htmlComment();
8003                                                }
8004                                                break;
8005
8006                                        case 33:
8007                                                {
8008                                                setState(985); match(CDATA);
8009                                                }
8010                                                break;
8011
8012                                        case 34:
8013                                                {
8014                                                setState(986); match(NEWLINE);
8015                                                }
8016                                                break;
8017
8018                                        case 35:
8019                                                {
8020                                                setState(987); text();
8021                                                }
8022                                                break;
8023
8024                                        case 36:
8025                                                {
8026                                                setState(988); javadocInlineTag();
8027                                                }
8028                                                break;
8029                                        }
8030                                        } 
8031                                }
8032                                setState(993);
8033                                _errHandler.sync(this);
8034                                _alt = getInterpreter().adaptivePredict(_input,66,_ctx);
8035                        }
8036                        setState(994); headTagClose();
8037                        }
8038                }
8039                catch (RecognitionException re) {
8040                        _localctx.exception = re;
8041                        _errHandler.reportError(this, re);
8042                        _errHandler.recover(this, re);
8043                }
8044                finally {
8045                        exitRule();
8046                }
8047                return _localctx;
8048        }
8049
8050        public static class HtmlTagOpenContext extends ParserRuleContext {
8051                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8052                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
8053                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8054                public TerminalNode NEWLINE(int i) {
8055                        return getToken(JavadocParser.NEWLINE, i);
8056                }
8057                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8058                public List<AttributeContext> attribute() {
8059                        return getRuleContexts(AttributeContext.class);
8060                }
8061                public AttributeContext attribute(int i) {
8062                        return getRuleContext(AttributeContext.class,i);
8063                }
8064                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8065                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8066                public TerminalNode LEADING_ASTERISK(int i) {
8067                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8068                }
8069                public TerminalNode WS(int i) {
8070                        return getToken(JavadocParser.WS, i);
8071                }
8072                public HtmlTagOpenContext(ParserRuleContext parent, int invokingState) {
8073                        super(parent, invokingState);
8074                }
8075                @Override public int getRuleIndex() { return RULE_htmlTagOpen; }
8076                @Override
8077                public void enterRule(ParseTreeListener listener) {
8078                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagOpen(this);
8079                }
8080                @Override
8081                public void exitRule(ParseTreeListener listener) {
8082                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagOpen(this);
8083                }
8084                @Override
8085                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8086                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagOpen(this);
8087                        else return visitor.visitChildren(this);
8088                }
8089        }
8090
8091        public final HtmlTagOpenContext htmlTagOpen() throws RecognitionException {
8092                HtmlTagOpenContext _localctx = new HtmlTagOpenContext(_ctx, getState());
8093                enterRule(_localctx, 72, RULE_htmlTagOpen);
8094                int _la;
8095                try {
8096                        enterOuterAlt(_localctx, 1);
8097                        {
8098                        setState(996); match(OPEN);
8099                        setState(997); match(HTML_HTML_TAG_NAME);
8100                        setState(1004);
8101                        _errHandler.sync(this);
8102                        _la = _input.LA(1);
8103                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
8104                                {
8105                                setState(1002);
8106                                switch (_input.LA(1)) {
8107                                case HTML_TAG_NAME:
8108                                        {
8109                                        setState(998); attribute();
8110                                        }
8111                                        break;
8112                                case NEWLINE:
8113                                        {
8114                                        setState(999); match(NEWLINE);
8115                                        }
8116                                        break;
8117                                case LEADING_ASTERISK:
8118                                        {
8119                                        setState(1000); match(LEADING_ASTERISK);
8120                                        }
8121                                        break;
8122                                case WS:
8123                                        {
8124                                        setState(1001); match(WS);
8125                                        }
8126                                        break;
8127                                default:
8128                                        throw new NoViableAltException(this);
8129                                }
8130                                }
8131                                setState(1006);
8132                                _errHandler.sync(this);
8133                                _la = _input.LA(1);
8134                        }
8135                        setState(1007); match(CLOSE);
8136                        }
8137                }
8138                catch (RecognitionException re) {
8139                        _localctx.exception = re;
8140                        _errHandler.reportError(this, re);
8141                        _errHandler.recover(this, re);
8142                }
8143                finally {
8144                        exitRule();
8145                }
8146                return _localctx;
8147        }
8148
8149        public static class HtmlTagCloseContext extends ParserRuleContext {
8150                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8151                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
8152                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8153                public TerminalNode NEWLINE(int i) {
8154                        return getToken(JavadocParser.NEWLINE, i);
8155                }
8156                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8157                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8158                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8159                public TerminalNode LEADING_ASTERISK(int i) {
8160                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8161                }
8162                public TerminalNode WS(int i) {
8163                        return getToken(JavadocParser.WS, i);
8164                }
8165                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
8166                public HtmlTagCloseContext(ParserRuleContext parent, int invokingState) {
8167                        super(parent, invokingState);
8168                }
8169                @Override public int getRuleIndex() { return RULE_htmlTagClose; }
8170                @Override
8171                public void enterRule(ParseTreeListener listener) {
8172                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagClose(this);
8173                }
8174                @Override
8175                public void exitRule(ParseTreeListener listener) {
8176                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagClose(this);
8177                }
8178                @Override
8179                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8180                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagClose(this);
8181                        else return visitor.visitChildren(this);
8182                }
8183        }
8184
8185        public final HtmlTagCloseContext htmlTagClose() throws RecognitionException {
8186                HtmlTagCloseContext _localctx = new HtmlTagCloseContext(_ctx, getState());
8187                enterRule(_localctx, 74, RULE_htmlTagClose);
8188                int _la;
8189                try {
8190                        enterOuterAlt(_localctx, 1);
8191                        {
8192                        setState(1009); match(OPEN);
8193                        setState(1010); match(SLASH);
8194                        setState(1011); match(HTML_HTML_TAG_NAME);
8195                        setState(1015);
8196                        _errHandler.sync(this);
8197                        _la = _input.LA(1);
8198                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
8199                                {
8200                                {
8201                                setState(1012);
8202                                _la = _input.LA(1);
8203                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
8204                                _errHandler.recoverInline(this);
8205                                }
8206                                consume();
8207                                }
8208                                }
8209                                setState(1017);
8210                                _errHandler.sync(this);
8211                                _la = _input.LA(1);
8212                        }
8213                        setState(1018); match(CLOSE);
8214                        }
8215                }
8216                catch (RecognitionException re) {
8217                        _localctx.exception = re;
8218                        _errHandler.reportError(this, re);
8219                        _errHandler.recover(this, re);
8220                }
8221                finally {
8222                        exitRule();
8223                }
8224                return _localctx;
8225        }
8226
8227        public static class HtmlContext extends ParserRuleContext {
8228                public List<ColgroupTagOpenContext> colgroupTagOpen() {
8229                        return getRuleContexts(ColgroupTagOpenContext.class);
8230                }
8231                public TbodyContext tbody(int i) {
8232                        return getRuleContext(TbodyContext.class,i);
8233                }
8234                public HtmlTagCloseContext htmlTagClose() {
8235                        return getRuleContext(HtmlTagCloseContext.class,0);
8236                }
8237                public TerminalNode CDATA(int i) {
8238                        return getToken(JavadocParser.CDATA, i);
8239                }
8240                public TfootTagOpenContext tfootTagOpen(int i) {
8241                        return getRuleContext(TfootTagOpenContext.class,i);
8242                }
8243                public List<DtTagOpenContext> dtTagOpen() {
8244                        return getRuleContexts(DtTagOpenContext.class);
8245                }
8246                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8247                public List<ColgroupContext> colgroup() {
8248                        return getRuleContexts(ColgroupContext.class);
8249                }
8250                public HeadContext head(int i) {
8251                        return getRuleContext(HeadContext.class,i);
8252                }
8253                public List<TrContext> tr() {
8254                        return getRuleContexts(TrContext.class);
8255                }
8256                public List<LiContext> li() {
8257                        return getRuleContexts(LiContext.class);
8258                }
8259                public ThTagOpenContext thTagOpen(int i) {
8260                        return getRuleContext(ThTagOpenContext.class,i);
8261                }
8262                public List<DdTagOpenContext> ddTagOpen() {
8263                        return getRuleContexts(DdTagOpenContext.class);
8264                }
8265                public ColgroupContext colgroup(int i) {
8266                        return getRuleContext(ColgroupContext.class,i);
8267                }
8268                public TdTagOpenContext tdTagOpen(int i) {
8269                        return getRuleContext(TdTagOpenContext.class,i);
8270                }
8271                public List<ThTagOpenContext> thTagOpen() {
8272                        return getRuleContexts(ThTagOpenContext.class);
8273                }
8274                public List<HeadTagOpenContext> headTagOpen() {
8275                        return getRuleContexts(HeadTagOpenContext.class);
8276                }
8277                public HtmlTagOpenContext htmlTagOpen() {
8278                        return getRuleContext(HtmlTagOpenContext.class,0);
8279                }
8280                public List<TbodyTagOpenContext> tbodyTagOpen() {
8281                        return getRuleContexts(TbodyTagOpenContext.class);
8282                }
8283                public List<TheadContext> thead() {
8284                        return getRuleContexts(TheadContext.class);
8285                }
8286                public LiContext li(int i) {
8287                        return getRuleContext(LiContext.class,i);
8288                }
8289                public List<TfootTagOpenContext> tfootTagOpen() {
8290                        return getRuleContexts(TfootTagOpenContext.class);
8291                }
8292                public List<TfootContext> tfoot() {
8293                        return getRuleContexts(TfootContext.class);
8294                }
8295                public List<JavadocInlineTagContext> javadocInlineTag() {
8296                        return getRuleContexts(JavadocInlineTagContext.class);
8297                }
8298                public List<HtmlCommentContext> htmlComment() {
8299                        return getRuleContexts(HtmlCommentContext.class);
8300                }
8301                public OptionContext option(int i) {
8302                        return getRuleContext(OptionContext.class,i);
8303                }
8304                public TrContext tr(int i) {
8305                        return getRuleContext(TrContext.class,i);
8306                }
8307                public List<DtContext> dt() {
8308                        return getRuleContexts(DtContext.class);
8309                }
8310                public HtmlCommentContext htmlComment(int i) {
8311                        return getRuleContext(HtmlCommentContext.class,i);
8312                }
8313                public List<TdContext> td() {
8314                        return getRuleContexts(TdContext.class);
8315                }
8316                public List<BodyTagOpenContext> bodyTagOpen() {
8317                        return getRuleContexts(BodyTagOpenContext.class);
8318                }
8319                public DtTagOpenContext dtTagOpen(int i) {
8320                        return getRuleContext(DtTagOpenContext.class,i);
8321                }
8322                public BodyTagOpenContext bodyTagOpen(int i) {
8323                        return getRuleContext(BodyTagOpenContext.class,i);
8324                }
8325                public DdTagOpenContext ddTagOpen(int i) {
8326                        return getRuleContext(DdTagOpenContext.class,i);
8327                }
8328                public List<HtmlTagContext> htmlTag() {
8329                        return getRuleContexts(HtmlTagContext.class);
8330                }
8331                public ParagraphContext paragraph(int i) {
8332                        return getRuleContext(ParagraphContext.class,i);
8333                }
8334                public List<TdTagOpenContext> tdTagOpen() {
8335                        return getRuleContexts(TdTagOpenContext.class);
8336                }
8337                public OptionTagOpenContext optionTagOpen(int i) {
8338                        return getRuleContext(OptionTagOpenContext.class,i);
8339                }
8340                public LiTagOpenContext liTagOpen(int i) {
8341                        return getRuleContext(LiTagOpenContext.class,i);
8342                }
8343                public TdContext td(int i) {
8344                        return getRuleContext(TdContext.class,i);
8345                }
8346                public List<ParagraphContext> paragraph() {
8347                        return getRuleContexts(ParagraphContext.class);
8348                }
8349                public HtmlTagContext htmlTag(int i) {
8350                        return getRuleContext(HtmlTagContext.class,i);
8351                }
8352                public List<SingletonTagContext> singletonTag() {
8353                        return getRuleContexts(SingletonTagContext.class);
8354                }
8355                public HeadTagOpenContext headTagOpen(int i) {
8356                        return getRuleContext(HeadTagOpenContext.class,i);
8357                }
8358                public TrTagOpenContext trTagOpen(int i) {
8359                        return getRuleContext(TrTagOpenContext.class,i);
8360                }
8361                public JavadocInlineTagContext javadocInlineTag(int i) {
8362                        return getRuleContext(JavadocInlineTagContext.class,i);
8363                }
8364                public List<ThContext> th() {
8365                        return getRuleContexts(ThContext.class);
8366                }
8367                public DtContext dt(int i) {
8368                        return getRuleContext(DtContext.class,i);
8369                }
8370                public PTagOpenContext pTagOpen(int i) {
8371                        return getRuleContext(PTagOpenContext.class,i);
8372                }
8373                public TerminalNode LEADING_ASTERISK(int i) {
8374                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8375                }
8376                public List<TrTagOpenContext> trTagOpen() {
8377                        return getRuleContexts(TrTagOpenContext.class);
8378                }
8379                public List<TbodyContext> tbody() {
8380                        return getRuleContexts(TbodyContext.class);
8381                }
8382                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
8383                public List<TheadTagOpenContext> theadTagOpen() {
8384                        return getRuleContexts(TheadTagOpenContext.class);
8385                }
8386                public List<HeadContext> head() {
8387                        return getRuleContexts(HeadContext.class);
8388                }
8389                public TerminalNode NEWLINE(int i) {
8390                        return getToken(JavadocParser.NEWLINE, i);
8391                }
8392                public TextContext text(int i) {
8393                        return getRuleContext(TextContext.class,i);
8394                }
8395                public List<BodyContext> body() {
8396                        return getRuleContexts(BodyContext.class);
8397                }
8398                public List<OptionTagOpenContext> optionTagOpen() {
8399                        return getRuleContexts(OptionTagOpenContext.class);
8400                }
8401                public List<TextContext> text() {
8402                        return getRuleContexts(TextContext.class);
8403                }
8404                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8405                public TbodyTagOpenContext tbodyTagOpen(int i) {
8406                        return getRuleContext(TbodyTagOpenContext.class,i);
8407                }
8408                public List<DdContext> dd() {
8409                        return getRuleContexts(DdContext.class);
8410                }
8411                public TheadTagOpenContext theadTagOpen(int i) {
8412                        return getRuleContext(TheadTagOpenContext.class,i);
8413                }
8414                public ColgroupTagOpenContext colgroupTagOpen(int i) {
8415                        return getRuleContext(ColgroupTagOpenContext.class,i);
8416                }
8417                public List<LiTagOpenContext> liTagOpen() {
8418                        return getRuleContexts(LiTagOpenContext.class);
8419                }
8420                public DdContext dd(int i) {
8421                        return getRuleContext(DdContext.class,i);
8422                }
8423                public List<OptionContext> option() {
8424                        return getRuleContexts(OptionContext.class);
8425                }
8426                public TheadContext thead(int i) {
8427                        return getRuleContext(TheadContext.class,i);
8428                }
8429                public BodyContext body(int i) {
8430                        return getRuleContext(BodyContext.class,i);
8431                }
8432                public ThContext th(int i) {
8433                        return getRuleContext(ThContext.class,i);
8434                }
8435                public List<PTagOpenContext> pTagOpen() {
8436                        return getRuleContexts(PTagOpenContext.class);
8437                }
8438                public SingletonTagContext singletonTag(int i) {
8439                        return getRuleContext(SingletonTagContext.class,i);
8440                }
8441                public TfootContext tfoot(int i) {
8442                        return getRuleContext(TfootContext.class,i);
8443                }
8444                public HtmlContext(ParserRuleContext parent, int invokingState) {
8445                        super(parent, invokingState);
8446                }
8447                @Override public int getRuleIndex() { return RULE_html; }
8448                @Override
8449                public void enterRule(ParseTreeListener listener) {
8450                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtml(this);
8451                }
8452                @Override
8453                public void exitRule(ParseTreeListener listener) {
8454                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtml(this);
8455                }
8456                @Override
8457                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8458                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtml(this);
8459                        else return visitor.visitChildren(this);
8460                }
8461        }
8462
8463        public final HtmlContext html() throws RecognitionException {
8464                HtmlContext _localctx = new HtmlContext(_ctx, getState());
8465                enterRule(_localctx, 76, RULE_html);
8466                try {
8467                        int _alt;
8468                        enterOuterAlt(_localctx, 1);
8469                        {
8470                        setState(1020); htmlTagOpen();
8471                        setState(1060);
8472                        _errHandler.sync(this);
8473                        _alt = getInterpreter().adaptivePredict(_input,71,_ctx);
8474                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8475                                if ( _alt==1 ) {
8476                                        {
8477                                        setState(1058);
8478                                        switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
8479                                        case 1:
8480                                                {
8481                                                setState(1021); htmlTag();
8482                                                }
8483                                                break;
8484
8485                                        case 2:
8486                                                {
8487                                                setState(1022); singletonTag();
8488                                                }
8489                                                break;
8490
8491                                        case 3:
8492                                                {
8493                                                setState(1023); paragraph();
8494                                                }
8495                                                break;
8496
8497                                        case 4:
8498                                                {
8499                                                setState(1024); li();
8500                                                }
8501                                                break;
8502
8503                                        case 5:
8504                                                {
8505                                                setState(1025); tr();
8506                                                }
8507                                                break;
8508
8509                                        case 6:
8510                                                {
8511                                                setState(1026); td();
8512                                                }
8513                                                break;
8514
8515                                        case 7:
8516                                                {
8517                                                setState(1027); th();
8518                                                }
8519                                                break;
8520
8521                                        case 8:
8522                                                {
8523                                                setState(1028); body();
8524                                                }
8525                                                break;
8526
8527                                        case 9:
8528                                                {
8529                                                setState(1029); colgroup();
8530                                                }
8531                                                break;
8532
8533                                        case 10:
8534                                                {
8535                                                setState(1030); dd();
8536                                                }
8537                                                break;
8538
8539                                        case 11:
8540                                                {
8541                                                setState(1031); dt();
8542                                                }
8543                                                break;
8544
8545                                        case 12:
8546                                                {
8547                                                setState(1032); head();
8548                                                }
8549                                                break;
8550
8551                                        case 13:
8552                                                {
8553                                                setState(1033); option();
8554                                                }
8555                                                break;
8556
8557                                        case 14:
8558                                                {
8559                                                setState(1034); tbody();
8560                                                }
8561                                                break;
8562
8563                                        case 15:
8564                                                {
8565                                                setState(1035); thead();
8566                                                }
8567                                                break;
8568
8569                                        case 16:
8570                                                {
8571                                                setState(1036); tfoot();
8572                                                }
8573                                                break;
8574
8575                                        case 17:
8576                                                {
8577                                                setState(1037); pTagOpen();
8578                                                }
8579                                                break;
8580
8581                                        case 18:
8582                                                {
8583                                                setState(1038); liTagOpen();
8584                                                }
8585                                                break;
8586
8587                                        case 19:
8588                                                {
8589                                                setState(1039); trTagOpen();
8590                                                }
8591                                                break;
8592
8593                                        case 20:
8594                                                {
8595                                                setState(1040); tdTagOpen();
8596                                                }
8597                                                break;
8598
8599                                        case 21:
8600                                                {
8601                                                setState(1041); thTagOpen();
8602                                                }
8603                                                break;
8604
8605                                        case 22:
8606                                                {
8607                                                setState(1042); bodyTagOpen();
8608                                                }
8609                                                break;
8610
8611                                        case 23:
8612                                                {
8613                                                setState(1043); colgroupTagOpen();
8614                                                }
8615                                                break;
8616
8617                                        case 24:
8618                                                {
8619                                                setState(1044); ddTagOpen();
8620                                                }
8621                                                break;
8622
8623                                        case 25:
8624                                                {
8625                                                setState(1045); dtTagOpen();
8626                                                }
8627                                                break;
8628
8629                                        case 26:
8630                                                {
8631                                                setState(1046); headTagOpen();
8632                                                }
8633                                                break;
8634
8635                                        case 27:
8636                                                {
8637                                                setState(1047); optionTagOpen();
8638                                                }
8639                                                break;
8640
8641                                        case 28:
8642                                                {
8643                                                setState(1048); tbodyTagOpen();
8644                                                }
8645                                                break;
8646
8647                                        case 29:
8648                                                {
8649                                                setState(1049); theadTagOpen();
8650                                                }
8651                                                break;
8652
8653                                        case 30:
8654                                                {
8655                                                setState(1050); tfootTagOpen();
8656                                                }
8657                                                break;
8658
8659                                        case 31:
8660                                                {
8661                                                {
8662                                                setState(1051);
8663                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
8664                                                setState(1052); match(LEADING_ASTERISK);
8665                                                }
8666                                                }
8667                                                break;
8668
8669                                        case 32:
8670                                                {
8671                                                setState(1053); htmlComment();
8672                                                }
8673                                                break;
8674
8675                                        case 33:
8676                                                {
8677                                                setState(1054); match(CDATA);
8678                                                }
8679                                                break;
8680
8681                                        case 34:
8682                                                {
8683                                                setState(1055); match(NEWLINE);
8684                                                }
8685                                                break;
8686
8687                                        case 35:
8688                                                {
8689                                                setState(1056); text();
8690                                                }
8691                                                break;
8692
8693                                        case 36:
8694                                                {
8695                                                setState(1057); javadocInlineTag();
8696                                                }
8697                                                break;
8698                                        }
8699                                        } 
8700                                }
8701                                setState(1062);
8702                                _errHandler.sync(this);
8703                                _alt = getInterpreter().adaptivePredict(_input,71,_ctx);
8704                        }
8705                        setState(1063); htmlTagClose();
8706                        }
8707                }
8708                catch (RecognitionException re) {
8709                        _localctx.exception = re;
8710                        _errHandler.reportError(this, re);
8711                        _errHandler.recover(this, re);
8712                }
8713                finally {
8714                        exitRule();
8715                }
8716                return _localctx;
8717        }
8718
8719        public static class OptionTagOpenContext extends ParserRuleContext {
8720                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8721                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
8722                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8723                public TerminalNode NEWLINE(int i) {
8724                        return getToken(JavadocParser.NEWLINE, i);
8725                }
8726                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8727                public List<AttributeContext> attribute() {
8728                        return getRuleContexts(AttributeContext.class);
8729                }
8730                public AttributeContext attribute(int i) {
8731                        return getRuleContext(AttributeContext.class,i);
8732                }
8733                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8734                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8735                public TerminalNode LEADING_ASTERISK(int i) {
8736                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8737                }
8738                public TerminalNode WS(int i) {
8739                        return getToken(JavadocParser.WS, i);
8740                }
8741                public OptionTagOpenContext(ParserRuleContext parent, int invokingState) {
8742                        super(parent, invokingState);
8743                }
8744                @Override public int getRuleIndex() { return RULE_optionTagOpen; }
8745                @Override
8746                public void enterRule(ParseTreeListener listener) {
8747                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagOpen(this);
8748                }
8749                @Override
8750                public void exitRule(ParseTreeListener listener) {
8751                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagOpen(this);
8752                }
8753                @Override
8754                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8755                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagOpen(this);
8756                        else return visitor.visitChildren(this);
8757                }
8758        }
8759
8760        public final OptionTagOpenContext optionTagOpen() throws RecognitionException {
8761                OptionTagOpenContext _localctx = new OptionTagOpenContext(_ctx, getState());
8762                enterRule(_localctx, 78, RULE_optionTagOpen);
8763                int _la;
8764                try {
8765                        enterOuterAlt(_localctx, 1);
8766                        {
8767                        setState(1065); match(OPEN);
8768                        setState(1066); match(OPTION_HTML_TAG_NAME);
8769                        setState(1073);
8770                        _errHandler.sync(this);
8771                        _la = _input.LA(1);
8772                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
8773                                {
8774                                setState(1071);
8775                                switch (_input.LA(1)) {
8776                                case HTML_TAG_NAME:
8777                                        {
8778                                        setState(1067); attribute();
8779                                        }
8780                                        break;
8781                                case NEWLINE:
8782                                        {
8783                                        setState(1068); match(NEWLINE);
8784                                        }
8785                                        break;
8786                                case LEADING_ASTERISK:
8787                                        {
8788                                        setState(1069); match(LEADING_ASTERISK);
8789                                        }
8790                                        break;
8791                                case WS:
8792                                        {
8793                                        setState(1070); match(WS);
8794                                        }
8795                                        break;
8796                                default:
8797                                        throw new NoViableAltException(this);
8798                                }
8799                                }
8800                                setState(1075);
8801                                _errHandler.sync(this);
8802                                _la = _input.LA(1);
8803                        }
8804                        setState(1076); match(CLOSE);
8805                        }
8806                }
8807                catch (RecognitionException re) {
8808                        _localctx.exception = re;
8809                        _errHandler.reportError(this, re);
8810                        _errHandler.recover(this, re);
8811                }
8812                finally {
8813                        exitRule();
8814                }
8815                return _localctx;
8816        }
8817
8818        public static class OptionTagCloseContext extends ParserRuleContext {
8819                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8820                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
8821                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8822                public TerminalNode NEWLINE(int i) {
8823                        return getToken(JavadocParser.NEWLINE, i);
8824                }
8825                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8826                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8827                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8828                public TerminalNode LEADING_ASTERISK(int i) {
8829                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8830                }
8831                public TerminalNode WS(int i) {
8832                        return getToken(JavadocParser.WS, i);
8833                }
8834                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
8835                public OptionTagCloseContext(ParserRuleContext parent, int invokingState) {
8836                        super(parent, invokingState);
8837                }
8838                @Override public int getRuleIndex() { return RULE_optionTagClose; }
8839                @Override
8840                public void enterRule(ParseTreeListener listener) {
8841                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagClose(this);
8842                }
8843                @Override
8844                public void exitRule(ParseTreeListener listener) {
8845                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagClose(this);
8846                }
8847                @Override
8848                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8849                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagClose(this);
8850                        else return visitor.visitChildren(this);
8851                }
8852        }
8853
8854        public final OptionTagCloseContext optionTagClose() throws RecognitionException {
8855                OptionTagCloseContext _localctx = new OptionTagCloseContext(_ctx, getState());
8856                enterRule(_localctx, 80, RULE_optionTagClose);
8857                int _la;
8858                try {
8859                        enterOuterAlt(_localctx, 1);
8860                        {
8861                        setState(1078); match(OPEN);
8862                        setState(1079); match(SLASH);
8863                        setState(1080); match(OPTION_HTML_TAG_NAME);
8864                        setState(1084);
8865                        _errHandler.sync(this);
8866                        _la = _input.LA(1);
8867                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
8868                                {
8869                                {
8870                                setState(1081);
8871                                _la = _input.LA(1);
8872                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
8873                                _errHandler.recoverInline(this);
8874                                }
8875                                consume();
8876                                }
8877                                }
8878                                setState(1086);
8879                                _errHandler.sync(this);
8880                                _la = _input.LA(1);
8881                        }
8882                        setState(1087); match(CLOSE);
8883                        }
8884                }
8885                catch (RecognitionException re) {
8886                        _localctx.exception = re;
8887                        _errHandler.reportError(this, re);
8888                        _errHandler.recover(this, re);
8889                }
8890                finally {
8891                        exitRule();
8892                }
8893                return _localctx;
8894        }
8895
8896        public static class OptionContext extends ParserRuleContext {
8897                public List<ColgroupTagOpenContext> colgroupTagOpen() {
8898                        return getRuleContexts(ColgroupTagOpenContext.class);
8899                }
8900                public TbodyContext tbody(int i) {
8901                        return getRuleContext(TbodyContext.class,i);
8902                }
8903                public TerminalNode CDATA(int i) {
8904                        return getToken(JavadocParser.CDATA, i);
8905                }
8906                public TfootTagOpenContext tfootTagOpen(int i) {
8907                        return getRuleContext(TfootTagOpenContext.class,i);
8908                }
8909                public List<DtTagOpenContext> dtTagOpen() {
8910                        return getRuleContexts(DtTagOpenContext.class);
8911                }
8912                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8913                public List<ColgroupContext> colgroup() {
8914                        return getRuleContexts(ColgroupContext.class);
8915                }
8916                public HeadContext head(int i) {
8917                        return getRuleContext(HeadContext.class,i);
8918                }
8919                public List<TrContext> tr() {
8920                        return getRuleContexts(TrContext.class);
8921                }
8922                public List<LiContext> li() {
8923                        return getRuleContexts(LiContext.class);
8924                }
8925                public ThTagOpenContext thTagOpen(int i) {
8926                        return getRuleContext(ThTagOpenContext.class,i);
8927                }
8928                public List<DdTagOpenContext> ddTagOpen() {
8929                        return getRuleContexts(DdTagOpenContext.class);
8930                }
8931                public ColgroupContext colgroup(int i) {
8932                        return getRuleContext(ColgroupContext.class,i);
8933                }
8934                public TdTagOpenContext tdTagOpen(int i) {
8935                        return getRuleContext(TdTagOpenContext.class,i);
8936                }
8937                public List<ThTagOpenContext> thTagOpen() {
8938                        return getRuleContexts(ThTagOpenContext.class);
8939                }
8940                public List<HeadTagOpenContext> headTagOpen() {
8941                        return getRuleContexts(HeadTagOpenContext.class);
8942                }
8943                public List<HtmlTagOpenContext> htmlTagOpen() {
8944                        return getRuleContexts(HtmlTagOpenContext.class);
8945                }
8946                public List<TbodyTagOpenContext> tbodyTagOpen() {
8947                        return getRuleContexts(TbodyTagOpenContext.class);
8948                }
8949                public List<TheadContext> thead() {
8950                        return getRuleContexts(TheadContext.class);
8951                }
8952                public LiContext li(int i) {
8953                        return getRuleContext(LiContext.class,i);
8954                }
8955                public List<TfootTagOpenContext> tfootTagOpen() {
8956                        return getRuleContexts(TfootTagOpenContext.class);
8957                }
8958                public List<TfootContext> tfoot() {
8959                        return getRuleContexts(TfootContext.class);
8960                }
8961                public List<JavadocInlineTagContext> javadocInlineTag() {
8962                        return getRuleContexts(JavadocInlineTagContext.class);
8963                }
8964                public List<HtmlCommentContext> htmlComment() {
8965                        return getRuleContexts(HtmlCommentContext.class);
8966                }
8967                public TrContext tr(int i) {
8968                        return getRuleContext(TrContext.class,i);
8969                }
8970                public List<DtContext> dt() {
8971                        return getRuleContexts(DtContext.class);
8972                }
8973                public HtmlCommentContext htmlComment(int i) {
8974                        return getRuleContext(HtmlCommentContext.class,i);
8975                }
8976                public List<TdContext> td() {
8977                        return getRuleContexts(TdContext.class);
8978                }
8979                public List<BodyTagOpenContext> bodyTagOpen() {
8980                        return getRuleContexts(BodyTagOpenContext.class);
8981                }
8982                public DtTagOpenContext dtTagOpen(int i) {
8983                        return getRuleContext(DtTagOpenContext.class,i);
8984                }
8985                public HtmlContext html(int i) {
8986                        return getRuleContext(HtmlContext.class,i);
8987                }
8988                public BodyTagOpenContext bodyTagOpen(int i) {
8989                        return getRuleContext(BodyTagOpenContext.class,i);
8990                }
8991                public DdTagOpenContext ddTagOpen(int i) {
8992                        return getRuleContext(DdTagOpenContext.class,i);
8993                }
8994                public OptionTagCloseContext optionTagClose() {
8995                        return getRuleContext(OptionTagCloseContext.class,0);
8996                }
8997                public List<HtmlTagContext> htmlTag() {
8998                        return getRuleContexts(HtmlTagContext.class);
8999                }
9000                public ParagraphContext paragraph(int i) {
9001                        return getRuleContext(ParagraphContext.class,i);
9002                }
9003                public List<TdTagOpenContext> tdTagOpen() {
9004                        return getRuleContexts(TdTagOpenContext.class);
9005                }
9006                public LiTagOpenContext liTagOpen(int i) {
9007                        return getRuleContext(LiTagOpenContext.class,i);
9008                }
9009                public TdContext td(int i) {
9010                        return getRuleContext(TdContext.class,i);
9011                }
9012                public List<ParagraphContext> paragraph() {
9013                        return getRuleContexts(ParagraphContext.class);
9014                }
9015                public HtmlTagContext htmlTag(int i) {
9016                        return getRuleContext(HtmlTagContext.class,i);
9017                }
9018                public List<SingletonTagContext> singletonTag() {
9019                        return getRuleContexts(SingletonTagContext.class);
9020                }
9021                public HeadTagOpenContext headTagOpen(int i) {
9022                        return getRuleContext(HeadTagOpenContext.class,i);
9023                }
9024                public TrTagOpenContext trTagOpen(int i) {
9025                        return getRuleContext(TrTagOpenContext.class,i);
9026                }
9027                public List<HtmlContext> html() {
9028                        return getRuleContexts(HtmlContext.class);
9029                }
9030                public JavadocInlineTagContext javadocInlineTag(int i) {
9031                        return getRuleContext(JavadocInlineTagContext.class,i);
9032                }
9033                public List<ThContext> th() {
9034                        return getRuleContexts(ThContext.class);
9035                }
9036                public DtContext dt(int i) {
9037                        return getRuleContext(DtContext.class,i);
9038                }
9039                public PTagOpenContext pTagOpen(int i) {
9040                        return getRuleContext(PTagOpenContext.class,i);
9041                }
9042                public TerminalNode LEADING_ASTERISK(int i) {
9043                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9044                }
9045                public List<TrTagOpenContext> trTagOpen() {
9046                        return getRuleContexts(TrTagOpenContext.class);
9047                }
9048                public List<TbodyContext> tbody() {
9049                        return getRuleContexts(TbodyContext.class);
9050                }
9051                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
9052                public List<TheadTagOpenContext> theadTagOpen() {
9053                        return getRuleContexts(TheadTagOpenContext.class);
9054                }
9055                public List<HeadContext> head() {
9056                        return getRuleContexts(HeadContext.class);
9057                }
9058                public TerminalNode NEWLINE(int i) {
9059                        return getToken(JavadocParser.NEWLINE, i);
9060                }
9061                public TextContext text(int i) {
9062                        return getRuleContext(TextContext.class,i);
9063                }
9064                public List<BodyContext> body() {
9065                        return getRuleContexts(BodyContext.class);
9066                }
9067                public OptionTagOpenContext optionTagOpen() {
9068                        return getRuleContext(OptionTagOpenContext.class,0);
9069                }
9070                public List<TextContext> text() {
9071                        return getRuleContexts(TextContext.class);
9072                }
9073                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9074                public TbodyTagOpenContext tbodyTagOpen(int i) {
9075                        return getRuleContext(TbodyTagOpenContext.class,i);
9076                }
9077                public List<DdContext> dd() {
9078                        return getRuleContexts(DdContext.class);
9079                }
9080                public TheadTagOpenContext theadTagOpen(int i) {
9081                        return getRuleContext(TheadTagOpenContext.class,i);
9082                }
9083                public ColgroupTagOpenContext colgroupTagOpen(int i) {
9084                        return getRuleContext(ColgroupTagOpenContext.class,i);
9085                }
9086                public List<LiTagOpenContext> liTagOpen() {
9087                        return getRuleContexts(LiTagOpenContext.class);
9088                }
9089                public DdContext dd(int i) {
9090                        return getRuleContext(DdContext.class,i);
9091                }
9092                public TheadContext thead(int i) {
9093                        return getRuleContext(TheadContext.class,i);
9094                }
9095                public BodyContext body(int i) {
9096                        return getRuleContext(BodyContext.class,i);
9097                }
9098                public ThContext th(int i) {
9099                        return getRuleContext(ThContext.class,i);
9100                }
9101                public List<PTagOpenContext> pTagOpen() {
9102                        return getRuleContexts(PTagOpenContext.class);
9103                }
9104                public HtmlTagOpenContext htmlTagOpen(int i) {
9105                        return getRuleContext(HtmlTagOpenContext.class,i);
9106                }
9107                public SingletonTagContext singletonTag(int i) {
9108                        return getRuleContext(SingletonTagContext.class,i);
9109                }
9110                public TfootContext tfoot(int i) {
9111                        return getRuleContext(TfootContext.class,i);
9112                }
9113                public OptionContext(ParserRuleContext parent, int invokingState) {
9114                        super(parent, invokingState);
9115                }
9116                @Override public int getRuleIndex() { return RULE_option; }
9117                @Override
9118                public void enterRule(ParseTreeListener listener) {
9119                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOption(this);
9120                }
9121                @Override
9122                public void exitRule(ParseTreeListener listener) {
9123                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOption(this);
9124                }
9125                @Override
9126                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9127                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOption(this);
9128                        else return visitor.visitChildren(this);
9129                }
9130        }
9131
9132        public final OptionContext option() throws RecognitionException {
9133                OptionContext _localctx = new OptionContext(_ctx, getState());
9134                enterRule(_localctx, 82, RULE_option);
9135                try {
9136                        int _alt;
9137                        enterOuterAlt(_localctx, 1);
9138                        {
9139                        setState(1089); optionTagOpen();
9140                        setState(1129);
9141                        _errHandler.sync(this);
9142                        _alt = getInterpreter().adaptivePredict(_input,76,_ctx);
9143                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
9144                                if ( _alt==1 ) {
9145                                        {
9146                                        setState(1127);
9147                                        switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
9148                                        case 1:
9149                                                {
9150                                                setState(1090); htmlTag();
9151                                                }
9152                                                break;
9153
9154                                        case 2:
9155                                                {
9156                                                setState(1091); singletonTag();
9157                                                }
9158                                                break;
9159
9160                                        case 3:
9161                                                {
9162                                                setState(1092); paragraph();
9163                                                }
9164                                                break;
9165
9166                                        case 4:
9167                                                {
9168                                                setState(1093); li();
9169                                                }
9170                                                break;
9171
9172                                        case 5:
9173                                                {
9174                                                setState(1094); tr();
9175                                                }
9176                                                break;
9177
9178                                        case 6:
9179                                                {
9180                                                setState(1095); td();
9181                                                }
9182                                                break;
9183
9184                                        case 7:
9185                                                {
9186                                                setState(1096); th();
9187                                                }
9188                                                break;
9189
9190                                        case 8:
9191                                                {
9192                                                setState(1097); body();
9193                                                }
9194                                                break;
9195
9196                                        case 9:
9197                                                {
9198                                                setState(1098); colgroup();
9199                                                }
9200                                                break;
9201
9202                                        case 10:
9203                                                {
9204                                                setState(1099); dd();
9205                                                }
9206                                                break;
9207
9208                                        case 11:
9209                                                {
9210                                                setState(1100); dt();
9211                                                }
9212                                                break;
9213
9214                                        case 12:
9215                                                {
9216                                                setState(1101); head();
9217                                                }
9218                                                break;
9219
9220                                        case 13:
9221                                                {
9222                                                setState(1102); html();
9223                                                }
9224                                                break;
9225
9226                                        case 14:
9227                                                {
9228                                                setState(1103); tbody();
9229                                                }
9230                                                break;
9231
9232                                        case 15:
9233                                                {
9234                                                setState(1104); thead();
9235                                                }
9236                                                break;
9237
9238                                        case 16:
9239                                                {
9240                                                setState(1105); tfoot();
9241                                                }
9242                                                break;
9243
9244                                        case 17:
9245                                                {
9246                                                setState(1106); pTagOpen();
9247                                                }
9248                                                break;
9249
9250                                        case 18:
9251                                                {
9252                                                setState(1107); liTagOpen();
9253                                                }
9254                                                break;
9255
9256                                        case 19:
9257                                                {
9258                                                setState(1108); trTagOpen();
9259                                                }
9260                                                break;
9261
9262                                        case 20:
9263                                                {
9264                                                setState(1109); tdTagOpen();
9265                                                }
9266                                                break;
9267
9268                                        case 21:
9269                                                {
9270                                                setState(1110); thTagOpen();
9271                                                }
9272                                                break;
9273
9274                                        case 22:
9275                                                {
9276                                                setState(1111); bodyTagOpen();
9277                                                }
9278                                                break;
9279
9280                                        case 23:
9281                                                {
9282                                                setState(1112); colgroupTagOpen();
9283                                                }
9284                                                break;
9285
9286                                        case 24:
9287                                                {
9288                                                setState(1113); ddTagOpen();
9289                                                }
9290                                                break;
9291
9292                                        case 25:
9293                                                {
9294                                                setState(1114); dtTagOpen();
9295                                                }
9296                                                break;
9297
9298                                        case 26:
9299                                                {
9300                                                setState(1115); headTagOpen();
9301                                                }
9302                                                break;
9303
9304                                        case 27:
9305                                                {
9306                                                setState(1116); htmlTagOpen();
9307                                                }
9308                                                break;
9309
9310                                        case 28:
9311                                                {
9312                                                setState(1117); tbodyTagOpen();
9313                                                }
9314                                                break;
9315
9316                                        case 29:
9317                                                {
9318                                                setState(1118); theadTagOpen();
9319                                                }
9320                                                break;
9321
9322                                        case 30:
9323                                                {
9324                                                setState(1119); tfootTagOpen();
9325                                                }
9326                                                break;
9327
9328                                        case 31:
9329                                                {
9330                                                {
9331                                                setState(1120);
9332                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
9333                                                setState(1121); match(LEADING_ASTERISK);
9334                                                }
9335                                                }
9336                                                break;
9337
9338                                        case 32:
9339                                                {
9340                                                setState(1122); htmlComment();
9341                                                }
9342                                                break;
9343
9344                                        case 33:
9345                                                {
9346                                                setState(1123); match(CDATA);
9347                                                }
9348                                                break;
9349
9350                                        case 34:
9351                                                {
9352                                                setState(1124); match(NEWLINE);
9353                                                }
9354                                                break;
9355
9356                                        case 35:
9357                                                {
9358                                                setState(1125); text();
9359                                                }
9360                                                break;
9361
9362                                        case 36:
9363                                                {
9364                                                setState(1126); javadocInlineTag();
9365                                                }
9366                                                break;
9367                                        }
9368                                        } 
9369                                }
9370                                setState(1131);
9371                                _errHandler.sync(this);
9372                                _alt = getInterpreter().adaptivePredict(_input,76,_ctx);
9373                        }
9374                        setState(1132); optionTagClose();
9375                        }
9376                }
9377                catch (RecognitionException re) {
9378                        _localctx.exception = re;
9379                        _errHandler.reportError(this, re);
9380                        _errHandler.recover(this, re);
9381                }
9382                finally {
9383                        exitRule();
9384                }
9385                return _localctx;
9386        }
9387
9388        public static class TbodyTagOpenContext extends ParserRuleContext {
9389                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9390                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9391                public TerminalNode NEWLINE(int i) {
9392                        return getToken(JavadocParser.NEWLINE, i);
9393                }
9394                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9395                public List<AttributeContext> attribute() {
9396                        return getRuleContexts(AttributeContext.class);
9397                }
9398                public AttributeContext attribute(int i) {
9399                        return getRuleContext(AttributeContext.class,i);
9400                }
9401                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9402                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
9403                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9404                public TerminalNode LEADING_ASTERISK(int i) {
9405                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9406                }
9407                public TerminalNode WS(int i) {
9408                        return getToken(JavadocParser.WS, i);
9409                }
9410                public TbodyTagOpenContext(ParserRuleContext parent, int invokingState) {
9411                        super(parent, invokingState);
9412                }
9413                @Override public int getRuleIndex() { return RULE_tbodyTagOpen; }
9414                @Override
9415                public void enterRule(ParseTreeListener listener) {
9416                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagOpen(this);
9417                }
9418                @Override
9419                public void exitRule(ParseTreeListener listener) {
9420                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagOpen(this);
9421                }
9422                @Override
9423                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9424                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagOpen(this);
9425                        else return visitor.visitChildren(this);
9426                }
9427        }
9428
9429        public final TbodyTagOpenContext tbodyTagOpen() throws RecognitionException {
9430                TbodyTagOpenContext _localctx = new TbodyTagOpenContext(_ctx, getState());
9431                enterRule(_localctx, 84, RULE_tbodyTagOpen);
9432                int _la;
9433                try {
9434                        enterOuterAlt(_localctx, 1);
9435                        {
9436                        setState(1134); match(OPEN);
9437                        setState(1135); match(TBODY_HTML_TAG_NAME);
9438                        setState(1142);
9439                        _errHandler.sync(this);
9440                        _la = _input.LA(1);
9441                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
9442                                {
9443                                setState(1140);
9444                                switch (_input.LA(1)) {
9445                                case HTML_TAG_NAME:
9446                                        {
9447                                        setState(1136); attribute();
9448                                        }
9449                                        break;
9450                                case NEWLINE:
9451                                        {
9452                                        setState(1137); match(NEWLINE);
9453                                        }
9454                                        break;
9455                                case LEADING_ASTERISK:
9456                                        {
9457                                        setState(1138); match(LEADING_ASTERISK);
9458                                        }
9459                                        break;
9460                                case WS:
9461                                        {
9462                                        setState(1139); match(WS);
9463                                        }
9464                                        break;
9465                                default:
9466                                        throw new NoViableAltException(this);
9467                                }
9468                                }
9469                                setState(1144);
9470                                _errHandler.sync(this);
9471                                _la = _input.LA(1);
9472                        }
9473                        setState(1145); match(CLOSE);
9474                        }
9475                }
9476                catch (RecognitionException re) {
9477                        _localctx.exception = re;
9478                        _errHandler.reportError(this, re);
9479                        _errHandler.recover(this, re);
9480                }
9481                finally {
9482                        exitRule();
9483                }
9484                return _localctx;
9485        }
9486
9487        public static class TbodyTagCloseContext extends ParserRuleContext {
9488                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9489                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9490                public TerminalNode NEWLINE(int i) {
9491                        return getToken(JavadocParser.NEWLINE, i);
9492                }
9493                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9494                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9495                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
9496                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9497                public TerminalNode LEADING_ASTERISK(int i) {
9498                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9499                }
9500                public TerminalNode WS(int i) {
9501                        return getToken(JavadocParser.WS, i);
9502                }
9503                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
9504                public TbodyTagCloseContext(ParserRuleContext parent, int invokingState) {
9505                        super(parent, invokingState);
9506                }
9507                @Override public int getRuleIndex() { return RULE_tbodyTagClose; }
9508                @Override
9509                public void enterRule(ParseTreeListener listener) {
9510                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagClose(this);
9511                }
9512                @Override
9513                public void exitRule(ParseTreeListener listener) {
9514                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagClose(this);
9515                }
9516                @Override
9517                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9518                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagClose(this);
9519                        else return visitor.visitChildren(this);
9520                }
9521        }
9522
9523        public final TbodyTagCloseContext tbodyTagClose() throws RecognitionException {
9524                TbodyTagCloseContext _localctx = new TbodyTagCloseContext(_ctx, getState());
9525                enterRule(_localctx, 86, RULE_tbodyTagClose);
9526                int _la;
9527                try {
9528                        enterOuterAlt(_localctx, 1);
9529                        {
9530                        setState(1147); match(OPEN);
9531                        setState(1148); match(SLASH);
9532                        setState(1149); match(TBODY_HTML_TAG_NAME);
9533                        setState(1153);
9534                        _errHandler.sync(this);
9535                        _la = _input.LA(1);
9536                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
9537                                {
9538                                {
9539                                setState(1150);
9540                                _la = _input.LA(1);
9541                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
9542                                _errHandler.recoverInline(this);
9543                                }
9544                                consume();
9545                                }
9546                                }
9547                                setState(1155);
9548                                _errHandler.sync(this);
9549                                _la = _input.LA(1);
9550                        }
9551                        setState(1156); match(CLOSE);
9552                        }
9553                }
9554                catch (RecognitionException re) {
9555                        _localctx.exception = re;
9556                        _errHandler.reportError(this, re);
9557                        _errHandler.recover(this, re);
9558                }
9559                finally {
9560                        exitRule();
9561                }
9562                return _localctx;
9563        }
9564
9565        public static class TbodyContext extends ParserRuleContext {
9566                public List<ColgroupTagOpenContext> colgroupTagOpen() {
9567                        return getRuleContexts(ColgroupTagOpenContext.class);
9568                }
9569                public TbodyTagCloseContext tbodyTagClose() {
9570                        return getRuleContext(TbodyTagCloseContext.class,0);
9571                }
9572                public TerminalNode CDATA(int i) {
9573                        return getToken(JavadocParser.CDATA, i);
9574                }
9575                public TfootTagOpenContext tfootTagOpen(int i) {
9576                        return getRuleContext(TfootTagOpenContext.class,i);
9577                }
9578                public List<DtTagOpenContext> dtTagOpen() {
9579                        return getRuleContexts(DtTagOpenContext.class);
9580                }
9581                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9582                public List<ColgroupContext> colgroup() {
9583                        return getRuleContexts(ColgroupContext.class);
9584                }
9585                public HeadContext head(int i) {
9586                        return getRuleContext(HeadContext.class,i);
9587                }
9588                public List<TrContext> tr() {
9589                        return getRuleContexts(TrContext.class);
9590                }
9591                public List<LiContext> li() {
9592                        return getRuleContexts(LiContext.class);
9593                }
9594                public ThTagOpenContext thTagOpen(int i) {
9595                        return getRuleContext(ThTagOpenContext.class,i);
9596                }
9597                public List<DdTagOpenContext> ddTagOpen() {
9598                        return getRuleContexts(DdTagOpenContext.class);
9599                }
9600                public ColgroupContext colgroup(int i) {
9601                        return getRuleContext(ColgroupContext.class,i);
9602                }
9603                public TdTagOpenContext tdTagOpen(int i) {
9604                        return getRuleContext(TdTagOpenContext.class,i);
9605                }
9606                public List<ThTagOpenContext> thTagOpen() {
9607                        return getRuleContexts(ThTagOpenContext.class);
9608                }
9609                public List<HeadTagOpenContext> headTagOpen() {
9610                        return getRuleContexts(HeadTagOpenContext.class);
9611                }
9612                public List<HtmlTagOpenContext> htmlTagOpen() {
9613                        return getRuleContexts(HtmlTagOpenContext.class);
9614                }
9615                public TbodyTagOpenContext tbodyTagOpen() {
9616                        return getRuleContext(TbodyTagOpenContext.class,0);
9617                }
9618                public List<TheadContext> thead() {
9619                        return getRuleContexts(TheadContext.class);
9620                }
9621                public LiContext li(int i) {
9622                        return getRuleContext(LiContext.class,i);
9623                }
9624                public List<TfootTagOpenContext> tfootTagOpen() {
9625                        return getRuleContexts(TfootTagOpenContext.class);
9626                }
9627                public List<TfootContext> tfoot() {
9628                        return getRuleContexts(TfootContext.class);
9629                }
9630                public List<JavadocInlineTagContext> javadocInlineTag() {
9631                        return getRuleContexts(JavadocInlineTagContext.class);
9632                }
9633                public List<HtmlCommentContext> htmlComment() {
9634                        return getRuleContexts(HtmlCommentContext.class);
9635                }
9636                public OptionContext option(int i) {
9637                        return getRuleContext(OptionContext.class,i);
9638                }
9639                public TrContext tr(int i) {
9640                        return getRuleContext(TrContext.class,i);
9641                }
9642                public List<DtContext> dt() {
9643                        return getRuleContexts(DtContext.class);
9644                }
9645                public HtmlCommentContext htmlComment(int i) {
9646                        return getRuleContext(HtmlCommentContext.class,i);
9647                }
9648                public List<TdContext> td() {
9649                        return getRuleContexts(TdContext.class);
9650                }
9651                public List<BodyTagOpenContext> bodyTagOpen() {
9652                        return getRuleContexts(BodyTagOpenContext.class);
9653                }
9654                public DtTagOpenContext dtTagOpen(int i) {
9655                        return getRuleContext(DtTagOpenContext.class,i);
9656                }
9657                public HtmlContext html(int i) {
9658                        return getRuleContext(HtmlContext.class,i);
9659                }
9660                public BodyTagOpenContext bodyTagOpen(int i) {
9661                        return getRuleContext(BodyTagOpenContext.class,i);
9662                }
9663                public DdTagOpenContext ddTagOpen(int i) {
9664                        return getRuleContext(DdTagOpenContext.class,i);
9665                }
9666                public List<HtmlTagContext> htmlTag() {
9667                        return getRuleContexts(HtmlTagContext.class);
9668                }
9669                public ParagraphContext paragraph(int i) {
9670                        return getRuleContext(ParagraphContext.class,i);
9671                }
9672                public List<TdTagOpenContext> tdTagOpen() {
9673                        return getRuleContexts(TdTagOpenContext.class);
9674                }
9675                public OptionTagOpenContext optionTagOpen(int i) {
9676                        return getRuleContext(OptionTagOpenContext.class,i);
9677                }
9678                public LiTagOpenContext liTagOpen(int i) {
9679                        return getRuleContext(LiTagOpenContext.class,i);
9680                }
9681                public TdContext td(int i) {
9682                        return getRuleContext(TdContext.class,i);
9683                }
9684                public List<ParagraphContext> paragraph() {
9685                        return getRuleContexts(ParagraphContext.class);
9686                }
9687                public HtmlTagContext htmlTag(int i) {
9688                        return getRuleContext(HtmlTagContext.class,i);
9689                }
9690                public List<SingletonTagContext> singletonTag() {
9691                        return getRuleContexts(SingletonTagContext.class);
9692                }
9693                public HeadTagOpenContext headTagOpen(int i) {
9694                        return getRuleContext(HeadTagOpenContext.class,i);
9695                }
9696                public TrTagOpenContext trTagOpen(int i) {
9697                        return getRuleContext(TrTagOpenContext.class,i);
9698                }
9699                public List<HtmlContext> html() {
9700                        return getRuleContexts(HtmlContext.class);
9701                }
9702                public JavadocInlineTagContext javadocInlineTag(int i) {
9703                        return getRuleContext(JavadocInlineTagContext.class,i);
9704                }
9705                public List<ThContext> th() {
9706                        return getRuleContexts(ThContext.class);
9707                }
9708                public DtContext dt(int i) {
9709                        return getRuleContext(DtContext.class,i);
9710                }
9711                public PTagOpenContext pTagOpen(int i) {
9712                        return getRuleContext(PTagOpenContext.class,i);
9713                }
9714                public TerminalNode LEADING_ASTERISK(int i) {
9715                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9716                }
9717                public List<TrTagOpenContext> trTagOpen() {
9718                        return getRuleContexts(TrTagOpenContext.class);
9719                }
9720                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
9721                public List<TheadTagOpenContext> theadTagOpen() {
9722                        return getRuleContexts(TheadTagOpenContext.class);
9723                }
9724                public List<HeadContext> head() {
9725                        return getRuleContexts(HeadContext.class);
9726                }
9727                public TerminalNode NEWLINE(int i) {
9728                        return getToken(JavadocParser.NEWLINE, i);
9729                }
9730                public TextContext text(int i) {
9731                        return getRuleContext(TextContext.class,i);
9732                }
9733                public List<BodyContext> body() {
9734                        return getRuleContexts(BodyContext.class);
9735                }
9736                public List<OptionTagOpenContext> optionTagOpen() {
9737                        return getRuleContexts(OptionTagOpenContext.class);
9738                }
9739                public List<TextContext> text() {
9740                        return getRuleContexts(TextContext.class);
9741                }
9742                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9743                public List<DdContext> dd() {
9744                        return getRuleContexts(DdContext.class);
9745                }
9746                public TheadTagOpenContext theadTagOpen(int i) {
9747                        return getRuleContext(TheadTagOpenContext.class,i);
9748                }
9749                public ColgroupTagOpenContext colgroupTagOpen(int i) {
9750                        return getRuleContext(ColgroupTagOpenContext.class,i);
9751                }
9752                public List<LiTagOpenContext> liTagOpen() {
9753                        return getRuleContexts(LiTagOpenContext.class);
9754                }
9755                public DdContext dd(int i) {
9756                        return getRuleContext(DdContext.class,i);
9757                }
9758                public List<OptionContext> option() {
9759                        return getRuleContexts(OptionContext.class);
9760                }
9761                public TheadContext thead(int i) {
9762                        return getRuleContext(TheadContext.class,i);
9763                }
9764                public BodyContext body(int i) {
9765                        return getRuleContext(BodyContext.class,i);
9766                }
9767                public ThContext th(int i) {
9768                        return getRuleContext(ThContext.class,i);
9769                }
9770                public List<PTagOpenContext> pTagOpen() {
9771                        return getRuleContexts(PTagOpenContext.class);
9772                }
9773                public HtmlTagOpenContext htmlTagOpen(int i) {
9774                        return getRuleContext(HtmlTagOpenContext.class,i);
9775                }
9776                public SingletonTagContext singletonTag(int i) {
9777                        return getRuleContext(SingletonTagContext.class,i);
9778                }
9779                public TfootContext tfoot(int i) {
9780                        return getRuleContext(TfootContext.class,i);
9781                }
9782                public TbodyContext(ParserRuleContext parent, int invokingState) {
9783                        super(parent, invokingState);
9784                }
9785                @Override public int getRuleIndex() { return RULE_tbody; }
9786                @Override
9787                public void enterRule(ParseTreeListener listener) {
9788                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbody(this);
9789                }
9790                @Override
9791                public void exitRule(ParseTreeListener listener) {
9792                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbody(this);
9793                }
9794                @Override
9795                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9796                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbody(this);
9797                        else return visitor.visitChildren(this);
9798                }
9799        }
9800
9801        public final TbodyContext tbody() throws RecognitionException {
9802                TbodyContext _localctx = new TbodyContext(_ctx, getState());
9803                enterRule(_localctx, 88, RULE_tbody);
9804                try {
9805                        int _alt;
9806                        enterOuterAlt(_localctx, 1);
9807                        {
9808                        setState(1158); tbodyTagOpen();
9809                        setState(1198);
9810                        _errHandler.sync(this);
9811                        _alt = getInterpreter().adaptivePredict(_input,81,_ctx);
9812                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
9813                                if ( _alt==1 ) {
9814                                        {
9815                                        setState(1196);
9816                                        switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
9817                                        case 1:
9818                                                {
9819                                                setState(1159); htmlTag();
9820                                                }
9821                                                break;
9822
9823                                        case 2:
9824                                                {
9825                                                setState(1160); singletonTag();
9826                                                }
9827                                                break;
9828
9829                                        case 3:
9830                                                {
9831                                                setState(1161); paragraph();
9832                                                }
9833                                                break;
9834
9835                                        case 4:
9836                                                {
9837                                                setState(1162); li();
9838                                                }
9839                                                break;
9840
9841                                        case 5:
9842                                                {
9843                                                setState(1163); tr();
9844                                                }
9845                                                break;
9846
9847                                        case 6:
9848                                                {
9849                                                setState(1164); td();
9850                                                }
9851                                                break;
9852
9853                                        case 7:
9854                                                {
9855                                                setState(1165); th();
9856                                                }
9857                                                break;
9858
9859                                        case 8:
9860                                                {
9861                                                setState(1166); body();
9862                                                }
9863                                                break;
9864
9865                                        case 9:
9866                                                {
9867                                                setState(1167); colgroup();
9868                                                }
9869                                                break;
9870
9871                                        case 10:
9872                                                {
9873                                                setState(1168); dd();
9874                                                }
9875                                                break;
9876
9877                                        case 11:
9878                                                {
9879                                                setState(1169); dt();
9880                                                }
9881                                                break;
9882
9883                                        case 12:
9884                                                {
9885                                                setState(1170); head();
9886                                                }
9887                                                break;
9888
9889                                        case 13:
9890                                                {
9891                                                setState(1171); html();
9892                                                }
9893                                                break;
9894
9895                                        case 14:
9896                                                {
9897                                                setState(1172); option();
9898                                                }
9899                                                break;
9900
9901                                        case 15:
9902                                                {
9903                                                setState(1173); thead();
9904                                                }
9905                                                break;
9906
9907                                        case 16:
9908                                                {
9909                                                setState(1174); tfoot();
9910                                                }
9911                                                break;
9912
9913                                        case 17:
9914                                                {
9915                                                setState(1175); pTagOpen();
9916                                                }
9917                                                break;
9918
9919                                        case 18:
9920                                                {
9921                                                setState(1176); liTagOpen();
9922                                                }
9923                                                break;
9924
9925                                        case 19:
9926                                                {
9927                                                setState(1177); trTagOpen();
9928                                                }
9929                                                break;
9930
9931                                        case 20:
9932                                                {
9933                                                setState(1178); tdTagOpen();
9934                                                }
9935                                                break;
9936
9937                                        case 21:
9938                                                {
9939                                                setState(1179); thTagOpen();
9940                                                }
9941                                                break;
9942
9943                                        case 22:
9944                                                {
9945                                                setState(1180); bodyTagOpen();
9946                                                }
9947                                                break;
9948
9949                                        case 23:
9950                                                {
9951                                                setState(1181); colgroupTagOpen();
9952                                                }
9953                                                break;
9954
9955                                        case 24:
9956                                                {
9957                                                setState(1182); ddTagOpen();
9958                                                }
9959                                                break;
9960
9961                                        case 25:
9962                                                {
9963                                                setState(1183); dtTagOpen();
9964                                                }
9965                                                break;
9966
9967                                        case 26:
9968                                                {
9969                                                setState(1184); headTagOpen();
9970                                                }
9971                                                break;
9972
9973                                        case 27:
9974                                                {
9975                                                setState(1185); htmlTagOpen();
9976                                                }
9977                                                break;
9978
9979                                        case 28:
9980                                                {
9981                                                setState(1186); optionTagOpen();
9982                                                }
9983                                                break;
9984
9985                                        case 29:
9986                                                {
9987                                                setState(1187); theadTagOpen();
9988                                                }
9989                                                break;
9990
9991                                        case 30:
9992                                                {
9993                                                setState(1188); tfootTagOpen();
9994                                                }
9995                                                break;
9996
9997                                        case 31:
9998                                                {
9999                                                {
10000                                                setState(1189);
10001                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
10002                                                setState(1190); match(LEADING_ASTERISK);
10003                                                }
10004                                                }
10005                                                break;
10006
10007                                        case 32:
10008                                                {
10009                                                setState(1191); htmlComment();
10010                                                }
10011                                                break;
10012
10013                                        case 33:
10014                                                {
10015                                                setState(1192); match(CDATA);
10016                                                }
10017                                                break;
10018
10019                                        case 34:
10020                                                {
10021                                                setState(1193); match(NEWLINE);
10022                                                }
10023                                                break;
10024
10025                                        case 35:
10026                                                {
10027                                                setState(1194); text();
10028                                                }
10029                                                break;
10030
10031                                        case 36:
10032                                                {
10033                                                setState(1195); javadocInlineTag();
10034                                                }
10035                                                break;
10036                                        }
10037                                        } 
10038                                }
10039                                setState(1200);
10040                                _errHandler.sync(this);
10041                                _alt = getInterpreter().adaptivePredict(_input,81,_ctx);
10042                        }
10043                        setState(1201); tbodyTagClose();
10044                        }
10045                }
10046                catch (RecognitionException re) {
10047                        _localctx.exception = re;
10048                        _errHandler.reportError(this, re);
10049                        _errHandler.recover(this, re);
10050                }
10051                finally {
10052                        exitRule();
10053                }
10054                return _localctx;
10055        }
10056
10057        public static class TfootTagOpenContext extends ParserRuleContext {
10058                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10059                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
10060                public TerminalNode NEWLINE(int i) {
10061                        return getToken(JavadocParser.NEWLINE, i);
10062                }
10063                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10064                public List<AttributeContext> attribute() {
10065                        return getRuleContexts(AttributeContext.class);
10066                }
10067                public AttributeContext attribute(int i) {
10068                        return getRuleContext(AttributeContext.class,i);
10069                }
10070                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
10071                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
10072                public TerminalNode LEADING_ASTERISK(int i) {
10073                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10074                }
10075                public TerminalNode WS(int i) {
10076                        return getToken(JavadocParser.WS, i);
10077                }
10078                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
10079                public TfootTagOpenContext(ParserRuleContext parent, int invokingState) {
10080                        super(parent, invokingState);
10081                }
10082                @Override public int getRuleIndex() { return RULE_tfootTagOpen; }
10083                @Override
10084                public void enterRule(ParseTreeListener listener) {
10085                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagOpen(this);
10086                }
10087                @Override
10088                public void exitRule(ParseTreeListener listener) {
10089                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagOpen(this);
10090                }
10091                @Override
10092                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10093                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagOpen(this);
10094                        else return visitor.visitChildren(this);
10095                }
10096        }
10097
10098        public final TfootTagOpenContext tfootTagOpen() throws RecognitionException {
10099                TfootTagOpenContext _localctx = new TfootTagOpenContext(_ctx, getState());
10100                enterRule(_localctx, 90, RULE_tfootTagOpen);
10101                int _la;
10102                try {
10103                        enterOuterAlt(_localctx, 1);
10104                        {
10105                        setState(1203); match(OPEN);
10106                        setState(1204); match(TFOOT_HTML_TAG_NAME);
10107                        setState(1211);
10108                        _errHandler.sync(this);
10109                        _la = _input.LA(1);
10110                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
10111                                {
10112                                setState(1209);
10113                                switch (_input.LA(1)) {
10114                                case HTML_TAG_NAME:
10115                                        {
10116                                        setState(1205); attribute();
10117                                        }
10118                                        break;
10119                                case NEWLINE:
10120                                        {
10121                                        setState(1206); match(NEWLINE);
10122                                        }
10123                                        break;
10124                                case LEADING_ASTERISK:
10125                                        {
10126                                        setState(1207); match(LEADING_ASTERISK);
10127                                        }
10128                                        break;
10129                                case WS:
10130                                        {
10131                                        setState(1208); match(WS);
10132                                        }
10133                                        break;
10134                                default:
10135                                        throw new NoViableAltException(this);
10136                                }
10137                                }
10138                                setState(1213);
10139                                _errHandler.sync(this);
10140                                _la = _input.LA(1);
10141                        }
10142                        setState(1214); match(CLOSE);
10143                        }
10144                }
10145                catch (RecognitionException re) {
10146                        _localctx.exception = re;
10147                        _errHandler.reportError(this, re);
10148                        _errHandler.recover(this, re);
10149                }
10150                finally {
10151                        exitRule();
10152                }
10153                return _localctx;
10154        }
10155
10156        public static class TfootTagCloseContext extends ParserRuleContext {
10157                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10158                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
10159                public TerminalNode NEWLINE(int i) {
10160                        return getToken(JavadocParser.NEWLINE, i);
10161                }
10162                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10163                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
10164                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
10165                public TerminalNode LEADING_ASTERISK(int i) {
10166                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10167                }
10168                public TerminalNode WS(int i) {
10169                        return getToken(JavadocParser.WS, i);
10170                }
10171                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
10172                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
10173                public TfootTagCloseContext(ParserRuleContext parent, int invokingState) {
10174                        super(parent, invokingState);
10175                }
10176                @Override public int getRuleIndex() { return RULE_tfootTagClose; }
10177                @Override
10178                public void enterRule(ParseTreeListener listener) {
10179                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagClose(this);
10180                }
10181                @Override
10182                public void exitRule(ParseTreeListener listener) {
10183                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagClose(this);
10184                }
10185                @Override
10186                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10187                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagClose(this);
10188                        else return visitor.visitChildren(this);
10189                }
10190        }
10191
10192        public final TfootTagCloseContext tfootTagClose() throws RecognitionException {
10193                TfootTagCloseContext _localctx = new TfootTagCloseContext(_ctx, getState());
10194                enterRule(_localctx, 92, RULE_tfootTagClose);
10195                int _la;
10196                try {
10197                        enterOuterAlt(_localctx, 1);
10198                        {
10199                        setState(1216); match(OPEN);
10200                        setState(1217); match(SLASH);
10201                        setState(1218); match(TFOOT_HTML_TAG_NAME);
10202                        setState(1222);
10203                        _errHandler.sync(this);
10204                        _la = _input.LA(1);
10205                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
10206                                {
10207                                {
10208                                setState(1219);
10209                                _la = _input.LA(1);
10210                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
10211                                _errHandler.recoverInline(this);
10212                                }
10213                                consume();
10214                                }
10215                                }
10216                                setState(1224);
10217                                _errHandler.sync(this);
10218                                _la = _input.LA(1);
10219                        }
10220                        setState(1225); match(CLOSE);
10221                        }
10222                }
10223                catch (RecognitionException re) {
10224                        _localctx.exception = re;
10225                        _errHandler.reportError(this, re);
10226                        _errHandler.recover(this, re);
10227                }
10228                finally {
10229                        exitRule();
10230                }
10231                return _localctx;
10232        }
10233
10234        public static class TfootContext extends ParserRuleContext {
10235                public List<ColgroupTagOpenContext> colgroupTagOpen() {
10236                        return getRuleContexts(ColgroupTagOpenContext.class);
10237                }
10238                public TbodyContext tbody(int i) {
10239                        return getRuleContext(TbodyContext.class,i);
10240                }
10241                public TerminalNode CDATA(int i) {
10242                        return getToken(JavadocParser.CDATA, i);
10243                }
10244                public List<DtTagOpenContext> dtTagOpen() {
10245                        return getRuleContexts(DtTagOpenContext.class);
10246                }
10247                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10248                public List<ColgroupContext> colgroup() {
10249                        return getRuleContexts(ColgroupContext.class);
10250                }
10251                public HeadContext head(int i) {
10252                        return getRuleContext(HeadContext.class,i);
10253                }
10254                public List<TrContext> tr() {
10255                        return getRuleContexts(TrContext.class);
10256                }
10257                public List<LiContext> li() {
10258                        return getRuleContexts(LiContext.class);
10259                }
10260                public ThTagOpenContext thTagOpen(int i) {
10261                        return getRuleContext(ThTagOpenContext.class,i);
10262                }
10263                public List<DdTagOpenContext> ddTagOpen() {
10264                        return getRuleContexts(DdTagOpenContext.class);
10265                }
10266                public ColgroupContext colgroup(int i) {
10267                        return getRuleContext(ColgroupContext.class,i);
10268                }
10269                public TdTagOpenContext tdTagOpen(int i) {
10270                        return getRuleContext(TdTagOpenContext.class,i);
10271                }
10272                public List<ThTagOpenContext> thTagOpen() {
10273                        return getRuleContexts(ThTagOpenContext.class);
10274                }
10275                public List<HeadTagOpenContext> headTagOpen() {
10276                        return getRuleContexts(HeadTagOpenContext.class);
10277                }
10278                public List<HtmlTagOpenContext> htmlTagOpen() {
10279                        return getRuleContexts(HtmlTagOpenContext.class);
10280                }
10281                public List<TbodyTagOpenContext> tbodyTagOpen() {
10282                        return getRuleContexts(TbodyTagOpenContext.class);
10283                }
10284                public List<TheadContext> thead() {
10285                        return getRuleContexts(TheadContext.class);
10286                }
10287                public LiContext li(int i) {
10288                        return getRuleContext(LiContext.class,i);
10289                }
10290                public TfootTagOpenContext tfootTagOpen() {
10291                        return getRuleContext(TfootTagOpenContext.class,0);
10292                }
10293                public List<JavadocInlineTagContext> javadocInlineTag() {
10294                        return getRuleContexts(JavadocInlineTagContext.class);
10295                }
10296                public List<HtmlCommentContext> htmlComment() {
10297                        return getRuleContexts(HtmlCommentContext.class);
10298                }
10299                public OptionContext option(int i) {
10300                        return getRuleContext(OptionContext.class,i);
10301                }
10302                public TrContext tr(int i) {
10303                        return getRuleContext(TrContext.class,i);
10304                }
10305                public List<DtContext> dt() {
10306                        return getRuleContexts(DtContext.class);
10307                }
10308                public HtmlCommentContext htmlComment(int i) {
10309                        return getRuleContext(HtmlCommentContext.class,i);
10310                }
10311                public List<TdContext> td() {
10312                        return getRuleContexts(TdContext.class);
10313                }
10314                public List<BodyTagOpenContext> bodyTagOpen() {
10315                        return getRuleContexts(BodyTagOpenContext.class);
10316                }
10317                public DtTagOpenContext dtTagOpen(int i) {
10318                        return getRuleContext(DtTagOpenContext.class,i);
10319                }
10320                public HtmlContext html(int i) {
10321                        return getRuleContext(HtmlContext.class,i);
10322                }
10323                public BodyTagOpenContext bodyTagOpen(int i) {
10324                        return getRuleContext(BodyTagOpenContext.class,i);
10325                }
10326                public DdTagOpenContext ddTagOpen(int i) {
10327                        return getRuleContext(DdTagOpenContext.class,i);
10328                }
10329                public List<HtmlTagContext> htmlTag() {
10330                        return getRuleContexts(HtmlTagContext.class);
10331                }
10332                public ParagraphContext paragraph(int i) {
10333                        return getRuleContext(ParagraphContext.class,i);
10334                }
10335                public List<TdTagOpenContext> tdTagOpen() {
10336                        return getRuleContexts(TdTagOpenContext.class);
10337                }
10338                public OptionTagOpenContext optionTagOpen(int i) {
10339                        return getRuleContext(OptionTagOpenContext.class,i);
10340                }
10341                public LiTagOpenContext liTagOpen(int i) {
10342                        return getRuleContext(LiTagOpenContext.class,i);
10343                }
10344                public TdContext td(int i) {
10345                        return getRuleContext(TdContext.class,i);
10346                }
10347                public List<ParagraphContext> paragraph() {
10348                        return getRuleContexts(ParagraphContext.class);
10349                }
10350                public HtmlTagContext htmlTag(int i) {
10351                        return getRuleContext(HtmlTagContext.class,i);
10352                }
10353                public List<SingletonTagContext> singletonTag() {
10354                        return getRuleContexts(SingletonTagContext.class);
10355                }
10356                public HeadTagOpenContext headTagOpen(int i) {
10357                        return getRuleContext(HeadTagOpenContext.class,i);
10358                }
10359                public TrTagOpenContext trTagOpen(int i) {
10360                        return getRuleContext(TrTagOpenContext.class,i);
10361                }
10362                public List<HtmlContext> html() {
10363                        return getRuleContexts(HtmlContext.class);
10364                }
10365                public JavadocInlineTagContext javadocInlineTag(int i) {
10366                        return getRuleContext(JavadocInlineTagContext.class,i);
10367                }
10368                public List<ThContext> th() {
10369                        return getRuleContexts(ThContext.class);
10370                }
10371                public DtContext dt(int i) {
10372                        return getRuleContext(DtContext.class,i);
10373                }
10374                public PTagOpenContext pTagOpen(int i) {
10375                        return getRuleContext(PTagOpenContext.class,i);
10376                }
10377                public TerminalNode LEADING_ASTERISK(int i) {
10378                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10379                }
10380                public List<TrTagOpenContext> trTagOpen() {
10381                        return getRuleContexts(TrTagOpenContext.class);
10382                }
10383                public List<TbodyContext> tbody() {
10384                        return getRuleContexts(TbodyContext.class);
10385                }
10386                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
10387                public List<TheadTagOpenContext> theadTagOpen() {
10388                        return getRuleContexts(TheadTagOpenContext.class);
10389                }
10390                public List<HeadContext> head() {
10391                        return getRuleContexts(HeadContext.class);
10392                }
10393                public TerminalNode NEWLINE(int i) {
10394                        return getToken(JavadocParser.NEWLINE, i);
10395                }
10396                public TextContext text(int i) {
10397                        return getRuleContext(TextContext.class,i);
10398                }
10399                public List<BodyContext> body() {
10400                        return getRuleContexts(BodyContext.class);
10401                }
10402                public List<OptionTagOpenContext> optionTagOpen() {
10403                        return getRuleContexts(OptionTagOpenContext.class);
10404                }
10405                public TfootTagCloseContext tfootTagClose() {
10406                        return getRuleContext(TfootTagCloseContext.class,0);
10407                }
10408                public List<TextContext> text() {
10409                        return getRuleContexts(TextContext.class);
10410                }
10411                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10412                public TbodyTagOpenContext tbodyTagOpen(int i) {
10413                        return getRuleContext(TbodyTagOpenContext.class,i);
10414                }
10415                public List<DdContext> dd() {
10416                        return getRuleContexts(DdContext.class);
10417                }
10418                public TheadTagOpenContext theadTagOpen(int i) {
10419                        return getRuleContext(TheadTagOpenContext.class,i);
10420                }
10421                public ColgroupTagOpenContext colgroupTagOpen(int i) {
10422                        return getRuleContext(ColgroupTagOpenContext.class,i);
10423                }
10424                public List<LiTagOpenContext> liTagOpen() {
10425                        return getRuleContexts(LiTagOpenContext.class);
10426                }
10427                public DdContext dd(int i) {
10428                        return getRuleContext(DdContext.class,i);
10429                }
10430                public List<OptionContext> option() {
10431                        return getRuleContexts(OptionContext.class);
10432                }
10433                public TheadContext thead(int i) {
10434                        return getRuleContext(TheadContext.class,i);
10435                }
10436                public BodyContext body(int i) {
10437                        return getRuleContext(BodyContext.class,i);
10438                }
10439                public ThContext th(int i) {
10440                        return getRuleContext(ThContext.class,i);
10441                }
10442                public List<PTagOpenContext> pTagOpen() {
10443                        return getRuleContexts(PTagOpenContext.class);
10444                }
10445                public HtmlTagOpenContext htmlTagOpen(int i) {
10446                        return getRuleContext(HtmlTagOpenContext.class,i);
10447                }
10448                public SingletonTagContext singletonTag(int i) {
10449                        return getRuleContext(SingletonTagContext.class,i);
10450                }
10451                public TfootContext(ParserRuleContext parent, int invokingState) {
10452                        super(parent, invokingState);
10453                }
10454                @Override public int getRuleIndex() { return RULE_tfoot; }
10455                @Override
10456                public void enterRule(ParseTreeListener listener) {
10457                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfoot(this);
10458                }
10459                @Override
10460                public void exitRule(ParseTreeListener listener) {
10461                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfoot(this);
10462                }
10463                @Override
10464                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10465                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfoot(this);
10466                        else return visitor.visitChildren(this);
10467                }
10468        }
10469
10470        public final TfootContext tfoot() throws RecognitionException {
10471                TfootContext _localctx = new TfootContext(_ctx, getState());
10472                enterRule(_localctx, 94, RULE_tfoot);
10473                try {
10474                        int _alt;
10475                        enterOuterAlt(_localctx, 1);
10476                        {
10477                        setState(1227); tfootTagOpen();
10478                        setState(1267);
10479                        _errHandler.sync(this);
10480                        _alt = getInterpreter().adaptivePredict(_input,86,_ctx);
10481                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
10482                                if ( _alt==1 ) {
10483                                        {
10484                                        setState(1265);
10485                                        switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
10486                                        case 1:
10487                                                {
10488                                                setState(1228); htmlTag();
10489                                                }
10490                                                break;
10491
10492                                        case 2:
10493                                                {
10494                                                setState(1229); singletonTag();
10495                                                }
10496                                                break;
10497
10498                                        case 3:
10499                                                {
10500                                                setState(1230); paragraph();
10501                                                }
10502                                                break;
10503
10504                                        case 4:
10505                                                {
10506                                                setState(1231); li();
10507                                                }
10508                                                break;
10509
10510                                        case 5:
10511                                                {
10512                                                setState(1232); tr();
10513                                                }
10514                                                break;
10515
10516                                        case 6:
10517                                                {
10518                                                setState(1233); td();
10519                                                }
10520                                                break;
10521
10522                                        case 7:
10523                                                {
10524                                                setState(1234); th();
10525                                                }
10526                                                break;
10527
10528                                        case 8:
10529                                                {
10530                                                setState(1235); body();
10531                                                }
10532                                                break;
10533
10534                                        case 9:
10535                                                {
10536                                                setState(1236); colgroup();
10537                                                }
10538                                                break;
10539
10540                                        case 10:
10541                                                {
10542                                                setState(1237); dd();
10543                                                }
10544                                                break;
10545
10546                                        case 11:
10547                                                {
10548                                                setState(1238); dt();
10549                                                }
10550                                                break;
10551
10552                                        case 12:
10553                                                {
10554                                                setState(1239); head();
10555                                                }
10556                                                break;
10557
10558                                        case 13:
10559                                                {
10560                                                setState(1240); html();
10561                                                }
10562                                                break;
10563
10564                                        case 14:
10565                                                {
10566                                                setState(1241); option();
10567                                                }
10568                                                break;
10569
10570                                        case 15:
10571                                                {
10572                                                setState(1242); tbody();
10573                                                }
10574                                                break;
10575
10576                                        case 16:
10577                                                {
10578                                                setState(1243); thead();
10579                                                }
10580                                                break;
10581
10582                                        case 17:
10583                                                {
10584                                                setState(1244); pTagOpen();
10585                                                }
10586                                                break;
10587
10588                                        case 18:
10589                                                {
10590                                                setState(1245); liTagOpen();
10591                                                }
10592                                                break;
10593
10594                                        case 19:
10595                                                {
10596                                                setState(1246); trTagOpen();
10597                                                }
10598                                                break;
10599
10600                                        case 20:
10601                                                {
10602                                                setState(1247); tdTagOpen();
10603                                                }
10604                                                break;
10605
10606                                        case 21:
10607                                                {
10608                                                setState(1248); thTagOpen();
10609                                                }
10610                                                break;
10611
10612                                        case 22:
10613                                                {
10614                                                setState(1249); bodyTagOpen();
10615                                                }
10616                                                break;
10617
10618                                        case 23:
10619                                                {
10620                                                setState(1250); colgroupTagOpen();
10621                                                }
10622                                                break;
10623
10624                                        case 24:
10625                                                {
10626                                                setState(1251); ddTagOpen();
10627                                                }
10628                                                break;
10629
10630                                        case 25:
10631                                                {
10632                                                setState(1252); dtTagOpen();
10633                                                }
10634                                                break;
10635
10636                                        case 26:
10637                                                {
10638                                                setState(1253); headTagOpen();
10639                                                }
10640                                                break;
10641
10642                                        case 27:
10643                                                {
10644                                                setState(1254); htmlTagOpen();
10645                                                }
10646                                                break;
10647
10648                                        case 28:
10649                                                {
10650                                                setState(1255); optionTagOpen();
10651                                                }
10652                                                break;
10653
10654                                        case 29:
10655                                                {
10656                                                setState(1256); tbodyTagOpen();
10657                                                }
10658                                                break;
10659
10660                                        case 30:
10661                                                {
10662                                                setState(1257); theadTagOpen();
10663                                                }
10664                                                break;
10665
10666                                        case 31:
10667                                                {
10668                                                {
10669                                                setState(1258);
10670                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
10671                                                setState(1259); match(LEADING_ASTERISK);
10672                                                }
10673                                                }
10674                                                break;
10675
10676                                        case 32:
10677                                                {
10678                                                setState(1260); htmlComment();
10679                                                }
10680                                                break;
10681
10682                                        case 33:
10683                                                {
10684                                                setState(1261); match(CDATA);
10685                                                }
10686                                                break;
10687
10688                                        case 34:
10689                                                {
10690                                                setState(1262); match(NEWLINE);
10691                                                }
10692                                                break;
10693
10694                                        case 35:
10695                                                {
10696                                                setState(1263); text();
10697                                                }
10698                                                break;
10699
10700                                        case 36:
10701                                                {
10702                                                setState(1264); javadocInlineTag();
10703                                                }
10704                                                break;
10705                                        }
10706                                        } 
10707                                }
10708                                setState(1269);
10709                                _errHandler.sync(this);
10710                                _alt = getInterpreter().adaptivePredict(_input,86,_ctx);
10711                        }
10712                        setState(1270); tfootTagClose();
10713                        }
10714                }
10715                catch (RecognitionException re) {
10716                        _localctx.exception = re;
10717                        _errHandler.reportError(this, re);
10718                        _errHandler.recover(this, re);
10719                }
10720                finally {
10721                        exitRule();
10722                }
10723                return _localctx;
10724        }
10725
10726        public static class TheadTagOpenContext extends ParserRuleContext {
10727                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10728                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
10729                public TerminalNode NEWLINE(int i) {
10730                        return getToken(JavadocParser.NEWLINE, i);
10731                }
10732                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10733                public List<AttributeContext> attribute() {
10734                        return getRuleContexts(AttributeContext.class);
10735                }
10736                public AttributeContext attribute(int i) {
10737                        return getRuleContext(AttributeContext.class,i);
10738                }
10739                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
10740                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
10741                public TerminalNode LEADING_ASTERISK(int i) {
10742                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10743                }
10744                public TerminalNode WS(int i) {
10745                        return getToken(JavadocParser.WS, i);
10746                }
10747                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
10748                public TheadTagOpenContext(ParserRuleContext parent, int invokingState) {
10749                        super(parent, invokingState);
10750                }
10751                @Override public int getRuleIndex() { return RULE_theadTagOpen; }
10752                @Override
10753                public void enterRule(ParseTreeListener listener) {
10754                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagOpen(this);
10755                }
10756                @Override
10757                public void exitRule(ParseTreeListener listener) {
10758                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagOpen(this);
10759                }
10760                @Override
10761                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10762                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagOpen(this);
10763                        else return visitor.visitChildren(this);
10764                }
10765        }
10766
10767        public final TheadTagOpenContext theadTagOpen() throws RecognitionException {
10768                TheadTagOpenContext _localctx = new TheadTagOpenContext(_ctx, getState());
10769                enterRule(_localctx, 96, RULE_theadTagOpen);
10770                int _la;
10771                try {
10772                        enterOuterAlt(_localctx, 1);
10773                        {
10774                        setState(1272); match(OPEN);
10775                        setState(1273); match(THEAD_HTML_TAG_NAME);
10776                        setState(1280);
10777                        _errHandler.sync(this);
10778                        _la = _input.LA(1);
10779                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
10780                                {
10781                                setState(1278);
10782                                switch (_input.LA(1)) {
10783                                case HTML_TAG_NAME:
10784                                        {
10785                                        setState(1274); attribute();
10786                                        }
10787                                        break;
10788                                case NEWLINE:
10789                                        {
10790                                        setState(1275); match(NEWLINE);
10791                                        }
10792                                        break;
10793                                case LEADING_ASTERISK:
10794                                        {
10795                                        setState(1276); match(LEADING_ASTERISK);
10796                                        }
10797                                        break;
10798                                case WS:
10799                                        {
10800                                        setState(1277); match(WS);
10801                                        }
10802                                        break;
10803                                default:
10804                                        throw new NoViableAltException(this);
10805                                }
10806                                }
10807                                setState(1282);
10808                                _errHandler.sync(this);
10809                                _la = _input.LA(1);
10810                        }
10811                        setState(1283); match(CLOSE);
10812                        }
10813                }
10814                catch (RecognitionException re) {
10815                        _localctx.exception = re;
10816                        _errHandler.reportError(this, re);
10817                        _errHandler.recover(this, re);
10818                }
10819                finally {
10820                        exitRule();
10821                }
10822                return _localctx;
10823        }
10824
10825        public static class TheadTagCloseContext extends ParserRuleContext {
10826                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10827                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
10828                public TerminalNode NEWLINE(int i) {
10829                        return getToken(JavadocParser.NEWLINE, i);
10830                }
10831                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10832                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
10833                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
10834                public TerminalNode LEADING_ASTERISK(int i) {
10835                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10836                }
10837                public TerminalNode WS(int i) {
10838                        return getToken(JavadocParser.WS, i);
10839                }
10840                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
10841                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
10842                public TheadTagCloseContext(ParserRuleContext parent, int invokingState) {
10843                        super(parent, invokingState);
10844                }
10845                @Override public int getRuleIndex() { return RULE_theadTagClose; }
10846                @Override
10847                public void enterRule(ParseTreeListener listener) {
10848                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagClose(this);
10849                }
10850                @Override
10851                public void exitRule(ParseTreeListener listener) {
10852                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagClose(this);
10853                }
10854                @Override
10855                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10856                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagClose(this);
10857                        else return visitor.visitChildren(this);
10858                }
10859        }
10860
10861        public final TheadTagCloseContext theadTagClose() throws RecognitionException {
10862                TheadTagCloseContext _localctx = new TheadTagCloseContext(_ctx, getState());
10863                enterRule(_localctx, 98, RULE_theadTagClose);
10864                int _la;
10865                try {
10866                        enterOuterAlt(_localctx, 1);
10867                        {
10868                        setState(1285); match(OPEN);
10869                        setState(1286); match(SLASH);
10870                        setState(1287); match(THEAD_HTML_TAG_NAME);
10871                        setState(1291);
10872                        _errHandler.sync(this);
10873                        _la = _input.LA(1);
10874                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
10875                                {
10876                                {
10877                                setState(1288);
10878                                _la = _input.LA(1);
10879                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
10880                                _errHandler.recoverInline(this);
10881                                }
10882                                consume();
10883                                }
10884                                }
10885                                setState(1293);
10886                                _errHandler.sync(this);
10887                                _la = _input.LA(1);
10888                        }
10889                        setState(1294); match(CLOSE);
10890                        }
10891                }
10892                catch (RecognitionException re) {
10893                        _localctx.exception = re;
10894                        _errHandler.reportError(this, re);
10895                        _errHandler.recover(this, re);
10896                }
10897                finally {
10898                        exitRule();
10899                }
10900                return _localctx;
10901        }
10902
10903        public static class TheadContext extends ParserRuleContext {
10904                public TheadTagCloseContext theadTagClose() {
10905                        return getRuleContext(TheadTagCloseContext.class,0);
10906                }
10907                public List<ColgroupTagOpenContext> colgroupTagOpen() {
10908                        return getRuleContexts(ColgroupTagOpenContext.class);
10909                }
10910                public TbodyContext tbody(int i) {
10911                        return getRuleContext(TbodyContext.class,i);
10912                }
10913                public TerminalNode CDATA(int i) {
10914                        return getToken(JavadocParser.CDATA, i);
10915                }
10916                public TfootTagOpenContext tfootTagOpen(int i) {
10917                        return getRuleContext(TfootTagOpenContext.class,i);
10918                }
10919                public List<DtTagOpenContext> dtTagOpen() {
10920                        return getRuleContexts(DtTagOpenContext.class);
10921                }
10922                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10923                public List<ColgroupContext> colgroup() {
10924                        return getRuleContexts(ColgroupContext.class);
10925                }
10926                public HeadContext head(int i) {
10927                        return getRuleContext(HeadContext.class,i);
10928                }
10929                public List<TrContext> tr() {
10930                        return getRuleContexts(TrContext.class);
10931                }
10932                public List<LiContext> li() {
10933                        return getRuleContexts(LiContext.class);
10934                }
10935                public ThTagOpenContext thTagOpen(int i) {
10936                        return getRuleContext(ThTagOpenContext.class,i);
10937                }
10938                public List<DdTagOpenContext> ddTagOpen() {
10939                        return getRuleContexts(DdTagOpenContext.class);
10940                }
10941                public ColgroupContext colgroup(int i) {
10942                        return getRuleContext(ColgroupContext.class,i);
10943                }
10944                public TdTagOpenContext tdTagOpen(int i) {
10945                        return getRuleContext(TdTagOpenContext.class,i);
10946                }
10947                public List<ThTagOpenContext> thTagOpen() {
10948                        return getRuleContexts(ThTagOpenContext.class);
10949                }
10950                public List<HeadTagOpenContext> headTagOpen() {
10951                        return getRuleContexts(HeadTagOpenContext.class);
10952                }
10953                public List<HtmlTagOpenContext> htmlTagOpen() {
10954                        return getRuleContexts(HtmlTagOpenContext.class);
10955                }
10956                public List<TbodyTagOpenContext> tbodyTagOpen() {
10957                        return getRuleContexts(TbodyTagOpenContext.class);
10958                }
10959                public LiContext li(int i) {
10960                        return getRuleContext(LiContext.class,i);
10961                }
10962                public List<TfootTagOpenContext> tfootTagOpen() {
10963                        return getRuleContexts(TfootTagOpenContext.class);
10964                }
10965                public List<TfootContext> tfoot() {
10966                        return getRuleContexts(TfootContext.class);
10967                }
10968                public List<JavadocInlineTagContext> javadocInlineTag() {
10969                        return getRuleContexts(JavadocInlineTagContext.class);
10970                }
10971                public List<HtmlCommentContext> htmlComment() {
10972                        return getRuleContexts(HtmlCommentContext.class);
10973                }
10974                public OptionContext option(int i) {
10975                        return getRuleContext(OptionContext.class,i);
10976                }
10977                public TrContext tr(int i) {
10978                        return getRuleContext(TrContext.class,i);
10979                }
10980                public List<DtContext> dt() {
10981                        return getRuleContexts(DtContext.class);
10982                }
10983                public HtmlCommentContext htmlComment(int i) {
10984                        return getRuleContext(HtmlCommentContext.class,i);
10985                }
10986                public List<TdContext> td() {
10987                        return getRuleContexts(TdContext.class);
10988                }
10989                public List<BodyTagOpenContext> bodyTagOpen() {
10990                        return getRuleContexts(BodyTagOpenContext.class);
10991                }
10992                public DtTagOpenContext dtTagOpen(int i) {
10993                        return getRuleContext(DtTagOpenContext.class,i);
10994                }
10995                public HtmlContext html(int i) {
10996                        return getRuleContext(HtmlContext.class,i);
10997                }
10998                public BodyTagOpenContext bodyTagOpen(int i) {
10999                        return getRuleContext(BodyTagOpenContext.class,i);
11000                }
11001                public DdTagOpenContext ddTagOpen(int i) {
11002                        return getRuleContext(DdTagOpenContext.class,i);
11003                }
11004                public List<HtmlTagContext> htmlTag() {
11005                        return getRuleContexts(HtmlTagContext.class);
11006                }
11007                public ParagraphContext paragraph(int i) {
11008                        return getRuleContext(ParagraphContext.class,i);
11009                }
11010                public List<TdTagOpenContext> tdTagOpen() {
11011                        return getRuleContexts(TdTagOpenContext.class);
11012                }
11013                public OptionTagOpenContext optionTagOpen(int i) {
11014                        return getRuleContext(OptionTagOpenContext.class,i);
11015                }
11016                public LiTagOpenContext liTagOpen(int i) {
11017                        return getRuleContext(LiTagOpenContext.class,i);
11018                }
11019                public TdContext td(int i) {
11020                        return getRuleContext(TdContext.class,i);
11021                }
11022                public List<ParagraphContext> paragraph() {
11023                        return getRuleContexts(ParagraphContext.class);
11024                }
11025                public HtmlTagContext htmlTag(int i) {
11026                        return getRuleContext(HtmlTagContext.class,i);
11027                }
11028                public List<SingletonTagContext> singletonTag() {
11029                        return getRuleContexts(SingletonTagContext.class);
11030                }
11031                public HeadTagOpenContext headTagOpen(int i) {
11032                        return getRuleContext(HeadTagOpenContext.class,i);
11033                }
11034                public TrTagOpenContext trTagOpen(int i) {
11035                        return getRuleContext(TrTagOpenContext.class,i);
11036                }
11037                public List<HtmlContext> html() {
11038                        return getRuleContexts(HtmlContext.class);
11039                }
11040                public JavadocInlineTagContext javadocInlineTag(int i) {
11041                        return getRuleContext(JavadocInlineTagContext.class,i);
11042                }
11043                public List<ThContext> th() {
11044                        return getRuleContexts(ThContext.class);
11045                }
11046                public DtContext dt(int i) {
11047                        return getRuleContext(DtContext.class,i);
11048                }
11049                public PTagOpenContext pTagOpen(int i) {
11050                        return getRuleContext(PTagOpenContext.class,i);
11051                }
11052                public TerminalNode LEADING_ASTERISK(int i) {
11053                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11054                }
11055                public List<TrTagOpenContext> trTagOpen() {
11056                        return getRuleContexts(TrTagOpenContext.class);
11057                }
11058                public List<TbodyContext> tbody() {
11059                        return getRuleContexts(TbodyContext.class);
11060                }
11061                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
11062                public TheadTagOpenContext theadTagOpen() {
11063                        return getRuleContext(TheadTagOpenContext.class,0);
11064                }
11065                public List<HeadContext> head() {
11066                        return getRuleContexts(HeadContext.class);
11067                }
11068                public TerminalNode NEWLINE(int i) {
11069                        return getToken(JavadocParser.NEWLINE, i);
11070                }
11071                public TextContext text(int i) {
11072                        return getRuleContext(TextContext.class,i);
11073                }
11074                public List<BodyContext> body() {
11075                        return getRuleContexts(BodyContext.class);
11076                }
11077                public List<OptionTagOpenContext> optionTagOpen() {
11078                        return getRuleContexts(OptionTagOpenContext.class);
11079                }
11080                public List<TextContext> text() {
11081                        return getRuleContexts(TextContext.class);
11082                }
11083                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11084                public TbodyTagOpenContext tbodyTagOpen(int i) {
11085                        return getRuleContext(TbodyTagOpenContext.class,i);
11086                }
11087                public List<DdContext> dd() {
11088                        return getRuleContexts(DdContext.class);
11089                }
11090                public ColgroupTagOpenContext colgroupTagOpen(int i) {
11091                        return getRuleContext(ColgroupTagOpenContext.class,i);
11092                }
11093                public List<LiTagOpenContext> liTagOpen() {
11094                        return getRuleContexts(LiTagOpenContext.class);
11095                }
11096                public DdContext dd(int i) {
11097                        return getRuleContext(DdContext.class,i);
11098                }
11099                public List<OptionContext> option() {
11100                        return getRuleContexts(OptionContext.class);
11101                }
11102                public BodyContext body(int i) {
11103                        return getRuleContext(BodyContext.class,i);
11104                }
11105                public ThContext th(int i) {
11106                        return getRuleContext(ThContext.class,i);
11107                }
11108                public List<PTagOpenContext> pTagOpen() {
11109                        return getRuleContexts(PTagOpenContext.class);
11110                }
11111                public HtmlTagOpenContext htmlTagOpen(int i) {
11112                        return getRuleContext(HtmlTagOpenContext.class,i);
11113                }
11114                public SingletonTagContext singletonTag(int i) {
11115                        return getRuleContext(SingletonTagContext.class,i);
11116                }
11117                public TfootContext tfoot(int i) {
11118                        return getRuleContext(TfootContext.class,i);
11119                }
11120                public TheadContext(ParserRuleContext parent, int invokingState) {
11121                        super(parent, invokingState);
11122                }
11123                @Override public int getRuleIndex() { return RULE_thead; }
11124                @Override
11125                public void enterRule(ParseTreeListener listener) {
11126                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThead(this);
11127                }
11128                @Override
11129                public void exitRule(ParseTreeListener listener) {
11130                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThead(this);
11131                }
11132                @Override
11133                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11134                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThead(this);
11135                        else return visitor.visitChildren(this);
11136                }
11137        }
11138
11139        public final TheadContext thead() throws RecognitionException {
11140                TheadContext _localctx = new TheadContext(_ctx, getState());
11141                enterRule(_localctx, 100, RULE_thead);
11142                try {
11143                        int _alt;
11144                        enterOuterAlt(_localctx, 1);
11145                        {
11146                        setState(1296); theadTagOpen();
11147                        setState(1336);
11148                        _errHandler.sync(this);
11149                        _alt = getInterpreter().adaptivePredict(_input,91,_ctx);
11150                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
11151                                if ( _alt==1 ) {
11152                                        {
11153                                        setState(1334);
11154                                        switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
11155                                        case 1:
11156                                                {
11157                                                setState(1297); htmlTag();
11158                                                }
11159                                                break;
11160
11161                                        case 2:
11162                                                {
11163                                                setState(1298); singletonTag();
11164                                                }
11165                                                break;
11166
11167                                        case 3:
11168                                                {
11169                                                setState(1299); paragraph();
11170                                                }
11171                                                break;
11172
11173                                        case 4:
11174                                                {
11175                                                setState(1300); li();
11176                                                }
11177                                                break;
11178
11179                                        case 5:
11180                                                {
11181                                                setState(1301); tr();
11182                                                }
11183                                                break;
11184
11185                                        case 6:
11186                                                {
11187                                                setState(1302); td();
11188                                                }
11189                                                break;
11190
11191                                        case 7:
11192                                                {
11193                                                setState(1303); th();
11194                                                }
11195                                                break;
11196
11197                                        case 8:
11198                                                {
11199                                                setState(1304); body();
11200                                                }
11201                                                break;
11202
11203                                        case 9:
11204                                                {
11205                                                setState(1305); colgroup();
11206                                                }
11207                                                break;
11208
11209                                        case 10:
11210                                                {
11211                                                setState(1306); dd();
11212                                                }
11213                                                break;
11214
11215                                        case 11:
11216                                                {
11217                                                setState(1307); dt();
11218                                                }
11219                                                break;
11220
11221                                        case 12:
11222                                                {
11223                                                setState(1308); head();
11224                                                }
11225                                                break;
11226
11227                                        case 13:
11228                                                {
11229                                                setState(1309); html();
11230                                                }
11231                                                break;
11232
11233                                        case 14:
11234                                                {
11235                                                setState(1310); option();
11236                                                }
11237                                                break;
11238
11239                                        case 15:
11240                                                {
11241                                                setState(1311); tbody();
11242                                                }
11243                                                break;
11244
11245                                        case 16:
11246                                                {
11247                                                setState(1312); tfoot();
11248                                                }
11249                                                break;
11250
11251                                        case 17:
11252                                                {
11253                                                setState(1313); pTagOpen();
11254                                                }
11255                                                break;
11256
11257                                        case 18:
11258                                                {
11259                                                setState(1314); liTagOpen();
11260                                                }
11261                                                break;
11262
11263                                        case 19:
11264                                                {
11265                                                setState(1315); trTagOpen();
11266                                                }
11267                                                break;
11268
11269                                        case 20:
11270                                                {
11271                                                setState(1316); tdTagOpen();
11272                                                }
11273                                                break;
11274
11275                                        case 21:
11276                                                {
11277                                                setState(1317); thTagOpen();
11278                                                }
11279                                                break;
11280
11281                                        case 22:
11282                                                {
11283                                                setState(1318); bodyTagOpen();
11284                                                }
11285                                                break;
11286
11287                                        case 23:
11288                                                {
11289                                                setState(1319); colgroupTagOpen();
11290                                                }
11291                                                break;
11292
11293                                        case 24:
11294                                                {
11295                                                setState(1320); ddTagOpen();
11296                                                }
11297                                                break;
11298
11299                                        case 25:
11300                                                {
11301                                                setState(1321); dtTagOpen();
11302                                                }
11303                                                break;
11304
11305                                        case 26:
11306                                                {
11307                                                setState(1322); headTagOpen();
11308                                                }
11309                                                break;
11310
11311                                        case 27:
11312                                                {
11313                                                setState(1323); htmlTagOpen();
11314                                                }
11315                                                break;
11316
11317                                        case 28:
11318                                                {
11319                                                setState(1324); optionTagOpen();
11320                                                }
11321                                                break;
11322
11323                                        case 29:
11324                                                {
11325                                                setState(1325); tbodyTagOpen();
11326                                                }
11327                                                break;
11328
11329                                        case 30:
11330                                                {
11331                                                setState(1326); tfootTagOpen();
11332                                                }
11333                                                break;
11334
11335                                        case 31:
11336                                                {
11337                                                {
11338                                                setState(1327);
11339                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
11340                                                setState(1328); match(LEADING_ASTERISK);
11341                                                }
11342                                                }
11343                                                break;
11344
11345                                        case 32:
11346                                                {
11347                                                setState(1329); htmlComment();
11348                                                }
11349                                                break;
11350
11351                                        case 33:
11352                                                {
11353                                                setState(1330); match(CDATA);
11354                                                }
11355                                                break;
11356
11357                                        case 34:
11358                                                {
11359                                                setState(1331); match(NEWLINE);
11360                                                }
11361                                                break;
11362
11363                                        case 35:
11364                                                {
11365                                                setState(1332); text();
11366                                                }
11367                                                break;
11368
11369                                        case 36:
11370                                                {
11371                                                setState(1333); javadocInlineTag();
11372                                                }
11373                                                break;
11374                                        }
11375                                        } 
11376                                }
11377                                setState(1338);
11378                                _errHandler.sync(this);
11379                                _alt = getInterpreter().adaptivePredict(_input,91,_ctx);
11380                        }
11381                        setState(1339); theadTagClose();
11382                        }
11383                }
11384                catch (RecognitionException re) {
11385                        _localctx.exception = re;
11386                        _errHandler.reportError(this, re);
11387                        _errHandler.recover(this, re);
11388                }
11389                finally {
11390                        exitRule();
11391                }
11392                return _localctx;
11393        }
11394
11395        public static class SingletonElementContext extends ParserRuleContext {
11396                public InputTagContext inputTag() {
11397                        return getRuleContext(InputTagContext.class,0);
11398                }
11399                public ImgTagContext imgTag() {
11400                        return getRuleContext(ImgTagContext.class,0);
11401                }
11402                public AreaTagContext areaTag() {
11403                        return getRuleContext(AreaTagContext.class,0);
11404                }
11405                public IsindexTagContext isindexTag() {
11406                        return getRuleContext(IsindexTagContext.class,0);
11407                }
11408                public SingletonTagContext singletonTag() {
11409                        return getRuleContext(SingletonTagContext.class,0);
11410                }
11411                public LinkTagContext linkTag() {
11412                        return getRuleContext(LinkTagContext.class,0);
11413                }
11414                public ColTagContext colTag() {
11415                        return getRuleContext(ColTagContext.class,0);
11416                }
11417                public BasefrontTagContext basefrontTag() {
11418                        return getRuleContext(BasefrontTagContext.class,0);
11419                }
11420                public ParamTagContext paramTag() {
11421                        return getRuleContext(ParamTagContext.class,0);
11422                }
11423                public HrTagContext hrTag() {
11424                        return getRuleContext(HrTagContext.class,0);
11425                }
11426                public MetaTagContext metaTag() {
11427                        return getRuleContext(MetaTagContext.class,0);
11428                }
11429                public BaseTagContext baseTag() {
11430                        return getRuleContext(BaseTagContext.class,0);
11431                }
11432                public FrameTagContext frameTag() {
11433                        return getRuleContext(FrameTagContext.class,0);
11434                }
11435                public WrongSinletonTagContext wrongSinletonTag() {
11436                        return getRuleContext(WrongSinletonTagContext.class,0);
11437                }
11438                public BrTagContext brTag() {
11439                        return getRuleContext(BrTagContext.class,0);
11440                }
11441                public SingletonElementContext(ParserRuleContext parent, int invokingState) {
11442                        super(parent, invokingState);
11443                }
11444                @Override public int getRuleIndex() { return RULE_singletonElement; }
11445                @Override
11446                public void enterRule(ParseTreeListener listener) {
11447                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonElement(this);
11448                }
11449                @Override
11450                public void exitRule(ParseTreeListener listener) {
11451                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonElement(this);
11452                }
11453                @Override
11454                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11455                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonElement(this);
11456                        else return visitor.visitChildren(this);
11457                }
11458        }
11459
11460        public final SingletonElementContext singletonElement() throws RecognitionException {
11461                SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState());
11462                enterRule(_localctx, 102, RULE_singletonElement);
11463                try {
11464                        setState(1356);
11465                        switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
11466                        case 1:
11467                                enterOuterAlt(_localctx, 1);
11468                                {
11469                                setState(1341); singletonTag();
11470                                }
11471                                break;
11472
11473                        case 2:
11474                                enterOuterAlt(_localctx, 2);
11475                                {
11476                                setState(1342); areaTag();
11477                                }
11478                                break;
11479
11480                        case 3:
11481                                enterOuterAlt(_localctx, 3);
11482                                {
11483                                setState(1343); baseTag();
11484                                }
11485                                break;
11486
11487                        case 4:
11488                                enterOuterAlt(_localctx, 4);
11489                                {
11490                                setState(1344); basefrontTag();
11491                                }
11492                                break;
11493
11494                        case 5:
11495                                enterOuterAlt(_localctx, 5);
11496                                {
11497                                setState(1345); brTag();
11498                                }
11499                                break;
11500
11501                        case 6:
11502                                enterOuterAlt(_localctx, 6);
11503                                {
11504                                setState(1346); colTag();
11505                                }
11506                                break;
11507
11508                        case 7:
11509                                enterOuterAlt(_localctx, 7);
11510                                {
11511                                setState(1347); frameTag();
11512                                }
11513                                break;
11514
11515                        case 8:
11516                                enterOuterAlt(_localctx, 8);
11517                                {
11518                                setState(1348); hrTag();
11519                                }
11520                                break;
11521
11522                        case 9:
11523                                enterOuterAlt(_localctx, 9);
11524                                {
11525                                setState(1349); imgTag();
11526                                }
11527                                break;
11528
11529                        case 10:
11530                                enterOuterAlt(_localctx, 10);
11531                                {
11532                                setState(1350); inputTag();
11533                                }
11534                                break;
11535
11536                        case 11:
11537                                enterOuterAlt(_localctx, 11);
11538                                {
11539                                setState(1351); isindexTag();
11540                                }
11541                                break;
11542
11543                        case 12:
11544                                enterOuterAlt(_localctx, 12);
11545                                {
11546                                setState(1352); linkTag();
11547                                }
11548                                break;
11549
11550                        case 13:
11551                                enterOuterAlt(_localctx, 13);
11552                                {
11553                                setState(1353); metaTag();
11554                                }
11555                                break;
11556
11557                        case 14:
11558                                enterOuterAlt(_localctx, 14);
11559                                {
11560                                setState(1354); paramTag();
11561                                }
11562                                break;
11563
11564                        case 15:
11565                                enterOuterAlt(_localctx, 15);
11566                                {
11567                                setState(1355); wrongSinletonTag();
11568                                }
11569                                break;
11570                        }
11571                }
11572                catch (RecognitionException re) {
11573                        _localctx.exception = re;
11574                        _errHandler.reportError(this, re);
11575                        _errHandler.recover(this, re);
11576                }
11577                finally {
11578                        exitRule();
11579                }
11580                return _localctx;
11581        }
11582
11583        public static class SingletonTagContext extends ParserRuleContext {
11584                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11585                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
11586                public AttributeContext attribute(int i) {
11587                        return getRuleContext(AttributeContext.class,i);
11588                }
11589                public TerminalNode WS(int i) {
11590                        return getToken(JavadocParser.WS, i);
11591                }
11592                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
11593                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
11594                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
11595                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
11596                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11597                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
11598                public TerminalNode LEADING_ASTERISK(int i) {
11599                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11600                }
11601                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
11602                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
11603                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
11604                public TerminalNode NEWLINE(int i) {
11605                        return getToken(JavadocParser.NEWLINE, i);
11606                }
11607                public List<AttributeContext> attribute() {
11608                        return getRuleContexts(AttributeContext.class);
11609                }
11610                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
11611                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
11612                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11613                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
11614                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
11615                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
11616                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11617                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
11618                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11619                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
11620                public SingletonTagContext(ParserRuleContext parent, int invokingState) {
11621                        super(parent, invokingState);
11622                }
11623                @Override public int getRuleIndex() { return RULE_singletonTag; }
11624                @Override
11625                public void enterRule(ParseTreeListener listener) {
11626                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTag(this);
11627                }
11628                @Override
11629                public void exitRule(ParseTreeListener listener) {
11630                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTag(this);
11631                }
11632                @Override
11633                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11634                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTag(this);
11635                        else return visitor.visitChildren(this);
11636                }
11637        }
11638
11639        public final SingletonTagContext singletonTag() throws RecognitionException {
11640                SingletonTagContext _localctx = new SingletonTagContext(_ctx, getState());
11641                enterRule(_localctx, 104, RULE_singletonTag);
11642                int _la;
11643                try {
11644                        enterOuterAlt(_localctx, 1);
11645                        {
11646                        setState(1358); match(OPEN);
11647                        setState(1359);
11648                        _la = _input.LA(1);
11649                        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)) ) {
11650                        _errHandler.recoverInline(this);
11651                        }
11652                        consume();
11653                        setState(1366);
11654                        _errHandler.sync(this);
11655                        _la = _input.LA(1);
11656                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
11657                                {
11658                                setState(1364);
11659                                switch (_input.LA(1)) {
11660                                case HTML_TAG_NAME:
11661                                        {
11662                                        setState(1360); attribute();
11663                                        }
11664                                        break;
11665                                case NEWLINE:
11666                                        {
11667                                        setState(1361); match(NEWLINE);
11668                                        }
11669                                        break;
11670                                case LEADING_ASTERISK:
11671                                        {
11672                                        setState(1362); match(LEADING_ASTERISK);
11673                                        }
11674                                        break;
11675                                case WS:
11676                                        {
11677                                        setState(1363); match(WS);
11678                                        }
11679                                        break;
11680                                default:
11681                                        throw new NoViableAltException(this);
11682                                }
11683                                }
11684                                setState(1368);
11685                                _errHandler.sync(this);
11686                                _la = _input.LA(1);
11687                        }
11688                        setState(1369); match(SLASH_CLOSE);
11689                        }
11690                }
11691                catch (RecognitionException re) {
11692                        _localctx.exception = re;
11693                        _errHandler.reportError(this, re);
11694                        _errHandler.recover(this, re);
11695                }
11696                finally {
11697                        exitRule();
11698                }
11699                return _localctx;
11700        }
11701
11702        public static class AreaTagContext extends ParserRuleContext {
11703                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11704                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11705                public TerminalNode NEWLINE(int i) {
11706                        return getToken(JavadocParser.NEWLINE, i);
11707                }
11708                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
11709                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11710                public List<AttributeContext> attribute() {
11711                        return getRuleContexts(AttributeContext.class);
11712                }
11713                public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); }
11714                public AttributeContext attribute(int i) {
11715                        return getRuleContext(AttributeContext.class,i);
11716                }
11717                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
11718                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11719                public TerminalNode LEADING_ASTERISK(int i) {
11720                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11721                }
11722                public TerminalNode WS(int i) {
11723                        return getToken(JavadocParser.WS, i);
11724                }
11725                public AreaTagContext(ParserRuleContext parent, int invokingState) {
11726                        super(parent, invokingState);
11727                }
11728                @Override public int getRuleIndex() { return RULE_areaTag; }
11729                @Override
11730                public void enterRule(ParseTreeListener listener) {
11731                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAreaTag(this);
11732                }
11733                @Override
11734                public void exitRule(ParseTreeListener listener) {
11735                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAreaTag(this);
11736                }
11737                @Override
11738                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11739                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAreaTag(this);
11740                        else return visitor.visitChildren(this);
11741                }
11742        }
11743
11744        public final AreaTagContext areaTag() throws RecognitionException {
11745                AreaTagContext _localctx = new AreaTagContext(_ctx, getState());
11746                enterRule(_localctx, 106, RULE_areaTag);
11747                int _la;
11748                try {
11749                        enterOuterAlt(_localctx, 1);
11750                        {
11751                        setState(1371); match(OPEN);
11752                        setState(1372); match(AREA_HTML_TAG_NAME);
11753                        setState(1379);
11754                        _errHandler.sync(this);
11755                        _la = _input.LA(1);
11756                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
11757                                {
11758                                setState(1377);
11759                                switch (_input.LA(1)) {
11760                                case HTML_TAG_NAME:
11761                                        {
11762                                        setState(1373); attribute();
11763                                        }
11764                                        break;
11765                                case NEWLINE:
11766                                        {
11767                                        setState(1374); match(NEWLINE);
11768                                        }
11769                                        break;
11770                                case LEADING_ASTERISK:
11771                                        {
11772                                        setState(1375); match(LEADING_ASTERISK);
11773                                        }
11774                                        break;
11775                                case WS:
11776                                        {
11777                                        setState(1376); match(WS);
11778                                        }
11779                                        break;
11780                                default:
11781                                        throw new NoViableAltException(this);
11782                                }
11783                                }
11784                                setState(1381);
11785                                _errHandler.sync(this);
11786                                _la = _input.LA(1);
11787                        }
11788                        setState(1382);
11789                        _la = _input.LA(1);
11790                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
11791                        _errHandler.recoverInline(this);
11792                        }
11793                        consume();
11794                        }
11795                }
11796                catch (RecognitionException re) {
11797                        _localctx.exception = re;
11798                        _errHandler.reportError(this, re);
11799                        _errHandler.recover(this, re);
11800                }
11801                finally {
11802                        exitRule();
11803                }
11804                return _localctx;
11805        }
11806
11807        public static class BaseTagContext extends ParserRuleContext {
11808                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11809                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11810                public TerminalNode NEWLINE(int i) {
11811                        return getToken(JavadocParser.NEWLINE, i);
11812                }
11813                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
11814                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11815                public List<AttributeContext> attribute() {
11816                        return getRuleContexts(AttributeContext.class);
11817                }
11818                public AttributeContext attribute(int i) {
11819                        return getRuleContext(AttributeContext.class,i);
11820                }
11821                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
11822                public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); }
11823                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11824                public TerminalNode LEADING_ASTERISK(int i) {
11825                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11826                }
11827                public TerminalNode WS(int i) {
11828                        return getToken(JavadocParser.WS, i);
11829                }
11830                public BaseTagContext(ParserRuleContext parent, int invokingState) {
11831                        super(parent, invokingState);
11832                }
11833                @Override public int getRuleIndex() { return RULE_baseTag; }
11834                @Override
11835                public void enterRule(ParseTreeListener listener) {
11836                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBaseTag(this);
11837                }
11838                @Override
11839                public void exitRule(ParseTreeListener listener) {
11840                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBaseTag(this);
11841                }
11842                @Override
11843                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11844                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBaseTag(this);
11845                        else return visitor.visitChildren(this);
11846                }
11847        }
11848
11849        public final BaseTagContext baseTag() throws RecognitionException {
11850                BaseTagContext _localctx = new BaseTagContext(_ctx, getState());
11851                enterRule(_localctx, 108, RULE_baseTag);
11852                int _la;
11853                try {
11854                        enterOuterAlt(_localctx, 1);
11855                        {
11856                        setState(1384); match(OPEN);
11857                        setState(1385); match(BASE_HTML_TAG_NAME);
11858                        setState(1392);
11859                        _errHandler.sync(this);
11860                        _la = _input.LA(1);
11861                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
11862                                {
11863                                setState(1390);
11864                                switch (_input.LA(1)) {
11865                                case HTML_TAG_NAME:
11866                                        {
11867                                        setState(1386); attribute();
11868                                        }
11869                                        break;
11870                                case NEWLINE:
11871                                        {
11872                                        setState(1387); match(NEWLINE);
11873                                        }
11874                                        break;
11875                                case LEADING_ASTERISK:
11876                                        {
11877                                        setState(1388); match(LEADING_ASTERISK);
11878                                        }
11879                                        break;
11880                                case WS:
11881                                        {
11882                                        setState(1389); match(WS);
11883                                        }
11884                                        break;
11885                                default:
11886                                        throw new NoViableAltException(this);
11887                                }
11888                                }
11889                                setState(1394);
11890                                _errHandler.sync(this);
11891                                _la = _input.LA(1);
11892                        }
11893                        setState(1395);
11894                        _la = _input.LA(1);
11895                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
11896                        _errHandler.recoverInline(this);
11897                        }
11898                        consume();
11899                        }
11900                }
11901                catch (RecognitionException re) {
11902                        _localctx.exception = re;
11903                        _errHandler.reportError(this, re);
11904                        _errHandler.recover(this, re);
11905                }
11906                finally {
11907                        exitRule();
11908                }
11909                return _localctx;
11910        }
11911
11912        public static class BasefrontTagContext extends ParserRuleContext {
11913                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11914                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11915                public TerminalNode NEWLINE(int i) {
11916                        return getToken(JavadocParser.NEWLINE, i);
11917                }
11918                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
11919                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
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 TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
11927                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11928                public TerminalNode LEADING_ASTERISK(int i) {
11929                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11930                }
11931                public TerminalNode WS(int i) {
11932                        return getToken(JavadocParser.WS, i);
11933                }
11934                public TerminalNode BASEFRONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFRONT_HTML_TAG_NAME, 0); }
11935                public BasefrontTagContext(ParserRuleContext parent, int invokingState) {
11936                        super(parent, invokingState);
11937                }
11938                @Override public int getRuleIndex() { return RULE_basefrontTag; }
11939                @Override
11940                public void enterRule(ParseTreeListener listener) {
11941                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBasefrontTag(this);
11942                }
11943                @Override
11944                public void exitRule(ParseTreeListener listener) {
11945                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBasefrontTag(this);
11946                }
11947                @Override
11948                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11949                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBasefrontTag(this);
11950                        else return visitor.visitChildren(this);
11951                }
11952        }
11953
11954        public final BasefrontTagContext basefrontTag() throws RecognitionException {
11955                BasefrontTagContext _localctx = new BasefrontTagContext(_ctx, getState());
11956                enterRule(_localctx, 110, RULE_basefrontTag);
11957                int _la;
11958                try {
11959                        enterOuterAlt(_localctx, 1);
11960                        {
11961                        setState(1397); match(OPEN);
11962                        setState(1398); match(BASEFRONT_HTML_TAG_NAME);
11963                        setState(1405);
11964                        _errHandler.sync(this);
11965                        _la = _input.LA(1);
11966                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
11967                                {
11968                                setState(1403);
11969                                switch (_input.LA(1)) {
11970                                case HTML_TAG_NAME:
11971                                        {
11972                                        setState(1399); attribute();
11973                                        }
11974                                        break;
11975                                case NEWLINE:
11976                                        {
11977                                        setState(1400); match(NEWLINE);
11978                                        }
11979                                        break;
11980                                case LEADING_ASTERISK:
11981                                        {
11982                                        setState(1401); match(LEADING_ASTERISK);
11983                                        }
11984                                        break;
11985                                case WS:
11986                                        {
11987                                        setState(1402); match(WS);
11988                                        }
11989                                        break;
11990                                default:
11991                                        throw new NoViableAltException(this);
11992                                }
11993                                }
11994                                setState(1407);
11995                                _errHandler.sync(this);
11996                                _la = _input.LA(1);
11997                        }
11998                        setState(1408);
11999                        _la = _input.LA(1);
12000                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12001                        _errHandler.recoverInline(this);
12002                        }
12003                        consume();
12004                        }
12005                }
12006                catch (RecognitionException re) {
12007                        _localctx.exception = re;
12008                        _errHandler.reportError(this, re);
12009                        _errHandler.recover(this, re);
12010                }
12011                finally {
12012                        exitRule();
12013                }
12014                return _localctx;
12015        }
12016
12017        public static class BrTagContext extends ParserRuleContext {
12018                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12019                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12020                public TerminalNode NEWLINE(int i) {
12021                        return getToken(JavadocParser.NEWLINE, i);
12022                }
12023                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12024                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12025                public List<AttributeContext> attribute() {
12026                        return getRuleContexts(AttributeContext.class);
12027                }
12028                public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); }
12029                public AttributeContext attribute(int i) {
12030                        return getRuleContext(AttributeContext.class,i);
12031                }
12032                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12033                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12034                public TerminalNode LEADING_ASTERISK(int i) {
12035                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12036                }
12037                public TerminalNode WS(int i) {
12038                        return getToken(JavadocParser.WS, i);
12039                }
12040                public BrTagContext(ParserRuleContext parent, int invokingState) {
12041                        super(parent, invokingState);
12042                }
12043                @Override public int getRuleIndex() { return RULE_brTag; }
12044                @Override
12045                public void enterRule(ParseTreeListener listener) {
12046                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBrTag(this);
12047                }
12048                @Override
12049                public void exitRule(ParseTreeListener listener) {
12050                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBrTag(this);
12051                }
12052                @Override
12053                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12054                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBrTag(this);
12055                        else return visitor.visitChildren(this);
12056                }
12057        }
12058
12059        public final BrTagContext brTag() throws RecognitionException {
12060                BrTagContext _localctx = new BrTagContext(_ctx, getState());
12061                enterRule(_localctx, 112, RULE_brTag);
12062                int _la;
12063                try {
12064                        enterOuterAlt(_localctx, 1);
12065                        {
12066                        setState(1410); match(OPEN);
12067                        setState(1411); match(BR_HTML_TAG_NAME);
12068                        setState(1418);
12069                        _errHandler.sync(this);
12070                        _la = _input.LA(1);
12071                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12072                                {
12073                                setState(1416);
12074                                switch (_input.LA(1)) {
12075                                case HTML_TAG_NAME:
12076                                        {
12077                                        setState(1412); attribute();
12078                                        }
12079                                        break;
12080                                case NEWLINE:
12081                                        {
12082                                        setState(1413); match(NEWLINE);
12083                                        }
12084                                        break;
12085                                case LEADING_ASTERISK:
12086                                        {
12087                                        setState(1414); match(LEADING_ASTERISK);
12088                                        }
12089                                        break;
12090                                case WS:
12091                                        {
12092                                        setState(1415); match(WS);
12093                                        }
12094                                        break;
12095                                default:
12096                                        throw new NoViableAltException(this);
12097                                }
12098                                }
12099                                setState(1420);
12100                                _errHandler.sync(this);
12101                                _la = _input.LA(1);
12102                        }
12103                        setState(1421);
12104                        _la = _input.LA(1);
12105                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12106                        _errHandler.recoverInline(this);
12107                        }
12108                        consume();
12109                        }
12110                }
12111                catch (RecognitionException re) {
12112                        _localctx.exception = re;
12113                        _errHandler.reportError(this, re);
12114                        _errHandler.recover(this, re);
12115                }
12116                finally {
12117                        exitRule();
12118                }
12119                return _localctx;
12120        }
12121
12122        public static class ColTagContext extends ParserRuleContext {
12123                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12124                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12125                public TerminalNode NEWLINE(int i) {
12126                        return getToken(JavadocParser.NEWLINE, i);
12127                }
12128                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12129                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12130                public List<AttributeContext> attribute() {
12131                        return getRuleContexts(AttributeContext.class);
12132                }
12133                public AttributeContext attribute(int i) {
12134                        return getRuleContext(AttributeContext.class,i);
12135                }
12136                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12137                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12138                public TerminalNode LEADING_ASTERISK(int i) {
12139                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12140                }
12141                public TerminalNode WS(int i) {
12142                        return getToken(JavadocParser.WS, i);
12143                }
12144                public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); }
12145                public ColTagContext(ParserRuleContext parent, int invokingState) {
12146                        super(parent, invokingState);
12147                }
12148                @Override public int getRuleIndex() { return RULE_colTag; }
12149                @Override
12150                public void enterRule(ParseTreeListener listener) {
12151                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColTag(this);
12152                }
12153                @Override
12154                public void exitRule(ParseTreeListener listener) {
12155                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColTag(this);
12156                }
12157                @Override
12158                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12159                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColTag(this);
12160                        else return visitor.visitChildren(this);
12161                }
12162        }
12163
12164        public final ColTagContext colTag() throws RecognitionException {
12165                ColTagContext _localctx = new ColTagContext(_ctx, getState());
12166                enterRule(_localctx, 114, RULE_colTag);
12167                int _la;
12168                try {
12169                        enterOuterAlt(_localctx, 1);
12170                        {
12171                        setState(1423); match(OPEN);
12172                        setState(1424); match(COL_HTML_TAG_NAME);
12173                        setState(1431);
12174                        _errHandler.sync(this);
12175                        _la = _input.LA(1);
12176                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12177                                {
12178                                setState(1429);
12179                                switch (_input.LA(1)) {
12180                                case HTML_TAG_NAME:
12181                                        {
12182                                        setState(1425); attribute();
12183                                        }
12184                                        break;
12185                                case NEWLINE:
12186                                        {
12187                                        setState(1426); match(NEWLINE);
12188                                        }
12189                                        break;
12190                                case LEADING_ASTERISK:
12191                                        {
12192                                        setState(1427); match(LEADING_ASTERISK);
12193                                        }
12194                                        break;
12195                                case WS:
12196                                        {
12197                                        setState(1428); match(WS);
12198                                        }
12199                                        break;
12200                                default:
12201                                        throw new NoViableAltException(this);
12202                                }
12203                                }
12204                                setState(1433);
12205                                _errHandler.sync(this);
12206                                _la = _input.LA(1);
12207                        }
12208                        setState(1434);
12209                        _la = _input.LA(1);
12210                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12211                        _errHandler.recoverInline(this);
12212                        }
12213                        consume();
12214                        }
12215                }
12216                catch (RecognitionException re) {
12217                        _localctx.exception = re;
12218                        _errHandler.reportError(this, re);
12219                        _errHandler.recover(this, re);
12220                }
12221                finally {
12222                        exitRule();
12223                }
12224                return _localctx;
12225        }
12226
12227        public static class FrameTagContext extends ParserRuleContext {
12228                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12229                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12230                public TerminalNode NEWLINE(int i) {
12231                        return getToken(JavadocParser.NEWLINE, i);
12232                }
12233                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12234                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12235                public List<AttributeContext> attribute() {
12236                        return getRuleContexts(AttributeContext.class);
12237                }
12238                public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); }
12239                public AttributeContext attribute(int i) {
12240                        return getRuleContext(AttributeContext.class,i);
12241                }
12242                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12243                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12244                public TerminalNode LEADING_ASTERISK(int i) {
12245                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12246                }
12247                public TerminalNode WS(int i) {
12248                        return getToken(JavadocParser.WS, i);
12249                }
12250                public FrameTagContext(ParserRuleContext parent, int invokingState) {
12251                        super(parent, invokingState);
12252                }
12253                @Override public int getRuleIndex() { return RULE_frameTag; }
12254                @Override
12255                public void enterRule(ParseTreeListener listener) {
12256                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterFrameTag(this);
12257                }
12258                @Override
12259                public void exitRule(ParseTreeListener listener) {
12260                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitFrameTag(this);
12261                }
12262                @Override
12263                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12264                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitFrameTag(this);
12265                        else return visitor.visitChildren(this);
12266                }
12267        }
12268
12269        public final FrameTagContext frameTag() throws RecognitionException {
12270                FrameTagContext _localctx = new FrameTagContext(_ctx, getState());
12271                enterRule(_localctx, 116, RULE_frameTag);
12272                int _la;
12273                try {
12274                        enterOuterAlt(_localctx, 1);
12275                        {
12276                        setState(1436); match(OPEN);
12277                        setState(1437); match(FRAME_HTML_TAG_NAME);
12278                        setState(1444);
12279                        _errHandler.sync(this);
12280                        _la = _input.LA(1);
12281                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12282                                {
12283                                setState(1442);
12284                                switch (_input.LA(1)) {
12285                                case HTML_TAG_NAME:
12286                                        {
12287                                        setState(1438); attribute();
12288                                        }
12289                                        break;
12290                                case NEWLINE:
12291                                        {
12292                                        setState(1439); match(NEWLINE);
12293                                        }
12294                                        break;
12295                                case LEADING_ASTERISK:
12296                                        {
12297                                        setState(1440); match(LEADING_ASTERISK);
12298                                        }
12299                                        break;
12300                                case WS:
12301                                        {
12302                                        setState(1441); match(WS);
12303                                        }
12304                                        break;
12305                                default:
12306                                        throw new NoViableAltException(this);
12307                                }
12308                                }
12309                                setState(1446);
12310                                _errHandler.sync(this);
12311                                _la = _input.LA(1);
12312                        }
12313                        setState(1447);
12314                        _la = _input.LA(1);
12315                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12316                        _errHandler.recoverInline(this);
12317                        }
12318                        consume();
12319                        }
12320                }
12321                catch (RecognitionException re) {
12322                        _localctx.exception = re;
12323                        _errHandler.reportError(this, re);
12324                        _errHandler.recover(this, re);
12325                }
12326                finally {
12327                        exitRule();
12328                }
12329                return _localctx;
12330        }
12331
12332        public static class HrTagContext extends ParserRuleContext {
12333                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12334                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12335                public TerminalNode NEWLINE(int i) {
12336                        return getToken(JavadocParser.NEWLINE, i);
12337                }
12338                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12339                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12340                public List<AttributeContext> attribute() {
12341                        return getRuleContexts(AttributeContext.class);
12342                }
12343                public AttributeContext attribute(int i) {
12344                        return getRuleContext(AttributeContext.class,i);
12345                }
12346                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12347                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12348                public TerminalNode LEADING_ASTERISK(int i) {
12349                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12350                }
12351                public TerminalNode WS(int i) {
12352                        return getToken(JavadocParser.WS, i);
12353                }
12354                public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); }
12355                public HrTagContext(ParserRuleContext parent, int invokingState) {
12356                        super(parent, invokingState);
12357                }
12358                @Override public int getRuleIndex() { return RULE_hrTag; }
12359                @Override
12360                public void enterRule(ParseTreeListener listener) {
12361                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHrTag(this);
12362                }
12363                @Override
12364                public void exitRule(ParseTreeListener listener) {
12365                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHrTag(this);
12366                }
12367                @Override
12368                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12369                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHrTag(this);
12370                        else return visitor.visitChildren(this);
12371                }
12372        }
12373
12374        public final HrTagContext hrTag() throws RecognitionException {
12375                HrTagContext _localctx = new HrTagContext(_ctx, getState());
12376                enterRule(_localctx, 118, RULE_hrTag);
12377                int _la;
12378                try {
12379                        enterOuterAlt(_localctx, 1);
12380                        {
12381                        setState(1449); match(OPEN);
12382                        setState(1450); match(HR_HTML_TAG_NAME);
12383                        setState(1457);
12384                        _errHandler.sync(this);
12385                        _la = _input.LA(1);
12386                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12387                                {
12388                                setState(1455);
12389                                switch (_input.LA(1)) {
12390                                case HTML_TAG_NAME:
12391                                        {
12392                                        setState(1451); attribute();
12393                                        }
12394                                        break;
12395                                case NEWLINE:
12396                                        {
12397                                        setState(1452); match(NEWLINE);
12398                                        }
12399                                        break;
12400                                case LEADING_ASTERISK:
12401                                        {
12402                                        setState(1453); match(LEADING_ASTERISK);
12403                                        }
12404                                        break;
12405                                case WS:
12406                                        {
12407                                        setState(1454); match(WS);
12408                                        }
12409                                        break;
12410                                default:
12411                                        throw new NoViableAltException(this);
12412                                }
12413                                }
12414                                setState(1459);
12415                                _errHandler.sync(this);
12416                                _la = _input.LA(1);
12417                        }
12418                        setState(1460);
12419                        _la = _input.LA(1);
12420                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12421                        _errHandler.recoverInline(this);
12422                        }
12423                        consume();
12424                        }
12425                }
12426                catch (RecognitionException re) {
12427                        _localctx.exception = re;
12428                        _errHandler.reportError(this, re);
12429                        _errHandler.recover(this, re);
12430                }
12431                finally {
12432                        exitRule();
12433                }
12434                return _localctx;
12435        }
12436
12437        public static class ImgTagContext extends ParserRuleContext {
12438                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12439                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12440                public TerminalNode NEWLINE(int i) {
12441                        return getToken(JavadocParser.NEWLINE, i);
12442                }
12443                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12444                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12445                public List<AttributeContext> attribute() {
12446                        return getRuleContexts(AttributeContext.class);
12447                }
12448                public AttributeContext attribute(int i) {
12449                        return getRuleContext(AttributeContext.class,i);
12450                }
12451                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12452                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12453                public TerminalNode LEADING_ASTERISK(int i) {
12454                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12455                }
12456                public TerminalNode WS(int i) {
12457                        return getToken(JavadocParser.WS, i);
12458                }
12459                public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); }
12460                public ImgTagContext(ParserRuleContext parent, int invokingState) {
12461                        super(parent, invokingState);
12462                }
12463                @Override public int getRuleIndex() { return RULE_imgTag; }
12464                @Override
12465                public void enterRule(ParseTreeListener listener) {
12466                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterImgTag(this);
12467                }
12468                @Override
12469                public void exitRule(ParseTreeListener listener) {
12470                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitImgTag(this);
12471                }
12472                @Override
12473                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12474                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitImgTag(this);
12475                        else return visitor.visitChildren(this);
12476                }
12477        }
12478
12479        public final ImgTagContext imgTag() throws RecognitionException {
12480                ImgTagContext _localctx = new ImgTagContext(_ctx, getState());
12481                enterRule(_localctx, 120, RULE_imgTag);
12482                int _la;
12483                try {
12484                        enterOuterAlt(_localctx, 1);
12485                        {
12486                        setState(1462); match(OPEN);
12487                        setState(1463); match(IMG_HTML_TAG_NAME);
12488                        setState(1470);
12489                        _errHandler.sync(this);
12490                        _la = _input.LA(1);
12491                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12492                                {
12493                                setState(1468);
12494                                switch (_input.LA(1)) {
12495                                case HTML_TAG_NAME:
12496                                        {
12497                                        setState(1464); attribute();
12498                                        }
12499                                        break;
12500                                case NEWLINE:
12501                                        {
12502                                        setState(1465); match(NEWLINE);
12503                                        }
12504                                        break;
12505                                case LEADING_ASTERISK:
12506                                        {
12507                                        setState(1466); match(LEADING_ASTERISK);
12508                                        }
12509                                        break;
12510                                case WS:
12511                                        {
12512                                        setState(1467); match(WS);
12513                                        }
12514                                        break;
12515                                default:
12516                                        throw new NoViableAltException(this);
12517                                }
12518                                }
12519                                setState(1472);
12520                                _errHandler.sync(this);
12521                                _la = _input.LA(1);
12522                        }
12523                        setState(1473);
12524                        _la = _input.LA(1);
12525                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12526                        _errHandler.recoverInline(this);
12527                        }
12528                        consume();
12529                        }
12530                }
12531                catch (RecognitionException re) {
12532                        _localctx.exception = re;
12533                        _errHandler.reportError(this, re);
12534                        _errHandler.recover(this, re);
12535                }
12536                finally {
12537                        exitRule();
12538                }
12539                return _localctx;
12540        }
12541
12542        public static class InputTagContext extends ParserRuleContext {
12543                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12544                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12545                public TerminalNode NEWLINE(int i) {
12546                        return getToken(JavadocParser.NEWLINE, i);
12547                }
12548                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12549                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12550                public List<AttributeContext> attribute() {
12551                        return getRuleContexts(AttributeContext.class);
12552                }
12553                public AttributeContext attribute(int i) {
12554                        return getRuleContext(AttributeContext.class,i);
12555                }
12556                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12557                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12558                public TerminalNode LEADING_ASTERISK(int i) {
12559                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12560                }
12561                public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); }
12562                public TerminalNode WS(int i) {
12563                        return getToken(JavadocParser.WS, i);
12564                }
12565                public InputTagContext(ParserRuleContext parent, int invokingState) {
12566                        super(parent, invokingState);
12567                }
12568                @Override public int getRuleIndex() { return RULE_inputTag; }
12569                @Override
12570                public void enterRule(ParseTreeListener listener) {
12571                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInputTag(this);
12572                }
12573                @Override
12574                public void exitRule(ParseTreeListener listener) {
12575                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInputTag(this);
12576                }
12577                @Override
12578                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12579                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInputTag(this);
12580                        else return visitor.visitChildren(this);
12581                }
12582        }
12583
12584        public final InputTagContext inputTag() throws RecognitionException {
12585                InputTagContext _localctx = new InputTagContext(_ctx, getState());
12586                enterRule(_localctx, 122, RULE_inputTag);
12587                int _la;
12588                try {
12589                        enterOuterAlt(_localctx, 1);
12590                        {
12591                        setState(1475); match(OPEN);
12592                        setState(1476); match(INPUT_HTML_TAG_NAME);
12593                        setState(1483);
12594                        _errHandler.sync(this);
12595                        _la = _input.LA(1);
12596                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12597                                {
12598                                setState(1481);
12599                                switch (_input.LA(1)) {
12600                                case HTML_TAG_NAME:
12601                                        {
12602                                        setState(1477); attribute();
12603                                        }
12604                                        break;
12605                                case NEWLINE:
12606                                        {
12607                                        setState(1478); match(NEWLINE);
12608                                        }
12609                                        break;
12610                                case LEADING_ASTERISK:
12611                                        {
12612                                        setState(1479); match(LEADING_ASTERISK);
12613                                        }
12614                                        break;
12615                                case WS:
12616                                        {
12617                                        setState(1480); match(WS);
12618                                        }
12619                                        break;
12620                                default:
12621                                        throw new NoViableAltException(this);
12622                                }
12623                                }
12624                                setState(1485);
12625                                _errHandler.sync(this);
12626                                _la = _input.LA(1);
12627                        }
12628                        setState(1486);
12629                        _la = _input.LA(1);
12630                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12631                        _errHandler.recoverInline(this);
12632                        }
12633                        consume();
12634                        }
12635                }
12636                catch (RecognitionException re) {
12637                        _localctx.exception = re;
12638                        _errHandler.reportError(this, re);
12639                        _errHandler.recover(this, re);
12640                }
12641                finally {
12642                        exitRule();
12643                }
12644                return _localctx;
12645        }
12646
12647        public static class IsindexTagContext extends ParserRuleContext {
12648                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12649                public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); }
12650                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12651                public TerminalNode NEWLINE(int i) {
12652                        return getToken(JavadocParser.NEWLINE, i);
12653                }
12654                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12655                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12656                public List<AttributeContext> attribute() {
12657                        return getRuleContexts(AttributeContext.class);
12658                }
12659                public AttributeContext attribute(int i) {
12660                        return getRuleContext(AttributeContext.class,i);
12661                }
12662                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12663                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12664                public TerminalNode LEADING_ASTERISK(int i) {
12665                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12666                }
12667                public TerminalNode WS(int i) {
12668                        return getToken(JavadocParser.WS, i);
12669                }
12670                public IsindexTagContext(ParserRuleContext parent, int invokingState) {
12671                        super(parent, invokingState);
12672                }
12673                @Override public int getRuleIndex() { return RULE_isindexTag; }
12674                @Override
12675                public void enterRule(ParseTreeListener listener) {
12676                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterIsindexTag(this);
12677                }
12678                @Override
12679                public void exitRule(ParseTreeListener listener) {
12680                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitIsindexTag(this);
12681                }
12682                @Override
12683                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12684                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitIsindexTag(this);
12685                        else return visitor.visitChildren(this);
12686                }
12687        }
12688
12689        public final IsindexTagContext isindexTag() throws RecognitionException {
12690                IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState());
12691                enterRule(_localctx, 124, RULE_isindexTag);
12692                int _la;
12693                try {
12694                        enterOuterAlt(_localctx, 1);
12695                        {
12696                        setState(1488); match(OPEN);
12697                        setState(1489); match(ISINDEX_HTML_TAG_NAME);
12698                        setState(1496);
12699                        _errHandler.sync(this);
12700                        _la = _input.LA(1);
12701                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12702                                {
12703                                setState(1494);
12704                                switch (_input.LA(1)) {
12705                                case HTML_TAG_NAME:
12706                                        {
12707                                        setState(1490); attribute();
12708                                        }
12709                                        break;
12710                                case NEWLINE:
12711                                        {
12712                                        setState(1491); match(NEWLINE);
12713                                        }
12714                                        break;
12715                                case LEADING_ASTERISK:
12716                                        {
12717                                        setState(1492); match(LEADING_ASTERISK);
12718                                        }
12719                                        break;
12720                                case WS:
12721                                        {
12722                                        setState(1493); match(WS);
12723                                        }
12724                                        break;
12725                                default:
12726                                        throw new NoViableAltException(this);
12727                                }
12728                                }
12729                                setState(1498);
12730                                _errHandler.sync(this);
12731                                _la = _input.LA(1);
12732                        }
12733                        setState(1499);
12734                        _la = _input.LA(1);
12735                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12736                        _errHandler.recoverInline(this);
12737                        }
12738                        consume();
12739                        }
12740                }
12741                catch (RecognitionException re) {
12742                        _localctx.exception = re;
12743                        _errHandler.reportError(this, re);
12744                        _errHandler.recover(this, re);
12745                }
12746                finally {
12747                        exitRule();
12748                }
12749                return _localctx;
12750        }
12751
12752        public static class LinkTagContext extends ParserRuleContext {
12753                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12754                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12755                public TerminalNode NEWLINE(int i) {
12756                        return getToken(JavadocParser.NEWLINE, i);
12757                }
12758                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12759                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12760                public List<AttributeContext> attribute() {
12761                        return getRuleContexts(AttributeContext.class);
12762                }
12763                public AttributeContext attribute(int i) {
12764                        return getRuleContext(AttributeContext.class,i);
12765                }
12766                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12767                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12768                public TerminalNode LEADING_ASTERISK(int i) {
12769                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12770                }
12771                public TerminalNode WS(int i) {
12772                        return getToken(JavadocParser.WS, i);
12773                }
12774                public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); }
12775                public LinkTagContext(ParserRuleContext parent, int invokingState) {
12776                        super(parent, invokingState);
12777                }
12778                @Override public int getRuleIndex() { return RULE_linkTag; }
12779                @Override
12780                public void enterRule(ParseTreeListener listener) {
12781                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLinkTag(this);
12782                }
12783                @Override
12784                public void exitRule(ParseTreeListener listener) {
12785                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLinkTag(this);
12786                }
12787                @Override
12788                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12789                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLinkTag(this);
12790                        else return visitor.visitChildren(this);
12791                }
12792        }
12793
12794        public final LinkTagContext linkTag() throws RecognitionException {
12795                LinkTagContext _localctx = new LinkTagContext(_ctx, getState());
12796                enterRule(_localctx, 126, RULE_linkTag);
12797                int _la;
12798                try {
12799                        enterOuterAlt(_localctx, 1);
12800                        {
12801                        setState(1501); match(OPEN);
12802                        setState(1502); match(LINK_HTML_TAG_NAME);
12803                        setState(1509);
12804                        _errHandler.sync(this);
12805                        _la = _input.LA(1);
12806                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12807                                {
12808                                setState(1507);
12809                                switch (_input.LA(1)) {
12810                                case HTML_TAG_NAME:
12811                                        {
12812                                        setState(1503); attribute();
12813                                        }
12814                                        break;
12815                                case NEWLINE:
12816                                        {
12817                                        setState(1504); match(NEWLINE);
12818                                        }
12819                                        break;
12820                                case LEADING_ASTERISK:
12821                                        {
12822                                        setState(1505); match(LEADING_ASTERISK);
12823                                        }
12824                                        break;
12825                                case WS:
12826                                        {
12827                                        setState(1506); match(WS);
12828                                        }
12829                                        break;
12830                                default:
12831                                        throw new NoViableAltException(this);
12832                                }
12833                                }
12834                                setState(1511);
12835                                _errHandler.sync(this);
12836                                _la = _input.LA(1);
12837                        }
12838                        setState(1512);
12839                        _la = _input.LA(1);
12840                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12841                        _errHandler.recoverInline(this);
12842                        }
12843                        consume();
12844                        }
12845                }
12846                catch (RecognitionException re) {
12847                        _localctx.exception = re;
12848                        _errHandler.reportError(this, re);
12849                        _errHandler.recover(this, re);
12850                }
12851                finally {
12852                        exitRule();
12853                }
12854                return _localctx;
12855        }
12856
12857        public static class MetaTagContext extends ParserRuleContext {
12858                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12859                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12860                public TerminalNode NEWLINE(int i) {
12861                        return getToken(JavadocParser.NEWLINE, i);
12862                }
12863                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12864                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12865                public List<AttributeContext> attribute() {
12866                        return getRuleContexts(AttributeContext.class);
12867                }
12868                public AttributeContext attribute(int i) {
12869                        return getRuleContext(AttributeContext.class,i);
12870                }
12871                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12872                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12873                public TerminalNode LEADING_ASTERISK(int i) {
12874                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12875                }
12876                public TerminalNode WS(int i) {
12877                        return getToken(JavadocParser.WS, i);
12878                }
12879                public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); }
12880                public MetaTagContext(ParserRuleContext parent, int invokingState) {
12881                        super(parent, invokingState);
12882                }
12883                @Override public int getRuleIndex() { return RULE_metaTag; }
12884                @Override
12885                public void enterRule(ParseTreeListener listener) {
12886                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterMetaTag(this);
12887                }
12888                @Override
12889                public void exitRule(ParseTreeListener listener) {
12890                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitMetaTag(this);
12891                }
12892                @Override
12893                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12894                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitMetaTag(this);
12895                        else return visitor.visitChildren(this);
12896                }
12897        }
12898
12899        public final MetaTagContext metaTag() throws RecognitionException {
12900                MetaTagContext _localctx = new MetaTagContext(_ctx, getState());
12901                enterRule(_localctx, 128, RULE_metaTag);
12902                int _la;
12903                try {
12904                        enterOuterAlt(_localctx, 1);
12905                        {
12906                        setState(1514); match(OPEN);
12907                        setState(1515); match(META_HTML_TAG_NAME);
12908                        setState(1522);
12909                        _errHandler.sync(this);
12910                        _la = _input.LA(1);
12911                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12912                                {
12913                                setState(1520);
12914                                switch (_input.LA(1)) {
12915                                case HTML_TAG_NAME:
12916                                        {
12917                                        setState(1516); attribute();
12918                                        }
12919                                        break;
12920                                case NEWLINE:
12921                                        {
12922                                        setState(1517); match(NEWLINE);
12923                                        }
12924                                        break;
12925                                case LEADING_ASTERISK:
12926                                        {
12927                                        setState(1518); match(LEADING_ASTERISK);
12928                                        }
12929                                        break;
12930                                case WS:
12931                                        {
12932                                        setState(1519); match(WS);
12933                                        }
12934                                        break;
12935                                default:
12936                                        throw new NoViableAltException(this);
12937                                }
12938                                }
12939                                setState(1524);
12940                                _errHandler.sync(this);
12941                                _la = _input.LA(1);
12942                        }
12943                        setState(1525);
12944                        _la = _input.LA(1);
12945                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12946                        _errHandler.recoverInline(this);
12947                        }
12948                        consume();
12949                        }
12950                }
12951                catch (RecognitionException re) {
12952                        _localctx.exception = re;
12953                        _errHandler.reportError(this, re);
12954                        _errHandler.recover(this, re);
12955                }
12956                finally {
12957                        exitRule();
12958                }
12959                return _localctx;
12960        }
12961
12962        public static class ParamTagContext extends ParserRuleContext {
12963                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12964                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12965                public TerminalNode NEWLINE(int i) {
12966                        return getToken(JavadocParser.NEWLINE, i);
12967                }
12968                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12969                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12970                public List<AttributeContext> attribute() {
12971                        return getRuleContexts(AttributeContext.class);
12972                }
12973                public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); }
12974                public AttributeContext attribute(int i) {
12975                        return getRuleContext(AttributeContext.class,i);
12976                }
12977                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12978                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12979                public TerminalNode LEADING_ASTERISK(int i) {
12980                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12981                }
12982                public TerminalNode WS(int i) {
12983                        return getToken(JavadocParser.WS, i);
12984                }
12985                public ParamTagContext(ParserRuleContext parent, int invokingState) {
12986                        super(parent, invokingState);
12987                }
12988                @Override public int getRuleIndex() { return RULE_paramTag; }
12989                @Override
12990                public void enterRule(ParseTreeListener listener) {
12991                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParamTag(this);
12992                }
12993                @Override
12994                public void exitRule(ParseTreeListener listener) {
12995                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParamTag(this);
12996                }
12997                @Override
12998                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12999                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParamTag(this);
13000                        else return visitor.visitChildren(this);
13001                }
13002        }
13003
13004        public final ParamTagContext paramTag() throws RecognitionException {
13005                ParamTagContext _localctx = new ParamTagContext(_ctx, getState());
13006                enterRule(_localctx, 130, RULE_paramTag);
13007                int _la;
13008                try {
13009                        enterOuterAlt(_localctx, 1);
13010                        {
13011                        setState(1527); match(OPEN);
13012                        setState(1528); match(PARAM_HTML_TAG_NAME);
13013                        setState(1535);
13014                        _errHandler.sync(this);
13015                        _la = _input.LA(1);
13016                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13017                                {
13018                                setState(1533);
13019                                switch (_input.LA(1)) {
13020                                case HTML_TAG_NAME:
13021                                        {
13022                                        setState(1529); attribute();
13023                                        }
13024                                        break;
13025                                case NEWLINE:
13026                                        {
13027                                        setState(1530); match(NEWLINE);
13028                                        }
13029                                        break;
13030                                case LEADING_ASTERISK:
13031                                        {
13032                                        setState(1531); match(LEADING_ASTERISK);
13033                                        }
13034                                        break;
13035                                case WS:
13036                                        {
13037                                        setState(1532); match(WS);
13038                                        }
13039                                        break;
13040                                default:
13041                                        throw new NoViableAltException(this);
13042                                }
13043                                }
13044                                setState(1537);
13045                                _errHandler.sync(this);
13046                                _la = _input.LA(1);
13047                        }
13048                        setState(1538);
13049                        _la = _input.LA(1);
13050                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13051                        _errHandler.recoverInline(this);
13052                        }
13053                        consume();
13054                        }
13055                }
13056                catch (RecognitionException re) {
13057                        _localctx.exception = re;
13058                        _errHandler.reportError(this, re);
13059                        _errHandler.recover(this, re);
13060                }
13061                finally {
13062                        exitRule();
13063                }
13064                return _localctx;
13065        }
13066
13067        public static class WrongSinletonTagContext extends ParserRuleContext {
13068                public SingletonTagNameContext singletonTagName;
13069                public SingletonTagNameContext singletonTagName() {
13070                        return getRuleContext(SingletonTagNameContext.class,0);
13071                }
13072                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13073                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13074                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
13075                public WrongSinletonTagContext(ParserRuleContext parent, int invokingState) {
13076                        super(parent, invokingState);
13077                }
13078                @Override public int getRuleIndex() { return RULE_wrongSinletonTag; }
13079                @Override
13080                public void enterRule(ParseTreeListener listener) {
13081                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterWrongSinletonTag(this);
13082                }
13083                @Override
13084                public void exitRule(ParseTreeListener listener) {
13085                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitWrongSinletonTag(this);
13086                }
13087                @Override
13088                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13089                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitWrongSinletonTag(this);
13090                        else return visitor.visitChildren(this);
13091                }
13092        }
13093
13094        public final WrongSinletonTagContext wrongSinletonTag() throws RecognitionException {
13095                WrongSinletonTagContext _localctx = new WrongSinletonTagContext(_ctx, getState());
13096                enterRule(_localctx, 132, RULE_wrongSinletonTag);
13097                try {
13098                        enterOuterAlt(_localctx, 1);
13099                        {
13100                        setState(1540); match(OPEN);
13101                        setState(1541); match(SLASH);
13102                        setState(1542); ((WrongSinletonTagContext)_localctx).singletonTagName = singletonTagName();
13103                        setState(1543); match(CLOSE);
13104                        notifyErrorListeners((((WrongSinletonTagContext)_localctx).singletonTagName!=null?(((WrongSinletonTagContext)_localctx).singletonTagName.start):null), "javadoc.wrong.singleton.html.tag", null);
13105                        }
13106                }
13107                catch (RecognitionException re) {
13108                        _localctx.exception = re;
13109                        _errHandler.reportError(this, re);
13110                        _errHandler.recover(this, re);
13111                }
13112                finally {
13113                        exitRule();
13114                }
13115                return _localctx;
13116        }
13117
13118        public static class SingletonTagNameContext extends ParserRuleContext {
13119                public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); }
13120                public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); }
13121                public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); }
13122                public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); }
13123                public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); }
13124                public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); }
13125                public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); }
13126                public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); }
13127                public TerminalNode BASEFRONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFRONT_HTML_TAG_NAME, 0); }
13128                public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); }
13129                public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); }
13130                public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); }
13131                public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); }
13132                public SingletonTagNameContext(ParserRuleContext parent, int invokingState) {
13133                        super(parent, invokingState);
13134                }
13135                @Override public int getRuleIndex() { return RULE_singletonTagName; }
13136                @Override
13137                public void enterRule(ParseTreeListener listener) {
13138                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTagName(this);
13139                }
13140                @Override
13141                public void exitRule(ParseTreeListener listener) {
13142                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTagName(this);
13143                }
13144                @Override
13145                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13146                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTagName(this);
13147                        else return visitor.visitChildren(this);
13148                }
13149        }
13150
13151        public final SingletonTagNameContext singletonTagName() throws RecognitionException {
13152                SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState());
13153                enterRule(_localctx, 134, RULE_singletonTagName);
13154                int _la;
13155                try {
13156                        enterOuterAlt(_localctx, 1);
13157                        {
13158                        setState(1546);
13159                        _la = _input.LA(1);
13160                        if ( !(((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (AREA_HTML_TAG_NAME - 74)) | (1L << (BASE_HTML_TAG_NAME - 74)) | (1L << (BASEFRONT_HTML_TAG_NAME - 74)) | (1L << (BR_HTML_TAG_NAME - 74)) | (1L << (COL_HTML_TAG_NAME - 74)) | (1L << (FRAME_HTML_TAG_NAME - 74)) | (1L << (HR_HTML_TAG_NAME - 74)) | (1L << (IMG_HTML_TAG_NAME - 74)) | (1L << (INPUT_HTML_TAG_NAME - 74)) | (1L << (ISINDEX_HTML_TAG_NAME - 74)) | (1L << (LINK_HTML_TAG_NAME - 74)) | (1L << (META_HTML_TAG_NAME - 74)) | (1L << (PARAM_HTML_TAG_NAME - 74)))) != 0)) ) {
13161                        _errHandler.recoverInline(this);
13162                        }
13163                        consume();
13164                        }
13165                }
13166                catch (RecognitionException re) {
13167                        _localctx.exception = re;
13168                        _errHandler.reportError(this, re);
13169                        _errHandler.recover(this, re);
13170                }
13171                finally {
13172                        exitRule();
13173                }
13174                return _localctx;
13175        }
13176
13177        public static class DescriptionContext extends ParserRuleContext {
13178                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
13179                public TerminalNode NEWLINE(int i) {
13180                        return getToken(JavadocParser.NEWLINE, i);
13181                }
13182                public TextContext text(int i) {
13183                        return getRuleContext(TextContext.class,i);
13184                }
13185                public List<JavadocInlineTagContext> javadocInlineTag() {
13186                        return getRuleContexts(JavadocInlineTagContext.class);
13187                }
13188                public List<HtmlElementContext> htmlElement() {
13189                        return getRuleContexts(HtmlElementContext.class);
13190                }
13191                public List<HtmlCommentContext> htmlComment() {
13192                        return getRuleContexts(HtmlCommentContext.class);
13193                }
13194                public TerminalNode CDATA(int i) {
13195                        return getToken(JavadocParser.CDATA, i);
13196                }
13197                public HtmlCommentContext htmlComment(int i) {
13198                        return getRuleContext(HtmlCommentContext.class,i);
13199                }
13200                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13201                public List<TextContext> text() {
13202                        return getRuleContexts(TextContext.class);
13203                }
13204                public HtmlElementContext htmlElement(int i) {
13205                        return getRuleContext(HtmlElementContext.class,i);
13206                }
13207                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13208                public JavadocInlineTagContext javadocInlineTag(int i) {
13209                        return getRuleContext(JavadocInlineTagContext.class,i);
13210                }
13211                public TerminalNode LEADING_ASTERISK(int i) {
13212                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13213                }
13214                public DescriptionContext(ParserRuleContext parent, int invokingState) {
13215                        super(parent, invokingState);
13216                }
13217                @Override public int getRuleIndex() { return RULE_description; }
13218                @Override
13219                public void enterRule(ParseTreeListener listener) {
13220                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescription(this);
13221                }
13222                @Override
13223                public void exitRule(ParseTreeListener listener) {
13224                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescription(this);
13225                }
13226                @Override
13227                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13228                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescription(this);
13229                        else return visitor.visitChildren(this);
13230                }
13231        }
13232
13233        public final DescriptionContext description() throws RecognitionException {
13234                DescriptionContext _localctx = new DescriptionContext(_ctx, getState());
13235                enterRule(_localctx, 136, RULE_description);
13236                try {
13237                        int _alt;
13238                        enterOuterAlt(_localctx, 1);
13239                        {
13240                        setState(1556); 
13241                        _errHandler.sync(this);
13242                        _alt = 1;
13243                        do {
13244                                switch (_alt) {
13245                                case 1:
13246                                        {
13247                                        setState(1556);
13248                                        switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
13249                                        case 1:
13250                                                {
13251                                                {
13252                                                setState(1548);
13253                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
13254                                                setState(1549); match(LEADING_ASTERISK);
13255                                                }
13256                                                }
13257                                                break;
13258
13259                                        case 2:
13260                                                {
13261                                                setState(1550); htmlComment();
13262                                                }
13263                                                break;
13264
13265                                        case 3:
13266                                                {
13267                                                setState(1551); match(CDATA);
13268                                                }
13269                                                break;
13270
13271                                        case 4:
13272                                                {
13273                                                setState(1552); match(NEWLINE);
13274                                                }
13275                                                break;
13276
13277                                        case 5:
13278                                                {
13279                                                setState(1553); text();
13280                                                }
13281                                                break;
13282
13283                                        case 6:
13284                                                {
13285                                                setState(1554); javadocInlineTag();
13286                                                }
13287                                                break;
13288
13289                                        case 7:
13290                                                {
13291                                                setState(1555); htmlElement();
13292                                                }
13293                                                break;
13294                                        }
13295                                        }
13296                                        break;
13297                                default:
13298                                        throw new NoViableAltException(this);
13299                                }
13300                                setState(1558); 
13301                                _errHandler.sync(this);
13302                                _alt = getInterpreter().adaptivePredict(_input,122,_ctx);
13303                        } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
13304                        }
13305                }
13306                catch (RecognitionException re) {
13307                        _localctx.exception = re;
13308                        _errHandler.reportError(this, re);
13309                        _errHandler.recover(this, re);
13310                }
13311                finally {
13312                        exitRule();
13313                }
13314                return _localctx;
13315        }
13316
13317        public static class ReferenceContext extends ParserRuleContext {
13318                public TerminalNode CLASS(int i) {
13319                        return getToken(JavadocParser.CLASS, i);
13320                }
13321                public List<TerminalNode> DOT() { return getTokens(JavadocParser.DOT); }
13322                public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); }
13323                public TerminalNode PACKAGE() { return getToken(JavadocParser.PACKAGE, 0); }
13324                public ParametersContext parameters() {
13325                        return getRuleContext(ParametersContext.class,0);
13326                }
13327                public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); }
13328                public TerminalNode DOT(int i) {
13329                        return getToken(JavadocParser.DOT, i);
13330                }
13331                public List<TerminalNode> CLASS() { return getTokens(JavadocParser.CLASS); }
13332                public ReferenceContext(ParserRuleContext parent, int invokingState) {
13333                        super(parent, invokingState);
13334                }
13335                @Override public int getRuleIndex() { return RULE_reference; }
13336                @Override
13337                public void enterRule(ParseTreeListener listener) {
13338                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterReference(this);
13339                }
13340                @Override
13341                public void exitRule(ParseTreeListener listener) {
13342                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitReference(this);
13343                }
13344                @Override
13345                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13346                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitReference(this);
13347                        else return visitor.visitChildren(this);
13348                }
13349        }
13350
13351        public final ReferenceContext reference() throws RecognitionException {
13352                ReferenceContext _localctx = new ReferenceContext(_ctx, getState());
13353                enterRule(_localctx, 138, RULE_reference);
13354                int _la;
13355                try {
13356                        int _alt;
13357                        enterOuterAlt(_localctx, 1);
13358                        {
13359                        setState(1597);
13360                        switch (_input.LA(1)) {
13361                        case PACKAGE:
13362                                {
13363                                setState(1560); match(PACKAGE);
13364                                setState(1564);
13365                                _errHandler.sync(this);
13366                                _alt = getInterpreter().adaptivePredict(_input,123,_ctx);
13367                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13368                                        if ( _alt==1 ) {
13369                                                {
13370                                                {
13371                                                setState(1561);
13372                                                _la = _input.LA(1);
13373                                                if ( !(_la==DOT || _la==CLASS) ) {
13374                                                _errHandler.recoverInline(this);
13375                                                }
13376                                                consume();
13377                                                }
13378                                                } 
13379                                        }
13380                                        setState(1566);
13381                                        _errHandler.sync(this);
13382                                        _alt = getInterpreter().adaptivePredict(_input,123,_ctx);
13383                                }
13384                                setState(1568);
13385                                switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
13386                                case 1:
13387                                        {
13388                                        setState(1567); match(HASH);
13389                                        }
13390                                        break;
13391                                }
13392                                setState(1571);
13393                                switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
13394                                case 1:
13395                                        {
13396                                        setState(1570); match(MEMBER);
13397                                        }
13398                                        break;
13399                                }
13400                                setState(1574);
13401                                switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
13402                                case 1:
13403                                        {
13404                                        setState(1573); parameters();
13405                                        }
13406                                        break;
13407                                }
13408                                }
13409                                break;
13410                        case DOT:
13411                        case CLASS:
13412                                {
13413                                setState(1577); 
13414                                _errHandler.sync(this);
13415                                _alt = 1;
13416                                do {
13417                                        switch (_alt) {
13418                                        case 1:
13419                                                {
13420                                                {
13421                                                setState(1576);
13422                                                _la = _input.LA(1);
13423                                                if ( !(_la==DOT || _la==CLASS) ) {
13424                                                _errHandler.recoverInline(this);
13425                                                }
13426                                                consume();
13427                                                }
13428                                                }
13429                                                break;
13430                                        default:
13431                                                throw new NoViableAltException(this);
13432                                        }
13433                                        setState(1579); 
13434                                        _errHandler.sync(this);
13435                                        _alt = getInterpreter().adaptivePredict(_input,127,_ctx);
13436                                } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
13437                                setState(1582);
13438                                switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) {
13439                                case 1:
13440                                        {
13441                                        setState(1581); match(HASH);
13442                                        }
13443                                        break;
13444                                }
13445                                setState(1585);
13446                                switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
13447                                case 1:
13448                                        {
13449                                        setState(1584); match(MEMBER);
13450                                        }
13451                                        break;
13452                                }
13453                                setState(1588);
13454                                switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
13455                                case 1:
13456                                        {
13457                                        setState(1587); parameters();
13458                                        }
13459                                        break;
13460                                }
13461                                }
13462                                break;
13463                        case HASH:
13464                        case MEMBER:
13465                                {
13466                                setState(1591);
13467                                _la = _input.LA(1);
13468                                if (_la==HASH) {
13469                                        {
13470                                        setState(1590); match(HASH);
13471                                        }
13472                                }
13473
13474                                setState(1593); match(MEMBER);
13475                                setState(1595);
13476                                switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
13477                                case 1:
13478                                        {
13479                                        setState(1594); parameters();
13480                                        }
13481                                        break;
13482                                }
13483                                }
13484                                break;
13485                        default:
13486                                throw new NoViableAltException(this);
13487                        }
13488                        }
13489                }
13490                catch (RecognitionException re) {
13491                        _localctx.exception = re;
13492                        _errHandler.reportError(this, re);
13493                        _errHandler.recover(this, re);
13494                }
13495                finally {
13496                        exitRule();
13497                }
13498                return _localctx;
13499        }
13500
13501        public static class ParametersContext extends ParserRuleContext {
13502                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13503                public TerminalNode ARGUMENT(int i) {
13504                        return getToken(JavadocParser.ARGUMENT, i);
13505                }
13506                public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); }
13507                public TerminalNode NEWLINE(int i) {
13508                        return getToken(JavadocParser.NEWLINE, i);
13509                }
13510                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13511                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13512                public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); }
13513                public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); }
13514                public TerminalNode LEADING_ASTERISK(int i) {
13515                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13516                }
13517                public TerminalNode WS(int i) {
13518                        return getToken(JavadocParser.WS, i);
13519                }
13520                public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); }
13521                public TerminalNode COMMA(int i) {
13522                        return getToken(JavadocParser.COMMA, i);
13523                }
13524                public ParametersContext(ParserRuleContext parent, int invokingState) {
13525                        super(parent, invokingState);
13526                }
13527                @Override public int getRuleIndex() { return RULE_parameters; }
13528                @Override
13529                public void enterRule(ParseTreeListener listener) {
13530                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParameters(this);
13531                }
13532                @Override
13533                public void exitRule(ParseTreeListener listener) {
13534                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParameters(this);
13535                }
13536                @Override
13537                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13538                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParameters(this);
13539                        else return visitor.visitChildren(this);
13540                }
13541        }
13542
13543        public final ParametersContext parameters() throws RecognitionException {
13544                ParametersContext _localctx = new ParametersContext(_ctx, getState());
13545                enterRule(_localctx, 140, RULE_parameters);
13546                int _la;
13547                try {
13548                        enterOuterAlt(_localctx, 1);
13549                        {
13550                        setState(1599); match(LEFT_BRACE);
13551                        setState(1603);
13552                        _errHandler.sync(this);
13553                        _la = _input.LA(1);
13554                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) {
13555                                {
13556                                {
13557                                setState(1600);
13558                                _la = _input.LA(1);
13559                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) {
13560                                _errHandler.recoverInline(this);
13561                                }
13562                                consume();
13563                                }
13564                                }
13565                                setState(1605);
13566                                _errHandler.sync(this);
13567                                _la = _input.LA(1);
13568                        }
13569                        setState(1606); match(RIGHT_BRACE);
13570                        }
13571                }
13572                catch (RecognitionException re) {
13573                        _localctx.exception = re;
13574                        _errHandler.reportError(this, re);
13575                        _errHandler.recover(this, re);
13576                }
13577                finally {
13578                        exitRule();
13579                }
13580                return _localctx;
13581        }
13582
13583        public static class JavadocTagContext extends ParserRuleContext {
13584                public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); }
13585                public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); }
13586                public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); }
13587                public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); }
13588                public TerminalNode STRING(int i) {
13589                        return getToken(JavadocParser.STRING, i);
13590                }
13591                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13592                public List<HtmlElementContext> htmlElement() {
13593                        return getRuleContexts(HtmlElementContext.class);
13594                }
13595                public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); }
13596                public TerminalNode WS(int i) {
13597                        return getToken(JavadocParser.WS, i);
13598                }
13599                public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); }
13600                public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); }
13601                public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); }
13602                public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); }
13603                public TerminalNode NEWLINE(int i) {
13604                        return getToken(JavadocParser.NEWLINE, i);
13605                }
13606                public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); }
13607                public DescriptionContext description() {
13608                        return getRuleContext(DescriptionContext.class,0);
13609                }
13610                public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); }
13611                public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); }
13612                public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); }
13613                public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); }
13614                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13615                public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); }
13616                public HtmlElementContext htmlElement(int i) {
13617                        return getRuleContext(HtmlElementContext.class,i);
13618                }
13619                public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); }
13620                public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); }
13621                public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); }
13622                public List<TerminalNode> STRING() { return getTokens(JavadocParser.STRING); }
13623                public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); }
13624                public ReferenceContext reference() {
13625                        return getRuleContext(ReferenceContext.class,0);
13626                }
13627                public JavadocTagContext(ParserRuleContext parent, int invokingState) {
13628                        super(parent, invokingState);
13629                }
13630                @Override public int getRuleIndex() { return RULE_javadocTag; }
13631                @Override
13632                public void enterRule(ParseTreeListener listener) {
13633                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocTag(this);
13634                }
13635                @Override
13636                public void exitRule(ParseTreeListener listener) {
13637                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocTag(this);
13638                }
13639                @Override
13640                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13641                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocTag(this);
13642                        else return visitor.visitChildren(this);
13643                }
13644        }
13645
13646        public final JavadocTagContext javadocTag() throws RecognitionException {
13647                JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState());
13648                enterRule(_localctx, 142, RULE_javadocTag);
13649                int _la;
13650                try {
13651                        int _alt;
13652                        setState(1802);
13653                        switch (_input.LA(1)) {
13654                        case AUTHOR_LITERAL:
13655                                enterOuterAlt(_localctx, 1);
13656                                {
13657                                setState(1608); match(AUTHOR_LITERAL);
13658                                setState(1612);
13659                                _errHandler.sync(this);
13660                                _alt = getInterpreter().adaptivePredict(_input,135,_ctx);
13661                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13662                                        if ( _alt==1 ) {
13663                                                {
13664                                                {
13665                                                setState(1609);
13666                                                _la = _input.LA(1);
13667                                                if ( !(_la==WS || _la==NEWLINE) ) {
13668                                                _errHandler.recoverInline(this);
13669                                                }
13670                                                consume();
13671                                                }
13672                                                } 
13673                                        }
13674                                        setState(1614);
13675                                        _errHandler.sync(this);
13676                                        _alt = getInterpreter().adaptivePredict(_input,135,_ctx);
13677                                }
13678                                setState(1616);
13679                                switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
13680                                case 1:
13681                                        {
13682                                        setState(1615); description();
13683                                        }
13684                                        break;
13685                                }
13686                                }
13687                                break;
13688                        case DEPRECATED_LITERAL:
13689                                enterOuterAlt(_localctx, 2);
13690                                {
13691                                setState(1618); match(DEPRECATED_LITERAL);
13692                                setState(1622);
13693                                _errHandler.sync(this);
13694                                _alt = getInterpreter().adaptivePredict(_input,137,_ctx);
13695                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13696                                        if ( _alt==1 ) {
13697                                                {
13698                                                {
13699                                                setState(1619);
13700                                                _la = _input.LA(1);
13701                                                if ( !(_la==WS || _la==NEWLINE) ) {
13702                                                _errHandler.recoverInline(this);
13703                                                }
13704                                                consume();
13705                                                }
13706                                                } 
13707                                        }
13708                                        setState(1624);
13709                                        _errHandler.sync(this);
13710                                        _alt = getInterpreter().adaptivePredict(_input,137,_ctx);
13711                                }
13712                                setState(1626);
13713                                switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) {
13714                                case 1:
13715                                        {
13716                                        setState(1625); description();
13717                                        }
13718                                        break;
13719                                }
13720                                }
13721                                break;
13722                        case EXCEPTION_LITERAL:
13723                                enterOuterAlt(_localctx, 3);
13724                                {
13725                                setState(1628); match(EXCEPTION_LITERAL);
13726                                setState(1632);
13727                                _errHandler.sync(this);
13728                                _alt = getInterpreter().adaptivePredict(_input,139,_ctx);
13729                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13730                                        if ( _alt==1 ) {
13731                                                {
13732                                                {
13733                                                setState(1629);
13734                                                _la = _input.LA(1);
13735                                                if ( !(_la==WS || _la==NEWLINE) ) {
13736                                                _errHandler.recoverInline(this);
13737                                                }
13738                                                consume();
13739                                                }
13740                                                } 
13741                                        }
13742                                        setState(1634);
13743                                        _errHandler.sync(this);
13744                                        _alt = getInterpreter().adaptivePredict(_input,139,_ctx);
13745                                }
13746                                setState(1636);
13747                                switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
13748                                case 1:
13749                                        {
13750                                        setState(1635); match(CLASS_NAME);
13751                                        }
13752                                        break;
13753                                }
13754                                setState(1641);
13755                                _errHandler.sync(this);
13756                                _alt = getInterpreter().adaptivePredict(_input,141,_ctx);
13757                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13758                                        if ( _alt==1 ) {
13759                                                {
13760                                                {
13761                                                setState(1638);
13762                                                _la = _input.LA(1);
13763                                                if ( !(_la==WS || _la==NEWLINE) ) {
13764                                                _errHandler.recoverInline(this);
13765                                                }
13766                                                consume();
13767                                                }
13768                                                } 
13769                                        }
13770                                        setState(1643);
13771                                        _errHandler.sync(this);
13772                                        _alt = getInterpreter().adaptivePredict(_input,141,_ctx);
13773                                }
13774                                setState(1645);
13775                                switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
13776                                case 1:
13777                                        {
13778                                        setState(1644); description();
13779                                        }
13780                                        break;
13781                                }
13782                                }
13783                                break;
13784                        case PARAM_LITERAL:
13785                                enterOuterAlt(_localctx, 4);
13786                                {
13787                                setState(1647); match(PARAM_LITERAL);
13788                                setState(1651);
13789                                _errHandler.sync(this);
13790                                _alt = getInterpreter().adaptivePredict(_input,143,_ctx);
13791                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13792                                        if ( _alt==1 ) {
13793                                                {
13794                                                {
13795                                                setState(1648);
13796                                                _la = _input.LA(1);
13797                                                if ( !(_la==WS || _la==NEWLINE) ) {
13798                                                _errHandler.recoverInline(this);
13799                                                }
13800                                                consume();
13801                                                }
13802                                                } 
13803                                        }
13804                                        setState(1653);
13805                                        _errHandler.sync(this);
13806                                        _alt = getInterpreter().adaptivePredict(_input,143,_ctx);
13807                                }
13808                                setState(1655);
13809                                switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) {
13810                                case 1:
13811                                        {
13812                                        setState(1654); match(PARAMETER_NAME);
13813                                        }
13814                                        break;
13815                                }
13816                                setState(1660);
13817                                _errHandler.sync(this);
13818                                _alt = getInterpreter().adaptivePredict(_input,145,_ctx);
13819                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13820                                        if ( _alt==1 ) {
13821                                                {
13822                                                {
13823                                                setState(1657);
13824                                                _la = _input.LA(1);
13825                                                if ( !(_la==WS || _la==NEWLINE) ) {
13826                                                _errHandler.recoverInline(this);
13827                                                }
13828                                                consume();
13829                                                }
13830                                                } 
13831                                        }
13832                                        setState(1662);
13833                                        _errHandler.sync(this);
13834                                        _alt = getInterpreter().adaptivePredict(_input,145,_ctx);
13835                                }
13836                                setState(1664);
13837                                switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
13838                                case 1:
13839                                        {
13840                                        setState(1663); description();
13841                                        }
13842                                        break;
13843                                }
13844                                }
13845                                break;
13846                        case RETURN_LITERAL:
13847                                enterOuterAlt(_localctx, 5);
13848                                {
13849                                setState(1666); match(RETURN_LITERAL);
13850                                setState(1670);
13851                                _errHandler.sync(this);
13852                                _alt = getInterpreter().adaptivePredict(_input,147,_ctx);
13853                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13854                                        if ( _alt==1 ) {
13855                                                {
13856                                                {
13857                                                setState(1667);
13858                                                _la = _input.LA(1);
13859                                                if ( !(_la==WS || _la==NEWLINE) ) {
13860                                                _errHandler.recoverInline(this);
13861                                                }
13862                                                consume();
13863                                                }
13864                                                } 
13865                                        }
13866                                        setState(1672);
13867                                        _errHandler.sync(this);
13868                                        _alt = getInterpreter().adaptivePredict(_input,147,_ctx);
13869                                }
13870                                setState(1674);
13871                                switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) {
13872                                case 1:
13873                                        {
13874                                        setState(1673); description();
13875                                        }
13876                                        break;
13877                                }
13878                                }
13879                                break;
13880                        case SEE_LITERAL:
13881                                enterOuterAlt(_localctx, 6);
13882                                {
13883                                setState(1676); match(SEE_LITERAL);
13884                                setState(1680);
13885                                _errHandler.sync(this);
13886                                _alt = getInterpreter().adaptivePredict(_input,149,_ctx);
13887                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13888                                        if ( _alt==1 ) {
13889                                                {
13890                                                {
13891                                                setState(1677);
13892                                                _la = _input.LA(1);
13893                                                if ( !(_la==WS || _la==NEWLINE) ) {
13894                                                _errHandler.recoverInline(this);
13895                                                }
13896                                                consume();
13897                                                }
13898                                                } 
13899                                        }
13900                                        setState(1682);
13901                                        _errHandler.sync(this);
13902                                        _alt = getInterpreter().adaptivePredict(_input,149,_ctx);
13903                                }
13904                                setState(1684);
13905                                switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
13906                                case 1:
13907                                        {
13908                                        setState(1683); reference();
13909                                        }
13910                                        break;
13911                                }
13912                                setState(1690);
13913                                _errHandler.sync(this);
13914                                _alt = getInterpreter().adaptivePredict(_input,152,_ctx);
13915                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13916                                        if ( _alt==1 ) {
13917                                                {
13918                                                setState(1688);
13919                                                switch (_input.LA(1)) {
13920                                                case STRING:
13921                                                        {
13922                                                        setState(1686); match(STRING);
13923                                                        }
13924                                                        break;
13925                                                case OPEN:
13926                                                        {
13927                                                        setState(1687); htmlElement();
13928                                                        }
13929                                                        break;
13930                                                default:
13931                                                        throw new NoViableAltException(this);
13932                                                }
13933                                                } 
13934                                        }
13935                                        setState(1692);
13936                                        _errHandler.sync(this);
13937                                        _alt = getInterpreter().adaptivePredict(_input,152,_ctx);
13938                                }
13939                                setState(1696);
13940                                _errHandler.sync(this);
13941                                _alt = getInterpreter().adaptivePredict(_input,153,_ctx);
13942                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13943                                        if ( _alt==1 ) {
13944                                                {
13945                                                {
13946                                                setState(1693);
13947                                                _la = _input.LA(1);
13948                                                if ( !(_la==WS || _la==NEWLINE) ) {
13949                                                _errHandler.recoverInline(this);
13950                                                }
13951                                                consume();
13952                                                }
13953                                                } 
13954                                        }
13955                                        setState(1698);
13956                                        _errHandler.sync(this);
13957                                        _alt = getInterpreter().adaptivePredict(_input,153,_ctx);
13958                                }
13959                                setState(1700);
13960                                switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
13961                                case 1:
13962                                        {
13963                                        setState(1699); description();
13964                                        }
13965                                        break;
13966                                }
13967                                }
13968                                break;
13969                        case SERIAL_LITERAL:
13970                                enterOuterAlt(_localctx, 7);
13971                                {
13972                                setState(1702); match(SERIAL_LITERAL);
13973                                setState(1706);
13974                                _errHandler.sync(this);
13975                                _alt = getInterpreter().adaptivePredict(_input,155,_ctx);
13976                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13977                                        if ( _alt==1 ) {
13978                                                {
13979                                                {
13980                                                setState(1703);
13981                                                _la = _input.LA(1);
13982                                                if ( !(_la==WS || _la==NEWLINE) ) {
13983                                                _errHandler.recoverInline(this);
13984                                                }
13985                                                consume();
13986                                                }
13987                                                } 
13988                                        }
13989                                        setState(1708);
13990                                        _errHandler.sync(this);
13991                                        _alt = getInterpreter().adaptivePredict(_input,155,_ctx);
13992                                }
13993                                setState(1710);
13994                                switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) {
13995                                case 1:
13996                                        {
13997                                        setState(1709);
13998                                        _la = _input.LA(1);
13999                                        if ( !(_la==LITERAL_INCLUDE || _la==LITERAL_EXCLUDE) ) {
14000                                        _errHandler.recoverInline(this);
14001                                        }
14002                                        consume();
14003                                        }
14004                                        break;
14005                                }
14006                                setState(1713);
14007                                switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) {
14008                                case 1:
14009                                        {
14010                                        setState(1712); description();
14011                                        }
14012                                        break;
14013                                }
14014                                }
14015                                break;
14016                        case SERIAL_DATA_LITERAL:
14017                                enterOuterAlt(_localctx, 8);
14018                                {
14019                                setState(1715); match(SERIAL_DATA_LITERAL);
14020                                setState(1719);
14021                                _errHandler.sync(this);
14022                                _alt = getInterpreter().adaptivePredict(_input,158,_ctx);
14023                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14024                                        if ( _alt==1 ) {
14025                                                {
14026                                                {
14027                                                setState(1716);
14028                                                _la = _input.LA(1);
14029                                                if ( !(_la==WS || _la==NEWLINE) ) {
14030                                                _errHandler.recoverInline(this);
14031                                                }
14032                                                consume();
14033                                                }
14034                                                } 
14035                                        }
14036                                        setState(1721);
14037                                        _errHandler.sync(this);
14038                                        _alt = getInterpreter().adaptivePredict(_input,158,_ctx);
14039                                }
14040                                setState(1723);
14041                                switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
14042                                case 1:
14043                                        {
14044                                        setState(1722); description();
14045                                        }
14046                                        break;
14047                                }
14048                                }
14049                                break;
14050                        case SERIAL_FIELD_LITERAL:
14051                                enterOuterAlt(_localctx, 9);
14052                                {
14053                                setState(1725); match(SERIAL_FIELD_LITERAL);
14054                                setState(1729);
14055                                _errHandler.sync(this);
14056                                _alt = getInterpreter().adaptivePredict(_input,160,_ctx);
14057                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14058                                        if ( _alt==1 ) {
14059                                                {
14060                                                {
14061                                                setState(1726);
14062                                                _la = _input.LA(1);
14063                                                if ( !(_la==WS || _la==NEWLINE) ) {
14064                                                _errHandler.recoverInline(this);
14065                                                }
14066                                                consume();
14067                                                }
14068                                                } 
14069                                        }
14070                                        setState(1731);
14071                                        _errHandler.sync(this);
14072                                        _alt = getInterpreter().adaptivePredict(_input,160,_ctx);
14073                                }
14074                                setState(1733);
14075                                switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) {
14076                                case 1:
14077                                        {
14078                                        setState(1732); match(FIELD_NAME);
14079                                        }
14080                                        break;
14081                                }
14082                                setState(1738);
14083                                _errHandler.sync(this);
14084                                _alt = getInterpreter().adaptivePredict(_input,162,_ctx);
14085                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14086                                        if ( _alt==1 ) {
14087                                                {
14088                                                {
14089                                                setState(1735);
14090                                                _la = _input.LA(1);
14091                                                if ( !(_la==WS || _la==NEWLINE) ) {
14092                                                _errHandler.recoverInline(this);
14093                                                }
14094                                                consume();
14095                                                }
14096                                                } 
14097                                        }
14098                                        setState(1740);
14099                                        _errHandler.sync(this);
14100                                        _alt = getInterpreter().adaptivePredict(_input,162,_ctx);
14101                                }
14102                                setState(1742);
14103                                switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) {
14104                                case 1:
14105                                        {
14106                                        setState(1741); match(FIELD_TYPE);
14107                                        }
14108                                        break;
14109                                }
14110                                setState(1747);
14111                                _errHandler.sync(this);
14112                                _alt = getInterpreter().adaptivePredict(_input,164,_ctx);
14113                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14114                                        if ( _alt==1 ) {
14115                                                {
14116                                                {
14117                                                setState(1744);
14118                                                _la = _input.LA(1);
14119                                                if ( !(_la==WS || _la==NEWLINE) ) {
14120                                                _errHandler.recoverInline(this);
14121                                                }
14122                                                consume();
14123                                                }
14124                                                } 
14125                                        }
14126                                        setState(1749);
14127                                        _errHandler.sync(this);
14128                                        _alt = getInterpreter().adaptivePredict(_input,164,_ctx);
14129                                }
14130                                setState(1751);
14131                                switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) {
14132                                case 1:
14133                                        {
14134                                        setState(1750); description();
14135                                        }
14136                                        break;
14137                                }
14138                                }
14139                                break;
14140                        case SINCE_LITERAL:
14141                                enterOuterAlt(_localctx, 10);
14142                                {
14143                                setState(1753); match(SINCE_LITERAL);
14144                                setState(1757);
14145                                _errHandler.sync(this);
14146                                _alt = getInterpreter().adaptivePredict(_input,166,_ctx);
14147                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14148                                        if ( _alt==1 ) {
14149                                                {
14150                                                {
14151                                                setState(1754);
14152                                                _la = _input.LA(1);
14153                                                if ( !(_la==WS || _la==NEWLINE) ) {
14154                                                _errHandler.recoverInline(this);
14155                                                }
14156                                                consume();
14157                                                }
14158                                                } 
14159                                        }
14160                                        setState(1759);
14161                                        _errHandler.sync(this);
14162                                        _alt = getInterpreter().adaptivePredict(_input,166,_ctx);
14163                                }
14164                                setState(1761);
14165                                switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) {
14166                                case 1:
14167                                        {
14168                                        setState(1760); description();
14169                                        }
14170                                        break;
14171                                }
14172                                }
14173                                break;
14174                        case THROWS_LITERAL:
14175                                enterOuterAlt(_localctx, 11);
14176                                {
14177                                setState(1763); match(THROWS_LITERAL);
14178                                setState(1767);
14179                                _errHandler.sync(this);
14180                                _alt = getInterpreter().adaptivePredict(_input,168,_ctx);
14181                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14182                                        if ( _alt==1 ) {
14183                                                {
14184                                                {
14185                                                setState(1764);
14186                                                _la = _input.LA(1);
14187                                                if ( !(_la==WS || _la==NEWLINE) ) {
14188                                                _errHandler.recoverInline(this);
14189                                                }
14190                                                consume();
14191                                                }
14192                                                } 
14193                                        }
14194                                        setState(1769);
14195                                        _errHandler.sync(this);
14196                                        _alt = getInterpreter().adaptivePredict(_input,168,_ctx);
14197                                }
14198                                setState(1771);
14199                                switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
14200                                case 1:
14201                                        {
14202                                        setState(1770); match(CLASS_NAME);
14203                                        }
14204                                        break;
14205                                }
14206                                setState(1776);
14207                                _errHandler.sync(this);
14208                                _alt = getInterpreter().adaptivePredict(_input,170,_ctx);
14209                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14210                                        if ( _alt==1 ) {
14211                                                {
14212                                                {
14213                                                setState(1773);
14214                                                _la = _input.LA(1);
14215                                                if ( !(_la==WS || _la==NEWLINE) ) {
14216                                                _errHandler.recoverInline(this);
14217                                                }
14218                                                consume();
14219                                                }
14220                                                } 
14221                                        }
14222                                        setState(1778);
14223                                        _errHandler.sync(this);
14224                                        _alt = getInterpreter().adaptivePredict(_input,170,_ctx);
14225                                }
14226                                setState(1780);
14227                                switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) {
14228                                case 1:
14229                                        {
14230                                        setState(1779); description();
14231                                        }
14232                                        break;
14233                                }
14234                                }
14235                                break;
14236                        case VERSION_LITERAL:
14237                                enterOuterAlt(_localctx, 12);
14238                                {
14239                                setState(1782); match(VERSION_LITERAL);
14240                                setState(1786);
14241                                _errHandler.sync(this);
14242                                _alt = getInterpreter().adaptivePredict(_input,172,_ctx);
14243                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14244                                        if ( _alt==1 ) {
14245                                                {
14246                                                {
14247                                                setState(1783);
14248                                                _la = _input.LA(1);
14249                                                if ( !(_la==WS || _la==NEWLINE) ) {
14250                                                _errHandler.recoverInline(this);
14251                                                }
14252                                                consume();
14253                                                }
14254                                                } 
14255                                        }
14256                                        setState(1788);
14257                                        _errHandler.sync(this);
14258                                        _alt = getInterpreter().adaptivePredict(_input,172,_ctx);
14259                                }
14260                                setState(1790);
14261                                switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) {
14262                                case 1:
14263                                        {
14264                                        setState(1789); description();
14265                                        }
14266                                        break;
14267                                }
14268                                }
14269                                break;
14270                        case CUSTOM_NAME:
14271                                enterOuterAlt(_localctx, 13);
14272                                {
14273                                setState(1792); match(CUSTOM_NAME);
14274                                setState(1796);
14275                                _errHandler.sync(this);
14276                                _alt = getInterpreter().adaptivePredict(_input,174,_ctx);
14277                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14278                                        if ( _alt==1 ) {
14279                                                {
14280                                                {
14281                                                setState(1793);
14282                                                _la = _input.LA(1);
14283                                                if ( !(_la==WS || _la==NEWLINE) ) {
14284                                                _errHandler.recoverInline(this);
14285                                                }
14286                                                consume();
14287                                                }
14288                                                } 
14289                                        }
14290                                        setState(1798);
14291                                        _errHandler.sync(this);
14292                                        _alt = getInterpreter().adaptivePredict(_input,174,_ctx);
14293                                }
14294                                setState(1800);
14295                                switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) {
14296                                case 1:
14297                                        {
14298                                        setState(1799); description();
14299                                        }
14300                                        break;
14301                                }
14302                                }
14303                                break;
14304                        default:
14305                                throw new NoViableAltException(this);
14306                        }
14307                }
14308                catch (RecognitionException re) {
14309                        _localctx.exception = re;
14310                        _errHandler.reportError(this, re);
14311                        _errHandler.recover(this, re);
14312                }
14313                finally {
14314                        exitRule();
14315                }
14316                return _localctx;
14317        }
14318
14319        public static class JavadocInlineTagContext extends ParserRuleContext {
14320                public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); }
14321                public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); }
14322                public TerminalNode NEWLINE(int i) {
14323                        return getToken(JavadocParser.NEWLINE, i);
14324                }
14325                public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); }
14326                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
14327                public TextContext text(int i) {
14328                        return getRuleContext(TextContext.class,i);
14329                }
14330                public DescriptionContext description() {
14331                        return getRuleContext(DescriptionContext.class,0);
14332                }
14333                public TerminalNode WS(int i) {
14334                        return getToken(JavadocParser.WS, i);
14335                }
14336                public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); }
14337                public List<TextContext> text() {
14338                        return getRuleContexts(TextContext.class);
14339                }
14340                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
14341                public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); }
14342                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
14343                public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); }
14344                public TerminalNode LEADING_ASTERISK(int i) {
14345                        return getToken(JavadocParser.LEADING_ASTERISK, i);
14346                }
14347                public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); }
14348                public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); }
14349                public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); }
14350                public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); }
14351                public ReferenceContext reference() {
14352                        return getRuleContext(ReferenceContext.class,0);
14353                }
14354                public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) {
14355                        super(parent, invokingState);
14356                }
14357                @Override public int getRuleIndex() { return RULE_javadocInlineTag; }
14358                @Override
14359                public void enterRule(ParseTreeListener listener) {
14360                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocInlineTag(this);
14361                }
14362                @Override
14363                public void exitRule(ParseTreeListener listener) {
14364                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocInlineTag(this);
14365                }
14366                @Override
14367                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
14368                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocInlineTag(this);
14369                        else return visitor.visitChildren(this);
14370                }
14371        }
14372
14373        public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException {
14374                JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState());
14375                enterRule(_localctx, 144, RULE_javadocInlineTag);
14376                int _la;
14377                try {
14378                        int _alt;
14379                        enterOuterAlt(_localctx, 1);
14380                        {
14381                        setState(1804); match(JAVADOC_INLINE_TAG_START);
14382                        setState(1880);
14383                        switch (_input.LA(1)) {
14384                        case CODE_LITERAL:
14385                                {
14386                                setState(1805); match(CODE_LITERAL);
14387                                setState(1812);
14388                                _errHandler.sync(this);
14389                                _la = _input.LA(1);
14390                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
14391                                        {
14392                                        setState(1810);
14393                                        switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) {
14394                                        case 1:
14395                                                {
14396                                                setState(1806); match(WS);
14397                                                }
14398                                                break;
14399
14400                                        case 2:
14401                                                {
14402                                                setState(1807); match(NEWLINE);
14403                                                }
14404                                                break;
14405
14406                                        case 3:
14407                                                {
14408                                                setState(1808); match(LEADING_ASTERISK);
14409                                                }
14410                                                break;
14411
14412                                        case 4:
14413                                                {
14414                                                setState(1809); text();
14415                                                }
14416                                                break;
14417                                        }
14418                                        }
14419                                        setState(1814);
14420                                        _errHandler.sync(this);
14421                                        _la = _input.LA(1);
14422                                }
14423                                }
14424                                break;
14425                        case DOC_ROOT_LITERAL:
14426                                {
14427                                setState(1815); match(DOC_ROOT_LITERAL);
14428                                setState(1819);
14429                                _errHandler.sync(this);
14430                                _la = _input.LA(1);
14431                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
14432                                        {
14433                                        {
14434                                        setState(1816);
14435                                        _la = _input.LA(1);
14436                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
14437                                        _errHandler.recoverInline(this);
14438                                        }
14439                                        consume();
14440                                        }
14441                                        }
14442                                        setState(1821);
14443                                        _errHandler.sync(this);
14444                                        _la = _input.LA(1);
14445                                }
14446                                }
14447                                break;
14448                        case INHERIT_DOC_LITERAL:
14449                                {
14450                                setState(1822); match(INHERIT_DOC_LITERAL);
14451                                setState(1826);
14452                                _errHandler.sync(this);
14453                                _la = _input.LA(1);
14454                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
14455                                        {
14456                                        {
14457                                        setState(1823);
14458                                        _la = _input.LA(1);
14459                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
14460                                        _errHandler.recoverInline(this);
14461                                        }
14462                                        consume();
14463                                        }
14464                                        }
14465                                        setState(1828);
14466                                        _errHandler.sync(this);
14467                                        _la = _input.LA(1);
14468                                }
14469                                }
14470                                break;
14471                        case LINK_LITERAL:
14472                                {
14473                                setState(1829); match(LINK_LITERAL);
14474                                setState(1833);
14475                                _errHandler.sync(this);
14476                                _la = _input.LA(1);
14477                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
14478                                        {
14479                                        {
14480                                        setState(1830);
14481                                        _la = _input.LA(1);
14482                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
14483                                        _errHandler.recoverInline(this);
14484                                        }
14485                                        consume();
14486                                        }
14487                                        }
14488                                        setState(1835);
14489                                        _errHandler.sync(this);
14490                                        _la = _input.LA(1);
14491                                }
14492                                setState(1836); reference();
14493                                setState(1838);
14494                                switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) {
14495                                case 1:
14496                                        {
14497                                        setState(1837); description();
14498                                        }
14499                                        break;
14500                                }
14501                                }
14502                                break;
14503                        case LINKPLAIN_LITERAL:
14504                                {
14505                                setState(1840); match(LINKPLAIN_LITERAL);
14506                                setState(1844);
14507                                _errHandler.sync(this);
14508                                _la = _input.LA(1);
14509                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
14510                                        {
14511                                        {
14512                                        setState(1841);
14513                                        _la = _input.LA(1);
14514                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
14515                                        _errHandler.recoverInline(this);
14516                                        }
14517                                        consume();
14518                                        }
14519                                        }
14520                                        setState(1846);
14521                                        _errHandler.sync(this);
14522                                        _la = _input.LA(1);
14523                                }
14524                                setState(1847); reference();
14525                                setState(1849);
14526                                switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) {
14527                                case 1:
14528                                        {
14529                                        setState(1848); description();
14530                                        }
14531                                        break;
14532                                }
14533                                }
14534                                break;
14535                        case LITERAL_LITERAL:
14536                                {
14537                                setState(1851); match(LITERAL_LITERAL);
14538                                setState(1858);
14539                                _errHandler.sync(this);
14540                                _la = _input.LA(1);
14541                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
14542                                        {
14543                                        setState(1856);
14544                                        switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) {
14545                                        case 1:
14546                                                {
14547                                                setState(1852); match(WS);
14548                                                }
14549                                                break;
14550
14551                                        case 2:
14552                                                {
14553                                                setState(1853); match(NEWLINE);
14554                                                }
14555                                                break;
14556
14557                                        case 3:
14558                                                {
14559                                                setState(1854); match(LEADING_ASTERISK);
14560                                                }
14561                                                break;
14562
14563                                        case 4:
14564                                                {
14565                                                setState(1855); text();
14566                                                }
14567                                                break;
14568                                        }
14569                                        }
14570                                        setState(1860);
14571                                        _errHandler.sync(this);
14572                                        _la = _input.LA(1);
14573                                }
14574                                }
14575                                break;
14576                        case VALUE_LITERAL:
14577                                {
14578                                setState(1861); match(VALUE_LITERAL);
14579                                setState(1865);
14580                                _errHandler.sync(this);
14581                                _la = _input.LA(1);
14582                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
14583                                        {
14584                                        {
14585                                        setState(1862);
14586                                        _la = _input.LA(1);
14587                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
14588                                        _errHandler.recoverInline(this);
14589                                        }
14590                                        consume();
14591                                        }
14592                                        }
14593                                        setState(1867);
14594                                        _errHandler.sync(this);
14595                                        _la = _input.LA(1);
14596                                }
14597                                setState(1869);
14598                                _la = _input.LA(1);
14599                                if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << DOT) | (1L << HASH) | (1L << CLASS) | (1L << MEMBER))) != 0)) {
14600                                        {
14601                                        setState(1868); reference();
14602                                        }
14603                                }
14604
14605                                }
14606                                break;
14607                        case CUSTOM_NAME:
14608                                {
14609                                setState(1871); match(CUSTOM_NAME);
14610                                setState(1873); 
14611                                _errHandler.sync(this);
14612                                _alt = 1;
14613                                do {
14614                                        switch (_alt) {
14615                                        case 1:
14616                                                {
14617                                                {
14618                                                setState(1872);
14619                                                _la = _input.LA(1);
14620                                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
14621                                                _errHandler.recoverInline(this);
14622                                                }
14623                                                consume();
14624                                                }
14625                                                }
14626                                                break;
14627                                        default:
14628                                                throw new NoViableAltException(this);
14629                                        }
14630                                        setState(1875); 
14631                                        _errHandler.sync(this);
14632                                        _alt = getInterpreter().adaptivePredict(_input,189,_ctx);
14633                                } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
14634                                setState(1878);
14635                                switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) {
14636                                case 1:
14637                                        {
14638                                        setState(1877); description();
14639                                        }
14640                                        break;
14641                                }
14642                                }
14643                                break;
14644                        default:
14645                                throw new NoViableAltException(this);
14646                        }
14647                        setState(1882); match(JAVADOC_INLINE_TAG_END);
14648                        }
14649                }
14650                catch (RecognitionException re) {
14651                        _localctx.exception = re;
14652                        _errHandler.reportError(this, re);
14653                        _errHandler.recover(this, re);
14654                }
14655                finally {
14656                        exitRule();
14657                }
14658                return _localctx;
14659        }
14660
14661        public static class HtmlCommentContext extends ParserRuleContext {
14662                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
14663                public List<TextContext> text() {
14664                        return getRuleContexts(TextContext.class);
14665                }
14666                public TerminalNode NEWLINE(int i) {
14667                        return getToken(JavadocParser.NEWLINE, i);
14668                }
14669                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
14670                public TextContext text(int i) {
14671                        return getRuleContext(TextContext.class,i);
14672                }
14673                public TerminalNode LEADING_ASTERISK(int i) {
14674                        return getToken(JavadocParser.LEADING_ASTERISK, i);
14675                }
14676                public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); }
14677                public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); }
14678                public HtmlCommentContext(ParserRuleContext parent, int invokingState) {
14679                        super(parent, invokingState);
14680                }
14681                @Override public int getRuleIndex() { return RULE_htmlComment; }
14682                @Override
14683                public void enterRule(ParseTreeListener listener) {
14684                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlComment(this);
14685                }
14686                @Override
14687                public void exitRule(ParseTreeListener listener) {
14688                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlComment(this);
14689                }
14690                @Override
14691                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
14692                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlComment(this);
14693                        else return visitor.visitChildren(this);
14694                }
14695        }
14696
14697        public final HtmlCommentContext htmlComment() throws RecognitionException {
14698                HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState());
14699                enterRule(_localctx, 146, RULE_htmlComment);
14700                int _la;
14701                try {
14702                        enterOuterAlt(_localctx, 1);
14703                        {
14704                        setState(1884); match(HTML_COMMENT_START);
14705                        setState(1890);
14706                        _errHandler.sync(this);
14707                        _la = _input.LA(1);
14708                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
14709                                {
14710                                setState(1888);
14711                                switch (_input.LA(1)) {
14712                                case WS:
14713                                case CHAR:
14714                                        {
14715                                        setState(1885); text();
14716                                        }
14717                                        break;
14718                                case NEWLINE:
14719                                        {
14720                                        setState(1886); match(NEWLINE);
14721                                        }
14722                                        break;
14723                                case LEADING_ASTERISK:
14724                                        {
14725                                        setState(1887); match(LEADING_ASTERISK);
14726                                        }
14727                                        break;
14728                                default:
14729                                        throw new NoViableAltException(this);
14730                                }
14731                                }
14732                                setState(1892);
14733                                _errHandler.sync(this);
14734                                _la = _input.LA(1);
14735                        }
14736                        setState(1893); match(HTML_COMMENT_END);
14737                        }
14738                }
14739                catch (RecognitionException re) {
14740                        _localctx.exception = re;
14741                        _errHandler.reportError(this, re);
14742                        _errHandler.recover(this, re);
14743                }
14744                finally {
14745                        exitRule();
14746                }
14747                return _localctx;
14748        }
14749
14750        public static class TextContext extends ParserRuleContext {
14751                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
14752                public TerminalNode WS(int i) {
14753                        return getToken(JavadocParser.WS, i);
14754                }
14755                public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); }
14756                public TerminalNode CHAR(int i) {
14757                        return getToken(JavadocParser.CHAR, i);
14758                }
14759                public TextContext(ParserRuleContext parent, int invokingState) {
14760                        super(parent, invokingState);
14761                }
14762                @Override public int getRuleIndex() { return RULE_text; }
14763                @Override
14764                public void enterRule(ParseTreeListener listener) {
14765                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterText(this);
14766                }
14767                @Override
14768                public void exitRule(ParseTreeListener listener) {
14769                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitText(this);
14770                }
14771                @Override
14772                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
14773                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitText(this);
14774                        else return visitor.visitChildren(this);
14775                }
14776        }
14777
14778        public final TextContext text() throws RecognitionException {
14779                TextContext _localctx = new TextContext(_ctx, getState());
14780                enterRule(_localctx, 148, RULE_text);
14781                int _la;
14782                try {
14783                        int _alt;
14784                        enterOuterAlt(_localctx, 1);
14785                        {
14786                        setState(1896); 
14787                        _errHandler.sync(this);
14788                        _alt = 1;
14789                        do {
14790                                switch (_alt) {
14791                                case 1:
14792                                        {
14793                                        {
14794                                        setState(1895);
14795                                        _la = _input.LA(1);
14796                                        if ( !(_la==WS || _la==CHAR) ) {
14797                                        _errHandler.recoverInline(this);
14798                                        }
14799                                        consume();
14800                                        }
14801                                        }
14802                                        break;
14803                                default:
14804                                        throw new NoViableAltException(this);
14805                                }
14806                                setState(1898); 
14807                                _errHandler.sync(this);
14808                                _alt = getInterpreter().adaptivePredict(_input,194,_ctx);
14809                        } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
14810                        }
14811                }
14812                catch (RecognitionException re) {
14813                        _localctx.exception = re;
14814                        _errHandler.reportError(this, re);
14815                        _errHandler.recover(this, re);
14816                }
14817                finally {
14818                        exitRule();
14819                }
14820                return _localctx;
14821        }
14822
14823        public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
14824                switch (ruleIndex) {
14825                case 0: return javadoc_sempred((JavadocContext)_localctx, predIndex);
14826
14827                case 5: return htmlTag_sempred((HtmlTagContext)_localctx, predIndex);
14828
14829                case 8: return paragraph_sempred((ParagraphContext)_localctx, predIndex);
14830
14831                case 11: return li_sempred((LiContext)_localctx, predIndex);
14832
14833                case 14: return tr_sempred((TrContext)_localctx, predIndex);
14834
14835                case 17: return td_sempred((TdContext)_localctx, predIndex);
14836
14837                case 20: return th_sempred((ThContext)_localctx, predIndex);
14838
14839                case 23: return body_sempred((BodyContext)_localctx, predIndex);
14840
14841                case 26: return colgroup_sempred((ColgroupContext)_localctx, predIndex);
14842
14843                case 29: return dd_sempred((DdContext)_localctx, predIndex);
14844
14845                case 32: return dt_sempred((DtContext)_localctx, predIndex);
14846
14847                case 35: return head_sempred((HeadContext)_localctx, predIndex);
14848
14849                case 38: return html_sempred((HtmlContext)_localctx, predIndex);
14850
14851                case 41: return option_sempred((OptionContext)_localctx, predIndex);
14852
14853                case 44: return tbody_sempred((TbodyContext)_localctx, predIndex);
14854
14855                case 47: return tfoot_sempred((TfootContext)_localctx, predIndex);
14856
14857                case 50: return thead_sempred((TheadContext)_localctx, predIndex);
14858
14859                case 68: return description_sempred((DescriptionContext)_localctx, predIndex);
14860                }
14861                return true;
14862        }
14863        private boolean thead_sempred(TheadContext _localctx, int predIndex) {
14864                switch (predIndex) {
14865                case 17: return !isNextJavadocTag();
14866                }
14867                return true;
14868        }
14869        private boolean dt_sempred(DtContext _localctx, int predIndex) {
14870                switch (predIndex) {
14871                case 11: return !isNextJavadocTag();
14872                }
14873                return true;
14874        }
14875        private boolean body_sempred(BodyContext _localctx, int predIndex) {
14876                switch (predIndex) {
14877                case 8: return !isNextJavadocTag();
14878                }
14879                return true;
14880        }
14881        private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) {
14882                switch (predIndex) {
14883                case 3: return !isNextJavadocTag();
14884                }
14885                return true;
14886        }
14887        private boolean tr_sempred(TrContext _localctx, int predIndex) {
14888                switch (predIndex) {
14889                case 5: return !isNextJavadocTag();
14890                }
14891                return true;
14892        }
14893        private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) {
14894                switch (predIndex) {
14895                case 9: return !isNextJavadocTag();
14896                }
14897                return true;
14898        }
14899        private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) {
14900                switch (predIndex) {
14901                case 0: return !isNextJavadocTag();
14902                }
14903                return true;
14904        }
14905        private boolean td_sempred(TdContext _localctx, int predIndex) {
14906                switch (predIndex) {
14907                case 6: return !isNextJavadocTag();
14908                }
14909                return true;
14910        }
14911        private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) {
14912                switch (predIndex) {
14913                case 1: return !isNextJavadocTag();
14914
14915                case 2: return !isNextJavadocTag();
14916                }
14917                return true;
14918        }
14919        private boolean tfoot_sempred(TfootContext _localctx, int predIndex) {
14920                switch (predIndex) {
14921                case 16: return !isNextJavadocTag();
14922                }
14923                return true;
14924        }
14925        private boolean th_sempred(ThContext _localctx, int predIndex) {
14926                switch (predIndex) {
14927                case 7: return !isNextJavadocTag();
14928                }
14929                return true;
14930        }
14931        private boolean li_sempred(LiContext _localctx, int predIndex) {
14932                switch (predIndex) {
14933                case 4: return !isNextJavadocTag();
14934                }
14935                return true;
14936        }
14937        private boolean dd_sempred(DdContext _localctx, int predIndex) {
14938                switch (predIndex) {
14939                case 10: return !isNextJavadocTag();
14940                }
14941                return true;
14942        }
14943        private boolean tbody_sempred(TbodyContext _localctx, int predIndex) {
14944                switch (predIndex) {
14945                case 15: return !isNextJavadocTag();
14946                }
14947                return true;
14948        }
14949        private boolean description_sempred(DescriptionContext _localctx, int predIndex) {
14950                switch (predIndex) {
14951                case 18: return !isNextJavadocTag();
14952                }
14953                return true;
14954        }
14955        private boolean html_sempred(HtmlContext _localctx, int predIndex) {
14956                switch (predIndex) {
14957                case 13: return !isNextJavadocTag();
14958                }
14959                return true;
14960        }
14961        private boolean head_sempred(HeadContext _localctx, int predIndex) {
14962                switch (predIndex) {
14963                case 12: return !isNextJavadocTag();
14964                }
14965                return true;
14966        }
14967        private boolean option_sempred(OptionContext _localctx, int predIndex) {
14968                switch (predIndex) {
14969                case 14: return !isNextJavadocTag();
14970                }
14971                return true;
14972        }
14973
14974        public static final String _serializedATN =
14975                "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3]\u076f\4\2\t\2\4"+
14976                "\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"+
14977                "\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"+
14978                "\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"+
14979                "\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!"+
14980                "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
14981                ",\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"+
14982                "\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="+
14983                "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
14984                "\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"+
14985                "\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"+
14986                "\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"+
14987                "\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"+
14988                "\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"+
14989                "\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"+
14990                "\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"+
14991                "\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"+
14992                "\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"+
14993                "\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"+
14994                "\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"+
14995                "\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"+
14996                "\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"+
14997                "\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"+
14998                "\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"+
14999                "\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"+
15000                "\13\3\13\3\13\3\13\3\13\3\13\7\13\u0180\n\13\f\13\16\13\u0183\13\13\3"+
15001                "\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"+
15002                "\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"+
15003                "\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"+
15004                "\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"+
15005                "\3\16\3\16\7\16\u01c5\n\16\f\16\16\16\u01c8\13\16\3\16\3\16\3\17\3\17"+
15006                "\3\17\3\17\7\17\u01d0\n\17\f\17\16\17\u01d3\13\17\3\17\3\17\3\20\3\20"+
15007                "\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"+
15008                "\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"+
15009                "\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"+
15010                "\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"+
15011                "\21\u020d\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0215\n\22\f\22\16"+
15012                "\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"+
15013                "\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"+
15014                "\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"+
15015                "\3\23\7\23\u0242\n\23\f\23\16\23\u0245\13\23\3\23\3\23\3\24\3\24\3\24"+
15016                "\3\24\3\24\3\24\7\24\u024f\n\24\f\24\16\24\u0252\13\24\3\24\3\24\3\25"+
15017                "\3\25\3\25\3\25\7\25\u025a\n\25\f\25\16\25\u025d\13\25\3\25\3\25\3\26"+
15018                "\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"+
15019                "\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"+
15020                "\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"+
15021                "\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"+
15022                "\f\27\16\27\u0297\13\27\3\27\3\27\3\30\3\30\3\30\3\30\7\30\u029f\n\30"+
15023                "\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"+
15024                "\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"+
15025                "\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"+
15026                "\31\3\31\3\31\7\31\u02cc\n\31\f\31\16\31\u02cf\13\31\3\31\3\31\3\32\3"+
15027                "\32\3\32\3\32\3\32\3\32\7\32\u02d9\n\32\f\32\16\32\u02dc\13\32\3\32\3"+
15028                "\32\3\33\3\33\3\33\3\33\7\33\u02e4\n\33\f\33\16\33\u02e7\13\33\3\33\3"+
15029                "\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"+
15030                "\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"+
15031                "\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"+
15032                "\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"+
15033                "\n\35\f\35\16\35\u0321\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u0329"+
15034                "\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"+
15035                "\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"+
15036                "\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"+
15037                "\37\3\37\3\37\3\37\7\37\u0356\n\37\f\37\16\37\u0359\13\37\3\37\3\37\3"+
15038                " \3 \3 \3 \3 \3 \7 \u0363\n \f \16 \u0366\13 \3 \3 \3!\3!\3!\3!\7!\u036e"+
15039                "\n!\f!\16!\u0371\13!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+
15040                "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+
15041                "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u039b\n\"\f\"\16\"\u039e\13"+
15042                "\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u03a8\n#\f#\16#\u03ab\13#\3#\3#\3$\3$"+
15043                "\3$\3$\7$\u03b3\n$\f$\16$\u03b6\13$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+
15044                "%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+
15045                "%\3%\3%\3%\3%\3%\7%\u03e0\n%\f%\16%\u03e3\13%\3%\3%\3&\3&\3&\3&\3&\3&"+
15046                "\7&\u03ed\n&\f&\16&\u03f0\13&\3&\3&\3\'\3\'\3\'\3\'\7\'\u03f8\n\'\f\'"+
15047                "\16\'\u03fb\13\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+
15048                "\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+
15049                "\7(\u0425\n(\f(\16(\u0428\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u0432\n)\f)\16"+
15050                ")\u0435\13)\3)\3)\3*\3*\3*\3*\7*\u043d\n*\f*\16*\u0440\13*\3*\3*\3+\3"+
15051                "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3"+
15052                "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\7+\u046a\n+\f+\16+\u046d\13+"+
15053                "\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0477\n,\f,\16,\u047a\13,\3,\3,\3-\3-\3-\3"+
15054                "-\7-\u0482\n-\f-\16-\u0485\13-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+
15055                "\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+
15056                "\3.\3.\3.\3.\7.\u04af\n.\f.\16.\u04b2\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/\u04bc"+
15057                "\n/\f/\16/\u04bf\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u04c7\n\60\f\60\16"+
15058                "\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"+
15059                "\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"+
15060                "\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"+
15061                "\3\61\7\61\u04f4\n\61\f\61\16\61\u04f7\13\61\3\61\3\61\3\62\3\62\3\62"+
15062                "\3\62\3\62\3\62\7\62\u0501\n\62\f\62\16\62\u0504\13\62\3\62\3\62\3\63"+
15063                "\3\63\3\63\3\63\7\63\u050c\n\63\f\63\16\63\u050f\13\63\3\63\3\63\3\64"+
15064                "\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"+
15065                "\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"+
15066                "\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"+
15067                "\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"+
15068                "\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"+
15069                "\3\66\7\66\u0557\n\66\f\66\16\66\u055a\13\66\3\66\3\66\3\67\3\67\3\67"+
15070                "\3\67\3\67\3\67\7\67\u0564\n\67\f\67\16\67\u0567\13\67\3\67\3\67\38\3"+
15071                "8\38\38\38\38\78\u0571\n8\f8\168\u0574\138\38\38\39\39\39\39\39\39\79"+
15072                "\u057e\n9\f9\169\u0581\139\39\39\3:\3:\3:\3:\3:\3:\7:\u058b\n:\f:\16:"+
15073                "\u058e\13:\3:\3:\3;\3;\3;\3;\3;\3;\7;\u0598\n;\f;\16;\u059b\13;\3;\3;"+
15074                "\3<\3<\3<\3<\3<\3<\7<\u05a5\n<\f<\16<\u05a8\13<\3<\3<\3=\3=\3=\3=\3=\3"+
15075                "=\7=\u05b2\n=\f=\16=\u05b5\13=\3=\3=\3>\3>\3>\3>\3>\3>\7>\u05bf\n>\f>"+
15076                "\16>\u05c2\13>\3>\3>\3?\3?\3?\3?\3?\3?\7?\u05cc\n?\f?\16?\u05cf\13?\3"+
15077                "?\3?\3@\3@\3@\3@\3@\3@\7@\u05d9\n@\f@\16@\u05dc\13@\3@\3@\3A\3A\3A\3A"+
15078                "\3A\3A\7A\u05e6\nA\fA\16A\u05e9\13A\3A\3A\3B\3B\3B\3B\3B\3B\7B\u05f3\n"+
15079                "B\fB\16B\u05f6\13B\3B\3B\3C\3C\3C\3C\3C\3C\7C\u0600\nC\fC\16C\u0603\13"+
15080                "C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\6F\u0617\nF\r"+
15081                "F\16F\u0618\3G\3G\7G\u061d\nG\fG\16G\u0620\13G\3G\5G\u0623\nG\3G\5G\u0626"+
15082                "\nG\3G\5G\u0629\nG\3G\6G\u062c\nG\rG\16G\u062d\3G\5G\u0631\nG\3G\5G\u0634"+
15083                "\nG\3G\5G\u0637\nG\3G\5G\u063a\nG\3G\3G\5G\u063e\nG\5G\u0640\nG\3H\3H"+
15084                "\7H\u0644\nH\fH\16H\u0647\13H\3H\3H\3I\3I\7I\u064d\nI\fI\16I\u0650\13"+
15085                "I\3I\5I\u0653\nI\3I\3I\7I\u0657\nI\fI\16I\u065a\13I\3I\5I\u065d\nI\3I"+
15086                "\3I\7I\u0661\nI\fI\16I\u0664\13I\3I\5I\u0667\nI\3I\7I\u066a\nI\fI\16I"+
15087                "\u066d\13I\3I\5I\u0670\nI\3I\3I\7I\u0674\nI\fI\16I\u0677\13I\3I\5I\u067a"+
15088                "\nI\3I\7I\u067d\nI\fI\16I\u0680\13I\3I\5I\u0683\nI\3I\3I\7I\u0687\nI\f"+
15089                "I\16I\u068a\13I\3I\5I\u068d\nI\3I\3I\7I\u0691\nI\fI\16I\u0694\13I\3I\5"+
15090                "I\u0697\nI\3I\3I\7I\u069b\nI\fI\16I\u069e\13I\3I\7I\u06a1\nI\fI\16I\u06a4"+
15091                "\13I\3I\5I\u06a7\nI\3I\3I\7I\u06ab\nI\fI\16I\u06ae\13I\3I\5I\u06b1\nI"+
15092                "\3I\5I\u06b4\nI\3I\3I\7I\u06b8\nI\fI\16I\u06bb\13I\3I\5I\u06be\nI\3I\3"+
15093                "I\7I\u06c2\nI\fI\16I\u06c5\13I\3I\5I\u06c8\nI\3I\7I\u06cb\nI\fI\16I\u06ce"+
15094                "\13I\3I\5I\u06d1\nI\3I\7I\u06d4\nI\fI\16I\u06d7\13I\3I\5I\u06da\nI\3I"+
15095                "\3I\7I\u06de\nI\fI\16I\u06e1\13I\3I\5I\u06e4\nI\3I\3I\7I\u06e8\nI\fI\16"+
15096                "I\u06eb\13I\3I\5I\u06ee\nI\3I\7I\u06f1\nI\fI\16I\u06f4\13I\3I\5I\u06f7"+
15097                "\nI\3I\3I\7I\u06fb\nI\fI\16I\u06fe\13I\3I\5I\u0701\nI\3I\3I\7I\u0705\n"+
15098                "I\fI\16I\u0708\13I\3I\5I\u070b\nI\5I\u070d\nI\3J\3J\3J\3J\3J\3J\7J\u0715"+
15099                "\nJ\fJ\16J\u0718\13J\3J\3J\7J\u071c\nJ\fJ\16J\u071f\13J\3J\3J\7J\u0723"+
15100                "\nJ\fJ\16J\u0726\13J\3J\3J\7J\u072a\nJ\fJ\16J\u072d\13J\3J\3J\5J\u0731"+
15101                "\nJ\3J\3J\7J\u0735\nJ\fJ\16J\u0738\13J\3J\3J\5J\u073c\nJ\3J\3J\3J\3J\3"+
15102                "J\7J\u0743\nJ\fJ\16J\u0746\13J\3J\3J\7J\u074a\nJ\fJ\16J\u074d\13J\3J\5"+
15103                "J\u0750\nJ\3J\3J\6J\u0754\nJ\rJ\16J\u0755\3J\5J\u0759\nJ\5J\u075b\nJ\3"+
15104                "J\3J\3K\3K\3K\3K\7K\u0763\nK\fK\16K\u0766\13K\3K\3K\3L\6L\u076b\nL\rL"+
15105                "\16L\u076c\3L\2\2M\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60"+
15106                "\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086"+
15107                "\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\2\13\5\2\3\3\6\6\b\b"+
15108                "\4\2=KYY\3\29:\3\2LX\4\2\37\37!!\6\2\3\3\6\6\b\b&\'\4\2\6\6\b\b\3\2\30"+
15109                "\31\4\2\6\6\32\32\u0a86\2\u00a2\3\2\2\2\4\u00e5\3\2\2\2\6\u00e7\3\2\2"+
15110                "\2\b\u00f4\3\2\2\2\n\u00ff\3\2\2\2\f\u0132\3\2\2\2\16\u0134\3\2\2\2\20"+
15111                "\u0141\3\2\2\2\22\u014c\3\2\2\2\24\u0179\3\2\2\2\26\u0186\3\2\2\2\30\u0191"+
15112                "\3\2\2\2\32\u01be\3\2\2\2\34\u01cb\3\2\2\2\36\u01d6\3\2\2\2 \u0203\3\2"+
15113                "\2\2\"\u0210\3\2\2\2$\u021b\3\2\2\2&\u0248\3\2\2\2(\u0255\3\2\2\2*\u0260"+
15114                "\3\2\2\2,\u028d\3\2\2\2.\u029a\3\2\2\2\60\u02a5\3\2\2\2\62\u02d2\3\2\2"+
15115                "\2\64\u02df\3\2\2\2\66\u02ea\3\2\2\28\u0317\3\2\2\2:\u0324\3\2\2\2<\u032f"+
15116                "\3\2\2\2>\u035c\3\2\2\2@\u0369\3\2\2\2B\u0374\3\2\2\2D\u03a1\3\2\2\2F"+
15117                "\u03ae\3\2\2\2H\u03b9\3\2\2\2J\u03e6\3\2\2\2L\u03f3\3\2\2\2N\u03fe\3\2"+
15118                "\2\2P\u042b\3\2\2\2R\u0438\3\2\2\2T\u0443\3\2\2\2V\u0470\3\2\2\2X\u047d"+
15119                "\3\2\2\2Z\u0488\3\2\2\2\\\u04b5\3\2\2\2^\u04c2\3\2\2\2`\u04cd\3\2\2\2"+
15120                "b\u04fa\3\2\2\2d\u0507\3\2\2\2f\u0512\3\2\2\2h\u054e\3\2\2\2j\u0550\3"+
15121                "\2\2\2l\u055d\3\2\2\2n\u056a\3\2\2\2p\u0577\3\2\2\2r\u0584\3\2\2\2t\u0591"+
15122                "\3\2\2\2v\u059e\3\2\2\2x\u05ab\3\2\2\2z\u05b8\3\2\2\2|\u05c5\3\2\2\2~"+
15123                "\u05d2\3\2\2\2\u0080\u05df\3\2\2\2\u0082\u05ec\3\2\2\2\u0084\u05f9\3\2"+
15124                "\2\2\u0086\u0606\3\2\2\2\u0088\u060c\3\2\2\2\u008a\u0616\3\2\2\2\u008c"+
15125                "\u063f\3\2\2\2\u008e\u0641\3\2\2\2\u0090\u070c\3\2\2\2\u0092\u070e\3\2"+
15126                "\2\2\u0094\u075e\3\2\2\2\u0096\u076a\3\2\2\2\u0098\u00a1\5\4\3\2\u0099"+
15127                "\u009a\6\2\2\2\u009a\u00a1\7\3\2\2\u009b\u00a1\5\u0094K\2\u009c\u00a1"+
15128                "\7\5\2\2\u009d\u00a1\7\b\2\2\u009e\u00a1\5\u0096L\2\u009f\u00a1\5\u0092"+
15129                "J\2\u00a0\u0098\3\2\2\2\u00a0\u0099\3\2\2\2\u00a0\u009b\3\2\2\2\u00a0"+
15130                "\u009c\3\2\2\2\u00a0\u009d\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u009f\3\2"+
15131                "\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3"+
15132                "\u00b1\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5\u00a7\7\3\2\2\u00a6\u00a5\3\2"+
15133                "\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00ab\3\2\2\2\u00a8\u00aa\7\6\2\2\u00a9"+
15134                "\u00a8\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00ac\3\2"+
15135                "\2\2\u00ac\u00ae\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00b0\5\u0090I\2\u00af"+
15136                "\u00a6\3\2\2\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2"+
15137                "\2\2\u00b2\u00b4\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4\u00b5\7\2\2\3\u00b5"+
15138                "\3\3\2\2\2\u00b6\u00e6\5\f\7\2\u00b7\u00e6\5h\65\2\u00b8\u00e6\5\22\n"+
15139                "\2\u00b9\u00e6\5\30\r\2\u00ba\u00e6\5\36\20\2\u00bb\u00e6\5$\23\2\u00bc"+
15140                "\u00e6\5*\26\2\u00bd\u00e6\5\60\31\2\u00be\u00e6\5\66\34\2\u00bf\u00e6"+
15141                "\5<\37\2\u00c0\u00e6\5B\"\2\u00c1\u00e6\5H%\2\u00c2\u00e6\5N(\2\u00c3"+
15142                "\u00e6\5T+\2\u00c4\u00e6\5Z.\2\u00c5\u00e6\5f\64\2\u00c6\u00e6\5`\61\2"+
15143                "\u00c7\u00e6\5\16\b\2\u00c8\u00e6\5\24\13\2\u00c9\u00e6\5\32\16\2\u00ca"+
15144                "\u00e6\5 \21\2\u00cb\u00e6\5&\24\2\u00cc\u00e6\5,\27\2\u00cd\u00e6\5\62"+
15145                "\32\2\u00ce\u00e6\58\35\2\u00cf\u00e6\5> \2\u00d0\u00e6\5D#\2\u00d1\u00e6"+
15146                "\5J&\2\u00d2\u00e6\5P)\2\u00d3\u00e6\5V,\2\u00d4\u00e6\5b\62\2\u00d5\u00e6"+
15147                "\5\\/\2\u00d6\u00e6\5\20\t\2\u00d7\u00e6\5\26\f\2\u00d8\u00e6\5\34\17"+
15148                "\2\u00d9\u00e6\5\"\22\2\u00da\u00e6\5(\25\2\u00db\u00e6\5.\30\2\u00dc"+
15149                "\u00e6\5\64\33\2\u00dd\u00e6\5:\36\2\u00de\u00e6\5@!\2\u00df\u00e6\5F"+
15150                "$\2\u00e0\u00e6\5L\'\2\u00e1\u00e6\5R*\2\u00e2\u00e6\5X-\2\u00e3\u00e6"+
15151                "\5d\63\2\u00e4\u00e6\5^\60\2\u00e5\u00b6\3\2\2\2\u00e5\u00b7\3\2\2\2\u00e5"+
15152                "\u00b8\3\2\2\2\u00e5\u00b9\3\2\2\2\u00e5\u00ba\3\2\2\2\u00e5\u00bb\3\2"+
15153                "\2\2\u00e5\u00bc\3\2\2\2\u00e5\u00bd\3\2\2\2\u00e5\u00be\3\2\2\2\u00e5"+
15154                "\u00bf\3\2\2\2\u00e5\u00c0\3\2\2\2\u00e5\u00c1\3\2\2\2\u00e5\u00c2\3\2"+
15155                "\2\2\u00e5\u00c3\3\2\2\2\u00e5\u00c4\3\2\2\2\u00e5\u00c5\3\2\2\2\u00e5"+
15156                "\u00c6\3\2\2\2\u00e5\u00c7\3\2\2\2\u00e5\u00c8\3\2\2\2\u00e5\u00c9\3\2"+
15157                "\2\2\u00e5\u00ca\3\2\2\2\u00e5\u00cb\3\2\2\2\u00e5\u00cc\3\2\2\2\u00e5"+
15158                "\u00cd\3\2\2\2\u00e5\u00ce\3\2\2\2\u00e5\u00cf\3\2\2\2\u00e5\u00d0\3\2"+
15159                "\2\2\u00e5\u00d1\3\2\2\2\u00e5\u00d2\3\2\2\2\u00e5\u00d3\3\2\2\2\u00e5"+
15160                "\u00d4\3\2\2\2\u00e5\u00d5\3\2\2\2\u00e5\u00d6\3\2\2\2\u00e5\u00d7\3\2"+
15161                "\2\2\u00e5\u00d8\3\2\2\2\u00e5\u00d9\3\2\2\2\u00e5\u00da\3\2\2\2\u00e5"+
15162                "\u00db\3\2\2\2\u00e5\u00dc\3\2\2\2\u00e5\u00dd\3\2\2\2\u00e5\u00de\3\2"+
15163                "\2\2\u00e5\u00df\3\2\2\2\u00e5\u00e0\3\2\2\2\u00e5\u00e1\3\2\2\2\u00e5"+
15164                "\u00e2\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e4\3\2\2\2\u00e6\5\3\2\2\2"+
15165                "\u00e7\u00e8\7\7\2\2\u00e8\u00ef\7Y\2\2\u00e9\u00ee\5\n\6\2\u00ea\u00ee"+
15166                "\7\b\2\2\u00eb\u00ee\7\3\2\2\u00ec\u00ee\7\6\2\2\u00ed\u00e9\3\2\2\2\u00ed"+
15167                "\u00ea\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ec\3\2\2\2\u00ee\u00f1\3\2"+
15168                "\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\3\2\2\2\u00f1"+
15169                "\u00ef\3\2\2\2\u00f2\u00f3\79\2\2\u00f3\7\3\2\2\2\u00f4\u00f5\7\7\2\2"+
15170                "\u00f5\u00f6\7;\2\2\u00f6\u00fa\7Y\2\2\u00f7\u00f9\t\2\2\2\u00f8\u00f7"+
15171                "\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb"+
15172                "\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\79\2\2\u00fe\t\3\2\2\2"+
15173                "\u00ff\u0103\7Y\2\2\u0100\u0102\t\2\2\2\u0101\u0100\3\2\2\2\u0102\u0105"+
15174                "\3\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105"+
15175                "\u0103\3\2\2\2\u0106\u010a\7<\2\2\u0107\u0109\t\2\2\2\u0108\u0107\3\2"+
15176                "\2\2\u0109\u010c\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b"+
15177                "\u0110\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u0111\7[\2\2\u010e\u0111\5\u0096"+
15178                "L\2\u010f\u0111\7Y\2\2\u0110\u010d\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u010f"+
15179                "\3\2\2\2\u0111\13\3\2\2\2\u0112\u011d\5\6\4\2\u0113\u011c\5\4\3\2\u0114"+
15180                "\u0115\6\7\3\2\u0115\u011c\7\3\2\2\u0116\u011c\5\u0094K\2\u0117\u011c"+
15181                "\7\5\2\2\u0118\u011c\7\b\2\2\u0119\u011c\5\u0096L\2\u011a\u011c\5\u0092"+
15182                "J\2\u011b\u0113\3\2\2\2\u011b\u0114\3\2\2\2\u011b\u0116\3\2\2\2\u011b"+
15183                "\u0117\3\2\2\2\u011b\u0118\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2"+
15184                "\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+
15185                "\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0121\5\b\5\2\u0121\u0133\3\2"+
15186                "\2\2\u0122\u012d\5\6\4\2\u0123\u012c\5\4\3\2\u0124\u0125\6\7\4\2\u0125"+
15187                "\u012c\7\3\2\2\u0126\u012c\5\u0094K\2\u0127\u012c\7\5\2\2\u0128\u012c"+
15188                "\7\b\2\2\u0129\u012c\5\u0096L\2\u012a\u012c\5\u0092J\2\u012b\u0123\3\2"+
15189                "\2\2\u012b\u0124\3\2\2\2\u012b\u0126\3\2\2\2\u012b\u0127\3\2\2\2\u012b"+
15190                "\u0128\3\2\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u012f\3\2"+
15191                "\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0130\3\2\2\2\u012f"+
15192                "\u012d\3\2\2\2\u0130\u0131\b\7\1\2\u0131\u0133\3\2\2\2\u0132\u0112\3\2"+
15193                "\2\2\u0132\u0122\3\2\2\2\u0133\r\3\2\2\2\u0134\u0135\7\7\2\2\u0135\u013c"+
15194                "\7=\2\2\u0136\u013b\5\n\6\2\u0137\u013b\7\b\2\2\u0138\u013b\7\3\2\2\u0139"+
15195                "\u013b\7\6\2\2\u013a\u0136\3\2\2\2\u013a\u0137\3\2\2\2\u013a\u0138\3\2"+
15196                "\2\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c"+
15197                "\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0140\79"+
15198                "\2\2\u0140\17\3\2\2\2\u0141\u0142\7\7\2\2\u0142\u0143\7;\2\2\u0143\u0147"+
15199                "\7=\2\2\u0144\u0146\t\2\2\2\u0145\u0144\3\2\2\2\u0146\u0149\3\2\2\2\u0147"+
15200                "\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2\u0149\u0147\3\2"+
15201                "\2\2\u014a\u014b\79\2\2\u014b\21\3\2\2\2\u014c\u0174\5\16\b\2\u014d\u0173"+
15202                "\5\f\7\2\u014e\u0173\5j\66\2\u014f\u0173\5\30\r\2\u0150\u0173\5\36\20"+
15203                "\2\u0151\u0173\5$\23\2\u0152\u0173\5*\26\2\u0153\u0173\5\60\31\2\u0154"+
15204                "\u0173\5\66\34\2\u0155\u0173\5<\37\2\u0156\u0173\5B\"\2\u0157\u0173\5"+
15205                "H%\2\u0158\u0173\5N(\2\u0159\u0173\5T+\2\u015a\u0173\5Z.\2\u015b\u0173"+
15206                "\5f\64\2\u015c\u0173\5`\61\2\u015d\u0173\5\24\13\2\u015e\u0173\5\32\16"+
15207                "\2\u015f\u0173\5 \21\2\u0160\u0173\5&\24\2\u0161\u0173\5,\27\2\u0162\u0173"+
15208                "\5\62\32\2\u0163\u0173\58\35\2\u0164\u0173\5> \2\u0165\u0173\5D#\2\u0166"+
15209                "\u0173\5J&\2\u0167\u0173\5P)\2\u0168\u0173\5V,\2\u0169\u0173\5b\62\2\u016a"+
15210                "\u0173\5\\/\2\u016b\u016c\6\n\5\2\u016c\u0173\7\3\2\2\u016d\u0173\5\u0094"+
15211                "K\2\u016e\u0173\7\5\2\2\u016f\u0173\7\b\2\2\u0170\u0173\5\u0096L\2\u0171"+
15212                "\u0173\5\u0092J\2\u0172\u014d\3\2\2\2\u0172\u014e\3\2\2\2\u0172\u014f"+
15213                "\3\2\2\2\u0172\u0150\3\2\2\2\u0172\u0151\3\2\2\2\u0172\u0152\3\2\2\2\u0172"+
15214                "\u0153\3\2\2\2\u0172\u0154\3\2\2\2\u0172\u0155\3\2\2\2\u0172\u0156\3\2"+
15215                "\2\2\u0172\u0157\3\2\2\2\u0172\u0158\3\2\2\2\u0172\u0159\3\2\2\2\u0172"+
15216                "\u015a\3\2\2\2\u0172\u015b\3\2\2\2\u0172\u015c\3\2\2\2\u0172\u015d\3\2"+
15217                "\2\2\u0172\u015e\3\2\2\2\u0172\u015f\3\2\2\2\u0172\u0160\3\2\2\2\u0172"+
15218                "\u0161\3\2\2\2\u0172\u0162\3\2\2\2\u0172\u0163\3\2\2\2\u0172\u0164\3\2"+
15219                "\2\2\u0172\u0165\3\2\2\2\u0172\u0166\3\2\2\2\u0172\u0167\3\2\2\2\u0172"+
15220                "\u0168\3\2\2\2\u0172\u0169\3\2\2\2\u0172\u016a\3\2\2\2\u0172\u016b\3\2"+
15221                "\2\2\u0172\u016d\3\2\2\2\u0172\u016e\3\2\2\2\u0172\u016f\3\2\2\2\u0172"+
15222                "\u0170\3\2\2\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2"+
15223                "\2\2\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2\u0177"+
15224                "\u0178\5\20\t\2\u0178\23\3\2\2\2\u0179\u017a\7\7\2\2\u017a\u0181\7>\2"+
15225                "\2\u017b\u0180\5\n\6\2\u017c\u0180\7\b\2\2\u017d\u0180\7\3\2\2\u017e\u0180"+
15226                "\7\6\2\2\u017f\u017b\3\2\2\2\u017f\u017c\3\2\2\2\u017f\u017d\3\2\2\2\u017f"+
15227                "\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2"+
15228                "\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0185\79\2\2\u0185"+
15229                "\25\3\2\2\2\u0186\u0187\7\7\2\2\u0187\u0188\7;\2\2\u0188\u018c\7>\2\2"+
15230                "\u0189\u018b\t\2\2\2\u018a\u0189\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a"+
15231                "\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f"+
15232                "\u0190\79\2\2\u0190\27\3\2\2\2\u0191\u01b9\5\24\13\2\u0192\u01b8\5\f\7"+
15233                "\2\u0193\u01b8\5j\66\2\u0194\u01b8\5\22\n\2\u0195\u01b8\5\36\20\2\u0196"+
15234                "\u01b8\5$\23\2\u0197\u01b8\5*\26\2\u0198\u01b8\5\60\31\2\u0199\u01b8\5"+
15235                "\66\34\2\u019a\u01b8\5<\37\2\u019b\u01b8\5B\"\2\u019c\u01b8\5H%\2\u019d"+
15236                "\u01b8\5N(\2\u019e\u01b8\5T+\2\u019f\u01b8\5Z.\2\u01a0\u01b8\5f\64\2\u01a1"+
15237                "\u01b8\5`\61\2\u01a2\u01b8\5\16\b\2\u01a3\u01b8\5\32\16\2\u01a4\u01b8"+
15238                "\5 \21\2\u01a5\u01b8\5&\24\2\u01a6\u01b8\5,\27\2\u01a7\u01b8\5\62\32\2"+
15239                "\u01a8\u01b8\58\35\2\u01a9\u01b8\5> \2\u01aa\u01b8\5D#\2\u01ab\u01b8\5"+
15240                "J&\2\u01ac\u01b8\5P)\2\u01ad\u01b8\5V,\2\u01ae\u01b8\5b\62\2\u01af\u01b8"+
15241                "\5\\/\2\u01b0\u01b1\6\r\6\2\u01b1\u01b8\7\3\2\2\u01b2\u01b8\5\u0094K\2"+
15242                "\u01b3\u01b8\7\5\2\2\u01b4\u01b8\7\b\2\2\u01b5\u01b8\5\u0096L\2\u01b6"+
15243                "\u01b8\5\u0092J\2\u01b7\u0192\3\2\2\2\u01b7\u0193\3\2\2\2\u01b7\u0194"+
15244                "\3\2\2\2\u01b7\u0195\3\2\2\2\u01b7\u0196\3\2\2\2\u01b7\u0197\3\2\2\2\u01b7"+
15245                "\u0198\3\2\2\2\u01b7\u0199\3\2\2\2\u01b7\u019a\3\2\2\2\u01b7\u019b\3\2"+
15246                "\2\2\u01b7\u019c\3\2\2\2\u01b7\u019d\3\2\2\2\u01b7\u019e\3\2\2\2\u01b7"+
15247                "\u019f\3\2\2\2\u01b7\u01a0\3\2\2\2\u01b7\u01a1\3\2\2\2\u01b7\u01a2\3\2"+
15248                "\2\2\u01b7\u01a3\3\2\2\2\u01b7\u01a4\3\2\2\2\u01b7\u01a5\3\2\2\2\u01b7"+
15249                "\u01a6\3\2\2\2\u01b7\u01a7\3\2\2\2\u01b7\u01a8\3\2\2\2\u01b7\u01a9\3\2"+
15250                "\2\2\u01b7\u01aa\3\2\2\2\u01b7\u01ab\3\2\2\2\u01b7\u01ac\3\2\2\2\u01b7"+
15251                "\u01ad\3\2\2\2\u01b7\u01ae\3\2\2\2\u01b7\u01af\3\2\2\2\u01b7\u01b0\3\2"+
15252                "\2\2\u01b7\u01b2\3\2\2\2\u01b7\u01b3\3\2\2\2\u01b7\u01b4\3\2\2\2\u01b7"+
15253                "\u01b5\3\2\2\2\u01b7\u01b6\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9\u01b7\3\2"+
15254                "\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bc"+
15255                "\u01bd\5\26\f\2\u01bd\31\3\2\2\2\u01be\u01bf\7\7\2\2\u01bf\u01c6\7?\2"+
15256                "\2\u01c0\u01c5\5\n\6\2\u01c1\u01c5\7\b\2\2\u01c2\u01c5\7\3\2\2\u01c3\u01c5"+
15257                "\7\6\2\2\u01c4\u01c0\3\2\2\2\u01c4\u01c1\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c4"+
15258                "\u01c3\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2"+
15259                "\2\2\u01c7\u01c9\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01ca\79\2\2\u01ca"+
15260                "\33\3\2\2\2\u01cb\u01cc\7\7\2\2\u01cc\u01cd\7;\2\2\u01cd\u01d1\7?\2\2"+
15261                "\u01ce\u01d0\t\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf"+
15262                "\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d4\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4"+
15263                "\u01d5\79\2\2\u01d5\35\3\2\2\2\u01d6\u01fe\5\32\16\2\u01d7\u01fd\5\f\7"+
15264                "\2\u01d8\u01fd\5j\66\2\u01d9\u01fd\5\22\n\2\u01da\u01fd\5\30\r\2\u01db"+
15265                "\u01fd\5$\23\2\u01dc\u01fd\5*\26\2\u01dd\u01fd\5\60\31\2\u01de\u01fd\5"+
15266                "\66\34\2\u01df\u01fd\5<\37\2\u01e0\u01fd\5B\"\2\u01e1\u01fd\5H%\2\u01e2"+
15267                "\u01fd\5N(\2\u01e3\u01fd\5T+\2\u01e4\u01fd\5Z.\2\u01e5\u01fd\5f\64\2\u01e6"+
15268                "\u01fd\5`\61\2\u01e7\u01fd\5\16\b\2\u01e8\u01fd\5\24\13\2\u01e9\u01fd"+
15269                "\5 \21\2\u01ea\u01fd\5&\24\2\u01eb\u01fd\5,\27\2\u01ec\u01fd\5\62\32\2"+
15270                "\u01ed\u01fd\58\35\2\u01ee\u01fd\5> \2\u01ef\u01fd\5D#\2\u01f0\u01fd\5"+
15271                "J&\2\u01f1\u01fd\5P)\2\u01f2\u01fd\5V,\2\u01f3\u01fd\5b\62\2\u01f4\u01fd"+
15272                "\5\\/\2\u01f5\u01f6\6\20\7\2\u01f6\u01fd\7\3\2\2\u01f7\u01fd\5\u0094K"+
15273                "\2\u01f8\u01fd\7\5\2\2\u01f9\u01fd\7\b\2\2\u01fa\u01fd\5\u0096L\2\u01fb"+
15274                "\u01fd\5\u0092J\2\u01fc\u01d7\3\2\2\2\u01fc\u01d8\3\2\2\2\u01fc\u01d9"+
15275                "\3\2\2\2\u01fc\u01da\3\2\2\2\u01fc\u01db\3\2\2\2\u01fc\u01dc\3\2\2\2\u01fc"+
15276                "\u01dd\3\2\2\2\u01fc\u01de\3\2\2\2\u01fc\u01df\3\2\2\2\u01fc\u01e0\3\2"+
15277                "\2\2\u01fc\u01e1\3\2\2\2\u01fc\u01e2\3\2\2\2\u01fc\u01e3\3\2\2\2\u01fc"+
15278                "\u01e4\3\2\2\2\u01fc\u01e5\3\2\2\2\u01fc\u01e6\3\2\2\2\u01fc\u01e7\3\2"+
15279                "\2\2\u01fc\u01e8\3\2\2\2\u01fc\u01e9\3\2\2\2\u01fc\u01ea\3\2\2\2\u01fc"+
15280                "\u01eb\3\2\2\2\u01fc\u01ec\3\2\2\2\u01fc\u01ed\3\2\2\2\u01fc\u01ee\3\2"+
15281                "\2\2\u01fc\u01ef\3\2\2\2\u01fc\u01f0\3\2\2\2\u01fc\u01f1\3\2\2\2\u01fc"+
15282                "\u01f2\3\2\2\2\u01fc\u01f3\3\2\2\2\u01fc\u01f4\3\2\2\2\u01fc\u01f5\3\2"+
15283                "\2\2\u01fc\u01f7\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fc\u01f9\3\2\2\2\u01fc"+
15284                "\u01fa\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fd\u0200\3\2\2\2\u01fe\u01fc\3\2"+
15285                "\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0201\3\2\2\2\u0200\u01fe\3\2\2\2\u0201"+
15286                "\u0202\5\34\17\2\u0202\37\3\2\2\2\u0203\u0204\7\7\2\2\u0204\u020b\7@\2"+
15287                "\2\u0205\u020a\5\n\6\2\u0206\u020a\7\b\2\2\u0207\u020a\7\3\2\2\u0208\u020a"+
15288                "\7\6\2\2\u0209\u0205\3\2\2\2\u0209\u0206\3\2\2\2\u0209\u0207\3\2\2\2\u0209"+
15289                "\u0208\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2"+
15290                "\2\2\u020c\u020e\3\2\2\2\u020d\u020b\3\2\2\2\u020e\u020f\79\2\2\u020f"+
15291                "!\3\2\2\2\u0210\u0211\7\7\2\2\u0211\u0212\7;\2\2\u0212\u0216\7@\2\2\u0213"+
15292                "\u0215\t\2\2\2\u0214\u0213\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2"+
15293                "\2\2\u0216\u0217\3\2\2\2\u0217\u0219\3\2\2\2\u0218\u0216\3\2\2\2\u0219"+
15294                "\u021a\79\2\2\u021a#\3\2\2\2\u021b\u0243\5 \21\2\u021c\u0242\5\f\7\2\u021d"+
15295                "\u0242\5j\66\2\u021e\u0242\5\22\n\2\u021f\u0242\5\30\r\2\u0220\u0242\5"+
15296                "\36\20\2\u0221\u0242\5*\26\2\u0222\u0242\5\60\31\2\u0223\u0242\5\66\34"+
15297                "\2\u0224\u0242\5<\37\2\u0225\u0242\5B\"\2\u0226\u0242\5H%\2\u0227\u0242"+
15298                "\5N(\2\u0228\u0242\5T+\2\u0229\u0242\5Z.\2\u022a\u0242\5f\64\2\u022b\u0242"+
15299                "\5`\61\2\u022c\u0242\5\16\b\2\u022d\u0242\5\24\13\2\u022e\u0242\5 \21"+
15300                "\2\u022f\u0242\5&\24\2\u0230\u0242\5,\27\2\u0231\u0242\5\62\32\2\u0232"+
15301                "\u0242\58\35\2\u0233\u0242\5> \2\u0234\u0242\5D#\2\u0235\u0242\5J&\2\u0236"+
15302                "\u0242\5P)\2\u0237\u0242\5V,\2\u0238\u0242\5b\62\2\u0239\u0242\5\\/\2"+
15303                "\u023a\u023b\6\23\b\2\u023b\u0242\7\3\2\2\u023c\u0242\5\u0094K\2\u023d"+
15304                "\u0242\7\5\2\2\u023e\u0242\7\b\2\2\u023f\u0242\5\u0096L\2\u0240\u0242"+
15305                "\5\u0092J\2\u0241\u021c\3\2\2\2\u0241\u021d\3\2\2\2\u0241\u021e\3\2\2"+
15306                "\2\u0241\u021f\3\2\2\2\u0241\u0220\3\2\2\2\u0241\u0221\3\2\2\2\u0241\u0222"+
15307                "\3\2\2\2\u0241\u0223\3\2\2\2\u0241\u0224\3\2\2\2\u0241\u0225\3\2\2\2\u0241"+
15308                "\u0226\3\2\2\2\u0241\u0227\3\2\2\2\u0241\u0228\3\2\2\2\u0241\u0229\3\2"+
15309                "\2\2\u0241\u022a\3\2\2\2\u0241\u022b\3\2\2\2\u0241\u022c\3\2\2\2\u0241"+
15310                "\u022d\3\2\2\2\u0241\u022e\3\2\2\2\u0241\u022f\3\2\2\2\u0241\u0230\3\2"+
15311                "\2\2\u0241\u0231\3\2\2\2\u0241\u0232\3\2\2\2\u0241\u0233\3\2\2\2\u0241"+
15312                "\u0234\3\2\2\2\u0241\u0235\3\2\2\2\u0241\u0236\3\2\2\2\u0241\u0237\3\2"+
15313                "\2\2\u0241\u0238\3\2\2\2\u0241\u0239\3\2\2\2\u0241\u023a\3\2\2\2\u0241"+
15314                "\u023c\3\2\2\2\u0241\u023d\3\2\2\2\u0241\u023e\3\2\2\2\u0241\u023f\3\2"+
15315                "\2\2\u0241\u0240\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243"+
15316                "\u0244\3\2\2\2\u0244\u0246\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\5\""+
15317                "\22\2\u0247%\3\2\2\2\u0248\u0249\7\7\2\2\u0249\u0250\7A\2\2\u024a\u024f"+
15318                "\5\n\6\2\u024b\u024f\7\b\2\2\u024c\u024f\7\3\2\2\u024d\u024f\7\6\2\2\u024e"+
15319                "\u024a\3\2\2\2\u024e\u024b\3\2\2\2\u024e\u024c\3\2\2\2\u024e\u024d\3\2"+
15320                "\2\2\u024f\u0252\3\2\2\2\u0250\u024e\3\2\2\2\u0250\u0251\3\2\2\2\u0251"+
15321                "\u0253\3\2\2\2\u0252\u0250\3\2\2\2\u0253\u0254\79\2\2\u0254\'\3\2\2\2"+
15322                "\u0255\u0256\7\7\2\2\u0256\u0257\7;\2\2\u0257\u025b\7A\2\2\u0258\u025a"+
15323                "\t\2\2\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2\2\u025b"+
15324                "\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f\79"+
15325                "\2\2\u025f)\3\2\2\2\u0260\u0288\5&\24\2\u0261\u0287\5\f\7\2\u0262\u0287"+
15326                "\5j\66\2\u0263\u0287\5\22\n\2\u0264\u0287\5\30\r\2\u0265\u0287\5\36\20"+
15327                "\2\u0266\u0287\5$\23\2\u0267\u0287\5\60\31\2\u0268\u0287\5\66\34\2\u0269"+
15328                "\u0287\5<\37\2\u026a\u0287\5B\"\2\u026b\u0287\5H%\2\u026c\u0287\5N(\2"+
15329                "\u026d\u0287\5T+\2\u026e\u0287\5Z.\2\u026f\u0287\5f\64\2\u0270\u0287\5"+
15330                "`\61\2\u0271\u0287\5\16\b\2\u0272\u0287\5\24\13\2\u0273\u0287\5\32\16"+
15331                "\2\u0274\u0287\5 \21\2\u0275\u0287\5,\27\2\u0276\u0287\5\62\32\2\u0277"+
15332                "\u0287\58\35\2\u0278\u0287\5> \2\u0279\u0287\5D#\2\u027a\u0287\5J&\2\u027b"+
15333                "\u0287\5P)\2\u027c\u0287\5V,\2\u027d\u0287\5b\62\2\u027e\u0287\5\\/\2"+
15334                "\u027f\u0280\6\26\t\2\u0280\u0287\7\3\2\2\u0281\u0287\5\u0094K\2\u0282"+
15335                "\u0287\7\5\2\2\u0283\u0287\7\b\2\2\u0284\u0287\5\u0096L\2\u0285\u0287"+
15336                "\5\u0092J\2\u0286\u0261\3\2\2\2\u0286\u0262\3\2\2\2\u0286\u0263\3\2\2"+
15337                "\2\u0286\u0264\3\2\2\2\u0286\u0265\3\2\2\2\u0286\u0266\3\2\2\2\u0286\u0267"+
15338                "\3\2\2\2\u0286\u0268\3\2\2\2\u0286\u0269\3\2\2\2\u0286\u026a\3\2\2\2\u0286"+
15339                "\u026b\3\2\2\2\u0286\u026c\3\2\2\2\u0286\u026d\3\2\2\2\u0286\u026e\3\2"+
15340                "\2\2\u0286\u026f\3\2\2\2\u0286\u0270\3\2\2\2\u0286\u0271\3\2\2\2\u0286"+
15341                "\u0272\3\2\2\2\u0286\u0273\3\2\2\2\u0286\u0274\3\2\2\2\u0286\u0275\3\2"+
15342                "\2\2\u0286\u0276\3\2\2\2\u0286\u0277\3\2\2\2\u0286\u0278\3\2\2\2\u0286"+
15343                "\u0279\3\2\2\2\u0286\u027a\3\2\2\2\u0286\u027b\3\2\2\2\u0286\u027c\3\2"+
15344                "\2\2\u0286\u027d\3\2\2\2\u0286\u027e\3\2\2\2\u0286\u027f\3\2\2\2\u0286"+
15345                "\u0281\3\2\2\2\u0286\u0282\3\2\2\2\u0286\u0283\3\2\2\2\u0286\u0284\3\2"+
15346                "\2\2\u0286\u0285\3\2\2\2\u0287\u028a\3\2\2\2\u0288\u0286\3\2\2\2\u0288"+
15347                "\u0289\3\2\2\2\u0289\u028b\3\2\2\2\u028a\u0288\3\2\2\2\u028b\u028c\5("+
15348                "\25\2\u028c+\3\2\2\2\u028d\u028e\7\7\2\2\u028e\u0295\7B\2\2\u028f\u0294"+
15349                "\5\n\6\2\u0290\u0294\7\b\2\2\u0291\u0294\7\3\2\2\u0292\u0294\7\6\2\2\u0293"+
15350                "\u028f\3\2\2\2\u0293\u0290\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0292\3\2"+
15351                "\2\2\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296"+
15352                "\u0298\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u0299\79\2\2\u0299-\3\2\2\2\u029a"+
15353                "\u029b\7\7\2\2\u029b\u029c\7;\2\2\u029c\u02a0\7B\2\2\u029d\u029f\t\2\2"+
15354                "\2\u029e\u029d\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0\u029e\3\2\2\2\u02a0\u02a1"+
15355                "\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a3\u02a4\79\2\2\u02a4"+
15356                "/\3\2\2\2\u02a5\u02cd\5,\27\2\u02a6\u02cc\5\f\7\2\u02a7\u02cc\5j\66\2"+
15357                "\u02a8\u02cc\5\22\n\2\u02a9\u02cc\5\30\r\2\u02aa\u02cc\5\36\20\2\u02ab"+
15358                "\u02cc\5$\23\2\u02ac\u02cc\5*\26\2\u02ad\u02cc\5\66\34\2\u02ae\u02cc\5"+
15359                "<\37\2\u02af\u02cc\5B\"\2\u02b0\u02cc\5H%\2\u02b1\u02cc\5N(\2\u02b2\u02cc"+
15360                "\5T+\2\u02b3\u02cc\5Z.\2\u02b4\u02cc\5f\64\2\u02b5\u02cc\5`\61\2\u02b6"+
15361                "\u02cc\5\16\b\2\u02b7\u02cc\5\24\13\2\u02b8\u02cc\5\32\16\2\u02b9\u02cc"+
15362                "\5 \21\2\u02ba\u02cc\5&\24\2\u02bb\u02cc\5\62\32\2\u02bc\u02cc\58\35\2"+
15363                "\u02bd\u02cc\5> \2\u02be\u02cc\5D#\2\u02bf\u02cc\5J&\2\u02c0\u02cc\5P"+
15364                ")\2\u02c1\u02cc\5V,\2\u02c2\u02cc\5b\62\2\u02c3\u02cc\5\\/\2\u02c4\u02c5"+
15365                "\6\31\n\2\u02c5\u02cc\7\3\2\2\u02c6\u02cc\5\u0094K\2\u02c7\u02cc\7\5\2"+
15366                "\2\u02c8\u02cc\7\b\2\2\u02c9\u02cc\5\u0096L\2\u02ca\u02cc\5\u0092J\2\u02cb"+
15367                "\u02a6\3\2\2\2\u02cb\u02a7\3\2\2\2\u02cb\u02a8\3\2\2\2\u02cb\u02a9\3\2"+
15368                "\2\2\u02cb\u02aa\3\2\2\2\u02cb\u02ab\3\2\2\2\u02cb\u02ac\3\2\2\2\u02cb"+
15369                "\u02ad\3\2\2\2\u02cb\u02ae\3\2\2\2\u02cb\u02af\3\2\2\2\u02cb\u02b0\3\2"+
15370                "\2\2\u02cb\u02b1\3\2\2\2\u02cb\u02b2\3\2\2\2\u02cb\u02b3\3\2\2\2\u02cb"+
15371                "\u02b4\3\2\2\2\u02cb\u02b5\3\2\2\2\u02cb\u02b6\3\2\2\2\u02cb\u02b7\3\2"+
15372                "\2\2\u02cb\u02b8\3\2\2\2\u02cb\u02b9\3\2\2\2\u02cb\u02ba\3\2\2\2\u02cb"+
15373                "\u02bb\3\2\2\2\u02cb\u02bc\3\2\2\2\u02cb\u02bd\3\2\2\2\u02cb\u02be\3\2"+
15374                "\2\2\u02cb\u02bf\3\2\2\2\u02cb\u02c0\3\2\2\2\u02cb\u02c1\3\2\2\2\u02cb"+
15375                "\u02c2\3\2\2\2\u02cb\u02c3\3\2\2\2\u02cb\u02c4\3\2\2\2\u02cb\u02c6\3\2"+
15376                "\2\2\u02cb\u02c7\3\2\2\2\u02cb\u02c8\3\2\2\2\u02cb\u02c9\3\2\2\2\u02cb"+
15377                "\u02ca\3\2\2\2\u02cc\u02cf\3\2\2\2\u02cd\u02cb\3\2\2\2\u02cd\u02ce\3\2"+
15378                "\2\2\u02ce\u02d0\3\2\2\2\u02cf\u02cd\3\2\2\2\u02d0\u02d1\5.\30\2\u02d1"+
15379                "\61\3\2\2\2\u02d2\u02d3\7\7\2\2\u02d3\u02da\7C\2\2\u02d4\u02d9\5\n\6\2"+
15380                "\u02d5\u02d9\7\b\2\2\u02d6\u02d9\7\3\2\2\u02d7\u02d9\7\6\2\2\u02d8\u02d4"+
15381                "\3\2\2\2\u02d8\u02d5\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d8\u02d7\3\2\2\2\u02d9"+
15382                "\u02dc\3\2\2\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\3\2"+
15383                "\2\2\u02dc\u02da\3\2\2\2\u02dd\u02de\79\2\2\u02de\63\3\2\2\2\u02df\u02e0"+
15384                "\7\7\2\2\u02e0\u02e1\7;\2\2\u02e1\u02e5\7C\2\2\u02e2\u02e4\t\2\2\2\u02e3"+
15385                "\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5\u02e6\3\2"+
15386                "\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\79\2\2\u02e9"+
15387                "\65\3\2\2\2\u02ea\u0312\5\62\32\2\u02eb\u0311\5\f\7\2\u02ec\u0311\5j\66"+
15388                "\2\u02ed\u0311\5\22\n\2\u02ee\u0311\5\30\r\2\u02ef\u0311\5\36\20\2\u02f0"+
15389                "\u0311\5$\23\2\u02f1\u0311\5*\26\2\u02f2\u0311\5\60\31\2\u02f3\u0311\5"+
15390                "<\37\2\u02f4\u0311\5B\"\2\u02f5\u0311\5H%\2\u02f6\u0311\5N(\2\u02f7\u0311"+
15391                "\5T+\2\u02f8\u0311\5Z.\2\u02f9\u0311\5f\64\2\u02fa\u0311\5`\61\2\u02fb"+
15392                "\u0311\5\16\b\2\u02fc\u0311\5\24\13\2\u02fd\u0311\5\32\16\2\u02fe\u0311"+
15393                "\5 \21\2\u02ff\u0311\5&\24\2\u0300\u0311\5,\27\2\u0301\u0311\58\35\2\u0302"+
15394                "\u0311\5> \2\u0303\u0311\5D#\2\u0304\u0311\5J&\2\u0305\u0311\5P)\2\u0306"+
15395                "\u0311\5V,\2\u0307\u0311\5b\62\2\u0308\u0311\5\\/\2\u0309\u030a\6\34\13"+
15396                "\2\u030a\u0311\7\3\2\2\u030b\u0311\5\u0094K\2\u030c\u0311\7\5\2\2\u030d"+
15397                "\u0311\7\b\2\2\u030e\u0311\5\u0096L\2\u030f\u0311\5\u0092J\2\u0310\u02eb"+
15398                "\3\2\2\2\u0310\u02ec\3\2\2\2\u0310\u02ed\3\2\2\2\u0310\u02ee\3\2\2\2\u0310"+
15399                "\u02ef\3\2\2\2\u0310\u02f0\3\2\2\2\u0310\u02f1\3\2\2\2\u0310\u02f2\3\2"+
15400                "\2\2\u0310\u02f3\3\2\2\2\u0310\u02f4\3\2\2\2\u0310\u02f5\3\2\2\2\u0310"+
15401                "\u02f6\3\2\2\2\u0310\u02f7\3\2\2\2\u0310\u02f8\3\2\2\2\u0310\u02f9\3\2"+
15402                "\2\2\u0310\u02fa\3\2\2\2\u0310\u02fb\3\2\2\2\u0310\u02fc\3\2\2\2\u0310"+
15403                "\u02fd\3\2\2\2\u0310\u02fe\3\2\2\2\u0310\u02ff\3\2\2\2\u0310\u0300\3\2"+
15404                "\2\2\u0310\u0301\3\2\2\2\u0310\u0302\3\2\2\2\u0310\u0303\3\2\2\2\u0310"+
15405                "\u0304\3\2\2\2\u0310\u0305\3\2\2\2\u0310\u0306\3\2\2\2\u0310\u0307\3\2"+
15406                "\2\2\u0310\u0308\3\2\2\2\u0310\u0309\3\2\2\2\u0310\u030b\3\2\2\2\u0310"+
15407                "\u030c\3\2\2\2\u0310\u030d\3\2\2\2\u0310\u030e\3\2\2\2\u0310\u030f\3\2"+
15408                "\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+
15409                "\u0315\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0316\5\64\33\2\u0316\67\3\2"+
15410                "\2\2\u0317\u0318\7\7\2\2\u0318\u031f\7D\2\2\u0319\u031e\5\n\6\2\u031a"+
15411                "\u031e\7\b\2\2\u031b\u031e\7\3\2\2\u031c\u031e\7\6\2\2\u031d\u0319\3\2"+
15412                "\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031c\3\2\2\2\u031e"+
15413                "\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0322\3\2"+
15414                "\2\2\u0321\u031f\3\2\2\2\u0322\u0323\79\2\2\u03239\3\2\2\2\u0324\u0325"+
15415                "\7\7\2\2\u0325\u0326\7;\2\2\u0326\u032a\7D\2\2\u0327\u0329\t\2\2\2\u0328"+
15416                "\u0327\3\2\2\2\u0329\u032c\3\2\2\2\u032a\u0328\3\2\2\2\u032a\u032b\3\2"+
15417                "\2\2\u032b\u032d\3\2\2\2\u032c\u032a\3\2\2\2\u032d\u032e\79\2\2\u032e"+
15418                ";\3\2\2\2\u032f\u0357\58\35\2\u0330\u0356\5\f\7\2\u0331\u0356\5j\66\2"+
15419                "\u0332\u0356\5\22\n\2\u0333\u0356\5\30\r\2\u0334\u0356\5\36\20\2\u0335"+
15420                "\u0356\5$\23\2\u0336\u0356\5*\26\2\u0337\u0356\5\60\31\2\u0338\u0356\5"+
15421                "\66\34\2\u0339\u0356\5B\"\2\u033a\u0356\5H%\2\u033b\u0356\5N(\2\u033c"+
15422                "\u0356\5T+\2\u033d\u0356\5Z.\2\u033e\u0356\5f\64\2\u033f\u0356\5`\61\2"+
15423                "\u0340\u0356\5\16\b\2\u0341\u0356\5\24\13\2\u0342\u0356\5\32\16\2\u0343"+
15424                "\u0356\5 \21\2\u0344\u0356\5&\24\2\u0345\u0356\5,\27\2\u0346\u0356\5\62"+
15425                "\32\2\u0347\u0356\5> \2\u0348\u0356\5D#\2\u0349\u0356\5J&\2\u034a\u0356"+
15426                "\5P)\2\u034b\u0356\5V,\2\u034c\u0356\5b\62\2\u034d\u0356\5\\/\2\u034e"+
15427                "\u034f\6\37\f\2\u034f\u0356\7\3\2\2\u0350\u0356\5\u0094K\2\u0351\u0356"+
15428                "\7\5\2\2\u0352\u0356\7\b\2\2\u0353\u0356\5\u0096L\2\u0354\u0356\5\u0092"+
15429                "J\2\u0355\u0330\3\2\2\2\u0355\u0331\3\2\2\2\u0355\u0332\3\2\2\2\u0355"+
15430                "\u0333\3\2\2\2\u0355\u0334\3\2\2\2\u0355\u0335\3\2\2\2\u0355\u0336\3\2"+
15431                "\2\2\u0355\u0337\3\2\2\2\u0355\u0338\3\2\2\2\u0355\u0339\3\2\2\2\u0355"+
15432                "\u033a\3\2\2\2\u0355\u033b\3\2\2\2\u0355\u033c\3\2\2\2\u0355\u033d\3\2"+
15433                "\2\2\u0355\u033e\3\2\2\2\u0355\u033f\3\2\2\2\u0355\u0340\3\2\2\2\u0355"+
15434                "\u0341\3\2\2\2\u0355\u0342\3\2\2\2\u0355\u0343\3\2\2\2\u0355\u0344\3\2"+
15435                "\2\2\u0355\u0345\3\2\2\2\u0355\u0346\3\2\2\2\u0355\u0347\3\2\2\2\u0355"+
15436                "\u0348\3\2\2\2\u0355\u0349\3\2\2\2\u0355\u034a\3\2\2\2\u0355\u034b\3\2"+
15437                "\2\2\u0355\u034c\3\2\2\2\u0355\u034d\3\2\2\2\u0355\u034e\3\2\2\2\u0355"+
15438                "\u0350\3\2\2\2\u0355\u0351\3\2\2\2\u0355\u0352\3\2\2\2\u0355\u0353\3\2"+
15439                "\2\2\u0355\u0354\3\2\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357"+
15440                "\u0358\3\2\2\2\u0358\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\5:"+
15441                "\36\2\u035b=\3\2\2\2\u035c\u035d\7\7\2\2\u035d\u0364\7E\2\2\u035e\u0363"+
15442                "\5\n\6\2\u035f\u0363\7\b\2\2\u0360\u0363\7\3\2\2\u0361\u0363\7\6\2\2\u0362"+
15443                "\u035e\3\2\2\2\u0362\u035f\3\2\2\2\u0362\u0360\3\2\2\2\u0362\u0361\3\2"+
15444                "\2\2\u0363\u0366\3\2\2\2\u0364\u0362\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+
15445                "\u0367\3\2\2\2\u0366\u0364\3\2\2\2\u0367\u0368\79\2\2\u0368?\3\2\2\2\u0369"+
15446                "\u036a\7\7\2\2\u036a\u036b\7;\2\2\u036b\u036f\7E\2\2\u036c\u036e\t\2\2"+
15447                "\2\u036d\u036c\3\2\2\2\u036e\u0371\3\2\2\2\u036f\u036d\3\2\2\2\u036f\u0370"+
15448                "\3\2\2\2\u0370\u0372\3\2\2\2\u0371\u036f\3\2\2\2\u0372\u0373\79\2\2\u0373"+
15449                "A\3\2\2\2\u0374\u039c\5> \2\u0375\u039b\5\f\7\2\u0376\u039b\5j\66\2\u0377"+
15450                "\u039b\5\22\n\2\u0378\u039b\5\30\r\2\u0379\u039b\5\36\20\2\u037a\u039b"+
15451                "\5$\23\2\u037b\u039b\5*\26\2\u037c\u039b\5\60\31\2\u037d\u039b\5\66\34"+
15452                "\2\u037e\u039b\5<\37\2\u037f\u039b\5H%\2\u0380\u039b\5N(\2\u0381\u039b"+
15453                "\5T+\2\u0382\u039b\5Z.\2\u0383\u039b\5f\64\2\u0384\u039b\5`\61\2\u0385"+
15454                "\u039b\5\16\b\2\u0386\u039b\5\24\13\2\u0387\u039b\5\32\16\2\u0388\u039b"+
15455                "\5 \21\2\u0389\u039b\5&\24\2\u038a\u039b\5,\27\2\u038b\u039b\5\62\32\2"+
15456                "\u038c\u039b\58\35\2\u038d\u039b\5D#\2\u038e\u039b\5J&\2\u038f\u039b\5"+
15457                "P)\2\u0390\u039b\5V,\2\u0391\u039b\5b\62\2\u0392\u039b\5\\/\2\u0393\u0394"+
15458                "\6\"\r\2\u0394\u039b\7\3\2\2\u0395\u039b\5\u0094K\2\u0396\u039b\7\5\2"+
15459                "\2\u0397\u039b\7\b\2\2\u0398\u039b\5\u0096L\2\u0399\u039b\5\u0092J\2\u039a"+
15460                "\u0375\3\2\2\2\u039a\u0376\3\2\2\2\u039a\u0377\3\2\2\2\u039a\u0378\3\2"+
15461                "\2\2\u039a\u0379\3\2\2\2\u039a\u037a\3\2\2\2\u039a\u037b\3\2\2\2\u039a"+
15462                "\u037c\3\2\2\2\u039a\u037d\3\2\2\2\u039a\u037e\3\2\2\2\u039a\u037f\3\2"+
15463                "\2\2\u039a\u0380\3\2\2\2\u039a\u0381\3\2\2\2\u039a\u0382\3\2\2\2\u039a"+
15464                "\u0383\3\2\2\2\u039a\u0384\3\2\2\2\u039a\u0385\3\2\2\2\u039a\u0386\3\2"+
15465                "\2\2\u039a\u0387\3\2\2\2\u039a\u0388\3\2\2\2\u039a\u0389\3\2\2\2\u039a"+
15466                "\u038a\3\2\2\2\u039a\u038b\3\2\2\2\u039a\u038c\3\2\2\2\u039a\u038d\3\2"+
15467                "\2\2\u039a\u038e\3\2\2\2\u039a\u038f\3\2\2\2\u039a\u0390\3\2\2\2\u039a"+
15468                "\u0391\3\2\2\2\u039a\u0392\3\2\2\2\u039a\u0393\3\2\2\2\u039a\u0395\3\2"+
15469                "\2\2\u039a\u0396\3\2\2\2\u039a\u0397\3\2\2\2\u039a\u0398\3\2\2\2\u039a"+
15470                "\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2"+
15471                "\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a0\5@!\2\u03a0C"+
15472                "\3\2\2\2\u03a1\u03a2\7\7\2\2\u03a2\u03a9\7F\2\2\u03a3\u03a8\5\n\6\2\u03a4"+
15473                "\u03a8\7\b\2\2\u03a5\u03a8\7\3\2\2\u03a6\u03a8\7\6\2\2\u03a7\u03a3\3\2"+
15474                "\2\2\u03a7\u03a4\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a6\3\2\2\2\u03a8"+
15475                "\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa\u03ac\3\2"+
15476                "\2\2\u03ab\u03a9\3\2\2\2\u03ac\u03ad\79\2\2\u03adE\3\2\2\2\u03ae\u03af"+
15477                "\7\7\2\2\u03af\u03b0\7;\2\2\u03b0\u03b4\7F\2\2\u03b1\u03b3\t\2\2\2\u03b2"+
15478                "\u03b1\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2"+
15479                "\2\2\u03b5\u03b7\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03b8\79\2\2\u03b8"+
15480                "G\3\2\2\2\u03b9\u03e1\5D#\2\u03ba\u03e0\5\f\7\2\u03bb\u03e0\5j\66\2\u03bc"+
15481                "\u03e0\5\22\n\2\u03bd\u03e0\5\30\r\2\u03be\u03e0\5\36\20\2\u03bf\u03e0"+
15482                "\5$\23\2\u03c0\u03e0\5*\26\2\u03c1\u03e0\5\60\31\2\u03c2\u03e0\5\66\34"+
15483                "\2\u03c3\u03e0\5<\37\2\u03c4\u03e0\5B\"\2\u03c5\u03e0\5N(\2\u03c6\u03e0"+
15484                "\5T+\2\u03c7\u03e0\5Z.\2\u03c8\u03e0\5f\64\2\u03c9\u03e0\5`\61\2\u03ca"+
15485                "\u03e0\5\16\b\2\u03cb\u03e0\5\24\13\2\u03cc\u03e0\5\32\16\2\u03cd\u03e0"+
15486                "\5 \21\2\u03ce\u03e0\5&\24\2\u03cf\u03e0\5,\27\2\u03d0\u03e0\5\62\32\2"+
15487                "\u03d1\u03e0\58\35\2\u03d2\u03e0\5> \2\u03d3\u03e0\5J&\2\u03d4\u03e0\5"+
15488                "P)\2\u03d5\u03e0\5V,\2\u03d6\u03e0\5b\62\2\u03d7\u03e0\5\\/\2\u03d8\u03d9"+
15489                "\6%\16\2\u03d9\u03e0\7\3\2\2\u03da\u03e0\5\u0094K\2\u03db\u03e0\7\5\2"+
15490                "\2\u03dc\u03e0\7\b\2\2\u03dd\u03e0\5\u0096L\2\u03de\u03e0\5\u0092J\2\u03df"+
15491                "\u03ba\3\2\2\2\u03df\u03bb\3\2\2\2\u03df\u03bc\3\2\2\2\u03df\u03bd\3\2"+
15492                "\2\2\u03df\u03be\3\2\2\2\u03df\u03bf\3\2\2\2\u03df\u03c0\3\2\2\2\u03df"+
15493                "\u03c1\3\2\2\2\u03df\u03c2\3\2\2\2\u03df\u03c3\3\2\2\2\u03df\u03c4\3\2"+
15494                "\2\2\u03df\u03c5\3\2\2\2\u03df\u03c6\3\2\2\2\u03df\u03c7\3\2\2\2\u03df"+
15495                "\u03c8\3\2\2\2\u03df\u03c9\3\2\2\2\u03df\u03ca\3\2\2\2\u03df\u03cb\3\2"+
15496                "\2\2\u03df\u03cc\3\2\2\2\u03df\u03cd\3\2\2\2\u03df\u03ce\3\2\2\2\u03df"+
15497                "\u03cf\3\2\2\2\u03df\u03d0\3\2\2\2\u03df\u03d1\3\2\2\2\u03df\u03d2\3\2"+
15498                "\2\2\u03df\u03d3\3\2\2\2\u03df\u03d4\3\2\2\2\u03df\u03d5\3\2\2\2\u03df"+
15499                "\u03d6\3\2\2\2\u03df\u03d7\3\2\2\2\u03df\u03d8\3\2\2\2\u03df\u03da\3\2"+
15500                "\2\2\u03df\u03db\3\2\2\2\u03df\u03dc\3\2\2\2\u03df\u03dd\3\2\2\2\u03df"+
15501                "\u03de\3\2\2\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2"+
15502                "\2\2\u03e2\u03e4\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5F$\2\u03e5I"+
15503                "\3\2\2\2\u03e6\u03e7\7\7\2\2\u03e7\u03ee\7G\2\2\u03e8\u03ed\5\n\6\2\u03e9"+
15504                "\u03ed\7\b\2\2\u03ea\u03ed\7\3\2\2\u03eb\u03ed\7\6\2\2\u03ec\u03e8\3\2"+
15505                "\2\2\u03ec\u03e9\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03eb\3\2\2\2\u03ed"+
15506                "\u03f0\3\2\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f1\3\2"+
15507                "\2\2\u03f0\u03ee\3\2\2\2\u03f1\u03f2\79\2\2\u03f2K\3\2\2\2\u03f3\u03f4"+
15508                "\7\7\2\2\u03f4\u03f5\7;\2\2\u03f5\u03f9\7G\2\2\u03f6\u03f8\t\2\2\2\u03f7"+
15509                "\u03f6\3\2\2\2\u03f8\u03fb\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2"+
15510                "\2\2\u03fa\u03fc\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u03fd\79\2\2\u03fd"+
15511                "M\3\2\2\2\u03fe\u0426\5J&\2\u03ff\u0425\5\f\7\2\u0400\u0425\5j\66\2\u0401"+
15512                "\u0425\5\22\n\2\u0402\u0425\5\30\r\2\u0403\u0425\5\36\20\2\u0404\u0425"+
15513                "\5$\23\2\u0405\u0425\5*\26\2\u0406\u0425\5\60\31\2\u0407\u0425\5\66\34"+
15514                "\2\u0408\u0425\5<\37\2\u0409\u0425\5B\"\2\u040a\u0425\5H%\2\u040b\u0425"+
15515                "\5T+\2\u040c\u0425\5Z.\2\u040d\u0425\5f\64\2\u040e\u0425\5`\61\2\u040f"+
15516                "\u0425\5\16\b\2\u0410\u0425\5\24\13\2\u0411\u0425\5\32\16\2\u0412\u0425"+
15517                "\5 \21\2\u0413\u0425\5&\24\2\u0414\u0425\5,\27\2\u0415\u0425\5\62\32\2"+
15518                "\u0416\u0425\58\35\2\u0417\u0425\5> \2\u0418\u0425\5D#\2\u0419\u0425\5"+
15519                "P)\2\u041a\u0425\5V,\2\u041b\u0425\5b\62\2\u041c\u0425\5\\/\2\u041d\u041e"+
15520                "\6(\17\2\u041e\u0425\7\3\2\2\u041f\u0425\5\u0094K\2\u0420\u0425\7\5\2"+
15521                "\2\u0421\u0425\7\b\2\2\u0422\u0425\5\u0096L\2\u0423\u0425\5\u0092J\2\u0424"+
15522                "\u03ff\3\2\2\2\u0424\u0400\3\2\2\2\u0424\u0401\3\2\2\2\u0424\u0402\3\2"+
15523                "\2\2\u0424\u0403\3\2\2\2\u0424\u0404\3\2\2\2\u0424\u0405\3\2\2\2\u0424"+
15524                "\u0406\3\2\2\2\u0424\u0407\3\2\2\2\u0424\u0408\3\2\2\2\u0424\u0409\3\2"+
15525                "\2\2\u0424\u040a\3\2\2\2\u0424\u040b\3\2\2\2\u0424\u040c\3\2\2\2\u0424"+
15526                "\u040d\3\2\2\2\u0424\u040e\3\2\2\2\u0424\u040f\3\2\2\2\u0424\u0410\3\2"+
15527                "\2\2\u0424\u0411\3\2\2\2\u0424\u0412\3\2\2\2\u0424\u0413\3\2\2\2\u0424"+
15528                "\u0414\3\2\2\2\u0424\u0415\3\2\2\2\u0424\u0416\3\2\2\2\u0424\u0417\3\2"+
15529                "\2\2\u0424\u0418\3\2\2\2\u0424\u0419\3\2\2\2\u0424\u041a\3\2\2\2\u0424"+
15530                "\u041b\3\2\2\2\u0424\u041c\3\2\2\2\u0424\u041d\3\2\2\2\u0424\u041f\3\2"+
15531                "\2\2\u0424\u0420\3\2\2\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424"+
15532                "\u0423\3\2\2\2\u0425\u0428\3\2\2\2\u0426\u0424\3\2\2\2\u0426\u0427\3\2"+
15533                "\2\2\u0427\u0429\3\2\2\2\u0428\u0426\3\2\2\2\u0429\u042a\5L\'\2\u042a"+
15534                "O\3\2\2\2\u042b\u042c\7\7\2\2\u042c\u0433\7H\2\2\u042d\u0432\5\n\6\2\u042e"+
15535                "\u0432\7\b\2\2\u042f\u0432\7\3\2\2\u0430\u0432\7\6\2\2\u0431\u042d\3\2"+
15536                "\2\2\u0431\u042e\3\2\2\2\u0431\u042f\3\2\2\2\u0431\u0430\3\2\2\2\u0432"+
15537                "\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434\u0436\3\2"+
15538                "\2\2\u0435\u0433\3\2\2\2\u0436\u0437\79\2\2\u0437Q\3\2\2\2\u0438\u0439"+
15539                "\7\7\2\2\u0439\u043a\7;\2\2\u043a\u043e\7H\2\2\u043b\u043d\t\2\2\2\u043c"+
15540                "\u043b\3\2\2\2\u043d\u0440\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2"+
15541                "\2\2\u043f\u0441\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0442\79\2\2\u0442"+
15542                "S\3\2\2\2\u0443\u046b\5P)\2\u0444\u046a\5\f\7\2\u0445\u046a\5j\66\2\u0446"+
15543                "\u046a\5\22\n\2\u0447\u046a\5\30\r\2\u0448\u046a\5\36\20\2\u0449\u046a"+
15544                "\5$\23\2\u044a\u046a\5*\26\2\u044b\u046a\5\60\31\2\u044c\u046a\5\66\34"+
15545                "\2\u044d\u046a\5<\37\2\u044e\u046a\5B\"\2\u044f\u046a\5H%\2\u0450\u046a"+
15546                "\5N(\2\u0451\u046a\5Z.\2\u0452\u046a\5f\64\2\u0453\u046a\5`\61\2\u0454"+
15547                "\u046a\5\16\b\2\u0455\u046a\5\24\13\2\u0456\u046a\5\32\16\2\u0457\u046a"+
15548                "\5 \21\2\u0458\u046a\5&\24\2\u0459\u046a\5,\27\2\u045a\u046a\5\62\32\2"+
15549                "\u045b\u046a\58\35\2\u045c\u046a\5> \2\u045d\u046a\5D#\2\u045e\u046a\5"+
15550                "J&\2\u045f\u046a\5V,\2\u0460\u046a\5b\62\2\u0461\u046a\5\\/\2\u0462\u0463"+
15551                "\6+\20\2\u0463\u046a\7\3\2\2\u0464\u046a\5\u0094K\2\u0465\u046a\7\5\2"+
15552                "\2\u0466\u046a\7\b\2\2\u0467\u046a\5\u0096L\2\u0468\u046a\5\u0092J\2\u0469"+
15553                "\u0444\3\2\2\2\u0469\u0445\3\2\2\2\u0469\u0446\3\2\2\2\u0469\u0447\3\2"+
15554                "\2\2\u0469\u0448\3\2\2\2\u0469\u0449\3\2\2\2\u0469\u044a\3\2\2\2\u0469"+
15555                "\u044b\3\2\2\2\u0469\u044c\3\2\2\2\u0469\u044d\3\2\2\2\u0469\u044e\3\2"+
15556                "\2\2\u0469\u044f\3\2\2\2\u0469\u0450\3\2\2\2\u0469\u0451\3\2\2\2\u0469"+
15557                "\u0452\3\2\2\2\u0469\u0453\3\2\2\2\u0469\u0454\3\2\2\2\u0469\u0455\3\2"+
15558                "\2\2\u0469\u0456\3\2\2\2\u0469\u0457\3\2\2\2\u0469\u0458\3\2\2\2\u0469"+
15559                "\u0459\3\2\2\2\u0469\u045a\3\2\2\2\u0469\u045b\3\2\2\2\u0469\u045c\3\2"+
15560                "\2\2\u0469\u045d\3\2\2\2\u0469\u045e\3\2\2\2\u0469\u045f\3\2\2\2\u0469"+
15561                "\u0460\3\2\2\2\u0469\u0461\3\2\2\2\u0469\u0462\3\2\2\2\u0469\u0464\3\2"+
15562                "\2\2\u0469\u0465\3\2\2\2\u0469\u0466\3\2\2\2\u0469\u0467\3\2\2\2\u0469"+
15563                "\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b\u046c\3\2"+
15564                "\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u046f\5R*\2\u046fU"+
15565                "\3\2\2\2\u0470\u0471\7\7\2\2\u0471\u0478\7I\2\2\u0472\u0477\5\n\6\2\u0473"+
15566                "\u0477\7\b\2\2\u0474\u0477\7\3\2\2\u0475\u0477\7\6\2\2\u0476\u0472\3\2"+
15567                "\2\2\u0476\u0473\3\2\2\2\u0476\u0474\3\2\2\2\u0476\u0475\3\2\2\2\u0477"+
15568                "\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3\2\2\2\u0479\u047b\3\2"+
15569                "\2\2\u047a\u0478\3\2\2\2\u047b\u047c\79\2\2\u047cW\3\2\2\2\u047d\u047e"+
15570                "\7\7\2\2\u047e\u047f\7;\2\2\u047f\u0483\7I\2\2\u0480\u0482\t\2\2\2\u0481"+
15571                "\u0480\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484\3\2"+
15572                "\2\2\u0484\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0487\79\2\2\u0487"+
15573                "Y\3\2\2\2\u0488\u04b0\5V,\2\u0489\u04af\5\f\7\2\u048a\u04af\5j\66\2\u048b"+
15574                "\u04af\5\22\n\2\u048c\u04af\5\30\r\2\u048d\u04af\5\36\20\2\u048e\u04af"+
15575                "\5$\23\2\u048f\u04af\5*\26\2\u0490\u04af\5\60\31\2\u0491\u04af\5\66\34"+
15576                "\2\u0492\u04af\5<\37\2\u0493\u04af\5B\"\2\u0494\u04af\5H%\2\u0495\u04af"+
15577                "\5N(\2\u0496\u04af\5T+\2\u0497\u04af\5f\64\2\u0498\u04af\5`\61\2\u0499"+
15578                "\u04af\5\16\b\2\u049a\u04af\5\24\13\2\u049b\u04af\5\32\16\2\u049c\u04af"+
15579                "\5 \21\2\u049d\u04af\5&\24\2\u049e\u04af\5,\27\2\u049f\u04af\5\62\32\2"+
15580                "\u04a0\u04af\58\35\2\u04a1\u04af\5> \2\u04a2\u04af\5D#\2\u04a3\u04af\5"+
15581                "J&\2\u04a4\u04af\5P)\2\u04a5\u04af\5b\62\2\u04a6\u04af\5\\/\2\u04a7\u04a8"+
15582                "\6.\21\2\u04a8\u04af\7\3\2\2\u04a9\u04af\5\u0094K\2\u04aa\u04af\7\5\2"+
15583                "\2\u04ab\u04af\7\b\2\2\u04ac\u04af\5\u0096L\2\u04ad\u04af\5\u0092J\2\u04ae"+
15584                "\u0489\3\2\2\2\u04ae\u048a\3\2\2\2\u04ae\u048b\3\2\2\2\u04ae\u048c\3\2"+
15585                "\2\2\u04ae\u048d\3\2\2\2\u04ae\u048e\3\2\2\2\u04ae\u048f\3\2\2\2\u04ae"+
15586                "\u0490\3\2\2\2\u04ae\u0491\3\2\2\2\u04ae\u0492\3\2\2\2\u04ae\u0493\3\2"+
15587                "\2\2\u04ae\u0494\3\2\2\2\u04ae\u0495\3\2\2\2\u04ae\u0496\3\2\2\2\u04ae"+
15588                "\u0497\3\2\2\2\u04ae\u0498\3\2\2\2\u04ae\u0499\3\2\2\2\u04ae\u049a\3\2"+
15589                "\2\2\u04ae\u049b\3\2\2\2\u04ae\u049c\3\2\2\2\u04ae\u049d\3\2\2\2\u04ae"+
15590                "\u049e\3\2\2\2\u04ae\u049f\3\2\2\2\u04ae\u04a0\3\2\2\2\u04ae\u04a1\3\2"+
15591                "\2\2\u04ae\u04a2\3\2\2\2\u04ae\u04a3\3\2\2\2\u04ae\u04a4\3\2\2\2\u04ae"+
15592                "\u04a5\3\2\2\2\u04ae\u04a6\3\2\2\2\u04ae\u04a7\3\2\2\2\u04ae\u04a9\3\2"+
15593                "\2\2\u04ae\u04aa\3\2\2\2\u04ae\u04ab\3\2\2\2\u04ae\u04ac\3\2\2\2\u04ae"+
15594                "\u04ad\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b0\u04b1\3\2"+
15595                "\2\2\u04b1\u04b3\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3\u04b4\5X-\2\u04b4["+
15596                "\3\2\2\2\u04b5\u04b6\7\7\2\2\u04b6\u04bd\7J\2\2\u04b7\u04bc\5\n\6\2\u04b8"+
15597                "\u04bc\7\b\2\2\u04b9\u04bc\7\3\2\2\u04ba\u04bc\7\6\2\2\u04bb\u04b7\3\2"+
15598                "\2\2\u04bb\u04b8\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bb\u04ba\3\2\2\2\u04bc"+
15599                "\u04bf\3\2\2\2\u04bd\u04bb\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04c0\3\2"+
15600                "\2\2\u04bf\u04bd\3\2\2\2\u04c0\u04c1\79\2\2\u04c1]\3\2\2\2\u04c2\u04c3"+
15601                "\7\7\2\2\u04c3\u04c4\7;\2\2\u04c4\u04c8\7J\2\2\u04c5\u04c7\t\2\2\2\u04c6"+
15602                "\u04c5\3\2\2\2\u04c7\u04ca\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c8\u04c9\3\2"+
15603                "\2\2\u04c9\u04cb\3\2\2\2\u04ca\u04c8\3\2\2\2\u04cb\u04cc\79\2\2\u04cc"+
15604                "_\3\2\2\2\u04cd\u04f5\5\\/\2\u04ce\u04f4\5\f\7\2\u04cf\u04f4\5j\66\2\u04d0"+
15605                "\u04f4\5\22\n\2\u04d1\u04f4\5\30\r\2\u04d2\u04f4\5\36\20\2\u04d3\u04f4"+
15606                "\5$\23\2\u04d4\u04f4\5*\26\2\u04d5\u04f4\5\60\31\2\u04d6\u04f4\5\66\34"+
15607                "\2\u04d7\u04f4\5<\37\2\u04d8\u04f4\5B\"\2\u04d9\u04f4\5H%\2\u04da\u04f4"+
15608                "\5N(\2\u04db\u04f4\5T+\2\u04dc\u04f4\5Z.\2\u04dd\u04f4\5f\64\2\u04de\u04f4"+
15609                "\5\16\b\2\u04df\u04f4\5\24\13\2\u04e0\u04f4\5\32\16\2\u04e1\u04f4\5 \21"+
15610                "\2\u04e2\u04f4\5&\24\2\u04e3\u04f4\5,\27\2\u04e4\u04f4\5\62\32\2\u04e5"+
15611                "\u04f4\58\35\2\u04e6\u04f4\5> \2\u04e7\u04f4\5D#\2\u04e8\u04f4\5J&\2\u04e9"+
15612                "\u04f4\5P)\2\u04ea\u04f4\5V,\2\u04eb\u04f4\5b\62\2\u04ec\u04ed\6\61\22"+
15613                "\2\u04ed\u04f4\7\3\2\2\u04ee\u04f4\5\u0094K\2\u04ef\u04f4\7\5\2\2\u04f0"+
15614                "\u04f4\7\b\2\2\u04f1\u04f4\5\u0096L\2\u04f2\u04f4\5\u0092J\2\u04f3\u04ce"+
15615                "\3\2\2\2\u04f3\u04cf\3\2\2\2\u04f3\u04d0\3\2\2\2\u04f3\u04d1\3\2\2\2\u04f3"+
15616                "\u04d2\3\2\2\2\u04f3\u04d3\3\2\2\2\u04f3\u04d4\3\2\2\2\u04f3\u04d5\3\2"+
15617                "\2\2\u04f3\u04d6\3\2\2\2\u04f3\u04d7\3\2\2\2\u04f3\u04d8\3\2\2\2\u04f3"+
15618                "\u04d9\3\2\2\2\u04f3\u04da\3\2\2\2\u04f3\u04db\3\2\2\2\u04f3\u04dc\3\2"+
15619                "\2\2\u04f3\u04dd\3\2\2\2\u04f3\u04de\3\2\2\2\u04f3\u04df\3\2\2\2\u04f3"+
15620                "\u04e0\3\2\2\2\u04f3\u04e1\3\2\2\2\u04f3\u04e2\3\2\2\2\u04f3\u04e3\3\2"+
15621                "\2\2\u04f3\u04e4\3\2\2\2\u04f3\u04e5\3\2\2\2\u04f3\u04e6\3\2\2\2\u04f3"+
15622                "\u04e7\3\2\2\2\u04f3\u04e8\3\2\2\2\u04f3\u04e9\3\2\2\2\u04f3\u04ea\3\2"+
15623                "\2\2\u04f3\u04eb\3\2\2\2\u04f3\u04ec\3\2\2\2\u04f3\u04ee\3\2\2\2\u04f3"+
15624                "\u04ef\3\2\2\2\u04f3\u04f0\3\2\2\2\u04f3\u04f1\3\2\2\2\u04f3\u04f2\3\2"+
15625                "\2\2\u04f4\u04f7\3\2\2\2\u04f5\u04f3\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6"+
15626                "\u04f8\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f8\u04f9\5^\60\2\u04f9a\3\2\2\2"+
15627                "\u04fa\u04fb\7\7\2\2\u04fb\u0502\7K\2\2\u04fc\u0501\5\n\6\2\u04fd\u0501"+
15628                "\7\b\2\2\u04fe\u0501\7\3\2\2\u04ff\u0501\7\6\2\2\u0500\u04fc\3\2\2\2\u0500"+
15629                "\u04fd\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u04ff\3\2\2\2\u0501\u0504\3\2"+
15630                "\2\2\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0505\3\2\2\2\u0504"+
15631                "\u0502\3\2\2\2\u0505\u0506\79\2\2\u0506c\3\2\2\2\u0507\u0508\7\7\2\2\u0508"+
15632                "\u0509\7;\2\2\u0509\u050d\7K\2\2\u050a\u050c\t\2\2\2\u050b\u050a\3\2\2"+
15633                "\2\u050c\u050f\3\2\2\2\u050d\u050b\3\2\2\2\u050d\u050e\3\2\2\2\u050e\u0510"+
15634                "\3\2\2\2\u050f\u050d\3\2\2\2\u0510\u0511\79\2\2\u0511e\3\2\2\2\u0512\u053a"+
15635                "\5b\62\2\u0513\u0539\5\f\7\2\u0514\u0539\5j\66\2\u0515\u0539\5\22\n\2"+
15636                "\u0516\u0539\5\30\r\2\u0517\u0539\5\36\20\2\u0518\u0539\5$\23\2\u0519"+
15637                "\u0539\5*\26\2\u051a\u0539\5\60\31\2\u051b\u0539\5\66\34\2\u051c\u0539"+
15638                "\5<\37\2\u051d\u0539\5B\"\2\u051e\u0539\5H%\2\u051f\u0539\5N(\2\u0520"+
15639                "\u0539\5T+\2\u0521\u0539\5Z.\2\u0522\u0539\5`\61\2\u0523\u0539\5\16\b"+
15640                "\2\u0524\u0539\5\24\13\2\u0525\u0539\5\32\16\2\u0526\u0539\5 \21\2\u0527"+
15641                "\u0539\5&\24\2\u0528\u0539\5,\27\2\u0529\u0539\5\62\32\2\u052a\u0539\5"+
15642                "8\35\2\u052b\u0539\5> \2\u052c\u0539\5D#\2\u052d\u0539\5J&\2\u052e\u0539"+
15643                "\5P)\2\u052f\u0539\5V,\2\u0530\u0539\5\\/\2\u0531\u0532\6\64\23\2\u0532"+
15644                "\u0539\7\3\2\2\u0533\u0539\5\u0094K\2\u0534\u0539\7\5\2\2\u0535\u0539"+
15645                "\7\b\2\2\u0536\u0539\5\u0096L\2\u0537\u0539\5\u0092J\2\u0538\u0513\3\2"+
15646                "\2\2\u0538\u0514\3\2\2\2\u0538\u0515\3\2\2\2\u0538\u0516\3\2\2\2\u0538"+
15647                "\u0517\3\2\2\2\u0538\u0518\3\2\2\2\u0538\u0519\3\2\2\2\u0538\u051a\3\2"+
15648                "\2\2\u0538\u051b\3\2\2\2\u0538\u051c\3\2\2\2\u0538\u051d\3\2\2\2\u0538"+
15649                "\u051e\3\2\2\2\u0538\u051f\3\2\2\2\u0538\u0520\3\2\2\2\u0538\u0521\3\2"+
15650                "\2\2\u0538\u0522\3\2\2\2\u0538\u0523\3\2\2\2\u0538\u0524\3\2\2\2\u0538"+
15651                "\u0525\3\2\2\2\u0538\u0526\3\2\2\2\u0538\u0527\3\2\2\2\u0538\u0528\3\2"+
15652                "\2\2\u0538\u0529\3\2\2\2\u0538\u052a\3\2\2\2\u0538\u052b\3\2\2\2\u0538"+
15653                "\u052c\3\2\2\2\u0538\u052d\3\2\2\2\u0538\u052e\3\2\2\2\u0538\u052f\3\2"+
15654                "\2\2\u0538\u0530\3\2\2\2\u0538\u0531\3\2\2\2\u0538\u0533\3\2\2\2\u0538"+
15655                "\u0534\3\2\2\2\u0538\u0535\3\2\2\2\u0538\u0536\3\2\2\2\u0538\u0537\3\2"+
15656                "\2\2\u0539\u053c\3\2\2\2\u053a\u0538\3\2\2\2\u053a\u053b\3\2\2\2\u053b"+
15657                "\u053d\3\2\2\2\u053c\u053a\3\2\2\2\u053d\u053e\5d\63\2\u053eg\3\2\2\2"+
15658                "\u053f\u054f\5j\66\2\u0540\u054f\5l\67\2\u0541\u054f\5n8\2\u0542\u054f"+
15659                "\5p9\2\u0543\u054f\5r:\2\u0544\u054f\5t;\2\u0545\u054f\5v<\2\u0546\u054f"+
15660                "\5x=\2\u0547\u054f\5z>\2\u0548\u054f\5|?\2\u0549\u054f\5~@\2\u054a\u054f"+
15661                "\5\u0080A\2\u054b\u054f\5\u0082B\2\u054c\u054f\5\u0084C\2\u054d\u054f"+
15662                "\5\u0086D\2\u054e\u053f\3\2\2\2\u054e\u0540\3\2\2\2\u054e\u0541\3\2\2"+
15663                "\2\u054e\u0542\3\2\2\2\u054e\u0543\3\2\2\2\u054e\u0544\3\2\2\2\u054e\u0545"+
15664                "\3\2\2\2\u054e\u0546\3\2\2\2\u054e\u0547\3\2\2\2\u054e\u0548\3\2\2\2\u054e"+
15665                "\u0549\3\2\2\2\u054e\u054a\3\2\2\2\u054e\u054b\3\2\2\2\u054e\u054c\3\2"+
15666                "\2\2\u054e\u054d\3\2\2\2\u054fi\3\2\2\2\u0550\u0551\7\7\2\2\u0551\u0558"+
15667                "\t\3\2\2\u0552\u0557\5\n\6\2\u0553\u0557\7\b\2\2\u0554\u0557\7\3\2\2\u0555"+
15668                "\u0557\7\6\2\2\u0556\u0552\3\2\2\2\u0556\u0553\3\2\2\2\u0556\u0554\3\2"+
15669                "\2\2\u0556\u0555\3\2\2\2\u0557\u055a\3\2\2\2\u0558\u0556\3\2\2\2\u0558"+
15670                "\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7:"+
15671                "\2\2\u055ck\3\2\2\2\u055d\u055e\7\7\2\2\u055e\u0565\7L\2\2\u055f\u0564"+
15672                "\5\n\6\2\u0560\u0564\7\b\2\2\u0561\u0564\7\3\2\2\u0562\u0564\7\6\2\2\u0563"+
15673                "\u055f\3\2\2\2\u0563\u0560\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0562\3\2"+
15674                "\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0565\u0566\3\2\2\2\u0566"+
15675                "\u0568\3\2\2\2\u0567\u0565\3\2\2\2\u0568\u0569\t\4\2\2\u0569m\3\2\2\2"+
15676                "\u056a\u056b\7\7\2\2\u056b\u0572\7M\2\2\u056c\u0571\5\n\6\2\u056d\u0571"+
15677                "\7\b\2\2\u056e\u0571\7\3\2\2\u056f\u0571\7\6\2\2\u0570\u056c\3\2\2\2\u0570"+
15678                "\u056d\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2"+
15679                "\2\2\u0572\u0570\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574"+
15680                "\u0572\3\2\2\2\u0575\u0576\t\4\2\2\u0576o\3\2\2\2\u0577\u0578\7\7\2\2"+
15681                "\u0578\u057f\7N\2\2\u0579\u057e\5\n\6\2\u057a\u057e\7\b\2\2\u057b\u057e"+
15682                "\7\3\2\2\u057c\u057e\7\6\2\2\u057d\u0579\3\2\2\2\u057d\u057a\3\2\2\2\u057d"+
15683                "\u057b\3\2\2\2\u057d\u057c\3\2\2\2\u057e\u0581\3\2\2\2\u057f\u057d\3\2"+
15684                "\2\2\u057f\u0580\3\2\2\2\u0580\u0582\3\2\2\2\u0581\u057f\3\2\2\2\u0582"+
15685                "\u0583\t\4\2\2\u0583q\3\2\2\2\u0584\u0585\7\7\2\2\u0585\u058c\7O\2\2\u0586"+
15686                "\u058b\5\n\6\2\u0587\u058b\7\b\2\2\u0588\u058b\7\3\2\2\u0589\u058b\7\6"+
15687                "\2\2\u058a\u0586\3\2\2\2\u058a\u0587\3\2\2\2\u058a\u0588\3\2\2\2\u058a"+
15688                "\u0589\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3\2\2\2\u058c\u058d\3\2"+
15689                "\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f\u0590\t\4\2\2\u0590"+
15690                "s\3\2\2\2\u0591\u0592\7\7\2\2\u0592\u0599\7P\2\2\u0593\u0598\5\n\6\2\u0594"+
15691                "\u0598\7\b\2\2\u0595\u0598\7\3\2\2\u0596\u0598\7\6\2\2\u0597\u0593\3\2"+
15692                "\2\2\u0597\u0594\3\2\2\2\u0597\u0595\3\2\2\2\u0597\u0596\3\2\2\2\u0598"+
15693                "\u059b\3\2\2\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059c\3\2"+
15694                "\2\2\u059b\u0599\3\2\2\2\u059c\u059d\t\4\2\2\u059du\3\2\2\2\u059e\u059f"+
15695                "\7\7\2\2\u059f\u05a6\7Q\2\2\u05a0\u05a5\5\n\6\2\u05a1\u05a5\7\b\2\2\u05a2"+
15696                "\u05a5\7\3\2\2\u05a3\u05a5\7\6\2\2\u05a4\u05a0\3\2\2\2\u05a4\u05a1\3\2"+
15697                "\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a3\3\2\2\2\u05a5\u05a8\3\2\2\2\u05a6"+
15698                "\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7\u05a9\3\2\2\2\u05a8\u05a6\3\2"+
15699                "\2\2\u05a9\u05aa\t\4\2\2\u05aaw\3\2\2\2\u05ab\u05ac\7\7\2\2\u05ac\u05b3"+
15700                "\7R\2\2\u05ad\u05b2\5\n\6\2\u05ae\u05b2\7\b\2\2\u05af\u05b2\7\3\2\2\u05b0"+
15701                "\u05b2\7\6\2\2\u05b1\u05ad\3\2\2\2\u05b1\u05ae\3\2\2\2\u05b1\u05af\3\2"+
15702                "\2\2\u05b1\u05b0\3\2\2\2\u05b2\u05b5\3\2\2\2\u05b3\u05b1\3\2\2\2\u05b3"+
15703                "\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05b3\3\2\2\2\u05b6\u05b7\t\4"+
15704                "\2\2\u05b7y\3\2\2\2\u05b8\u05b9\7\7\2\2\u05b9\u05c0\7S\2\2\u05ba\u05bf"+
15705                "\5\n\6\2\u05bb\u05bf\7\b\2\2\u05bc\u05bf\7\3\2\2\u05bd\u05bf\7\6\2\2\u05be"+
15706                "\u05ba\3\2\2\2\u05be\u05bb\3\2\2\2\u05be\u05bc\3\2\2\2\u05be\u05bd\3\2"+
15707                "\2\2\u05bf\u05c2\3\2\2\2\u05c0\u05be\3\2\2\2\u05c0\u05c1\3\2\2\2\u05c1"+
15708                "\u05c3\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c3\u05c4\t\4\2\2\u05c4{\3\2\2\2"+
15709                "\u05c5\u05c6\7\7\2\2\u05c6\u05cd\7T\2\2\u05c7\u05cc\5\n\6\2\u05c8\u05cc"+
15710                "\7\b\2\2\u05c9\u05cc\7\3\2\2\u05ca\u05cc\7\6\2\2\u05cb\u05c7\3\2\2\2\u05cb"+
15711                "\u05c8\3\2\2\2\u05cb\u05c9\3\2\2\2\u05cb\u05ca\3\2\2\2\u05cc\u05cf\3\2"+
15712                "\2\2\u05cd\u05cb\3\2\2\2\u05cd\u05ce\3\2\2\2\u05ce\u05d0\3\2\2\2\u05cf"+
15713                "\u05cd\3\2\2\2\u05d0\u05d1\t\4\2\2\u05d1}\3\2\2\2\u05d2\u05d3\7\7\2\2"+
15714                "\u05d3\u05da\7U\2\2\u05d4\u05d9\5\n\6\2\u05d5\u05d9\7\b\2\2\u05d6\u05d9"+
15715                "\7\3\2\2\u05d7\u05d9\7\6\2\2\u05d8\u05d4\3\2\2\2\u05d8\u05d5\3\2\2\2\u05d8"+
15716                "\u05d6\3\2\2\2\u05d8\u05d7\3\2\2\2\u05d9\u05dc\3\2\2\2\u05da\u05d8\3\2"+
15717                "\2\2\u05da\u05db\3\2\2\2\u05db\u05dd\3\2\2\2\u05dc\u05da\3\2\2\2\u05dd"+
15718                "\u05de\t\4\2\2\u05de\177\3\2\2\2\u05df\u05e0\7\7\2\2\u05e0\u05e7\7V\2"+
15719                "\2\u05e1\u05e6\5\n\6\2\u05e2\u05e6\7\b\2\2\u05e3\u05e6\7\3\2\2\u05e4\u05e6"+
15720                "\7\6\2\2\u05e5\u05e1\3\2\2\2\u05e5\u05e2\3\2\2\2\u05e5\u05e3\3\2\2\2\u05e5"+
15721                "\u05e4\3\2\2\2\u05e6\u05e9\3\2\2\2\u05e7\u05e5\3\2\2\2\u05e7\u05e8\3\2"+
15722                "\2\2\u05e8\u05ea\3\2\2\2\u05e9\u05e7\3\2\2\2\u05ea\u05eb\t\4\2\2\u05eb"+
15723                "\u0081\3\2\2\2\u05ec\u05ed\7\7\2\2\u05ed\u05f4\7W\2\2\u05ee\u05f3\5\n"+
15724                "\6\2\u05ef\u05f3\7\b\2\2\u05f0\u05f3\7\3\2\2\u05f1\u05f3\7\6\2\2\u05f2"+
15725                "\u05ee\3\2\2\2\u05f2\u05ef\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f2\u05f1\3\2"+
15726                "\2\2\u05f3\u05f6\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5"+
15727                "\u05f7\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f7\u05f8\t\4\2\2\u05f8\u0083\3\2"+
15728                "\2\2\u05f9\u05fa\7\7\2\2\u05fa\u0601\7X\2\2\u05fb\u0600\5\n\6\2\u05fc"+
15729                "\u0600\7\b\2\2\u05fd\u0600\7\3\2\2\u05fe\u0600\7\6\2\2\u05ff\u05fb\3\2"+
15730                "\2\2\u05ff\u05fc\3\2\2\2\u05ff\u05fd\3\2\2\2\u05ff\u05fe\3\2\2\2\u0600"+
15731                "\u0603\3\2\2\2\u0601\u05ff\3\2\2\2\u0601\u0602\3\2\2\2\u0602\u0604\3\2"+
15732                "\2\2\u0603\u0601\3\2\2\2\u0604\u0605\t\4\2\2\u0605\u0085\3\2\2\2\u0606"+
15733                "\u0607\7\7\2\2\u0607\u0608\7;\2\2\u0608\u0609\5\u0088E\2\u0609\u060a\7"+
15734                "9\2\2\u060a\u060b\bD\1\2\u060b\u0087\3\2\2\2\u060c\u060d\t\5\2\2\u060d"+
15735                "\u0089\3\2\2\2\u060e\u060f\6F\24\2\u060f\u0617\7\3\2\2\u0610\u0617\5\u0094"+
15736                "K\2\u0611\u0617\7\5\2\2\u0612\u0617\7\b\2\2\u0613\u0617\5\u0096L\2\u0614"+
15737                "\u0617\5\u0092J\2\u0615\u0617\5\4\3\2\u0616\u060e\3\2\2\2\u0616\u0610"+
15738                "\3\2\2\2\u0616\u0611\3\2\2\2\u0616\u0612\3\2\2\2\u0616\u0613\3\2\2\2\u0616"+
15739                "\u0614\3\2\2\2\u0616\u0615\3\2\2\2\u0617\u0618\3\2\2\2\u0618\u0616\3\2"+
15740                "\2\2\u0618\u0619\3\2\2\2\u0619\u008b\3\2\2\2\u061a\u061e\7\36\2\2\u061b"+
15741                "\u061d\t\6\2\2\u061c\u061b\3\2\2\2\u061d\u0620\3\2\2\2\u061e\u061c\3\2"+
15742                "\2\2\u061e\u061f\3\2\2\2\u061f\u0622\3\2\2\2\u0620\u061e\3\2\2\2\u0621"+
15743                "\u0623\7 \2\2\u0622\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2"+
15744                "\2\2\u0624\u0626\7#\2\2\u0625\u0624\3\2\2\2\u0625\u0626\3\2\2\2\u0626"+
15745                "\u0628\3\2\2\2\u0627\u0629\5\u008eH\2\u0628\u0627\3\2\2\2\u0628\u0629"+
15746                "\3\2\2\2\u0629\u0640\3\2\2\2\u062a\u062c\t\6\2\2\u062b\u062a\3\2\2\2\u062c"+
15747                "\u062d\3\2\2\2\u062d\u062b\3\2\2\2\u062d\u062e\3\2\2\2\u062e\u0630\3\2"+
15748                "\2\2\u062f\u0631\7 \2\2\u0630\u062f\3\2\2\2\u0630\u0631\3\2\2\2\u0631"+
15749                "\u0633\3\2\2\2\u0632\u0634\7#\2\2\u0633\u0632\3\2\2\2\u0633\u0634\3\2"+
15750                "\2\2\u0634\u0636\3\2\2\2\u0635\u0637\5\u008eH\2\u0636\u0635\3\2\2\2\u0636"+
15751                "\u0637\3\2\2\2\u0637\u0640\3\2\2\2\u0638\u063a\7 \2\2\u0639\u0638\3\2"+
15752                "\2\2\u0639\u063a\3\2\2\2\u063a\u063b\3\2\2\2\u063b\u063d\7#\2\2\u063c"+
15753                "\u063e\5\u008eH\2\u063d\u063c\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u0640"+
15754                "\3\2\2\2\u063f\u061a\3\2\2\2\u063f\u062b\3\2\2\2\u063f\u0639\3\2\2\2\u0640"+
15755                "\u008d\3\2\2\2\u0641\u0645\7$\2\2\u0642\u0644\t\7\2\2\u0643\u0642\3\2"+
15756                "\2\2\u0644\u0647\3\2\2\2\u0645\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646"+
15757                "\u0648\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649\7%\2\2\u0649\u008f\3\2"+
15758                "\2\2\u064a\u064e\7\t\2\2\u064b\u064d\t\b\2\2\u064c\u064b\3\2\2\2\u064d"+
15759                "\u0650\3\2\2\2\u064e\u064c\3\2\2\2\u064e\u064f\3\2\2\2\u064f\u0652\3\2"+
15760                "\2\2\u0650\u064e\3\2\2\2\u0651\u0653\5\u008aF\2\u0652\u0651\3\2\2\2\u0652"+
15761                "\u0653\3\2\2\2\u0653\u070d\3\2\2\2\u0654\u0658\7\n\2\2\u0655\u0657\t\b"+
15762                "\2\2\u0656\u0655\3\2\2\2\u0657\u065a\3\2\2\2\u0658\u0656\3\2\2\2\u0658"+
15763                "\u0659\3\2\2\2\u0659\u065c\3\2\2\2\u065a\u0658\3\2\2\2\u065b\u065d\5\u008a"+
15764                "F\2\u065c\u065b\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u070d\3\2\2\2\u065e"+
15765                "\u0662\7\13\2\2\u065f\u0661\t\b\2\2\u0660\u065f\3\2\2\2\u0661\u0664\3"+
15766                "\2\2\2\u0662\u0660\3\2\2\2\u0662\u0663\3\2\2\2\u0663\u0666\3\2\2\2\u0664"+
15767                "\u0662\3\2\2\2\u0665\u0667\7-\2\2\u0666\u0665\3\2\2\2\u0666\u0667\3\2"+
15768                "\2\2\u0667\u066b\3\2\2\2\u0668\u066a\t\b\2\2\u0669\u0668\3\2\2\2\u066a"+
15769                "\u066d\3\2\2\2\u066b\u0669\3\2\2\2\u066b\u066c\3\2\2\2\u066c\u066f\3\2"+
15770                "\2\2\u066d\u066b\3\2\2\2\u066e\u0670\5\u008aF\2\u066f\u066e\3\2\2\2\u066f"+
15771                "\u0670\3\2\2\2\u0670\u070d\3\2\2\2\u0671\u0675\7\f\2\2\u0672\u0674\t\b"+
15772                "\2\2\u0673\u0672\3\2\2\2\u0674\u0677\3\2\2\2\u0675\u0673\3\2\2\2\u0675"+
15773                "\u0676\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0675\3\2\2\2\u0678\u067a\7\33"+
15774                "\2\2\u0679\u0678\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067e\3\2\2\2\u067b"+
15775                "\u067d\t\b\2\2\u067c\u067b\3\2\2\2\u067d\u0680\3\2\2\2\u067e\u067c\3\2"+
15776                "\2\2\u067e\u067f\3\2\2\2\u067f\u0682\3\2\2\2\u0680\u067e\3\2\2\2\u0681"+
15777                "\u0683\5\u008aF\2\u0682\u0681\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u070d"+
15778                "\3\2\2\2\u0684\u0688\7\r\2\2\u0685\u0687\t\b\2\2\u0686\u0685\3\2\2\2\u0687"+
15779                "\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068c\3\2"+
15780                "\2\2\u068a\u0688\3\2\2\2\u068b\u068d\5\u008aF\2\u068c\u068b\3\2\2\2\u068c"+
15781                "\u068d\3\2\2\2\u068d\u070d\3\2\2\2\u068e\u0692\7\16\2\2\u068f\u0691\t"+
15782                "\b\2\2\u0690\u068f\3\2\2\2\u0691\u0694\3\2\2\2\u0692\u0690\3\2\2\2\u0692"+
15783                "\u0693\3\2\2\2\u0693\u0696\3\2\2\2\u0694\u0692\3\2\2\2\u0695\u0697\5\u008c"+
15784                "G\2\u0696\u0695\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u069c\3\2\2\2\u0698"+
15785                "\u069b\7\35\2\2\u0699\u069b\5\4\3\2\u069a\u0698\3\2\2\2\u069a\u0699\3"+
15786                "\2\2\2\u069b\u069e\3\2\2\2\u069c\u069a\3\2\2\2\u069c\u069d\3\2\2\2\u069d"+
15787                "\u06a2\3\2\2\2\u069e\u069c\3\2\2\2\u069f\u06a1\t\b\2\2\u06a0\u069f\3\2"+
15788                "\2\2\u06a1\u06a4\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3"+
15789                "\u06a6\3\2\2\2\u06a4\u06a2\3\2\2\2\u06a5\u06a7\5\u008aF\2\u06a6\u06a5"+
15790                "\3\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u070d\3\2\2\2\u06a8\u06ac\7\17\2\2"+
15791                "\u06a9\u06ab\t\b\2\2\u06aa\u06a9\3\2\2\2\u06ab\u06ae\3\2\2\2\u06ac\u06aa"+
15792                "\3\2\2\2\u06ac\u06ad\3\2\2\2\u06ad\u06b0\3\2\2\2\u06ae\u06ac\3\2\2\2\u06af"+
15793                "\u06b1\t\t\2\2\u06b0\u06af\3\2\2\2\u06b0\u06b1\3\2\2\2\u06b1\u06b3\3\2"+
15794                "\2\2\u06b2\u06b4\5\u008aF\2\u06b3\u06b2\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4"+
15795                "\u070d\3\2\2\2\u06b5\u06b9\7\21\2\2\u06b6\u06b8\t\b\2\2\u06b7\u06b6\3"+
15796                "\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba"+
15797                "\u06bd\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06be\5\u008aF\2\u06bd\u06bc"+
15798                "\3\2\2\2\u06bd\u06be\3\2\2\2\u06be\u070d\3\2\2\2\u06bf\u06c3\7\20\2\2"+
15799                "\u06c0\u06c2\t\b\2\2\u06c1\u06c0\3\2\2\2\u06c2\u06c5\3\2\2\2\u06c3\u06c1"+
15800                "\3\2\2\2\u06c3\u06c4\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5\u06c3\3\2\2\2\u06c6"+
15801                "\u06c8\7)\2\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06cc\3\2"+
15802                "\2\2\u06c9\u06cb\t\b\2\2\u06ca\u06c9\3\2\2\2\u06cb\u06ce\3\2\2\2\u06cc"+
15803                "\u06ca\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd\u06d0\3\2\2\2\u06ce\u06cc\3\2"+
15804                "\2\2\u06cf\u06d1\7+\2\2\u06d0\u06cf\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1"+
15805                "\u06d5\3\2\2\2\u06d2\u06d4\t\b\2\2\u06d3\u06d2\3\2\2\2\u06d4\u06d7\3\2"+
15806                "\2\2\u06d5\u06d3\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06d9\3\2\2\2\u06d7"+
15807                "\u06d5\3\2\2\2\u06d8\u06da\5\u008aF\2\u06d9\u06d8\3\2\2\2\u06d9\u06da"+
15808                "\3\2\2\2\u06da\u070d\3\2\2\2\u06db\u06df\7\22\2\2\u06dc\u06de\t\b\2\2"+
15809                "\u06dd\u06dc\3\2\2\2\u06de\u06e1\3\2\2\2\u06df\u06dd\3\2\2\2\u06df\u06e0"+
15810                "\3\2\2\2\u06e0\u06e3\3\2\2\2\u06e1\u06df\3\2\2\2\u06e2\u06e4\5\u008aF"+
15811                "\2\u06e3\u06e2\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u070d\3\2\2\2\u06e5\u06e9"+
15812                "\7\23\2\2\u06e6\u06e8\t\b\2\2\u06e7\u06e6\3\2\2\2\u06e8\u06eb\3\2\2\2"+
15813                "\u06e9\u06e7\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06ed\3\2\2\2\u06eb\u06e9"+
15814                "\3\2\2\2\u06ec\u06ee\7-\2\2\u06ed\u06ec\3\2\2\2\u06ed\u06ee\3\2\2\2\u06ee"+
15815                "\u06f2\3\2\2\2\u06ef\u06f1\t\b\2\2\u06f0\u06ef\3\2\2\2\u06f1\u06f4\3\2"+
15816                "\2\2\u06f2\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f6\3\2\2\2\u06f4"+
15817                "\u06f2\3\2\2\2\u06f5\u06f7\5\u008aF\2\u06f6\u06f5\3\2\2\2\u06f6\u06f7"+
15818                "\3\2\2\2\u06f7\u070d\3\2\2\2\u06f8\u06fc\7\24\2\2\u06f9\u06fb\t\b\2\2"+
15819                "\u06fa\u06f9\3\2\2\2\u06fb\u06fe\3\2\2\2\u06fc\u06fa\3\2\2\2\u06fc\u06fd"+
15820                "\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3\2\2\2\u06ff\u0701\5\u008aF"+
15821                "\2\u0700\u06ff\3\2\2\2\u0700\u0701\3\2\2\2\u0701\u070d\3\2\2\2\u0702\u0706"+
15822                "\7\27\2\2\u0703\u0705\t\b\2\2\u0704\u0703\3\2\2\2\u0705\u0708\3\2\2\2"+
15823                "\u0706\u0704\3\2\2\2\u0706\u0707\3\2\2\2\u0707\u070a\3\2\2\2\u0708\u0706"+
15824                "\3\2\2\2\u0709\u070b\5\u008aF\2\u070a\u0709\3\2\2\2\u070a\u070b\3\2\2"+
15825                "\2\u070b\u070d\3\2\2\2\u070c\u064a\3\2\2\2\u070c\u0654\3\2\2\2\u070c\u065e"+
15826                "\3\2\2\2\u070c\u0671\3\2\2\2\u070c\u0684\3\2\2\2\u070c\u068e\3\2\2\2\u070c"+
15827                "\u06a8\3\2\2\2\u070c\u06b5\3\2\2\2\u070c\u06bf\3\2\2\2\u070c\u06db\3\2"+
15828                "\2\2\u070c\u06e5\3\2\2\2\u070c\u06f8\3\2\2\2\u070c\u0702\3\2\2\2\u070d"+
15829                "\u0091\3\2\2\2\u070e\u075a\7\25\2\2\u070f\u0716\7/\2\2\u0710\u0715\7\6"+
15830                "\2\2\u0711\u0715\7\b\2\2\u0712\u0715\7\3\2\2\u0713\u0715\5\u0096L\2\u0714"+
15831                "\u0710\3\2\2\2\u0714\u0711\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0713\3\2"+
15832                "\2\2\u0715\u0718\3\2\2\2\u0716\u0714\3\2\2\2\u0716\u0717\3\2\2\2\u0717"+
15833                "\u075b\3\2\2\2\u0718\u0716\3\2\2\2\u0719\u071d\7\60\2\2\u071a\u071c\t"+
15834                "\2\2\2\u071b\u071a\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2\2\2\u071d"+
15835                "\u071e\3\2\2\2\u071e\u075b\3\2\2\2\u071f\u071d\3\2\2\2\u0720\u0724\7\61"+
15836                "\2\2\u0721\u0723\t\2\2\2\u0722\u0721\3\2\2\2\u0723\u0726\3\2\2\2\u0724"+
15837                "\u0722\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u075b\3\2\2\2\u0726\u0724\3\2"+
15838                "\2\2\u0727\u072b\7\62\2\2\u0728\u072a\t\2\2\2\u0729\u0728\3\2\2\2\u072a"+
15839                "\u072d\3\2\2\2\u072b\u0729\3\2\2\2\u072b\u072c\3\2\2\2\u072c\u072e\3\2"+
15840                "\2\2\u072d\u072b\3\2\2\2\u072e\u0730\5\u008cG\2\u072f\u0731\5\u008aF\2"+
15841                "\u0730\u072f\3\2\2\2\u0730\u0731\3\2\2\2\u0731\u075b\3\2\2\2\u0732\u0736"+
15842                "\7\63\2\2\u0733\u0735\t\2\2\2\u0734\u0733\3\2\2\2\u0735\u0738\3\2\2\2"+
15843                "\u0736\u0734\3\2\2\2\u0736\u0737\3\2\2\2\u0737\u0739\3\2\2\2\u0738\u0736"+
15844                "\3\2\2\2\u0739\u073b\5\u008cG\2\u073a\u073c\5\u008aF\2\u073b\u073a\3\2"+
15845                "\2\2\u073b\u073c\3\2\2\2\u073c\u075b\3\2\2\2\u073d\u0744\7\64\2\2\u073e"+
15846                "\u0743\7\6\2\2\u073f\u0743\7\b\2\2\u0740\u0743\7\3\2\2\u0741\u0743\5\u0096"+
15847                "L\2\u0742\u073e\3\2\2\2\u0742\u073f\3\2\2\2\u0742\u0740\3\2\2\2\u0742"+
15848                "\u0741\3\2\2\2\u0743\u0746\3\2\2\2\u0744\u0742\3\2\2\2\u0744\u0745\3\2"+
15849                "\2\2\u0745\u075b\3\2\2\2\u0746\u0744\3\2\2\2\u0747\u074b\7\65\2\2\u0748"+
15850                "\u074a\t\2\2\2\u0749\u0748\3\2\2\2\u074a\u074d\3\2\2\2\u074b\u0749\3\2"+
15851                "\2\2\u074b\u074c\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b\3\2\2\2\u074e"+
15852                "\u0750\5\u008cG\2\u074f\u074e\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u075b"+
15853                "\3\2\2\2\u0751\u0753\7\27\2\2\u0752\u0754\t\2\2\2\u0753\u0752\3\2\2\2"+
15854                "\u0754\u0755\3\2\2\2\u0755\u0753\3\2\2\2\u0755\u0756\3\2\2\2\u0756\u0758"+
15855                "\3\2\2\2\u0757\u0759\5\u008aF\2\u0758\u0757\3\2\2\2\u0758\u0759\3\2\2"+
15856                "\2\u0759\u075b\3\2\2\2\u075a\u070f\3\2\2\2\u075a\u0719\3\2\2\2\u075a\u0720"+
15857                "\3\2\2\2\u075a\u0727\3\2\2\2\u075a\u0732\3\2\2\2\u075a\u073d\3\2\2\2\u075a"+
15858                "\u0747\3\2\2\2\u075a\u0751\3\2\2\2\u075b\u075c\3\2\2\2\u075c\u075d\7\26"+
15859                "\2\2\u075d\u0093\3\2\2\2\u075e\u0764\7\4\2\2\u075f\u0763\5\u0096L\2\u0760"+
15860                "\u0763\7\b\2\2\u0761\u0763\7\3\2\2\u0762\u075f\3\2\2\2\u0762\u0760\3\2"+
15861                "\2\2\u0762\u0761\3\2\2\2\u0763\u0766\3\2\2\2\u0764\u0762\3\2\2\2\u0764"+
15862                "\u0765\3\2\2\2\u0765\u0767\3\2\2\2\u0766\u0764\3\2\2\2\u0767\u0768\7]"+
15863                "\2\2\u0768\u0095\3\2\2\2\u0769\u076b\t\n\2\2\u076a\u0769\3\2\2\2\u076b"+
15864                "\u076c\3\2\2\2\u076c\u076a\3\2\2\2\u076c\u076d\3\2\2\2\u076d\u0097\3\2"+
15865                "\2\2\u00c5\u00a0\u00a2\u00a6\u00ab\u00b1\u00e5\u00ed\u00ef\u00fa\u0103"+
15866                "\u010a\u0110\u011b\u011d\u012b\u012d\u0132\u013a\u013c\u0147\u0172\u0174"+
15867                "\u017f\u0181\u018c\u01b7\u01b9\u01c4\u01c6\u01d1\u01fc\u01fe\u0209\u020b"+
15868                "\u0216\u0241\u0243\u024e\u0250\u025b\u0286\u0288\u0293\u0295\u02a0\u02cb"+
15869                "\u02cd\u02d8\u02da\u02e5\u0310\u0312\u031d\u031f\u032a\u0355\u0357\u0362"+
15870                "\u0364\u036f\u039a\u039c\u03a7\u03a9\u03b4\u03df\u03e1\u03ec\u03ee\u03f9"+
15871                "\u0424\u0426\u0431\u0433\u043e\u0469\u046b\u0476\u0478\u0483\u04ae\u04b0"+
15872                "\u04bb\u04bd\u04c8\u04f3\u04f5\u0500\u0502\u050d\u0538\u053a\u054e\u0556"+
15873                "\u0558\u0563\u0565\u0570\u0572\u057d\u057f\u058a\u058c\u0597\u0599\u05a4"+
15874                "\u05a6\u05b1\u05b3\u05be\u05c0\u05cb\u05cd\u05d8\u05da\u05e5\u05e7\u05f2"+
15875                "\u05f4\u05ff\u0601\u0616\u0618\u061e\u0622\u0625\u0628\u062d\u0630\u0633"+
15876                "\u0636\u0639\u063d\u063f\u0645\u064e\u0652\u0658\u065c\u0662\u0666\u066b"+
15877                "\u066f\u0675\u0679\u067e\u0682\u0688\u068c\u0692\u0696\u069a\u069c\u06a2"+
15878                "\u06a6\u06ac\u06b0\u06b3\u06b9\u06bd\u06c3\u06c7\u06cc\u06d0\u06d5\u06d9"+
15879                "\u06df\u06e3\u06e9\u06ed\u06f2\u06f6\u06fc\u0700\u0706\u070a\u070c\u0714"+
15880                "\u0716\u071d\u0724\u072b\u0730\u0736\u073b\u0742\u0744\u074b\u074f\u0755"+
15881                "\u0758\u075a\u0762\u0764\u076c";
15882        public static final ATN _ATN =
15883                new ATNDeserializer().deserialize(_serializedATN.toCharArray());
15884        static {
15885                _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
15886                for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
15887                        _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
15888                }
15889        }
15890}