View Javadoc
1   // Generated from com/puppycrawl/tools/checkstyle/grammars/javadoc/JavadocParser.g4 by ANTLR 4.7.1
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  	static { RuntimeMetaData.checkVersion("4.7.1", RuntimeMetaData.VERSION); }
15  
16  	protected static final DFA[] _decisionToDFA;
17  	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  	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  	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  	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 	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 		tokenNames = new String[_SYMBOLIC_NAMES.length];
124 		for (int i = 0; i < tokenNames.length; i++) {
125 			tokenNames[i] = VOCABULARY.getLiteralName(i);
126 			if (tokenNames[i] == null) {
127 				tokenNames[i] = VOCABULARY.getSymbolicName(i);
128 			}
129 
130 			if (tokenNames[i] == null) {
131 				tokenNames[i] = "<INVALID>";
132 			}
133 		}
134 	}
135 
136 	@Override
137 	@Deprecated
138 	public String[] getTokenNames() {
139 		return tokenNames;
140 	}
141 
142 	@Override
143 
144 	public Vocabulary getVocabulary() {
145 		return VOCABULARY;
146 	}
147 
148 	@Override
149 	public String getGrammarFileName() { return "JavadocParser.g4"; }
150 
151 	@Override
152 	public String[] getRuleNames() { return ruleNames; }
153 
154 	@Override
155 	public String getSerializedATN() { return _serializedATN; }
156 
157 	@Override
158 	public ATN getATN() { return _ATN; }
159 
160 
161 	    boolean isNextJavadocTag() {
162 	        int token1 = _input.LA(2);
163 	        int token2 = _input.LA(3);
164 	        return isJavadocTag(token1)
165 	            || (token1 == WS && isJavadocTag(token2));
166 	    }
167 
168 	    boolean isJavadocTag(int type) {
169 	        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 	                return true;
184 	            default:
185 	                return false;
186 	        }
187 	    }
188 
189 	    boolean isSameTagNames(ParserRuleContext htmlTagStart, ParserRuleContext htmlTagEnd) {
190 	          String startTag = htmlTagStart.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
191 	          String endTag = htmlTagEnd.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
192 	          return startTag.equals(endTag);
193 	    }
194 
195 	    public ParserRuleContext nonTightTagStartContext;
196 
197 	public JavadocParser(TokenStream input) {
198 		super(input);
199 		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
200 	}
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 		JavadocContext _localctx = new JavadocContext(_ctx, getState());
257 		enterRule(_localctx, 0, RULE_javadoc);
258 		int _la;
259 		try {
260 			int _alt;
261 			enterOuterAlt(_localctx, 1);
262 			{
263 			setState(170);
264 			_errHandler.sync(this);
265 			_alt = getInterpreter().adaptivePredict(_input,1,_ctx);
266 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
267 				if ( _alt==1 ) {
268 					{
269 					setState(168);
270 					_errHandler.sync(this);
271 					switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
272 					case 1:
273 						{
274 						setState(160);
275 						htmlElement();
276 						}
277 						break;
278 					case 2:
279 						{
280 						{
281 						setState(161);
282 						if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
283 						setState(162);
284 						match(LEADING_ASTERISK);
285 						}
286 						}
287 						break;
288 					case 3:
289 						{
290 						setState(163);
291 						htmlComment();
292 						}
293 						break;
294 					case 4:
295 						{
296 						setState(164);
297 						match(CDATA);
298 						}
299 						break;
300 					case 5:
301 						{
302 						setState(165);
303 						match(NEWLINE);
304 						}
305 						break;
306 					case 6:
307 						{
308 						setState(166);
309 						text();
310 						}
311 						break;
312 					case 7:
313 						{
314 						setState(167);
315 						javadocInlineTag();
316 						}
317 						break;
318 					}
319 					} 
320 				}
321 				setState(172);
322 				_errHandler.sync(this);
323 				_alt = getInterpreter().adaptivePredict(_input,1,_ctx);
324 			}
325 			setState(185);
326 			_errHandler.sync(this);
327 			_la = _input.LA(1);
328 			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 				setState(174);
332 				_errHandler.sync(this);
333 				_la = _input.LA(1);
334 				if (_la==LEADING_ASTERISK) {
335 					{
336 					setState(173);
337 					match(LEADING_ASTERISK);
338 					}
339 				}
340 
341 				setState(179);
342 				_errHandler.sync(this);
343 				_la = _input.LA(1);
344 				while (_la==WS) {
345 					{
346 					{
347 					setState(176);
348 					match(WS);
349 					}
350 					}
351 					setState(181);
352 					_errHandler.sync(this);
353 					_la = _input.LA(1);
354 				}
355 				setState(182);
356 				javadocTag();
357 				}
358 				}
359 				setState(187);
360 				_errHandler.sync(this);
361 				_la = _input.LA(1);
362 			}
363 			setState(188);
364 			match(EOF);
365 			}
366 		}
367 		catch (RecognitionException re) {
368 			_localctx.exception = re;
369 			_errHandler.reportError(this, re);
370 			_errHandler.recover(this, re);
371 		}
372 		finally {
373 			exitRule();
374 		}
375 		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 		HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState());
528 		enterRule(_localctx, 2, RULE_htmlElement);
529 		try {
530 			setState(237);
531 			_errHandler.sync(this);
532 			switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
533 			case 1:
534 				enterOuterAlt(_localctx, 1);
535 				{
536 				setState(190);
537 				htmlTag();
538 				}
539 				break;
540 			case 2:
541 				enterOuterAlt(_localctx, 2);
542 				{
543 				setState(191);
544 				singletonElement();
545 				}
546 				break;
547 			case 3:
548 				enterOuterAlt(_localctx, 3);
549 				{
550 				setState(192);
551 				paragraph();
552 				}
553 				break;
554 			case 4:
555 				enterOuterAlt(_localctx, 4);
556 				{
557 				setState(193);
558 				li();
559 				}
560 				break;
561 			case 5:
562 				enterOuterAlt(_localctx, 5);
563 				{
564 				setState(194);
565 				tr();
566 				}
567 				break;
568 			case 6:
569 				enterOuterAlt(_localctx, 6);
570 				{
571 				setState(195);
572 				td();
573 				}
574 				break;
575 			case 7:
576 				enterOuterAlt(_localctx, 7);
577 				{
578 				setState(196);
579 				th();
580 				}
581 				break;
582 			case 8:
583 				enterOuterAlt(_localctx, 8);
584 				{
585 				setState(197);
586 				body();
587 				}
588 				break;
589 			case 9:
590 				enterOuterAlt(_localctx, 9);
591 				{
592 				setState(198);
593 				colgroup();
594 				}
595 				break;
596 			case 10:
597 				enterOuterAlt(_localctx, 10);
598 				{
599 				setState(199);
600 				dd();
601 				}
602 				break;
603 			case 11:
604 				enterOuterAlt(_localctx, 11);
605 				{
606 				setState(200);
607 				dt();
608 				}
609 				break;
610 			case 12:
611 				enterOuterAlt(_localctx, 12);
612 				{
613 				setState(201);
614 				head();
615 				}
616 				break;
617 			case 13:
618 				enterOuterAlt(_localctx, 13);
619 				{
620 				setState(202);
621 				html();
622 				}
623 				break;
624 			case 14:
625 				enterOuterAlt(_localctx, 14);
626 				{
627 				setState(203);
628 				option();
629 				}
630 				break;
631 			case 15:
632 				enterOuterAlt(_localctx, 15);
633 				{
634 				setState(204);
635 				tbody();
636 				}
637 				break;
638 			case 16:
639 				enterOuterAlt(_localctx, 16);
640 				{
641 				setState(205);
642 				thead();
643 				}
644 				break;
645 			case 17:
646 				enterOuterAlt(_localctx, 17);
647 				{
648 				setState(206);
649 				tfoot();
650 				}
651 				break;
652 			case 18:
653 				enterOuterAlt(_localctx, 18);
654 				{
655 				setState(207);
656 				pTagStart(true);
657 				}
658 				break;
659 			case 19:
660 				enterOuterAlt(_localctx, 19);
661 				{
662 				setState(208);
663 				liTagStart(true);
664 				}
665 				break;
666 			case 20:
667 				enterOuterAlt(_localctx, 20);
668 				{
669 				setState(209);
670 				trTagStart(true);
671 				}
672 				break;
673 			case 21:
674 				enterOuterAlt(_localctx, 21);
675 				{
676 				setState(210);
677 				tdTagStart(true);
678 				}
679 				break;
680 			case 22:
681 				enterOuterAlt(_localctx, 22);
682 				{
683 				setState(211);
684 				thTagStart(true);
685 				}
686 				break;
687 			case 23:
688 				enterOuterAlt(_localctx, 23);
689 				{
690 				setState(212);
691 				bodyTagStart(true);
692 				}
693 				break;
694 			case 24:
695 				enterOuterAlt(_localctx, 24);
696 				{
697 				setState(213);
698 				colgroupTagStart(true);
699 				}
700 				break;
701 			case 25:
702 				enterOuterAlt(_localctx, 25);
703 				{
704 				setState(214);
705 				ddTagStart(true);
706 				}
707 				break;
708 			case 26:
709 				enterOuterAlt(_localctx, 26);
710 				{
711 				setState(215);
712 				dtTagStart(true);
713 				}
714 				break;
715 			case 27:
716 				enterOuterAlt(_localctx, 27);
717 				{
718 				setState(216);
719 				headTagStart(true);
720 				}
721 				break;
722 			case 28:
723 				enterOuterAlt(_localctx, 28);
724 				{
725 				setState(217);
726 				htmlTagStart(true);
727 				}
728 				break;
729 			case 29:
730 				enterOuterAlt(_localctx, 29);
731 				{
732 				setState(218);
733 				optionTagStart(true);
734 				}
735 				break;
736 			case 30:
737 				enterOuterAlt(_localctx, 30);
738 				{
739 				setState(219);
740 				tbodyTagStart(true);
741 				}
742 				break;
743 			case 31:
744 				enterOuterAlt(_localctx, 31);
745 				{
746 				setState(220);
747 				theadTagStart(true);
748 				}
749 				break;
750 			case 32:
751 				enterOuterAlt(_localctx, 32);
752 				{
753 				setState(221);
754 				tfootTagStart(true);
755 				}
756 				break;
757 			case 33:
758 				enterOuterAlt(_localctx, 33);
759 				{
760 				setState(222);
761 				pTagEnd();
762 				}
763 				break;
764 			case 34:
765 				enterOuterAlt(_localctx, 34);
766 				{
767 				setState(223);
768 				liTagEnd();
769 				}
770 				break;
771 			case 35:
772 				enterOuterAlt(_localctx, 35);
773 				{
774 				setState(224);
775 				trTagEnd();
776 				}
777 				break;
778 			case 36:
779 				enterOuterAlt(_localctx, 36);
780 				{
781 				setState(225);
782 				tdTagEnd();
783 				}
784 				break;
785 			case 37:
786 				enterOuterAlt(_localctx, 37);
787 				{
788 				setState(226);
789 				thTagEnd();
790 				}
791 				break;
792 			case 38:
793 				enterOuterAlt(_localctx, 38);
794 				{
795 				setState(227);
796 				bodyTagEnd();
797 				}
798 				break;
799 			case 39:
800 				enterOuterAlt(_localctx, 39);
801 				{
802 				setState(228);
803 				colgroupTagEnd();
804 				}
805 				break;
806 			case 40:
807 				enterOuterAlt(_localctx, 40);
808 				{
809 				setState(229);
810 				ddTagEnd();
811 				}
812 				break;
813 			case 41:
814 				enterOuterAlt(_localctx, 41);
815 				{
816 				setState(230);
817 				dtTagEnd();
818 				}
819 				break;
820 			case 42:
821 				enterOuterAlt(_localctx, 42);
822 				{
823 				setState(231);
824 				headTagEnd();
825 				}
826 				break;
827 			case 43:
828 				enterOuterAlt(_localctx, 43);
829 				{
830 				setState(232);
831 				htmlTagEnd();
832 				}
833 				break;
834 			case 44:
835 				enterOuterAlt(_localctx, 44);
836 				{
837 				setState(233);
838 				optionTagEnd();
839 				}
840 				break;
841 			case 45:
842 				enterOuterAlt(_localctx, 45);
843 				{
844 				setState(234);
845 				tbodyTagEnd();
846 				}
847 				break;
848 			case 46:
849 				enterOuterAlt(_localctx, 46);
850 				{
851 				setState(235);
852 				theadTagEnd();
853 				}
854 				break;
855 			case 47:
856 				enterOuterAlt(_localctx, 47);
857 				{
858 				setState(236);
859 				tfootTagEnd();
860 				}
861 				break;
862 			}
863 		}
864 		catch (RecognitionException re) {
865 			_localctx.exception = re;
866 			_errHandler.reportError(this, re);
867 			_errHandler.recover(this, re);
868 		}
869 		finally {
870 			exitRule();
871 		}
872 		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 		HtmlElementStartContext _localctx = new HtmlElementStartContext(_ctx, getState());
905 		enterRule(_localctx, 4, RULE_htmlElementStart);
906 		int _la;
907 		try {
908 			enterOuterAlt(_localctx, 1);
909 			{
910 			setState(239);
911 			match(START);
912 			setState(240);
913 			match(HTML_TAG_NAME);
914 			setState(247);
915 			_errHandler.sync(this);
916 			_la = _input.LA(1);
917 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
918 				{
919 				setState(245);
920 				_errHandler.sync(this);
921 				switch (_input.LA(1)) {
922 				case HTML_TAG_NAME:
923 					{
924 					setState(241);
925 					attribute();
926 					}
927 					break;
928 				case NEWLINE:
929 					{
930 					setState(242);
931 					match(NEWLINE);
932 					}
933 					break;
934 				case LEADING_ASTERISK:
935 					{
936 					setState(243);
937 					match(LEADING_ASTERISK);
938 					}
939 					break;
940 				case WS:
941 					{
942 					setState(244);
943 					match(WS);
944 					}
945 					break;
946 				default:
947 					throw new NoViableAltException(this);
948 				}
949 				}
950 				setState(249);
951 				_errHandler.sync(this);
952 				_la = _input.LA(1);
953 			}
954 			setState(250);
955 			match(END);
956 			}
957 		}
958 		catch (RecognitionException re) {
959 			_localctx.exception = re;
960 			_errHandler.reportError(this, re);
961 			_errHandler.recover(this, re);
962 		}
963 		finally {
964 			exitRule();
965 		}
966 		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 		HtmlElementEndContext _localctx = new HtmlElementEndContext(_ctx, getState());
994 		enterRule(_localctx, 6, RULE_htmlElementEnd);
995 		int _la;
996 		try {
997 			enterOuterAlt(_localctx, 1);
998 			{
999 			setState(252);
1000 			match(START);
1001 			setState(253);
1002 			match(SLASH);
1003 			setState(254);
1004 			match(HTML_TAG_NAME);
1005 			setState(258);
1006 			_errHandler.sync(this);
1007 			_la = _input.LA(1);
1008 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1009 				{
1010 				{
1011 				setState(255);
1012 				_la = _input.LA(1);
1013 				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1014 				_errHandler.recoverInline(this);
1015 				}
1016 				else {
1017 					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1018 					_errHandler.reportMatch(this);
1019 					consume();
1020 				}
1021 				}
1022 				}
1023 				setState(260);
1024 				_errHandler.sync(this);
1025 				_la = _input.LA(1);
1026 			}
1027 			setState(261);
1028 			match(END);
1029 			}
1030 		}
1031 		catch (RecognitionException re) {
1032 			_localctx.exception = re;
1033 			_errHandler.reportError(this, re);
1034 			_errHandler.recover(this, re);
1035 		}
1036 		finally {
1037 			exitRule();
1038 		}
1039 		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 		AttributeContext _localctx = new AttributeContext(_ctx, getState());
1072 		enterRule(_localctx, 8, RULE_attribute);
1073 		int _la;
1074 		try {
1075 			int _alt;
1076 			enterOuterAlt(_localctx, 1);
1077 			{
1078 			setState(263);
1079 			match(HTML_TAG_NAME);
1080 			setState(267);
1081 			_errHandler.sync(this);
1082 			_la = _input.LA(1);
1083 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1084 				{
1085 				{
1086 				setState(264);
1087 				_la = _input.LA(1);
1088 				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1089 				_errHandler.recoverInline(this);
1090 				}
1091 				else {
1092 					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1093 					_errHandler.reportMatch(this);
1094 					consume();
1095 				}
1096 				}
1097 				}
1098 				setState(269);
1099 				_errHandler.sync(this);
1100 				_la = _input.LA(1);
1101 			}
1102 			setState(270);
1103 			match(EQUALS);
1104 			setState(274);
1105 			_errHandler.sync(this);
1106 			_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
1107 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1108 				if ( _alt==1 ) {
1109 					{
1110 					{
1111 					setState(271);
1112 					_la = _input.LA(1);
1113 					if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1114 					_errHandler.recoverInline(this);
1115 					}
1116 					else {
1117 						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1118 						_errHandler.reportMatch(this);
1119 						consume();
1120 					}
1121 					}
1122 					} 
1123 				}
1124 				setState(276);
1125 				_errHandler.sync(this);
1126 				_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
1127 			}
1128 			setState(280);
1129 			_errHandler.sync(this);
1130 			switch (_input.LA(1)) {
1131 			case ATTR_VALUE:
1132 				{
1133 				setState(277);
1134 				match(ATTR_VALUE);
1135 				}
1136 				break;
1137 			case WS:
1138 			case CHAR:
1139 				{
1140 				setState(278);
1141 				text();
1142 				}
1143 				break;
1144 			case HTML_TAG_NAME:
1145 				{
1146 				setState(279);
1147 				match(HTML_TAG_NAME);
1148 				}
1149 				break;
1150 			default:
1151 				throw new NoViableAltException(this);
1152 			}
1153 			}
1154 		}
1155 		catch (RecognitionException re) {
1156 			_localctx.exception = re;
1157 			_errHandler.reportError(this, re);
1158 			_errHandler.recover(this, re);
1159 		}
1160 		finally {
1161 			exitRule();
1162 		}
1163 		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 		HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState());
1219 		enterRule(_localctx, 10, RULE_htmlTag);
1220 		try {
1221 			int _alt;
1222 			enterOuterAlt(_localctx, 1);
1223 			{
1224 			setState(282);
1225 			((HtmlTagContext)_localctx).htmlElementStart = htmlElementStart();
1226 			setState(293);
1227 			_errHandler.sync(this);
1228 			_alt = getInterpreter().adaptivePredict(_input,13,_ctx);
1229 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1230 				if ( _alt==1 ) {
1231 					{
1232 					setState(291);
1233 					_errHandler.sync(this);
1234 					switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
1235 					case 1:
1236 						{
1237 						setState(283);
1238 						htmlElement();
1239 						}
1240 						break;
1241 					case 2:
1242 						{
1243 						{
1244 						setState(284);
1245 						if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
1246 						setState(285);
1247 						match(LEADING_ASTERISK);
1248 						}
1249 						}
1250 						break;
1251 					case 3:
1252 						{
1253 						setState(286);
1254 						htmlComment();
1255 						}
1256 						break;
1257 					case 4:
1258 						{
1259 						setState(287);
1260 						match(CDATA);
1261 						}
1262 						break;
1263 					case 5:
1264 						{
1265 						setState(288);
1266 						match(NEWLINE);
1267 						}
1268 						break;
1269 					case 6:
1270 						{
1271 						setState(289);
1272 						text();
1273 						}
1274 						break;
1275 					case 7:
1276 						{
1277 						setState(290);
1278 						javadocInlineTag();
1279 						}
1280 						break;
1281 					}
1282 					} 
1283 				}
1284 				setState(295);
1285 				_errHandler.sync(this);
1286 				_alt = getInterpreter().adaptivePredict(_input,13,_ctx);
1287 			}
1288 			setState(296);
1289 			((HtmlTagContext)_localctx).htmlElementEnd = htmlElementEnd();
1290 			setState(297);
1291 			if (!(isSameTagNames(((HtmlTagContext)_localctx).htmlElementStart, ((HtmlTagContext)_localctx).htmlElementEnd))) throw new FailedPredicateException(this, "isSameTagNames($htmlElementStart.ctx, $htmlElementEnd.ctx)");
1292 			}
1293 		}
1294 		catch (RecognitionException re) {
1295 			_localctx.exception = re;
1296 			_errHandler.reportError(this, re);
1297 			_errHandler.recover(this, re);
1298 		}
1299 		finally {
1300 			exitRule();
1301 		}
1302 		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 		PTagStartContext _localctx = new PTagStartContext(_ctx, getState(), isNonTight);
1338 		enterRule(_localctx, 12, RULE_pTagStart);
1339 		int _la;
1340 		try {
1341 			enterOuterAlt(_localctx, 1);
1342 			{
1343 			setState(299);
1344 			match(START);
1345 			setState(300);
1346 			match(P_HTML_TAG_NAME);
1347 			setState(307);
1348 			_errHandler.sync(this);
1349 			_la = _input.LA(1);
1350 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
1351 				{
1352 				setState(305);
1353 				_errHandler.sync(this);
1354 				switch (_input.LA(1)) {
1355 				case HTML_TAG_NAME:
1356 					{
1357 					setState(301);
1358 					attribute();
1359 					}
1360 					break;
1361 				case NEWLINE:
1362 					{
1363 					setState(302);
1364 					match(NEWLINE);
1365 					}
1366 					break;
1367 				case LEADING_ASTERISK:
1368 					{
1369 					setState(303);
1370 					match(LEADING_ASTERISK);
1371 					}
1372 					break;
1373 				case WS:
1374 					{
1375 					setState(304);
1376 					match(WS);
1377 					}
1378 					break;
1379 				default:
1380 					throw new NoViableAltException(this);
1381 				}
1382 				}
1383 				setState(309);
1384 				_errHandler.sync(this);
1385 				_la = _input.LA(1);
1386 			}
1387 			setState(310);
1388 			match(END);
1389 			}
1390 			_ctx.stop = _input.LT(-1);
1391 
1392 			    if (isNonTight && nonTightTagStartContext == null) {
1393 			        nonTightTagStartContext = _localctx;
1394 			    }
1395 
1396 		}
1397 		catch (RecognitionException re) {
1398 			_localctx.exception = re;
1399 			_errHandler.reportError(this, re);
1400 			_errHandler.recover(this, re);
1401 		}
1402 		finally {
1403 			exitRule();
1404 		}
1405 		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 		PTagEndContext _localctx = new PTagEndContext(_ctx, getState());
1433 		enterRule(_localctx, 14, RULE_pTagEnd);
1434 		int _la;
1435 		try {
1436 			enterOuterAlt(_localctx, 1);
1437 			{
1438 			setState(312);
1439 			match(START);
1440 			setState(313);
1441 			match(SLASH);
1442 			setState(314);
1443 			match(P_HTML_TAG_NAME);
1444 			setState(318);
1445 			_errHandler.sync(this);
1446 			_la = _input.LA(1);
1447 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1448 				{
1449 				{
1450 				setState(315);
1451 				_la = _input.LA(1);
1452 				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1453 				_errHandler.recoverInline(this);
1454 				}
1455 				else {
1456 					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1457 					_errHandler.reportMatch(this);
1458 					consume();
1459 				}
1460 				}
1461 				}
1462 				setState(320);
1463 				_errHandler.sync(this);
1464 				_la = _input.LA(1);
1465 			}
1466 			setState(321);
1467 			match(END);
1468 			}
1469 		}
1470 		catch (RecognitionException re) {
1471 			_localctx.exception = re;
1472 			_errHandler.reportError(this, re);
1473 			_errHandler.recover(this, re);
1474 		}
1475 		finally {
1476 			exitRule();
1477 		}
1478 		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 		ParagraphContext _localctx = new ParagraphContext(_ctx, getState());
1706 		enterRule(_localctx, 16, RULE_paragraph);
1707 		try {
1708 			int _alt;
1709 			enterOuterAlt(_localctx, 1);
1710 			{
1711 			setState(323);
1712 			pTagStart(false);
1713 			setState(363);
1714 			_errHandler.sync(this);
1715 			_alt = getInterpreter().adaptivePredict(_input,18,_ctx);
1716 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1717 				if ( _alt==1 ) {
1718 					{
1719 					setState(361);
1720 					_errHandler.sync(this);
1721 					switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
1722 					case 1:
1723 						{
1724 						setState(324);
1725 						htmlTag();
1726 						}
1727 						break;
1728 					case 2:
1729 						{
1730 						setState(325);
1731 						singletonElement();
1732 						}
1733 						break;
1734 					case 3:
1735 						{
1736 						setState(326);
1737 						li();
1738 						}
1739 						break;
1740 					case 4:
1741 						{
1742 						setState(327);
1743 						tr();
1744 						}
1745 						break;
1746 					case 5:
1747 						{
1748 						setState(328);
1749 						td();
1750 						}
1751 						break;
1752 					case 6:
1753 						{
1754 						setState(329);
1755 						th();
1756 						}
1757 						break;
1758 					case 7:
1759 						{
1760 						setState(330);
1761 						body();
1762 						}
1763 						break;
1764 					case 8:
1765 						{
1766 						setState(331);
1767 						colgroup();
1768 						}
1769 						break;
1770 					case 9:
1771 						{
1772 						setState(332);
1773 						dd();
1774 						}
1775 						break;
1776 					case 10:
1777 						{
1778 						setState(333);
1779 						dt();
1780 						}
1781 						break;
1782 					case 11:
1783 						{
1784 						setState(334);
1785 						head();
1786 						}
1787 						break;
1788 					case 12:
1789 						{
1790 						setState(335);
1791 						html();
1792 						}
1793 						break;
1794 					case 13:
1795 						{
1796 						setState(336);
1797 						option();
1798 						}
1799 						break;
1800 					case 14:
1801 						{
1802 						setState(337);
1803 						tbody();
1804 						}
1805 						break;
1806 					case 15:
1807 						{
1808 						setState(338);
1809 						thead();
1810 						}
1811 						break;
1812 					case 16:
1813 						{
1814 						setState(339);
1815 						tfoot();
1816 						}
1817 						break;
1818 					case 17:
1819 						{
1820 						setState(340);
1821 						liTagStart(true);
1822 						}
1823 						break;
1824 					case 18:
1825 						{
1826 						setState(341);
1827 						trTagStart(true);
1828 						}
1829 						break;
1830 					case 19:
1831 						{
1832 						setState(342);
1833 						tdTagStart(true);
1834 						}
1835 						break;
1836 					case 20:
1837 						{
1838 						setState(343);
1839 						thTagStart(true);
1840 						}
1841 						break;
1842 					case 21:
1843 						{
1844 						setState(344);
1845 						bodyTagStart(true);
1846 						}
1847 						break;
1848 					case 22:
1849 						{
1850 						setState(345);
1851 						colgroupTagStart(true);
1852 						}
1853 						break;
1854 					case 23:
1855 						{
1856 						setState(346);
1857 						ddTagStart(true);
1858 						}
1859 						break;
1860 					case 24:
1861 						{
1862 						setState(347);
1863 						dtTagStart(true);
1864 						}
1865 						break;
1866 					case 25:
1867 						{
1868 						setState(348);
1869 						headTagStart(true);
1870 						}
1871 						break;
1872 					case 26:
1873 						{
1874 						setState(349);
1875 						htmlTagStart(true);
1876 						}
1877 						break;
1878 					case 27:
1879 						{
1880 						setState(350);
1881 						optionTagStart(true);
1882 						}
1883 						break;
1884 					case 28:
1885 						{
1886 						setState(351);
1887 						tbodyTagStart(true);
1888 						}
1889 						break;
1890 					case 29:
1891 						{
1892 						setState(352);
1893 						theadTagStart(true);
1894 						}
1895 						break;
1896 					case 30:
1897 						{
1898 						setState(353);
1899 						tfootTagStart(true);
1900 						}
1901 						break;
1902 					case 31:
1903 						{
1904 						{
1905 						setState(354);
1906 						if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
1907 						setState(355);
1908 						match(LEADING_ASTERISK);
1909 						}
1910 						}
1911 						break;
1912 					case 32:
1913 						{
1914 						setState(356);
1915 						htmlComment();
1916 						}
1917 						break;
1918 					case 33:
1919 						{
1920 						setState(357);
1921 						match(CDATA);
1922 						}
1923 						break;
1924 					case 34:
1925 						{
1926 						setState(358);
1927 						match(NEWLINE);
1928 						}
1929 						break;
1930 					case 35:
1931 						{
1932 						setState(359);
1933 						text();
1934 						}
1935 						break;
1936 					case 36:
1937 						{
1938 						setState(360);
1939 						javadocInlineTag();
1940 						}
1941 						break;
1942 					}
1943 					} 
1944 				}
1945 				setState(365);
1946 				_errHandler.sync(this);
1947 				_alt = getInterpreter().adaptivePredict(_input,18,_ctx);
1948 			}
1949 			setState(366);
1950 			pTagEnd();
1951 			}
1952 		}
1953 		catch (RecognitionException re) {
1954 			_localctx.exception = re;
1955 			_errHandler.reportError(this, re);
1956 			_errHandler.recover(this, re);
1957 		}
1958 		finally {
1959 			exitRule();
1960 		}
1961 		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 		LiTagStartContext _localctx = new LiTagStartContext(_ctx, getState(), isNonTight);
1997 		enterRule(_localctx, 18, RULE_liTagStart);
1998 		int _la;
1999 		try {
2000 			enterOuterAlt(_localctx, 1);
2001 			{
2002 			setState(368);
2003 			match(START);
2004 			setState(369);
2005 			match(LI_HTML_TAG_NAME);
2006 			setState(376);
2007 			_errHandler.sync(this);
2008 			_la = _input.LA(1);
2009 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2010 				{
2011 				setState(374);
2012 				_errHandler.sync(this);
2013 				switch (_input.LA(1)) {
2014 				case HTML_TAG_NAME:
2015 					{
2016 					setState(370);
2017 					attribute();
2018 					}
2019 					break;
2020 				case NEWLINE:
2021 					{
2022 					setState(371);
2023 					match(NEWLINE);
2024 					}
2025 					break;
2026 				case LEADING_ASTERISK:
2027 					{
2028 					setState(372);
2029 					match(LEADING_ASTERISK);
2030 					}
2031 					break;
2032 				case WS:
2033 					{
2034 					setState(373);
2035 					match(WS);
2036 					}
2037 					break;
2038 				default:
2039 					throw new NoViableAltException(this);
2040 				}
2041 				}
2042 				setState(378);
2043 				_errHandler.sync(this);
2044 				_la = _input.LA(1);
2045 			}
2046 			setState(379);
2047 			match(END);
2048 			}
2049 			_ctx.stop = _input.LT(-1);
2050 
2051 			    if (isNonTight && nonTightTagStartContext == null) {
2052 			        nonTightTagStartContext = _localctx;
2053 			    }
2054 
2055 		}
2056 		catch (RecognitionException re) {
2057 			_localctx.exception = re;
2058 			_errHandler.reportError(this, re);
2059 			_errHandler.recover(this, re);
2060 		}
2061 		finally {
2062 			exitRule();
2063 		}
2064 		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 		LiTagEndContext _localctx = new LiTagEndContext(_ctx, getState());
2092 		enterRule(_localctx, 20, RULE_liTagEnd);
2093 		int _la;
2094 		try {
2095 			enterOuterAlt(_localctx, 1);
2096 			{
2097 			setState(381);
2098 			match(START);
2099 			setState(382);
2100 			match(SLASH);
2101 			setState(383);
2102 			match(LI_HTML_TAG_NAME);
2103 			setState(387);
2104 			_errHandler.sync(this);
2105 			_la = _input.LA(1);
2106 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
2107 				{
2108 				{
2109 				setState(384);
2110 				_la = _input.LA(1);
2111 				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
2112 				_errHandler.recoverInline(this);
2113 				}
2114 				else {
2115 					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
2116 					_errHandler.reportMatch(this);
2117 					consume();
2118 				}
2119 				}
2120 				}
2121 				setState(389);
2122 				_errHandler.sync(this);
2123 				_la = _input.LA(1);
2124 			}
2125 			setState(390);
2126 			match(END);
2127 			}
2128 		}
2129 		catch (RecognitionException re) {
2130 			_localctx.exception = re;
2131 			_errHandler.reportError(this, re);
2132 			_errHandler.recover(this, re);
2133 		}
2134 		finally {
2135 			exitRule();
2136 		}
2137 		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 		LiContext _localctx = new LiContext(_ctx, getState());
2365 		enterRule(_localctx, 22, RULE_li);
2366 		try {
2367 			int _alt;
2368 			enterOuterAlt(_localctx, 1);
2369 			{
2370 			setState(392);
2371 			liTagStart(false);
2372 			setState(432);
2373 			_errHandler.sync(this);
2374 			_alt = getInterpreter().adaptivePredict(_input,23,_ctx);
2375 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
2376 				if ( _alt==1 ) {
2377 					{
2378 					setState(430);
2379 					_errHandler.sync(this);
2380 					switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
2381 					case 1:
2382 						{
2383 						setState(393);
2384 						htmlTag();
2385 						}
2386 						break;
2387 					case 2:
2388 						{
2389 						setState(394);
2390 						singletonElement();
2391 						}
2392 						break;
2393 					case 3:
2394 						{
2395 						setState(395);
2396 						paragraph();
2397 						}
2398 						break;
2399 					case 4:
2400 						{
2401 						setState(396);
2402 						tr();
2403 						}
2404 						break;
2405 					case 5:
2406 						{
2407 						setState(397);
2408 						td();
2409 						}
2410 						break;
2411 					case 6:
2412 						{
2413 						setState(398);
2414 						th();
2415 						}
2416 						break;
2417 					case 7:
2418 						{
2419 						setState(399);
2420 						body();
2421 						}
2422 						break;
2423 					case 8:
2424 						{
2425 						setState(400);
2426 						colgroup();
2427 						}
2428 						break;
2429 					case 9:
2430 						{
2431 						setState(401);
2432 						dd();
2433 						}
2434 						break;
2435 					case 10:
2436 						{
2437 						setState(402);
2438 						dt();
2439 						}
2440 						break;
2441 					case 11:
2442 						{
2443 						setState(403);
2444 						head();
2445 						}
2446 						break;
2447 					case 12:
2448 						{
2449 						setState(404);
2450 						html();
2451 						}
2452 						break;
2453 					case 13:
2454 						{
2455 						setState(405);
2456 						option();
2457 						}
2458 						break;
2459 					case 14:
2460 						{
2461 						setState(406);
2462 						tbody();
2463 						}
2464 						break;
2465 					case 15:
2466 						{
2467 						setState(407);
2468 						thead();
2469 						}
2470 						break;
2471 					case 16:
2472 						{
2473 						setState(408);
2474 						tfoot();
2475 						}
2476 						break;
2477 					case 17:
2478 						{
2479 						setState(409);
2480 						pTagStart(true);
2481 						}
2482 						break;
2483 					case 18:
2484 						{
2485 						setState(410);
2486 						trTagStart(true);
2487 						}
2488 						break;
2489 					case 19:
2490 						{
2491 						setState(411);
2492 						tdTagStart(true);
2493 						}
2494 						break;
2495 					case 20:
2496 						{
2497 						setState(412);
2498 						thTagStart(true);
2499 						}
2500 						break;
2501 					case 21:
2502 						{
2503 						setState(413);
2504 						bodyTagStart(true);
2505 						}
2506 						break;
2507 					case 22:
2508 						{
2509 						setState(414);
2510 						colgroupTagStart(true);
2511 						}
2512 						break;
2513 					case 23:
2514 						{
2515 						setState(415);
2516 						ddTagStart(true);
2517 						}
2518 						break;
2519 					case 24:
2520 						{
2521 						setState(416);
2522 						dtTagStart(true);
2523 						}
2524 						break;
2525 					case 25:
2526 						{
2527 						setState(417);
2528 						headTagStart(true);
2529 						}
2530 						break;
2531 					case 26:
2532 						{
2533 						setState(418);
2534 						htmlTagStart(true);
2535 						}
2536 						break;
2537 					case 27:
2538 						{
2539 						setState(419);
2540 						optionTagStart(true);
2541 						}
2542 						break;
2543 					case 28:
2544 						{
2545 						setState(420);
2546 						tbodyTagStart(true);
2547 						}
2548 						break;
2549 					case 29:
2550 						{
2551 						setState(421);
2552 						theadTagStart(true);
2553 						}
2554 						break;
2555 					case 30:
2556 						{
2557 						setState(422);
2558 						tfootTagStart(true);
2559 						}
2560 						break;
2561 					case 31:
2562 						{
2563 						{
2564 						setState(423);
2565 						if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
2566 						setState(424);
2567 						match(LEADING_ASTERISK);
2568 						}
2569 						}
2570 						break;
2571 					case 32:
2572 						{
2573 						setState(425);
2574 						htmlComment();
2575 						}
2576 						break;
2577 					case 33:
2578 						{
2579 						setState(426);
2580 						match(CDATA);
2581 						}
2582 						break;
2583 					case 34:
2584 						{
2585 						setState(427);
2586 						match(NEWLINE);
2587 						}
2588 						break;
2589 					case 35:
2590 						{
2591 						setState(428);
2592 						text();
2593 						}
2594 						break;
2595 					case 36:
2596 						{
2597 						setState(429);
2598 						javadocInlineTag();
2599 						}
2600 						break;
2601 					}
2602 					} 
2603 				}
2604 				setState(434);
2605 				_errHandler.sync(this);
2606 				_alt = getInterpreter().adaptivePredict(_input,23,_ctx);
2607 			}
2608 			setState(435);
2609 			liTagEnd();
2610 			}
2611 		}
2612 		catch (RecognitionException re) {
2613 			_localctx.exception = re;
2614 			_errHandler.reportError(this, re);
2615 			_errHandler.recover(this, re);
2616 		}
2617 		finally {
2618 			exitRule();
2619 		}
2620 		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 		TrTagStartContext _localctx = new TrTagStartContext(_ctx, getState(), isNonTight);
2656 		enterRule(_localctx, 24, RULE_trTagStart);
2657 		int _la;
2658 		try {
2659 			enterOuterAlt(_localctx, 1);
2660 			{
2661 			setState(437);
2662 			match(START);
2663 			setState(438);
2664 			match(TR_HTML_TAG_NAME);
2665 			setState(445);
2666 			_errHandler.sync(this);
2667 			_la = _input.LA(1);
2668 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2669 				{
2670 				setState(443);
2671 				_errHandler.sync(this);
2672 				switch (_input.LA(1)) {
2673 				case HTML_TAG_NAME:
2674 					{
2675 					setState(439);
2676 					attribute();
2677 					}
2678 					break;
2679 				case NEWLINE:
2680 					{
2681 					setState(440);
2682 					match(NEWLINE);
2683 					}
2684 					break;
2685 				case LEADING_ASTERISK:
2686 					{
2687 					setState(441);
2688 					match(LEADING_ASTERISK);
2689 					}
2690 					break;
2691 				case WS:
2692 					{
2693 					setState(442);
2694 					match(WS);
2695 					}
2696 					break;
2697 				default:
2698 					throw new NoViableAltException(this);
2699 				}
2700 				}
2701 				setState(447);
2702 				_errHandler.sync(this);
2703 				_la = _input.LA(1);
2704 			}
2705 			setState(448);
2706 			match(END);
2707 			}
2708 			_ctx.stop = _input.LT(-1);
2709 
2710 			    if (isNonTight && nonTightTagStartContext == null) {
2711 			        nonTightTagStartContext = _localctx;
2712 			    }
2713 
2714 		}
2715 		catch (RecognitionException re) {
2716 			_localctx.exception = re;
2717 			_errHandler.reportError(this, re);
2718 			_errHandler.recover(this, re);
2719 		}
2720 		finally {
2721 			exitRule();
2722 		}
2723 		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 		TrTagEndContext _localctx = new TrTagEndContext(_ctx, getState());
2751 		enterRule(_localctx, 26, RULE_trTagEnd);
2752 		int _la;
2753 		try {
2754 			enterOuterAlt(_localctx, 1);
2755 			{
2756 			setState(450);
2757 			match(START);
2758 			setState(451);
2759 			match(SLASH);
2760 			setState(452);
2761 			match(TR_HTML_TAG_NAME);
2762 			setState(456);
2763 			_errHandler.sync(this);
2764 			_la = _input.LA(1);
2765 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
2766 				{
2767 				{
2768 				setState(453);
2769 				_la = _input.LA(1);
2770 				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
2771 				_errHandler.recoverInline(this);
2772 				}
2773 				else {
2774 					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
2775 					_errHandler.reportMatch(this);
2776 					consume();
2777 				}
2778 				}
2779 				}
2780 				setState(458);
2781 				_errHandler.sync(this);
2782 				_la = _input.LA(1);
2783 			}
2784 			setState(459);
2785 			match(END);
2786 			}
2787 		}
2788 		catch (RecognitionException re) {
2789 			_localctx.exception = re;
2790 			_errHandler.reportError(this, re);
2791 			_errHandler.recover(this, re);
2792 		}
2793 		finally {
2794 			exitRule();
2795 		}
2796 		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 		TrContext _localctx = new TrContext(_ctx, getState());
3024 		enterRule(_localctx, 28, RULE_tr);
3025 		try {
3026 			int _alt;
3027 			enterOuterAlt(_localctx, 1);
3028 			{
3029 			setState(461);
3030 			trTagStart(false);
3031 			setState(501);
3032 			_errHandler.sync(this);
3033 			_alt = getInterpreter().adaptivePredict(_input,28,_ctx);
3034 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3035 				if ( _alt==1 ) {
3036 					{
3037 					setState(499);
3038 					_errHandler.sync(this);
3039 					switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
3040 					case 1:
3041 						{
3042 						setState(462);
3043 						htmlTag();
3044 						}
3045 						break;
3046 					case 2:
3047 						{
3048 						setState(463);
3049 						singletonElement();
3050 						}
3051 						break;
3052 					case 3:
3053 						{
3054 						setState(464);
3055 						paragraph();
3056 						}
3057 						break;
3058 					case 4:
3059 						{
3060 						setState(465);
3061 						li();
3062 						}
3063 						break;
3064 					case 5:
3065 						{
3066 						setState(466);
3067 						td();
3068 						}
3069 						break;
3070 					case 6:
3071 						{
3072 						setState(467);
3073 						th();
3074 						}
3075 						break;
3076 					case 7:
3077 						{
3078 						setState(468);
3079 						body();
3080 						}
3081 						break;
3082 					case 8:
3083 						{
3084 						setState(469);
3085 						colgroup();
3086 						}
3087 						break;
3088 					case 9:
3089 						{
3090 						setState(470);
3091 						dd();
3092 						}
3093 						break;
3094 					case 10:
3095 						{
3096 						setState(471);
3097 						dt();
3098 						}
3099 						break;
3100 					case 11:
3101 						{
3102 						setState(472);
3103 						head();
3104 						}
3105 						break;
3106 					case 12:
3107 						{
3108 						setState(473);
3109 						html();
3110 						}
3111 						break;
3112 					case 13:
3113 						{
3114 						setState(474);
3115 						option();
3116 						}
3117 						break;
3118 					case 14:
3119 						{
3120 						setState(475);
3121 						tbody();
3122 						}
3123 						break;
3124 					case 15:
3125 						{
3126 						setState(476);
3127 						thead();
3128 						}
3129 						break;
3130 					case 16:
3131 						{
3132 						setState(477);
3133 						tfoot();
3134 						}
3135 						break;
3136 					case 17:
3137 						{
3138 						setState(478);
3139 						pTagStart(true);
3140 						}
3141 						break;
3142 					case 18:
3143 						{
3144 						setState(479);
3145 						liTagStart(true);
3146 						}
3147 						break;
3148 					case 19:
3149 						{
3150 						setState(480);
3151 						tdTagStart(true);
3152 						}
3153 						break;
3154 					case 20:
3155 						{
3156 						setState(481);
3157 						thTagStart(true);
3158 						}
3159 						break;
3160 					case 21:
3161 						{
3162 						setState(482);
3163 						bodyTagStart(true);
3164 						}
3165 						break;
3166 					case 22:
3167 						{
3168 						setState(483);
3169 						colgroupTagStart(true);
3170 						}
3171 						break;
3172 					case 23:
3173 						{
3174 						setState(484);
3175 						ddTagStart(true);
3176 						}
3177 						break;
3178 					case 24:
3179 						{
3180 						setState(485);
3181 						dtTagStart(true);
3182 						}
3183 						break;
3184 					case 25:
3185 						{
3186 						setState(486);
3187 						headTagStart(true);
3188 						}
3189 						break;
3190 					case 26:
3191 						{
3192 						setState(487);
3193 						htmlTagStart(true);
3194 						}
3195 						break;
3196 					case 27:
3197 						{
3198 						setState(488);
3199 						optionTagStart(true);
3200 						}
3201 						break;
3202 					case 28:
3203 						{
3204 						setState(489);
3205 						tbodyTagStart(true);
3206 						}
3207 						break;
3208 					case 29:
3209 						{
3210 						setState(490);
3211 						theadTagStart(true);
3212 						}
3213 						break;
3214 					case 30:
3215 						{
3216 						setState(491);
3217 						tfootTagStart(true);
3218 						}
3219 						break;
3220 					case 31:
3221 						{
3222 						{
3223 						setState(492);
3224 						if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
3225 						setState(493);
3226 						match(LEADING_ASTERISK);
3227 						}
3228 						}
3229 						break;
3230 					case 32:
3231 						{
3232 						setState(494);
3233 						htmlComment();
3234 						}
3235 						break;
3236 					case 33:
3237 						{
3238 						setState(495);
3239 						match(CDATA);
3240 						}
3241 						break;
3242 					case 34:
3243 						{
3244 						setState(496);
3245 						match(NEWLINE);
3246 						}
3247 						break;
3248 					case 35:
3249 						{
3250 						setState(497);
3251 						text();
3252 						}
3253 						break;
3254 					case 36:
3255 						{
3256 						setState(498);
3257 						javadocInlineTag();
3258 						}
3259 						break;
3260 					}
3261 					} 
3262 				}
3263 				setState(503);
3264 				_errHandler.sync(this);
3265 				_alt = getInterpreter().adaptivePredict(_input,28,_ctx);
3266 			}
3267 			setState(504);
3268 			trTagEnd();
3269 			}
3270 		}
3271 		catch (RecognitionException re) {
3272 			_localctx.exception = re;
3273 			_errHandler.reportError(this, re);
3274 			_errHandler.recover(this, re);
3275 		}
3276 		finally {
3277 			exitRule();
3278 		}
3279 		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 		TdTagStartContext _localctx = new TdTagStartContext(_ctx, getState(), isNonTight);
3315 		enterRule(_localctx, 30, RULE_tdTagStart);
3316 		int _la;
3317 		try {
3318 			enterOuterAlt(_localctx, 1);
3319 			{
3320 			setState(506);
3321 			match(START);
3322 			setState(507);
3323 			match(TD_HTML_TAG_NAME);
3324 			setState(514);
3325 			_errHandler.sync(this);
3326 			_la = _input.LA(1);
3327 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
3328 				{
3329 				setState(512);
3330 				_errHandler.sync(this);
3331 				switch (_input.LA(1)) {
3332 				case HTML_TAG_NAME:
3333 					{
3334 					setState(508);
3335 					attribute();
3336 					}
3337 					break;
3338 				case NEWLINE:
3339 					{
3340 					setState(509);
3341 					match(NEWLINE);
3342 					}
3343 					break;
3344 				case LEADING_ASTERISK:
3345 					{
3346 					setState(510);
3347 					match(LEADING_ASTERISK);
3348 					}
3349 					break;
3350 				case WS:
3351 					{
3352 					setState(511);
3353 					match(WS);
3354 					}
3355 					break;
3356 				default:
3357 					throw new NoViableAltException(this);
3358 				}
3359 				}
3360 				setState(516);
3361 				_errHandler.sync(this);
3362 				_la = _input.LA(1);
3363 			}
3364 			setState(517);
3365 			match(END);
3366 			}
3367 			_ctx.stop = _input.LT(-1);
3368 
3369 			    if (isNonTight && nonTightTagStartContext == null) {
3370 			        nonTightTagStartContext = _localctx;
3371 			    }
3372 
3373 		}
3374 		catch (RecognitionException re) {
3375 			_localctx.exception = re;
3376 			_errHandler.reportError(this, re);
3377 			_errHandler.recover(this, re);
3378 		}
3379 		finally {
3380 			exitRule();
3381 		}
3382 		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 		TdTagEndContext _localctx = new TdTagEndContext(_ctx, getState());
3410 		enterRule(_localctx, 32, RULE_tdTagEnd);
3411 		int _la;
3412 		try {
3413 			enterOuterAlt(_localctx, 1);
3414 			{
3415 			setState(519);
3416 			match(START);
3417 			setState(520);
3418 			match(SLASH);
3419 			setState(521);
3420 			match(TD_HTML_TAG_NAME);
3421 			setState(525);
3422 			_errHandler.sync(this);
3423 			_la = _input.LA(1);
3424 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
3425 				{
3426 				{
3427 				setState(522);
3428 				_la = _input.LA(1);
3429 				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
3430 				_errHandler.recoverInline(this);
3431 				}
3432 				else {
3433 					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
3434 					_errHandler.reportMatch(this);
3435 					consume();
3436 				}
3437 				}
3438 				}
3439 				setState(527);
3440 				_errHandler.sync(this);
3441 				_la = _input.LA(1);
3442 			}
3443 			setState(528);
3444 			match(END);
3445 			}
3446 		}
3447 		catch (RecognitionException re) {
3448 			_localctx.exception = re;
3449 			_errHandler.reportError(this, re);
3450 			_errHandler.recover(this, re);
3451 		}
3452 		finally {
3453 			exitRule();
3454 		}
3455 		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 		TdContext _localctx = new TdContext(_ctx, getState());
3680 		enterRule(_localctx, 34, RULE_td);
3681 		try {
3682 			int _alt;
3683 			enterOuterAlt(_localctx, 1);
3684 			{
3685 			setState(530);
3686 			tdTagStart(false);
3687 			setState(570);
3688 			_errHandler.sync(this);
3689 			_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
3690 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3691 				if ( _alt==1 ) {
3692 					{
3693 					setState(568);
3694 					_errHandler.sync(this);
3695 					switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
3696 					case 1:
3697 						{
3698 						setState(531);
3699 						htmlTag();
3700 						}
3701 						break;
3702 					case 2:
3703 						{
3704 						setState(532);
3705 						singletonElement();
3706 						}
3707 						break;
3708 					case 3:
3709 						{
3710 						setState(533);
3711 						paragraph();
3712 						}
3713 						break;
3714 					case 4:
3715 						{
3716 						setState(534);
3717 						li();
3718 						}
3719 						break;
3720 					case 5:
3721 						{
3722 						setState(535);
3723 						tr();
3724 						}
3725 						break;
3726 					case 6:
3727 						{
3728 						setState(536);
3729 						th();
3730 						}
3731 						break;
3732 					case 7:
3733 						{
3734 						setState(537);
3735 						body();
3736 						}
3737 						break;
3738 					case 8:
3739 						{
3740 						setState(538);
3741 						colgroup();
3742 						}
3743 						break;
3744 					case 9:
3745 						{
3746 						setState(539);
3747 						dd();
3748 						}
3749 						break;
3750 					case 10:
3751 						{
3752 						setState(540);
3753 						dt();
3754 						}
3755 						break;
3756 					case 11:
3757 						{
3758 						setState(541);
3759 						head();
3760 						}
3761 						break;
3762 					case 12:
3763 						{
3764 						setState(542);
3765 						html();
3766 						}
3767 						break;
3768 					case 13:
3769 						{
3770 						setState(543);
3771 						option();
3772 						}
3773 						break;
3774 					case 14:
3775 						{
3776 						setState(544);
3777 						tbody();
3778 						}
3779 						break;
3780 					case 15:
3781 						{
3782 						setState(545);
3783 						thead();
3784 						}
3785 						break;
3786 					case 16:
3787 						{
3788 						setState(546);
3789 						tfoot();
3790 						}
3791 						break;
3792 					case 17:
3793 						{
3794 						setState(547);
3795 						pTagStart(true);
3796 						}
3797 						break;
3798 					case 18:
3799 						{
3800 						setState(548);
3801 						liTagStart(true);
3802 						}
3803 						break;
3804 					case 19:
3805 						{
3806 						setState(549);
3807 						tdTagStart(true);
3808 						}
3809 						break;
3810 					case 20:
3811 						{
3812 						setState(550);
3813 						thTagStart(true);
3814 						}
3815 						break;
3816 					case 21:
3817 						{
3818 						setState(551);
3819 						bodyTagStart(true);
3820 						}
3821 						break;
3822 					case 22:
3823 						{
3824 						setState(552);
3825 						colgroupTagStart(true);
3826 						}
3827 						break;
3828 					case 23:
3829 						{
3830 						setState(553);
3831 						ddTagStart(true);
3832 						}
3833 						break;
3834 					case 24:
3835 						{
3836 						setState(554);
3837 						dtTagStart(true);
3838 						}
3839 						break;
3840 					case 25:
3841 						{
3842 						setState(555);
3843 						headTagStart(true);
3844 						}
3845 						break;
3846 					case 26:
3847 						{
3848 						setState(556);
3849 						htmlTagStart(true);
3850 						}
3851 						break;
3852 					case 27:
3853 						{
3854 						setState(557);
3855 						optionTagStart(true);
3856 						}
3857 						break;
3858 					case 28:
3859 						{
3860 						setState(558);
3861 						tbodyTagStart(true);
3862 						}
3863 						break;
3864 					case 29:
3865 						{
3866 						setState(559);
3867 						theadTagStart(true);
3868 						}
3869 						break;
3870 					case 30:
3871 						{
3872 						setState(560);
3873 						tfootTagStart(true);
3874 						}
3875 						break;
3876 					case 31:
3877 						{
3878 						{
3879 						setState(561);
3880 						if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
3881 						setState(562);
3882 						match(LEADING_ASTERISK);
3883 						}
3884 						}
3885 						break;
3886 					case 32:
3887 						{
3888 						setState(563);
3889 						htmlComment();
3890 						}
3891 						break;
3892 					case 33:
3893 						{
3894 						setState(564);
3895 						match(CDATA);
3896 						}
3897 						break;
3898 					case 34:
3899 						{
3900 						setState(565);
3901 						match(NEWLINE);
3902 						}
3903 						break;
3904 					case 35:
3905 						{
3906 						setState(566);
3907 						text();
3908 						}
3909 						break;
3910 					case 36:
3911 						{
3912 						setState(567);
3913 						javadocInlineTag();
3914 						}
3915 						break;
3916 					}
3917 					} 
3918 				}
3919 				setState(572);
3920 				_errHandler.sync(this);
3921 				_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
3922 			}
3923 			setState(573);
3924 			tdTagEnd();
3925 			}
3926 		}
3927 		catch (RecognitionException re) {
3928 			_localctx.exception = re;
3929 			_errHandler.reportError(this, re);
3930 			_errHandler.recover(this, re);
3931 		}
3932 		finally {
3933 			exitRule();
3934 		}
3935 		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 		ThTagStartContext _localctx = new ThTagStartContext(_ctx, getState(), isNonTight);
3971 		enterRule(_localctx, 36, RULE_thTagStart);
3972 		int _la;
3973 		try {
3974 			enterOuterAlt(_localctx, 1);
3975 			{
3976 			setState(575);
3977 			match(START);
3978 			setState(576);
3979 			match(TH_HTML_TAG_NAME);
3980 			setState(583);
3981 			_errHandler.sync(this);
3982 			_la = _input.LA(1);
3983 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
3984 				{
3985 				setState(581);
3986 				_errHandler.sync(this);
3987 				switch (_input.LA(1)) {
3988 				case HTML_TAG_NAME:
3989 					{
3990 					setState(577);
3991 					attribute();
3992 					}
3993 					break;
3994 				case NEWLINE:
3995 					{
3996 					setState(578);
3997 					match(NEWLINE);
3998 					}
3999 					break;
4000 				case LEADING_ASTERISK:
4001 					{
4002 					setState(579);
4003 					match(LEADING_ASTERISK);
4004 					}
4005 					break;
4006 				case WS:
4007 					{
4008 					setState(580);
4009 					match(WS);
4010 					}
4011 					break;
4012 				default:
4013 					throw new NoViableAltException(this);
4014 				}
4015 				}
4016 				setState(585);
4017 				_errHandler.sync(this);
4018 				_la = _input.LA(1);
4019 			}
4020 			setState(586);
4021 			match(END);
4022 			}
4023 			_ctx.stop = _input.LT(-1);
4024 
4025 			    if (isNonTight && nonTightTagStartContext == null) {
4026 			        nonTightTagStartContext = _localctx;
4027 			    }
4028 
4029 		}
4030 		catch (RecognitionException re) {
4031 			_localctx.exception = re;
4032 			_errHandler.reportError(this, re);
4033 			_errHandler.recover(this, re);
4034 		}
4035 		finally {
4036 			exitRule();
4037 		}
4038 		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 		ThTagEndContext _localctx = new ThTagEndContext(_ctx, getState());
4066 		enterRule(_localctx, 38, RULE_thTagEnd);
4067 		int _la;
4068 		try {
4069 			enterOuterAlt(_localctx, 1);
4070 			{
4071 			setState(588);
4072 			match(START);
4073 			setState(589);
4074 			match(SLASH);
4075 			setState(590);
4076 			match(TH_HTML_TAG_NAME);
4077 			setState(594);
4078 			_errHandler.sync(this);
4079 			_la = _input.LA(1);
4080 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
4081 				{
4082 				{
4083 				setState(591);
4084 				_la = _input.LA(1);
4085 				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
4086 				_errHandler.recoverInline(this);
4087 				}
4088 				else {
4089 					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
4090 					_errHandler.reportMatch(this);
4091 					consume();
4092 				}
4093 				}
4094 				}
4095 				setState(596);
4096 				_errHandler.sync(this);
4097 				_la = _input.LA(1);
4098 			}
4099 			setState(597);
4100 			match(END);
4101 			}
4102 		}
4103 		catch (RecognitionException re) {
4104 			_localctx.exception = re;
4105 			_errHandler.reportError(this, re);
4106 			_errHandler.recover(this, re);
4107 		}
4108 		finally {
4109 			exitRule();
4110 		}
4111 		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 		ThContext _localctx = new ThContext(_ctx, getState());
4339 		enterRule(_localctx, 40, RULE_th);
4340 		try {
4341 			int _alt;
4342 			enterOuterAlt(_localctx, 1);
4343 			{
4344 			setState(599);
4345 			thTagStart(false);
4346 			setState(639);
4347 			_errHandler.sync(this);
4348 			_alt = getInterpreter().adaptivePredict(_input,38,_ctx);
4349 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
4350 				if ( _alt==1 ) {
4351 					{
4352 					setState(637);
4353 					_errHandler.sync(this);
4354 					switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
4355 					case 1:
4356 						{
4357 						setState(600);
4358 						htmlTag();
4359 						}
4360 						break;
4361 					case 2:
4362 						{
4363 						setState(601);
4364 						singletonElement();
4365 						}
4366 						break;
4367 					case 3:
4368 						{
4369 						setState(602);
4370 						paragraph();
4371 						}
4372 						break;
4373 					case 4:
4374 						{
4375 						setState(603);
4376 						li();
4377 						}
4378 						break;
4379 					case 5:
4380 						{
4381 						setState(604);
4382 						tr();
4383 						}
4384 						break;
4385 					case 6:
4386 						{
4387 						setState(605);
4388 						td();
4389 						}
4390 						break;
4391 					case 7:
4392 						{
4393 						setState(606);
4394 						body();
4395 						}
4396 						break;
4397 					case 8:
4398 						{
4399 						setState(607);
4400 						colgroup();
4401 						}
4402 						break;
4403 					case 9:
4404 						{
4405 						setState(608);
4406 						dd();
4407 						}
4408 						break;
4409 					case 10:
4410 						{
4411 						setState(609);
4412 						dt();
4413 						}
4414 						break;
4415 					case 11:
4416 						{
4417 						setState(610);
4418 						head();
4419 						}
4420 						break;
4421 					case 12:
4422 						{
4423 						setState(611);
4424 						html();
4425 						}
4426 						break;
4427 					case 13:
4428 						{
4429 						setState(612);
4430 						option();
4431 						}
4432 						break;
4433 					case 14:
4434 						{
4435 						setState(613);
4436 						tbody();
4437 						}
4438 						break;
4439 					case 15:
4440 						{
4441 						setState(614);
4442 						thead();
4443 						}
4444 						break;
4445 					case 16:
4446 						{
4447 						setState(615);
4448 						tfoot();
4449 						}
4450 						break;
4451 					case 17:
4452 						{
4453 						setState(616);
4454 						pTagStart(true);
4455 						}
4456 						break;
4457 					case 18:
4458 						{
4459 						setState(617);
4460 						liTagStart(true);
4461 						}
4462 						break;
4463 					case 19:
4464 						{
4465 						setState(618);
4466 						trTagStart(true);
4467 						}
4468 						break;
4469 					case 20:
4470 						{
4471 						setState(619);
4472 						tdTagStart(true);
4473 						}
4474 						break;
4475 					case 21:
4476 						{
4477 						setState(620);
4478 						bodyTagStart(true);
4479 						}
4480 						break;
4481 					case 22:
4482 						{
4483 						setState(621);
4484 						colgroupTagStart(true);
4485 						}
4486 						break;
4487 					case 23:
4488 						{
4489 						setState(622);
4490 						ddTagStart(true);
4491 						}
4492 						break;
4493 					case 24:
4494 						{
4495 						setState(623);
4496 						dtTagStart(true);
4497 						}
4498 						break;
4499 					case 25:
4500 						{
4501 						setState(624);
4502 						headTagStart(true);
4503 						}
4504 						break;
4505 					case 26:
4506 						{
4507 						setState(625);
4508 						htmlTagStart(true);
4509 						}
4510 						break;
4511 					case 27:
4512 						{
4513 						setState(626);
4514 						optionTagStart(true);
4515 						}
4516 						break;
4517 					case 28:
4518 						{
4519 						setState(627);
4520 						tbodyTagStart(true);
4521 						}
4522 						break;
4523 					case 29:
4524 						{
4525 						setState(628);
4526 						theadTagStart(true);
4527 						}
4528 						break;
4529 					case 30:
4530 						{
4531 						setState(629);
4532 						tfootTagStart(true);
4533 						}
4534 						break;
4535 					case 31:
4536 						{
4537 						{
4538 						setState(630);
4539 						if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
4540 						setState(631);
4541 						match(LEADING_ASTERISK);
4542 						}
4543 						}
4544 						break;
4545 					case 32:
4546 						{
4547 						setState(632);
4548 						htmlComment();
4549 						}
4550 						break;
4551 					case 33:
4552 						{
4553 						setState(633);
4554 						match(CDATA);
4555 						}
4556 						break;
4557 					case 34:
4558 						{
4559 						setState(634);
4560 						match(NEWLINE);
4561 						}
4562 						break;
4563 					case 35:
4564 						{
4565 						setState(635);
4566 						text();
4567 						}
4568 						break;
4569 					case 36:
4570 						{
4571 						setState(636);
4572 						javadocInlineTag();
4573 						}
4574 						break;
4575 					}
4576 					} 
4577 				}
4578 				setState(641);
4579 				_errHandler.sync(this);
4580 				_alt = getInterpreter().adaptivePredict(_input,38,_ctx);
4581 			}
4582 			setState(642);
4583 			thTagEnd();
4584 			}
4585 		}
4586 		catch (RecognitionException re) {
4587 			_localctx.exception = re;
4588 			_errHandler.reportError(this, re);
4589 			_errHandler.recover(this, re);
4590 		}
4591 		finally {
4592 			exitRule();
4593 		}
4594 		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 		BodyTagStartContext _localctx = new BodyTagStartContext(_ctx, getState(), isNonTight);
4630 		enterRule(_localctx, 42, RULE_bodyTagStart);
4631 		int _la;
4632 		try {
4633 			enterOuterAlt(_localctx, 1);
4634 			{
4635 			setState(644);
4636 			match(START);
4637 			setState(645);
4638 			match(BODY_HTML_TAG_NAME);
4639 			setState(652);
4640 			_errHandler.sync(this);
4641 			_la = _input.LA(1);
4642 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
4643 				{
4644 				setState(650);
4645 				_errHandler.sync(this);
4646 				switch (_input.LA(1)) {
4647 				case HTML_TAG_NAME:
4648 					{
4649 					setState(646);
4650 					attribute();
4651 					}
4652 					break;
4653 				case NEWLINE:
4654 					{
4655 					setState(647);
4656 					match(NEWLINE);
4657 					}
4658 					break;
4659 				case LEADING_ASTERISK:
4660 					{
4661 					setState(648);
4662 					match(LEADING_ASTERISK);
4663 					}
4664 					break;
4665 				case WS:
4666 					{
4667 					setState(649);
4668 					match(WS);
4669 					}
4670 					break;
4671 				default:
4672 					throw new NoViableAltException(this);
4673 				}
4674 				}
4675 				setState(654);
4676 				_errHandler.sync(this);
4677 				_la = _input.LA(1);
4678 			}
4679 			setState(655);
4680 			match(END);
4681 			}
4682 			_ctx.stop = _input.LT(-1);
4683 
4684 			    if (isNonTight && nonTightTagStartContext == null) {
4685 			        nonTightTagStartContext = _localctx;
4686 			    }
4687 
4688 		}
4689 		catch (RecognitionException re) {
4690 			_localctx.exception = re;
4691 			_errHandler.reportError(this, re);
4692 			_errHandler.recover(this, re);
4693 		}
4694 		finally {
4695 			exitRule();
4696 		}
4697 		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 		BodyTagEndContext _localctx = new BodyTagEndContext(_ctx, getState());
4725 		enterRule(_localctx, 44, RULE_bodyTagEnd);
4726 		int _la;
4727 		try {
4728 			enterOuterAlt(_localctx, 1);
4729 			{
4730 			setState(657);
4731 			match(START);
4732 			setState(658);
4733 			match(SLASH);
4734 			setState(659);
4735 			match(BODY_HTML_TAG_NAME);
4736 			setState(663);
4737 			_errHandler.sync(this);
4738 			_la = _input.LA(1);
4739 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
4740 				{
4741 				{
4742 				setState(660);
4743 				_la = _input.LA(1);
4744 				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
4745 				_errHandler.recoverInline(this);
4746 				}
4747 				else {
4748 					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
4749 					_errHandler.reportMatch(this);
4750 					consume();
4751 				}
4752 				}
4753 				}
4754 				setState(665);
4755 				_errHandler.sync(this);
4756 				_la = _input.LA(1);
4757 			}
4758 			setState(666);
4759 			match(END);
4760 			}
4761 		}
4762 		catch (RecognitionException re) {
4763 			_localctx.exception = re;
4764 			_errHandler.reportError(this, re);
4765 			_errHandler.recover(this, re);
4766 		}
4767 		finally {
4768 			exitRule();
4769 		}
4770 		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 		}
4822 		public List<ColgroupContext> colgroup() {
4823 			return getRuleContexts(ColgroupContext.class);
4824 		}
4825 		public ColgroupContext colgroup(int i) {
4826 			return getRuleContext(ColgroupContext.class,i);
4827 		}
4828 		public List<DdContext> dd() {
4829 			return getRuleContexts(DdContext.class);
4830 		}
4831 		public DdContext dd(int i) {
4832 			return getRuleContext(DdContext.class,i);
4833 		}
4834 		public List<DtContext> dt() {
4835 			return getRuleContexts(DtContext.class);
4836 		}
4837 		public DtContext dt(int i) {
4838 			return getRuleContext(DtContext.class,i);
4839 		}
4840 		public List<HeadContext> head() {
4841 			return getRuleContexts(HeadContext.class);
4842 		}
4843 		public HeadContext head(int i) {
4844 			return getRuleContext(HeadContext.class,i);
4845 		}
4846 		public List<HtmlContext> html() {
4847 			return getRuleContexts(HtmlContext.class);
4848 		}
4849 		public HtmlContext html(int i) {
4850 			return getRuleContext(HtmlContext.class,i);
4851 		}
4852 		public List<OptionContext> option() {
4853 			return getRuleContexts(OptionContext.class);
4854 		}
4855 		public OptionContext option(int i) {
4856 			return getRuleContext(OptionContext.class,i);
4857 		}
4858 		public List<TbodyContext> tbody() {
4859 			return getRuleContexts(TbodyContext.class);
4860 		}
4861 		public TbodyContext tbody(int i) {
4862 			return getRuleContext(TbodyContext.class,i);
4863 		}
4864 		public List<TheadContext> thead() {
4865 			return getRuleContexts(TheadContext.class);
4866 		}
4867 		public TheadContext thead(int i) {
4868 			return getRuleContext(TheadContext.class,i);
4869 		}
4870 		public List<TfootContext> tfoot() {
4871 			return getRuleContexts(TfootContext.class);
4872 		}
4873 		public TfootContext tfoot(int i) {
4874 			return getRuleContext(TfootContext.class,i);
4875 		}
4876 		public List<PTagStartContext> pTagStart() {
4877 			return getRuleContexts(PTagStartContext.class);
4878 		}
4879 		public PTagStartContext pTagStart(int i) {
4880 			return getRuleContext(PTagStartContext.class,i);
4881 		}
4882 		public List<LiTagStartContext> liTagStart() {
4883 			return getRuleContexts(LiTagStartContext.class);
4884 		}
4885 		public LiTagStartContext liTagStart(int i) {
4886 			return getRuleContext(LiTagStartContext.class,i);
4887 		}
4888 		public List<TrTagStartContext> trTagStart() {
4889 			return getRuleContexts(TrTagStartContext.class);
4890 		}
4891 		public TrTagStartContext trTagStart(int i) {
4892 			return getRuleContext(TrTagStartContext.class,i);
4893 		}
4894 		public List<TdTagStartContext> tdTagStart() {
4895 			return getRuleContexts(TdTagStartContext.class);
4896 		}
4897 		public TdTagStartContext tdTagStart(int i) {
4898 			return getRuleContext(TdTagStartContext.class,i);
4899 		}
4900 		public List<ThTagStartContext> thTagStart() {
4901 			return getRuleContexts(ThTagStartContext.class);
4902 		}
4903 		public ThTagStartContext thTagStart(int i) {
4904 			return getRuleContext(ThTagStartContext.class,i);
4905 		}
4906 		public List<ColgroupTagStartContext> colgroupTagStart() {
4907 			return getRuleContexts(ColgroupTagStartContext.class);
4908 		}
4909 		public ColgroupTagStartContext colgroupTagStart(int i) {
4910 			return getRuleContext(ColgroupTagStartContext.class,i);
4911 		}
4912 		public List<DdTagStartContext> ddTagStart() {
4913 			return getRuleContexts(DdTagStartContext.class);
4914 		}
4915 		public DdTagStartContext ddTagStart(int i) {
4916 			return getRuleContext(DdTagStartContext.class,i);
4917 		}
4918 		public List<DtTagStartContext> dtTagStart() {
4919 			return getRuleContexts(DtTagStartContext.class);
4920 		}
4921 		public DtTagStartContext dtTagStart(int i) {
4922 			return getRuleContext(DtTagStartContext.class,i);
4923 		}
4924 		public List<HeadTagStartContext> headTagStart() {
4925 			return getRuleContexts(HeadTagStartContext.class);
4926 		}
4927 		public HeadTagStartContext headTagStart(int i) {
4928 			return getRuleContext(HeadTagStartContext.class,i);
4929 		}
4930 		public List<HtmlTagStartContext> htmlTagStart() {
4931 			return getRuleContexts(HtmlTagStartContext.class);
4932 		}
4933 		public HtmlTagStartContext htmlTagStart(int i) {
4934 			return getRuleContext(HtmlTagStartContext.class,i);
4935 		}
4936 		public List<OptionTagStartContext> optionTagStart() {
4937 			return getRuleContexts(OptionTagStartContext.class);
4938 		}
4939 		public OptionTagStartContext optionTagStart(int i) {
4940 			return getRuleContext(OptionTagStartContext.class,i);
4941 		}
4942 		public List<TbodyTagStartContext> tbodyTagStart() {
4943 			return getRuleContexts(TbodyTagStartContext.class);
4944 		}
4945 		public TbodyTagStartContext tbodyTagStart(int i) {
4946 			return getRuleContext(TbodyTagStartContext.class,i);
4947 		}
4948 		public List<TheadTagStartContext> theadTagStart() {
4949 			return getRuleContexts(TheadTagStartContext.class);
4950 		}
4951 		public TheadTagStartContext theadTagStart(int i) {
4952 			return getRuleContext(TheadTagStartContext.class,i);
4953 		}
4954 		public List<TfootTagStartContext> tfootTagStart() {
4955 			return getRuleContexts(TfootTagStartContext.class);
4956 		}
4957 		public TfootTagStartContext tfootTagStart(int i) {
4958 			return getRuleContext(TfootTagStartContext.class,i);
4959 		}
4960 		public List<HtmlCommentContext> htmlComment() {
4961 			return getRuleContexts(HtmlCommentContext.class);
4962 		}
4963 		public HtmlCommentContext htmlComment(int i) {
4964 			return getRuleContext(HtmlCommentContext.class,i);
4965 		}
4966 		public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
4967 		public TerminalNode CDATA(int i) {
4968 			return getToken(JavadocParser.CDATA, i);
4969 		}
4970 		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4971 		public TerminalNode NEWLINE(int i) {
4972 			return getToken(JavadocParser.NEWLINE, i);
4973 		}
4974 		public List<TextContext> text() {
4975 			return getRuleContexts(TextContext.class);
4976 		}
4977 		public TextContext text(int i) {
4978 			return getRuleContext(TextContext.class,i);
4979 		}
4980 		public List<JavadocInlineTagContext> javadocInlineTag() {
4981 			return getRuleContexts(JavadocInlineTagContext.class);
4982 		}
4983 		public JavadocInlineTagContext javadocInlineTag(int i) {
4984 			return getRuleContext(JavadocInlineTagContext.class,i);
4985 		}
4986 		public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4987 		public TerminalNode LEADING_ASTERISK(int i) {
4988 			return getToken(JavadocParser.LEADING_ASTERISK, i);
4989 		}
4990 		public BodyContext(ParserRuleContext parent, int invokingState) {
4991 			super(parent, invokingState);
4992 		}
4993 		@Override public int getRuleIndex() { return RULE_body; }
4994 	}
4995 
4996 	public final BodyContext body() throws RecognitionException {
4997 		BodyContext _localctx = new BodyContext(_ctx, getState());
4998 		enterRule(_localctx, 46, RULE_body);
4999 		try {
5000 			int _alt;
5001 			enterOuterAlt(_localctx, 1);
5002 			{
5003 			setState(668);
5004 			bodyTagStart(false);
5005 			setState(708);
5006 			_errHandler.sync(this);
5007 			_alt = getInterpreter().adaptivePredict(_input,43,_ctx);
5008 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5009 				if ( _alt==1 ) {
5010 					{
5011 					setState(706);
5012 					_errHandler.sync(this);
5013 					switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
5014 					case 1:
5015 						{
5016 						setState(669);
5017 						htmlTag();
5018 						}
5019 						break;
5020 					case 2:
5021 						{
5022 						setState(670);
5023 						singletonElement();
5024 						}
5025 						break;
5026 					case 3:
5027 						{
5028 						setState(671);
5029 						paragraph();
5030 						}
5031 						break;
5032 					case 4:
5033 						{
5034 						setState(672);
5035 						li();
5036 						}
5037 						break;
5038 					case 5:
5039 						{
5040 						setState(673);
5041 						tr();
5042 						}
5043 						break;
5044 					case 6:
5045 						{
5046 						setState(674);
5047 						td();
5048 						}
5049 						break;
5050 					case 7:
5051 						{
5052 						setState(675);
5053 						th();
5054 						}
5055 						break;
5056 					case 8:
5057 						{
5058 						setState(676);
5059 						colgroup();
5060 						}
5061 						break;
5062 					case 9:
5063 						{
5064 						setState(677);
5065 						dd();
5066 						}
5067 						break;
5068 					case 10:
5069 						{
5070 						setState(678);
5071 						dt();
5072 						}
5073 						break;
5074 					case 11:
5075 						{
5076 						setState(679);
5077 						head();
5078 						}
5079 						break;
5080 					case 12:
5081 						{
5082 						setState(680);
5083 						html();
5084 						}
5085 						break;
5086 					case 13:
5087 						{
5088 						setState(681);
5089 						option();
5090 						}
5091 						break;
5092 					case 14:
5093 						{
5094 						setState(682);
5095 						tbody();
5096 						}
5097 						break;
5098 					case 15:
5099 						{
5100 						setState(683);
5101 						thead();
5102 						}
5103 						break;
5104 					case 16:
5105 						{
5106 						setState(684);
5107 						tfoot();
5108 						}
5109 						break;
5110 					case 17:
5111 						{
5112 						setState(685);
5113 						pTagStart(true);
5114 						}
5115 						break;
5116 					case 18:
5117 						{
5118 						setState(686);
5119 						liTagStart(true);
5120 						}
5121 						break;
5122 					case 19:
5123 						{
5124 						setState(687);
5125 						trTagStart(true);
5126 						}
5127 						break;
5128 					case 20:
5129 						{
5130 						setState(688);
5131 						tdTagStart(true);
5132 						}
5133 						break;
5134 					case 21:
5135 						{
5136 						setState(689);
5137 						thTagStart(true);
5138 						}
5139 						break;
5140 					case 22:
5141 						{
5142 						setState(690);
5143 						colgroupTagStart(true);
5144 						}
5145 						break;
5146 					case 23:
5147 						{
5148 						setState(691);
5149 						ddTagStart(true);
5150 						}
5151 						break;
5152 					case 24:
5153 						{
5154 						setState(692);
5155 						dtTagStart(true);
5156 						}
5157 						break;
5158 					case 25:
5159 						{
5160 						setState(693);
5161 						headTagStart(true);
5162 						}
5163 						break;
5164 					case 26:
5165 						{
5166 						setState(694);
5167 						htmlTagStart(true);
5168 						}
5169 						break;
5170 					case 27:
5171 						{
5172 						setState(695);
5173 						optionTagStart(true);
5174 						}
5175 						break;
5176 					case 28:
5177 						{
5178 						setState(696);
5179 						tbodyTagStart(true);
5180 						}
5181 						break;
5182 					case 29:
5183 						{
5184 						setState(697);
5185 						theadTagStart(true);
5186 						}
5187 						break;
5188 					case 30:
5189 						{
5190 						setState(698);
5191 						tfootTagStart(true);
5192 						}
5193 						break;
5194 					case 31:
5195 						{
5196 						{
5197 						setState(699);
5198 						if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
5199 						setState(700);
5200 						match(LEADING_ASTERISK);
5201 						}
5202 						}
5203 						break;
5204 					case 32:
5205 						{
5206 						setState(701);
5207 						htmlComment();
5208 						}
5209 						break;
5210 					case 33:
5211 						{
5212 						setState(702);
5213 						match(CDATA);
5214 						}
5215 						break;
5216 					case 34:
5217 						{
5218 						setState(703);
5219 						match(NEWLINE);
5220 						}
5221 						break;
5222 					case 35:
5223 						{
5224 						setState(704);
5225 						text();
5226 						}
5227 						break;
5228 					case 36:
5229 						{
5230 						setState(705);
5231 						javadocInlineTag();
5232 						}
5233 						break;
5234 					}
5235 					} 
5236 				}
5237 				setState(710);
5238 				_errHandler.sync(this);
5239 				_alt = getInterpreter().adaptivePredict(_input,43,_ctx);
5240 			}
5241 			setState(711);
5242 			bodyTagEnd();
5243 			}
5244 		}
5245 		catch (RecognitionException re) {
5246 			_localctx.exception = re;
5247 			_errHandler.reportError(this, re);
5248 			_errHandler.recover(this, re);
5249 		}
5250 		finally {
5251 			exitRule();
5252 		}
5253 		return _localctx;
5254 	}
5255 
5256 	public static class ColgroupTagStartContext extends ParserRuleContext {
5257 		public boolean isNonTight;
5258 		public TerminalNode START() { return getToken(JavadocParser.START, 0); }
5259 		public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5260 		public TerminalNode END() { return getToken(JavadocParser.END, 0); }
5261 		public List<AttributeContext> attribute() {
5262 			return getRuleContexts(AttributeContext.class);
5263 		}
5264 		public AttributeContext attribute(int i) {
5265 			return getRuleContext(AttributeContext.class,i);
5266 		}
5267 		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5268 		public TerminalNode NEWLINE(int i) {
5269 			return getToken(JavadocParser.NEWLINE, i);
5270 		}
5271 		public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5272 		public TerminalNode LEADING_ASTERISK(int i) {
5273 			return getToken(JavadocParser.LEADING_ASTERISK, i);
5274 		}
5275 		public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5276 		public TerminalNode WS(int i) {
5277 			return getToken(JavadocParser.WS, i);
5278 		}
5279 		public ColgroupTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
5280 		public ColgroupTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
5281 			super(parent, invokingState);
5282 			this.isNonTight = isNonTight;
5283 		}
5284 		@Override public int getRuleIndex() { return RULE_colgroupTagStart; }
5285 	}
5286 
5287 	public final ColgroupTagStartContext colgroupTagStart(boolean isNonTight) throws RecognitionException {
5288 		ColgroupTagStartContext _localctx = new ColgroupTagStartContext(_ctx, getState(), isNonTight);
5289 		enterRule(_localctx, 48, RULE_colgroupTagStart);
5290 		int _la;
5291 		try {
5292 			enterOuterAlt(_localctx, 1);
5293 			{
5294 			setState(713);
5295 			match(START);
5296 			setState(714);
5297 			match(COLGROUP_HTML_TAG_NAME);
5298 			setState(721);
5299 			_errHandler.sync(this);
5300 			_la = _input.LA(1);
5301 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
5302 				{
5303 				setState(719);
5304 				_errHandler.sync(this);
5305 				switch (_input.LA(1)) {
5306 				case HTML_TAG_NAME:
5307 					{
5308 					setState(715);
5309 					attribute();
5310 					}
5311 					break;
5312 				case NEWLINE:
5313 					{
5314 					setState(716);
5315 					match(NEWLINE);
5316 					}
5317 					break;
5318 				case LEADING_ASTERISK:
5319 					{
5320 					setState(717);
5321 					match(LEADING_ASTERISK);
5322 					}
5323 					break;
5324 				case WS:
5325 					{
5326 					setState(718);
5327 					match(WS);
5328 					}
5329 					break;
5330 				default:
5331 					throw new NoViableAltException(this);
5332 				}
5333 				}
5334 				setState(723);
5335 				_errHandler.sync(this);
5336 				_la = _input.LA(1);
5337 			}
5338 			setState(724);
5339 			match(END);
5340 			}
5341 			_ctx.stop = _input.LT(-1);
5342 
5343 			    if (isNonTight && nonTightTagStartContext == null) {
5344 			        nonTightTagStartContext = _localctx;
5345 			    }
5346 
5347 		}
5348 		catch (RecognitionException re) {
5349 			_localctx.exception = re;
5350 			_errHandler.reportError(this, re);
5351 			_errHandler.recover(this, re);
5352 		}
5353 		finally {
5354 			exitRule();
5355 		}
5356 		return _localctx;
5357 	}
5358 
5359 	public static class ColgroupTagEndContext extends ParserRuleContext {
5360 		public TerminalNode START() { return getToken(JavadocParser.START, 0); }
5361 		public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
5362 		public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5363 		public TerminalNode END() { return getToken(JavadocParser.END, 0); }
5364 		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5365 		public TerminalNode NEWLINE(int i) {
5366 			return getToken(JavadocParser.NEWLINE, i);
5367 		}
5368 		public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5369 		public TerminalNode LEADING_ASTERISK(int i) {
5370 			return getToken(JavadocParser.LEADING_ASTERISK, i);
5371 		}
5372 		public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5373 		public TerminalNode WS(int i) {
5374 			return getToken(JavadocParser.WS, i);
5375 		}
5376 		public ColgroupTagEndContext(ParserRuleContext parent, int invokingState) {
5377 			super(parent, invokingState);
5378 		}
5379 		@Override public int getRuleIndex() { return RULE_colgroupTagEnd; }
5380 	}
5381 
5382 	public final ColgroupTagEndContext colgroupTagEnd() throws RecognitionException {
5383 		ColgroupTagEndContext _localctx = new ColgroupTagEndContext(_ctx, getState());
5384 		enterRule(_localctx, 50, RULE_colgroupTagEnd);
5385 		int _la;
5386 		try {
5387 			enterOuterAlt(_localctx, 1);
5388 			{
5389 			setState(726);
5390 			match(START);
5391 			setState(727);
5392 			match(SLASH);
5393 			setState(728);
5394 			match(COLGROUP_HTML_TAG_NAME);
5395 			setState(732);
5396 			_errHandler.sync(this);
5397 			_la = _input.LA(1);
5398 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
5399 				{
5400 				{
5401 				setState(729);
5402 				_la = _input.LA(1);
5403 				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
5404 				_errHandler.recoverInline(this);
5405 				}
5406 				else {
5407 					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
5408 					_errHandler.reportMatch(this);
5409 					consume();
5410 				}
5411 				}
5412 				}
5413 				setState(734);
5414 				_errHandler.sync(this);
5415 				_la = _input.LA(1);
5416 			}
5417 			setState(735);
5418 			match(END);
5419 			}
5420 		}
5421 		catch (RecognitionException re) {
5422 			_localctx.exception = re;
5423 			_errHandler.reportError(this, re);
5424 			_errHandler.recover(this, re);
5425 		}
5426 		finally {
5427 			exitRule();
5428 		}
5429 		return _localctx;
5430 	}
5431 
5432 	public static class ColgroupContext extends ParserRuleContext {
5433 		public ColgroupTagStartContext colgroupTagStart() {
5434 			return getRuleContext(ColgroupTagStartContext.class,0);
5435 		}
5436 		public ColgroupTagEndContext colgroupTagEnd() {
5437 			return getRuleContext(ColgroupTagEndContext.class,0);
5438 		}
5439 		public List<HtmlTagContext> htmlTag() {
5440 			return getRuleContexts(HtmlTagContext.class);
5441 		}
5442 		public HtmlTagContext htmlTag(int i) {
5443 			return getRuleContext(HtmlTagContext.class,i);
5444 		}
5445 		public List<SingletonElementContext> singletonElement() {
5446 			return getRuleContexts(SingletonElementContext.class);
5447 		}
5448 		public SingletonElementContext singletonElement(int i) {
5449 			return getRuleContext(SingletonElementContext.class,i);
5450 		}
5451 		public List<ParagraphContext> paragraph() {
5452 			return getRuleContexts(ParagraphContext.class);
5453 		}
5454 		public ParagraphContext paragraph(int i) {
5455 			return getRuleContext(ParagraphContext.class,i);
5456 		}
5457 		public List<LiContext> li() {
5458 			return getRuleContexts(LiContext.class);
5459 		}
5460 		public LiContext li(int i) {
5461 			return getRuleContext(LiContext.class,i);
5462 		}
5463 		public List<TrContext> tr() {
5464 			return getRuleContexts(TrContext.class);
5465 		}
5466 		public TrContext tr(int i) {
5467 			return getRuleContext(TrContext.class,i);
5468 		}
5469 		public List<TdContext> td() {
5470 			return getRuleContexts(TdContext.class);
5471 		}
5472 		public TdContext td(int i) {
5473 			return getRuleContext(TdContext.class,i);
5474 		}
5475 		public List<ThContext> th() {
5476 			return getRuleContexts(ThContext.class);
5477 		}
5478 		public ThContext th(int i) {
5479 			return getRuleContext(ThContext.class,i);
5480 		}
5481 		public List<BodyContext> body() {
5482 			return getRuleContexts(BodyContext.class);
5483 		}
5484 		public BodyContext body(int i) {
5485 			return getRuleContext(BodyContext.class,i);
5486 		}
5487 		public List<DdContext> dd() {
5488 			return getRuleContexts(DdContext.class);
5489 		}
5490 		public DdContext dd(int i) {
5491 			return getRuleContext(DdContext.class,i);
5492 		}
5493 		public List<DtContext> dt() {
5494 			return getRuleContexts(DtContext.class);
5495 		}
5496 		public DtContext dt(int i) {
5497 			return getRuleContext(DtContext.class,i);
5498 		}
5499 		public List<HeadContext> head() {
5500 			return getRuleContexts(HeadContext.class);
5501 		}
5502 		public HeadContext head(int i) {
5503 			return getRuleContext(HeadContext.class,i);
5504 		}
5505 		public List<HtmlContext> html() {
5506 			return getRuleContexts(HtmlContext.class);
5507 		}
5508 		public HtmlContext html(int i) {
5509 			return getRuleContext(HtmlContext.class,i);
5510 		}
5511 		public List<OptionContext> option() {
5512 			return getRuleContexts(OptionContext.class);
5513 		}
5514 		public OptionContext option(int i) {
5515 			return getRuleContext(OptionContext.class,i);
5516 		}
5517 		public List<TbodyContext> tbody() {
5518 			return getRuleContexts(TbodyContext.class);
5519 		}
5520 		public TbodyContext tbody(int i) {
5521 			return getRuleContext(TbodyContext.class,i);
5522 		}
5523 		public List<TheadContext> thead() {
5524 			return getRuleContexts(TheadContext.class);
5525 		}
5526 		public TheadContext thead(int i) {
5527 			return getRuleContext(TheadContext.class,i);
5528 		}
5529 		public List<TfootContext> tfoot() {
5530 			return getRuleContexts(TfootContext.class);
5531 		}
5532 		public TfootContext tfoot(int i) {
5533 			return getRuleContext(TfootContext.class,i);
5534 		}
5535 		public List<PTagStartContext> pTagStart() {
5536 			return getRuleContexts(PTagStartContext.class);
5537 		}
5538 		public PTagStartContext pTagStart(int i) {
5539 			return getRuleContext(PTagStartContext.class,i);
5540 		}
5541 		public List<LiTagStartContext> liTagStart() {
5542 			return getRuleContexts(LiTagStartContext.class);
5543 		}
5544 		public LiTagStartContext liTagStart(int i) {
5545 			return getRuleContext(LiTagStartContext.class,i);
5546 		}
5547 		public List<TrTagStartContext> trTagStart() {
5548 			return getRuleContexts(TrTagStartContext.class);
5549 		}
5550 		public TrTagStartContext trTagStart(int i) {
5551 			return getRuleContext(TrTagStartContext.class,i);
5552 		}
5553 		public List<TdTagStartContext> tdTagStart() {
5554 			return getRuleContexts(TdTagStartContext.class);
5555 		}
5556 		public TdTagStartContext tdTagStart(int i) {
5557 			return getRuleContext(TdTagStartContext.class,i);
5558 		}
5559 		public List<ThTagStartContext> thTagStart() {
5560 			return getRuleContexts(ThTagStartContext.class);
5561 		}
5562 		public ThTagStartContext thTagStart(int i) {
5563 			return getRuleContext(ThTagStartContext.class,i);
5564 		}
5565 		public List<BodyTagStartContext> bodyTagStart() {
5566 			return getRuleContexts(BodyTagStartContext.class);
5567 		}
5568 		public BodyTagStartContext bodyTagStart(int i) {
5569 			return getRuleContext(BodyTagStartContext.class,i);
5570 		}
5571 		public List<DdTagStartContext> ddTagStart() {
5572 			return getRuleContexts(DdTagStartContext.class);
5573 		}
5574 		public DdTagStartContext ddTagStart(int i) {
5575 			return getRuleContext(DdTagStartContext.class,i);
5576 		}
5577 		public List<DtTagStartContext> dtTagStart() {
5578 			return getRuleContexts(DtTagStartContext.class);
5579 		}
5580 		public DtTagStartContext dtTagStart(int i) {
5581 			return getRuleContext(DtTagStartContext.class,i);
5582 		}
5583 		public List<HeadTagStartContext> headTagStart() {
5584 			return getRuleContexts(HeadTagStartContext.class);
5585 		}
5586 		public HeadTagStartContext headTagStart(int i) {
5587 			return getRuleContext(HeadTagStartContext.class,i);
5588 		}
5589 		public List<HtmlTagStartContext> htmlTagStart() {
5590 			return getRuleContexts(HtmlTagStartContext.class);
5591 		}
5592 		public HtmlTagStartContext htmlTagStart(int i) {
5593 			return getRuleContext(HtmlTagStartContext.class,i);
5594 		}
5595 		public List<OptionTagStartContext> optionTagStart() {
5596 			return getRuleContexts(OptionTagStartContext.class);
5597 		}
5598 		public OptionTagStartContext optionTagStart(int i) {
5599 			return getRuleContext(OptionTagStartContext.class,i);
5600 		}
5601 		public List<TbodyTagStartContext> tbodyTagStart() {
5602 			return getRuleContexts(TbodyTagStartContext.class);
5603 		}
5604 		public TbodyTagStartContext tbodyTagStart(int i) {
5605 			return getRuleContext(TbodyTagStartContext.class,i);
5606 		}
5607 		public List<TheadTagStartContext> theadTagStart() {
5608 			return getRuleContexts(TheadTagStartContext.class);
5609 		}
5610 		public TheadTagStartContext theadTagStart(int i) {
5611 			return getRuleContext(TheadTagStartContext.class,i);
5612 		}
5613 		public List<TfootTagStartContext> tfootTagStart() {
5614 			return getRuleContexts(TfootTagStartContext.class);
5615 		}
5616 		public TfootTagStartContext tfootTagStart(int i) {
5617 			return getRuleContext(TfootTagStartContext.class,i);
5618 		}
5619 		public List<HtmlCommentContext> htmlComment() {
5620 			return getRuleContexts(HtmlCommentContext.class);
5621 		}
5622 		public HtmlCommentContext htmlComment(int i) {
5623 			return getRuleContext(HtmlCommentContext.class,i);
5624 		}
5625 		public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
5626 		public TerminalNode CDATA(int i) {
5627 			return getToken(JavadocParser.CDATA, i);
5628 		}
5629 		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5630 		public TerminalNode NEWLINE(int i) {
5631 			return getToken(JavadocParser.NEWLINE, i);
5632 		}
5633 		public List<TextContext> text() {
5634 			return getRuleContexts(TextContext.class);
5635 		}
5636 		public TextContext text(int i) {
5637 			return getRuleContext(TextContext.class,i);
5638 		}
5639 		public List<JavadocInlineTagContext> javadocInlineTag() {
5640 			return getRuleContexts(JavadocInlineTagContext.class);
5641 		}
5642 		public JavadocInlineTagContext javadocInlineTag(int i) {
5643 			return getRuleContext(JavadocInlineTagContext.class,i);
5644 		}
5645 		public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5646 		public TerminalNode LEADING_ASTERISK(int i) {
5647 			return getToken(JavadocParser.LEADING_ASTERISK, i);
5648 		}
5649 		public ColgroupContext(ParserRuleContext parent, int invokingState) {
5650 			super(parent, invokingState);
5651 		}
5652 		@Override public int getRuleIndex() { return RULE_colgroup; }
5653 	}
5654 
5655 	public final ColgroupContext colgroup() throws RecognitionException {
5656 		ColgroupContext _localctx = new ColgroupContext(_ctx, getState());
5657 		enterRule(_localctx, 52, RULE_colgroup);
5658 		try {
5659 			int _alt;
5660 			enterOuterAlt(_localctx, 1);
5661 			{
5662 			setState(737);
5663 			colgroupTagStart(false);
5664 			setState(777);
5665 			_errHandler.sync(this);
5666 			_alt = getInterpreter().adaptivePredict(_input,48,_ctx);
5667 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5668 				if ( _alt==1 ) {
5669 					{
5670 					setState(775);
5671 					_errHandler.sync(this);
5672 					switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
5673 					case 1:
5674 						{
5675 						setState(738);
5676 						htmlTag();
5677 						}
5678 						break;
5679 					case 2:
5680 						{
5681 						setState(739);
5682 						singletonElement();
5683 						}
5684 						break;
5685 					case 3:
5686 						{
5687 						setState(740);
5688 						paragraph();
5689 						}
5690 						break;
5691 					case 4:
5692 						{
5693 						setState(741);
5694 						li();
5695 						}
5696 						break;
5697 					case 5:
5698 						{
5699 						setState(742);
5700 						tr();
5701 						}
5702 						break;
5703 					case 6:
5704 						{
5705 						setState(743);
5706 						td();
5707 						}
5708 						break;
5709 					case 7:
5710 						{
5711 						setState(744);
5712 						th();
5713 						}
5714 						break;
5715 					case 8:
5716 						{
5717 						setState(745);
5718 						body();
5719 						}
5720 						break;
5721 					case 9:
5722 						{
5723 						setState(746);
5724 						dd();
5725 						}
5726 						break;
5727 					case 10:
5728 						{
5729 						setState(747);
5730 						dt();
5731 						}
5732 						break;
5733 					case 11:
5734 						{
5735 						setState(748);
5736 						head();
5737 						}
5738 						break;
5739 					case 12:
5740 						{
5741 						setState(749);
5742 						html();
5743 						}
5744 						break;
5745 					case 13:
5746 						{
5747 						setState(750);
5748 						option();
5749 						}
5750 						break;
5751 					case 14:
5752 						{
5753 						setState(751);
5754 						tbody();
5755 						}
5756 						break;
5757 					case 15:
5758 						{
5759 						setState(752);
5760 						thead();
5761 						}
5762 						break;
5763 					case 16:
5764 						{
5765 						setState(753);
5766 						tfoot();
5767 						}
5768 						break;
5769 					case 17:
5770 						{
5771 						setState(754);
5772 						pTagStart(true);
5773 						}
5774 						break;
5775 					case 18:
5776 						{
5777 						setState(755);
5778 						liTagStart(true);
5779 						}
5780 						break;
5781 					case 19:
5782 						{
5783 						setState(756);
5784 						trTagStart(true);
5785 						}
5786 						break;
5787 					case 20:
5788 						{
5789 						setState(757);
5790 						tdTagStart(true);
5791 						}
5792 						break;
5793 					case 21:
5794 						{
5795 						setState(758);
5796 						thTagStart(true);
5797 						}
5798 						break;
5799 					case 22:
5800 						{
5801 						setState(759);
5802 						bodyTagStart(true);
5803 						}
5804 						break;
5805 					case 23:
5806 						{
5807 						setState(760);
5808 						ddTagStart(true);
5809 						}
5810 						break;
5811 					case 24:
5812 						{
5813 						setState(761);
5814 						dtTagStart(true);
5815 						}
5816 						break;
5817 					case 25:
5818 						{
5819 						setState(762);
5820 						headTagStart(true);
5821 						}
5822 						break;
5823 					case 26:
5824 						{
5825 						setState(763);
5826 						htmlTagStart(true);
5827 						}
5828 						break;
5829 					case 27:
5830 						{
5831 						setState(764);
5832 						optionTagStart(true);
5833 						}
5834 						break;
5835 					case 28:
5836 						{
5837 						setState(765);
5838 						tbodyTagStart(true);
5839 						}
5840 						break;
5841 					case 29:
5842 						{
5843 						setState(766);
5844 						theadTagStart(true);
5845 						}
5846 						break;
5847 					case 30:
5848 						{
5849 						setState(767);
5850 						tfootTagStart(true);
5851 						}
5852 						break;
5853 					case 31:
5854 						{
5855 						{
5856 						setState(768);
5857 						if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
5858 						setState(769);
5859 						match(LEADING_ASTERISK);
5860 						}
5861 						}
5862 						break;
5863 					case 32:
5864 						{
5865 						setState(770);
5866 						htmlComment();
5867 						}
5868 						break;
5869 					case 33:
5870 						{
5871 						setState(771);
5872 						match(CDATA);
5873 						}
5874 						break;
5875 					case 34:
5876 						{
5877 						setState(772);
5878 						match(NEWLINE);
5879 						}
5880 						break;
5881 					case 35:
5882 						{
5883 						setState(773);
5884 						text();
5885 						}
5886 						break;
5887 					case 36:
5888 						{
5889 						setState(774);
5890 						javadocInlineTag();
5891 						}
5892 						break;
5893 					}
5894 					} 
5895 				}
5896 				setState(779);
5897 				_errHandler.sync(this);
5898 				_alt = getInterpreter().adaptivePredict(_input,48,_ctx);
5899 			}
5900 			setState(780);
5901 			colgroupTagEnd();
5902 			}
5903 		}
5904 		catch (RecognitionException re) {
5905 			_localctx.exception = re;
5906 			_errHandler.reportError(this, re);
5907 			_errHandler.recover(this, re);
5908 		}
5909 		finally {
5910 			exitRule();
5911 		}
5912 		return _localctx;
5913 	}
5914 
5915 	public static class DdTagStartContext extends ParserRuleContext {
5916 		public boolean isNonTight;
5917 		public TerminalNode START() { return getToken(JavadocParser.START, 0); }
5918 		public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
5919 		public TerminalNode END() { return getToken(JavadocParser.END, 0); }
5920 		public List<AttributeContext> attribute() {
5921 			return getRuleContexts(AttributeContext.class);
5922 		}
5923 		public AttributeContext attribute(int i) {
5924 			return getRuleContext(AttributeContext.class,i);
5925 		}
5926 		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5927 		public TerminalNode NEWLINE(int i) {
5928 			return getToken(JavadocParser.NEWLINE, i);
5929 		}
5930 		public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5931 		public TerminalNode LEADING_ASTERISK(int i) {
5932 			return getToken(JavadocParser.LEADING_ASTERISK, i);
5933 		}
5934 		public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5935 		public TerminalNode WS(int i) {
5936 			return getToken(JavadocParser.WS, i);
5937 		}
5938 		public DdTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
5939 		public DdTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
5940 			super(parent, invokingState);
5941 			this.isNonTight = isNonTight;
5942 		}
5943 		@Override public int getRuleIndex() { return RULE_ddTagStart; }
5944 	}
5945 
5946 	public final DdTagStartContext ddTagStart(boolean isNonTight) throws RecognitionException {
5947 		DdTagStartContext _localctx = new DdTagStartContext(_ctx, getState(), isNonTight);
5948 		enterRule(_localctx, 54, RULE_ddTagStart);
5949 		int _la;
5950 		try {
5951 			enterOuterAlt(_localctx, 1);
5952 			{
5953 			setState(782);
5954 			match(START);
5955 			setState(783);
5956 			match(DD_HTML_TAG_NAME);
5957 			setState(790);
5958 			_errHandler.sync(this);
5959 			_la = _input.LA(1);
5960 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
5961 				{
5962 				setState(788);
5963 				_errHandler.sync(this);
5964 				switch (_input.LA(1)) {
5965 				case HTML_TAG_NAME:
5966 					{
5967 					setState(784);
5968 					attribute();
5969 					}
5970 					break;
5971 				case NEWLINE:
5972 					{
5973 					setState(785);
5974 					match(NEWLINE);
5975 					}
5976 					break;
5977 				case LEADING_ASTERISK:
5978 					{
5979 					setState(786);
5980 					match(LEADING_ASTERISK);
5981 					}
5982 					break;
5983 				case WS:
5984 					{
5985 					setState(787);
5986 					match(WS);
5987 					}
5988 					break;
5989 				default:
5990 					throw new NoViableAltException(this);
5991 				}
5992 				}
5993 				setState(792);
5994 				_errHandler.sync(this);
5995 				_la = _input.LA(1);
5996 			}
5997 			setState(793);
5998 			match(END);
5999 			}
6000 			_ctx.stop = _input.LT(-1);
6001 
6002 			    if (isNonTight && nonTightTagStartContext == null) {
6003 			        nonTightTagStartContext = _localctx;
6004 			    }
6005 
6006 		}
6007 		catch (RecognitionException re) {
6008 			_localctx.exception = re;
6009 			_errHandler.reportError(this, re);
6010 			_errHandler.recover(this, re);
6011 		}
6012 		finally {
6013 			exitRule();
6014 		}
6015 		return _localctx;
6016 	}
6017 
6018 	public static class DdTagEndContext extends ParserRuleContext {
6019 		public TerminalNode START() { return getToken(JavadocParser.START, 0); }
6020 		public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
6021 		public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
6022 		public TerminalNode END() { return getToken(JavadocParser.END, 0); }
6023 		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6024 		public TerminalNode NEWLINE(int i) {
6025 			return getToken(JavadocParser.NEWLINE, i);
6026 		}
6027 		public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6028 		public TerminalNode LEADING_ASTERISK(int i) {
6029 			return getToken(JavadocParser.LEADING_ASTERISK, i);
6030 		}
6031 		public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6032 		public TerminalNode WS(int i) {
6033 			return getToken(JavadocParser.WS, i);
6034 		}
6035 		public DdTagEndContext(ParserRuleContext parent, int invokingState) {
6036 			super(parent, invokingState);
6037 		}
6038 		@Override public int getRuleIndex() { return RULE_ddTagEnd; }
6039 	}
6040 
6041 	public final DdTagEndContext ddTagEnd() throws RecognitionException {
6042 		DdTagEndContext _localctx = new DdTagEndContext(_ctx, getState());
6043 		enterRule(_localctx, 56, RULE_ddTagEnd);
6044 		int _la;
6045 		try {
6046 			enterOuterAlt(_localctx, 1);
6047 			{
6048 			setState(795);
6049 			match(START);
6050 			setState(796);
6051 			match(SLASH);
6052 			setState(797);
6053 			match(DD_HTML_TAG_NAME);
6054 			setState(801);
6055 			_errHandler.sync(this);
6056 			_la = _input.LA(1);
6057 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
6058 				{
6059 				{
6060 				setState(798);
6061 				_la = _input.LA(1);
6062 				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
6063 				_errHandler.recoverInline(this);
6064 				}
6065 				else {
6066 					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
6067 					_errHandler.reportMatch(this);
6068 					consume();
6069 				}
6070 				}
6071 				}
6072 				setState(803);
6073 				_errHandler.sync(this);
6074 				_la = _input.LA(1);
6075 			}
6076 			setState(804);
6077 			match(END);
6078 			}
6079 		}
6080 		catch (RecognitionException re) {
6081 			_localctx.exception = re;
6082 			_errHandler.reportError(this, re);
6083 			_errHandler.recover(this, re);
6084 		}
6085 		finally {
6086 			exitRule();
6087 		}
6088 		return _localctx;
6089 	}
6090 
6091 	public static class DdContext extends ParserRuleContext {
6092 		public DdTagStartContext ddTagStart() {
6093 			return getRuleContext(DdTagStartContext.class,0);
6094 		}
6095 		public DdTagEndContext ddTagEnd() {
6096 			return getRuleContext(DdTagEndContext.class,0);
6097 		}
6098 		public List<HtmlTagContext> htmlTag() {
6099 			return getRuleContexts(HtmlTagContext.class);
6100 		}
6101 		public HtmlTagContext htmlTag(int i) {
6102 			return getRuleContext(HtmlTagContext.class,i);
6103 		}
6104 		public List<SingletonElementContext> singletonElement() {
6105 			return getRuleContexts(SingletonElementContext.class);
6106 		}
6107 		public SingletonElementContext singletonElement(int i) {
6108 			return getRuleContext(SingletonElementContext.class,i);
6109 		}
6110 		public List<ParagraphContext> paragraph() {
6111 			return getRuleContexts(ParagraphContext.class);
6112 		}
6113 		public ParagraphContext paragraph(int i) {
6114 			return getRuleContext(ParagraphContext.class,i);
6115 		}
6116 		public List<LiContext> li() {
6117 			return getRuleContexts(LiContext.class);
6118 		}
6119 		public LiContext li(int i) {
6120 			return getRuleContext(LiContext.class,i);
6121 		}
6122 		public List<TrContext> tr() {
6123 			return getRuleContexts(TrContext.class);
6124 		}
6125 		public TrContext tr(int i) {
6126 			return getRuleContext(TrContext.class,i);
6127 		}
6128 		public List<TdContext> td() {
6129 			return getRuleContexts(TdContext.class);
6130 		}
6131 		public TdContext td(int i) {
6132 			return getRuleContext(TdContext.class,i);
6133 		}
6134 		public List<ThContext> th() {
6135 			return getRuleContexts(ThContext.class);
6136 		}
6137 		public ThContext th(int i) {
6138 			return getRuleContext(ThContext.class,i);
6139 		}
6140 		public List<BodyContext> body() {
6141 			return getRuleContexts(BodyContext.class);
6142 		}
6143 		public BodyContext body(int i) {
6144 			return getRuleContext(BodyContext.class,i);
6145 		}
6146 		public List<ColgroupContext> colgroup() {
6147 			return getRuleContexts(ColgroupContext.class);
6148 		}
6149 		public ColgroupContext colgroup(int i) {
6150 			return getRuleContext(ColgroupContext.class,i);
6151 		}
6152 		public List<DtContext> dt() {
6153 			return getRuleContexts(DtContext.class);
6154 		}
6155 		public DtContext dt(int i) {
6156 			return getRuleContext(DtContext.class,i);
6157 		}
6158 		public List<HeadContext> head() {
6159 			return getRuleContexts(HeadContext.class);
6160 		}
6161 		public HeadContext head(int i) {
6162 			return getRuleContext(HeadContext.class,i);
6163 		}
6164 		public List<HtmlContext> html() {
6165 			return getRuleContexts(HtmlContext.class);
6166 		}
6167 		public HtmlContext html(int i) {
6168 			return getRuleContext(HtmlContext.class,i);
6169 		}
6170 		public List<OptionContext> option() {
6171 			return getRuleContexts(OptionContext.class);
6172 		}
6173 		public OptionContext option(int i) {
6174 			return getRuleContext(OptionContext.class,i);
6175 		}
6176 		public List<TbodyContext> tbody() {
6177 			return getRuleContexts(TbodyContext.class);
6178 		}
6179 		public TbodyContext tbody(int i) {
6180 			return getRuleContext(TbodyContext.class,i);
6181 		}
6182 		public List<TheadContext> thead() {
6183 			return getRuleContexts(TheadContext.class);
6184 		}
6185 		public TheadContext thead(int i) {
6186 			return getRuleContext(TheadContext.class,i);
6187 		}
6188 		public List<TfootContext> tfoot() {
6189 			return getRuleContexts(TfootContext.class);
6190 		}
6191 		public TfootContext tfoot(int i) {
6192 			return getRuleContext(TfootContext.class,i);
6193 		}
6194 		public List<PTagStartContext> pTagStart() {
6195 			return getRuleContexts(PTagStartContext.class);
6196 		}
6197 		public PTagStartContext pTagStart(int i) {
6198 			return getRuleContext(PTagStartContext.class,i);
6199 		}
6200 		public List<LiTagStartContext> liTagStart() {
6201 			return getRuleContexts(LiTagStartContext.class);
6202 		}
6203 		public LiTagStartContext liTagStart(int i) {
6204 			return getRuleContext(LiTagStartContext.class,i);
6205 		}
6206 		public List<TrTagStartContext> trTagStart() {
6207 			return getRuleContexts(TrTagStartContext.class);
6208 		}
6209 		public TrTagStartContext trTagStart(int i) {
6210 			return getRuleContext(TrTagStartContext.class,i);
6211 		}
6212 		public List<TdTagStartContext> tdTagStart() {
6213 			return getRuleContexts(TdTagStartContext.class);
6214 		}
6215 		public TdTagStartContext tdTagStart(int i) {
6216 			return getRuleContext(TdTagStartContext.class,i);
6217 		}
6218 		public List<ThTagStartContext> thTagStart() {
6219 			return getRuleContexts(ThTagStartContext.class);
6220 		}
6221 		public ThTagStartContext thTagStart(int i) {
6222 			return getRuleContext(ThTagStartContext.class,i);
6223 		}
6224 		public List<BodyTagStartContext> bodyTagStart() {
6225 			return getRuleContexts(BodyTagStartContext.class);
6226 		}
6227 		public BodyTagStartContext bodyTagStart(int i) {
6228 			return getRuleContext(BodyTagStartContext.class,i);
6229 		}
6230 		public List<ColgroupTagStartContext> colgroupTagStart() {
6231 			return getRuleContexts(ColgroupTagStartContext.class);
6232 		}
6233 		public ColgroupTagStartContext colgroupTagStart(int i) {
6234 			return getRuleContext(ColgroupTagStartContext.class,i);
6235 		}
6236 		public List<DtTagStartContext> dtTagStart() {
6237 			return getRuleContexts(DtTagStartContext.class);
6238 		}
6239 		public DtTagStartContext dtTagStart(int i) {
6240 			return getRuleContext(DtTagStartContext.class,i);
6241 		}
6242 		public List<HeadTagStartContext> headTagStart() {
6243 			return getRuleContexts(HeadTagStartContext.class);
6244 		}
6245 		public HeadTagStartContext headTagStart(int i) {
6246 			return getRuleContext(HeadTagStartContext.class,i);
6247 		}
6248 		public List<HtmlTagStartContext> htmlTagStart() {
6249 			return getRuleContexts(HtmlTagStartContext.class);
6250 		}
6251 		public HtmlTagStartContext htmlTagStart(int i) {
6252 			return getRuleContext(HtmlTagStartContext.class,i);
6253 		}
6254 		public List<OptionTagStartContext> optionTagStart() {
6255 			return getRuleContexts(OptionTagStartContext.class);
6256 		}
6257 		public OptionTagStartContext optionTagStart(int i) {
6258 			return getRuleContext(OptionTagStartContext.class,i);
6259 		}
6260 		public List<TbodyTagStartContext> tbodyTagStart() {
6261 			return getRuleContexts(TbodyTagStartContext.class);
6262 		}
6263 		public TbodyTagStartContext tbodyTagStart(int i) {
6264 			return getRuleContext(TbodyTagStartContext.class,i);
6265 		}
6266 		public List<TheadTagStartContext> theadTagStart() {
6267 			return getRuleContexts(TheadTagStartContext.class);
6268 		}
6269 		public TheadTagStartContext theadTagStart(int i) {
6270 			return getRuleContext(TheadTagStartContext.class,i);
6271 		}
6272 		public List<TfootTagStartContext> tfootTagStart() {
6273 			return getRuleContexts(TfootTagStartContext.class);
6274 		}
6275 		public TfootTagStartContext tfootTagStart(int i) {
6276 			return getRuleContext(TfootTagStartContext.class,i);
6277 		}
6278 		public List<HtmlCommentContext> htmlComment() {
6279 			return getRuleContexts(HtmlCommentContext.class);
6280 		}
6281 		public HtmlCommentContext htmlComment(int i) {
6282 			return getRuleContext(HtmlCommentContext.class,i);
6283 		}
6284 		public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
6285 		public TerminalNode CDATA(int i) {
6286 			return getToken(JavadocParser.CDATA, i);
6287 		}
6288 		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6289 		public TerminalNode NEWLINE(int i) {
6290 			return getToken(JavadocParser.NEWLINE, i);
6291 		}
6292 		public List<TextContext> text() {
6293 			return getRuleContexts(TextContext.class);
6294 		}
6295 		public TextContext text(int i) {
6296 			return getRuleContext(TextContext.class,i);
6297 		}
6298 		public List<JavadocInlineTagContext> javadocInlineTag() {
6299 			return getRuleContexts(JavadocInlineTagContext.class);
6300 		}
6301 		public JavadocInlineTagContext javadocInlineTag(int i) {
6302 			return getRuleContext(JavadocInlineTagContext.class,i);
6303 		}
6304 		public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6305 		public TerminalNode LEADING_ASTERISK(int i) {
6306 			return getToken(JavadocParser.LEADING_ASTERISK, i);
6307 		}
6308 		public DdContext(ParserRuleContext parent, int invokingState) {
6309 			super(parent, invokingState);
6310 		}
6311 		@Override public int getRuleIndex() { return RULE_dd; }
6312 	}
6313 
6314 	public final DdContext dd() throws RecognitionException {
6315 		DdContext _localctx = new DdContext(_ctx, getState());
6316 		enterRule(_localctx, 58, RULE_dd);
6317 		try {
6318 			int _alt;
6319 			enterOuterAlt(_localctx, 1);
6320 			{
6321 			setState(806);
6322 			ddTagStart(false);
6323 			setState(846);
6324 			_errHandler.sync(this);
6325 			_alt = getInterpreter().adaptivePredict(_input,53,_ctx);
6326 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
6327 				if ( _alt==1 ) {
6328 					{
6329 					setState(844);
6330 					_errHandler.sync(this);
6331 					switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
6332 					case 1:
6333 						{
6334 						setState(807);
6335 						htmlTag();
6336 						}
6337 						break;
6338 					case 2:
6339 						{
6340 						setState(808);
6341 						singletonElement();
6342 						}
6343 						break;
6344 					case 3:
6345 						{
6346 						setState(809);
6347 						paragraph();
6348 						}
6349 						break;
6350 					case 4:
6351 						{
6352 						setState(810);
6353 						li();
6354 						}
6355 						break;
6356 					case 5:
6357 						{
6358 						setState(811);
6359 						tr();
6360 						}
6361 						break;
6362 					case 6:
6363 						{
6364 						setState(812);
6365 						td();
6366 						}
6367 						break;
6368 					case 7:
6369 						{
6370 						setState(813);
6371 						th();
6372 						}
6373 						break;
6374 					case 8:
6375 						{
6376 						setState(814);
6377 						body();
6378 						}
6379 						break;
6380 					case 9:
6381 						{
6382 						setState(815);
6383 						colgroup();
6384 						}
6385 						break;
6386 					case 10:
6387 						{
6388 						setState(816);
6389 						dt();
6390 						}
6391 						break;
6392 					case 11:
6393 						{
6394 						setState(817);
6395 						head();
6396 						}
6397 						break;
6398 					case 12:
6399 						{
6400 						setState(818);
6401 						html();
6402 						}
6403 						break;
6404 					case 13:
6405 						{
6406 						setState(819);
6407 						option();
6408 						}
6409 						break;
6410 					case 14:
6411 						{
6412 						setState(820);
6413 						tbody();
6414 						}
6415 						break;
6416 					case 15:
6417 						{
6418 						setState(821);
6419 						thead();
6420 						}
6421 						break;
6422 					case 16:
6423 						{
6424 						setState(822);
6425 						tfoot();
6426 						}
6427 						break;
6428 					case 17:
6429 						{
6430 						setState(823);
6431 						pTagStart(true);
6432 						}
6433 						break;
6434 					case 18:
6435 						{
6436 						setState(824);
6437 						liTagStart(true);
6438 						}
6439 						break;
6440 					case 19:
6441 						{
6442 						setState(825);
6443 						trTagStart(true);
6444 						}
6445 						break;
6446 					case 20:
6447 						{
6448 						setState(826);
6449 						tdTagStart(true);
6450 						}
6451 						break;
6452 					case 21:
6453 						{
6454 						setState(827);
6455 						thTagStart(true);
6456 						}
6457 						break;
6458 					case 22:
6459 						{
6460 						setState(828);
6461 						bodyTagStart(true);
6462 						}
6463 						break;
6464 					case 23:
6465 						{
6466 						setState(829);
6467 						colgroupTagStart(true);
6468 						}
6469 						break;
6470 					case 24:
6471 						{
6472 						setState(830);
6473 						dtTagStart(true);
6474 						}
6475 						break;
6476 					case 25:
6477 						{
6478 						setState(831);
6479 						headTagStart(true);
6480 						}
6481 						break;
6482 					case 26:
6483 						{
6484 						setState(832);
6485 						htmlTagStart(true);
6486 						}
6487 						break;
6488 					case 27:
6489 						{
6490 						setState(833);
6491 						optionTagStart(true);
6492 						}
6493 						break;
6494 					case 28:
6495 						{
6496 						setState(834);
6497 						tbodyTagStart(true);
6498 						}
6499 						break;
6500 					case 29:
6501 						{
6502 						setState(835);
6503 						theadTagStart(true);
6504 						}
6505 						break;
6506 					case 30:
6507 						{
6508 						setState(836);
6509 						tfootTagStart(true);
6510 						}
6511 						break;
6512 					case 31:
6513 						{
6514 						{
6515 						setState(837);
6516 						if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
6517 						setState(838);
6518 						match(LEADING_ASTERISK);
6519 						}
6520 						}
6521 						break;
6522 					case 32:
6523 						{
6524 						setState(839);
6525 						htmlComment();
6526 						}
6527 						break;
6528 					case 33:
6529 						{
6530 						setState(840);
6531 						match(CDATA);
6532 						}
6533 						break;
6534 					case 34:
6535 						{
6536 						setState(841);
6537 						match(NEWLINE);
6538 						}
6539 						break;
6540 					case 35:
6541 						{
6542 						setState(842);
6543 						text();
6544 						}
6545 						break;
6546 					case 36:
6547 						{
6548 						setState(843);
6549 						javadocInlineTag();
6550 						}
6551 						break;
6552 					}
6553 					} 
6554 				}
6555 				setState(848);
6556 				_errHandler.sync(this);
6557 				_alt = getInterpreter().adaptivePredict(_input,53,_ctx);
6558 			}
6559 			setState(849);
6560 			ddTagEnd();
6561 			}
6562 		}
6563 		catch (RecognitionException re) {
6564 			_localctx.exception = re;
6565 			_errHandler.reportError(this, re);
6566 			_errHandler.recover(this, re);
6567 		}
6568 		finally {
6569 			exitRule();
6570 		}
6571 		return _localctx;
6572 	}
6573 
6574 	public static class DtTagStartContext extends ParserRuleContext {
6575 		public boolean isNonTight;
6576 		public TerminalNode START() { return getToken(JavadocParser.START, 0); }
6577 		public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
6578 		public TerminalNode END() { return getToken(JavadocParser.END, 0); }
6579 		public List<AttributeContext> attribute() {
6580 			return getRuleContexts(AttributeContext.class);
6581 		}
6582 		public AttributeContext attribute(int i) {
6583 			return getRuleContext(AttributeContext.class,i);
6584 		}
6585 		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6586 		public TerminalNode NEWLINE(int i) {
6587 			return getToken(JavadocParser.NEWLINE, i);
6588 		}
6589 		public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6590 		public TerminalNode LEADING_ASTERISK(int i) {
6591 			return getToken(JavadocParser.LEADING_ASTERISK, i);
6592 		}
6593 		public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6594 		public TerminalNode WS(int i) {
6595 			return getToken(JavadocParser.WS, i);
6596 		}
6597 		public DtTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
6598 		public DtTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
6599 			super(parent, invokingState);
6600 			this.isNonTight = isNonTight;
6601 		}
6602 		@Override public int getRuleIndex() { return RULE_dtTagStart; }
6603 	}
6604 
6605 	public final DtTagStartContext dtTagStart(boolean isNonTight) throws RecognitionException {
6606 		DtTagStartContext _localctx = new DtTagStartContext(_ctx, getState(), isNonTight);
6607 		enterRule(_localctx, 60, RULE_dtTagStart);
6608 		int _la;
6609 		try {
6610 			enterOuterAlt(_localctx, 1);
6611 			{
6612 			setState(851);
6613 			match(START);
6614 			setState(852);
6615 			match(DT_HTML_TAG_NAME);
6616 			setState(859);
6617 			_errHandler.sync(this);
6618 			_la = _input.LA(1);
6619 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
6620 				{
6621 				setState(857);
6622 				_errHandler.sync(this);
6623 				switch (_input.LA(1)) {
6624 				case HTML_TAG_NAME:
6625 					{
6626 					setState(853);
6627 					attribute();
6628 					}
6629 					break;
6630 				case NEWLINE:
6631 					{
6632 					setState(854);
6633 					match(NEWLINE);
6634 					}
6635 					break;
6636 				case LEADING_ASTERISK:
6637 					{
6638 					setState(855);
6639 					match(LEADING_ASTERISK);
6640 					}
6641 					break;
6642 				case WS:
6643 					{
6644 					setState(856);
6645 					match(WS);
6646 					}
6647 					break;
6648 				default:
6649 					throw new NoViableAltException(this);
6650 				}
6651 				}
6652 				setState(861);
6653 				_errHandler.sync(this);
6654 				_la = _input.LA(1);
6655 			}
6656 			setState(862);
6657 			match(END);
6658 			}
6659 			_ctx.stop = _input.LT(-1);
6660 
6661 			    if (isNonTight && nonTightTagStartContext == null) {
6662 			        nonTightTagStartContext = _localctx;
6663 			    }
6664 
6665 		}
6666 		catch (RecognitionException re) {
6667 			_localctx.exception = re;
6668 			_errHandler.reportError(this, re);
6669 			_errHandler.recover(this, re);
6670 		}
6671 		finally {
6672 			exitRule();
6673 		}
6674 		return _localctx;
6675 	}
6676 
6677 	public static class DtTagEndContext extends ParserRuleContext {
6678 		public TerminalNode START() { return getToken(JavadocParser.START, 0); }
6679 		public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
6680 		public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
6681 		public TerminalNode END() { return getToken(JavadocParser.END, 0); }
6682 		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6683 		public TerminalNode NEWLINE(int i) {
6684 			return getToken(JavadocParser.NEWLINE, i);
6685 		}
6686 		public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6687 		public TerminalNode LEADING_ASTERISK(int i) {
6688 			return getToken(JavadocParser.LEADING_ASTERISK, i);
6689 		}
6690 		public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6691 		public TerminalNode WS(int i) {
6692 			return getToken(JavadocParser.WS, i);
6693 		}
6694 		public DtTagEndContext(ParserRuleContext parent, int invokingState) {
6695 			super(parent, invokingState);
6696 		}
6697 		@Override public int getRuleIndex() { return RULE_dtTagEnd; }
6698 	}
6699 
6700 	public final DtTagEndContext dtTagEnd() throws RecognitionException {
6701 		DtTagEndContext _localctx = new DtTagEndContext(_ctx, getState());
6702 		enterRule(_localctx, 62, RULE_dtTagEnd);
6703 		int _la;
6704 		try {
6705 			enterOuterAlt(_localctx, 1);
6706 			{
6707 			setState(864);
6708 			match(START);
6709 			setState(865);
6710 			match(SLASH);
6711 			setState(866);
6712 			match(DT_HTML_TAG_NAME);
6713 			setState(870);
6714 			_errHandler.sync(this);
6715 			_la = _input.LA(1);
6716 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
6717 				{
6718 				{
6719 				setState(867);
6720 				_la = _input.LA(1);
6721 				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
6722 				_errHandler.recoverInline(this);
6723 				}
6724 				else {
6725 					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
6726 					_errHandler.reportMatch(this);
6727 					consume();
6728 				}
6729 				}
6730 				}
6731 				setState(872);
6732 				_errHandler.sync(this);
6733 				_la = _input.LA(1);
6734 			}
6735 			setState(873);
6736 			match(END);
6737 			}
6738 		}
6739 		catch (RecognitionException re) {
6740 			_localctx.exception = re;
6741 			_errHandler.reportError(this, re);
6742 			_errHandler.recover(this, re);
6743 		}
6744 		finally {
6745 			exitRule();
6746 		}
6747 		return _localctx;
6748 	}
6749 
6750 	public static class DtContext extends ParserRuleContext {
6751 		public DtTagStartContext dtTagStart() {
6752 			return getRuleContext(DtTagStartContext.class,0);
6753 		}
6754 		public DtTagEndContext dtTagEnd() {
6755 			return getRuleContext(DtTagEndContext.class,0);
6756 		}
6757 		public List<HtmlTagContext> htmlTag() {
6758 			return getRuleContexts(HtmlTagContext.class);
6759 		}
6760 		public HtmlTagContext htmlTag(int i) {
6761 			return getRuleContext(HtmlTagContext.class,i);
6762 		}
6763 		public List<SingletonElementContext> singletonElement() {
6764 			return getRuleContexts(SingletonElementContext.class);
6765 		}
6766 		public SingletonElementContext singletonElement(int i) {
6767 			return getRuleContext(SingletonElementContext.class,i);
6768 		}
6769 		public List<ParagraphContext> paragraph() {
6770 			return getRuleContexts(ParagraphContext.class);
6771 		}
6772 		public ParagraphContext paragraph(int i) {
6773 			return getRuleContext(ParagraphContext.class,i);
6774 		}
6775 		public List<LiContext> li() {
6776 			return getRuleContexts(LiContext.class);
6777 		}
6778 		public LiContext li(int i) {
6779 			return getRuleContext(LiContext.class,i);
6780 		}
6781 		public List<TrContext> tr() {
6782 			return getRuleContexts(TrContext.class);
6783 		}
6784 		public TrContext tr(int i) {
6785 			return getRuleContext(TrContext.class,i);
6786 		}
6787 		public List<TdContext> td() {
6788 			return getRuleContexts(TdContext.class);
6789 		}
6790 		public TdContext td(int i) {
6791 			return getRuleContext(TdContext.class,i);
6792 		}
6793 		public List<ThContext> th() {
6794 			return getRuleContexts(ThContext.class);
6795 		}
6796 		public ThContext th(int i) {
6797 			return getRuleContext(ThContext.class,i);
6798 		}
6799 		public List<BodyContext> body() {
6800 			return getRuleContexts(BodyContext.class);
6801 		}
6802 		public BodyContext body(int i) {
6803 			return getRuleContext(BodyContext.class,i);
6804 		}
6805 		public List<ColgroupContext> colgroup() {
6806 			return getRuleContexts(ColgroupContext.class);
6807 		}
6808 		public ColgroupContext colgroup(int i) {
6809 			return getRuleContext(ColgroupContext.class,i);
6810 		}
6811 		public List<DdContext> dd() {
6812 			return getRuleContexts(DdContext.class);
6813 		}
6814 		public DdContext dd(int i) {
6815 			return getRuleContext(DdContext.class,i);
6816 		}
6817 		public List<HeadContext> head() {
6818 			return getRuleContexts(HeadContext.class);
6819 		}
6820 		public HeadContext head(int i) {
6821 			return getRuleContext(HeadContext.class,i);
6822 		}
6823 		public List<HtmlContext> html() {
6824 			return getRuleContexts(HtmlContext.class);
6825 		}
6826 		public HtmlContext html(int i) {
6827 			return getRuleContext(HtmlContext.class,i);
6828 		}
6829 		public List<OptionContext> option() {
6830 			return getRuleContexts(OptionContext.class);
6831 		}
6832 		public OptionContext option(int i) {
6833 			return getRuleContext(OptionContext.class,i);
6834 		}
6835 		public List<TbodyContext> tbody() {
6836 			return getRuleContexts(TbodyContext.class);
6837 		}
6838 		public TbodyContext tbody(int i) {
6839 			return getRuleContext(TbodyContext.class,i);
6840 		}
6841 		public List<TheadContext> thead() {
6842 			return getRuleContexts(TheadContext.class);
6843 		}
6844 		public TheadContext thead(int i) {
6845 			return getRuleContext(TheadContext.class,i);
6846 		}
6847 		public List<TfootContext> tfoot() {
6848 			return getRuleContexts(TfootContext.class);
6849 		}
6850 		public TfootContext tfoot(int i) {
6851 			return getRuleContext(TfootContext.class,i);
6852 		}
6853 		public List<PTagStartContext> pTagStart() {
6854 			return getRuleContexts(PTagStartContext.class);
6855 		}
6856 		public PTagStartContext pTagStart(int i) {
6857 			return getRuleContext(PTagStartContext.class,i);
6858 		}
6859 		public List<LiTagStartContext> liTagStart() {
6860 			return getRuleContexts(LiTagStartContext.class);
6861 		}
6862 		public LiTagStartContext liTagStart(int i) {
6863 			return getRuleContext(LiTagStartContext.class,i);
6864 		}
6865 		public List<TrTagStartContext> trTagStart() {
6866 			return getRuleContexts(TrTagStartContext.class);
6867 		}
6868 		public TrTagStartContext trTagStart(int i) {
6869 			return getRuleContext(TrTagStartContext.class,i);
6870 		}
6871 		public List<TdTagStartContext> tdTagStart() {
6872 			return getRuleContexts(TdTagStartContext.class);
6873 		}
6874 		public TdTagStartContext tdTagStart(int i) {
6875 			return getRuleContext(TdTagStartContext.class,i);
6876 		}
6877 		public List<ThTagStartContext> thTagStart() {
6878 			return getRuleContexts(ThTagStartContext.class);
6879 		}
6880 		public ThTagStartContext thTagStart(int i) {
6881 			return getRuleContext(ThTagStartContext.class,i);
6882 		}
6883 		public List<BodyTagStartContext> bodyTagStart() {
6884 			return getRuleContexts(BodyTagStartContext.class);
6885 		}
6886 		public BodyTagStartContext bodyTagStart(int i) {
6887 			return getRuleContext(BodyTagStartContext.class,i);
6888 		}
6889 		public List<ColgroupTagStartContext> colgroupTagStart() {
6890 			return getRuleContexts(ColgroupTagStartContext.class);
6891 		}
6892 		public ColgroupTagStartContext colgroupTagStart(int i) {
6893 			return getRuleContext(ColgroupTagStartContext.class,i);
6894 		}
6895 		public List<DdTagStartContext> ddTagStart() {
6896 			return getRuleContexts(DdTagStartContext.class);
6897 		}
6898 		public DdTagStartContext ddTagStart(int i) {
6899 			return getRuleContext(DdTagStartContext.class,i);
6900 		}
6901 		public List<HeadTagStartContext> headTagStart() {
6902 			return getRuleContexts(HeadTagStartContext.class);
6903 		}
6904 		public HeadTagStartContext headTagStart(int i) {
6905 			return getRuleContext(HeadTagStartContext.class,i);
6906 		}
6907 		public List<HtmlTagStartContext> htmlTagStart() {
6908 			return getRuleContexts(HtmlTagStartContext.class);
6909 		}
6910 		public HtmlTagStartContext htmlTagStart(int i) {
6911 			return getRuleContext(HtmlTagStartContext.class,i);
6912 		}
6913 		public List<OptionTagStartContext> optionTagStart() {
6914 			return getRuleContexts(OptionTagStartContext.class);
6915 		}
6916 		public OptionTagStartContext optionTagStart(int i) {
6917 			return getRuleContext(OptionTagStartContext.class,i);
6918 		}
6919 		public List<TbodyTagStartContext> tbodyTagStart() {
6920 			return getRuleContexts(TbodyTagStartContext.class);
6921 		}
6922 		public TbodyTagStartContext tbodyTagStart(int i) {
6923 			return getRuleContext(TbodyTagStartContext.class,i);
6924 		}
6925 		public List<TheadTagStartContext> theadTagStart() {
6926 			return getRuleContexts(TheadTagStartContext.class);
6927 		}
6928 		public TheadTagStartContext theadTagStart(int i) {
6929 			return getRuleContext(TheadTagStartContext.class,i);
6930 		}
6931 		public List<TfootTagStartContext> tfootTagStart() {
6932 			return getRuleContexts(TfootTagStartContext.class);
6933 		}
6934 		public TfootTagStartContext tfootTagStart(int i) {
6935 			return getRuleContext(TfootTagStartContext.class,i);
6936 		}
6937 		public List<HtmlCommentContext> htmlComment() {
6938 			return getRuleContexts(HtmlCommentContext.class);
6939 		}
6940 		public HtmlCommentContext htmlComment(int i) {
6941 			return getRuleContext(HtmlCommentContext.class,i);
6942 		}
6943 		public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
6944 		public TerminalNode CDATA(int i) {
6945 			return getToken(JavadocParser.CDATA, i);
6946 		}
6947 		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6948 		public TerminalNode NEWLINE(int i) {
6949 			return getToken(JavadocParser.NEWLINE, i);
6950 		}
6951 		public List<TextContext> text() {
6952 			return getRuleContexts(TextContext.class);
6953 		}
6954 		public TextContext text(int i) {
6955 			return getRuleContext(TextContext.class,i);
6956 		}
6957 		public List<JavadocInlineTagContext> javadocInlineTag() {
6958 			return getRuleContexts(JavadocInlineTagContext.class);
6959 		}
6960 		public JavadocInlineTagContext javadocInlineTag(int i) {
6961 			return getRuleContext(JavadocInlineTagContext.class,i);
6962 		}
6963 		public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6964 		public TerminalNode LEADING_ASTERISK(int i) {
6965 			return getToken(JavadocParser.LEADING_ASTERISK, i);
6966 		}
6967 		public DtContext(ParserRuleContext parent, int invokingState) {
6968 			super(parent, invokingState);
6969 		}
6970 		@Override public int getRuleIndex() { return RULE_dt; }
6971 	}
6972 
6973 	public final DtContext dt() throws RecognitionException {
6974 		DtContext _localctx = new DtContext(_ctx, getState());
6975 		enterRule(_localctx, 64, RULE_dt);
6976 		try {
6977 			int _alt;
6978 			enterOuterAlt(_localctx, 1);
6979 			{
6980 			setState(875);
6981 			dtTagStart(false);
6982 			setState(915);
6983 			_errHandler.sync(this);
6984 			_alt = getInterpreter().adaptivePredict(_input,58,_ctx);
6985 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
6986 				if ( _alt==1 ) {
6987 					{
6988 					setState(913);
6989 					_errHandler.sync(this);
6990 					switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
6991 					case 1:
6992 						{
6993 						setState(876);
6994 						htmlTag();
6995 						}
6996 						break;
6997 					case 2:
6998 						{
6999 						setState(877);
7000 						singletonElement();
7001 						}
7002 						break;
7003 					case 3:
7004 						{
7005 						setState(878);
7006 						paragraph();
7007 						}
7008 						break;
7009 					case 4:
7010 						{
7011 						setState(879);
7012 						li();
7013 						}
7014 						break;
7015 					case 5:
7016 						{
7017 						setState(880);
7018 						tr();
7019 						}
7020 						break;
7021 					case 6:
7022 						{
7023 						setState(881);
7024 						td();
7025 						}
7026 						break;
7027 					case 7:
7028 						{
7029 						setState(882);
7030 						th();
7031 						}
7032 						break;
7033 					case 8:
7034 						{
7035 						setState(883);
7036 						body();
7037 						}
7038 						break;
7039 					case 9:
7040 						{
7041 						setState(884);
7042 						colgroup();
7043 						}
7044 						break;
7045 					case 10:
7046 						{
7047 						setState(885);
7048 						dd();
7049 						}
7050 						break;
7051 					case 11:
7052 						{
7053 						setState(886);
7054 						head();
7055 						}
7056 						break;
7057 					case 12:
7058 						{
7059 						setState(887);
7060 						html();
7061 						}
7062 						break;
7063 					case 13:
7064 						{
7065 						setState(888);
7066 						option();
7067 						}
7068 						break;
7069 					case 14:
7070 						{
7071 						setState(889);
7072 						tbody();
7073 						}
7074 						break;
7075 					case 15:
7076 						{
7077 						setState(890);
7078 						thead();
7079 						}
7080 						break;
7081 					case 16:
7082 						{
7083 						setState(891);
7084 						tfoot();
7085 						}
7086 						break;
7087 					case 17:
7088 						{
7089 						setState(892);
7090 						pTagStart(true);
7091 						}
7092 						break;
7093 					case 18:
7094 						{
7095 						setState(893);
7096 						liTagStart(true);
7097 						}
7098 						break;
7099 					case 19:
7100 						{
7101 						setState(894);
7102 						trTagStart(true);
7103 						}
7104 						break;
7105 					case 20:
7106 						{
7107 						setState(895);
7108 						tdTagStart(true);
7109 						}
7110 						break;
7111 					case 21:
7112 						{
7113 						setState(896);
7114 						thTagStart(true);
7115 						}
7116 						break;
7117 					case 22:
7118 						{
7119 						setState(897);
7120 						bodyTagStart(true);
7121 						}
7122 						break;
7123 					case 23:
7124 						{
7125 						setState(898);
7126 						colgroupTagStart(true);
7127 						}
7128 						break;
7129 					case 24:
7130 						{
7131 						setState(899);
7132 						ddTagStart(true);
7133 						}
7134 						break;
7135 					case 25:
7136 						{
7137 						setState(900);
7138 						headTagStart(true);
7139 						}
7140 						break;
7141 					case 26:
7142 						{
7143 						setState(901);
7144 						htmlTagStart(true);
7145 						}
7146 						break;
7147 					case 27:
7148 						{
7149 						setState(902);
7150 						optionTagStart(true);
7151 						}
7152 						break;
7153 					case 28:
7154 						{
7155 						setState(903);
7156 						tbodyTagStart(true);
7157 						}
7158 						break;
7159 					case 29:
7160 						{
7161 						setState(904);
7162 						theadTagStart(true);
7163 						}
7164 						break;
7165 					case 30:
7166 						{
7167 						setState(905);
7168 						tfootTagStart(true);
7169 						}
7170 						break;
7171 					case 31:
7172 						{
7173 						{
7174 						setState(906);
7175 						if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
7176 						setState(907);
7177 						match(LEADING_ASTERISK);
7178 						}
7179 						}
7180 						break;
7181 					case 32:
7182 						{
7183 						setState(908);
7184 						htmlComment();
7185 						}
7186 						break;
7187 					case 33:
7188 						{
7189 						setState(909);
7190 						match(CDATA);
7191 						}
7192 						break;
7193 					case 34:
7194 						{
7195 						setState(910);
7196 						match(NEWLINE);
7197 						}
7198 						break;
7199 					case 35:
7200 						{
7201 						setState(911);
7202 						text();
7203 						}
7204 						break;
7205 					case 36:
7206 						{
7207 						setState(912);
7208 						javadocInlineTag();
7209 						}
7210 						break;
7211 					}
7212 					} 
7213 				}
7214 				setState(917);
7215 				_errHandler.sync(this);
7216 				_alt = getInterpreter().adaptivePredict(_input,58,_ctx);
7217 			}
7218 			setState(918);
7219 			dtTagEnd();
7220 			}
7221 		}
7222 		catch (RecognitionException re) {
7223 			_localctx.exception = re;
7224 			_errHandler.reportError(this, re);
7225 			_errHandler.recover(this, re);
7226 		}
7227 		finally {
7228 			exitRule();
7229 		}
7230 		return _localctx;
7231 	}
7232 
7233 	public static class HeadTagStartContext extends ParserRuleContext {
7234 		public boolean isNonTight;
7235 		public TerminalNode START() { return getToken(JavadocParser.START, 0); }
7236 		public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7237 		public TerminalNode END() { return getToken(JavadocParser.END, 0); }
7238 		public List<AttributeContext> attribute() {
7239 			return getRuleContexts(AttributeContext.class);
7240 		}
7241 		public AttributeContext attribute(int i) {
7242 			return getRuleContext(AttributeContext.class,i);
7243 		}
7244 		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7245 		public TerminalNode NEWLINE(int i) {
7246 			return getToken(JavadocParser.NEWLINE, i);
7247 		}
7248 		public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7249 		public TerminalNode LEADING_ASTERISK(int i) {
7250 			return getToken(JavadocParser.LEADING_ASTERISK, i);
7251 		}
7252 		public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7253 		public TerminalNode WS(int i) {
7254 			return getToken(JavadocParser.WS, i);
7255 		}
7256 		public HeadTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
7257 		public HeadTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
7258 			super(parent, invokingState);
7259 			this.isNonTight = isNonTight;
7260 		}
7261 		@Override public int getRuleIndex() { return RULE_headTagStart; }
7262 	}
7263 
7264 	public final HeadTagStartContext headTagStart(boolean isNonTight) throws RecognitionException {
7265 		HeadTagStartContext _localctx = new HeadTagStartContext(_ctx, getState(), isNonTight);
7266 		enterRule(_localctx, 66, RULE_headTagStart);
7267 		int _la;
7268 		try {
7269 			enterOuterAlt(_localctx, 1);
7270 			{
7271 			setState(920);
7272 			match(START);
7273 			setState(921);
7274 			match(HEAD_HTML_TAG_NAME);
7275 			setState(928);
7276 			_errHandler.sync(this);
7277 			_la = _input.LA(1);
7278 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
7279 				{
7280 				setState(926);
7281 				_errHandler.sync(this);
7282 				switch (_input.LA(1)) {
7283 				case HTML_TAG_NAME:
7284 					{
7285 					setState(922);
7286 					attribute();
7287 					}
7288 					break;
7289 				case NEWLINE:
7290 					{
7291 					setState(923);
7292 					match(NEWLINE);
7293 					}
7294 					break;
7295 				case LEADING_ASTERISK:
7296 					{
7297 					setState(924);
7298 					match(LEADING_ASTERISK);
7299 					}
7300 					break;
7301 				case WS:
7302 					{
7303 					setState(925);
7304 					match(WS);
7305 					}
7306 					break;
7307 				default:
7308 					throw new NoViableAltException(this);
7309 				}
7310 				}
7311 				setState(930);
7312 				_errHandler.sync(this);
7313 				_la = _input.LA(1);
7314 			}
7315 			setState(931);
7316 			match(END);
7317 			}
7318 			_ctx.stop = _input.LT(-1);
7319 
7320 			    if (isNonTight && nonTightTagStartContext == null) {
7321 			        nonTightTagStartContext = _localctx;
7322 			    }
7323 
7324 		}
7325 		catch (RecognitionException re) {
7326 			_localctx.exception = re;
7327 			_errHandler.reportError(this, re);
7328 			_errHandler.recover(this, re);
7329 		}
7330 		finally {
7331 			exitRule();
7332 		}
7333 		return _localctx;
7334 	}
7335 
7336 	public static class HeadTagEndContext extends ParserRuleContext {
7337 		public TerminalNode START() { return getToken(JavadocParser.START, 0); }
7338 		public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
7339 		public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7340 		public TerminalNode END() { return getToken(JavadocParser.END, 0); }
7341 		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7342 		public TerminalNode NEWLINE(int i) {
7343 			return getToken(JavadocParser.NEWLINE, i);
7344 		}
7345 		public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7346 		public TerminalNode LEADING_ASTERISK(int i) {
7347 			return getToken(JavadocParser.LEADING_ASTERISK, i);
7348 		}
7349 		public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7350 		public TerminalNode WS(int i) {
7351 			return getToken(JavadocParser.WS, i);
7352 		}
7353 		public HeadTagEndContext(ParserRuleContext parent, int invokingState) {
7354 			super(parent, invokingState);
7355 		}
7356 		@Override public int getRuleIndex() { return RULE_headTagEnd; }
7357 	}
7358 
7359 	public final HeadTagEndContext headTagEnd() throws RecognitionException {
7360 		HeadTagEndContext _localctx = new HeadTagEndContext(_ctx, getState());
7361 		enterRule(_localctx, 68, RULE_headTagEnd);
7362 		int _la;
7363 		try {
7364 			enterOuterAlt(_localctx, 1);
7365 			{
7366 			setState(933);
7367 			match(START);
7368 			setState(934);
7369 			match(SLASH);
7370 			setState(935);
7371 			match(HEAD_HTML_TAG_NAME);
7372 			setState(939);
7373 			_errHandler.sync(this);
7374 			_la = _input.LA(1);
7375 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
7376 				{
7377 				{
7378 				setState(936);
7379 				_la = _input.LA(1);
7380 				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
7381 				_errHandler.recoverInline(this);
7382 				}
7383 				else {
7384 					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
7385 					_errHandler.reportMatch(this);
7386 					consume();
7387 				}
7388 				}
7389 				}
7390 				setState(941);
7391 				_errHandler.sync(this);
7392 				_la = _input.LA(1);
7393 			}
7394 			setState(942);
7395 			match(END);
7396 			}
7397 		}
7398 		catch (RecognitionException re) {
7399 			_localctx.exception = re;
7400 			_errHandler.reportError(this, re);
7401 			_errHandler.recover(this, re);
7402 		}
7403 		finally {
7404 			exitRule();
7405 		}
7406 		return _localctx;
7407 	}
7408 
7409 	public static class HeadContext extends ParserRuleContext {
7410 		public HeadTagStartContext headTagStart() {
7411 			return getRuleContext(HeadTagStartContext.class,0);
7412 		}
7413 		public HeadTagEndContext headTagEnd() {
7414 			return getRuleContext(HeadTagEndContext.class,0);
7415 		}
7416 		public List<HtmlTagContext> htmlTag() {
7417 			return getRuleContexts(HtmlTagContext.class);
7418 		}
7419 		public HtmlTagContext htmlTag(int i) {
7420 			return getRuleContext(HtmlTagContext.class,i);
7421 		}
7422 		public List<SingletonElementContext> singletonElement() {
7423 			return getRuleContexts(SingletonElementContext.class);
7424 		}
7425 		public SingletonElementContext singletonElement(int i) {
7426 			return getRuleContext(SingletonElementContext.class,i);
7427 		}
7428 		public List<ParagraphContext> paragraph() {
7429 			return getRuleContexts(ParagraphContext.class);
7430 		}
7431 		public ParagraphContext paragraph(int i) {
7432 			return getRuleContext(ParagraphContext.class,i);
7433 		}
7434 		public List<LiContext> li() {
7435 			return getRuleContexts(LiContext.class);
7436 		}
7437 		public LiContext li(int i) {
7438 			return getRuleContext(LiContext.class,i);
7439 		}
7440 		public List<TrContext> tr() {
7441 			return getRuleContexts(TrContext.class);
7442 		}
7443 		public TrContext tr(int i) {
7444 			return getRuleContext(TrContext.class,i);
7445 		}
7446 		public List<TdContext> td() {
7447 			return getRuleContexts(TdContext.class);
7448 		}
7449 		public TdContext td(int i) {
7450 			return getRuleContext(TdContext.class,i);
7451 		}
7452 		public List<ThContext> th() {
7453 			return getRuleContexts(ThContext.class);
7454 		}
7455 		public ThContext th(int i) {
7456 			return getRuleContext(ThContext.class,i);
7457 		}
7458 		public List<BodyContext> body() {
7459 			return getRuleContexts(BodyContext.class);
7460 		}
7461 		public BodyContext body(int i) {
7462 			return getRuleContext(BodyContext.class,i);
7463 		}
7464 		public List<ColgroupContext> colgroup() {
7465 			return getRuleContexts(ColgroupContext.class);
7466 		}
7467 		public ColgroupContext colgroup(int i) {
7468 			return getRuleContext(ColgroupContext.class,i);
7469 		}
7470 		public List<DdContext> dd() {
7471 			return getRuleContexts(DdContext.class);
7472 		}
7473 		public DdContext dd(int i) {
7474 			return getRuleContext(DdContext.class,i);
7475 		}
7476 		public List<DtContext> dt() {
7477 			return getRuleContexts(DtContext.class);
7478 		}
7479 		public DtContext dt(int i) {
7480 			return getRuleContext(DtContext.class,i);
7481 		}
7482 		public List<HtmlContext> html() {
7483 			return getRuleContexts(HtmlContext.class);
7484 		}
7485 		public HtmlContext html(int i) {
7486 			return getRuleContext(HtmlContext.class,i);
7487 		}
7488 		public List<OptionContext> option() {
7489 			return getRuleContexts(OptionContext.class);
7490 		}
7491 		public OptionContext option(int i) {
7492 			return getRuleContext(OptionContext.class,i);
7493 		}
7494 		public List<TbodyContext> tbody() {
7495 			return getRuleContexts(TbodyContext.class);
7496 		}
7497 		public TbodyContext tbody(int i) {
7498 			return getRuleContext(TbodyContext.class,i);
7499 		}
7500 		public List<TheadContext> thead() {
7501 			return getRuleContexts(TheadContext.class);
7502 		}
7503 		public TheadContext thead(int i) {
7504 			return getRuleContext(TheadContext.class,i);
7505 		}
7506 		public List<TfootContext> tfoot() {
7507 			return getRuleContexts(TfootContext.class);
7508 		}
7509 		public TfootContext tfoot(int i) {
7510 			return getRuleContext(TfootContext.class,i);
7511 		}
7512 		public List<PTagStartContext> pTagStart() {
7513 			return getRuleContexts(PTagStartContext.class);
7514 		}
7515 		public PTagStartContext pTagStart(int i) {
7516 			return getRuleContext(PTagStartContext.class,i);
7517 		}
7518 		public List<LiTagStartContext> liTagStart() {
7519 			return getRuleContexts(LiTagStartContext.class);
7520 		}
7521 		public LiTagStartContext liTagStart(int i) {
7522 			return getRuleContext(LiTagStartContext.class,i);
7523 		}
7524 		public List<TrTagStartContext> trTagStart() {
7525 			return getRuleContexts(TrTagStartContext.class);
7526 		}
7527 		public TrTagStartContext trTagStart(int i) {
7528 			return getRuleContext(TrTagStartContext.class,i);
7529 		}
7530 		public List<TdTagStartContext> tdTagStart() {
7531 			return getRuleContexts(TdTagStartContext.class);
7532 		}
7533 		public TdTagStartContext tdTagStart(int i) {
7534 			return getRuleContext(TdTagStartContext.class,i);
7535 		}
7536 		public List<ThTagStartContext> thTagStart() {
7537 			return getRuleContexts(ThTagStartContext.class);
7538 		}
7539 		public ThTagStartContext thTagStart(int i) {
7540 			return getRuleContext(ThTagStartContext.class,i);
7541 		}
7542 		public List<BodyTagStartContext> bodyTagStart() {
7543 			return getRuleContexts(BodyTagStartContext.class);
7544 		}
7545 		public BodyTagStartContext bodyTagStart(int i) {
7546 			return getRuleContext(BodyTagStartContext.class,i);
7547 		}
7548 		public List<ColgroupTagStartContext> colgroupTagStart() {
7549 			return getRuleContexts(ColgroupTagStartContext.class);
7550 		}
7551 		public ColgroupTagStartContext colgroupTagStart(int i) {
7552 			return getRuleContext(ColgroupTagStartContext.class,i);
7553 		}
7554 		public List<DdTagStartContext> ddTagStart() {
7555 			return getRuleContexts(DdTagStartContext.class);
7556 		}
7557 		public DdTagStartContext ddTagStart(int i) {
7558 			return getRuleContext(DdTagStartContext.class,i);
7559 		}
7560 		public List<DtTagStartContext> dtTagStart() {
7561 			return getRuleContexts(DtTagStartContext.class);
7562 		}
7563 		public DtTagStartContext dtTagStart(int i) {
7564 			return getRuleContext(DtTagStartContext.class,i);
7565 		}
7566 		public List<HtmlTagStartContext> htmlTagStart() {
7567 			return getRuleContexts(HtmlTagStartContext.class);
7568 		}
7569 		public HtmlTagStartContext htmlTagStart(int i) {
7570 			return getRuleContext(HtmlTagStartContext.class,i);
7571 		}
7572 		public List<OptionTagStartContext> optionTagStart() {
7573 			return getRuleContexts(OptionTagStartContext.class);
7574 		}
7575 		public OptionTagStartContext optionTagStart(int i) {
7576 			return getRuleContext(OptionTagStartContext.class,i);
7577 		}
7578 		public List<TbodyTagStartContext> tbodyTagStart() {
7579 			return getRuleContexts(TbodyTagStartContext.class);
7580 		}
7581 		public TbodyTagStartContext tbodyTagStart(int i) {
7582 			return getRuleContext(TbodyTagStartContext.class,i);
7583 		}
7584 		public List<TheadTagStartContext> theadTagStart() {
7585 			return getRuleContexts(TheadTagStartContext.class);
7586 		}
7587 		public TheadTagStartContext theadTagStart(int i) {
7588 			return getRuleContext(TheadTagStartContext.class,i);
7589 		}
7590 		public List<TfootTagStartContext> tfootTagStart() {
7591 			return getRuleContexts(TfootTagStartContext.class);
7592 		}
7593 		public TfootTagStartContext tfootTagStart(int i) {
7594 			return getRuleContext(TfootTagStartContext.class,i);
7595 		}
7596 		public List<HtmlCommentContext> htmlComment() {
7597 			return getRuleContexts(HtmlCommentContext.class);
7598 		}
7599 		public HtmlCommentContext htmlComment(int i) {
7600 			return getRuleContext(HtmlCommentContext.class,i);
7601 		}
7602 		public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
7603 		public TerminalNode CDATA(int i) {
7604 			return getToken(JavadocParser.CDATA, i);
7605 		}
7606 		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7607 		public TerminalNode NEWLINE(int i) {
7608 			return getToken(JavadocParser.NEWLINE, i);
7609 		}
7610 		public List<TextContext> text() {
7611 			return getRuleContexts(TextContext.class);
7612 		}
7613 		public TextContext text(int i) {
7614 			return getRuleContext(TextContext.class,i);
7615 		}
7616 		public List<JavadocInlineTagContext> javadocInlineTag() {
7617 			return getRuleContexts(JavadocInlineTagContext.class);
7618 		}
7619 		public JavadocInlineTagContext javadocInlineTag(int i) {
7620 			return getRuleContext(JavadocInlineTagContext.class,i);
7621 		}
7622 		public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7623 		public TerminalNode LEADING_ASTERISK(int i) {
7624 			return getToken(JavadocParser.LEADING_ASTERISK, i);
7625 		}
7626 		public HeadContext(ParserRuleContext parent, int invokingState) {
7627 			super(parent, invokingState);
7628 		}
7629 		@Override public int getRuleIndex() { return RULE_head; }
7630 	}
7631 
7632 	public final HeadContext head() throws RecognitionException {
7633 		HeadContext _localctx = new HeadContext(_ctx, getState());
7634 		enterRule(_localctx, 70, RULE_head);
7635 		try {
7636 			int _alt;
7637 			enterOuterAlt(_localctx, 1);
7638 			{
7639 			setState(944);
7640 			headTagStart(false);
7641 			setState(984);
7642 			_errHandler.sync(this);
7643 			_alt = getInterpreter().adaptivePredict(_input,63,_ctx);
7644 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
7645 				if ( _alt==1 ) {
7646 					{
7647 					setState(982);
7648 					_errHandler.sync(this);
7649 					switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
7650 					case 1:
7651 						{
7652 						setState(945);
7653 						htmlTag();
7654 						}
7655 						break;
7656 					case 2:
7657 						{
7658 						setState(946);
7659 						singletonElement();
7660 						}
7661 						break;
7662 					case 3:
7663 						{
7664 						setState(947);
7665 						paragraph();
7666 						}
7667 						break;
7668 					case 4:
7669 						{
7670 						setState(948);
7671 						li();
7672 						}
7673 						break;
7674 					case 5:
7675 						{
7676 						setState(949);
7677 						tr();
7678 						}
7679 						break;
7680 					case 6:
7681 						{
7682 						setState(950);
7683 						td();
7684 						}
7685 						break;
7686 					case 7:
7687 						{
7688 						setState(951);
7689 						th();
7690 						}
7691 						break;
7692 					case 8:
7693 						{
7694 						setState(952);
7695 						body();
7696 						}
7697 						break;
7698 					case 9:
7699 						{
7700 						setState(953);
7701 						colgroup();
7702 						}
7703 						break;
7704 					case 10:
7705 						{
7706 						setState(954);
7707 						dd();
7708 						}
7709 						break;
7710 					case 11:
7711 						{
7712 						setState(955);
7713 						dt();
7714 						}
7715 						break;
7716 					case 12:
7717 						{
7718 						setState(956);
7719 						html();
7720 						}
7721 						break;
7722 					case 13:
7723 						{
7724 						setState(957);
7725 						option();
7726 						}
7727 						break;
7728 					case 14:
7729 						{
7730 						setState(958);
7731 						tbody();
7732 						}
7733 						break;
7734 					case 15:
7735 						{
7736 						setState(959);
7737 						thead();
7738 						}
7739 						break;
7740 					case 16:
7741 						{
7742 						setState(960);
7743 						tfoot();
7744 						}
7745 						break;
7746 					case 17:
7747 						{
7748 						setState(961);
7749 						pTagStart(true);
7750 						}
7751 						break;
7752 					case 18:
7753 						{
7754 						setState(962);
7755 						liTagStart(true);
7756 						}
7757 						break;
7758 					case 19:
7759 						{
7760 						setState(963);
7761 						trTagStart(true);
7762 						}
7763 						break;
7764 					case 20:
7765 						{
7766 						setState(964);
7767 						tdTagStart(true);
7768 						}
7769 						break;
7770 					case 21:
7771 						{
7772 						setState(965);
7773 						thTagStart(true);
7774 						}
7775 						break;
7776 					case 22:
7777 						{
7778 						setState(966);
7779 						bodyTagStart(true);
7780 						}
7781 						break;
7782 					case 23:
7783 						{
7784 						setState(967);
7785 						colgroupTagStart(true);
7786 						}
7787 						break;
7788 					case 24:
7789 						{
7790 						setState(968);
7791 						ddTagStart(true);
7792 						}
7793 						break;
7794 					case 25:
7795 						{
7796 						setState(969);
7797 						dtTagStart(true);
7798 						}
7799 						break;
7800 					case 26:
7801 						{
7802 						setState(970);
7803 						htmlTagStart(true);
7804 						}
7805 						break;
7806 					case 27:
7807 						{
7808 						setState(971);
7809 						optionTagStart(true);
7810 						}
7811 						break;
7812 					case 28:
7813 						{
7814 						setState(972);
7815 						tbodyTagStart(true);
7816 						}
7817 						break;
7818 					case 29:
7819 						{
7820 						setState(973);
7821 						theadTagStart(true);
7822 						}
7823 						break;
7824 					case 30:
7825 						{
7826 						setState(974);
7827 						tfootTagStart(true);
7828 						}
7829 						break;
7830 					case 31:
7831 						{
7832 						{
7833 						setState(975);
7834 						if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
7835 						setState(976);
7836 						match(LEADING_ASTERISK);
7837 						}
7838 						}
7839 						break;
7840 					case 32:
7841 						{
7842 						setState(977);
7843 						htmlComment();
7844 						}
7845 						break;
7846 					case 33:
7847 						{
7848 						setState(978);
7849 						match(CDATA);
7850 						}
7851 						break;
7852 					case 34:
7853 						{
7854 						setState(979);
7855 						match(NEWLINE);
7856 						}
7857 						break;
7858 					case 35:
7859 						{
7860 						setState(980);
7861 						text();
7862 						}
7863 						break;
7864 					case 36:
7865 						{
7866 						setState(981);
7867 						javadocInlineTag();
7868 						}
7869 						break;
7870 					}
7871 					} 
7872 				}
7873 				setState(986);
7874 				_errHandler.sync(this);
7875 				_alt = getInterpreter().adaptivePredict(_input,63,_ctx);
7876 			}
7877 			setState(987);
7878 			headTagEnd();
7879 			}
7880 		}
7881 		catch (RecognitionException re) {
7882 			_localctx.exception = re;
7883 			_errHandler.reportError(this, re);
7884 			_errHandler.recover(this, re);
7885 		}
7886 		finally {
7887 			exitRule();
7888 		}
7889 		return _localctx;
7890 	}
7891 
7892 	public static class HtmlTagStartContext extends ParserRuleContext {
7893 		public boolean isNonTight;
7894 		public TerminalNode START() { return getToken(JavadocParser.START, 0); }
7895 		public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
7896 		public TerminalNode END() { return getToken(JavadocParser.END, 0); }
7897 		public List<AttributeContext> attribute() {
7898 			return getRuleContexts(AttributeContext.class);
7899 		}
7900 		public AttributeContext attribute(int i) {
7901 			return getRuleContext(AttributeContext.class,i);
7902 		}
7903 		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7904 		public TerminalNode NEWLINE(int i) {
7905 			return getToken(JavadocParser.NEWLINE, i);
7906 		}
7907 		public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7908 		public TerminalNode LEADING_ASTERISK(int i) {
7909 			return getToken(JavadocParser.LEADING_ASTERISK, i);
7910 		}
7911 		public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7912 		public TerminalNode WS(int i) {
7913 			return getToken(JavadocParser.WS, i);
7914 		}
7915 		public HtmlTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
7916 		public HtmlTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
7917 			super(parent, invokingState);
7918 			this.isNonTight = isNonTight;
7919 		}
7920 		@Override public int getRuleIndex() { return RULE_htmlTagStart; }
7921 	}
7922 
7923 	public final HtmlTagStartContext htmlTagStart(boolean isNonTight) throws RecognitionException {
7924 		HtmlTagStartContext _localctx = new HtmlTagStartContext(_ctx, getState(), isNonTight);
7925 		enterRule(_localctx, 72, RULE_htmlTagStart);
7926 		int _la;
7927 		try {
7928 			enterOuterAlt(_localctx, 1);
7929 			{
7930 			setState(989);
7931 			match(START);
7932 			setState(990);
7933 			match(HTML_HTML_TAG_NAME);
7934 			setState(997);
7935 			_errHandler.sync(this);
7936 			_la = _input.LA(1);
7937 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
7938 				{
7939 				setState(995);
7940 				_errHandler.sync(this);
7941 				switch (_input.LA(1)) {
7942 				case HTML_TAG_NAME:
7943 					{
7944 					setState(991);
7945 					attribute();
7946 					}
7947 					break;
7948 				case NEWLINE:
7949 					{
7950 					setState(992);
7951 					match(NEWLINE);
7952 					}
7953 					break;
7954 				case LEADING_ASTERISK:
7955 					{
7956 					setState(993);
7957 					match(LEADING_ASTERISK);
7958 					}
7959 					break;
7960 				case WS:
7961 					{
7962 					setState(994);
7963 					match(WS);
7964 					}
7965 					break;
7966 				default:
7967 					throw new NoViableAltException(this);
7968 				}
7969 				}
7970 				setState(999);
7971 				_errHandler.sync(this);
7972 				_la = _input.LA(1);
7973 			}
7974 			setState(1000);
7975 			match(END);
7976 			}
7977 			_ctx.stop = _input.LT(-1);
7978 
7979 			    if (isNonTight && nonTightTagStartContext == null) {
7980 			        nonTightTagStartContext = _localctx;
7981 			    }
7982 
7983 		}
7984 		catch (RecognitionException re) {
7985 			_localctx.exception = re;
7986 			_errHandler.reportError(this, re);
7987 			_errHandler.recover(this, re);
7988 		}
7989 		finally {
7990 			exitRule();
7991 		}
7992 		return _localctx;
7993 	}
7994 
7995 	public static class HtmlTagEndContext extends ParserRuleContext {
7996 		public TerminalNode START() { return getToken(JavadocParser.START, 0); }
7997 		public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
7998 		public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
7999 		public TerminalNode END() { return getToken(JavadocParser.END, 0); }
8000 		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8001 		public TerminalNode NEWLINE(int i) {
8002 			return getToken(JavadocParser.NEWLINE, i);
8003 		}
8004 		public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8005 		public TerminalNode LEADING_ASTERISK(int i) {
8006 			return getToken(JavadocParser.LEADING_ASTERISK, i);
8007 		}
8008 		public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8009 		public TerminalNode WS(int i) {
8010 			return getToken(JavadocParser.WS, i);
8011 		}
8012 		public HtmlTagEndContext(ParserRuleContext parent, int invokingState) {
8013 			super(parent, invokingState);
8014 		}
8015 		@Override public int getRuleIndex() { return RULE_htmlTagEnd; }
8016 	}
8017 
8018 	public final HtmlTagEndContext htmlTagEnd() throws RecognitionException {
8019 		HtmlTagEndContext _localctx = new HtmlTagEndContext(_ctx, getState());
8020 		enterRule(_localctx, 74, RULE_htmlTagEnd);
8021 		int _la;
8022 		try {
8023 			enterOuterAlt(_localctx, 1);
8024 			{
8025 			setState(1002);
8026 			match(START);
8027 			setState(1003);
8028 			match(SLASH);
8029 			setState(1004);
8030 			match(HTML_HTML_TAG_NAME);
8031 			setState(1008);
8032 			_errHandler.sync(this);
8033 			_la = _input.LA(1);
8034 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
8035 				{
8036 				{
8037 				setState(1005);
8038 				_la = _input.LA(1);
8039 				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
8040 				_errHandler.recoverInline(this);
8041 				}
8042 				else {
8043 					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
8044 					_errHandler.reportMatch(this);
8045 					consume();
8046 				}
8047 				}
8048 				}
8049 				setState(1010);
8050 				_errHandler.sync(this);
8051 				_la = _input.LA(1);
8052 			}
8053 			setState(1011);
8054 			match(END);
8055 			}
8056 		}
8057 		catch (RecognitionException re) {
8058 			_localctx.exception = re;
8059 			_errHandler.reportError(this, re);
8060 			_errHandler.recover(this, re);
8061 		}
8062 		finally {
8063 			exitRule();
8064 		}
8065 		return _localctx;
8066 	}
8067 
8068 	public static class HtmlContext extends ParserRuleContext {
8069 		public HtmlTagStartContext htmlTagStart() {
8070 			return getRuleContext(HtmlTagStartContext.class,0);
8071 		}
8072 		public HtmlTagEndContext htmlTagEnd() {
8073 			return getRuleContext(HtmlTagEndContext.class,0);
8074 		}
8075 		public List<HtmlTagContext> htmlTag() {
8076 			return getRuleContexts(HtmlTagContext.class);
8077 		}
8078 		public HtmlTagContext htmlTag(int i) {
8079 			return getRuleContext(HtmlTagContext.class,i);
8080 		}
8081 		public List<SingletonElementContext> singletonElement() {
8082 			return getRuleContexts(SingletonElementContext.class);
8083 		}
8084 		public SingletonElementContext singletonElement(int i) {
8085 			return getRuleContext(SingletonElementContext.class,i);
8086 		}
8087 		public List<ParagraphContext> paragraph() {
8088 			return getRuleContexts(ParagraphContext.class);
8089 		}
8090 		public ParagraphContext paragraph(int i) {
8091 			return getRuleContext(ParagraphContext.class,i);
8092 		}
8093 		public List<LiContext> li() {
8094 			return getRuleContexts(LiContext.class);
8095 		}
8096 		public LiContext li(int i) {
8097 			return getRuleContext(LiContext.class,i);
8098 		}
8099 		public List<TrContext> tr() {
8100 			return getRuleContexts(TrContext.class);
8101 		}
8102 		public TrContext tr(int i) {
8103 			return getRuleContext(TrContext.class,i);
8104 		}
8105 		public List<TdContext> td() {
8106 			return getRuleContexts(TdContext.class);
8107 		}
8108 		public TdContext td(int i) {
8109 			return getRuleContext(TdContext.class,i);
8110 		}
8111 		public List<ThContext> th() {
8112 			return getRuleContexts(ThContext.class);
8113 		}
8114 		public ThContext th(int i) {
8115 			return getRuleContext(ThContext.class,i);
8116 		}
8117 		public List<BodyContext> body() {
8118 			return getRuleContexts(BodyContext.class);
8119 		}
8120 		public BodyContext body(int i) {
8121 			return getRuleContext(BodyContext.class,i);
8122 		}
8123 		public List<ColgroupContext> colgroup() {
8124 			return getRuleContexts(ColgroupContext.class);
8125 		}
8126 		public ColgroupContext colgroup(int i) {
8127 			return getRuleContext(ColgroupContext.class,i);
8128 		}
8129 		public List<DdContext> dd() {
8130 			return getRuleContexts(DdContext.class);
8131 		}
8132 		public DdContext dd(int i) {
8133 			return getRuleContext(DdContext.class,i);
8134 		}
8135 		public List<DtContext> dt() {
8136 			return getRuleContexts(DtContext.class);
8137 		}
8138 		public DtContext dt(int i) {
8139 			return getRuleContext(DtContext.class,i);
8140 		}
8141 		public List<HeadContext> head() {
8142 			return getRuleContexts(HeadContext.class);
8143 		}
8144 		public HeadContext head(int i) {
8145 			return getRuleContext(HeadContext.class,i);
8146 		}
8147 		public List<OptionContext> option() {
8148 			return getRuleContexts(OptionContext.class);
8149 		}
8150 		public OptionContext option(int i) {
8151 			return getRuleContext(OptionContext.class,i);
8152 		}
8153 		public List<TbodyContext> tbody() {
8154 			return getRuleContexts(TbodyContext.class);
8155 		}
8156 		public TbodyContext tbody(int i) {
8157 			return getRuleContext(TbodyContext.class,i);
8158 		}
8159 		public List<TheadContext> thead() {
8160 			return getRuleContexts(TheadContext.class);
8161 		}
8162 		public TheadContext thead(int i) {
8163 			return getRuleContext(TheadContext.class,i);
8164 		}
8165 		public List<TfootContext> tfoot() {
8166 			return getRuleContexts(TfootContext.class);
8167 		}
8168 		public TfootContext tfoot(int i) {
8169 			return getRuleContext(TfootContext.class,i);
8170 		}
8171 		public List<PTagStartContext> pTagStart() {
8172 			return getRuleContexts(PTagStartContext.class);
8173 		}
8174 		public PTagStartContext pTagStart(int i) {
8175 			return getRuleContext(PTagStartContext.class,i);
8176 		}
8177 		public List<LiTagStartContext> liTagStart() {
8178 			return getRuleContexts(LiTagStartContext.class);
8179 		}
8180 		public LiTagStartContext liTagStart(int i) {
8181 			return getRuleContext(LiTagStartContext.class,i);
8182 		}
8183 		public List<TrTagStartContext> trTagStart() {
8184 			return getRuleContexts(TrTagStartContext.class);
8185 		}
8186 		public TrTagStartContext trTagStart(int i) {
8187 			return getRuleContext(TrTagStartContext.class,i);
8188 		}
8189 		public List<TdTagStartContext> tdTagStart() {
8190 			return getRuleContexts(TdTagStartContext.class);
8191 		}
8192 		public TdTagStartContext tdTagStart(int i) {
8193 			return getRuleContext(TdTagStartContext.class,i);
8194 		}
8195 		public List<ThTagStartContext> thTagStart() {
8196 			return getRuleContexts(ThTagStartContext.class);
8197 		}
8198 		public ThTagStartContext thTagStart(int i) {
8199 			return getRuleContext(ThTagStartContext.class,i);
8200 		}
8201 		public List<BodyTagStartContext> bodyTagStart() {
8202 			return getRuleContexts(BodyTagStartContext.class);
8203 		}
8204 		public BodyTagStartContext bodyTagStart(int i) {
8205 			return getRuleContext(BodyTagStartContext.class,i);
8206 		}
8207 		public List<ColgroupTagStartContext> colgroupTagStart() {
8208 			return getRuleContexts(ColgroupTagStartContext.class);
8209 		}
8210 		public ColgroupTagStartContext colgroupTagStart(int i) {
8211 			return getRuleContext(ColgroupTagStartContext.class,i);
8212 		}
8213 		public List<DdTagStartContext> ddTagStart() {
8214 			return getRuleContexts(DdTagStartContext.class);
8215 		}
8216 		public DdTagStartContext ddTagStart(int i) {
8217 			return getRuleContext(DdTagStartContext.class,i);
8218 		}
8219 		public List<DtTagStartContext> dtTagStart() {
8220 			return getRuleContexts(DtTagStartContext.class);
8221 		}
8222 		public DtTagStartContext dtTagStart(int i) {
8223 			return getRuleContext(DtTagStartContext.class,i);
8224 		}
8225 		public List<HeadTagStartContext> headTagStart() {
8226 			return getRuleContexts(HeadTagStartContext.class);
8227 		}
8228 		public HeadTagStartContext headTagStart(int i) {
8229 			return getRuleContext(HeadTagStartContext.class,i);
8230 		}
8231 		public List<OptionTagStartContext> optionTagStart() {
8232 			return getRuleContexts(OptionTagStartContext.class);
8233 		}
8234 		public OptionTagStartContext optionTagStart(int i) {
8235 			return getRuleContext(OptionTagStartContext.class,i);
8236 		}
8237 		public List<TbodyTagStartContext> tbodyTagStart() {
8238 			return getRuleContexts(TbodyTagStartContext.class);
8239 		}
8240 		public TbodyTagStartContext tbodyTagStart(int i) {
8241 			return getRuleContext(TbodyTagStartContext.class,i);
8242 		}
8243 		public List<TheadTagStartContext> theadTagStart() {
8244 			return getRuleContexts(TheadTagStartContext.class);
8245 		}
8246 		public TheadTagStartContext theadTagStart(int i) {
8247 			return getRuleContext(TheadTagStartContext.class,i);
8248 		}
8249 		public List<TfootTagStartContext> tfootTagStart() {
8250 			return getRuleContexts(TfootTagStartContext.class);
8251 		}
8252 		public TfootTagStartContext tfootTagStart(int i) {
8253 			return getRuleContext(TfootTagStartContext.class,i);
8254 		}
8255 		public List<HtmlCommentContext> htmlComment() {
8256 			return getRuleContexts(HtmlCommentContext.class);
8257 		}
8258 		public HtmlCommentContext htmlComment(int i) {
8259 			return getRuleContext(HtmlCommentContext.class,i);
8260 		}
8261 		public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
8262 		public TerminalNode CDATA(int i) {
8263 			return getToken(JavadocParser.CDATA, i);
8264 		}
8265 		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8266 		public TerminalNode NEWLINE(int i) {
8267 			return getToken(JavadocParser.NEWLINE, i);
8268 		}
8269 		public List<TextContext> text() {
8270 			return getRuleContexts(TextContext.class);
8271 		}
8272 		public TextContext text(int i) {
8273 			return getRuleContext(TextContext.class,i);
8274 		}
8275 		public List<JavadocInlineTagContext> javadocInlineTag() {
8276 			return getRuleContexts(JavadocInlineTagContext.class);
8277 		}
8278 		public JavadocInlineTagContext javadocInlineTag(int i) {
8279 			return getRuleContext(JavadocInlineTagContext.class,i);
8280 		}
8281 		public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8282 		public TerminalNode LEADING_ASTERISK(int i) {
8283 			return getToken(JavadocParser.LEADING_ASTERISK, i);
8284 		}
8285 		public HtmlContext(ParserRuleContext parent, int invokingState) {
8286 			super(parent, invokingState);
8287 		}
8288 		@Override public int getRuleIndex() { return RULE_html; }
8289 	}
8290 
8291 	public final HtmlContext html() throws RecognitionException {
8292 		HtmlContext _localctx = new HtmlContext(_ctx, getState());
8293 		enterRule(_localctx, 76, RULE_html);
8294 		try {
8295 			int _alt;
8296 			enterOuterAlt(_localctx, 1);
8297 			{
8298 			setState(1013);
8299 			htmlTagStart(false);
8300 			setState(1053);
8301 			_errHandler.sync(this);
8302 			_alt = getInterpreter().adaptivePredict(_input,68,_ctx);
8303 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8304 				if ( _alt==1 ) {
8305 					{
8306 					setState(1051);
8307 					_errHandler.sync(this);
8308 					switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) {
8309 					case 1:
8310 						{
8311 						setState(1014);
8312 						htmlTag();
8313 						}
8314 						break;
8315 					case 2:
8316 						{
8317 						setState(1015);
8318 						singletonElement();
8319 						}
8320 						break;
8321 					case 3:
8322 						{
8323 						setState(1016);
8324 						paragraph();
8325 						}
8326 						break;
8327 					case 4:
8328 						{
8329 						setState(1017);
8330 						li();
8331 						}
8332 						break;
8333 					case 5:
8334 						{
8335 						setState(1018);
8336 						tr();
8337 						}
8338 						break;
8339 					case 6:
8340 						{
8341 						setState(1019);
8342 						td();
8343 						}
8344 						break;
8345 					case 7:
8346 						{
8347 						setState(1020);
8348 						th();
8349 						}
8350 						break;
8351 					case 8:
8352 						{
8353 						setState(1021);
8354 						body();
8355 						}
8356 						break;
8357 					case 9:
8358 						{
8359 						setState(1022);
8360 						colgroup();
8361 						}
8362 						break;
8363 					case 10:
8364 						{
8365 						setState(1023);
8366 						dd();
8367 						}
8368 						break;
8369 					case 11:
8370 						{
8371 						setState(1024);
8372 						dt();
8373 						}
8374 						break;
8375 					case 12:
8376 						{
8377 						setState(1025);
8378 						head();
8379 						}
8380 						break;
8381 					case 13:
8382 						{
8383 						setState(1026);
8384 						option();
8385 						}
8386 						break;
8387 					case 14:
8388 						{
8389 						setState(1027);
8390 						tbody();
8391 						}
8392 						break;
8393 					case 15:
8394 						{
8395 						setState(1028);
8396 						thead();
8397 						}
8398 						break;
8399 					case 16:
8400 						{
8401 						setState(1029);
8402 						tfoot();
8403 						}
8404 						break;
8405 					case 17:
8406 						{
8407 						setState(1030);
8408 						pTagStart(true);
8409 						}
8410 						break;
8411 					case 18:
8412 						{
8413 						setState(1031);
8414 						liTagStart(true);
8415 						}
8416 						break;
8417 					case 19:
8418 						{
8419 						setState(1032);
8420 						trTagStart(true);
8421 						}
8422 						break;
8423 					case 20:
8424 						{
8425 						setState(1033);
8426 						tdTagStart(true);
8427 						}
8428 						break;
8429 					case 21:
8430 						{
8431 						setState(1034);
8432 						thTagStart(true);