Coverage Report - com.puppycrawl.tools.checkstyle.grammars.javadoc.JavadocParser
 
Classes in this File Line Coverage Branch Coverage Complexity
JavadocParser
54%
3102/5641
44%
980/2217
1.768
 
 1  
 // Generated from com/puppycrawl/tools/checkstyle/grammars/javadoc/JavadocParser.g4 by ANTLR 4.7
 2  
 package com.puppycrawl.tools.checkstyle.grammars.javadoc;
 3  
 import org.antlr.v4.runtime.atn.*;
 4  
 import org.antlr.v4.runtime.dfa.DFA;
 5  
 import org.antlr.v4.runtime.*;
 6  
 import org.antlr.v4.runtime.misc.*;
 7  
 import org.antlr.v4.runtime.tree.*;
 8  
 import java.util.List;
 9  
 import java.util.Iterator;
 10  
 import java.util.ArrayList;
 11  
 
 12  
 @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
 13  
 public class JavadocParser extends Parser {
 14  2
         static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); }
 15  
 
 16  
         protected static final DFA[] _decisionToDFA;
 17  2
         protected static final PredictionContextCache _sharedContextCache =
 18  
                 new PredictionContextCache();
 19  
         public static final int
 20  
                 LEADING_ASTERISK=1, HTML_COMMENT_START=2, CDATA=3, WS=4, START=5, NEWLINE=6, 
 21  
                 AUTHOR_LITERAL=7, DEPRECATED_LITERAL=8, EXCEPTION_LITERAL=9, PARAM_LITERAL=10, 
 22  
                 RETURN_LITERAL=11, SEE_LITERAL=12, SERIAL_LITERAL=13, SERIAL_FIELD_LITERAL=14, 
 23  
                 SERIAL_DATA_LITERAL=15, SINCE_LITERAL=16, THROWS_LITERAL=17, VERSION_LITERAL=18, 
 24  
                 JAVADOC_INLINE_TAG_START=19, JAVADOC_INLINE_TAG_END=20, CUSTOM_NAME=21, 
 25  
                 LITERAL_INCLUDE=22, LITERAL_EXCLUDE=23, CHAR=24, PARAMETER_NAME=25, Char1=26, 
 26  
                 STRING=27, PACKAGE_CLASS=28, DOT=29, HASH=30, CLASS=31, Char2=32, MEMBER=33, 
 27  
                 LEFT_BRACE=34, RIGHT_BRACE=35, ARGUMENT=36, COMMA=37, Char20=38, FIELD_NAME=39, 
 28  
                 Char3=40, FIELD_TYPE=41, Char4=42, CLASS_NAME=43, Char5=44, CODE_LITERAL=45, 
 29  
                 DOC_ROOT_LITERAL=46, INHERIT_DOC_LITERAL=47, LINK_LITERAL=48, LINKPLAIN_LITERAL=49, 
 30  
                 LITERAL_LITERAL=50, VALUE_LITERAL=51, Char7=52, Char8=53, Char10=54, END=55, 
 31  
                 SLASH_END=56, SLASH=57, EQUALS=58, P_HTML_TAG_NAME=59, LI_HTML_TAG_NAME=60, 
 32  
                 TR_HTML_TAG_NAME=61, TD_HTML_TAG_NAME=62, TH_HTML_TAG_NAME=63, BODY_HTML_TAG_NAME=64, 
 33  
                 COLGROUP_HTML_TAG_NAME=65, DD_HTML_TAG_NAME=66, DT_HTML_TAG_NAME=67, HEAD_HTML_TAG_NAME=68, 
 34  
                 HTML_HTML_TAG_NAME=69, OPTION_HTML_TAG_NAME=70, TBODY_HTML_TAG_NAME=71, 
 35  
                 TFOOT_HTML_TAG_NAME=72, THEAD_HTML_TAG_NAME=73, AREA_HTML_TAG_NAME=74, 
 36  
                 BASE_HTML_TAG_NAME=75, BASEFONT_HTML_TAG_NAME=76, BR_HTML_TAG_NAME=77, 
 37  
                 COL_HTML_TAG_NAME=78, FRAME_HTML_TAG_NAME=79, HR_HTML_TAG_NAME=80, IMG_HTML_TAG_NAME=81, 
 38  
                 INPUT_HTML_TAG_NAME=82, ISINDEX_HTML_TAG_NAME=83, LINK_HTML_TAG_NAME=84, 
 39  
                 META_HTML_TAG_NAME=85, PARAM_HTML_TAG_NAME=86, EMBED_HTML_TAG_NAME=87, 
 40  
                 KEYGEN_HTML_TAG_NAME=88, ATTR_VALUE=89, Char12=90, HTML_COMMENT_END=91, 
 41  
                 SOURCE_HTML_TAG_NAME=92, TRACK_HTML_TAG_NAME=93, WBR_HTML_TAG_NAME=94, 
 42  
                 HTML_TAG_NAME=95, Char11=96;
 43  
         public static final int
 44  
                 RULE_javadoc = 0, RULE_htmlElement = 1, RULE_htmlElementStart = 2, RULE_htmlElementEnd = 3, 
 45  
                 RULE_attribute = 4, RULE_htmlTag = 5, RULE_pTagStart = 6, RULE_pTagEnd = 7, 
 46  
                 RULE_paragraph = 8, RULE_liTagStart = 9, RULE_liTagEnd = 10, RULE_li = 11, 
 47  
                 RULE_trTagStart = 12, RULE_trTagEnd = 13, RULE_tr = 14, RULE_tdTagStart = 15, 
 48  
                 RULE_tdTagEnd = 16, RULE_td = 17, RULE_thTagStart = 18, RULE_thTagEnd = 19, 
 49  
                 RULE_th = 20, RULE_bodyTagStart = 21, RULE_bodyTagEnd = 22, RULE_body = 23, 
 50  
                 RULE_colgroupTagStart = 24, RULE_colgroupTagEnd = 25, RULE_colgroup = 26, 
 51  
                 RULE_ddTagStart = 27, RULE_ddTagEnd = 28, RULE_dd = 29, RULE_dtTagStart = 30, 
 52  
                 RULE_dtTagEnd = 31, RULE_dt = 32, RULE_headTagStart = 33, RULE_headTagEnd = 34, 
 53  
                 RULE_head = 35, RULE_htmlTagStart = 36, RULE_htmlTagEnd = 37, RULE_html = 38, 
 54  
                 RULE_optionTagStart = 39, RULE_optionTagEnd = 40, RULE_option = 41, RULE_tbodyTagStart = 42, 
 55  
                 RULE_tbodyTagEnd = 43, RULE_tbody = 44, RULE_tfootTagStart = 45, RULE_tfootTagEnd = 46, 
 56  
                 RULE_tfoot = 47, RULE_theadTagStart = 48, RULE_theadTagEnd = 49, RULE_thead = 50, 
 57  
                 RULE_singletonElement = 51, RULE_emptyTag = 52, RULE_areaTag = 53, RULE_baseTag = 54, 
 58  
                 RULE_basefontTag = 55, RULE_brTag = 56, RULE_colTag = 57, RULE_frameTag = 58, 
 59  
                 RULE_hrTag = 59, RULE_imgTag = 60, RULE_inputTag = 61, RULE_isindexTag = 62, 
 60  
                 RULE_linkTag = 63, RULE_metaTag = 64, RULE_paramTag = 65, RULE_wrongSinletonTag = 66, 
 61  
                 RULE_singletonTagName = 67, RULE_description = 68, RULE_reference = 69, 
 62  
                 RULE_parameters = 70, RULE_javadocTag = 71, RULE_javadocInlineTag = 72, 
 63  
                 RULE_htmlComment = 73, RULE_text = 74, RULE_embedTag = 75, RULE_keygenTag = 76, 
 64  
                 RULE_sourceTag = 77, RULE_trackTag = 78, RULE_wbrTag = 79;
 65  2
         public static final String[] ruleNames = {
 66  
                 "javadoc", "htmlElement", "htmlElementStart", "htmlElementEnd", "attribute", 
 67  
                 "htmlTag", "pTagStart", "pTagEnd", "paragraph", "liTagStart", "liTagEnd", 
 68  
                 "li", "trTagStart", "trTagEnd", "tr", "tdTagStart", "tdTagEnd", "td", 
 69  
                 "thTagStart", "thTagEnd", "th", "bodyTagStart", "bodyTagEnd", "body", 
 70  
                 "colgroupTagStart", "colgroupTagEnd", "colgroup", "ddTagStart", "ddTagEnd", 
 71  
                 "dd", "dtTagStart", "dtTagEnd", "dt", "headTagStart", "headTagEnd", "head", 
 72  
                 "htmlTagStart", "htmlTagEnd", "html", "optionTagStart", "optionTagEnd", 
 73  
                 "option", "tbodyTagStart", "tbodyTagEnd", "tbody", "tfootTagStart", "tfootTagEnd", 
 74  
                 "tfoot", "theadTagStart", "theadTagEnd", "thead", "singletonElement", 
 75  
                 "emptyTag", "areaTag", "baseTag", "basefontTag", "brTag", "colTag", "frameTag", 
 76  
                 "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", "paramTag", 
 77  
                 "wrongSinletonTag", "singletonTagName", "description", "reference", "parameters", 
 78  
                 "javadocTag", "javadocInlineTag", "htmlComment", "text", "embedTag", "keygenTag", 
 79  
                 "sourceTag", "trackTag", "wbrTag"
 80  
         };
 81  
 
 82  2
         private static final String[] _LITERAL_NAMES = {
 83  
                 null, null, null, null, null, null, null, "'@author'", "'@deprecated'", 
 84  
                 null, null, "'@return'", null, "'@serial'", null, "'@serialData'", "'@since'", 
 85  
                 null, "'@version'", null, null, null, "'include'", "'exclude'", null, 
 86  
                 null, null, null, null, "'.'", null, null, null, null, "'('", "')'", null, 
 87  
                 "','", null, null, null, null, null, null, null, null, "'@docRoot'", "'@inheritDoc'", 
 88  
                 "'@link'", "'@linkplain'", null, "'@value'", null, null, null, null, null, 
 89  
                 "'/'", "'='", null, null, null, null, null, null, null, null, null, null, 
 90  
                 null, null, null, null, null, null, null, null, null, null, null, null, 
 91  
                 null, null, null, null, null, null, null, null, null, null, "'-->'"
 92  
         };
 93  2
         private static final String[] _SYMBOLIC_NAMES = {
 94  
                 null, "LEADING_ASTERISK", "HTML_COMMENT_START", "CDATA", "WS", "START", 
 95  
                 "NEWLINE", "AUTHOR_LITERAL", "DEPRECATED_LITERAL", "EXCEPTION_LITERAL", 
 96  
                 "PARAM_LITERAL", "RETURN_LITERAL", "SEE_LITERAL", "SERIAL_LITERAL", "SERIAL_FIELD_LITERAL", 
 97  
                 "SERIAL_DATA_LITERAL", "SINCE_LITERAL", "THROWS_LITERAL", "VERSION_LITERAL", 
 98  
                 "JAVADOC_INLINE_TAG_START", "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", "LITERAL_INCLUDE", 
 99  
                 "LITERAL_EXCLUDE", "CHAR", "PARAMETER_NAME", "Char1", "STRING", "PACKAGE_CLASS", 
 100  
                 "DOT", "HASH", "CLASS", "Char2", "MEMBER", "LEFT_BRACE", "RIGHT_BRACE", 
 101  
                 "ARGUMENT", "COMMA", "Char20", "FIELD_NAME", "Char3", "FIELD_TYPE", "Char4", 
 102  
                 "CLASS_NAME", "Char5", "CODE_LITERAL", "DOC_ROOT_LITERAL", "INHERIT_DOC_LITERAL", 
 103  
                 "LINK_LITERAL", "LINKPLAIN_LITERAL", "LITERAL_LITERAL", "VALUE_LITERAL", 
 104  
                 "Char7", "Char8", "Char10", "END", "SLASH_END", "SLASH", "EQUALS", "P_HTML_TAG_NAME", 
 105  
                 "LI_HTML_TAG_NAME", "TR_HTML_TAG_NAME", "TD_HTML_TAG_NAME", "TH_HTML_TAG_NAME", 
 106  
                 "BODY_HTML_TAG_NAME", "COLGROUP_HTML_TAG_NAME", "DD_HTML_TAG_NAME", "DT_HTML_TAG_NAME", 
 107  
                 "HEAD_HTML_TAG_NAME", "HTML_HTML_TAG_NAME", "OPTION_HTML_TAG_NAME", "TBODY_HTML_TAG_NAME", 
 108  
                 "TFOOT_HTML_TAG_NAME", "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", "BASE_HTML_TAG_NAME", 
 109  
                 "BASEFONT_HTML_TAG_NAME", "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", "FRAME_HTML_TAG_NAME", 
 110  
                 "HR_HTML_TAG_NAME", "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", "ISINDEX_HTML_TAG_NAME", 
 111  
                 "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", "EMBED_HTML_TAG_NAME", 
 112  
                 "KEYGEN_HTML_TAG_NAME", "ATTR_VALUE", "Char12", "HTML_COMMENT_END", "SOURCE_HTML_TAG_NAME", 
 113  
                 "TRACK_HTML_TAG_NAME", "WBR_HTML_TAG_NAME", "HTML_TAG_NAME", "Char11"
 114  
         };
 115  2
         public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
 116  
 
 117  
         /**
 118  
          * @deprecated Use {@link #VOCABULARY} instead.
 119  
          */
 120  
         @Deprecated
 121  
         public static final String[] tokenNames;
 122  
         static {
 123  2
                 tokenNames = new String[_SYMBOLIC_NAMES.length];
 124  196
                 for (int i = 0; i < tokenNames.length; i++) {
 125  194
                         tokenNames[i] = VOCABULARY.getLiteralName(i);
 126  194
                         if (tokenNames[i] == null) {
 127  152
                                 tokenNames[i] = VOCABULARY.getSymbolicName(i);
 128  
                         }
 129  
 
 130  194
                         if (tokenNames[i] == null) {
 131  2
                                 tokenNames[i] = "<INVALID>";
 132  
                         }
 133  
                 }
 134  
         }
 135  
 
 136  
         @Override
 137  
         @Deprecated
 138  
         public String[] getTokenNames() {
 139  0
                 return tokenNames;
 140  
         }
 141  
 
 142  
         @Override
 143  
 
 144  
         public Vocabulary getVocabulary() {
 145  17
                 return VOCABULARY;
 146  
         }
 147  
 
 148  
         @Override
 149  0
         public String getGrammarFileName() { return "JavadocParser.g4"; }
 150  
 
 151  
         @Override
 152  36
         public String[] getRuleNames() { return ruleNames; }
 153  
 
 154  
         @Override
 155  0
         public String getSerializedATN() { return _serializedATN; }
 156  
 
 157  
         @Override
 158  17
         public ATN getATN() { return _ATN; }
 159  
 
 160  
 
 161  
             boolean isNextJavadocTag() {
 162  4267
                 int token1 = _input.LA(2);
 163  4267
                 int token2 = _input.LA(3);
 164  8534
                 return isJavadocTag(token1)
 165  3445
                     || (token1 == WS && isJavadocTag(token2));
 166  
             }
 167  
 
 168  
             boolean isJavadocTag(int type) {
 169  7712
                 switch(type) {
 170  
                     case AUTHOR_LITERAL:
 171  
                     case DEPRECATED_LITERAL:
 172  
                     case EXCEPTION_LITERAL:
 173  
                     case PARAM_LITERAL:
 174  
                     case RETURN_LITERAL:
 175  
                     case SEE_LITERAL:
 176  
                     case SERIAL_LITERAL:
 177  
                     case SERIAL_FIELD_LITERAL:
 178  
                     case SERIAL_DATA_LITERAL:
 179  
                     case SINCE_LITERAL:
 180  
                     case THROWS_LITERAL:
 181  
                     case VERSION_LITERAL:
 182  
                     case CUSTOM_NAME:
 183  569
                         return true;
 184  
                     default:
 185  7143
                         return false;
 186  
                 }
 187  
             }
 188  
 
 189  
             boolean isSameTagNames(ParserRuleContext htmlTagStart, ParserRuleContext htmlTagEnd) {
 190  59
                   String startTag = htmlTagStart.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
 191  59
                   String endTag = htmlTagEnd.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
 192  59
                   return startTag.equals(endTag);
 193  
             }
 194  
 
 195  
             public ParserRuleContext nonTightTagStartContext;
 196  
 
 197  
         public JavadocParser(TokenStream input) {
 198  650
                 super(input);
 199  650
                 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
 200  650
         }
 201  
         public static class JavadocContext extends ParserRuleContext {
 202  
                 public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); }
 203  
                 public List<HtmlElementContext> htmlElement() {
 204  
                         return getRuleContexts(HtmlElementContext.class);
 205  
                 }
 206  
                 public HtmlElementContext htmlElement(int i) {
 207  
                         return getRuleContext(HtmlElementContext.class,i);
 208  
                 }
 209  
                 public List<HtmlCommentContext> htmlComment() {
 210  
                         return getRuleContexts(HtmlCommentContext.class);
 211  
                 }
 212  
                 public HtmlCommentContext htmlComment(int i) {
 213  
                         return getRuleContext(HtmlCommentContext.class,i);
 214  
                 }
 215  
                 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
 216  
                 public TerminalNode CDATA(int i) {
 217  
                         return getToken(JavadocParser.CDATA, i);
 218  
                 }
 219  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 220  
                 public TerminalNode NEWLINE(int i) {
 221  
                         return getToken(JavadocParser.NEWLINE, i);
 222  
                 }
 223  
                 public List<TextContext> text() {
 224  
                         return getRuleContexts(TextContext.class);
 225  
                 }
 226  
                 public TextContext text(int i) {
 227  
                         return getRuleContext(TextContext.class,i);
 228  
                 }
 229  
                 public List<JavadocInlineTagContext> javadocInlineTag() {
 230  
                         return getRuleContexts(JavadocInlineTagContext.class);
 231  
                 }
 232  
                 public JavadocInlineTagContext javadocInlineTag(int i) {
 233  
                         return getRuleContext(JavadocInlineTagContext.class,i);
 234  
                 }
 235  
                 public List<JavadocTagContext> javadocTag() {
 236  
                         return getRuleContexts(JavadocTagContext.class);
 237  
                 }
 238  
                 public JavadocTagContext javadocTag(int i) {
 239  
                         return getRuleContext(JavadocTagContext.class,i);
 240  
                 }
 241  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 242  
                 public TerminalNode LEADING_ASTERISK(int i) {
 243  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 244  
                 }
 245  
                 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
 246  
                 public TerminalNode WS(int i) {
 247  
                         return getToken(JavadocParser.WS, i);
 248  
                 }
 249  
                 public JavadocContext(ParserRuleContext parent, int invokingState) {
 250  
                         super(parent, invokingState);
 251  
                 }
 252  
                 @Override public int getRuleIndex() { return RULE_javadoc; }
 253  
         }
 254  
 
 255  
         public final JavadocContext javadoc() throws RecognitionException {
 256  650
                 JavadocContext _localctx = new JavadocContext(_ctx, getState());
 257  650
                 enterRule(_localctx, 0, RULE_javadoc);
 258  
                 int _la;
 259  
                 try {
 260  
                         int _alt;
 261  650
                         enterOuterAlt(_localctx, 1);
 262  
                         {
 263  650
                         setState(170);
 264  650
                         _errHandler.sync(this);
 265  650
                         _alt = getInterpreter().adaptivePredict(_input,1,_ctx);
 266  4864
                         while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 267  4234
                                 if ( _alt==1 ) {
 268  
                                         {
 269  4234
                                         setState(168);
 270  4234
                                         _errHandler.sync(this);
 271  4234
                                         switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
 272  
                                         case 1:
 273  
                                                 {
 274  649
                                                 setState(160);
 275  649
                                                 htmlElement();
 276  
                                                 }
 277  634
                                                 break;
 278  
                                         case 2:
 279  
                                                 {
 280  
                                                 {
 281  876
                                                 setState(161);
 282  876
                                                 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
 283  876
                                                 setState(162);
 284  876
                                                 match(LEADING_ASTERISK);
 285  
                                                 }
 286  
                                                 }
 287  876
                                                 break;
 288  
                                         case 3:
 289  
                                                 {
 290  1
                                                 setState(163);
 291  1
                                                 htmlComment();
 292  
                                                 }
 293  1
                                                 break;
 294  
                                         case 4:
 295  
                                                 {
 296  0
                                                 setState(164);
 297  0
                                                 match(CDATA);
 298  
                                                 }
 299  0
                                                 break;
 300  
                                         case 5:
 301  
                                                 {
 302  1261
                                                 setState(165);
 303  1261
                                                 match(NEWLINE);
 304  
                                                 }
 305  1261
                                                 break;
 306  
                                         case 6:
 307  
                                                 {
 308  1356
                                                 setState(166);
 309  1356
                                                 text();
 310  
                                                 }
 311  1356
                                                 break;
 312  
                                         case 7:
 313  
                                                 {
 314  91
                                                 setState(167);
 315  91
                                                 javadocInlineTag();
 316  
                                                 }
 317  
                                                 break;
 318  
                                         }
 319  
                                         } 
 320  
                                 }
 321  4214
                                 setState(172);
 322  4214
                                 _errHandler.sync(this);
 323  4214
                                 _alt = getInterpreter().adaptivePredict(_input,1,_ctx);
 324  
                         }
 325  630
                         setState(185);
 326  630
                         _errHandler.sync(this);
 327  630
                         _la = _input.LA(1);
 328  1281
                         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)) {
 329  
                                 {
 330  
                                 {
 331  661
                                 setState(174);
 332  661
                                 _errHandler.sync(this);
 333  661
                                 _la = _input.LA(1);
 334  661
                                 if (_la==LEADING_ASTERISK) {
 335  
                                         {
 336  566
                                         setState(173);
 337  566
                                         match(LEADING_ASTERISK);
 338  
                                         }
 339  
                                 }
 340  
 
 341  661
                                 setState(179);
 342  661
                                 _errHandler.sync(this);
 343  661
                                 _la = _input.LA(1);
 344  1227
                                 while (_la==WS) {
 345  
                                         {
 346  
                                         {
 347  566
                                         setState(176);
 348  566
                                         match(WS);
 349  
                                         }
 350  
                                         }
 351  566
                                         setState(181);
 352  566
                                         _errHandler.sync(this);
 353  566
                                         _la = _input.LA(1);
 354  
                                 }
 355  661
                                 setState(182);
 356  661
                                 javadocTag();
 357  
                                 }
 358  
                                 }
 359  651
                                 setState(187);
 360  651
                                 _errHandler.sync(this);
 361  651
                                 _la = _input.LA(1);
 362  
                         }
 363  620
                         setState(188);
 364  620
                         match(EOF);
 365  
                         }
 366  
                 }
 367  0
                 catch (RecognitionException re) {
 368  0
                         _localctx.exception = re;
 369  0
                         _errHandler.reportError(this, re);
 370  0
                         _errHandler.recover(this, re);
 371  
                 }
 372  
                 finally {
 373  650
                         exitRule();
 374  609
                 }
 375  609
                 return _localctx;
 376  
         }
 377  
 
 378  
         public static class HtmlElementContext extends ParserRuleContext {
 379  
                 public HtmlTagContext htmlTag() {
 380  
                         return getRuleContext(HtmlTagContext.class,0);
 381  
                 }
 382  
                 public SingletonElementContext singletonElement() {
 383  
                         return getRuleContext(SingletonElementContext.class,0);
 384  
                 }
 385  
                 public ParagraphContext paragraph() {
 386  
                         return getRuleContext(ParagraphContext.class,0);
 387  
                 }
 388  
                 public LiContext li() {
 389  
                         return getRuleContext(LiContext.class,0);
 390  
                 }
 391  
                 public TrContext tr() {
 392  
                         return getRuleContext(TrContext.class,0);
 393  
                 }
 394  
                 public TdContext td() {
 395  
                         return getRuleContext(TdContext.class,0);
 396  
                 }
 397  
                 public ThContext th() {
 398  
                         return getRuleContext(ThContext.class,0);
 399  
                 }
 400  
                 public BodyContext body() {
 401  
                         return getRuleContext(BodyContext.class,0);
 402  
                 }
 403  
                 public ColgroupContext colgroup() {
 404  
                         return getRuleContext(ColgroupContext.class,0);
 405  
                 }
 406  
                 public DdContext dd() {
 407  
                         return getRuleContext(DdContext.class,0);
 408  
                 }
 409  
                 public DtContext dt() {
 410  
                         return getRuleContext(DtContext.class,0);
 411  
                 }
 412  
                 public HeadContext head() {
 413  
                         return getRuleContext(HeadContext.class,0);
 414  
                 }
 415  
                 public HtmlContext html() {
 416  
                         return getRuleContext(HtmlContext.class,0);
 417  
                 }
 418  
                 public OptionContext option() {
 419  
                         return getRuleContext(OptionContext.class,0);
 420  
                 }
 421  
                 public TbodyContext tbody() {
 422  
                         return getRuleContext(TbodyContext.class,0);
 423  
                 }
 424  
                 public TheadContext thead() {
 425  
                         return getRuleContext(TheadContext.class,0);
 426  
                 }
 427  
                 public TfootContext tfoot() {
 428  
                         return getRuleContext(TfootContext.class,0);
 429  
                 }
 430  
                 public PTagStartContext pTagStart() {
 431  
                         return getRuleContext(PTagStartContext.class,0);
 432  
                 }
 433  
                 public LiTagStartContext liTagStart() {
 434  
                         return getRuleContext(LiTagStartContext.class,0);
 435  
                 }
 436  
                 public TrTagStartContext trTagStart() {
 437  
                         return getRuleContext(TrTagStartContext.class,0);
 438  
                 }
 439  
                 public TdTagStartContext tdTagStart() {
 440  
                         return getRuleContext(TdTagStartContext.class,0);
 441  
                 }
 442  
                 public ThTagStartContext thTagStart() {
 443  
                         return getRuleContext(ThTagStartContext.class,0);
 444  
                 }
 445  
                 public BodyTagStartContext bodyTagStart() {
 446  
                         return getRuleContext(BodyTagStartContext.class,0);
 447  
                 }
 448  
                 public ColgroupTagStartContext colgroupTagStart() {
 449  
                         return getRuleContext(ColgroupTagStartContext.class,0);
 450  
                 }
 451  
                 public DdTagStartContext ddTagStart() {
 452  
                         return getRuleContext(DdTagStartContext.class,0);
 453  
                 }
 454  
                 public DtTagStartContext dtTagStart() {
 455  
                         return getRuleContext(DtTagStartContext.class,0);
 456  
                 }
 457  
                 public HeadTagStartContext headTagStart() {
 458  
                         return getRuleContext(HeadTagStartContext.class,0);
 459  
                 }
 460  
                 public HtmlTagStartContext htmlTagStart() {
 461  
                         return getRuleContext(HtmlTagStartContext.class,0);
 462  
                 }
 463  
                 public OptionTagStartContext optionTagStart() {
 464  
                         return getRuleContext(OptionTagStartContext.class,0);
 465  
                 }
 466  
                 public TbodyTagStartContext tbodyTagStart() {
 467  
                         return getRuleContext(TbodyTagStartContext.class,0);
 468  
                 }
 469  
                 public TheadTagStartContext theadTagStart() {
 470  
                         return getRuleContext(TheadTagStartContext.class,0);
 471  
                 }
 472  
                 public TfootTagStartContext tfootTagStart() {
 473  
                         return getRuleContext(TfootTagStartContext.class,0);
 474  
                 }
 475  
                 public PTagEndContext pTagEnd() {
 476  
                         return getRuleContext(PTagEndContext.class,0);
 477  
                 }
 478  
                 public LiTagEndContext liTagEnd() {
 479  
                         return getRuleContext(LiTagEndContext.class,0);
 480  
                 }
 481  
                 public TrTagEndContext trTagEnd() {
 482  
                         return getRuleContext(TrTagEndContext.class,0);
 483  
                 }
 484  
                 public TdTagEndContext tdTagEnd() {
 485  
                         return getRuleContext(TdTagEndContext.class,0);
 486  
                 }
 487  
                 public ThTagEndContext thTagEnd() {
 488  
                         return getRuleContext(ThTagEndContext.class,0);
 489  
                 }
 490  
                 public BodyTagEndContext bodyTagEnd() {
 491  
                         return getRuleContext(BodyTagEndContext.class,0);
 492  
                 }
 493  
                 public ColgroupTagEndContext colgroupTagEnd() {
 494  
                         return getRuleContext(ColgroupTagEndContext.class,0);
 495  
                 }
 496  
                 public DdTagEndContext ddTagEnd() {
 497  
                         return getRuleContext(DdTagEndContext.class,0);
 498  
                 }
 499  
                 public DtTagEndContext dtTagEnd() {
 500  
                         return getRuleContext(DtTagEndContext.class,0);
 501  
                 }
 502  
                 public HeadTagEndContext headTagEnd() {
 503  
                         return getRuleContext(HeadTagEndContext.class,0);
 504  
                 }
 505  
                 public HtmlTagEndContext htmlTagEnd() {
 506  
                         return getRuleContext(HtmlTagEndContext.class,0);
 507  
                 }
 508  
                 public OptionTagEndContext optionTagEnd() {
 509  
                         return getRuleContext(OptionTagEndContext.class,0);
 510  
                 }
 511  
                 public TbodyTagEndContext tbodyTagEnd() {
 512  
                         return getRuleContext(TbodyTagEndContext.class,0);
 513  
                 }
 514  
                 public TheadTagEndContext theadTagEnd() {
 515  
                         return getRuleContext(TheadTagEndContext.class,0);
 516  
                 }
 517  
                 public TfootTagEndContext tfootTagEnd() {
 518  
                         return getRuleContext(TfootTagEndContext.class,0);
 519  
                 }
 520  
                 public HtmlElementContext(ParserRuleContext parent, int invokingState) {
 521  
                         super(parent, invokingState);
 522  
                 }
 523  
                 @Override public int getRuleIndex() { return RULE_htmlElement; }
 524  
         }
 525  
 
 526  
         public final HtmlElementContext htmlElement() throws RecognitionException {
 527  780
                 HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState());
 528  780
                 enterRule(_localctx, 2, RULE_htmlElement);
 529  
                 try {
 530  780
                         setState(237);
 531  780
                         _errHandler.sync(this);
 532  780
                         switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
 533  
                         case 1:
 534  96
                                 enterOuterAlt(_localctx, 1);
 535  
                                 {
 536  96
                                 setState(190);
 537  96
                                 htmlTag();
 538  
                                 }
 539  48
                                 break;
 540  
                         case 2:
 541  85
                                 enterOuterAlt(_localctx, 2);
 542  
                                 {
 543  85
                                 setState(191);
 544  85
                                 singletonElement();
 545  
                                 }
 546  78
                                 break;
 547  
                         case 3:
 548  79
                                 enterOuterAlt(_localctx, 3);
 549  
                                 {
 550  79
                                 setState(192);
 551  79
                                 paragraph();
 552  
                                 }
 553  79
                                 break;
 554  
                         case 4:
 555  35
                                 enterOuterAlt(_localctx, 4);
 556  
                                 {
 557  35
                                 setState(193);
 558  35
                                 li();
 559  
                                 }
 560  35
                                 break;
 561  
                         case 5:
 562  23
                                 enterOuterAlt(_localctx, 5);
 563  
                                 {
 564  23
                                 setState(194);
 565  23
                                 tr();
 566  
                                 }
 567  23
                                 break;
 568  
                         case 6:
 569  18
                                 enterOuterAlt(_localctx, 6);
 570  
                                 {
 571  18
                                 setState(195);
 572  18
                                 td();
 573  
                                 }
 574  18
                                 break;
 575  
                         case 7:
 576  20
                                 enterOuterAlt(_localctx, 7);
 577  
                                 {
 578  20
                                 setState(196);
 579  20
                                 th();
 580  
                                 }
 581  20
                                 break;
 582  
                         case 8:
 583  25
                                 enterOuterAlt(_localctx, 8);
 584  
                                 {
 585  25
                                 setState(197);
 586  25
                                 body();
 587  
                                 }
 588  25
                                 break;
 589  
                         case 9:
 590  17
                                 enterOuterAlt(_localctx, 9);
 591  
                                 {
 592  17
                                 setState(198);
 593  17
                                 colgroup();
 594  
                                 }
 595  17
                                 break;
 596  
                         case 10:
 597  17
                                 enterOuterAlt(_localctx, 10);
 598  
                                 {
 599  17
                                 setState(199);
 600  17
                                 dd();
 601  
                                 }
 602  17
                                 break;
 603  
                         case 11:
 604  17
                                 enterOuterAlt(_localctx, 11);
 605  
                                 {
 606  17
                                 setState(200);
 607  17
                                 dt();
 608  
                                 }
 609  17
                                 break;
 610  
                         case 12:
 611  17
                                 enterOuterAlt(_localctx, 12);
 612  
                                 {
 613  17
                                 setState(201);
 614  17
                                 head();
 615  
                                 }
 616  17
                                 break;
 617  
                         case 13:
 618  18
                                 enterOuterAlt(_localctx, 13);
 619  
                                 {
 620  18
                                 setState(202);
 621  18
                                 html();
 622  
                                 }
 623  18
                                 break;
 624  
                         case 14:
 625  18
                                 enterOuterAlt(_localctx, 14);
 626  
                                 {
 627  18
                                 setState(203);
 628  18
                                 option();
 629  
                                 }
 630  18
                                 break;
 631  
                         case 15:
 632  18
                                 enterOuterAlt(_localctx, 15);
 633  
                                 {
 634  18
                                 setState(204);
 635  18
                                 tbody();
 636  
                                 }
 637  18
                                 break;
 638  
                         case 16:
 639  18
                                 enterOuterAlt(_localctx, 16);
 640  
                                 {
 641  18
                                 setState(205);
 642  18
                                 thead();
 643  
                                 }
 644  18
                                 break;
 645  
                         case 17:
 646  18
                                 enterOuterAlt(_localctx, 17);
 647  
                                 {
 648  18
                                 setState(206);
 649  18
                                 tfoot();
 650  
                                 }
 651  18
                                 break;
 652  
                         case 18:
 653  94
                                 enterOuterAlt(_localctx, 18);
 654  
                                 {
 655  94
                                 setState(207);
 656  94
                                 pTagStart(true);
 657  
                                 }
 658  94
                                 break;
 659  
                         case 19:
 660  18
                                 enterOuterAlt(_localctx, 19);
 661  
                                 {
 662  18
                                 setState(208);
 663  18
                                 liTagStart(true);
 664  
                                 }
 665  18
                                 break;
 666  
                         case 20:
 667  12
                                 enterOuterAlt(_localctx, 20);
 668  
                                 {
 669  12
                                 setState(209);
 670  12
                                 trTagStart(true);
 671  
                                 }
 672  12
                                 break;
 673  
                         case 21:
 674  4
                                 enterOuterAlt(_localctx, 21);
 675  
                                 {
 676  4
                                 setState(210);
 677  4
                                 tdTagStart(true);
 678  
                                 }
 679  4
                                 break;
 680  
                         case 22:
 681  4
                                 enterOuterAlt(_localctx, 22);
 682  
                                 {
 683  4
                                 setState(211);
 684  4
                                 thTagStart(true);
 685  
                                 }
 686  4
                                 break;
 687  
                         case 23:
 688  4
                                 enterOuterAlt(_localctx, 23);
 689  
                                 {
 690  4
                                 setState(212);
 691  4
                                 bodyTagStart(true);
 692  
                                 }
 693  4
                                 break;
 694  
                         case 24:
 695  4
                                 enterOuterAlt(_localctx, 24);
 696  
                                 {
 697  4
                                 setState(213);
 698  4
                                 colgroupTagStart(true);
 699  
                                 }
 700  4
                                 break;
 701  
                         case 25:
 702  5
                                 enterOuterAlt(_localctx, 25);
 703  
                                 {
 704  5
                                 setState(214);
 705  5
                                 ddTagStart(true);
 706  
                                 }
 707  5
                                 break;
 708  
                         case 26:
 709  4
                                 enterOuterAlt(_localctx, 26);
 710  
                                 {
 711  4
                                 setState(215);
 712  4
                                 dtTagStart(true);
 713  
                                 }
 714  4
                                 break;
 715  
                         case 27:
 716  4
                                 enterOuterAlt(_localctx, 27);
 717  
                                 {
 718  4
                                 setState(216);
 719  4
                                 headTagStart(true);
 720  
                                 }
 721  4
                                 break;
 722  
                         case 28:
 723  4
                                 enterOuterAlt(_localctx, 28);
 724  
                                 {
 725  4
                                 setState(217);
 726  4
                                 htmlTagStart(true);
 727  
                                 }
 728  4
                                 break;
 729  
                         case 29:
 730  4
                                 enterOuterAlt(_localctx, 29);
 731  
                                 {
 732  4
                                 setState(218);
 733  4
                                 optionTagStart(true);
 734  
                                 }
 735  4
                                 break;
 736  
                         case 30:
 737  4
                                 enterOuterAlt(_localctx, 30);
 738  
                                 {
 739  4
                                 setState(219);
 740  4
                                 tbodyTagStart(true);
 741  
                                 }
 742  4
                                 break;
 743  
                         case 31:
 744  4
                                 enterOuterAlt(_localctx, 31);
 745  
                                 {
 746  4
                                 setState(220);
 747  4
                                 theadTagStart(true);
 748  
                                 }
 749  4
                                 break;
 750  
                         case 32:
 751  4
                                 enterOuterAlt(_localctx, 32);
 752  
                                 {
 753  4
                                 setState(221);
 754  4
                                 tfootTagStart(true);
 755  
                                 }
 756  4
                                 break;
 757  
                         case 33:
 758  32
                                 enterOuterAlt(_localctx, 33);
 759  
                                 {
 760  32
                                 setState(222);
 761  32
                                 pTagEnd();
 762  
                                 }
 763  32
                                 break;
 764  
                         case 34:
 765  13
                                 enterOuterAlt(_localctx, 34);
 766  
                                 {
 767  13
                                 setState(223);
 768  13
                                 liTagEnd();
 769  
                                 }
 770  13
                                 break;
 771  
                         case 35:
 772  5
                                 enterOuterAlt(_localctx, 35);
 773  
                                 {
 774  5
                                 setState(224);
 775  5
                                 trTagEnd();
 776  
                                 }
 777  5
                                 break;
 778  
                         case 36:
 779  1
                                 enterOuterAlt(_localctx, 36);
 780  
                                 {
 781  1
                                 setState(225);
 782  1
                                 tdTagEnd();
 783  
                                 }
 784  1
                                 break;
 785  
                         case 37:
 786  5
                                 enterOuterAlt(_localctx, 37);
 787  
                                 {
 788  5
                                 setState(226);
 789  5
                                 thTagEnd();
 790  
                                 }
 791  5
                                 break;
 792  
                         case 38:
 793  1
                                 enterOuterAlt(_localctx, 38);
 794  
                                 {
 795  1
                                 setState(227);
 796  1
                                 bodyTagEnd();
 797  
                                 }
 798  1
                                 break;
 799  
                         case 39:
 800  1
                                 enterOuterAlt(_localctx, 39);
 801  
                                 {
 802  1
                                 setState(228);
 803  1
                                 colgroupTagEnd();
 804  
                                 }
 805  1
                                 break;
 806  
                         case 40:
 807  1
                                 enterOuterAlt(_localctx, 40);
 808  
                                 {
 809  1
                                 setState(229);
 810  1
                                 ddTagEnd();
 811  
                                 }
 812  1
                                 break;
 813  
                         case 41:
 814  2
                                 enterOuterAlt(_localctx, 41);
 815  
                                 {
 816  2
                                 setState(230);
 817  2
                                 dtTagEnd();
 818  
                                 }
 819  2
                                 break;
 820  
                         case 42:
 821  1
                                 enterOuterAlt(_localctx, 42);
 822  
                                 {
 823  1
                                 setState(231);
 824  1
                                 headTagEnd();
 825  
                                 }
 826  1
                                 break;
 827  
                         case 43:
 828  1
                                 enterOuterAlt(_localctx, 43);
 829  
                                 {
 830  1
                                 setState(232);
 831  1
                                 htmlTagEnd();
 832  
                                 }
 833  1
                                 break;
 834  
                         case 44:
 835  1
                                 enterOuterAlt(_localctx, 44);
 836  
                                 {
 837  1
                                 setState(233);
 838  1
                                 optionTagEnd();
 839  
                                 }
 840  1
                                 break;
 841  
                         case 45:
 842  1
                                 enterOuterAlt(_localctx, 45);
 843  
                                 {
 844  1
                                 setState(234);
 845  1
                                 tbodyTagEnd();
 846  
                                 }
 847  1
                                 break;
 848  
                         case 46:
 849  0
                                 enterOuterAlt(_localctx, 46);
 850  
                                 {
 851  0
                                 setState(235);
 852  0
                                 theadTagEnd();
 853  
                                 }
 854  0
                                 break;
 855  
                         case 47:
 856  1
                                 enterOuterAlt(_localctx, 47);
 857  
                                 {
 858  1
                                 setState(236);
 859  1
                                 tfootTagEnd();
 860  
                                 }
 861  
                                 break;
 862  
                         }
 863  
                 }
 864  2
                 catch (RecognitionException re) {
 865  2
                         _localctx.exception = re;
 866  2
                         _errHandler.reportError(this, re);
 867  2
                         _errHandler.recover(this, re);
 868  
                 }
 869  
                 finally {
 870  780
                         exitRule();
 871  723
                 }
 872  723
                 return _localctx;
 873  
         }
 874  
 
 875  
         public static class HtmlElementStartContext extends ParserRuleContext {
 876  
                 public TerminalNode START() { return getToken(JavadocParser.START, 0); }
 877  
                 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
 878  
                 public TerminalNode END() { return getToken(JavadocParser.END, 0); }
 879  
                 public List<AttributeContext> attribute() {
 880  
                         return getRuleContexts(AttributeContext.class);
 881  
                 }
 882  
                 public AttributeContext attribute(int i) {
 883  
                         return getRuleContext(AttributeContext.class,i);
 884  
                 }
 885  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 886  
                 public TerminalNode NEWLINE(int i) {
 887  
                         return getToken(JavadocParser.NEWLINE, i);
 888  
                 }
 889  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 890  
                 public TerminalNode LEADING_ASTERISK(int i) {
 891  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 892  
                 }
 893  
                 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
 894  
                 public TerminalNode WS(int i) {
 895  
                         return getToken(JavadocParser.WS, i);
 896  
                 }
 897  
                 public HtmlElementStartContext(ParserRuleContext parent, int invokingState) {
 898  
                         super(parent, invokingState);
 899  
                 }
 900  
                 @Override public int getRuleIndex() { return RULE_htmlElementStart; }
 901  
         }
 902  
 
 903  
         public final HtmlElementStartContext htmlElementStart() throws RecognitionException {
 904  105
                 HtmlElementStartContext _localctx = new HtmlElementStartContext(_ctx, getState());
 905  105
                 enterRule(_localctx, 4, RULE_htmlElementStart);
 906  
                 int _la;
 907  
                 try {
 908  105
                         enterOuterAlt(_localctx, 1);
 909  
                         {
 910  105
                         setState(239);
 911  105
                         match(START);
 912  105
                         setState(240);
 913  105
                         match(HTML_TAG_NAME);
 914  105
                         setState(247);
 915  105
                         _errHandler.sync(this);
 916  105
                         _la = _input.LA(1);
 917  157
                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
 918  
                                 {
 919  52
                                 setState(245);
 920  52
                                 _errHandler.sync(this);
 921  52
                                 switch (_input.LA(1)) {
 922  
                                 case HTML_TAG_NAME:
 923  
                                         {
 924  26
                                         setState(241);
 925  26
                                         attribute();
 926  
                                         }
 927  26
                                         break;
 928  
                                 case NEWLINE:
 929  
                                         {
 930  0
                                         setState(242);
 931  0
                                         match(NEWLINE);
 932  
                                         }
 933  0
                                         break;
 934  
                                 case LEADING_ASTERISK:
 935  
                                         {
 936  0
                                         setState(243);
 937  0
                                         match(LEADING_ASTERISK);
 938  
                                         }
 939  0
                                         break;
 940  
                                 case WS:
 941  
                                         {
 942  26
                                         setState(244);
 943  26
                                         match(WS);
 944  
                                         }
 945  26
                                         break;
 946  
                                 default:
 947  0
                                         throw new NoViableAltException(this);
 948  
                                 }
 949  
                                 }
 950  52
                                 setState(249);
 951  52
                                 _errHandler.sync(this);
 952  52
                                 _la = _input.LA(1);
 953  
                         }
 954  105
                         setState(250);
 955  105
                         match(END);
 956  
                         }
 957  
                 }
 958  0
                 catch (RecognitionException re) {
 959  0
                         _localctx.exception = re;
 960  0
                         _errHandler.reportError(this, re);
 961  0
                         _errHandler.recover(this, re);
 962  
                 }
 963  
                 finally {
 964  105
                         exitRule();
 965  105
                 }
 966  105
                 return _localctx;
 967  
         }
 968  
 
 969  
         public static class HtmlElementEndContext extends ParserRuleContext {
 970  
                 public TerminalNode START() { return getToken(JavadocParser.START, 0); }
 971  
                 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
 972  
                 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
 973  
                 public TerminalNode END() { return getToken(JavadocParser.END, 0); }
 974  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 975  
                 public TerminalNode NEWLINE(int i) {
 976  
                         return getToken(JavadocParser.NEWLINE, i);
 977  
                 }
 978  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 979  
                 public TerminalNode LEADING_ASTERISK(int i) {
 980  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 981  
                 }
 982  
                 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
 983  
                 public TerminalNode WS(int i) {
 984  
                         return getToken(JavadocParser.WS, i);
 985  
                 }
 986  
                 public HtmlElementEndContext(ParserRuleContext parent, int invokingState) {
 987  
                         super(parent, invokingState);
 988  
                 }
 989  
                 @Override public int getRuleIndex() { return RULE_htmlElementEnd; }
 990  
         }
 991  
 
 992  
         public final HtmlElementEndContext htmlElementEnd() throws RecognitionException {
 993  59
                 HtmlElementEndContext _localctx = new HtmlElementEndContext(_ctx, getState());
 994  59
                 enterRule(_localctx, 6, RULE_htmlElementEnd);
 995  
                 int _la;
 996  
                 try {
 997  59
                         enterOuterAlt(_localctx, 1);
 998  
                         {
 999  59
                         setState(252);
 1000  59
                         match(START);
 1001  59
                         setState(253);
 1002  59
                         match(SLASH);
 1003  59
                         setState(254);
 1004  59
                         match(HTML_TAG_NAME);
 1005  59
                         setState(258);
 1006  59
                         _errHandler.sync(this);
 1007  59
                         _la = _input.LA(1);
 1008  59
                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
 1009  
                                 {
 1010  
                                 {
 1011  0
                                 setState(255);
 1012  0
                                 _la = _input.LA(1);
 1013  0
                                 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
 1014  0
                                 _errHandler.recoverInline(this);
 1015  
                                 }
 1016  
                                 else {
 1017  0
                                         if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
 1018  0
                                         _errHandler.reportMatch(this);
 1019  0
                                         consume();
 1020  
                                 }
 1021  
                                 }
 1022  
                                 }
 1023  0
                                 setState(260);
 1024  0
                                 _errHandler.sync(this);
 1025  0
                                 _la = _input.LA(1);
 1026  
                         }
 1027  59
                         setState(261);
 1028  59
                         match(END);
 1029  
                         }
 1030  
                 }
 1031  0
                 catch (RecognitionException re) {
 1032  0
                         _localctx.exception = re;
 1033  0
                         _errHandler.reportError(this, re);
 1034  0
                         _errHandler.recover(this, re);
 1035  
                 }
 1036  
                 finally {
 1037  59
                         exitRule();
 1038  59
                 }
 1039  59
                 return _localctx;
 1040  
         }
 1041  
 
 1042  
         public static class AttributeContext extends ParserRuleContext {
 1043  
                 public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); }
 1044  
                 public TerminalNode HTML_TAG_NAME(int i) {
 1045  
                         return getToken(JavadocParser.HTML_TAG_NAME, i);
 1046  
                 }
 1047  
                 public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); }
 1048  
                 public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); }
 1049  
                 public TextContext text() {
 1050  
                         return getRuleContext(TextContext.class,0);
 1051  
                 }
 1052  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 1053  
                 public TerminalNode NEWLINE(int i) {
 1054  
                         return getToken(JavadocParser.NEWLINE, i);
 1055  
                 }
 1056  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 1057  
                 public TerminalNode LEADING_ASTERISK(int i) {
 1058  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 1059  
                 }
 1060  
                 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
 1061  
                 public TerminalNode WS(int i) {
 1062  
                         return getToken(JavadocParser.WS, i);
 1063  
                 }
 1064  
                 public AttributeContext(ParserRuleContext parent, int invokingState) {
 1065  
                         super(parent, invokingState);
 1066  
                 }
 1067  
                 @Override public int getRuleIndex() { return RULE_attribute; }
 1068  
         }
 1069  
 
 1070  
         public final AttributeContext attribute() throws RecognitionException {
 1071  165
                 AttributeContext _localctx = new AttributeContext(_ctx, getState());
 1072  165
                 enterRule(_localctx, 8, RULE_attribute);
 1073  
                 int _la;
 1074  
                 try {
 1075  
                         int _alt;
 1076  165
                         enterOuterAlt(_localctx, 1);
 1077  
                         {
 1078  165
                         setState(263);
 1079  165
                         match(HTML_TAG_NAME);
 1080  165
                         setState(267);
 1081  165
                         _errHandler.sync(this);
 1082  165
                         _la = _input.LA(1);
 1083  165
                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
 1084  
                                 {
 1085  
                                 {
 1086  0
                                 setState(264);
 1087  0
                                 _la = _input.LA(1);
 1088  0
                                 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
 1089  0
                                 _errHandler.recoverInline(this);
 1090  
                                 }
 1091  
                                 else {
 1092  0
                                         if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
 1093  0
                                         _errHandler.reportMatch(this);
 1094  0
                                         consume();
 1095  
                                 }
 1096  
                                 }
 1097  
                                 }
 1098  0
                                 setState(269);
 1099  0
                                 _errHandler.sync(this);
 1100  0
                                 _la = _input.LA(1);
 1101  
                         }
 1102  165
                         setState(270);
 1103  165
                         match(EQUALS);
 1104  165
                         setState(274);
 1105  165
                         _errHandler.sync(this);
 1106  165
                         _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
 1107  165
                         while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 1108  0
                                 if ( _alt==1 ) {
 1109  
                                         {
 1110  
                                         {
 1111  0
                                         setState(271);
 1112  0
                                         _la = _input.LA(1);
 1113  0
                                         if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
 1114  0
                                         _errHandler.recoverInline(this);
 1115  
                                         }
 1116  
                                         else {
 1117  0
                                                 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
 1118  0
                                                 _errHandler.reportMatch(this);
 1119  0
                                                 consume();
 1120  
                                         }
 1121  
                                         }
 1122  
                                         } 
 1123  
                                 }
 1124  0
                                 setState(276);
 1125  0
                                 _errHandler.sync(this);
 1126  0
                                 _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
 1127  
                         }
 1128  165
                         setState(280);
 1129  165
                         _errHandler.sync(this);
 1130  165
                         switch (_input.LA(1)) {
 1131  
                         case ATTR_VALUE:
 1132  
                                 {
 1133  165
                                 setState(277);
 1134  165
                                 match(ATTR_VALUE);
 1135  
                                 }
 1136  165
                                 break;
 1137  
                         case WS:
 1138  
                         case CHAR:
 1139  
                                 {
 1140  0
                                 setState(278);
 1141  0
                                 text();
 1142  
                                 }
 1143  0
                                 break;
 1144  
                         case HTML_TAG_NAME:
 1145  
                                 {
 1146  0
                                 setState(279);
 1147  0
                                 match(HTML_TAG_NAME);
 1148  
                                 }
 1149  0
                                 break;
 1150  
                         default:
 1151  0
                                 throw new NoViableAltException(this);
 1152  
                         }
 1153  
                         }
 1154  
                 }
 1155  0
                 catch (RecognitionException re) {
 1156  0
                         _localctx.exception = re;
 1157  0
                         _errHandler.reportError(this, re);
 1158  0
                         _errHandler.recover(this, re);
 1159  
                 }
 1160  
                 finally {
 1161  165
                         exitRule();
 1162  165
                 }
 1163  165
                 return _localctx;
 1164  
         }
 1165  
 
 1166  
         public static class HtmlTagContext extends ParserRuleContext {
 1167  
                 public HtmlElementStartContext htmlElementStart;
 1168  
                 public HtmlElementEndContext htmlElementEnd;
 1169  
                 public HtmlElementStartContext htmlElementStart() {
 1170  
                         return getRuleContext(HtmlElementStartContext.class,0);
 1171  
                 }
 1172  
                 public HtmlElementEndContext htmlElementEnd() {
 1173  
                         return getRuleContext(HtmlElementEndContext.class,0);
 1174  
                 }
 1175  
                 public List<HtmlElementContext> htmlElement() {
 1176  
                         return getRuleContexts(HtmlElementContext.class);
 1177  
                 }
 1178  
                 public HtmlElementContext htmlElement(int i) {
 1179  
                         return getRuleContext(HtmlElementContext.class,i);
 1180  
                 }
 1181  
                 public List<HtmlCommentContext> htmlComment() {
 1182  
                         return getRuleContexts(HtmlCommentContext.class);
 1183  
                 }
 1184  
                 public HtmlCommentContext htmlComment(int i) {
 1185  
                         return getRuleContext(HtmlCommentContext.class,i);
 1186  
                 }
 1187  
                 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
 1188  
                 public TerminalNode CDATA(int i) {
 1189  
                         return getToken(JavadocParser.CDATA, i);
 1190  
                 }
 1191  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 1192  
                 public TerminalNode NEWLINE(int i) {
 1193  
                         return getToken(JavadocParser.NEWLINE, i);
 1194  
                 }
 1195  
                 public List<TextContext> text() {
 1196  
                         return getRuleContexts(TextContext.class);
 1197  
                 }
 1198  
                 public TextContext text(int i) {
 1199  
                         return getRuleContext(TextContext.class,i);
 1200  
                 }
 1201  
                 public List<JavadocInlineTagContext> javadocInlineTag() {
 1202  
                         return getRuleContexts(JavadocInlineTagContext.class);
 1203  
                 }
 1204  
                 public JavadocInlineTagContext javadocInlineTag(int i) {
 1205  
                         return getRuleContext(JavadocInlineTagContext.class,i);
 1206  
                 }
 1207  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 1208  
                 public TerminalNode LEADING_ASTERISK(int i) {
 1209  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 1210  
                 }
 1211  
                 public HtmlTagContext(ParserRuleContext parent, int invokingState) {
 1212  
                         super(parent, invokingState);
 1213  
                 }
 1214  
                 @Override public int getRuleIndex() { return RULE_htmlTag; }
 1215  
         }
 1216  
 
 1217  
         public final HtmlTagContext htmlTag() throws RecognitionException {
 1218  105
                 HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState());
 1219  105
                 enterRule(_localctx, 10, RULE_htmlTag);
 1220  
                 try {
 1221  
                         int _alt;
 1222  105
                         enterOuterAlt(_localctx, 1);
 1223  
                         {
 1224  105
                         setState(282);
 1225  105
                         ((HtmlTagContext)_localctx).htmlElementStart = htmlElementStart();
 1226  105
                         setState(293);
 1227  105
                         _errHandler.sync(this);
 1228  105
                         _alt = getInterpreter().adaptivePredict(_input,13,_ctx);
 1229  395
                         while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 1230  336
                                 if ( _alt==1 ) {
 1231  
                                         {
 1232  336
                                         setState(291);
 1233  336
                                         _errHandler.sync(this);
 1234  336
                                         switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
 1235  
                                         case 1:
 1236  
                                                 {
 1237  61
                                                 setState(283);
 1238  61
                                                 htmlElement();
 1239  
                                                 }
 1240  21
                                                 break;
 1241  
                                         case 2:
 1242  
                                                 {
 1243  
                                                 {
 1244  31
                                                 setState(284);
 1245  31
                                                 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
 1246  31
                                                 setState(285);
 1247  31
                                                 match(LEADING_ASTERISK);
 1248  
                                                 }
 1249  
                                                 }
 1250  31
                                                 break;
 1251  
                                         case 3:
 1252  
                                                 {
 1253  0
                                                 setState(286);
 1254  0
                                                 htmlComment();
 1255  
                                                 }
 1256  0
                                                 break;
 1257  
                                         case 4:
 1258  
                                                 {
 1259  0
                                                 setState(287);
 1260  0
                                                 match(CDATA);
 1261  
                                                 }
 1262  0
                                                 break;
 1263  
                                         case 5:
 1264  
                                                 {
 1265  78
                                                 setState(288);
 1266  78
                                                 match(NEWLINE);
 1267  
                                                 }
 1268  78
                                                 break;
 1269  
                                         case 6:
 1270  
                                                 {
 1271  164
                                                 setState(289);
 1272  164
                                                 text();
 1273  
                                                 }
 1274  164
                                                 break;
 1275  
                                         case 7:
 1276  
                                                 {
 1277  2
                                                 setState(290);
 1278  2
                                                 javadocInlineTag();
 1279  
                                                 }
 1280  
                                                 break;
 1281  
                                         }
 1282  
                                         } 
 1283  
                                 }
 1284  295
                                 setState(295);
 1285  295
                                 _errHandler.sync(this);
 1286  295
                                 _alt = getInterpreter().adaptivePredict(_input,13,_ctx);
 1287  
                         }
 1288  59
                         setState(296);
 1289  59
                         ((HtmlTagContext)_localctx).htmlElementEnd = htmlElementEnd();
 1290  59
                         setState(297);
 1291  59
                         if (!(isSameTagNames(((HtmlTagContext)_localctx).htmlElementStart, ((HtmlTagContext)_localctx).htmlElementEnd))) throw new FailedPredicateException(this, "isSameTagNames($htmlElementStart.ctx, $htmlElementEnd.ctx)");
 1292  
                         }
 1293  
                 }
 1294  7
                 catch (RecognitionException re) {
 1295  7
                         _localctx.exception = re;
 1296  7
                         _errHandler.reportError(this, re);
 1297  7
                         _errHandler.recover(this, re);
 1298  
                 }
 1299  
                 finally {
 1300  105
                         exitRule();
 1301  57
                 }
 1302  57
                 return _localctx;
 1303  
         }
 1304  
 
 1305  
         public static class PTagStartContext extends ParserRuleContext {
 1306  
                 public boolean isNonTight;
 1307  
                 public TerminalNode START() { return getToken(JavadocParser.START, 0); }
 1308  
                 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
 1309  
                 public TerminalNode END() { return getToken(JavadocParser.END, 0); }
 1310  
                 public List<AttributeContext> attribute() {
 1311  
                         return getRuleContexts(AttributeContext.class);
 1312  
                 }
 1313  
                 public AttributeContext attribute(int i) {
 1314  
                         return getRuleContext(AttributeContext.class,i);
 1315  
                 }
 1316  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 1317  
                 public TerminalNode NEWLINE(int i) {
 1318  
                         return getToken(JavadocParser.NEWLINE, i);
 1319  
                 }
 1320  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 1321  
                 public TerminalNode LEADING_ASTERISK(int i) {
 1322  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 1323  
                 }
 1324  
                 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
 1325  
                 public TerminalNode WS(int i) {
 1326  
                         return getToken(JavadocParser.WS, i);
 1327  
                 }
 1328  
                 public PTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
 1329  
                 public PTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
 1330  
                         super(parent, invokingState);
 1331  
                         this.isNonTight = isNonTight;
 1332  
                 }
 1333  
                 @Override public int getRuleIndex() { return RULE_pTagStart; }
 1334  
         }
 1335  
 
 1336  
         public final PTagStartContext pTagStart(boolean isNonTight) throws RecognitionException {
 1337  197
                 PTagStartContext _localctx = new PTagStartContext(_ctx, getState(), isNonTight);
 1338  197
                 enterRule(_localctx, 12, RULE_pTagStart);
 1339  
                 int _la;
 1340  
                 try {
 1341  197
                         enterOuterAlt(_localctx, 1);
 1342  
                         {
 1343  197
                         setState(299);
 1344  197
                         match(START);
 1345  197
                         setState(300);
 1346  197
                         match(P_HTML_TAG_NAME);
 1347  197
                         setState(307);
 1348  197
                         _errHandler.sync(this);
 1349  197
                         _la = _input.LA(1);
 1350  208
                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
 1351  
                                 {
 1352  11
                                 setState(305);
 1353  11
                                 _errHandler.sync(this);
 1354  11
                                 switch (_input.LA(1)) {
 1355  
                                 case HTML_TAG_NAME:
 1356  
                                         {
 1357  2
                                         setState(301);
 1358  2
                                         attribute();
 1359  
                                         }
 1360  2
                                         break;
 1361  
                                 case NEWLINE:
 1362  
                                         {
 1363  2
                                         setState(302);
 1364  2
                                         match(NEWLINE);
 1365  
                                         }
 1366  2
                                         break;
 1367  
                                 case LEADING_ASTERISK:
 1368  
                                         {
 1369  2
                                         setState(303);
 1370  2
                                         match(LEADING_ASTERISK);
 1371  
                                         }
 1372  2
                                         break;
 1373  
                                 case WS:
 1374  
                                         {
 1375  5
                                         setState(304);
 1376  5
                                         match(WS);
 1377  
                                         }
 1378  5
                                         break;
 1379  
                                 default:
 1380  0
                                         throw new NoViableAltException(this);
 1381  
                                 }
 1382  
                                 }
 1383  11
                                 setState(309);
 1384  11
                                 _errHandler.sync(this);
 1385  11
                                 _la = _input.LA(1);
 1386  
                         }
 1387  197
                         setState(310);
 1388  197
                         match(END);
 1389  
                         }
 1390  197
                         _ctx.stop = _input.LT(-1);
 1391  
 
 1392  197
                             if (isNonTight && nonTightTagStartContext == null) {
 1393  55
                                 nonTightTagStartContext = _localctx;
 1394  
                             }
 1395  
 
 1396  
                 }
 1397  0
                 catch (RecognitionException re) {
 1398  0
                         _localctx.exception = re;
 1399  0
                         _errHandler.reportError(this, re);
 1400  0
                         _errHandler.recover(this, re);
 1401  
                 }
 1402  
                 finally {
 1403  197
                         exitRule();
 1404  197
                 }
 1405  197
                 return _localctx;
 1406  
         }
 1407  
 
 1408  
         public static class PTagEndContext extends ParserRuleContext {
 1409  
                 public TerminalNode START() { return getToken(JavadocParser.START, 0); }
 1410  
                 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
 1411  
                 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
 1412  
                 public TerminalNode END() { return getToken(JavadocParser.END, 0); }
 1413  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 1414  
                 public TerminalNode NEWLINE(int i) {
 1415  
                         return getToken(JavadocParser.NEWLINE, i);
 1416  
                 }
 1417  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 1418  
                 public TerminalNode LEADING_ASTERISK(int i) {
 1419  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 1420  
                 }
 1421  
                 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
 1422  
                 public TerminalNode WS(int i) {
 1423  
                         return getToken(JavadocParser.WS, i);
 1424  
                 }
 1425  
                 public PTagEndContext(ParserRuleContext parent, int invokingState) {
 1426  
                         super(parent, invokingState);
 1427  
                 }
 1428  
                 @Override public int getRuleIndex() { return RULE_pTagEnd; }
 1429  
         }
 1430  
 
 1431  
         public final PTagEndContext pTagEnd() throws RecognitionException {
 1432  123
                 PTagEndContext _localctx = new PTagEndContext(_ctx, getState());
 1433  123
                 enterRule(_localctx, 14, RULE_pTagEnd);
 1434  
                 int _la;
 1435  
                 try {
 1436  123
                         enterOuterAlt(_localctx, 1);
 1437  
                         {
 1438  123
                         setState(312);
 1439  123
                         match(START);
 1440  123
                         setState(313);
 1441  123
                         match(SLASH);
 1442  123
                         setState(314);
 1443  123
                         match(P_HTML_TAG_NAME);
 1444  123
                         setState(318);
 1445  123
                         _errHandler.sync(this);
 1446  123
                         _la = _input.LA(1);
 1447  130
                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
 1448  
                                 {
 1449  
                                 {
 1450  7
                                 setState(315);
 1451  7
                                 _la = _input.LA(1);
 1452  7
                                 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
 1453  0
                                 _errHandler.recoverInline(this);
 1454  
                                 }
 1455  
                                 else {
 1456  7
                                         if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
 1457  7
                                         _errHandler.reportMatch(this);
 1458  7
                                         consume();
 1459  
                                 }
 1460  
                                 }
 1461  
                                 }
 1462  7
                                 setState(320);
 1463  7
                                 _errHandler.sync(this);
 1464  7
                                 _la = _input.LA(1);
 1465  
                         }
 1466  123
                         setState(321);
 1467  123
                         match(END);
 1468  
                         }
 1469  
                 }
 1470  0
                 catch (RecognitionException re) {
 1471  0
                         _localctx.exception = re;
 1472  0
                         _errHandler.reportError(this, re);
 1473  0
                         _errHandler.recover(this, re);
 1474  
                 }
 1475  
                 finally {
 1476  123
                         exitRule();
 1477  123
                 }
 1478  123
                 return _localctx;
 1479  
         }
 1480  
 
 1481  
         public static class ParagraphContext extends ParserRuleContext {
 1482  
                 public PTagStartContext pTagStart() {
 1483  
                         return getRuleContext(PTagStartContext.class,0);
 1484  
                 }
 1485  
                 public PTagEndContext pTagEnd() {
 1486  
                         return getRuleContext(PTagEndContext.class,0);
 1487  
                 }
 1488  
                 public List<HtmlTagContext> htmlTag() {
 1489  
                         return getRuleContexts(HtmlTagContext.class);
 1490  
                 }
 1491  
                 public HtmlTagContext htmlTag(int i) {
 1492  
                         return getRuleContext(HtmlTagContext.class,i);
 1493  
                 }
 1494  
                 public List<SingletonElementContext> singletonElement() {
 1495  
                         return getRuleContexts(SingletonElementContext.class);
 1496  
                 }
 1497  
                 public SingletonElementContext singletonElement(int i) {
 1498  
                         return getRuleContext(SingletonElementContext.class,i);
 1499  
                 }
 1500  
                 public List<LiContext> li() {
 1501  
                         return getRuleContexts(LiContext.class);
 1502  
                 }
 1503  
                 public LiContext li(int i) {
 1504  
                         return getRuleContext(LiContext.class,i);
 1505  
                 }
 1506  
                 public List<TrContext> tr() {
 1507  
                         return getRuleContexts(TrContext.class);
 1508  
                 }
 1509  
                 public TrContext tr(int i) {
 1510  
                         return getRuleContext(TrContext.class,i);
 1511  
                 }
 1512  
                 public List<TdContext> td() {
 1513  
                         return getRuleContexts(TdContext.class);
 1514  
                 }
 1515  
                 public TdContext td(int i) {
 1516  
                         return getRuleContext(TdContext.class,i);
 1517  
                 }
 1518  
                 public List<ThContext> th() {
 1519  
                         return getRuleContexts(ThContext.class);
 1520  
                 }
 1521  
                 public ThContext th(int i) {
 1522  
                         return getRuleContext(ThContext.class,i);
 1523  
                 }
 1524  
                 public List<BodyContext> body() {
 1525  
                         return getRuleContexts(BodyContext.class);
 1526  
                 }
 1527  
                 public BodyContext body(int i) {
 1528  
                         return getRuleContext(BodyContext.class,i);
 1529  
                 }
 1530  
                 public List<ColgroupContext> colgroup() {
 1531  
                         return getRuleContexts(ColgroupContext.class);
 1532  
                 }
 1533  
                 public ColgroupContext colgroup(int i) {
 1534  
                         return getRuleContext(ColgroupContext.class,i);
 1535  
                 }
 1536  
                 public List<DdContext> dd() {
 1537  
                         return getRuleContexts(DdContext.class);
 1538  
                 }
 1539  
                 public DdContext dd(int i) {
 1540  
                         return getRuleContext(DdContext.class,i);
 1541  
                 }
 1542  
                 public List<DtContext> dt() {
 1543  
                         return getRuleContexts(DtContext.class);
 1544  
                 }
 1545  
                 public DtContext dt(int i) {
 1546  
                         return getRuleContext(DtContext.class,i);
 1547  
                 }
 1548  
                 public List<HeadContext> head() {
 1549  
                         return getRuleContexts(HeadContext.class);
 1550  
                 }
 1551  
                 public HeadContext head(int i) {
 1552  
                         return getRuleContext(HeadContext.class,i);
 1553  
                 }
 1554  
                 public List<HtmlContext> html() {
 1555  
                         return getRuleContexts(HtmlContext.class);
 1556  
                 }
 1557  
                 public HtmlContext html(int i) {
 1558  
                         return getRuleContext(HtmlContext.class,i);
 1559  
                 }
 1560  
                 public List<OptionContext> option() {
 1561  
                         return getRuleContexts(OptionContext.class);
 1562  
                 }
 1563  
                 public OptionContext option(int i) {
 1564  
                         return getRuleContext(OptionContext.class,i);
 1565  
                 }
 1566  
                 public List<TbodyContext> tbody() {
 1567  
                         return getRuleContexts(TbodyContext.class);
 1568  
                 }
 1569  
                 public TbodyContext tbody(int i) {
 1570  
                         return getRuleContext(TbodyContext.class,i);
 1571  
                 }
 1572  
                 public List<TheadContext> thead() {
 1573  
                         return getRuleContexts(TheadContext.class);
 1574  
                 }
 1575  
                 public TheadContext thead(int i) {
 1576  
                         return getRuleContext(TheadContext.class,i);
 1577  
                 }
 1578  
                 public List<TfootContext> tfoot() {
 1579  
                         return getRuleContexts(TfootContext.class);
 1580  
                 }
 1581  
                 public TfootContext tfoot(int i) {
 1582  
                         return getRuleContext(TfootContext.class,i);
 1583  
                 }
 1584  
                 public List<LiTagStartContext> liTagStart() {
 1585  
                         return getRuleContexts(LiTagStartContext.class);
 1586  
                 }
 1587  
                 public LiTagStartContext liTagStart(int i) {
 1588  
                         return getRuleContext(LiTagStartContext.class,i);
 1589  
                 }
 1590  
                 public List<TrTagStartContext> trTagStart() {
 1591  
                         return getRuleContexts(TrTagStartContext.class);
 1592  
                 }
 1593  
                 public TrTagStartContext trTagStart(int i) {
 1594  
                         return getRuleContext(TrTagStartContext.class,i);
 1595  
                 }
 1596  
                 public List<TdTagStartContext> tdTagStart() {
 1597  
                         return getRuleContexts(TdTagStartContext.class);
 1598  
                 }
 1599  
                 public TdTagStartContext tdTagStart(int i) {
 1600  
                         return getRuleContext(TdTagStartContext.class,i);
 1601  
                 }
 1602  
                 public List<ThTagStartContext> thTagStart() {
 1603  
                         return getRuleContexts(ThTagStartContext.class);
 1604  
                 }
 1605  
                 public ThTagStartContext thTagStart(int i) {
 1606  
                         return getRuleContext(ThTagStartContext.class,i);
 1607  
                 }
 1608  
                 public List<BodyTagStartContext> bodyTagStart() {
 1609  
                         return getRuleContexts(BodyTagStartContext.class);
 1610  
                 }
 1611  
                 public BodyTagStartContext bodyTagStart(int i) {
 1612  
                         return getRuleContext(BodyTagStartContext.class,i);
 1613  
                 }
 1614  
                 public List<ColgroupTagStartContext> colgroupTagStart() {
 1615  
                         return getRuleContexts(ColgroupTagStartContext.class);
 1616  
                 }
 1617  
                 public ColgroupTagStartContext colgroupTagStart(int i) {
 1618  
                         return getRuleContext(ColgroupTagStartContext.class,i);
 1619  
                 }
 1620  
                 public List<DdTagStartContext> ddTagStart() {
 1621  
                         return getRuleContexts(DdTagStartContext.class);
 1622  
                 }
 1623  
                 public DdTagStartContext ddTagStart(int i) {
 1624  
                         return getRuleContext(DdTagStartContext.class,i);
 1625  
                 }
 1626  
                 public List<DtTagStartContext> dtTagStart() {
 1627  
                         return getRuleContexts(DtTagStartContext.class);
 1628  
                 }
 1629  
                 public DtTagStartContext dtTagStart(int i) {
 1630  
                         return getRuleContext(DtTagStartContext.class,i);
 1631  
                 }
 1632  
                 public List<HeadTagStartContext> headTagStart() {
 1633  
                         return getRuleContexts(HeadTagStartContext.class);
 1634  
                 }
 1635  
                 public HeadTagStartContext headTagStart(int i) {
 1636  
                         return getRuleContext(HeadTagStartContext.class,i);
 1637  
                 }
 1638  
                 public List<HtmlTagStartContext> htmlTagStart() {
 1639  
                         return getRuleContexts(HtmlTagStartContext.class);
 1640  
                 }
 1641  
                 public HtmlTagStartContext htmlTagStart(int i) {
 1642  
                         return getRuleContext(HtmlTagStartContext.class,i);
 1643  
                 }
 1644  
                 public List<OptionTagStartContext> optionTagStart() {
 1645  
                         return getRuleContexts(OptionTagStartContext.class);
 1646  
                 }
 1647  
                 public OptionTagStartContext optionTagStart(int i) {
 1648  
                         return getRuleContext(OptionTagStartContext.class,i);
 1649  
                 }
 1650  
                 public List<TbodyTagStartContext> tbodyTagStart() {
 1651  
                         return getRuleContexts(TbodyTagStartContext.class);
 1652  
                 }
 1653  
                 public TbodyTagStartContext tbodyTagStart(int i) {
 1654  
                         return getRuleContext(TbodyTagStartContext.class,i);
 1655  
                 }
 1656  
                 public List<TheadTagStartContext> theadTagStart() {
 1657  
                         return getRuleContexts(TheadTagStartContext.class);
 1658  
                 }
 1659  
                 public TheadTagStartContext theadTagStart(int i) {
 1660  
                         return getRuleContext(TheadTagStartContext.class,i);
 1661  
                 }
 1662  
                 public List<TfootTagStartContext> tfootTagStart() {
 1663  
                         return getRuleContexts(TfootTagStartContext.class);
 1664  
                 }
 1665  
                 public TfootTagStartContext tfootTagStart(int i) {
 1666  
                         return getRuleContext(TfootTagStartContext.class,i);
 1667  
                 }
 1668  
                 public List<HtmlCommentContext> htmlComment() {
 1669  
                         return getRuleContexts(HtmlCommentContext.class);
 1670  
                 }
 1671  
                 public HtmlCommentContext htmlComment(int i) {
 1672  
                         return getRuleContext(HtmlCommentContext.class,i);
 1673  
                 }
 1674  
                 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
 1675  
                 public TerminalNode CDATA(int i) {
 1676  
                         return getToken(JavadocParser.CDATA, i);
 1677  
                 }
 1678  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 1679  
                 public TerminalNode NEWLINE(int i) {
 1680  
                         return getToken(JavadocParser.NEWLINE, i);
 1681  
                 }
 1682  
                 public List<TextContext> text() {
 1683  
                         return getRuleContexts(TextContext.class);
 1684  
                 }
 1685  
                 public TextContext text(int i) {
 1686  
                         return getRuleContext(TextContext.class,i);
 1687  
                 }
 1688  
                 public List<JavadocInlineTagContext> javadocInlineTag() {
 1689  
                         return getRuleContexts(JavadocInlineTagContext.class);
 1690  
                 }
 1691  
                 public JavadocInlineTagContext javadocInlineTag(int i) {
 1692  
                         return getRuleContext(JavadocInlineTagContext.class,i);
 1693  
                 }
 1694  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 1695  
                 public TerminalNode LEADING_ASTERISK(int i) {
 1696  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 1697  
                 }
 1698  
                 public ParagraphContext(ParserRuleContext parent, int invokingState) {
 1699  
                         super(parent, invokingState);
 1700  
                 }
 1701  
                 @Override public int getRuleIndex() { return RULE_paragraph; }
 1702  
         }
 1703  
 
 1704  
         public final ParagraphContext paragraph() throws RecognitionException {
 1705  91
                 ParagraphContext _localctx = new ParagraphContext(_ctx, getState());
 1706  91
                 enterRule(_localctx, 16, RULE_paragraph);
 1707  
                 try {
 1708  
                         int _alt;
 1709  91
                         enterOuterAlt(_localctx, 1);
 1710  
                         {
 1711  91
                         setState(323);
 1712  91
                         pTagStart(false);
 1713  91
                         setState(363);
 1714  91
                         _errHandler.sync(this);
 1715  91
                         _alt = getInterpreter().adaptivePredict(_input,18,_ctx);
 1716  354
                         while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 1717  263
                                 if ( _alt==1 ) {
 1718  
                                         {
 1719  263
                                         setState(361);
 1720  263
                                         _errHandler.sync(this);
 1721  263
                                         switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
 1722  
                                         case 1:
 1723  
                                                 {
 1724  9
                                                 setState(324);
 1725  9
                                                 htmlTag();
 1726  
                                                 }
 1727  9
                                                 break;
 1728  
                                         case 2:
 1729  
                                                 {
 1730  29
                                                 setState(325);
 1731  29
                                                 singletonElement();
 1732  
                                                 }
 1733  29
                                                 break;
 1734  
                                         case 3:
 1735  
                                                 {
 1736  5
                                                 setState(326);
 1737  5
                                                 li();
 1738  
                                                 }
 1739  5
                                                 break;
 1740  
                                         case 4:
 1741  
                                                 {
 1742  1
                                                 setState(327);
 1743  1
                                                 tr();
 1744  
                                                 }
 1745  1
                                                 break;
 1746  
                                         case 5:
 1747  
                                                 {
 1748  1
                                                 setState(328);
 1749  1
                                                 td();
 1750  
                                                 }
 1751  1
                                                 break;
 1752  
                                         case 6:
 1753  
                                                 {
 1754  1
                                                 setState(329);
 1755  1
                                                 th();
 1756  
                                                 }
 1757  1
                                                 break;
 1758  
                                         case 7:
 1759  
                                                 {
 1760  1
                                                 setState(330);
 1761  1
                                                 body();
 1762  
                                                 }
 1763  1
                                                 break;
 1764  
                                         case 8:
 1765  
                                                 {
 1766  1
                                                 setState(331);
 1767  1
                                                 colgroup();
 1768  
                                                 }
 1769  1
                                                 break;
 1770  
                                         case 9:
 1771  
                                                 {
 1772  1
                                                 setState(332);
 1773  1
                                                 dd();
 1774  
                                                 }
 1775  1
                                                 break;
 1776  
                                         case 10:
 1777  
                                                 {
 1778  1
                                                 setState(333);
 1779  1
                                                 dt();
 1780  
                                                 }
 1781  1
                                                 break;
 1782  
                                         case 11:
 1783  
                                                 {
 1784  1
                                                 setState(334);
 1785  1
                                                 head();
 1786  
                                                 }
 1787  1
                                                 break;
 1788  
                                         case 12:
 1789  
                                                 {
 1790  1
                                                 setState(335);
 1791  1
                                                 html();
 1792  
                                                 }
 1793  1
                                                 break;
 1794  
                                         case 13:
 1795  
                                                 {
 1796  1
                                                 setState(336);
 1797  1
                                                 option();
 1798  
                                                 }
 1799  1
                                                 break;
 1800  
                                         case 14:
 1801  
                                                 {
 1802  1
                                                 setState(337);
 1803  1
                                                 tbody();
 1804  
                                                 }
 1805  1
                                                 break;
 1806  
                                         case 15:
 1807  
                                                 {
 1808  0
                                                 setState(338);
 1809  0
                                                 thead();
 1810  
                                                 }
 1811  0
                                                 break;
 1812  
                                         case 16:
 1813  
                                                 {
 1814  1
                                                 setState(339);
 1815  1
                                                 tfoot();
 1816  
                                                 }
 1817  1
                                                 break;
 1818  
                                         case 17:
 1819  
                                                 {
 1820  1
                                                 setState(340);
 1821  1
                                                 liTagStart(true);
 1822  
                                                 }
 1823  1
                                                 break;
 1824  
                                         case 18:
 1825  
                                                 {
 1826  1
                                                 setState(341);
 1827  1
                                                 trTagStart(true);
 1828  
                                                 }
 1829  1
                                                 break;
 1830  
                                         case 19:
 1831  
                                                 {
 1832  1
                                                 setState(342);
 1833  1
                                                 tdTagStart(true);
 1834  
                                                 }
 1835  1
                                                 break;
 1836  
                                         case 20:
 1837  
                                                 {
 1838  1
                                                 setState(343);
 1839  1
                                                 thTagStart(true);
 1840  
                                                 }
 1841  1
                                                 break;
 1842  
                                         case 21:
 1843  
                                                 {
 1844  1
                                                 setState(344);
 1845  1
                                                 bodyTagStart(true);
 1846  
                                                 }
 1847  1
                                                 break;
 1848  
                                         case 22:
 1849  
                                                 {
 1850  1
                                                 setState(345);
 1851  1
                                                 colgroupTagStart(true);
 1852  
                                                 }
 1853  1
                                                 break;
 1854  
                                         case 23:
 1855  
                                                 {
 1856  1
                                                 setState(346);
 1857  1
                                                 ddTagStart(true);
 1858  
                                                 }
 1859  1
                                                 break;
 1860  
                                         case 24:
 1861  
                                                 {
 1862  1
                                                 setState(347);
 1863  1
                                                 dtTagStart(true);
 1864  
                                                 }
 1865  1
                                                 break;
 1866  
                                         case 25:
 1867  
                                                 {
 1868  1
                                                 setState(348);
 1869  1
                                                 headTagStart(true);
 1870  
                                                 }
 1871  1
                                                 break;
 1872  
                                         case 26:
 1873  
                                                 {
 1874  1
                                                 setState(349);
 1875  1
                                                 htmlTagStart(true);
 1876  
                                                 }
 1877  1
                                                 break;
 1878  
                                         case 27:
 1879  
                                                 {
 1880  1
                                                 setState(350);
 1881  1
                                                 optionTagStart(true);
 1882  
                                                 }
 1883  1
                                                 break;
 1884  
                                         case 28:
 1885  
                                                 {
 1886  1
                                                 setState(351);
 1887  1
                                                 tbodyTagStart(true);
 1888  
                                                 }
 1889  1
                                                 break;
 1890  
                                         case 29:
 1891  
                                                 {
 1892  0
                                                 setState(352);
 1893  0
                                                 theadTagStart(true);
 1894  
                                                 }
 1895  0
                                                 break;
 1896  
                                         case 30:
 1897  
                                                 {
 1898  1
                                                 setState(353);
 1899  1
                                                 tfootTagStart(true);
 1900  
                                                 }
 1901  1
                                                 break;
 1902  
                                         case 31:
 1903  
                                                 {
 1904  
                                                 {
 1905  10
                                                 setState(354);
 1906  10
                                                 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
 1907  10
                                                 setState(355);
 1908  10
                                                 match(LEADING_ASTERISK);
 1909  
                                                 }
 1910  
                                                 }
 1911  10
                                                 break;
 1912  
                                         case 32:
 1913  
                                                 {
 1914  1
                                                 setState(356);
 1915  1
                                                 htmlComment();
 1916  
                                                 }
 1917  1
                                                 break;
 1918  
                                         case 33:
 1919  
                                                 {
 1920  0
                                                 setState(357);
 1921  0
                                                 match(CDATA);
 1922  
                                                 }
 1923  0
                                                 break;
 1924  
                                         case 34:
 1925  
                                                 {
 1926  22
                                                 setState(358);
 1927  22
                                                 match(NEWLINE);
 1928  
                                                 }
 1929  22
                                                 break;
 1930  
                                         case 35:
 1931  
                                                 {
 1932  159
                                                 setState(359);
 1933  159
                                                 text();
 1934  
                                                 }
 1935  159
                                                 break;
 1936  
                                         case 36:
 1937  
                                                 {
 1938  3
                                                 setState(360);
 1939  3
                                                 javadocInlineTag();
 1940  
                                                 }
 1941  
                                                 break;
 1942  
                                         }
 1943  
                                         } 
 1944  
                                 }
 1945  263
                                 setState(365);
 1946  263
                                 _errHandler.sync(this);
 1947  263
                                 _alt = getInterpreter().adaptivePredict(_input,18,_ctx);
 1948  
                         }
 1949  91
                         setState(366);
 1950  91
                         pTagEnd();
 1951  
                         }
 1952  
                 }
 1953  0
                 catch (RecognitionException re) {
 1954  0
                         _localctx.exception = re;
 1955  0
                         _errHandler.reportError(this, re);
 1956  0
                         _errHandler.recover(this, re);
 1957  
                 }
 1958  
                 finally {
 1959  91
                         exitRule();
 1960  91
                 }
 1961  91
                 return _localctx;
 1962  
         }
 1963  
 
 1964  
         public static class LiTagStartContext extends ParserRuleContext {
 1965  
                 public boolean isNonTight;
 1966  
                 public TerminalNode START() { return getToken(JavadocParser.START, 0); }
 1967  
                 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
 1968  
                 public TerminalNode END() { return getToken(JavadocParser.END, 0); }
 1969  
                 public List<AttributeContext> attribute() {
 1970  
                         return getRuleContexts(AttributeContext.class);
 1971  
                 }
 1972  
                 public AttributeContext attribute(int i) {
 1973  
                         return getRuleContext(AttributeContext.class,i);
 1974  
                 }
 1975  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 1976  
                 public TerminalNode NEWLINE(int i) {
 1977  
                         return getToken(JavadocParser.NEWLINE, i);
 1978  
                 }
 1979  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 1980  
                 public TerminalNode LEADING_ASTERISK(int i) {
 1981  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 1982  
                 }
 1983  
                 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
 1984  
                 public TerminalNode WS(int i) {
 1985  
                         return getToken(JavadocParser.WS, i);
 1986  
                 }
 1987  
                 public LiTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
 1988  
                 public LiTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
 1989  
                         super(parent, invokingState);
 1990  
                         this.isNonTight = isNonTight;
 1991  
                 }
 1992  
                 @Override public int getRuleIndex() { return RULE_liTagStart; }
 1993  
         }
 1994  
 
 1995  
         public final LiTagStartContext liTagStart(boolean isNonTight) throws RecognitionException {
 1996  66
                 LiTagStartContext _localctx = new LiTagStartContext(_ctx, getState(), isNonTight);
 1997  66
                 enterRule(_localctx, 18, RULE_liTagStart);
 1998  
                 int _la;
 1999  
                 try {
 2000  66
                         enterOuterAlt(_localctx, 1);
 2001  
                         {
 2002  66
                         setState(368);
 2003  66
                         match(START);
 2004  66
                         setState(369);
 2005  66
                         match(LI_HTML_TAG_NAME);
 2006  66
                         setState(376);
 2007  66
                         _errHandler.sync(this);
 2008  66
                         _la = _input.LA(1);
 2009  66
                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
 2010  
                                 {
 2011  0
                                 setState(374);
 2012  0
                                 _errHandler.sync(this);
 2013  0
                                 switch (_input.LA(1)) {
 2014  
                                 case HTML_TAG_NAME:
 2015  
                                         {
 2016  0
                                         setState(370);
 2017  0
                                         attribute();
 2018  
                                         }
 2019  0
                                         break;
 2020  
                                 case NEWLINE:
 2021  
                                         {
 2022  0
                                         setState(371);
 2023  0
                                         match(NEWLINE);
 2024  
                                         }
 2025  0
                                         break;
 2026  
                                 case LEADING_ASTERISK:
 2027  
                                         {
 2028  0
                                         setState(372);
 2029  0
                                         match(LEADING_ASTERISK);
 2030  
                                         }
 2031  0
                                         break;
 2032  
                                 case WS:
 2033  
                                         {
 2034  0
                                         setState(373);
 2035  0
                                         match(WS);
 2036  
                                         }
 2037  0
                                         break;
 2038  
                                 default:
 2039  0
                                         throw new NoViableAltException(this);
 2040  
                                 }
 2041  
                                 }
 2042  0
                                 setState(378);
 2043  0
                                 _errHandler.sync(this);
 2044  0
                                 _la = _input.LA(1);
 2045  
                         }
 2046  66
                         setState(379);
 2047  66
                         match(END);
 2048  
                         }
 2049  66
                         _ctx.stop = _input.LT(-1);
 2050  
 
 2051  66
                             if (isNonTight && nonTightTagStartContext == null) {
 2052  14
                                 nonTightTagStartContext = _localctx;
 2053  
                             }
 2054  
 
 2055  
                 }
 2056  0
                 catch (RecognitionException re) {
 2057  0
                         _localctx.exception = re;
 2058  0
                         _errHandler.reportError(this, re);
 2059  0
                         _errHandler.recover(this, re);
 2060  
                 }
 2061  
                 finally {
 2062  66
                         exitRule();
 2063  66
                 }
 2064  66
                 return _localctx;
 2065  
         }
 2066  
 
 2067  
         public static class LiTagEndContext extends ParserRuleContext {
 2068  
                 public TerminalNode START() { return getToken(JavadocParser.START, 0); }
 2069  
                 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
 2070  
                 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
 2071  
                 public TerminalNode END() { return getToken(JavadocParser.END, 0); }
 2072  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 2073  
                 public TerminalNode NEWLINE(int i) {
 2074  
                         return getToken(JavadocParser.NEWLINE, i);
 2075  
                 }
 2076  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 2077  
                 public TerminalNode LEADING_ASTERISK(int i) {
 2078  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 2079  
                 }
 2080  
                 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
 2081  
                 public TerminalNode WS(int i) {
 2082  
                         return getToken(JavadocParser.WS, i);
 2083  
                 }
 2084  
                 public LiTagEndContext(ParserRuleContext parent, int invokingState) {
 2085  
                         super(parent, invokingState);
 2086  
                 }
 2087  
                 @Override public int getRuleIndex() { return RULE_liTagEnd; }
 2088  
         }
 2089  
 
 2090  
         public final LiTagEndContext liTagEnd() throws RecognitionException {
 2091  60
                 LiTagEndContext _localctx = new LiTagEndContext(_ctx, getState());
 2092  60
                 enterRule(_localctx, 20, RULE_liTagEnd);
 2093  
                 int _la;
 2094  
                 try {
 2095  60
                         enterOuterAlt(_localctx, 1);
 2096  
                         {
 2097  60
                         setState(381);
 2098  60
                         match(START);
 2099  60
                         setState(382);
 2100  60
                         match(SLASH);
 2101  60
                         setState(383);
 2102  60
                         match(LI_HTML_TAG_NAME);
 2103  60
                         setState(387);
 2104  60
                         _errHandler.sync(this);
 2105  60
                         _la = _input.LA(1);
 2106  60
                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
 2107  
                                 {
 2108  
                                 {
 2109  0
                                 setState(384);
 2110  0
                                 _la = _input.LA(1);
 2111  0
                                 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
 2112  0
                                 _errHandler.recoverInline(this);
 2113  
                                 }
 2114  
                                 else {
 2115  0
                                         if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
 2116  0
                                         _errHandler.reportMatch(this);
 2117  0
                                         consume();
 2118  
                                 }
 2119  
                                 }
 2120  
                                 }
 2121  0
                                 setState(389);
 2122  0
                                 _errHandler.sync(this);
 2123  0
                                 _la = _input.LA(1);
 2124  
                         }
 2125  60
                         setState(390);
 2126  60
                         match(END);
 2127  
                         }
 2128  
                 }
 2129  0
                 catch (RecognitionException re) {
 2130  0
                         _localctx.exception = re;
 2131  0
                         _errHandler.reportError(this, re);
 2132  0
                         _errHandler.recover(this, re);
 2133  
                 }
 2134  
                 finally {
 2135  60
                         exitRule();
 2136  60
                 }
 2137  60
                 return _localctx;
 2138  
         }
 2139  
 
 2140  
         public static class LiContext extends ParserRuleContext {
 2141  
                 public LiTagStartContext liTagStart() {
 2142  
                         return getRuleContext(LiTagStartContext.class,0);
 2143  
                 }
 2144  
                 public LiTagEndContext liTagEnd() {
 2145  
                         return getRuleContext(LiTagEndContext.class,0);
 2146  
                 }
 2147  
                 public List<HtmlTagContext> htmlTag() {
 2148  
                         return getRuleContexts(HtmlTagContext.class);
 2149  
                 }
 2150  
                 public HtmlTagContext htmlTag(int i) {
 2151  
                         return getRuleContext(HtmlTagContext.class,i);
 2152  
                 }
 2153  
                 public List<SingletonElementContext> singletonElement() {
 2154  
                         return getRuleContexts(SingletonElementContext.class);
 2155  
                 }
 2156  
                 public SingletonElementContext singletonElement(int i) {
 2157  
                         return getRuleContext(SingletonElementContext.class,i);
 2158  
                 }
 2159  
                 public List<ParagraphContext> paragraph() {
 2160  
                         return getRuleContexts(ParagraphContext.class);
 2161  
                 }
 2162  
                 public ParagraphContext paragraph(int i) {
 2163  
                         return getRuleContext(ParagraphContext.class,i);
 2164  
                 }
 2165  
                 public List<TrContext> tr() {
 2166  
                         return getRuleContexts(TrContext.class);
 2167  
                 }
 2168  
                 public TrContext tr(int i) {
 2169  
                         return getRuleContext(TrContext.class,i);
 2170  
                 }
 2171  
                 public List<TdContext> td() {
 2172  
                         return getRuleContexts(TdContext.class);
 2173  
                 }
 2174  
                 public TdContext td(int i) {
 2175  
                         return getRuleContext(TdContext.class,i);
 2176  
                 }
 2177  
                 public List<ThContext> th() {
 2178  
                         return getRuleContexts(ThContext.class);
 2179  
                 }
 2180  
                 public ThContext th(int i) {
 2181  
                         return getRuleContext(ThContext.class,i);
 2182  
                 }
 2183  
                 public List<BodyContext> body() {
 2184  
                         return getRuleContexts(BodyContext.class);
 2185  
                 }
 2186  
                 public BodyContext body(int i) {
 2187  
                         return getRuleContext(BodyContext.class,i);
 2188  
                 }
 2189  
                 public List<ColgroupContext> colgroup() {
 2190  
                         return getRuleContexts(ColgroupContext.class);
 2191  
                 }
 2192  
                 public ColgroupContext colgroup(int i) {
 2193  
                         return getRuleContext(ColgroupContext.class,i);
 2194  
                 }
 2195  
                 public List<DdContext> dd() {
 2196  
                         return getRuleContexts(DdContext.class);
 2197  
                 }
 2198  
                 public DdContext dd(int i) {
 2199  
                         return getRuleContext(DdContext.class,i);
 2200  
                 }
 2201  
                 public List<DtContext> dt() {
 2202  
                         return getRuleContexts(DtContext.class);
 2203  
                 }
 2204  
                 public DtContext dt(int i) {
 2205  
                         return getRuleContext(DtContext.class,i);
 2206  
                 }
 2207  
                 public List<HeadContext> head() {
 2208  
                         return getRuleContexts(HeadContext.class);
 2209  
                 }
 2210  
                 public HeadContext head(int i) {
 2211  
                         return getRuleContext(HeadContext.class,i);
 2212  
                 }
 2213  
                 public List<HtmlContext> html() {
 2214  
                         return getRuleContexts(HtmlContext.class);
 2215  
                 }
 2216  
                 public HtmlContext html(int i) {
 2217  
                         return getRuleContext(HtmlContext.class,i);
 2218  
                 }
 2219  
                 public List<OptionContext> option() {
 2220  
                         return getRuleContexts(OptionContext.class);
 2221  
                 }
 2222  
                 public OptionContext option(int i) {
 2223  
                         return getRuleContext(OptionContext.class,i);
 2224  
                 }
 2225  
                 public List<TbodyContext> tbody() {
 2226  
                         return getRuleContexts(TbodyContext.class);
 2227  
                 }
 2228  
                 public TbodyContext tbody(int i) {
 2229  
                         return getRuleContext(TbodyContext.class,i);
 2230  
                 }
 2231  
                 public List<TheadContext> thead() {
 2232  
                         return getRuleContexts(TheadContext.class);
 2233  
                 }
 2234  
                 public TheadContext thead(int i) {
 2235  
                         return getRuleContext(TheadContext.class,i);
 2236  
                 }
 2237  
                 public List<TfootContext> tfoot() {
 2238  
                         return getRuleContexts(TfootContext.class);
 2239  
                 }
 2240  
                 public TfootContext tfoot(int i) {
 2241  
                         return getRuleContext(TfootContext.class,i);
 2242  
                 }
 2243  
                 public List<PTagStartContext> pTagStart() {
 2244  
                         return getRuleContexts(PTagStartContext.class);
 2245  
                 }
 2246  
                 public PTagStartContext pTagStart(int i) {
 2247  
                         return getRuleContext(PTagStartContext.class,i);
 2248  
                 }
 2249  
                 public List<TrTagStartContext> trTagStart() {
 2250  
                         return getRuleContexts(TrTagStartContext.class);
 2251  
                 }
 2252  
                 public TrTagStartContext trTagStart(int i) {
 2253  
                         return getRuleContext(TrTagStartContext.class,i);
 2254  
                 }
 2255  
                 public List<TdTagStartContext> tdTagStart() {
 2256  
                         return getRuleContexts(TdTagStartContext.class);
 2257  
                 }
 2258  
                 public TdTagStartContext tdTagStart(int i) {
 2259  
                         return getRuleContext(TdTagStartContext.class,i);
 2260  
                 }
 2261  
                 public List<ThTagStartContext> thTagStart() {
 2262  
                         return getRuleContexts(ThTagStartContext.class);
 2263  
                 }
 2264  
                 public ThTagStartContext thTagStart(int i) {
 2265  
                         return getRuleContext(ThTagStartContext.class,i);
 2266  
                 }
 2267  
                 public List<BodyTagStartContext> bodyTagStart() {
 2268  
                         return getRuleContexts(BodyTagStartContext.class);
 2269  
                 }
 2270  
                 public BodyTagStartContext bodyTagStart(int i) {
 2271  
                         return getRuleContext(BodyTagStartContext.class,i);
 2272  
                 }
 2273  
                 public List<ColgroupTagStartContext> colgroupTagStart() {
 2274  
                         return getRuleContexts(ColgroupTagStartContext.class);
 2275  
                 }
 2276  
                 public ColgroupTagStartContext colgroupTagStart(int i) {
 2277  
                         return getRuleContext(ColgroupTagStartContext.class,i);
 2278  
                 }
 2279  
                 public List<DdTagStartContext> ddTagStart() {
 2280  
                         return getRuleContexts(DdTagStartContext.class);
 2281  
                 }
 2282  
                 public DdTagStartContext ddTagStart(int i) {
 2283  
                         return getRuleContext(DdTagStartContext.class,i);
 2284  
                 }
 2285  
                 public List<DtTagStartContext> dtTagStart() {
 2286  
                         return getRuleContexts(DtTagStartContext.class);
 2287  
                 }
 2288  
                 public DtTagStartContext dtTagStart(int i) {
 2289  
                         return getRuleContext(DtTagStartContext.class,i);
 2290  
                 }
 2291  
                 public List<HeadTagStartContext> headTagStart() {
 2292  
                         return getRuleContexts(HeadTagStartContext.class);
 2293  
                 }
 2294  
                 public HeadTagStartContext headTagStart(int i) {
 2295  
                         return getRuleContext(HeadTagStartContext.class,i);
 2296  
                 }
 2297  
                 public List<HtmlTagStartContext> htmlTagStart() {
 2298  
                         return getRuleContexts(HtmlTagStartContext.class);
 2299  
                 }
 2300  
                 public HtmlTagStartContext htmlTagStart(int i) {
 2301  
                         return getRuleContext(HtmlTagStartContext.class,i);
 2302  
                 }
 2303  
                 public List<OptionTagStartContext> optionTagStart() {
 2304  
                         return getRuleContexts(OptionTagStartContext.class);
 2305  
                 }
 2306  
                 public OptionTagStartContext optionTagStart(int i) {
 2307  
                         return getRuleContext(OptionTagStartContext.class,i);
 2308  
                 }
 2309  
                 public List<TbodyTagStartContext> tbodyTagStart() {
 2310  
                         return getRuleContexts(TbodyTagStartContext.class);
 2311  
                 }
 2312  
                 public TbodyTagStartContext tbodyTagStart(int i) {
 2313  
                         return getRuleContext(TbodyTagStartContext.class,i);
 2314  
                 }
 2315  
                 public List<TheadTagStartContext> theadTagStart() {
 2316  
                         return getRuleContexts(TheadTagStartContext.class);
 2317  
                 }
 2318  
                 public TheadTagStartContext theadTagStart(int i) {
 2319  
                         return getRuleContext(TheadTagStartContext.class,i);
 2320  
                 }
 2321  
                 public List<TfootTagStartContext> tfootTagStart() {
 2322  
                         return getRuleContexts(TfootTagStartContext.class);
 2323  
                 }
 2324  
                 public TfootTagStartContext tfootTagStart(int i) {
 2325  
                         return getRuleContext(TfootTagStartContext.class,i);
 2326  
                 }
 2327  
                 public List<HtmlCommentContext> htmlComment() {
 2328  
                         return getRuleContexts(HtmlCommentContext.class);
 2329  
                 }
 2330  
                 public HtmlCommentContext htmlComment(int i) {
 2331  
                         return getRuleContext(HtmlCommentContext.class,i);
 2332  
                 }
 2333  
                 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
 2334  
                 public TerminalNode CDATA(int i) {
 2335  
                         return getToken(JavadocParser.CDATA, i);
 2336  
                 }
 2337  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 2338  
                 public TerminalNode NEWLINE(int i) {
 2339  
                         return getToken(JavadocParser.NEWLINE, i);
 2340  
                 }
 2341  
                 public List<TextContext> text() {
 2342  
                         return getRuleContexts(TextContext.class);
 2343  
                 }
 2344  
                 public TextContext text(int i) {
 2345  
                         return getRuleContext(TextContext.class,i);
 2346  
                 }
 2347  
                 public List<JavadocInlineTagContext> javadocInlineTag() {
 2348  
                         return getRuleContexts(JavadocInlineTagContext.class);
 2349  
                 }
 2350  
                 public JavadocInlineTagContext javadocInlineTag(int i) {
 2351  
                         return getRuleContext(JavadocInlineTagContext.class,i);
 2352  
                 }
 2353  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 2354  
                 public TerminalNode LEADING_ASTERISK(int i) {
 2355  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 2356  
                 }
 2357  
                 public LiContext(ParserRuleContext parent, int invokingState) {
 2358  
                         super(parent, invokingState);
 2359  
                 }
 2360  
                 @Override public int getRuleIndex() { return RULE_li; }
 2361  
         }
 2362  
 
 2363  
         public final LiContext li() throws RecognitionException {
 2364  47
                 LiContext _localctx = new LiContext(_ctx, getState());
 2365  47
                 enterRule(_localctx, 22, RULE_li);
 2366  
                 try {
 2367  
                         int _alt;
 2368  47
                         enterOuterAlt(_localctx, 1);
 2369  
                         {
 2370  47
                         setState(392);
 2371  47
                         liTagStart(false);
 2372  47
                         setState(432);
 2373  47
                         _errHandler.sync(this);
 2374  47
                         _alt = getInterpreter().adaptivePredict(_input,23,_ctx);
 2375  173
                         while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 2376  126
                                 if ( _alt==1 ) {
 2377  
                                         {
 2378  126
                                         setState(430);
 2379  126
                                         _errHandler.sync(this);
 2380  126
                                         switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
 2381  
                                         case 1:
 2382  
                                                 {
 2383  0
                                                 setState(393);
 2384  0
                                                 htmlTag();
 2385  
                                                 }
 2386  0
                                                 break;
 2387  
                                         case 2:
 2388  
                                                 {
 2389  20
                                                 setState(394);
 2390  20
                                                 singletonElement();
 2391  
                                                 }
 2392  20
                                                 break;
 2393  
                                         case 3:
 2394  
                                                 {
 2395  4
                                                 setState(395);
 2396  4
                                                 paragraph();
 2397  
                                                 }
 2398  4
                                                 break;
 2399  
                                         case 4:
 2400  
                                                 {
 2401  0
                                                 setState(396);
 2402  0
                                                 tr();
 2403  
                                                 }
 2404  0
                                                 break;
 2405  
                                         case 5:
 2406  
                                                 {
 2407  0
                                                 setState(397);
 2408  0
                                                 td();
 2409  
                                                 }
 2410  0
                                                 break;
 2411  
                                         case 6:
 2412  
                                                 {
 2413  0
                                                 setState(398);
 2414  0
                                                 th();
 2415  
                                                 }
 2416  0
                                                 break;
 2417  
                                         case 7:
 2418  
                                                 {
 2419  0
                                                 setState(399);
 2420  0
                                                 body();
 2421  
                                                 }
 2422  0
                                                 break;
 2423  
                                         case 8:
 2424  
                                                 {
 2425  0
                                                 setState(400);
 2426  0
                                                 colgroup();
 2427  
                                                 }
 2428  0
                                                 break;
 2429  
                                         case 9:
 2430  
                                                 {
 2431  0
                                                 setState(401);
 2432  0
                                                 dd();
 2433  
                                                 }
 2434  0
                                                 break;
 2435  
                                         case 10:
 2436  
                                                 {
 2437  0
                                                 setState(402);
 2438  0
                                                 dt();
 2439  
                                                 }
 2440  0
                                                 break;
 2441  
                                         case 11:
 2442  
                                                 {
 2443  0
                                                 setState(403);
 2444  0
                                                 head();
 2445  
                                                 }
 2446  0
                                                 break;
 2447  
                                         case 12:
 2448  
                                                 {
 2449  0
                                                 setState(404);
 2450  0
                                                 html();
 2451  
                                                 }
 2452  0
                                                 break;
 2453  
                                         case 13:
 2454  
                                                 {
 2455  0
                                                 setState(405);
 2456  0
                                                 option();
 2457  
                                                 }
 2458  0
                                                 break;
 2459  
                                         case 14:
 2460  
                                                 {
 2461  0
                                                 setState(406);
 2462  0
                                                 tbody();
 2463  
                                                 }
 2464  0
                                                 break;
 2465  
                                         case 15:
 2466  
                                                 {
 2467  0
                                                 setState(407);
 2468  0
                                                 thead();
 2469  
                                                 }
 2470  0
                                                 break;
 2471  
                                         case 16:
 2472  
                                                 {
 2473  0
                                                 setState(408);
 2474  0
                                                 tfoot();
 2475  
                                                 }
 2476  0
                                                 break;
 2477  
                                         case 17:
 2478  
                                                 {
 2479  8
                                                 setState(409);
 2480  8
                                                 pTagStart(true);
 2481  
                                                 }
 2482  8
                                                 break;
 2483  
                                         case 18:
 2484  
                                                 {
 2485  0
                                                 setState(410);
 2486  0
                                                 trTagStart(true);
 2487  
                                                 }
 2488  0
                                                 break;
 2489  
                                         case 19:
 2490  
                                                 {
 2491  0
                                                 setState(411);
 2492  0
                                                 tdTagStart(true);
 2493  
                                                 }
 2494  0
                                                 break;
 2495  
                                         case 20:
 2496  
                                                 {
 2497  0
                                                 setState(412);
 2498  0
                                                 thTagStart(true);
 2499  
                                                 }
 2500  0
                                                 break;
 2501  
                                         case 21:
 2502  
                                                 {
 2503  0
                                                 setState(413);
 2504  0
                                                 bodyTagStart(true);
 2505  
                                                 }
 2506  0
                                                 break;
 2507  
                                         case 22:
 2508  
                                                 {
 2509  0
                                                 setState(414);
 2510  0
                                                 colgroupTagStart(true);
 2511  
                                                 }
 2512  0
                                                 break;
 2513  
                                         case 23:
 2514  
                                                 {
 2515  0
                                                 setState(415);
 2516  0
                                                 ddTagStart(true);
 2517  
                                                 }
 2518  0
                                                 break;
 2519  
                                         case 24:
 2520  
                                                 {
 2521  0
                                                 setState(416);
 2522  0
                                                 dtTagStart(true);
 2523  
                                                 }
 2524  0
                                                 break;
 2525  
                                         case 25:
 2526  
                                                 {
 2527  0
                                                 setState(417);
 2528  0
                                                 headTagStart(true);
 2529  
                                                 }
 2530  0
                                                 break;
 2531  
                                         case 26:
 2532  
                                                 {
 2533  0
                                                 setState(418);
 2534  0
                                                 htmlTagStart(true);
 2535  
                                                 }
 2536  0
                                                 break;
 2537  
                                         case 27:
 2538  
                                                 {
 2539  0
                                                 setState(419);
 2540  0
                                                 optionTagStart(true);
 2541  
                                                 }
 2542  0
                                                 break;
 2543  
                                         case 28:
 2544  
                                                 {
 2545  0
                                                 setState(420);
 2546  0
                                                 tbodyTagStart(true);
 2547  
                                                 }
 2548  0
                                                 break;
 2549  
                                         case 29:
 2550  
                                                 {
 2551  0
                                                 setState(421);
 2552  0
                                                 theadTagStart(true);
 2553  
                                                 }
 2554  0
                                                 break;
 2555  
                                         case 30:
 2556  
                                                 {
 2557  0
                                                 setState(422);
 2558  0
                                                 tfootTagStart(true);
 2559  
                                                 }
 2560  0
                                                 break;
 2561  
                                         case 31:
 2562  
                                                 {
 2563  
                                                 {
 2564  5
                                                 setState(423);
 2565  5
                                                 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
 2566  5
                                                 setState(424);
 2567  5
                                                 match(LEADING_ASTERISK);
 2568  
                                                 }
 2569  
                                                 }
 2570  5
                                                 break;
 2571  
                                         case 32:
 2572  
                                                 {
 2573  0
                                                 setState(425);
 2574  0
                                                 htmlComment();
 2575  
                                                 }
 2576  0
                                                 break;
 2577  
                                         case 33:
 2578  
                                                 {
 2579  0
                                                 setState(426);
 2580  0
                                                 match(CDATA);
 2581  
                                                 }
 2582  0
                                                 break;
 2583  
                                         case 34:
 2584  
                                                 {
 2585  5
                                                 setState(427);
 2586  5
                                                 match(NEWLINE);
 2587  
                                                 }
 2588  5
                                                 break;
 2589  
                                         case 35:
 2590  
                                                 {
 2591  84
                                                 setState(428);
 2592  84
                                                 text();
 2593  
                                                 }
 2594  84
                                                 break;
 2595  
                                         case 36:
 2596  
                                                 {
 2597  0
                                                 setState(429);
 2598  0
                                                 javadocInlineTag();
 2599  
                                                 }
 2600  
                                                 break;
 2601  
                                         }
 2602  
                                         } 
 2603  
                                 }
 2604  126
                                 setState(434);
 2605  126
                                 _errHandler.sync(this);
 2606  126
                                 _alt = getInterpreter().adaptivePredict(_input,23,_ctx);
 2607  
                         }
 2608  47
                         setState(435);
 2609  47
                         liTagEnd();
 2610  
                         }
 2611  
                 }
 2612  0
                 catch (RecognitionException re) {
 2613  0
                         _localctx.exception = re;
 2614  0
                         _errHandler.reportError(this, re);
 2615  0
                         _errHandler.recover(this, re);
 2616  
                 }
 2617  
                 finally {
 2618  47
                         exitRule();
 2619  47
                 }
 2620  47
                 return _localctx;
 2621  
         }
 2622  
 
 2623  
         public static class TrTagStartContext extends ParserRuleContext {
 2624  
                 public boolean isNonTight;
 2625  
                 public TerminalNode START() { return getToken(JavadocParser.START, 0); }
 2626  
                 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
 2627  
                 public TerminalNode END() { return getToken(JavadocParser.END, 0); }
 2628  
                 public List<AttributeContext> attribute() {
 2629  
                         return getRuleContexts(AttributeContext.class);
 2630  
                 }
 2631  
                 public AttributeContext attribute(int i) {
 2632  
                         return getRuleContext(AttributeContext.class,i);
 2633  
                 }
 2634  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 2635  
                 public TerminalNode NEWLINE(int i) {
 2636  
                         return getToken(JavadocParser.NEWLINE, i);
 2637  
                 }
 2638  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 2639  
                 public TerminalNode LEADING_ASTERISK(int i) {
 2640  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 2641  
                 }
 2642  
                 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
 2643  
                 public TerminalNode WS(int i) {
 2644  
                         return getToken(JavadocParser.WS, i);
 2645  
                 }
 2646  
                 public TrTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
 2647  
                 public TrTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
 2648  
                         super(parent, invokingState);
 2649  
                         this.isNonTight = isNonTight;
 2650  
                 }
 2651  
                 @Override public int getRuleIndex() { return RULE_trTagStart; }
 2652  
         }
 2653  
 
 2654  
         public final TrTagStartContext trTagStart(boolean isNonTight) throws RecognitionException {
 2655  37
                 TrTagStartContext _localctx = new TrTagStartContext(_ctx, getState(), isNonTight);
 2656  37
                 enterRule(_localctx, 24, RULE_trTagStart);
 2657  
                 int _la;
 2658  
                 try {
 2659  37
                         enterOuterAlt(_localctx, 1);
 2660  
                         {
 2661  37
                         setState(437);
 2662  37
                         match(START);
 2663  37
                         setState(438);
 2664  37
                         match(TR_HTML_TAG_NAME);
 2665  37
                         setState(445);
 2666  37
                         _errHandler.sync(this);
 2667  37
                         _la = _input.LA(1);
 2668  37
                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
 2669  
                                 {
 2670  0
                                 setState(443);
 2671  0
                                 _errHandler.sync(this);
 2672  0
                                 switch (_input.LA(1)) {
 2673  
                                 case HTML_TAG_NAME:
 2674  
                                         {
 2675  0
                                         setState(439);
 2676  0
                                         attribute();
 2677  
                                         }
 2678  0
                                         break;
 2679  
                                 case NEWLINE:
 2680  
                                         {
 2681  0
                                         setState(440);
 2682  0
                                         match(NEWLINE);
 2683  
                                         }
 2684  0
                                         break;
 2685  
                                 case LEADING_ASTERISK:
 2686  
                                         {
 2687  0
                                         setState(441);
 2688  0
                                         match(LEADING_ASTERISK);
 2689  
                                         }
 2690  0
                                         break;
 2691  
                                 case WS:
 2692  
                                         {
 2693  0
                                         setState(442);
 2694  0
                                         match(WS);
 2695  
                                         }
 2696  0
                                         break;
 2697  
                                 default:
 2698  0
                                         throw new NoViableAltException(this);
 2699  
                                 }
 2700  
                                 }
 2701  0
                                 setState(447);
 2702  0
                                 _errHandler.sync(this);
 2703  0
                                 _la = _input.LA(1);
 2704  
                         }
 2705  37
                         setState(448);
 2706  37
                         match(END);
 2707  
                         }
 2708  37
                         _ctx.stop = _input.LT(-1);
 2709  
 
 2710  37
                             if (isNonTight && nonTightTagStartContext == null) {
 2711  8
                                 nonTightTagStartContext = _localctx;
 2712  
                             }
 2713  
 
 2714  
                 }
 2715  0
                 catch (RecognitionException re) {
 2716  0
                         _localctx.exception = re;
 2717  0
                         _errHandler.reportError(this, re);
 2718  0
                         _errHandler.recover(this, re);
 2719  
                 }
 2720  
                 finally {
 2721  37
                         exitRule();
 2722  37
                 }
 2723  37
                 return _localctx;
 2724  
         }
 2725  
 
 2726  
         public static class TrTagEndContext extends ParserRuleContext {
 2727  
                 public TerminalNode START() { return getToken(JavadocParser.START, 0); }
 2728  
                 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
 2729  
                 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
 2730  
                 public TerminalNode END() { return getToken(JavadocParser.END, 0); }
 2731  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 2732  
                 public TerminalNode NEWLINE(int i) {
 2733  
                         return getToken(JavadocParser.NEWLINE, i);
 2734  
                 }
 2735  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 2736  
                 public TerminalNode LEADING_ASTERISK(int i) {
 2737  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 2738  
                 }
 2739  
                 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
 2740  
                 public TerminalNode WS(int i) {
 2741  
                         return getToken(JavadocParser.WS, i);
 2742  
                 }
 2743  
                 public TrTagEndContext(ParserRuleContext parent, int invokingState) {
 2744  
                         super(parent, invokingState);
 2745  
                 }
 2746  
                 @Override public int getRuleIndex() { return RULE_trTagEnd; }
 2747  
         }
 2748  
 
 2749  
         public final TrTagEndContext trTagEnd() throws RecognitionException {
 2750  29
                 TrTagEndContext _localctx = new TrTagEndContext(_ctx, getState());
 2751  29
                 enterRule(_localctx, 26, RULE_trTagEnd);
 2752  
                 int _la;
 2753  
                 try {
 2754  29
                         enterOuterAlt(_localctx, 1);
 2755  
                         {
 2756  29
                         setState(450);
 2757  29
                         match(START);
 2758  29
                         setState(451);
 2759  29
                         match(SLASH);
 2760  29
                         setState(452);
 2761  29
                         match(TR_HTML_TAG_NAME);
 2762  29
                         setState(456);
 2763  29
                         _errHandler.sync(this);
 2764  29
                         _la = _input.LA(1);
 2765  29
                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
 2766  
                                 {
 2767  
                                 {
 2768  0
                                 setState(453);
 2769  0
                                 _la = _input.LA(1);
 2770  0
                                 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
 2771  0
                                 _errHandler.recoverInline(this);
 2772  
                                 }
 2773  
                                 else {
 2774  0
                                         if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
 2775  0
                                         _errHandler.reportMatch(this);
 2776  0
                                         consume();
 2777  
                                 }
 2778  
                                 }
 2779  
                                 }
 2780  0
                                 setState(458);
 2781  0
                                 _errHandler.sync(this);
 2782  0
                                 _la = _input.LA(1);
 2783  
                         }
 2784  29
                         setState(459);
 2785  29
                         match(END);
 2786  
                         }
 2787  
                 }
 2788  0
                 catch (RecognitionException re) {
 2789  0
                         _localctx.exception = re;
 2790  0
                         _errHandler.reportError(this, re);
 2791  0
                         _errHandler.recover(this, re);
 2792  
                 }
 2793  
                 finally {
 2794  29
                         exitRule();
 2795  29
                 }
 2796  29
                 return _localctx;
 2797  
         }
 2798  
 
 2799  
         public static class TrContext extends ParserRuleContext {
 2800  
                 public TrTagStartContext trTagStart() {
 2801  
                         return getRuleContext(TrTagStartContext.class,0);
 2802  
                 }
 2803  
                 public TrTagEndContext trTagEnd() {
 2804  
                         return getRuleContext(TrTagEndContext.class,0);
 2805  
                 }
 2806  
                 public List<HtmlTagContext> htmlTag() {
 2807  
                         return getRuleContexts(HtmlTagContext.class);
 2808  
                 }
 2809  
                 public HtmlTagContext htmlTag(int i) {
 2810  
                         return getRuleContext(HtmlTagContext.class,i);
 2811  
                 }
 2812  
                 public List<SingletonElementContext> singletonElement() {
 2813  
                         return getRuleContexts(SingletonElementContext.class);
 2814  
                 }
 2815  
                 public SingletonElementContext singletonElement(int i) {
 2816  
                         return getRuleContext(SingletonElementContext.class,i);
 2817  
                 }
 2818  
                 public List<ParagraphContext> paragraph() {
 2819  
                         return getRuleContexts(ParagraphContext.class);
 2820  
                 }
 2821  
                 public ParagraphContext paragraph(int i) {
 2822  
                         return getRuleContext(ParagraphContext.class,i);
 2823  
                 }
 2824  
                 public List<LiContext> li() {
 2825  
                         return getRuleContexts(LiContext.class);
 2826  
                 }
 2827  
                 public LiContext li(int i) {
 2828  
                         return getRuleContext(LiContext.class,i);
 2829  
                 }
 2830  
                 public List<TdContext> td() {
 2831  
                         return getRuleContexts(TdContext.class);
 2832  
                 }
 2833  
                 public TdContext td(int i) {
 2834  
                         return getRuleContext(TdContext.class,i);
 2835  
                 }
 2836  
                 public List<ThContext> th() {
 2837  
                         return getRuleContexts(ThContext.class);
 2838  
                 }
 2839  
                 public ThContext th(int i) {
 2840  
                         return getRuleContext(ThContext.class,i);
 2841  
                 }
 2842  
                 public List<BodyContext> body() {
 2843  
                         return getRuleContexts(BodyContext.class);
 2844  
                 }
 2845  
                 public BodyContext body(int i) {
 2846  
                         return getRuleContext(BodyContext.class,i);
 2847  
                 }
 2848  
                 public List<ColgroupContext> colgroup() {
 2849  
                         return getRuleContexts(ColgroupContext.class);
 2850  
                 }
 2851  
                 public ColgroupContext colgroup(int i) {
 2852  
                         return getRuleContext(ColgroupContext.class,i);
 2853  
                 }
 2854  
                 public List<DdContext> dd() {
 2855  
                         return getRuleContexts(DdContext.class);
 2856  
                 }
 2857  
                 public DdContext dd(int i) {
 2858  
                         return getRuleContext(DdContext.class,i);
 2859  
                 }
 2860  
                 public List<DtContext> dt() {
 2861  
                         return getRuleContexts(DtContext.class);
 2862  
                 }
 2863  
                 public DtContext dt(int i) {
 2864  
                         return getRuleContext(DtContext.class,i);
 2865  
                 }
 2866  
                 public List<HeadContext> head() {
 2867  
                         return getRuleContexts(HeadContext.class);
 2868  
                 }
 2869  
                 public HeadContext head(int i) {
 2870  
                         return getRuleContext(HeadContext.class,i);
 2871  
                 }
 2872  
                 public List<HtmlContext> html() {
 2873  
                         return getRuleContexts(HtmlContext.class);
 2874  
                 }
 2875  
                 public HtmlContext html(int i) {
 2876  
                         return getRuleContext(HtmlContext.class,i);
 2877  
                 }
 2878  
                 public List<OptionContext> option() {
 2879  
                         return getRuleContexts(OptionContext.class);
 2880  
                 }
 2881  
                 public OptionContext option(int i) {
 2882  
                         return getRuleContext(OptionContext.class,i);
 2883  
                 }
 2884  
                 public List<TbodyContext> tbody() {
 2885  
                         return getRuleContexts(TbodyContext.class);
 2886  
                 }
 2887  
                 public TbodyContext tbody(int i) {
 2888  
                         return getRuleContext(TbodyContext.class,i);
 2889  
                 }
 2890  
                 public List<TheadContext> thead() {
 2891  
                         return getRuleContexts(TheadContext.class);
 2892  
                 }
 2893  
                 public TheadContext thead(int i) {
 2894  
                         return getRuleContext(TheadContext.class,i);
 2895  
                 }
 2896  
                 public List<TfootContext> tfoot() {
 2897  
                         return getRuleContexts(TfootContext.class);
 2898  
                 }
 2899  
                 public TfootContext tfoot(int i) {
 2900  
                         return getRuleContext(TfootContext.class,i);
 2901  
                 }
 2902  
                 public List<PTagStartContext> pTagStart() {
 2903  
                         return getRuleContexts(PTagStartContext.class);
 2904  
                 }
 2905  
                 public PTagStartContext pTagStart(int i) {
 2906  
                         return getRuleContext(PTagStartContext.class,i);
 2907  
                 }
 2908  
                 public List<LiTagStartContext> liTagStart() {
 2909  
                         return getRuleContexts(LiTagStartContext.class);
 2910  
                 }
 2911  
                 public LiTagStartContext liTagStart(int i) {
 2912  
                         return getRuleContext(LiTagStartContext.class,i);
 2913  
                 }
 2914  
                 public List<TdTagStartContext> tdTagStart() {
 2915  
                         return getRuleContexts(TdTagStartContext.class);
 2916  
                 }
 2917  
                 public TdTagStartContext tdTagStart(int i) {
 2918  
                         return getRuleContext(TdTagStartContext.class,i);
 2919  
                 }
 2920  
                 public List<ThTagStartContext> thTagStart() {
 2921  
                         return getRuleContexts(ThTagStartContext.class);
 2922  
                 }
 2923  
                 public ThTagStartContext thTagStart(int i) {
 2924  
                         return getRuleContext(ThTagStartContext.class,i);
 2925  
                 }
 2926  
                 public List<BodyTagStartContext> bodyTagStart() {
 2927  
                         return getRuleContexts(BodyTagStartContext.class);
 2928  
                 }
 2929  
                 public BodyTagStartContext bodyTagStart(int i) {
 2930  
                         return getRuleContext(BodyTagStartContext.class,i);
 2931  
                 }
 2932  
                 public List<ColgroupTagStartContext> colgroupTagStart() {
 2933  
                         return getRuleContexts(ColgroupTagStartContext.class);
 2934  
                 }
 2935  
                 public ColgroupTagStartContext colgroupTagStart(int i) {
 2936  
                         return getRuleContext(ColgroupTagStartContext.class,i);
 2937  
                 }
 2938  
                 public List<DdTagStartContext> ddTagStart() {
 2939  
                         return getRuleContexts(DdTagStartContext.class);
 2940  
                 }
 2941  
                 public DdTagStartContext ddTagStart(int i) {
 2942  
                         return getRuleContext(DdTagStartContext.class,i);
 2943  
                 }
 2944  
                 public List<DtTagStartContext> dtTagStart() {
 2945  
                         return getRuleContexts(DtTagStartContext.class);
 2946  
                 }
 2947  
                 public DtTagStartContext dtTagStart(int i) {
 2948  
                         return getRuleContext(DtTagStartContext.class,i);
 2949  
                 }
 2950  
                 public List<HeadTagStartContext> headTagStart() {
 2951  
                         return getRuleContexts(HeadTagStartContext.class);
 2952  
                 }
 2953  
                 public HeadTagStartContext headTagStart(int i) {
 2954  
                         return getRuleContext(HeadTagStartContext.class,i);
 2955  
                 }
 2956  
                 public List<HtmlTagStartContext> htmlTagStart() {
 2957  
                         return getRuleContexts(HtmlTagStartContext.class);
 2958  
                 }
 2959  
                 public HtmlTagStartContext htmlTagStart(int i) {
 2960  
                         return getRuleContext(HtmlTagStartContext.class,i);
 2961  
                 }
 2962  
                 public List<OptionTagStartContext> optionTagStart() {
 2963  
                         return getRuleContexts(OptionTagStartContext.class);
 2964  
                 }
 2965  
                 public OptionTagStartContext optionTagStart(int i) {
 2966  
                         return getRuleContext(OptionTagStartContext.class,i);
 2967  
                 }
 2968  
                 public List<TbodyTagStartContext> tbodyTagStart() {
 2969  
                         return getRuleContexts(TbodyTagStartContext.class);
 2970  
                 }
 2971  
                 public TbodyTagStartContext tbodyTagStart(int i) {
 2972  
                         return getRuleContext(TbodyTagStartContext.class,i);
 2973  
                 }
 2974  
                 public List<TheadTagStartContext> theadTagStart() {
 2975  
                         return getRuleContexts(TheadTagStartContext.class);
 2976  
                 }
 2977  
                 public TheadTagStartContext theadTagStart(int i) {
 2978  
                         return getRuleContext(TheadTagStartContext.class,i);
 2979  
                 }
 2980  
                 public List<TfootTagStartContext> tfootTagStart() {
 2981  
                         return getRuleContexts(TfootTagStartContext.class);
 2982  
                 }
 2983  
                 public TfootTagStartContext tfootTagStart(int i) {
 2984  
                         return getRuleContext(TfootTagStartContext.class,i);
 2985  
                 }
 2986  
                 public List<HtmlCommentContext> htmlComment() {
 2987  
                         return getRuleContexts(HtmlCommentContext.class);
 2988  
                 }
 2989  
                 public HtmlCommentContext htmlComment(int i) {
 2990  
                         return getRuleContext(HtmlCommentContext.class,i);
 2991  
                 }
 2992  
                 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
 2993  
                 public TerminalNode CDATA(int i) {
 2994  
                         return getToken(JavadocParser.CDATA, i);
 2995  
                 }
 2996  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 2997  
                 public TerminalNode NEWLINE(int i) {
 2998  
                         return getToken(JavadocParser.NEWLINE, i);
 2999  
                 }
 3000  
                 public List<TextContext> text() {
 3001  
                         return getRuleContexts(TextContext.class);
 3002  
                 }
 3003  
                 public TextContext text(int i) {
 3004  
                         return getRuleContext(TextContext.class,i);
 3005  
                 }
 3006  
                 public List<JavadocInlineTagContext> javadocInlineTag() {
 3007  
                         return getRuleContexts(JavadocInlineTagContext.class);
 3008  
                 }
 3009  
                 public JavadocInlineTagContext javadocInlineTag(int i) {
 3010  
                         return getRuleContext(JavadocInlineTagContext.class,i);
 3011  
                 }
 3012  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 3013  
                 public TerminalNode LEADING_ASTERISK(int i) {
 3014  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 3015  
                 }
 3016  
                 public TrContext(ParserRuleContext parent, int invokingState) {
 3017  
                         super(parent, invokingState);
 3018  
                 }
 3019  
                 @Override public int getRuleIndex() { return RULE_tr; }
 3020  
         }
 3021  
 
 3022  
         public final TrContext tr() throws RecognitionException {
 3023  24
                 TrContext _localctx = new TrContext(_ctx, getState());
 3024  24
                 enterRule(_localctx, 28, RULE_tr);
 3025  
                 try {
 3026  
                         int _alt;
 3027  24
                         enterOuterAlt(_localctx, 1);
 3028  
                         {
 3029  24
                         setState(461);
 3030  24
                         trTagStart(false);
 3031  24
                         setState(501);
 3032  24
                         _errHandler.sync(this);
 3033  24
                         _alt = getInterpreter().adaptivePredict(_input,28,_ctx);
 3034  82
                         while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 3035  58
                                 if ( _alt==1 ) {
 3036  
                                         {
 3037  58
                                         setState(499);
 3038  58
                                         _errHandler.sync(this);
 3039  58
                                         switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
 3040  
                                         case 1:
 3041  
                                                 {
 3042  0
                                                 setState(462);
 3043  0
                                                 htmlTag();
 3044  
                                                 }
 3045  0
                                                 break;
 3046  
                                         case 2:
 3047  
                                                 {
 3048  15
                                                 setState(463);
 3049  15
                                                 singletonElement();
 3050  
                                                 }
 3051  15
                                                 break;
 3052  
                                         case 3:
 3053  
                                                 {
 3054  0
                                                 setState(464);
 3055  0
                                                 paragraph();
 3056  
                                                 }
 3057  0
                                                 break;
 3058  
                                         case 4:
 3059  
                                                 {
 3060  3
                                                 setState(465);
 3061  3
                                                 li();
 3062  
                                                 }
 3063  3
                                                 break;
 3064  
                                         case 5:
 3065  
                                                 {
 3066  0
                                                 setState(466);
 3067  0
                                                 td();
 3068  
                                                 }
 3069  0
                                                 break;
 3070  
                                         case 6:
 3071  
                                                 {
 3072  0
                                                 setState(467);
 3073  0
                                                 th();
 3074  
                                                 }
 3075  0
                                                 break;
 3076  
                                         case 7:
 3077  
                                                 {
 3078  0
                                                 setState(468);
 3079  0
                                                 body();
 3080  
                                                 }
 3081  0
                                                 break;
 3082  
                                         case 8:
 3083  
                                                 {
 3084  0
                                                 setState(469);
 3085  0
                                                 colgroup();
 3086  
                                                 }
 3087  0
                                                 break;
 3088  
                                         case 9:
 3089  
                                                 {
 3090  0
                                                 setState(470);
 3091  0
                                                 dd();
 3092  
                                                 }
 3093  0
                                                 break;
 3094  
                                         case 10:
 3095  
                                                 {
 3096  0
                                                 setState(471);
 3097  0
                                                 dt();
 3098  
                                                 }
 3099  0
                                                 break;
 3100  
                                         case 11:
 3101  
                                                 {
 3102  0
                                                 setState(472);
 3103  0
                                                 head();
 3104  
                                                 }
 3105  0
                                                 break;
 3106  
                                         case 12:
 3107  
                                                 {
 3108  0
                                                 setState(473);
 3109  0
                                                 html();
 3110  
                                                 }
 3111  0
                                                 break;
 3112  
                                         case 13:
 3113  
                                                 {
 3114  0
                                                 setState(474);
 3115  0
                                                 option();
 3116  
                                                 }
 3117  0
                                                 break;
 3118  
                                         case 14:
 3119  
                                                 {
 3120  0
                                                 setState(475);
 3121  0
                                                 tbody();
 3122  
                                                 }
 3123  0
                                                 break;
 3124  
                                         case 15:
 3125  
                                                 {
 3126  0
                                                 setState(476);
 3127  0
                                                 thead();
 3128  
                                                 }
 3129  0
                                                 break;
 3130  
                                         case 16:
 3131  
                                                 {
 3132  0
                                                 setState(477);
 3133  0
                                                 tfoot();
 3134  
                                                 }
 3135  0
                                                 break;
 3136  
                                         case 17:
 3137  
                                                 {
 3138  0
                                                 setState(478);
 3139  0
                                                 pTagStart(true);
 3140  
                                                 }
 3141  0
                                                 break;
 3142  
                                         case 18:
 3143  
                                                 {
 3144  0
                                                 setState(479);
 3145  0
                                                 liTagStart(true);
 3146  
                                                 }
 3147  0
                                                 break;
 3148  
                                         case 19:
 3149  
                                                 {
 3150  0
                                                 setState(480);
 3151  0
                                                 tdTagStart(true);
 3152  
                                                 }
 3153  0
                                                 break;
 3154  
                                         case 20:
 3155  
                                                 {
 3156  0
                                                 setState(481);
 3157  0
                                                 thTagStart(true);
 3158  
                                                 }
 3159  0
                                                 break;
 3160  
                                         case 21:
 3161  
                                                 {
 3162  0
                                                 setState(482);
 3163  0
                                                 bodyTagStart(true);
 3164  
                                                 }
 3165  0
                                                 break;
 3166  
                                         case 22:
 3167  
                                                 {
 3168  0
                                                 setState(483);
 3169  0
                                                 colgroupTagStart(true);
 3170  
                                                 }
 3171  0
                                                 break;
 3172  
                                         case 23:
 3173  
                                                 {
 3174  0
                                                 setState(484);
 3175  0
                                                 ddTagStart(true);
 3176  
                                                 }
 3177  0
                                                 break;
 3178  
                                         case 24:
 3179  
                                                 {
 3180  0
                                                 setState(485);
 3181  0
                                                 dtTagStart(true);
 3182  
                                                 }
 3183  0
                                                 break;
 3184  
                                         case 25:
 3185  
                                                 {
 3186  0
                                                 setState(486);
 3187  0
                                                 headTagStart(true);
 3188  
                                                 }
 3189  0
                                                 break;
 3190  
                                         case 26:
 3191  
                                                 {
 3192  0
                                                 setState(487);
 3193  0
                                                 htmlTagStart(true);
 3194  
                                                 }
 3195  0
                                                 break;
 3196  
                                         case 27:
 3197  
                                                 {
 3198  0
                                                 setState(488);
 3199  0
                                                 optionTagStart(true);
 3200  
                                                 }
 3201  0
                                                 break;
 3202  
                                         case 28:
 3203  
                                                 {
 3204  0
                                                 setState(489);
 3205  0
                                                 tbodyTagStart(true);
 3206  
                                                 }
 3207  0
                                                 break;
 3208  
                                         case 29:
 3209  
                                                 {
 3210  0
                                                 setState(490);
 3211  0
                                                 theadTagStart(true);
 3212  
                                                 }
 3213  0
                                                 break;
 3214  
                                         case 30:
 3215  
                                                 {
 3216  0
                                                 setState(491);
 3217  0
                                                 tfootTagStart(true);
 3218  
                                                 }
 3219  0
                                                 break;
 3220  
                                         case 31:
 3221  
                                                 {
 3222  
                                                 {
 3223  0
                                                 setState(492);
 3224  0
                                                 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
 3225  0
                                                 setState(493);
 3226  0
                                                 match(LEADING_ASTERISK);
 3227  
                                                 }
 3228  
                                                 }
 3229  0
                                                 break;
 3230  
                                         case 32:
 3231  
                                                 {
 3232  0
                                                 setState(494);
 3233  0
                                                 htmlComment();
 3234  
                                                 }
 3235  0
                                                 break;
 3236  
                                         case 33:
 3237  
                                                 {
 3238  0
                                                 setState(495);
 3239  0
                                                 match(CDATA);
 3240  
                                                 }
 3241  0
                                                 break;
 3242  
                                         case 34:
 3243  
                                                 {
 3244  0
                                                 setState(496);
 3245  0
                                                 match(NEWLINE);
 3246  
                                                 }
 3247  0
                                                 break;
 3248  
                                         case 35:
 3249  
                                                 {
 3250  40
                                                 setState(497);
 3251  40
                                                 text();
 3252  
                                                 }
 3253  40
                                                 break;
 3254  
                                         case 36:
 3255  
                                                 {
 3256  0
                                                 setState(498);
 3257  0
                                                 javadocInlineTag();
 3258  
                                                 }
 3259  
                                                 break;
 3260  
                                         }
 3261  
                                         } 
 3262  
                                 }
 3263  58
                                 setState(503);
 3264  58
                                 _errHandler.sync(this);
 3265  58
                                 _alt = getInterpreter().adaptivePredict(_input,28,_ctx);
 3266  
                         }
 3267  24
                         setState(504);
 3268  24
                         trTagEnd();
 3269  
                         }
 3270  
                 }
 3271  0
                 catch (RecognitionException re) {
 3272  0
                         _localctx.exception = re;
 3273  0
                         _errHandler.reportError(this, re);
 3274  0
                         _errHandler.recover(this, re);
 3275  
                 }
 3276  
                 finally {
 3277  24
                         exitRule();
 3278  24
                 }
 3279  24
                 return _localctx;
 3280  
         }
 3281  
 
 3282  
         public static class TdTagStartContext extends ParserRuleContext {
 3283  
                 public boolean isNonTight;
 3284  
                 public TerminalNode START() { return getToken(JavadocParser.START, 0); }
 3285  
                 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
 3286  
                 public TerminalNode END() { return getToken(JavadocParser.END, 0); }
 3287  
                 public List<AttributeContext> attribute() {
 3288  
                         return getRuleContexts(AttributeContext.class);
 3289  
                 }
 3290  
                 public AttributeContext attribute(int i) {
 3291  
                         return getRuleContext(AttributeContext.class,i);
 3292  
                 }
 3293  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 3294  
                 public TerminalNode NEWLINE(int i) {
 3295  
                         return getToken(JavadocParser.NEWLINE, i);
 3296  
                 }
 3297  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 3298  
                 public TerminalNode LEADING_ASTERISK(int i) {
 3299  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 3300  
                 }
 3301  
                 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
 3302  
                 public TerminalNode WS(int i) {
 3303  
                         return getToken(JavadocParser.WS, i);
 3304  
                 }
 3305  
                 public TdTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
 3306  
                 public TdTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
 3307  
                         super(parent, invokingState);
 3308  
                         this.isNonTight = isNonTight;
 3309  
                 }
 3310  
                 @Override public int getRuleIndex() { return RULE_tdTagStart; }
 3311  
         }
 3312  
 
 3313  
         public final TdTagStartContext tdTagStart(boolean isNonTight) throws RecognitionException {
 3314  24
                 TdTagStartContext _localctx = new TdTagStartContext(_ctx, getState(), isNonTight);
 3315  24
                 enterRule(_localctx, 30, RULE_tdTagStart);
 3316  
                 int _la;
 3317  
                 try {
 3318  24
                         enterOuterAlt(_localctx, 1);
 3319  
                         {
 3320  24
                         setState(506);
 3321  24
                         match(START);
 3322  24
                         setState(507);
 3323  24
                         match(TD_HTML_TAG_NAME);
 3324  24
                         setState(514);
 3325  24
                         _errHandler.sync(this);
 3326  24
                         _la = _input.LA(1);
 3327  24
                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
 3328  
                                 {
 3329  0
                                 setState(512);
 3330  0
                                 _errHandler.sync(this);
 3331  0
                                 switch (_input.LA(1)) {
 3332  
                                 case HTML_TAG_NAME:
 3333  
                                         {
 3334  0
                                         setState(508);
 3335  0
                                         attribute();
 3336  
                                         }
 3337  0
                                         break;
 3338  
                                 case NEWLINE:
 3339  
                                         {
 3340  0
                                         setState(509);
 3341  0
                                         match(NEWLINE);
 3342  
                                         }
 3343  0
                                         break;
 3344  
                                 case LEADING_ASTERISK:
 3345  
                                         {
 3346  0
                                         setState(510);
 3347  0
                                         match(LEADING_ASTERISK);
 3348  
                                         }
 3349  0
                                         break;
 3350  
                                 case WS:
 3351  
                                         {
 3352  0
                                         setState(511);
 3353  0
                                         match(WS);
 3354  
                                         }
 3355  0
                                         break;
 3356  
                                 default:
 3357  0
                                         throw new NoViableAltException(this);
 3358  
                                 }
 3359  
                                 }
 3360  0
                                 setState(516);
 3361  0
                                 _errHandler.sync(this);
 3362  0
                                 _la = _input.LA(1);
 3363  
                         }
 3364  24
                         setState(517);
 3365  24
                         match(END);
 3366  
                         }
 3367  24
                         _ctx.stop = _input.LT(-1);
 3368  
 
 3369  24
                             if (isNonTight && nonTightTagStartContext == null) {
 3370  0
                                 nonTightTagStartContext = _localctx;
 3371  
                             }
 3372  
 
 3373  
                 }
 3374  0
                 catch (RecognitionException re) {
 3375  0
                         _localctx.exception = re;
 3376  0
                         _errHandler.reportError(this, re);
 3377  0
                         _errHandler.recover(this, re);
 3378  
                 }
 3379  
                 finally {
 3380  24
                         exitRule();
 3381  24
                 }
 3382  24
                 return _localctx;
 3383  
         }
 3384  
 
 3385  
         public static class TdTagEndContext extends ParserRuleContext {
 3386  
                 public TerminalNode START() { return getToken(JavadocParser.START, 0); }
 3387  
                 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
 3388  
                 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
 3389  
                 public TerminalNode END() { return getToken(JavadocParser.END, 0); }
 3390  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 3391  
                 public TerminalNode NEWLINE(int i) {
 3392  
                         return getToken(JavadocParser.NEWLINE, i);
 3393  
                 }
 3394  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 3395  
                 public TerminalNode LEADING_ASTERISK(int i) {
 3396  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 3397  
                 }
 3398  
                 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
 3399  
                 public TerminalNode WS(int i) {
 3400  
                         return getToken(JavadocParser.WS, i);
 3401  
                 }
 3402  
                 public TdTagEndContext(ParserRuleContext parent, int invokingState) {
 3403  
                         super(parent, invokingState);
 3404  
                 }
 3405  
                 @Override public int getRuleIndex() { return RULE_tdTagEnd; }
 3406  
         }
 3407  
 
 3408  
         public final TdTagEndContext tdTagEnd() throws RecognitionException {
 3409  20
                 TdTagEndContext _localctx = new TdTagEndContext(_ctx, getState());
 3410  20
                 enterRule(_localctx, 32, RULE_tdTagEnd);
 3411  
                 int _la;
 3412  
                 try {
 3413  20
                         enterOuterAlt(_localctx, 1);
 3414  
                         {
 3415  20
                         setState(519);
 3416  20
                         match(START);
 3417  20
                         setState(520);
 3418  20
                         match(SLASH);
 3419  20
                         setState(521);
 3420  20
                         match(TD_HTML_TAG_NAME);
 3421  20
                         setState(525);
 3422  20
                         _errHandler.sync(this);
 3423  20
                         _la = _input.LA(1);
 3424  20
                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
 3425  
                                 {
 3426  
                                 {
 3427  0
                                 setState(522);
 3428  0
                                 _la = _input.LA(1);
 3429  0
                                 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
 3430  0
                                 _errHandler.recoverInline(this);
 3431  
                                 }
 3432  
                                 else {
 3433  0
                                         if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
 3434  0
                                         _errHandler.reportMatch(this);
 3435  0
                                         consume();
 3436  
                                 }
 3437  
                                 }
 3438  
                                 }
 3439  0
                                 setState(527);
 3440  0
                                 _errHandler.sync(this);
 3441  0
                                 _la = _input.LA(1);
 3442  
                         }
 3443  20
                         setState(528);
 3444  20
                         match(END);
 3445  
                         }
 3446  
                 }
 3447  0
                 catch (RecognitionException re) {
 3448  0
                         _localctx.exception = re;
 3449  0
                         _errHandler.reportError(this, re);
 3450  0
                         _errHandler.recover(this, re);
 3451  
                 }
 3452  
                 finally {
 3453  20
                         exitRule();
 3454  20
                 }
 3455  20
                 return _localctx;
 3456  
         }
 3457  
 
 3458  
         public static class TdContext extends ParserRuleContext {
 3459  
                 public List<TdTagStartContext> tdTagStart() {
 3460  
                         return getRuleContexts(TdTagStartContext.class);
 3461  
                 }
 3462  
                 public TdTagStartContext tdTagStart(int i) {
 3463  
                         return getRuleContext(TdTagStartContext.class,i);
 3464  
                 }
 3465  
                 public TdTagEndContext tdTagEnd() {
 3466  
                         return getRuleContext(TdTagEndContext.class,0);
 3467  
                 }
 3468  
                 public List<HtmlTagContext> htmlTag() {
 3469  
                         return getRuleContexts(HtmlTagContext.class);
 3470  
                 }
 3471  
                 public HtmlTagContext htmlTag(int i) {
 3472  
                         return getRuleContext(HtmlTagContext.class,i);
 3473  
                 }
 3474  
                 public List<SingletonElementContext> singletonElement() {
 3475  
                         return getRuleContexts(SingletonElementContext.class);
 3476  
                 }
 3477  
                 public SingletonElementContext singletonElement(int i) {
 3478  
                         return getRuleContext(SingletonElementContext.class,i);
 3479  
                 }
 3480  
                 public List<ParagraphContext> paragraph() {
 3481  
                         return getRuleContexts(ParagraphContext.class);
 3482  
                 }
 3483  
                 public ParagraphContext paragraph(int i) {
 3484  
                         return getRuleContext(ParagraphContext.class,i);
 3485  
                 }
 3486  
                 public List<LiContext> li() {
 3487  
                         return getRuleContexts(LiContext.class);
 3488  
                 }
 3489  
                 public LiContext li(int i) {
 3490  
                         return getRuleContext(LiContext.class,i);
 3491  
                 }
 3492  
                 public List<TrContext> tr() {
 3493  
                         return getRuleContexts(TrContext.class);
 3494  
                 }
 3495  
                 public TrContext tr(int i) {
 3496  
                         return getRuleContext(TrContext.class,i);
 3497  
                 }
 3498  
                 public List<ThContext> th() {
 3499  
                         return getRuleContexts(ThContext.class);
 3500  
                 }
 3501  
                 public ThContext th(int i) {
 3502  
                         return getRuleContext(ThContext.class,i);
 3503  
                 }
 3504  
                 public List<BodyContext> body() {
 3505  
                         return getRuleContexts(BodyContext.class);
 3506  
                 }
 3507  
                 public BodyContext body(int i) {
 3508  
                         return getRuleContext(BodyContext.class,i);
 3509  
                 }
 3510  
                 public List<ColgroupContext> colgroup() {
 3511  
                         return getRuleContexts(ColgroupContext.class);
 3512  
                 }
 3513  
                 public ColgroupContext colgroup(int i) {
 3514  
                         return getRuleContext(ColgroupContext.class,i);
 3515  
                 }
 3516  
                 public List<DdContext> dd() {
 3517  
                         return getRuleContexts(DdContext.class);
 3518  
                 }
 3519  
                 public DdContext dd(int i) {
 3520  
                         return getRuleContext(DdContext.class,i);
 3521  
                 }
 3522  
                 public List<DtContext> dt() {
 3523  
                         return getRuleContexts(DtContext.class);
 3524  
                 }
 3525  
                 public DtContext dt(int i) {
 3526  
                         return getRuleContext(DtContext.class,i);
 3527  
                 }
 3528  
                 public List<HeadContext> head() {
 3529  
                         return getRuleContexts(HeadContext.class);
 3530  
                 }
 3531  
                 public HeadContext head(int i) {
 3532  
                         return getRuleContext(HeadContext.class,i);
 3533  
                 }
 3534  
                 public List<HtmlContext> html() {
 3535  
                         return getRuleContexts(HtmlContext.class);
 3536  
                 }
 3537  
                 public HtmlContext html(int i) {
 3538  
                         return getRuleContext(HtmlContext.class,i);
 3539  
                 }
 3540  
                 public List<OptionContext> option() {
 3541  
                         return getRuleContexts(OptionContext.class);
 3542  
                 }
 3543  
                 public OptionContext option(int i) {
 3544  
                         return getRuleContext(OptionContext.class,i);
 3545  
                 }
 3546  
                 public List<TbodyContext> tbody() {
 3547  
                         return getRuleContexts(TbodyContext.class);
 3548  
                 }
 3549  
                 public TbodyContext tbody(int i) {
 3550  
                         return getRuleContext(TbodyContext.class,i);
 3551  
                 }
 3552  
                 public List<TheadContext> thead() {
 3553  
                         return getRuleContexts(TheadContext.class);
 3554  
                 }
 3555  
                 public TheadContext thead(int i) {
 3556  
                         return getRuleContext(TheadContext.class,i);
 3557  
                 }
 3558  
                 public List<TfootContext> tfoot() {
 3559  
                         return getRuleContexts(TfootContext.class);
 3560  
                 }
 3561  
                 public TfootContext tfoot(int i) {
 3562  
                         return getRuleContext(TfootContext.class,i);
 3563  
                 }
 3564  
                 public List<PTagStartContext> pTagStart() {
 3565  
                         return getRuleContexts(PTagStartContext.class);
 3566  
                 }
 3567  
                 public PTagStartContext pTagStart(int i) {
 3568  
                         return getRuleContext(PTagStartContext.class,i);
 3569  
                 }
 3570  
                 public List<LiTagStartContext> liTagStart() {
 3571  
                         return getRuleContexts(LiTagStartContext.class);
 3572  
                 }
 3573  
                 public LiTagStartContext liTagStart(int i) {
 3574  
                         return getRuleContext(LiTagStartContext.class,i);
 3575  
                 }
 3576  
                 public List<ThTagStartContext> thTagStart() {
 3577  
                         return getRuleContexts(ThTagStartContext.class);
 3578  
                 }
 3579  
                 public ThTagStartContext thTagStart(int i) {
 3580  
                         return getRuleContext(ThTagStartContext.class,i);
 3581  
                 }
 3582  
                 public List<BodyTagStartContext> bodyTagStart() {
 3583  
                         return getRuleContexts(BodyTagStartContext.class);
 3584  
                 }
 3585  
                 public BodyTagStartContext bodyTagStart(int i) {
 3586  
                         return getRuleContext(BodyTagStartContext.class,i);
 3587  
                 }
 3588  
                 public List<ColgroupTagStartContext> colgroupTagStart() {
 3589  
                         return getRuleContexts(ColgroupTagStartContext.class);
 3590  
                 }
 3591  
                 public ColgroupTagStartContext colgroupTagStart(int i) {
 3592  
                         return getRuleContext(ColgroupTagStartContext.class,i);
 3593  
                 }
 3594  
                 public List<DdTagStartContext> ddTagStart() {
 3595  
                         return getRuleContexts(DdTagStartContext.class);
 3596  
                 }
 3597  
                 public DdTagStartContext ddTagStart(int i) {
 3598  
                         return getRuleContext(DdTagStartContext.class,i);
 3599  
                 }
 3600  
                 public List<DtTagStartContext> dtTagStart() {
 3601  
                         return getRuleContexts(DtTagStartContext.class);
 3602  
                 }
 3603  
                 public DtTagStartContext dtTagStart(int i) {
 3604  
                         return getRuleContext(DtTagStartContext.class,i);
 3605  
                 }
 3606  
                 public List<HeadTagStartContext> headTagStart() {
 3607  
                         return getRuleContexts(HeadTagStartContext.class);
 3608  
                 }
 3609  
                 public HeadTagStartContext headTagStart(int i) {
 3610  
                         return getRuleContext(HeadTagStartContext.class,i);
 3611  
                 }
 3612  
                 public List<HtmlTagStartContext> htmlTagStart() {
 3613  
                         return getRuleContexts(HtmlTagStartContext.class);
 3614  
                 }
 3615  
                 public HtmlTagStartContext htmlTagStart(int i) {
 3616  
                         return getRuleContext(HtmlTagStartContext.class,i);
 3617  
                 }
 3618  
                 public List<OptionTagStartContext> optionTagStart() {
 3619  
                         return getRuleContexts(OptionTagStartContext.class);
 3620  
                 }
 3621  
                 public OptionTagStartContext optionTagStart(int i) {
 3622  
                         return getRuleContext(OptionTagStartContext.class,i);
 3623  
                 }
 3624  
                 public List<TbodyTagStartContext> tbodyTagStart() {
 3625  
                         return getRuleContexts(TbodyTagStartContext.class);
 3626  
                 }
 3627  
                 public TbodyTagStartContext tbodyTagStart(int i) {
 3628  
                         return getRuleContext(TbodyTagStartContext.class,i);
 3629  
                 }
 3630  
                 public List<TheadTagStartContext> theadTagStart() {
 3631  
                         return getRuleContexts(TheadTagStartContext.class);
 3632  
                 }
 3633  
                 public TheadTagStartContext theadTagStart(int i) {
 3634  
                         return getRuleContext(TheadTagStartContext.class,i);
 3635  
                 }
 3636  
                 public List<TfootTagStartContext> tfootTagStart() {
 3637  
                         return getRuleContexts(TfootTagStartContext.class);
 3638  
                 }
 3639  
                 public TfootTagStartContext tfootTagStart(int i) {
 3640  
                         return getRuleContext(TfootTagStartContext.class,i);
 3641  
                 }
 3642  
                 public List<HtmlCommentContext> htmlComment() {
 3643  
                         return getRuleContexts(HtmlCommentContext.class);
 3644  
                 }
 3645  
                 public HtmlCommentContext htmlComment(int i) {
 3646  
                         return getRuleContext(HtmlCommentContext.class,i);
 3647  
                 }
 3648  
                 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
 3649  
                 public TerminalNode CDATA(int i) {
 3650  
                         return getToken(JavadocParser.CDATA, i);
 3651  
                 }
 3652  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 3653  
                 public TerminalNode NEWLINE(int i) {
 3654  
                         return getToken(JavadocParser.NEWLINE, i);
 3655  
                 }
 3656  
                 public List<TextContext> text() {
 3657  
                         return getRuleContexts(TextContext.class);
 3658  
                 }
 3659  
                 public TextContext text(int i) {
 3660  
                         return getRuleContext(TextContext.class,i);
 3661  
                 }
 3662  
                 public List<JavadocInlineTagContext> javadocInlineTag() {
 3663  
                         return getRuleContexts(JavadocInlineTagContext.class);
 3664  
                 }
 3665  
                 public JavadocInlineTagContext javadocInlineTag(int i) {
 3666  
                         return getRuleContext(JavadocInlineTagContext.class,i);
 3667  
                 }
 3668  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 3669  
                 public TerminalNode LEADING_ASTERISK(int i) {
 3670  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 3671  
                 }
 3672  
                 public TdContext(ParserRuleContext parent, int invokingState) {
 3673  
                         super(parent, invokingState);
 3674  
                 }
 3675  
                 @Override public int getRuleIndex() { return RULE_td; }
 3676  
         }
 3677  
 
 3678  
         public final TdContext td() throws RecognitionException {
 3679  19
                 TdContext _localctx = new TdContext(_ctx, getState());
 3680  19
                 enterRule(_localctx, 34, RULE_td);
 3681  
                 try {
 3682  
                         int _alt;
 3683  19
                         enterOuterAlt(_localctx, 1);
 3684  
                         {
 3685  19
                         setState(530);
 3686  19
                         tdTagStart(false);
 3687  19
                         setState(570);
 3688  19
                         _errHandler.sync(this);
 3689  19
                         _alt = getInterpreter().adaptivePredict(_input,33,_ctx);
 3690  68
                         while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 3691  49
                                 if ( _alt==1 ) {
 3692  
                                         {
 3693  49
                                         setState(568);
 3694  49
                                         _errHandler.sync(this);
 3695  49
                                         switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
 3696  
                                         case 1:
 3697  
                                                 {
 3698  0
                                                 setState(531);
 3699  0
                                                 htmlTag();
 3700  
                                                 }
 3701  0
                                                 break;
 3702  
                                         case 2:
 3703  
                                                 {
 3704  15
                                                 setState(532);
 3705  15
                                                 singletonElement();
 3706  
                                                 }
 3707  15
                                                 break;
 3708  
                                         case 3:
 3709  
                                                 {
 3710  0
                                                 setState(533);
 3711  0
                                                 paragraph();
 3712  
                                                 }
 3713  0
                                                 break;
 3714  
                                         case 4:
 3715  
                                                 {
 3716  0
                                                 setState(534);
 3717  0
                                                 li();
 3718  
                                                 }
 3719  0
                                                 break;
 3720  
                                         case 5:
 3721  
                                                 {
 3722  0
                                                 setState(535);
 3723  0
                                                 tr();
 3724  
                                                 }
 3725  0
                                                 break;
 3726  
                                         case 6:
 3727  
                                                 {
 3728  0
                                                 setState(536);
 3729  0
                                                 th();
 3730  
                                                 }
 3731  0
                                                 break;
 3732  
                                         case 7:
 3733  
                                                 {
 3734  0
                                                 setState(537);
 3735  0
                                                 body();
 3736  
                                                 }
 3737  0
                                                 break;
 3738  
                                         case 8:
 3739  
                                                 {
 3740  0
                                                 setState(538);
 3741  0
                                                 colgroup();
 3742  
                                                 }
 3743  0
                                                 break;
 3744  
                                         case 9:
 3745  
                                                 {
 3746  0
                                                 setState(539);
 3747  0
                                                 dd();
 3748  
                                                 }
 3749  0
                                                 break;
 3750  
                                         case 10:
 3751  
                                                 {
 3752  0
                                                 setState(540);
 3753  0
                                                 dt();
 3754  
                                                 }
 3755  0
                                                 break;
 3756  
                                         case 11:
 3757  
                                                 {
 3758  0
                                                 setState(541);
 3759  0
                                                 head();
 3760  
                                                 }
 3761  0
                                                 break;
 3762  
                                         case 12:
 3763  
                                                 {
 3764  0
                                                 setState(542);
 3765  0
                                                 html();
 3766  
                                                 }
 3767  0
                                                 break;
 3768  
                                         case 13:
 3769  
                                                 {
 3770  0
                                                 setState(543);
 3771  0
                                                 option();
 3772  
                                                 }
 3773  0
                                                 break;
 3774  
                                         case 14:
 3775  
                                                 {
 3776  0
                                                 setState(544);
 3777  0
                                                 tbody();
 3778  
                                                 }
 3779  0
                                                 break;
 3780  
                                         case 15:
 3781  
                                                 {
 3782  0
                                                 setState(545);
 3783  0
                                                 thead();
 3784  
                                                 }
 3785  0
                                                 break;
 3786  
                                         case 16:
 3787  
                                                 {
 3788  0
                                                 setState(546);
 3789  0
                                                 tfoot();
 3790  
                                                 }
 3791  0
                                                 break;
 3792  
                                         case 17:
 3793  
                                                 {
 3794  0
                                                 setState(547);
 3795  0
                                                 pTagStart(true);
 3796  
                                                 }
 3797  0
                                                 break;
 3798  
                                         case 18:
 3799  
                                                 {
 3800  0
                                                 setState(548);
 3801  0
                                                 liTagStart(true);
 3802  
                                                 }
 3803  0
                                                 break;
 3804  
                                         case 19:
 3805  
                                                 {
 3806  0
                                                 setState(549);
 3807  0
                                                 tdTagStart(true);
 3808  
                                                 }
 3809  0
                                                 break;
 3810  
                                         case 20:
 3811  
                                                 {
 3812  0
                                                 setState(550);
 3813  0
                                                 thTagStart(true);
 3814  
                                                 }
 3815  0
                                                 break;
 3816  
                                         case 21:
 3817  
                                                 {
 3818  0
                                                 setState(551);
 3819  0
                                                 bodyTagStart(true);
 3820  
                                                 }
 3821  0
                                                 break;
 3822  
                                         case 22:
 3823  
                                                 {
 3824  0
                                                 setState(552);
 3825  0
                                                 colgroupTagStart(true);
 3826  
                                                 }
 3827  0
                                                 break;
 3828  
                                         case 23:
 3829  
                                                 {
 3830  0
                                                 setState(553);
 3831  0
                                                 ddTagStart(true);
 3832  
                                                 }
 3833  0
                                                 break;
 3834  
                                         case 24:
 3835  
                                                 {
 3836  0
                                                 setState(554);
 3837  0
                                                 dtTagStart(true);
 3838  
                                                 }
 3839  0
                                                 break;
 3840  
                                         case 25:
 3841  
                                                 {
 3842  0
                                                 setState(555);
 3843  0
                                                 headTagStart(true);
 3844  
                                                 }
 3845  0
                                                 break;
 3846  
                                         case 26:
 3847  
                                                 {
 3848  0
                                                 setState(556);
 3849  0
                                                 htmlTagStart(true);
 3850  
                                                 }
 3851  0
                                                 break;
 3852  
                                         case 27:
 3853  
                                                 {
 3854  0
                                                 setState(557);
 3855  0
                                                 optionTagStart(true);
 3856  
                                                 }
 3857  0
                                                 break;
 3858  
                                         case 28:
 3859  
                                                 {
 3860  0
                                                 setState(558);
 3861  0
                                                 tbodyTagStart(true);
 3862  
                                                 }
 3863  0
                                                 break;
 3864  
                                         case 29:
 3865  
                                                 {
 3866  0
                                                 setState(559);
 3867  0
                                                 theadTagStart(true);
 3868  
                                                 }
 3869  0
                                                 break;
 3870  
                                         case 30:
 3871  
                                                 {
 3872  0
                                                 setState(560);
 3873  0
                                                 tfootTagStart(true);
 3874  
                                                 }
 3875  0
                                                 break;
 3876  
                                         case 31:
 3877  
                                                 {
 3878  
                                                 {
 3879  0
                                                 setState(561);
 3880  0
                                                 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
 3881  0
                                                 setState(562);
 3882  0
                                                 match(LEADING_ASTERISK);
 3883  
                                                 }
 3884  
                                                 }
 3885  0
                                                 break;
 3886  
                                         case 32:
 3887  
                                                 {
 3888  0
                                                 setState(563);
 3889  0
                                                 htmlComment();
 3890  
                                                 }
 3891  0
                                                 break;
 3892  
                                         case 33:
 3893  
                                                 {
 3894  0
                                                 setState(564);
 3895  0
                                                 match(CDATA);
 3896  
                                                 }
 3897  0
                                                 break;
 3898  
                                         case 34:
 3899  
                                                 {
 3900  0
                                                 setState(565);
 3901  0
                                                 match(NEWLINE);
 3902  
                                                 }
 3903  0
                                                 break;
 3904  
                                         case 35:
 3905  
                                                 {
 3906  34
                                                 setState(566);
 3907  34
                                                 text();
 3908  
                                                 }
 3909  34
                                                 break;
 3910  
                                         case 36:
 3911  
                                                 {
 3912  0
                                                 setState(567);
 3913  0
                                                 javadocInlineTag();
 3914  
                                                 }
 3915  
                                                 break;
 3916  
                                         }
 3917  
                                         } 
 3918  
                                 }
 3919  49
                                 setState(572);
 3920  49
                                 _errHandler.sync(this);
 3921  49
                                 _alt = getInterpreter().adaptivePredict(_input,33,_ctx);
 3922  
                         }
 3923  19
                         setState(573);
 3924  19
                         tdTagEnd();
 3925  
                         }
 3926  
                 }
 3927  0
                 catch (RecognitionException re) {
 3928  0
                         _localctx.exception = re;
 3929  0
                         _errHandler.reportError(this, re);
 3930  0
                         _errHandler.recover(this, re);
 3931  
                 }
 3932  
                 finally {
 3933  19
                         exitRule();
 3934  19
                 }
 3935  19
                 return _localctx;
 3936  
         }
 3937  
 
 3938  
         public static class ThTagStartContext extends ParserRuleContext {
 3939  
                 public boolean isNonTight;
 3940  
                 public TerminalNode START() { return getToken(JavadocParser.START, 0); }
 3941  
                 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
 3942  
                 public TerminalNode END() { return getToken(JavadocParser.END, 0); }
 3943  
                 public List<AttributeContext> attribute() {
 3944  
                         return getRuleContexts(AttributeContext.class);
 3945  
                 }
 3946  
                 public AttributeContext attribute(int i) {
 3947  
                         return getRuleContext(AttributeContext.class,i);
 3948  
                 }
 3949  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 3950  
                 public TerminalNode NEWLINE(int i) {
 3951  
                         return getToken(JavadocParser.NEWLINE, i);
 3952  
                 }
 3953  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 3954  
                 public TerminalNode LEADING_ASTERISK(int i) {
 3955  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 3956  
                 }
 3957  
                 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
 3958  
                 public TerminalNode WS(int i) {
 3959  
                         return getToken(JavadocParser.WS, i);
 3960  
                 }
 3961  
                 public ThTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
 3962  
                 public ThTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
 3963  
                         super(parent, invokingState);
 3964  
                         this.isNonTight = isNonTight;
 3965  
                 }
 3966  
                 @Override public int getRuleIndex() { return RULE_thTagStart; }
 3967  
         }
 3968  
 
 3969  
         public final ThTagStartContext thTagStart(boolean isNonTight) throws RecognitionException {
 3970  26
                 ThTagStartContext _localctx = new ThTagStartContext(_ctx, getState(), isNonTight);
 3971  26
                 enterRule(_localctx, 36, RULE_thTagStart);
 3972  
                 int _la;
 3973  
                 try {
 3974  26
                         enterOuterAlt(_localctx, 1);
 3975  
                         {
 3976  26
                         setState(575);
 3977  26
                         match(START);
 3978  26
                         setState(576);
 3979  26
                         match(TH_HTML_TAG_NAME);
 3980  26
                         setState(583);
 3981  26
                         _errHandler.sync(this);
 3982  26
                         _la = _input.LA(1);
 3983  26
                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
 3984  
                                 {
 3985  0
                                 setState(581);
 3986  0
                                 _errHandler.sync(this);
 3987  0
                                 switch (_input.LA(1)) {
 3988  
                                 case HTML_TAG_NAME:
 3989  
                                         {
 3990  0
                                         setState(577);
 3991  0
                                         attribute();
 3992  
                                         }
 3993  0
                                         break;
 3994  
                                 case NEWLINE:
 3995  
                                         {
 3996  0
                                         setState(578);
 3997  0
                                         match(NEWLINE);
 3998  
                                         }
 3999  0
                                         break;
 4000  
                                 case LEADING_ASTERISK:
 4001  
                                         {
 4002  0
                                         setState(579);
 4003  0
                                         match(LEADING_ASTERISK);
 4004  
                                         }
 4005  0
                                         break;
 4006  
                                 case WS:
 4007  
                                         {
 4008  0
                                         setState(580);
 4009  0
                                         match(WS);
 4010  
                                         }
 4011  0
                                         break;
 4012  
                                 default:
 4013  0
                                         throw new NoViableAltException(this);
 4014  
                                 }
 4015  
                                 }
 4016  0
                                 setState(585);
 4017  0
                                 _errHandler.sync(this);
 4018  0
                                 _la = _input.LA(1);
 4019  
                         }
 4020  26
                         setState(586);
 4021  26
                         match(END);
 4022  
                         }
 4023  26
                         _ctx.stop = _input.LT(-1);
 4024  
 
 4025  26
                             if (isNonTight && nonTightTagStartContext == null) {
 4026  0
                                 nonTightTagStartContext = _localctx;
 4027  
                             }
 4028  
 
 4029  
                 }
 4030  0
                 catch (RecognitionException re) {
 4031  0
                         _localctx.exception = re;
 4032  0
                         _errHandler.reportError(this, re);
 4033  0
                         _errHandler.recover(this, re);
 4034  
                 }
 4035  
                 finally {
 4036  26
                         exitRule();
 4037  26
                 }
 4038  26
                 return _localctx;
 4039  
         }
 4040  
 
 4041  
         public static class ThTagEndContext extends ParserRuleContext {
 4042  
                 public TerminalNode START() { return getToken(JavadocParser.START, 0); }
 4043  
                 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
 4044  
                 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
 4045  
                 public TerminalNode END() { return getToken(JavadocParser.END, 0); }
 4046  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 4047  
                 public TerminalNode NEWLINE(int i) {
 4048  
                         return getToken(JavadocParser.NEWLINE, i);
 4049  
                 }
 4050  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 4051  
                 public TerminalNode LEADING_ASTERISK(int i) {
 4052  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 4053  
                 }
 4054  
                 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
 4055  
                 public TerminalNode WS(int i) {
 4056  
                         return getToken(JavadocParser.WS, i);
 4057  
                 }
 4058  
                 public ThTagEndContext(ParserRuleContext parent, int invokingState) {
 4059  
                         super(parent, invokingState);
 4060  
                 }
 4061  
                 @Override public int getRuleIndex() { return RULE_thTagEnd; }
 4062  
         }
 4063  
 
 4064  
         public final ThTagEndContext thTagEnd() throws RecognitionException {
 4065  26
                 ThTagEndContext _localctx = new ThTagEndContext(_ctx, getState());
 4066  26
                 enterRule(_localctx, 38, RULE_thTagEnd);
 4067  
                 int _la;
 4068  
                 try {
 4069  26
                         enterOuterAlt(_localctx, 1);
 4070  
                         {
 4071  26
                         setState(588);
 4072  26
                         match(START);
 4073  26
                         setState(589);
 4074  26
                         match(SLASH);
 4075  26
                         setState(590);
 4076  26
                         match(TH_HTML_TAG_NAME);
 4077  26
                         setState(594);
 4078  26
                         _errHandler.sync(this);
 4079  26
                         _la = _input.LA(1);
 4080  26
                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
 4081  
                                 {
 4082  
                                 {
 4083  0
                                 setState(591);
 4084  0
                                 _la = _input.LA(1);
 4085  0
                                 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
 4086  0
                                 _errHandler.recoverInline(this);
 4087  
                                 }
 4088  
                                 else {
 4089  0
                                         if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
 4090  0
                                         _errHandler.reportMatch(this);
 4091  0
                                         consume();
 4092  
                                 }
 4093  
                                 }
 4094  
                                 }
 4095  0
                                 setState(596);
 4096  0
                                 _errHandler.sync(this);
 4097  0
                                 _la = _input.LA(1);
 4098  
                         }
 4099  26
                         setState(597);
 4100  26
                         match(END);
 4101  
                         }
 4102  
                 }
 4103  0
                 catch (RecognitionException re) {
 4104  0
                         _localctx.exception = re;
 4105  0
                         _errHandler.reportError(this, re);
 4106  0
                         _errHandler.recover(this, re);
 4107  
                 }
 4108  
                 finally {
 4109  26
                         exitRule();
 4110  26
                 }
 4111  26
                 return _localctx;
 4112  
         }
 4113  
 
 4114  
         public static class ThContext extends ParserRuleContext {
 4115  
                 public ThTagStartContext thTagStart() {
 4116  
                         return getRuleContext(ThTagStartContext.class,0);
 4117  
                 }
 4118  
                 public ThTagEndContext thTagEnd() {
 4119  
                         return getRuleContext(ThTagEndContext.class,0);
 4120  
                 }
 4121  
                 public List<HtmlTagContext> htmlTag() {
 4122  
                         return getRuleContexts(HtmlTagContext.class);
 4123  
                 }
 4124  
                 public HtmlTagContext htmlTag(int i) {
 4125  
                         return getRuleContext(HtmlTagContext.class,i);
 4126  
                 }
 4127  
                 public List<SingletonElementContext> singletonElement() {
 4128  
                         return getRuleContexts(SingletonElementContext.class);
 4129  
                 }
 4130  
                 public SingletonElementContext singletonElement(int i) {
 4131  
                         return getRuleContext(SingletonElementContext.class,i);
 4132  
                 }
 4133  
                 public List<ParagraphContext> paragraph() {
 4134  
                         return getRuleContexts(ParagraphContext.class);
 4135  
                 }
 4136  
                 public ParagraphContext paragraph(int i) {
 4137  
                         return getRuleContext(ParagraphContext.class,i);
 4138  
                 }
 4139  
                 public List<LiContext> li() {
 4140  
                         return getRuleContexts(LiContext.class);
 4141  
                 }
 4142  
                 public LiContext li(int i) {
 4143  
                         return getRuleContext(LiContext.class,i);
 4144  
                 }
 4145  
                 public List<TrContext> tr() {
 4146  
                         return getRuleContexts(TrContext.class);
 4147  
                 }
 4148  
                 public TrContext tr(int i) {
 4149  
                         return getRuleContext(TrContext.class,i);
 4150  
                 }
 4151  
                 public List<TdContext> td() {
 4152  
                         return getRuleContexts(TdContext.class);
 4153  
                 }
 4154  
                 public TdContext td(int i) {
 4155  
                         return getRuleContext(TdContext.class,i);
 4156  
                 }
 4157  
                 public List<BodyContext> body() {
 4158  
                         return getRuleContexts(BodyContext.class);
 4159  
                 }
 4160  
                 public BodyContext body(int i) {
 4161  
                         return getRuleContext(BodyContext.class,i);
 4162  
                 }
 4163  
                 public List<ColgroupContext> colgroup() {
 4164  
                         return getRuleContexts(ColgroupContext.class);
 4165  
                 }
 4166  
                 public ColgroupContext colgroup(int i) {
 4167  
                         return getRuleContext(ColgroupContext.class,i);
 4168  
                 }
 4169  
                 public List<DdContext> dd() {
 4170  
                         return getRuleContexts(DdContext.class);
 4171  
                 }
 4172  
                 public DdContext dd(int i) {
 4173  
                         return getRuleContext(DdContext.class,i);
 4174  
                 }
 4175  
                 public List<DtContext> dt() {
 4176  
                         return getRuleContexts(DtContext.class);
 4177  
                 }
 4178  
                 public DtContext dt(int i) {
 4179  
                         return getRuleContext(DtContext.class,i);
 4180  
                 }
 4181  
                 public List<HeadContext> head() {
 4182  
                         return getRuleContexts(HeadContext.class);
 4183  
                 }
 4184  
                 public HeadContext head(int i) {
 4185  
                         return getRuleContext(HeadContext.class,i);
 4186  
                 }
 4187  
                 public List<HtmlContext> html() {
 4188  
                         return getRuleContexts(HtmlContext.class);
 4189  
                 }
 4190  
                 public HtmlContext html(int i) {
 4191  
                         return getRuleContext(HtmlContext.class,i);
 4192  
                 }
 4193  
                 public List<OptionContext> option() {
 4194  
                         return getRuleContexts(OptionContext.class);
 4195  
                 }
 4196  
                 public OptionContext option(int i) {
 4197  
                         return getRuleContext(OptionContext.class,i);
 4198  
                 }
 4199  
                 public List<TbodyContext> tbody() {
 4200  
                         return getRuleContexts(TbodyContext.class);
 4201  
                 }
 4202  
                 public TbodyContext tbody(int i) {
 4203  
                         return getRuleContext(TbodyContext.class,i);
 4204  
                 }
 4205  
                 public List<TheadContext> thead() {
 4206  
                         return getRuleContexts(TheadContext.class);
 4207  
                 }
 4208  
                 public TheadContext thead(int i) {
 4209  
                         return getRuleContext(TheadContext.class,i);
 4210  
                 }
 4211  
                 public List<TfootContext> tfoot() {
 4212  
                         return getRuleContexts(TfootContext.class);
 4213  
                 }
 4214  
                 public TfootContext tfoot(int i) {
 4215  
                         return getRuleContext(TfootContext.class,i);
 4216  
                 }
 4217  
                 public List<PTagStartContext> pTagStart() {
 4218  
                         return getRuleContexts(PTagStartContext.class);
 4219  
                 }
 4220  
                 public PTagStartContext pTagStart(int i) {
 4221  
                         return getRuleContext(PTagStartContext.class,i);
 4222  
                 }
 4223  
                 public List<LiTagStartContext> liTagStart() {
 4224  
                         return getRuleContexts(LiTagStartContext.class);
 4225  
                 }
 4226  
                 public LiTagStartContext liTagStart(int i) {
 4227  
                         return getRuleContext(LiTagStartContext.class,i);
 4228  
                 }
 4229  
                 public List<TrTagStartContext> trTagStart() {
 4230  
                         return getRuleContexts(TrTagStartContext.class);
 4231  
                 }
 4232  
                 public TrTagStartContext trTagStart(int i) {
 4233  
                         return getRuleContext(TrTagStartContext.class,i);
 4234  
                 }
 4235  
                 public List<TdTagStartContext> tdTagStart() {
 4236  
                         return getRuleContexts(TdTagStartContext.class);
 4237  
                 }
 4238  
                 public TdTagStartContext tdTagStart(int i) {
 4239  
                         return getRuleContext(TdTagStartContext.class,i);
 4240  
                 }
 4241  
                 public List<BodyTagStartContext> bodyTagStart() {
 4242  
                         return getRuleContexts(BodyTagStartContext.class);
 4243  
                 }
 4244  
                 public BodyTagStartContext bodyTagStart(int i) {
 4245  
                         return getRuleContext(BodyTagStartContext.class,i);
 4246  
                 }
 4247  
                 public List<ColgroupTagStartContext> colgroupTagStart() {
 4248  
                         return getRuleContexts(ColgroupTagStartContext.class);
 4249  
                 }
 4250  
                 public ColgroupTagStartContext colgroupTagStart(int i) {
 4251  
                         return getRuleContext(ColgroupTagStartContext.class,i);
 4252  
                 }
 4253  
                 public List<DdTagStartContext> ddTagStart() {
 4254  
                         return getRuleContexts(DdTagStartContext.class);
 4255  
                 }
 4256  
                 public DdTagStartContext ddTagStart(int i) {
 4257  
                         return getRuleContext(DdTagStartContext.class,i);
 4258  
                 }
 4259  
                 public List<DtTagStartContext> dtTagStart() {
 4260  
                         return getRuleContexts(DtTagStartContext.class);
 4261  
                 }
 4262  
                 public DtTagStartContext dtTagStart(int i) {
 4263  
                         return getRuleContext(DtTagStartContext.class,i);
 4264  
                 }
 4265  
                 public List<HeadTagStartContext> headTagStart() {
 4266  
                         return getRuleContexts(HeadTagStartContext.class);
 4267  
                 }
 4268  
                 public HeadTagStartContext headTagStart(int i) {
 4269  
                         return getRuleContext(HeadTagStartContext.class,i);
 4270  
                 }
 4271  
                 public List<HtmlTagStartContext> htmlTagStart() {
 4272  
                         return getRuleContexts(HtmlTagStartContext.class);
 4273  
                 }
 4274  
                 public HtmlTagStartContext htmlTagStart(int i) {
 4275  
                         return getRuleContext(HtmlTagStartContext.class,i);
 4276  
                 }
 4277  
                 public List<OptionTagStartContext> optionTagStart() {
 4278  
                         return getRuleContexts(OptionTagStartContext.class);
 4279  
                 }
 4280  
                 public OptionTagStartContext optionTagStart(int i) {
 4281  
                         return getRuleContext(OptionTagStartContext.class,i);
 4282  
                 }
 4283  
                 public List<TbodyTagStartContext> tbodyTagStart() {
 4284  
                         return getRuleContexts(TbodyTagStartContext.class);
 4285  
                 }
 4286  
                 public TbodyTagStartContext tbodyTagStart(int i) {
 4287  
                         return getRuleContext(TbodyTagStartContext.class,i);
 4288  
                 }
 4289  
                 public List<TheadTagStartContext> theadTagStart() {
 4290  
                         return getRuleContexts(TheadTagStartContext.class);
 4291  
                 }
 4292  
                 public TheadTagStartContext theadTagStart(int i) {
 4293  
                         return getRuleContext(TheadTagStartContext.class,i);
 4294  
                 }
 4295  
                 public List<TfootTagStartContext> tfootTagStart() {
 4296  
                         return getRuleContexts(TfootTagStartContext.class);
 4297  
                 }
 4298  
                 public TfootTagStartContext tfootTagStart(int i) {
 4299  
                         return getRuleContext(TfootTagStartContext.class,i);
 4300  
                 }
 4301  
                 public List<HtmlCommentContext> htmlComment() {
 4302  
                         return getRuleContexts(HtmlCommentContext.class);
 4303  
                 }
 4304  
                 public HtmlCommentContext htmlComment(int i) {
 4305  
                         return getRuleContext(HtmlCommentContext.class,i);
 4306  
                 }
 4307  
                 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
 4308  
                 public TerminalNode CDATA(int i) {
 4309  
                         return getToken(JavadocParser.CDATA, i);
 4310  
                 }
 4311  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 4312  
                 public TerminalNode NEWLINE(int i) {
 4313  
                         return getToken(JavadocParser.NEWLINE, i);
 4314  
                 }
 4315  
                 public List<TextContext> text() {
 4316  
                         return getRuleContexts(TextContext.class);
 4317  
                 }
 4318  
                 public TextContext text(int i) {
 4319  
                         return getRuleContext(TextContext.class,i);
 4320  
                 }
 4321  
                 public List<JavadocInlineTagContext> javadocInlineTag() {
 4322  
                         return getRuleContexts(JavadocInlineTagContext.class);
 4323  
                 }
 4324  
                 public JavadocInlineTagContext javadocInlineTag(int i) {
 4325  
                         return getRuleContext(JavadocInlineTagContext.class,i);
 4326  
                 }
 4327  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 4328  
                 public TerminalNode LEADING_ASTERISK(int i) {
 4329  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 4330  
                 }
 4331  
                 public ThContext(ParserRuleContext parent, int invokingState) {
 4332  
                         super(parent, invokingState);
 4333  
                 }
 4334  
                 @Override public int getRuleIndex() { return RULE_th; }
 4335  
         }
 4336  
 
 4337  
         public final ThContext th() throws RecognitionException {
 4338  21
                 ThContext _localctx = new ThContext(_ctx, getState());
 4339  21
                 enterRule(_localctx, 40, RULE_th);
 4340  
                 try {
 4341  
                         int _alt;
 4342  21
                         enterOuterAlt(_localctx, 1);
 4343  
                         {
 4344  21
                         setState(599);
 4345  21
                         thTagStart(false);
 4346  21
                         setState(639);
 4347  21
                         _errHandler.sync(this);
 4348  21
                         _alt = getInterpreter().adaptivePredict(_input,38,_ctx);
 4349  70
                         while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 4350  49
                                 if ( _alt==1 ) {
 4351  
                                         {
 4352  49
                                         setState(637);
 4353  49
                                         _errHandler.sync(this);
 4354  49
                                         switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
 4355  
                                         case 1:
 4356  
                                                 {
 4357  0
                                                 setState(600);
 4358  0
                                                 htmlTag();
 4359  
                                                 }
 4360  0
                                                 break;
 4361  
                                         case 2:
 4362  
                                                 {
 4363  14
                                                 setState(601);
 4364  14
                                                 singletonElement();
 4365  
                                                 }
 4366  14
                                                 break;
 4367  
                                         case 3:
 4368  
                                                 {
 4369  0
                                                 setState(602);
 4370  0
                                                 paragraph();
 4371  
                                                 }
 4372  0
                                                 break;
 4373  
                                         case 4:
 4374  
                                                 {
 4375  0
                                                 setState(603);
 4376  0
                                                 li();
 4377  
                                                 }
 4378  0
                                                 break;
 4379  
                                         case 5:
 4380  
                                                 {
 4381  0
                                                 setState(604);
 4382  0
                                                 tr();
 4383  
                                                 }
 4384  0
                                                 break;
 4385  
                                         case 6:
 4386  
                                                 {
 4387  0
                                                 setState(605);
 4388  0
                                                 td();
 4389  
                                                 }
 4390  0
                                                 break;
 4391  
                                         case 7:
 4392  
                                                 {
 4393  0
                                                 setState(606);
 4394  0
                                                 body();
 4395  
                                                 }
 4396  0
                                                 break;
 4397  
                                         case 8:
 4398  
                                                 {
 4399  0
                                                 setState(607);
 4400  0
                                                 colgroup();
 4401  
                                                 }
 4402  0
                                                 break;
 4403  
                                         case 9:
 4404  
                                                 {
 4405  0
                                                 setState(608);
 4406  0
                                                 dd();
 4407  
                                                 }
 4408  0
                                                 break;
 4409  
                                         case 10:
 4410  
                                                 {
 4411  0
                                                 setState(609);
 4412  0
                                                 dt();
 4413  
                                                 }
 4414  0
                                                 break;
 4415  
                                         case 11:
 4416  
                                                 {
 4417  0
                                                 setState(610);
 4418  0
                                                 head();
 4419  
                                                 }
 4420  0
                                                 break;
 4421  
                                         case 12:
 4422  
                                                 {
 4423  0
                                                 setState(611);
 4424  0
                                                 html();
 4425  
                                                 }
 4426  0
                                                 break;
 4427  
                                         case 13:
 4428  
                                                 {
 4429  0
                                                 setState(612);
 4430  0
                                                 option();
 4431  
                                                 }
 4432  0
                                                 break;
 4433  
                                         case 14:
 4434  
                                                 {
 4435  0
                                                 setState(613);
 4436  0
                                                 tbody();
 4437  
                                                 }
 4438  0
                                                 break;
 4439  
                                         case 15:
 4440  
                                                 {
 4441  0
                                                 setState(614);
 4442  0
                                                 thead();
 4443  
                                                 }
 4444  0
                                                 break;
 4445  
                                         case 16:
 4446  
                                                 {
 4447  0
                                                 setState(615);
 4448  0
                                                 tfoot();
 4449  
                                                 }
 4450  0
                                                 break;
 4451  
                                         case 17:
 4452  
                                                 {
 4453  0
                                                 setState(616);
 4454  0
                                                 pTagStart(true);
 4455  
                                                 }
 4456  0
                                                 break;
 4457  
                                         case 18:
 4458  
                                                 {
 4459  0
                                                 setState(617);
 4460  0
                                                 liTagStart(true);
 4461  
                                                 }
 4462  0
                                                 break;
 4463  
                                         case 19:
 4464  
                                                 {
 4465  0
                                                 setState(618);
 4466  0
                                                 trTagStart(true);
 4467  
                                                 }
 4468  0
                                                 break;
 4469  
                                         case 20:
 4470  
                                                 {
 4471  0
                                                 setState(619);
 4472  0
                                                 tdTagStart(true);
 4473  
                                                 }
 4474  0
                                                 break;
 4475  
                                         case 21:
 4476  
                                                 {
 4477  0
                                                 setState(620);
 4478  0
                                                 bodyTagStart(true);
 4479  
                                                 }
 4480  0
                                                 break;
 4481  
                                         case 22:
 4482  
                                                 {
 4483  0
                                                 setState(621);
 4484  0
                                                 colgroupTagStart(true);
 4485  
                                                 }
 4486  0
                                                 break;
 4487  
                                         case 23:
 4488  
                                                 {
 4489  0
                                                 setState(622);
 4490  0
                                                 ddTagStart(true);
 4491  
                                                 }
 4492  0
                                                 break;
 4493  
                                         case 24:
 4494  
                                                 {
 4495  0
                                                 setState(623);
 4496  0
                                                 dtTagStart(true);
 4497  
                                                 }
 4498  0
                                                 break;
 4499  
                                         case 25:
 4500  
                                                 {
 4501  0
                                                 setState(624);
 4502  0
                                                 headTagStart(true);
 4503  
                                                 }
 4504  0
                                                 break;
 4505  
                                         case 26:
 4506  
                                                 {
 4507  0
                                                 setState(625);
 4508  0
                                                 htmlTagStart(true);
 4509  
                                                 }
 4510  0
                                                 break;
 4511  
                                         case 27:
 4512  
                                                 {
 4513  0
                                                 setState(626);
 4514  0
                                                 optionTagStart(true);
 4515  
                                                 }
 4516  0
                                                 break;
 4517  
                                         case 28:
 4518  
                                                 {
 4519  0
                                                 setState(627);
 4520  0
                                                 tbodyTagStart(true);
 4521  
                                                 }
 4522  0
                                                 break;
 4523  
                                         case 29:
 4524  
                                                 {
 4525  0
                                                 setState(628);
 4526  0
                                                 theadTagStart(true);
 4527  
                                                 }
 4528  0
                                                 break;
 4529  
                                         case 30:
 4530  
                                                 {
 4531  0
                                                 setState(629);
 4532  0
                                                 tfootTagStart(true);
 4533  
                                                 }
 4534  0
                                                 break;
 4535  
                                         case 31:
 4536  
                                                 {
 4537  
                                                 {
 4538  0
                                                 setState(630);
 4539  0
                                                 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
 4540  0
                                                 setState(631);
 4541  0
                                                 match(LEADING_ASTERISK);
 4542  
                                                 }
 4543  
                                                 }
 4544  0
                                                 break;
 4545  
                                         case 32:
 4546  
                                                 {
 4547  0
                                                 setState(632);
 4548  0
                                                 htmlComment();
 4549  
                                                 }
 4550  0
                                                 break;
 4551  
                                         case 33:
 4552  
                                                 {
 4553  0
                                                 setState(633);
 4554  0
                                                 match(CDATA);
 4555  
                                                 }
 4556  0
                                                 break;
 4557  
                                         case 34:
 4558  
                                                 {
 4559  0
                                                 setState(634);
 4560  0
                                                 match(NEWLINE);
 4561  
                                                 }
 4562  0
                                                 break;
 4563  
                                         case 35:
 4564  
                                                 {
 4565  35
                                                 setState(635);
 4566  35
                                                 text();
 4567  
                                                 }
 4568  35
                                                 break;
 4569  
                                         case 36:
 4570  
                                                 {
 4571  0
                                                 setState(636);
 4572  0
                                                 javadocInlineTag();
 4573  
                                                 }
 4574  
                                                 break;
 4575  
                                         }
 4576  
                                         } 
 4577  
                                 }
 4578  49
                                 setState(641);
 4579  49
                                 _errHandler.sync(this);
 4580  49
                                 _alt = getInterpreter().adaptivePredict(_input,38,_ctx);
 4581  
                         }
 4582  21
                         setState(642);
 4583  21
                         thTagEnd();
 4584  
                         }
 4585  
                 }
 4586  0
                 catch (RecognitionException re) {
 4587  0
                         _localctx.exception = re;
 4588  0
                         _errHandler.reportError(this, re);
 4589  0
                         _errHandler.recover(this, re);
 4590  
                 }
 4591  
                 finally {
 4592  21
                         exitRule();
 4593  21
                 }
 4594  21
                 return _localctx;
 4595  
         }
 4596  
 
 4597  
         public static class BodyTagStartContext extends ParserRuleContext {
 4598  
                 public boolean isNonTight;
 4599  
                 public TerminalNode START() { return getToken(JavadocParser.START, 0); }
 4600  
                 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
 4601  
                 public TerminalNode END() { return getToken(JavadocParser.END, 0); }
 4602  
                 public List<AttributeContext> attribute() {
 4603  
                         return getRuleContexts(AttributeContext.class);
 4604  
                 }
 4605  
                 public AttributeContext attribute(int i) {
 4606  
                         return getRuleContext(AttributeContext.class,i);
 4607  
                 }
 4608  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 4609  
                 public TerminalNode NEWLINE(int i) {
 4610  
                         return getToken(JavadocParser.NEWLINE, i);
 4611  
                 }
 4612  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 4613  
                 public TerminalNode LEADING_ASTERISK(int i) {
 4614  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 4615  
                 }
 4616  
                 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
 4617  
                 public TerminalNode WS(int i) {
 4618  
                         return getToken(JavadocParser.WS, i);
 4619  
                 }
 4620  
                 public BodyTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
 4621  
                 public BodyTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
 4622  
                         super(parent, invokingState);
 4623  
                         this.isNonTight = isNonTight;
 4624  
                 }
 4625  
                 @Override public int getRuleIndex() { return RULE_bodyTagStart; }
 4626  
         }
 4627  
 
 4628  
         public final BodyTagStartContext bodyTagStart(boolean isNonTight) throws RecognitionException {
 4629  31
                 BodyTagStartContext _localctx = new BodyTagStartContext(_ctx, getState(), isNonTight);
 4630  31
                 enterRule(_localctx, 42, RULE_bodyTagStart);
 4631  
                 int _la;
 4632  
                 try {
 4633  31
                         enterOuterAlt(_localctx, 1);
 4634  
                         {
 4635  31
                         setState(644);
 4636  31
                         match(START);
 4637  31
                         setState(645);
 4638  31
                         match(BODY_HTML_TAG_NAME);
 4639  31
                         setState(652);
 4640  31
                         _errHandler.sync(this);
 4641  31
                         _la = _input.LA(1);
 4642  31
                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
 4643  
                                 {
 4644  0
                                 setState(650);
 4645  0
                                 _errHandler.sync(this);
 4646  0
                                 switch (_input.LA(1)) {
 4647  
                                 case HTML_TAG_NAME:
 4648  
                                         {
 4649  0
                                         setState(646);
 4650  0
                                         attribute();
 4651  
                                         }
 4652  0
                                         break;
 4653  
                                 case NEWLINE:
 4654  
                                         {
 4655  0
                                         setState(647);
 4656  0
                                         match(NEWLINE);
 4657  
                                         }
 4658  0
                                         break;
 4659  
                                 case LEADING_ASTERISK:
 4660  
                                         {
 4661  0
                                         setState(648);
 4662  0
                                         match(LEADING_ASTERISK);
 4663  
                                         }
 4664  0
                                         break;
 4665  
                                 case WS:
 4666  
                                         {
 4667  0
                                         setState(649);
 4668  0
                                         match(WS);
 4669  
                                         }
 4670  0
                                         break;
 4671  
                                 default:
 4672  0
                                         throw new NoViableAltException(this);
 4673  
                                 }
 4674  
                                 }
 4675  0
                                 setState(654);
 4676  0
                                 _errHandler.sync(this);
 4677  0
                                 _la = _input.LA(1);
 4678  
                         }
 4679  31
                         setState(655);
 4680  31
                         match(END);
 4681  
                         }
 4682  31
                         _ctx.stop = _input.LT(-1);
 4683  
 
 4684  31
                             if (isNonTight && nonTightTagStartContext == null) {
 4685  0
                                 nonTightTagStartContext = _localctx;
 4686  
                             }
 4687  
 
 4688  
                 }
 4689  0
                 catch (RecognitionException re) {
 4690  0
                         _localctx.exception = re;
 4691  0
                         _errHandler.reportError(this, re);
 4692  0
                         _errHandler.recover(this, re);
 4693  
                 }
 4694  
                 finally {
 4695  31
                         exitRule();
 4696  31
                 }
 4697  31
                 return _localctx;
 4698  
         }
 4699  
 
 4700  
         public static class BodyTagEndContext extends ParserRuleContext {
 4701  
                 public TerminalNode START() { return getToken(JavadocParser.START, 0); }
 4702  
                 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
 4703  
                 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
 4704  
                 public TerminalNode END() { return getToken(JavadocParser.END, 0); }
 4705  
                 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
 4706  
                 public TerminalNode NEWLINE(int i) {
 4707  
                         return getToken(JavadocParser.NEWLINE, i);
 4708  
                 }
 4709  
                 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
 4710  
                 public TerminalNode LEADING_ASTERISK(int i) {
 4711  
                         return getToken(JavadocParser.LEADING_ASTERISK, i);
 4712  
                 }
 4713  
                 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
 4714  
                 public TerminalNode WS(int i) {
 4715  
                         return getToken(JavadocParser.WS, i);
 4716  
                 }
 4717  
                 public BodyTagEndContext(ParserRuleContext parent, int invokingState) {
 4718  
                         super(parent, invokingState);
 4719  
                 }
 4720  
                 @Override public int getRuleIndex() { return RULE_bodyTagEnd; }
 4721  
         }
 4722  
 
 4723  
         public final BodyTagEndContext bodyTagEnd() throws RecognitionException {
 4724  27
                 BodyTagEndContext _localctx = new BodyTagEndContext(_ctx, getState());
 4725  27
                 enterRule(_localctx, 44, RULE_bodyTagEnd);
 4726  
                 int _la;
 4727  
                 try {
 4728  27
                         enterOuterAlt(_localctx, 1);
 4729  
                         {
 4730  27
                         setState(657);
 4731  27
                         match(START);
 4732  27
                         setState(658);
 4733  27
                         match(SLASH);
 4734  27
                         setState(659);
 4735  27
                         match(BODY_HTML_TAG_NAME);
 4736  27
                         setState(663);
 4737  27
                         _errHandler.sync(this);
 4738  27
                         _la = _input.LA(1);
 4739  27
                         while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
 4740  
                                 {
 4741  
                                 {
 4742  0
                                 setState(660);
 4743  0
                                 _la = _input.LA(1);
 4744  0
                                 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
 4745  0
                                 _errHandler.recoverInline(this);
 4746  
                                 }
 4747  
                                 else {
 4748  0
                                         if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
 4749  0
                                         _errHandler.reportMatch(this);
 4750  0
                                         consume();
 4751  
                                 }
 4752  
                                 }
 4753  
                                 }
 4754  0
                                 setState(665);
 4755  0
                                 _errHandler.sync(this);
 4756  0
                                 _la = _input.LA(1);
 4757  
                         }
 4758  27
                         setState(666);
 4759  27
                         match(END);
 4760  
                         }
 4761  
                 }
 4762  0
                 catch (RecognitionException re) {
 4763  0
                         _localctx.exception = re;
 4764  0
                         _errHandler.reportError(this, re);
 4765  0
                         _errHandler.recover(this, re);
 4766  
                 }
 4767  
                 finally {
 4768  27
                         exitRule();
 4769  27
                 }
 4770  27
                 return _localctx;
 4771  
         }
 4772  
 
 4773  
         public static class BodyContext extends ParserRuleContext {
 4774  
                 public BodyTagStartContext bodyTagStart() {
 4775  
                         return getRuleContext(BodyTagStartContext.class,0);
 4776  
                 }
 4777  
                 public BodyTagEndContext bodyTagEnd() {
 4778  
                         return getRuleContext(BodyTagEndContext.class,0);
 4779  
                 }
 4780  
                 public List<HtmlTagContext> htmlTag() {
 4781  
                         return getRuleContexts(HtmlTagContext.class);
 4782  
                 }
 4783  
                 public HtmlTagContext htmlTag(int i) {
 4784  
                         return getRuleContext(HtmlTagContext.class,i);
 4785  
                 }
 4786  
                 public List<SingletonElementContext> singletonElement() {
 4787  
                         return getRuleContexts(SingletonElementContext.class);
 4788  
                 }
 4789  
                 public SingletonElementContext singletonElement(int i) {
 4790  
                         return getRuleContext(SingletonElementContext.class,i);
 4791  
                 }
 4792  
                 public List<ParagraphContext> paragraph() {
 4793  
                         return getRuleContexts(ParagraphContext.class);
 4794  
                 }
 4795  
                 public ParagraphContext paragraph(int i) {
 4796  
                         return getRuleContext(ParagraphContext.class,i);
 4797  
                 }
 4798  
                 public List<LiContext> li() {
 4799  
                         return getRuleContexts(LiContext.class);
 4800  
                 }
 4801  
                 public LiContext li(int i) {
 4802  
                         return getRuleContext(LiContext.class,i);
 4803  
                 }
 4804  
                 public List<TrContext> tr() {
 4805  
                         return getRuleContexts(TrContext.class);
 4806  
                 }
 4807  
                 public TrContext tr(int i) {
 4808  
                         return getRuleContext(TrContext.class,i);
 4809  
                 }
 4810  
                 public List<TdContext> td() {
 4811  
                         return getRuleContexts(TdContext.class);
 4812  
                 }
 4813  
                 public TdContext td(int i) {
 4814  
                         return getRuleContext(TdContext.class,i);
 4815  
                 }
 4816  
                 public List<ThContext> th() {
 4817  
                         return getRuleContexts(ThContext.class);
 4818  
                 }
 4819  
                 public ThContext th(int i) {
 4820  
                         return getRuleContext(ThContext.class,i);
 4821 &n