001// Generated from com\puppycrawl\tools\checkstyle\grammar\javadoc\JavadocParser.g4 by ANTLR 4.8 002package com.puppycrawl.tools.checkstyle.grammar.javadoc; 003import org.antlr.v4.runtime.atn.*; 004import org.antlr.v4.runtime.dfa.DFA; 005import org.antlr.v4.runtime.*; 006import org.antlr.v4.runtime.misc.*; 007import org.antlr.v4.runtime.tree.*; 008import java.util.List; 009import java.util.Iterator; 010import java.util.ArrayList; 011 012@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) 013public class JavadocParser extends Parser { 014 static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); } 015 016 protected static final DFA[] _decisionToDFA; 017 protected static final PredictionContextCache _sharedContextCache = 018 new PredictionContextCache(); 019 public static final int 020 LEADING_ASTERISK=1, HTML_COMMENT_START=2, DEPRECATED_CDATA_DO_NOT_USE=3, 021 WS=4, START=5, NEWLINE=6, AUTHOR_LITERAL=7, DEPRECATED_LITERAL=8, EXCEPTION_LITERAL=9, 022 PARAM_LITERAL=10, RETURN_LITERAL=11, SEE_LITERAL=12, SERIAL_LITERAL=13, 023 SERIAL_FIELD_LITERAL=14, SERIAL_DATA_LITERAL=15, SINCE_LITERAL=16, THROWS_LITERAL=17, 024 VERSION_LITERAL=18, JAVADOC_INLINE_TAG_START=19, JAVADOC_INLINE_TAG_END=20, 025 CUSTOM_NAME=21, LITERAL_INCLUDE=22, LITERAL_EXCLUDE=23, CHAR=24, PARAMETER_NAME=25, 026 Char1=26, STRING=27, PACKAGE_CLASS=28, DOT=29, HASH=30, CLASS=31, Char2=32, 027 MEMBER=33, LEFT_BRACE=34, RIGHT_BRACE=35, ARGUMENT=36, COMMA=37, Char20=38, 028 FIELD_NAME=39, Char3=40, FIELD_TYPE=41, Char4=42, CLASS_NAME=43, Char5=44, 029 CODE_LITERAL=45, DOC_ROOT_LITERAL=46, INHERIT_DOC_LITERAL=47, LINK_LITERAL=48, 030 LINKPLAIN_LITERAL=49, LITERAL_LITERAL=50, VALUE_LITERAL=51, Char7=52, 031 Char8=53, Char10=54, END=55, SLASH_END=56, SLASH=57, EQUALS=58, P_HTML_TAG_NAME=59, 032 LI_HTML_TAG_NAME=60, TR_HTML_TAG_NAME=61, TD_HTML_TAG_NAME=62, TH_HTML_TAG_NAME=63, 033 BODY_HTML_TAG_NAME=64, COLGROUP_HTML_TAG_NAME=65, DD_HTML_TAG_NAME=66, 034 DT_HTML_TAG_NAME=67, HEAD_HTML_TAG_NAME=68, HTML_HTML_TAG_NAME=69, OPTION_HTML_TAG_NAME=70, 035 TBODY_HTML_TAG_NAME=71, TFOOT_HTML_TAG_NAME=72, THEAD_HTML_TAG_NAME=73, 036 AREA_HTML_TAG_NAME=74, BASE_HTML_TAG_NAME=75, BASEFONT_HTML_TAG_NAME=76, 037 BR_HTML_TAG_NAME=77, COL_HTML_TAG_NAME=78, FRAME_HTML_TAG_NAME=79, HR_HTML_TAG_NAME=80, 038 IMG_HTML_TAG_NAME=81, INPUT_HTML_TAG_NAME=82, ISINDEX_HTML_TAG_NAME=83, 039 LINK_HTML_TAG_NAME=84, META_HTML_TAG_NAME=85, PARAM_HTML_TAG_NAME=86, 040 EMBED_HTML_TAG_NAME=87, KEYGEN_HTML_TAG_NAME=88, ATTR_VALUE=89, Char12=90, 041 HTML_COMMENT_END=91, SOURCE_HTML_TAG_NAME=92, TRACK_HTML_TAG_NAME=93, 042 WBR_HTML_TAG_NAME=94, OPTGROUP_HTML_TAG_NAME=95, RB_HTML_TAG_NAME=96, 043 RT_HTML_TAG_NAME=97, RTC_HTML_TAG_NAME=98, RP_HTML_TAG_NAME=99, HTML_TAG_NAME=100, 044 Char11=101; 045 public static final int 046 RULE_javadoc = 0, RULE_htmlElement = 1, RULE_htmlElementStart = 2, RULE_htmlElementEnd = 3, 047 RULE_attribute = 4, RULE_htmlTag = 5, RULE_pTagStart = 6, RULE_pTagEnd = 7, 048 RULE_paragraph = 8, RULE_liTagStart = 9, RULE_liTagEnd = 10, RULE_li = 11, 049 RULE_trTagStart = 12, RULE_trTagEnd = 13, RULE_tr = 14, RULE_tdTagStart = 15, 050 RULE_tdTagEnd = 16, RULE_td = 17, RULE_thTagStart = 18, RULE_thTagEnd = 19, 051 RULE_th = 20, RULE_bodyTagStart = 21, RULE_bodyTagEnd = 22, RULE_body = 23, 052 RULE_colgroupTagStart = 24, RULE_colgroupTagEnd = 25, RULE_colgroup = 26, 053 RULE_ddTagStart = 27, RULE_ddTagEnd = 28, RULE_dd = 29, RULE_dtTagStart = 30, 054 RULE_dtTagEnd = 31, RULE_dt = 32, RULE_headTagStart = 33, RULE_headTagEnd = 34, 055 RULE_head = 35, RULE_htmlTagStart = 36, RULE_htmlTagEnd = 37, RULE_html = 38, 056 RULE_optionTagStart = 39, RULE_optionTagEnd = 40, RULE_option = 41, RULE_tbodyTagStart = 42, 057 RULE_tbodyTagEnd = 43, RULE_tbody = 44, RULE_tfootTagStart = 45, RULE_tfootTagEnd = 46, 058 RULE_tfoot = 47, RULE_theadTagStart = 48, RULE_theadTagEnd = 49, RULE_thead = 50, 059 RULE_singletonElement = 51, RULE_emptyTag = 52, RULE_areaTag = 53, RULE_baseTag = 54, 060 RULE_basefontTag = 55, RULE_brTag = 56, RULE_colTag = 57, RULE_frameTag = 58, 061 RULE_hrTag = 59, RULE_imgTag = 60, RULE_inputTag = 61, RULE_isindexTag = 62, 062 RULE_linkTag = 63, RULE_metaTag = 64, RULE_paramTag = 65, RULE_wrongSingletonTag = 66, 063 RULE_singletonTagName = 67, RULE_description = 68, RULE_reference = 69, 064 RULE_parameters = 70, RULE_javadocTag = 71, RULE_javadocInlineTag = 72, 065 RULE_htmlComment = 73, RULE_text = 74, RULE_embedTag = 75, RULE_keygenTag = 76, 066 RULE_sourceTag = 77, RULE_trackTag = 78, RULE_wbrTag = 79, RULE_optgroupTagStart = 80, 067 RULE_optgroupTagEnd = 81, RULE_optgroup = 82, RULE_rbTagStart = 83, RULE_rbTagEnd = 84, 068 RULE_rb = 85, RULE_rtTagStart = 86, RULE_rtTagEnd = 87, RULE_rt = 88, 069 RULE_rtcTagStart = 89, RULE_rtcTagEnd = 90, RULE_rtc = 91, RULE_rpTagStart = 92, 070 RULE_rpTagEnd = 93, RULE_rp = 94; 071 private static String[] makeRuleNames() { 072 return new String[] { 073 "javadoc", "htmlElement", "htmlElementStart", "htmlElementEnd", "attribute", 074 "htmlTag", "pTagStart", "pTagEnd", "paragraph", "liTagStart", "liTagEnd", 075 "li", "trTagStart", "trTagEnd", "tr", "tdTagStart", "tdTagEnd", "td", 076 "thTagStart", "thTagEnd", "th", "bodyTagStart", "bodyTagEnd", "body", 077 "colgroupTagStart", "colgroupTagEnd", "colgroup", "ddTagStart", "ddTagEnd", 078 "dd", "dtTagStart", "dtTagEnd", "dt", "headTagStart", "headTagEnd", "head", 079 "htmlTagStart", "htmlTagEnd", "html", "optionTagStart", "optionTagEnd", 080 "option", "tbodyTagStart", "tbodyTagEnd", "tbody", "tfootTagStart", "tfootTagEnd", 081 "tfoot", "theadTagStart", "theadTagEnd", "thead", "singletonElement", 082 "emptyTag", "areaTag", "baseTag", "basefontTag", "brTag", "colTag", "frameTag", 083 "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", "paramTag", 084 "wrongSingletonTag", "singletonTagName", "description", "reference", 085 "parameters", "javadocTag", "javadocInlineTag", "htmlComment", "text", 086 "embedTag", "keygenTag", "sourceTag", "trackTag", "wbrTag", "optgroupTagStart", 087 "optgroupTagEnd", "optgroup", "rbTagStart", "rbTagEnd", "rb", "rtTagStart", 088 "rtTagEnd", "rt", "rtcTagStart", "rtcTagEnd", "rtc", "rpTagStart", "rpTagEnd", 089 "rp" 090 }; 091 } 092 public static final String[] ruleNames = makeRuleNames(); 093 094 private static String[] makeLiteralNames() { 095 return new String[] { 096 null, null, null, null, null, null, null, "'@author'", "'@deprecated'", 097 null, null, "'@return'", null, "'@serial'", null, "'@serialData'", "'@since'", 098 null, "'@version'", null, null, null, "'include'", "'exclude'", null, 099 null, null, null, null, "'.'", null, null, null, null, "'('", "')'", 100 null, "','", null, null, null, null, null, null, null, null, "'@docRoot'", 101 "'@inheritDoc'", "'@link'", "'@linkplain'", null, "'@value'", null, null, 102 null, null, null, "'/'", "'='", null, null, null, null, null, null, null, 103 null, null, null, null, null, null, null, null, null, null, null, null, 104 null, null, null, null, null, null, null, null, null, null, null, null, 105 null, "'-->'" 106 }; 107 } 108 private static final String[] _LITERAL_NAMES = makeLiteralNames(); 109 private static String[] makeSymbolicNames() { 110 return new String[] { 111 null, "LEADING_ASTERISK", "HTML_COMMENT_START", "DEPRECATED_CDATA_DO_NOT_USE", 112 "WS", "START", "NEWLINE", "AUTHOR_LITERAL", "DEPRECATED_LITERAL", "EXCEPTION_LITERAL", 113 "PARAM_LITERAL", "RETURN_LITERAL", "SEE_LITERAL", "SERIAL_LITERAL", "SERIAL_FIELD_LITERAL", 114 "SERIAL_DATA_LITERAL", "SINCE_LITERAL", "THROWS_LITERAL", "VERSION_LITERAL", 115 "JAVADOC_INLINE_TAG_START", "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", 116 "LITERAL_INCLUDE", "LITERAL_EXCLUDE", "CHAR", "PARAMETER_NAME", "Char1", 117 "STRING", "PACKAGE_CLASS", "DOT", "HASH", "CLASS", "Char2", "MEMBER", 118 "LEFT_BRACE", "RIGHT_BRACE", "ARGUMENT", "COMMA", "Char20", "FIELD_NAME", 119 "Char3", "FIELD_TYPE", "Char4", "CLASS_NAME", "Char5", "CODE_LITERAL", 120 "DOC_ROOT_LITERAL", "INHERIT_DOC_LITERAL", "LINK_LITERAL", "LINKPLAIN_LITERAL", 121 "LITERAL_LITERAL", "VALUE_LITERAL", "Char7", "Char8", "Char10", "END", 122 "SLASH_END", "SLASH", "EQUALS", "P_HTML_TAG_NAME", "LI_HTML_TAG_NAME", 123 "TR_HTML_TAG_NAME", "TD_HTML_TAG_NAME", "TH_HTML_TAG_NAME", "BODY_HTML_TAG_NAME", 124 "COLGROUP_HTML_TAG_NAME", "DD_HTML_TAG_NAME", "DT_HTML_TAG_NAME", "HEAD_HTML_TAG_NAME", 125 "HTML_HTML_TAG_NAME", "OPTION_HTML_TAG_NAME", "TBODY_HTML_TAG_NAME", 126 "TFOOT_HTML_TAG_NAME", "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", "BASE_HTML_TAG_NAME", 127 "BASEFONT_HTML_TAG_NAME", "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", "FRAME_HTML_TAG_NAME", 128 "HR_HTML_TAG_NAME", "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", "ISINDEX_HTML_TAG_NAME", 129 "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", "EMBED_HTML_TAG_NAME", 130 "KEYGEN_HTML_TAG_NAME", "ATTR_VALUE", "Char12", "HTML_COMMENT_END", "SOURCE_HTML_TAG_NAME", 131 "TRACK_HTML_TAG_NAME", "WBR_HTML_TAG_NAME", "OPTGROUP_HTML_TAG_NAME", 132 "RB_HTML_TAG_NAME", "RT_HTML_TAG_NAME", "RTC_HTML_TAG_NAME", "RP_HTML_TAG_NAME", 133 "HTML_TAG_NAME", "Char11" 134 }; 135 } 136 private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); 137 public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); 138 139 /** 140 * @deprecated Use {@link #VOCABULARY} instead. 141 */ 142 @Deprecated 143 public static final String[] tokenNames; 144 static { 145 tokenNames = new String[_SYMBOLIC_NAMES.length]; 146 for (int i = 0; i < tokenNames.length; i++) { 147 tokenNames[i] = VOCABULARY.getLiteralName(i); 148 if (tokenNames[i] == null) { 149 tokenNames[i] = VOCABULARY.getSymbolicName(i); 150 } 151 152 if (tokenNames[i] == null) { 153 tokenNames[i] = "<INVALID>"; 154 } 155 } 156 } 157 158 @Override 159 @Deprecated 160 public String[] getTokenNames() { 161 return tokenNames; 162 } 163 164 @Override 165 166 public Vocabulary getVocabulary() { 167 return VOCABULARY; 168 } 169 170 @Override 171 public String getGrammarFileName() { return "JavadocParser.g4"; } 172 173 @Override 174 public String[] getRuleNames() { return ruleNames; } 175 176 @Override 177 public String getSerializedATN() { return _serializedATN; } 178 179 @Override 180 public ATN getATN() { return _ATN; } 181 182 183 boolean isNextJavadocTag() { 184 int token1 = _input.LA(2); 185 int token2 = _input.LA(3); 186 return isJavadocTag(token1) 187 || (token1 == WS && isJavadocTag(token2)); 188 } 189 190 boolean isJavadocTag(int type) { 191 switch(type) { 192 case AUTHOR_LITERAL: 193 case DEPRECATED_LITERAL: 194 case EXCEPTION_LITERAL: 195 case PARAM_LITERAL: 196 case RETURN_LITERAL: 197 case SEE_LITERAL: 198 case SERIAL_LITERAL: 199 case SERIAL_FIELD_LITERAL: 200 case SERIAL_DATA_LITERAL: 201 case SINCE_LITERAL: 202 case THROWS_LITERAL: 203 case VERSION_LITERAL: 204 case CUSTOM_NAME: 205 return true; 206 default: 207 return false; 208 } 209 } 210 211 boolean isSameTagNames(ParserRuleContext htmlTagStart, ParserRuleContext htmlTagEnd) { 212 String startTag = htmlTagStart.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 213 String endTag = htmlTagEnd.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 214 return startTag.equals(endTag); 215 } 216 217 public ParserRuleContext nonTightTagStartContext; 218 219 public JavadocParser(TokenStream input) { 220 super(input); 221 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); 222 } 223 224 public static class JavadocContext extends ParserRuleContext { 225 public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); } 226 public List<HtmlElementContext> htmlElement() { 227 return getRuleContexts(HtmlElementContext.class); 228 } 229 public HtmlElementContext htmlElement(int i) { 230 return getRuleContext(HtmlElementContext.class,i); 231 } 232 public List<HtmlCommentContext> htmlComment() { 233 return getRuleContexts(HtmlCommentContext.class); 234 } 235 public HtmlCommentContext htmlComment(int i) { 236 return getRuleContext(HtmlCommentContext.class,i); 237 } 238 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 239 public TerminalNode NEWLINE(int i) { 240 return getToken(JavadocParser.NEWLINE, i); 241 } 242 public List<TextContext> text() { 243 return getRuleContexts(TextContext.class); 244 } 245 public TextContext text(int i) { 246 return getRuleContext(TextContext.class,i); 247 } 248 public List<JavadocInlineTagContext> javadocInlineTag() { 249 return getRuleContexts(JavadocInlineTagContext.class); 250 } 251 public JavadocInlineTagContext javadocInlineTag(int i) { 252 return getRuleContext(JavadocInlineTagContext.class,i); 253 } 254 public List<JavadocTagContext> javadocTag() { 255 return getRuleContexts(JavadocTagContext.class); 256 } 257 public JavadocTagContext javadocTag(int i) { 258 return getRuleContext(JavadocTagContext.class,i); 259 } 260 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 261 public TerminalNode LEADING_ASTERISK(int i) { 262 return getToken(JavadocParser.LEADING_ASTERISK, i); 263 } 264 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 265 public TerminalNode WS(int i) { 266 return getToken(JavadocParser.WS, i); 267 } 268 public JavadocContext(ParserRuleContext parent, int invokingState) { 269 super(parent, invokingState); 270 } 271 @Override public int getRuleIndex() { return RULE_javadoc; } 272 } 273 274 public final JavadocContext javadoc() throws RecognitionException { 275 JavadocContext _localctx = new JavadocContext(_ctx, getState()); 276 enterRule(_localctx, 0, RULE_javadoc); 277 int _la; 278 try { 279 int _alt; 280 enterOuterAlt(_localctx, 1); 281 { 282 setState(199); 283 _errHandler.sync(this); 284 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 285 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 286 if ( _alt==1 ) { 287 { 288 setState(197); 289 _errHandler.sync(this); 290 switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { 291 case 1: 292 { 293 setState(190); 294 htmlElement(); 295 } 296 break; 297 case 2: 298 { 299 { 300 setState(191); 301 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 302 setState(192); 303 match(LEADING_ASTERISK); 304 } 305 } 306 break; 307 case 3: 308 { 309 setState(193); 310 htmlComment(); 311 } 312 break; 313 case 4: 314 { 315 setState(194); 316 match(NEWLINE); 317 } 318 break; 319 case 5: 320 { 321 setState(195); 322 text(); 323 } 324 break; 325 case 6: 326 { 327 setState(196); 328 javadocInlineTag(); 329 } 330 break; 331 } 332 } 333 } 334 setState(201); 335 _errHandler.sync(this); 336 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 337 } 338 setState(214); 339 _errHandler.sync(this); 340 _la = _input.LA(1); 341 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)) { 342 { 343 { 344 setState(203); 345 _errHandler.sync(this); 346 _la = _input.LA(1); 347 if (_la==LEADING_ASTERISK) { 348 { 349 setState(202); 350 match(LEADING_ASTERISK); 351 } 352 } 353 354 setState(208); 355 _errHandler.sync(this); 356 _la = _input.LA(1); 357 while (_la==WS) { 358 { 359 { 360 setState(205); 361 match(WS); 362 } 363 } 364 setState(210); 365 _errHandler.sync(this); 366 _la = _input.LA(1); 367 } 368 setState(211); 369 javadocTag(); 370 } 371 } 372 setState(216); 373 _errHandler.sync(this); 374 _la = _input.LA(1); 375 } 376 setState(217); 377 match(EOF); 378 } 379 } 380 catch (RecognitionException re) { 381 _localctx.exception = re; 382 _errHandler.reportError(this, re); 383 _errHandler.recover(this, re); 384 } 385 finally { 386 exitRule(); 387 } 388 return _localctx; 389 } 390 391 public static class HtmlElementContext extends ParserRuleContext { 392 public HtmlTagContext htmlTag() { 393 return getRuleContext(HtmlTagContext.class,0); 394 } 395 public SingletonElementContext singletonElement() { 396 return getRuleContext(SingletonElementContext.class,0); 397 } 398 public ParagraphContext paragraph() { 399 return getRuleContext(ParagraphContext.class,0); 400 } 401 public LiContext li() { 402 return getRuleContext(LiContext.class,0); 403 } 404 public TrContext tr() { 405 return getRuleContext(TrContext.class,0); 406 } 407 public TdContext td() { 408 return getRuleContext(TdContext.class,0); 409 } 410 public ThContext th() { 411 return getRuleContext(ThContext.class,0); 412 } 413 public BodyContext body() { 414 return getRuleContext(BodyContext.class,0); 415 } 416 public ColgroupContext colgroup() { 417 return getRuleContext(ColgroupContext.class,0); 418 } 419 public DdContext dd() { 420 return getRuleContext(DdContext.class,0); 421 } 422 public DtContext dt() { 423 return getRuleContext(DtContext.class,0); 424 } 425 public HeadContext head() { 426 return getRuleContext(HeadContext.class,0); 427 } 428 public HtmlContext html() { 429 return getRuleContext(HtmlContext.class,0); 430 } 431 public OptionContext option() { 432 return getRuleContext(OptionContext.class,0); 433 } 434 public TbodyContext tbody() { 435 return getRuleContext(TbodyContext.class,0); 436 } 437 public TheadContext thead() { 438 return getRuleContext(TheadContext.class,0); 439 } 440 public TfootContext tfoot() { 441 return getRuleContext(TfootContext.class,0); 442 } 443 public OptgroupContext optgroup() { 444 return getRuleContext(OptgroupContext.class,0); 445 } 446 public RbContext rb() { 447 return getRuleContext(RbContext.class,0); 448 } 449 public RtContext rt() { 450 return getRuleContext(RtContext.class,0); 451 } 452 public RtcContext rtc() { 453 return getRuleContext(RtcContext.class,0); 454 } 455 public RpContext rp() { 456 return getRuleContext(RpContext.class,0); 457 } 458 public PTagStartContext pTagStart() { 459 return getRuleContext(PTagStartContext.class,0); 460 } 461 public LiTagStartContext liTagStart() { 462 return getRuleContext(LiTagStartContext.class,0); 463 } 464 public TrTagStartContext trTagStart() { 465 return getRuleContext(TrTagStartContext.class,0); 466 } 467 public TdTagStartContext tdTagStart() { 468 return getRuleContext(TdTagStartContext.class,0); 469 } 470 public ThTagStartContext thTagStart() { 471 return getRuleContext(ThTagStartContext.class,0); 472 } 473 public BodyTagStartContext bodyTagStart() { 474 return getRuleContext(BodyTagStartContext.class,0); 475 } 476 public ColgroupTagStartContext colgroupTagStart() { 477 return getRuleContext(ColgroupTagStartContext.class,0); 478 } 479 public DdTagStartContext ddTagStart() { 480 return getRuleContext(DdTagStartContext.class,0); 481 } 482 public DtTagStartContext dtTagStart() { 483 return getRuleContext(DtTagStartContext.class,0); 484 } 485 public HeadTagStartContext headTagStart() { 486 return getRuleContext(HeadTagStartContext.class,0); 487 } 488 public HtmlTagStartContext htmlTagStart() { 489 return getRuleContext(HtmlTagStartContext.class,0); 490 } 491 public OptionTagStartContext optionTagStart() { 492 return getRuleContext(OptionTagStartContext.class,0); 493 } 494 public TbodyTagStartContext tbodyTagStart() { 495 return getRuleContext(TbodyTagStartContext.class,0); 496 } 497 public TheadTagStartContext theadTagStart() { 498 return getRuleContext(TheadTagStartContext.class,0); 499 } 500 public TfootTagStartContext tfootTagStart() { 501 return getRuleContext(TfootTagStartContext.class,0); 502 } 503 public OptgroupTagStartContext optgroupTagStart() { 504 return getRuleContext(OptgroupTagStartContext.class,0); 505 } 506 public RbTagStartContext rbTagStart() { 507 return getRuleContext(RbTagStartContext.class,0); 508 } 509 public RtTagStartContext rtTagStart() { 510 return getRuleContext(RtTagStartContext.class,0); 511 } 512 public RtcTagStartContext rtcTagStart() { 513 return getRuleContext(RtcTagStartContext.class,0); 514 } 515 public RpTagStartContext rpTagStart() { 516 return getRuleContext(RpTagStartContext.class,0); 517 } 518 public PTagEndContext pTagEnd() { 519 return getRuleContext(PTagEndContext.class,0); 520 } 521 public LiTagEndContext liTagEnd() { 522 return getRuleContext(LiTagEndContext.class,0); 523 } 524 public TrTagEndContext trTagEnd() { 525 return getRuleContext(TrTagEndContext.class,0); 526 } 527 public TdTagEndContext tdTagEnd() { 528 return getRuleContext(TdTagEndContext.class,0); 529 } 530 public ThTagEndContext thTagEnd() { 531 return getRuleContext(ThTagEndContext.class,0); 532 } 533 public BodyTagEndContext bodyTagEnd() { 534 return getRuleContext(BodyTagEndContext.class,0); 535 } 536 public ColgroupTagEndContext colgroupTagEnd() { 537 return getRuleContext(ColgroupTagEndContext.class,0); 538 } 539 public DdTagEndContext ddTagEnd() { 540 return getRuleContext(DdTagEndContext.class,0); 541 } 542 public DtTagEndContext dtTagEnd() { 543 return getRuleContext(DtTagEndContext.class,0); 544 } 545 public HeadTagEndContext headTagEnd() { 546 return getRuleContext(HeadTagEndContext.class,0); 547 } 548 public HtmlTagEndContext htmlTagEnd() { 549 return getRuleContext(HtmlTagEndContext.class,0); 550 } 551 public OptionTagEndContext optionTagEnd() { 552 return getRuleContext(OptionTagEndContext.class,0); 553 } 554 public TbodyTagEndContext tbodyTagEnd() { 555 return getRuleContext(TbodyTagEndContext.class,0); 556 } 557 public TheadTagEndContext theadTagEnd() { 558 return getRuleContext(TheadTagEndContext.class,0); 559 } 560 public TfootTagEndContext tfootTagEnd() { 561 return getRuleContext(TfootTagEndContext.class,0); 562 } 563 public OptgroupTagEndContext optgroupTagEnd() { 564 return getRuleContext(OptgroupTagEndContext.class,0); 565 } 566 public RbTagEndContext rbTagEnd() { 567 return getRuleContext(RbTagEndContext.class,0); 568 } 569 public RtTagEndContext rtTagEnd() { 570 return getRuleContext(RtTagEndContext.class,0); 571 } 572 public RtcTagEndContext rtcTagEnd() { 573 return getRuleContext(RtcTagEndContext.class,0); 574 } 575 public RpTagEndContext rpTagEnd() { 576 return getRuleContext(RpTagEndContext.class,0); 577 } 578 public HtmlElementContext(ParserRuleContext parent, int invokingState) { 579 super(parent, invokingState); 580 } 581 @Override public int getRuleIndex() { return RULE_htmlElement; } 582 } 583 584 public final HtmlElementContext htmlElement() throws RecognitionException { 585 HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState()); 586 enterRule(_localctx, 2, RULE_htmlElement); 587 try { 588 setState(281); 589 _errHandler.sync(this); 590 switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { 591 case 1: 592 enterOuterAlt(_localctx, 1); 593 { 594 setState(219); 595 htmlTag(); 596 } 597 break; 598 case 2: 599 enterOuterAlt(_localctx, 2); 600 { 601 setState(220); 602 singletonElement(); 603 } 604 break; 605 case 3: 606 enterOuterAlt(_localctx, 3); 607 { 608 setState(221); 609 paragraph(); 610 } 611 break; 612 case 4: 613 enterOuterAlt(_localctx, 4); 614 { 615 setState(222); 616 li(); 617 } 618 break; 619 case 5: 620 enterOuterAlt(_localctx, 5); 621 { 622 setState(223); 623 tr(); 624 } 625 break; 626 case 6: 627 enterOuterAlt(_localctx, 6); 628 { 629 setState(224); 630 td(); 631 } 632 break; 633 case 7: 634 enterOuterAlt(_localctx, 7); 635 { 636 setState(225); 637 th(); 638 } 639 break; 640 case 8: 641 enterOuterAlt(_localctx, 8); 642 { 643 setState(226); 644 body(); 645 } 646 break; 647 case 9: 648 enterOuterAlt(_localctx, 9); 649 { 650 setState(227); 651 colgroup(); 652 } 653 break; 654 case 10: 655 enterOuterAlt(_localctx, 10); 656 { 657 setState(228); 658 dd(); 659 } 660 break; 661 case 11: 662 enterOuterAlt(_localctx, 11); 663 { 664 setState(229); 665 dt(); 666 } 667 break; 668 case 12: 669 enterOuterAlt(_localctx, 12); 670 { 671 setState(230); 672 head(); 673 } 674 break; 675 case 13: 676 enterOuterAlt(_localctx, 13); 677 { 678 setState(231); 679 html(); 680 } 681 break; 682 case 14: 683 enterOuterAlt(_localctx, 14); 684 { 685 setState(232); 686 option(); 687 } 688 break; 689 case 15: 690 enterOuterAlt(_localctx, 15); 691 { 692 setState(233); 693 tbody(); 694 } 695 break; 696 case 16: 697 enterOuterAlt(_localctx, 16); 698 { 699 setState(234); 700 thead(); 701 } 702 break; 703 case 17: 704 enterOuterAlt(_localctx, 17); 705 { 706 setState(235); 707 tfoot(); 708 } 709 break; 710 case 18: 711 enterOuterAlt(_localctx, 18); 712 { 713 setState(236); 714 optgroup(); 715 } 716 break; 717 case 19: 718 enterOuterAlt(_localctx, 19); 719 { 720 setState(237); 721 rb(); 722 } 723 break; 724 case 20: 725 enterOuterAlt(_localctx, 20); 726 { 727 setState(238); 728 rt(); 729 } 730 break; 731 case 21: 732 enterOuterAlt(_localctx, 21); 733 { 734 setState(239); 735 rtc(); 736 } 737 break; 738 case 22: 739 enterOuterAlt(_localctx, 22); 740 { 741 setState(240); 742 rp(); 743 } 744 break; 745 case 23: 746 enterOuterAlt(_localctx, 23); 747 { 748 setState(241); 749 pTagStart(true); 750 } 751 break; 752 case 24: 753 enterOuterAlt(_localctx, 24); 754 { 755 setState(242); 756 liTagStart(true); 757 } 758 break; 759 case 25: 760 enterOuterAlt(_localctx, 25); 761 { 762 setState(243); 763 trTagStart(true); 764 } 765 break; 766 case 26: 767 enterOuterAlt(_localctx, 26); 768 { 769 setState(244); 770 tdTagStart(true); 771 } 772 break; 773 case 27: 774 enterOuterAlt(_localctx, 27); 775 { 776 setState(245); 777 thTagStart(true); 778 } 779 break; 780 case 28: 781 enterOuterAlt(_localctx, 28); 782 { 783 setState(246); 784 bodyTagStart(true); 785 } 786 break; 787 case 29: 788 enterOuterAlt(_localctx, 29); 789 { 790 setState(247); 791 colgroupTagStart(true); 792 } 793 break; 794 case 30: 795 enterOuterAlt(_localctx, 30); 796 { 797 setState(248); 798 ddTagStart(true); 799 } 800 break; 801 case 31: 802 enterOuterAlt(_localctx, 31); 803 { 804 setState(249); 805 dtTagStart(true); 806 } 807 break; 808 case 32: 809 enterOuterAlt(_localctx, 32); 810 { 811 setState(250); 812 headTagStart(true); 813 } 814 break; 815 case 33: 816 enterOuterAlt(_localctx, 33); 817 { 818 setState(251); 819 htmlTagStart(true); 820 } 821 break; 822 case 34: 823 enterOuterAlt(_localctx, 34); 824 { 825 setState(252); 826 optionTagStart(true); 827 } 828 break; 829 case 35: 830 enterOuterAlt(_localctx, 35); 831 { 832 setState(253); 833 tbodyTagStart(true); 834 } 835 break; 836 case 36: 837 enterOuterAlt(_localctx, 36); 838 { 839 setState(254); 840 theadTagStart(true); 841 } 842 break; 843 case 37: 844 enterOuterAlt(_localctx, 37); 845 { 846 setState(255); 847 tfootTagStart(true); 848 } 849 break; 850 case 38: 851 enterOuterAlt(_localctx, 38); 852 { 853 setState(256); 854 optgroupTagStart(true); 855 } 856 break; 857 case 39: 858 enterOuterAlt(_localctx, 39); 859 { 860 setState(257); 861 rbTagStart(true); 862 } 863 break; 864 case 40: 865 enterOuterAlt(_localctx, 40); 866 { 867 setState(258); 868 rtTagStart(true); 869 } 870 break; 871 case 41: 872 enterOuterAlt(_localctx, 41); 873 { 874 setState(259); 875 rtcTagStart(true); 876 } 877 break; 878 case 42: 879 enterOuterAlt(_localctx, 42); 880 { 881 setState(260); 882 rpTagStart(true); 883 } 884 break; 885 case 43: 886 enterOuterAlt(_localctx, 43); 887 { 888 setState(261); 889 pTagEnd(); 890 } 891 break; 892 case 44: 893 enterOuterAlt(_localctx, 44); 894 { 895 setState(262); 896 liTagEnd(); 897 } 898 break; 899 case 45: 900 enterOuterAlt(_localctx, 45); 901 { 902 setState(263); 903 trTagEnd(); 904 } 905 break; 906 case 46: 907 enterOuterAlt(_localctx, 46); 908 { 909 setState(264); 910 tdTagEnd(); 911 } 912 break; 913 case 47: 914 enterOuterAlt(_localctx, 47); 915 { 916 setState(265); 917 thTagEnd(); 918 } 919 break; 920 case 48: 921 enterOuterAlt(_localctx, 48); 922 { 923 setState(266); 924 bodyTagEnd(); 925 } 926 break; 927 case 49: 928 enterOuterAlt(_localctx, 49); 929 { 930 setState(267); 931 colgroupTagEnd(); 932 } 933 break; 934 case 50: 935 enterOuterAlt(_localctx, 50); 936 { 937 setState(268); 938 ddTagEnd(); 939 } 940 break; 941 case 51: 942 enterOuterAlt(_localctx, 51); 943 { 944 setState(269); 945 dtTagEnd(); 946 } 947 break; 948 case 52: 949 enterOuterAlt(_localctx, 52); 950 { 951 setState(270); 952 headTagEnd(); 953 } 954 break; 955 case 53: 956 enterOuterAlt(_localctx, 53); 957 { 958 setState(271); 959 htmlTagEnd(); 960 } 961 break; 962 case 54: 963 enterOuterAlt(_localctx, 54); 964 { 965 setState(272); 966 optionTagEnd(); 967 } 968 break; 969 case 55: 970 enterOuterAlt(_localctx, 55); 971 { 972 setState(273); 973 tbodyTagEnd(); 974 } 975 break; 976 case 56: 977 enterOuterAlt(_localctx, 56); 978 { 979 setState(274); 980 theadTagEnd(); 981 } 982 break; 983 case 57: 984 enterOuterAlt(_localctx, 57); 985 { 986 setState(275); 987 tfootTagEnd(); 988 } 989 break; 990 case 58: 991 enterOuterAlt(_localctx, 58); 992 { 993 setState(276); 994 optgroupTagEnd(); 995 } 996 break; 997 case 59: 998 enterOuterAlt(_localctx, 59); 999 { 1000 setState(277); 1001 rbTagEnd(); 1002 } 1003 break; 1004 case 60: 1005 enterOuterAlt(_localctx, 60); 1006 { 1007 setState(278); 1008 rtTagEnd(); 1009 } 1010 break; 1011 case 61: 1012 enterOuterAlt(_localctx, 61); 1013 { 1014 setState(279); 1015 rtcTagEnd(); 1016 } 1017 break; 1018 case 62: 1019 enterOuterAlt(_localctx, 62); 1020 { 1021 setState(280); 1022 rpTagEnd(); 1023 } 1024 break; 1025 } 1026 } 1027 catch (RecognitionException re) { 1028 _localctx.exception = re; 1029 _errHandler.reportError(this, re); 1030 _errHandler.recover(this, re); 1031 } 1032 finally { 1033 exitRule(); 1034 } 1035 return _localctx; 1036 } 1037 1038 public static class HtmlElementStartContext extends ParserRuleContext { 1039 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 1040 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 1041 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 1042 public List<AttributeContext> attribute() { 1043 return getRuleContexts(AttributeContext.class); 1044 } 1045 public AttributeContext attribute(int i) { 1046 return getRuleContext(AttributeContext.class,i); 1047 } 1048 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1049 public TerminalNode NEWLINE(int i) { 1050 return getToken(JavadocParser.NEWLINE, i); 1051 } 1052 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1053 public TerminalNode LEADING_ASTERISK(int i) { 1054 return getToken(JavadocParser.LEADING_ASTERISK, i); 1055 } 1056 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1057 public TerminalNode WS(int i) { 1058 return getToken(JavadocParser.WS, i); 1059 } 1060 public HtmlElementStartContext(ParserRuleContext parent, int invokingState) { 1061 super(parent, invokingState); 1062 } 1063 @Override public int getRuleIndex() { return RULE_htmlElementStart; } 1064 } 1065 1066 public final HtmlElementStartContext htmlElementStart() throws RecognitionException { 1067 HtmlElementStartContext _localctx = new HtmlElementStartContext(_ctx, getState()); 1068 enterRule(_localctx, 4, RULE_htmlElementStart); 1069 int _la; 1070 try { 1071 enterOuterAlt(_localctx, 1); 1072 { 1073 setState(283); 1074 match(START); 1075 setState(284); 1076 match(HTML_TAG_NAME); 1077 setState(291); 1078 _errHandler.sync(this); 1079 _la = _input.LA(1); 1080 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 1081 { 1082 setState(289); 1083 _errHandler.sync(this); 1084 switch (_input.LA(1)) { 1085 case HTML_TAG_NAME: 1086 { 1087 setState(285); 1088 attribute(); 1089 } 1090 break; 1091 case NEWLINE: 1092 { 1093 setState(286); 1094 match(NEWLINE); 1095 } 1096 break; 1097 case LEADING_ASTERISK: 1098 { 1099 setState(287); 1100 match(LEADING_ASTERISK); 1101 } 1102 break; 1103 case WS: 1104 { 1105 setState(288); 1106 match(WS); 1107 } 1108 break; 1109 default: 1110 throw new NoViableAltException(this); 1111 } 1112 } 1113 setState(293); 1114 _errHandler.sync(this); 1115 _la = _input.LA(1); 1116 } 1117 setState(294); 1118 match(END); 1119 } 1120 } 1121 catch (RecognitionException re) { 1122 _localctx.exception = re; 1123 _errHandler.reportError(this, re); 1124 _errHandler.recover(this, re); 1125 } 1126 finally { 1127 exitRule(); 1128 } 1129 return _localctx; 1130 } 1131 1132 public static class HtmlElementEndContext extends ParserRuleContext { 1133 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 1134 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1135 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 1136 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 1137 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1138 public TerminalNode NEWLINE(int i) { 1139 return getToken(JavadocParser.NEWLINE, i); 1140 } 1141 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1142 public TerminalNode LEADING_ASTERISK(int i) { 1143 return getToken(JavadocParser.LEADING_ASTERISK, i); 1144 } 1145 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1146 public TerminalNode WS(int i) { 1147 return getToken(JavadocParser.WS, i); 1148 } 1149 public HtmlElementEndContext(ParserRuleContext parent, int invokingState) { 1150 super(parent, invokingState); 1151 } 1152 @Override public int getRuleIndex() { return RULE_htmlElementEnd; } 1153 } 1154 1155 public final HtmlElementEndContext htmlElementEnd() throws RecognitionException { 1156 HtmlElementEndContext _localctx = new HtmlElementEndContext(_ctx, getState()); 1157 enterRule(_localctx, 6, RULE_htmlElementEnd); 1158 int _la; 1159 try { 1160 enterOuterAlt(_localctx, 1); 1161 { 1162 setState(296); 1163 match(START); 1164 setState(297); 1165 match(SLASH); 1166 setState(298); 1167 match(HTML_TAG_NAME); 1168 setState(302); 1169 _errHandler.sync(this); 1170 _la = _input.LA(1); 1171 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1172 { 1173 { 1174 setState(299); 1175 _la = _input.LA(1); 1176 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1177 _errHandler.recoverInline(this); 1178 } 1179 else { 1180 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1181 _errHandler.reportMatch(this); 1182 consume(); 1183 } 1184 } 1185 } 1186 setState(304); 1187 _errHandler.sync(this); 1188 _la = _input.LA(1); 1189 } 1190 setState(305); 1191 match(END); 1192 } 1193 } 1194 catch (RecognitionException re) { 1195 _localctx.exception = re; 1196 _errHandler.reportError(this, re); 1197 _errHandler.recover(this, re); 1198 } 1199 finally { 1200 exitRule(); 1201 } 1202 return _localctx; 1203 } 1204 1205 public static class AttributeContext extends ParserRuleContext { 1206 public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); } 1207 public TerminalNode HTML_TAG_NAME(int i) { 1208 return getToken(JavadocParser.HTML_TAG_NAME, i); 1209 } 1210 public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); } 1211 public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); } 1212 public TextContext text() { 1213 return getRuleContext(TextContext.class,0); 1214 } 1215 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1216 public TerminalNode NEWLINE(int i) { 1217 return getToken(JavadocParser.NEWLINE, i); 1218 } 1219 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1220 public TerminalNode LEADING_ASTERISK(int i) { 1221 return getToken(JavadocParser.LEADING_ASTERISK, i); 1222 } 1223 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1224 public TerminalNode WS(int i) { 1225 return getToken(JavadocParser.WS, i); 1226 } 1227 public AttributeContext(ParserRuleContext parent, int invokingState) { 1228 super(parent, invokingState); 1229 } 1230 @Override public int getRuleIndex() { return RULE_attribute; } 1231 } 1232 1233 public final AttributeContext attribute() throws RecognitionException { 1234 AttributeContext _localctx = new AttributeContext(_ctx, getState()); 1235 enterRule(_localctx, 8, RULE_attribute); 1236 int _la; 1237 try { 1238 int _alt; 1239 enterOuterAlt(_localctx, 1); 1240 { 1241 setState(307); 1242 match(HTML_TAG_NAME); 1243 setState(311); 1244 _errHandler.sync(this); 1245 _la = _input.LA(1); 1246 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1247 { 1248 { 1249 setState(308); 1250 _la = _input.LA(1); 1251 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1252 _errHandler.recoverInline(this); 1253 } 1254 else { 1255 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1256 _errHandler.reportMatch(this); 1257 consume(); 1258 } 1259 } 1260 } 1261 setState(313); 1262 _errHandler.sync(this); 1263 _la = _input.LA(1); 1264 } 1265 setState(314); 1266 match(EQUALS); 1267 setState(318); 1268 _errHandler.sync(this); 1269 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1270 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1271 if ( _alt==1 ) { 1272 { 1273 { 1274 setState(315); 1275 _la = _input.LA(1); 1276 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1277 _errHandler.recoverInline(this); 1278 } 1279 else { 1280 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1281 _errHandler.reportMatch(this); 1282 consume(); 1283 } 1284 } 1285 } 1286 } 1287 setState(320); 1288 _errHandler.sync(this); 1289 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1290 } 1291 setState(324); 1292 _errHandler.sync(this); 1293 switch (_input.LA(1)) { 1294 case ATTR_VALUE: 1295 { 1296 setState(321); 1297 match(ATTR_VALUE); 1298 } 1299 break; 1300 case WS: 1301 case CHAR: 1302 { 1303 setState(322); 1304 text(); 1305 } 1306 break; 1307 case HTML_TAG_NAME: 1308 { 1309 setState(323); 1310 match(HTML_TAG_NAME); 1311 } 1312 break; 1313 default: 1314 throw new NoViableAltException(this); 1315 } 1316 } 1317 } 1318 catch (RecognitionException re) { 1319 _localctx.exception = re; 1320 _errHandler.reportError(this, re); 1321 _errHandler.recover(this, re); 1322 } 1323 finally { 1324 exitRule(); 1325 } 1326 return _localctx; 1327 } 1328 1329 public static class HtmlTagContext extends ParserRuleContext { 1330 public HtmlElementStartContext htmlElementStart; 1331 public HtmlElementEndContext htmlElementEnd; 1332 public HtmlElementStartContext htmlElementStart() { 1333 return getRuleContext(HtmlElementStartContext.class,0); 1334 } 1335 public HtmlElementEndContext htmlElementEnd() { 1336 return getRuleContext(HtmlElementEndContext.class,0); 1337 } 1338 public List<HtmlElementContext> htmlElement() { 1339 return getRuleContexts(HtmlElementContext.class); 1340 } 1341 public HtmlElementContext htmlElement(int i) { 1342 return getRuleContext(HtmlElementContext.class,i); 1343 } 1344 public List<HtmlCommentContext> htmlComment() { 1345 return getRuleContexts(HtmlCommentContext.class); 1346 } 1347 public HtmlCommentContext htmlComment(int i) { 1348 return getRuleContext(HtmlCommentContext.class,i); 1349 } 1350 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1351 public TerminalNode NEWLINE(int i) { 1352 return getToken(JavadocParser.NEWLINE, i); 1353 } 1354 public List<TextContext> text() { 1355 return getRuleContexts(TextContext.class); 1356 } 1357 public TextContext text(int i) { 1358 return getRuleContext(TextContext.class,i); 1359 } 1360 public List<JavadocInlineTagContext> javadocInlineTag() { 1361 return getRuleContexts(JavadocInlineTagContext.class); 1362 } 1363 public JavadocInlineTagContext javadocInlineTag(int i) { 1364 return getRuleContext(JavadocInlineTagContext.class,i); 1365 } 1366 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1367 public TerminalNode LEADING_ASTERISK(int i) { 1368 return getToken(JavadocParser.LEADING_ASTERISK, i); 1369 } 1370 public HtmlTagContext(ParserRuleContext parent, int invokingState) { 1371 super(parent, invokingState); 1372 } 1373 @Override public int getRuleIndex() { return RULE_htmlTag; } 1374 } 1375 1376 public final HtmlTagContext htmlTag() throws RecognitionException { 1377 HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState()); 1378 enterRule(_localctx, 10, RULE_htmlTag); 1379 try { 1380 int _alt; 1381 enterOuterAlt(_localctx, 1); 1382 { 1383 setState(326); 1384 ((HtmlTagContext)_localctx).htmlElementStart = htmlElementStart(); 1385 setState(336); 1386 _errHandler.sync(this); 1387 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1388 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1389 if ( _alt==1 ) { 1390 { 1391 setState(334); 1392 _errHandler.sync(this); 1393 switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { 1394 case 1: 1395 { 1396 setState(327); 1397 htmlElement(); 1398 } 1399 break; 1400 case 2: 1401 { 1402 { 1403 setState(328); 1404 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1405 setState(329); 1406 match(LEADING_ASTERISK); 1407 } 1408 } 1409 break; 1410 case 3: 1411 { 1412 setState(330); 1413 htmlComment(); 1414 } 1415 break; 1416 case 4: 1417 { 1418 setState(331); 1419 match(NEWLINE); 1420 } 1421 break; 1422 case 5: 1423 { 1424 setState(332); 1425 text(); 1426 } 1427 break; 1428 case 6: 1429 { 1430 setState(333); 1431 javadocInlineTag(); 1432 } 1433 break; 1434 } 1435 } 1436 } 1437 setState(338); 1438 _errHandler.sync(this); 1439 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1440 } 1441 setState(339); 1442 ((HtmlTagContext)_localctx).htmlElementEnd = htmlElementEnd(); 1443 setState(340); 1444 if (!(isSameTagNames(((HtmlTagContext)_localctx).htmlElementStart, ((HtmlTagContext)_localctx).htmlElementEnd))) throw new FailedPredicateException(this, "isSameTagNames($htmlElementStart.ctx, $htmlElementEnd.ctx)"); 1445 } 1446 } 1447 catch (RecognitionException re) { 1448 _localctx.exception = re; 1449 _errHandler.reportError(this, re); 1450 _errHandler.recover(this, re); 1451 } 1452 finally { 1453 exitRule(); 1454 } 1455 return _localctx; 1456 } 1457 1458 public static class PTagStartContext extends ParserRuleContext { 1459 public boolean isNonTight; 1460 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 1461 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1462 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 1463 public List<AttributeContext> attribute() { 1464 return getRuleContexts(AttributeContext.class); 1465 } 1466 public AttributeContext attribute(int i) { 1467 return getRuleContext(AttributeContext.class,i); 1468 } 1469 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1470 public TerminalNode NEWLINE(int i) { 1471 return getToken(JavadocParser.NEWLINE, i); 1472 } 1473 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1474 public TerminalNode LEADING_ASTERISK(int i) { 1475 return getToken(JavadocParser.LEADING_ASTERISK, i); 1476 } 1477 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1478 public TerminalNode WS(int i) { 1479 return getToken(JavadocParser.WS, i); 1480 } 1481 public PTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 1482 public PTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 1483 super(parent, invokingState); 1484 this.isNonTight = isNonTight; 1485 } 1486 @Override public int getRuleIndex() { return RULE_pTagStart; } 1487 } 1488 1489 public final PTagStartContext pTagStart(boolean isNonTight) throws RecognitionException { 1490 PTagStartContext _localctx = new PTagStartContext(_ctx, getState(), isNonTight); 1491 enterRule(_localctx, 12, RULE_pTagStart); 1492 int _la; 1493 try { 1494 enterOuterAlt(_localctx, 1); 1495 { 1496 setState(342); 1497 match(START); 1498 setState(343); 1499 match(P_HTML_TAG_NAME); 1500 setState(350); 1501 _errHandler.sync(this); 1502 _la = _input.LA(1); 1503 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 1504 { 1505 setState(348); 1506 _errHandler.sync(this); 1507 switch (_input.LA(1)) { 1508 case HTML_TAG_NAME: 1509 { 1510 setState(344); 1511 attribute(); 1512 } 1513 break; 1514 case NEWLINE: 1515 { 1516 setState(345); 1517 match(NEWLINE); 1518 } 1519 break; 1520 case LEADING_ASTERISK: 1521 { 1522 setState(346); 1523 match(LEADING_ASTERISK); 1524 } 1525 break; 1526 case WS: 1527 { 1528 setState(347); 1529 match(WS); 1530 } 1531 break; 1532 default: 1533 throw new NoViableAltException(this); 1534 } 1535 } 1536 setState(352); 1537 _errHandler.sync(this); 1538 _la = _input.LA(1); 1539 } 1540 setState(353); 1541 match(END); 1542 } 1543 _ctx.stop = _input.LT(-1); 1544 1545 if (isNonTight && nonTightTagStartContext == null) { 1546 nonTightTagStartContext = _localctx; 1547 } 1548 1549 } 1550 catch (RecognitionException re) { 1551 _localctx.exception = re; 1552 _errHandler.reportError(this, re); 1553 _errHandler.recover(this, re); 1554 } 1555 finally { 1556 exitRule(); 1557 } 1558 return _localctx; 1559 } 1560 1561 public static class PTagEndContext extends ParserRuleContext { 1562 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 1563 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1564 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1565 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 1566 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1567 public TerminalNode NEWLINE(int i) { 1568 return getToken(JavadocParser.NEWLINE, i); 1569 } 1570 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1571 public TerminalNode LEADING_ASTERISK(int i) { 1572 return getToken(JavadocParser.LEADING_ASTERISK, i); 1573 } 1574 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1575 public TerminalNode WS(int i) { 1576 return getToken(JavadocParser.WS, i); 1577 } 1578 public PTagEndContext(ParserRuleContext parent, int invokingState) { 1579 super(parent, invokingState); 1580 } 1581 @Override public int getRuleIndex() { return RULE_pTagEnd; } 1582 } 1583 1584 public final PTagEndContext pTagEnd() throws RecognitionException { 1585 PTagEndContext _localctx = new PTagEndContext(_ctx, getState()); 1586 enterRule(_localctx, 14, RULE_pTagEnd); 1587 int _la; 1588 try { 1589 enterOuterAlt(_localctx, 1); 1590 { 1591 setState(355); 1592 match(START); 1593 setState(356); 1594 match(SLASH); 1595 setState(357); 1596 match(P_HTML_TAG_NAME); 1597 setState(361); 1598 _errHandler.sync(this); 1599 _la = _input.LA(1); 1600 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1601 { 1602 { 1603 setState(358); 1604 _la = _input.LA(1); 1605 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1606 _errHandler.recoverInline(this); 1607 } 1608 else { 1609 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1610 _errHandler.reportMatch(this); 1611 consume(); 1612 } 1613 } 1614 } 1615 setState(363); 1616 _errHandler.sync(this); 1617 _la = _input.LA(1); 1618 } 1619 setState(364); 1620 match(END); 1621 } 1622 } 1623 catch (RecognitionException re) { 1624 _localctx.exception = re; 1625 _errHandler.reportError(this, re); 1626 _errHandler.recover(this, re); 1627 } 1628 finally { 1629 exitRule(); 1630 } 1631 return _localctx; 1632 } 1633 1634 public static class ParagraphContext extends ParserRuleContext { 1635 public PTagStartContext pTagStart() { 1636 return getRuleContext(PTagStartContext.class,0); 1637 } 1638 public PTagEndContext pTagEnd() { 1639 return getRuleContext(PTagEndContext.class,0); 1640 } 1641 public List<HtmlTagContext> htmlTag() { 1642 return getRuleContexts(HtmlTagContext.class); 1643 } 1644 public HtmlTagContext htmlTag(int i) { 1645 return getRuleContext(HtmlTagContext.class,i); 1646 } 1647 public List<SingletonElementContext> singletonElement() { 1648 return getRuleContexts(SingletonElementContext.class); 1649 } 1650 public SingletonElementContext singletonElement(int i) { 1651 return getRuleContext(SingletonElementContext.class,i); 1652 } 1653 public List<LiContext> li() { 1654 return getRuleContexts(LiContext.class); 1655 } 1656 public LiContext li(int i) { 1657 return getRuleContext(LiContext.class,i); 1658 } 1659 public List<TrContext> tr() { 1660 return getRuleContexts(TrContext.class); 1661 } 1662 public TrContext tr(int i) { 1663 return getRuleContext(TrContext.class,i); 1664 } 1665 public List<TdContext> td() { 1666 return getRuleContexts(TdContext.class); 1667 } 1668 public TdContext td(int i) { 1669 return getRuleContext(TdContext.class,i); 1670 } 1671 public List<ThContext> th() { 1672 return getRuleContexts(ThContext.class); 1673 } 1674 public ThContext th(int i) { 1675 return getRuleContext(ThContext.class,i); 1676 } 1677 public List<BodyContext> body() { 1678 return getRuleContexts(BodyContext.class); 1679 } 1680 public BodyContext body(int i) { 1681 return getRuleContext(BodyContext.class,i); 1682 } 1683 public List<ColgroupContext> colgroup() { 1684 return getRuleContexts(ColgroupContext.class); 1685 } 1686 public ColgroupContext colgroup(int i) { 1687 return getRuleContext(ColgroupContext.class,i); 1688 } 1689 public List<DdContext> dd() { 1690 return getRuleContexts(DdContext.class); 1691 } 1692 public DdContext dd(int i) { 1693 return getRuleContext(DdContext.class,i); 1694 } 1695 public List<DtContext> dt() { 1696 return getRuleContexts(DtContext.class); 1697 } 1698 public DtContext dt(int i) { 1699 return getRuleContext(DtContext.class,i); 1700 } 1701 public List<HeadContext> head() { 1702 return getRuleContexts(HeadContext.class); 1703 } 1704 public HeadContext head(int i) { 1705 return getRuleContext(HeadContext.class,i); 1706 } 1707 public List<HtmlContext> html() { 1708 return getRuleContexts(HtmlContext.class); 1709 } 1710 public HtmlContext html(int i) { 1711 return getRuleContext(HtmlContext.class,i); 1712 } 1713 public List<OptionContext> option() { 1714 return getRuleContexts(OptionContext.class); 1715 } 1716 public OptionContext option(int i) { 1717 return getRuleContext(OptionContext.class,i); 1718 } 1719 public List<TbodyContext> tbody() { 1720 return getRuleContexts(TbodyContext.class); 1721 } 1722 public TbodyContext tbody(int i) { 1723 return getRuleContext(TbodyContext.class,i); 1724 } 1725 public List<TheadContext> thead() { 1726 return getRuleContexts(TheadContext.class); 1727 } 1728 public TheadContext thead(int i) { 1729 return getRuleContext(TheadContext.class,i); 1730 } 1731 public List<TfootContext> tfoot() { 1732 return getRuleContexts(TfootContext.class); 1733 } 1734 public TfootContext tfoot(int i) { 1735 return getRuleContext(TfootContext.class,i); 1736 } 1737 public List<OptgroupContext> optgroup() { 1738 return getRuleContexts(OptgroupContext.class); 1739 } 1740 public OptgroupContext optgroup(int i) { 1741 return getRuleContext(OptgroupContext.class,i); 1742 } 1743 public List<RbContext> rb() { 1744 return getRuleContexts(RbContext.class); 1745 } 1746 public RbContext rb(int i) { 1747 return getRuleContext(RbContext.class,i); 1748 } 1749 public List<RtContext> rt() { 1750 return getRuleContexts(RtContext.class); 1751 } 1752 public RtContext rt(int i) { 1753 return getRuleContext(RtContext.class,i); 1754 } 1755 public List<RtcContext> rtc() { 1756 return getRuleContexts(RtcContext.class); 1757 } 1758 public RtcContext rtc(int i) { 1759 return getRuleContext(RtcContext.class,i); 1760 } 1761 public List<RpContext> rp() { 1762 return getRuleContexts(RpContext.class); 1763 } 1764 public RpContext rp(int i) { 1765 return getRuleContext(RpContext.class,i); 1766 } 1767 public List<LiTagStartContext> liTagStart() { 1768 return getRuleContexts(LiTagStartContext.class); 1769 } 1770 public LiTagStartContext liTagStart(int i) { 1771 return getRuleContext(LiTagStartContext.class,i); 1772 } 1773 public List<TrTagStartContext> trTagStart() { 1774 return getRuleContexts(TrTagStartContext.class); 1775 } 1776 public TrTagStartContext trTagStart(int i) { 1777 return getRuleContext(TrTagStartContext.class,i); 1778 } 1779 public List<TdTagStartContext> tdTagStart() { 1780 return getRuleContexts(TdTagStartContext.class); 1781 } 1782 public TdTagStartContext tdTagStart(int i) { 1783 return getRuleContext(TdTagStartContext.class,i); 1784 } 1785 public List<ThTagStartContext> thTagStart() { 1786 return getRuleContexts(ThTagStartContext.class); 1787 } 1788 public ThTagStartContext thTagStart(int i) { 1789 return getRuleContext(ThTagStartContext.class,i); 1790 } 1791 public List<BodyTagStartContext> bodyTagStart() { 1792 return getRuleContexts(BodyTagStartContext.class); 1793 } 1794 public BodyTagStartContext bodyTagStart(int i) { 1795 return getRuleContext(BodyTagStartContext.class,i); 1796 } 1797 public List<ColgroupTagStartContext> colgroupTagStart() { 1798 return getRuleContexts(ColgroupTagStartContext.class); 1799 } 1800 public ColgroupTagStartContext colgroupTagStart(int i) { 1801 return getRuleContext(ColgroupTagStartContext.class,i); 1802 } 1803 public List<DdTagStartContext> ddTagStart() { 1804 return getRuleContexts(DdTagStartContext.class); 1805 } 1806 public DdTagStartContext ddTagStart(int i) { 1807 return getRuleContext(DdTagStartContext.class,i); 1808 } 1809 public List<DtTagStartContext> dtTagStart() { 1810 return getRuleContexts(DtTagStartContext.class); 1811 } 1812 public DtTagStartContext dtTagStart(int i) { 1813 return getRuleContext(DtTagStartContext.class,i); 1814 } 1815 public List<HeadTagStartContext> headTagStart() { 1816 return getRuleContexts(HeadTagStartContext.class); 1817 } 1818 public HeadTagStartContext headTagStart(int i) { 1819 return getRuleContext(HeadTagStartContext.class,i); 1820 } 1821 public List<HtmlTagStartContext> htmlTagStart() { 1822 return getRuleContexts(HtmlTagStartContext.class); 1823 } 1824 public HtmlTagStartContext htmlTagStart(int i) { 1825 return getRuleContext(HtmlTagStartContext.class,i); 1826 } 1827 public List<OptionTagStartContext> optionTagStart() { 1828 return getRuleContexts(OptionTagStartContext.class); 1829 } 1830 public OptionTagStartContext optionTagStart(int i) { 1831 return getRuleContext(OptionTagStartContext.class,i); 1832 } 1833 public List<TbodyTagStartContext> tbodyTagStart() { 1834 return getRuleContexts(TbodyTagStartContext.class); 1835 } 1836 public TbodyTagStartContext tbodyTagStart(int i) { 1837 return getRuleContext(TbodyTagStartContext.class,i); 1838 } 1839 public List<TheadTagStartContext> theadTagStart() { 1840 return getRuleContexts(TheadTagStartContext.class); 1841 } 1842 public TheadTagStartContext theadTagStart(int i) { 1843 return getRuleContext(TheadTagStartContext.class,i); 1844 } 1845 public List<TfootTagStartContext> tfootTagStart() { 1846 return getRuleContexts(TfootTagStartContext.class); 1847 } 1848 public TfootTagStartContext tfootTagStart(int i) { 1849 return getRuleContext(TfootTagStartContext.class,i); 1850 } 1851 public List<OptgroupTagStartContext> optgroupTagStart() { 1852 return getRuleContexts(OptgroupTagStartContext.class); 1853 } 1854 public OptgroupTagStartContext optgroupTagStart(int i) { 1855 return getRuleContext(OptgroupTagStartContext.class,i); 1856 } 1857 public List<RbTagStartContext> rbTagStart() { 1858 return getRuleContexts(RbTagStartContext.class); 1859 } 1860 public RbTagStartContext rbTagStart(int i) { 1861 return getRuleContext(RbTagStartContext.class,i); 1862 } 1863 public List<RtTagStartContext> rtTagStart() { 1864 return getRuleContexts(RtTagStartContext.class); 1865 } 1866 public RtTagStartContext rtTagStart(int i) { 1867 return getRuleContext(RtTagStartContext.class,i); 1868 } 1869 public List<RtcTagStartContext> rtcTagStart() { 1870 return getRuleContexts(RtcTagStartContext.class); 1871 } 1872 public RtcTagStartContext rtcTagStart(int i) { 1873 return getRuleContext(RtcTagStartContext.class,i); 1874 } 1875 public List<RpTagStartContext> rpTagStart() { 1876 return getRuleContexts(RpTagStartContext.class); 1877 } 1878 public RpTagStartContext rpTagStart(int i) { 1879 return getRuleContext(RpTagStartContext.class,i); 1880 } 1881 public List<HtmlCommentContext> htmlComment() { 1882 return getRuleContexts(HtmlCommentContext.class); 1883 } 1884 public HtmlCommentContext htmlComment(int i) { 1885 return getRuleContext(HtmlCommentContext.class,i); 1886 } 1887 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1888 public TerminalNode NEWLINE(int i) { 1889 return getToken(JavadocParser.NEWLINE, i); 1890 } 1891 public List<TextContext> text() { 1892 return getRuleContexts(TextContext.class); 1893 } 1894 public TextContext text(int i) { 1895 return getRuleContext(TextContext.class,i); 1896 } 1897 public List<JavadocInlineTagContext> javadocInlineTag() { 1898 return getRuleContexts(JavadocInlineTagContext.class); 1899 } 1900 public JavadocInlineTagContext javadocInlineTag(int i) { 1901 return getRuleContext(JavadocInlineTagContext.class,i); 1902 } 1903 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1904 public TerminalNode LEADING_ASTERISK(int i) { 1905 return getToken(JavadocParser.LEADING_ASTERISK, i); 1906 } 1907 public ParagraphContext(ParserRuleContext parent, int invokingState) { 1908 super(parent, invokingState); 1909 } 1910 @Override public int getRuleIndex() { return RULE_paragraph; } 1911 } 1912 1913 public final ParagraphContext paragraph() throws RecognitionException { 1914 ParagraphContext _localctx = new ParagraphContext(_ctx, getState()); 1915 enterRule(_localctx, 16, RULE_paragraph); 1916 try { 1917 int _alt; 1918 enterOuterAlt(_localctx, 1); 1919 { 1920 setState(366); 1921 pTagStart(false); 1922 setState(415); 1923 _errHandler.sync(this); 1924 _alt = getInterpreter().adaptivePredict(_input,18,_ctx); 1925 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1926 if ( _alt==1 ) { 1927 { 1928 setState(413); 1929 _errHandler.sync(this); 1930 switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { 1931 case 1: 1932 { 1933 setState(367); 1934 htmlTag(); 1935 } 1936 break; 1937 case 2: 1938 { 1939 setState(368); 1940 singletonElement(); 1941 } 1942 break; 1943 case 3: 1944 { 1945 setState(369); 1946 li(); 1947 } 1948 break; 1949 case 4: 1950 { 1951 setState(370); 1952 tr(); 1953 } 1954 break; 1955 case 5: 1956 { 1957 setState(371); 1958 td(); 1959 } 1960 break; 1961 case 6: 1962 { 1963 setState(372); 1964 th(); 1965 } 1966 break; 1967 case 7: 1968 { 1969 setState(373); 1970 body(); 1971 } 1972 break; 1973 case 8: 1974 { 1975 setState(374); 1976 colgroup(); 1977 } 1978 break; 1979 case 9: 1980 { 1981 setState(375); 1982 dd(); 1983 } 1984 break; 1985 case 10: 1986 { 1987 setState(376); 1988 dt(); 1989 } 1990 break; 1991 case 11: 1992 { 1993 setState(377); 1994 head(); 1995 } 1996 break; 1997 case 12: 1998 { 1999 setState(378); 2000 html(); 2001 } 2002 break; 2003 case 13: 2004 { 2005 setState(379); 2006 option(); 2007 } 2008 break; 2009 case 14: 2010 { 2011 setState(380); 2012 tbody(); 2013 } 2014 break; 2015 case 15: 2016 { 2017 setState(381); 2018 thead(); 2019 } 2020 break; 2021 case 16: 2022 { 2023 setState(382); 2024 tfoot(); 2025 } 2026 break; 2027 case 17: 2028 { 2029 setState(383); 2030 optgroup(); 2031 } 2032 break; 2033 case 18: 2034 { 2035 setState(384); 2036 rb(); 2037 } 2038 break; 2039 case 19: 2040 { 2041 setState(385); 2042 rt(); 2043 } 2044 break; 2045 case 20: 2046 { 2047 setState(386); 2048 rtc(); 2049 } 2050 break; 2051 case 21: 2052 { 2053 setState(387); 2054 rp(); 2055 } 2056 break; 2057 case 22: 2058 { 2059 setState(388); 2060 liTagStart(true); 2061 } 2062 break; 2063 case 23: 2064 { 2065 setState(389); 2066 trTagStart(true); 2067 } 2068 break; 2069 case 24: 2070 { 2071 setState(390); 2072 tdTagStart(true); 2073 } 2074 break; 2075 case 25: 2076 { 2077 setState(391); 2078 thTagStart(true); 2079 } 2080 break; 2081 case 26: 2082 { 2083 setState(392); 2084 bodyTagStart(true); 2085 } 2086 break; 2087 case 27: 2088 { 2089 setState(393); 2090 colgroupTagStart(true); 2091 } 2092 break; 2093 case 28: 2094 { 2095 setState(394); 2096 ddTagStart(true); 2097 } 2098 break; 2099 case 29: 2100 { 2101 setState(395); 2102 dtTagStart(true); 2103 } 2104 break; 2105 case 30: 2106 { 2107 setState(396); 2108 headTagStart(true); 2109 } 2110 break; 2111 case 31: 2112 { 2113 setState(397); 2114 htmlTagStart(true); 2115 } 2116 break; 2117 case 32: 2118 { 2119 setState(398); 2120 optionTagStart(true); 2121 } 2122 break; 2123 case 33: 2124 { 2125 setState(399); 2126 tbodyTagStart(true); 2127 } 2128 break; 2129 case 34: 2130 { 2131 setState(400); 2132 theadTagStart(true); 2133 } 2134 break; 2135 case 35: 2136 { 2137 setState(401); 2138 tfootTagStart(true); 2139 } 2140 break; 2141 case 36: 2142 { 2143 setState(402); 2144 optgroupTagStart(true); 2145 } 2146 break; 2147 case 37: 2148 { 2149 setState(403); 2150 rbTagStart(true); 2151 } 2152 break; 2153 case 38: 2154 { 2155 setState(404); 2156 rtTagStart(true); 2157 } 2158 break; 2159 case 39: 2160 { 2161 setState(405); 2162 rtcTagStart(true); 2163 } 2164 break; 2165 case 40: 2166 { 2167 setState(406); 2168 rpTagStart(true); 2169 } 2170 break; 2171 case 41: 2172 { 2173 { 2174 setState(407); 2175 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2176 setState(408); 2177 match(LEADING_ASTERISK); 2178 } 2179 } 2180 break; 2181 case 42: 2182 { 2183 setState(409); 2184 htmlComment(); 2185 } 2186 break; 2187 case 43: 2188 { 2189 setState(410); 2190 match(NEWLINE); 2191 } 2192 break; 2193 case 44: 2194 { 2195 setState(411); 2196 text(); 2197 } 2198 break; 2199 case 45: 2200 { 2201 setState(412); 2202 javadocInlineTag(); 2203 } 2204 break; 2205 } 2206 } 2207 } 2208 setState(417); 2209 _errHandler.sync(this); 2210 _alt = getInterpreter().adaptivePredict(_input,18,_ctx); 2211 } 2212 setState(418); 2213 pTagEnd(); 2214 } 2215 } 2216 catch (RecognitionException re) { 2217 _localctx.exception = re; 2218 _errHandler.reportError(this, re); 2219 _errHandler.recover(this, re); 2220 } 2221 finally { 2222 exitRule(); 2223 } 2224 return _localctx; 2225 } 2226 2227 public static class LiTagStartContext extends ParserRuleContext { 2228 public boolean isNonTight; 2229 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 2230 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2231 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 2232 public List<AttributeContext> attribute() { 2233 return getRuleContexts(AttributeContext.class); 2234 } 2235 public AttributeContext attribute(int i) { 2236 return getRuleContext(AttributeContext.class,i); 2237 } 2238 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2239 public TerminalNode NEWLINE(int i) { 2240 return getToken(JavadocParser.NEWLINE, i); 2241 } 2242 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2243 public TerminalNode LEADING_ASTERISK(int i) { 2244 return getToken(JavadocParser.LEADING_ASTERISK, i); 2245 } 2246 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2247 public TerminalNode WS(int i) { 2248 return getToken(JavadocParser.WS, i); 2249 } 2250 public LiTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 2251 public LiTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 2252 super(parent, invokingState); 2253 this.isNonTight = isNonTight; 2254 } 2255 @Override public int getRuleIndex() { return RULE_liTagStart; } 2256 } 2257 2258 public final LiTagStartContext liTagStart(boolean isNonTight) throws RecognitionException { 2259 LiTagStartContext _localctx = new LiTagStartContext(_ctx, getState(), isNonTight); 2260 enterRule(_localctx, 18, RULE_liTagStart); 2261 int _la; 2262 try { 2263 enterOuterAlt(_localctx, 1); 2264 { 2265 setState(420); 2266 match(START); 2267 setState(421); 2268 match(LI_HTML_TAG_NAME); 2269 setState(428); 2270 _errHandler.sync(this); 2271 _la = _input.LA(1); 2272 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2273 { 2274 setState(426); 2275 _errHandler.sync(this); 2276 switch (_input.LA(1)) { 2277 case HTML_TAG_NAME: 2278 { 2279 setState(422); 2280 attribute(); 2281 } 2282 break; 2283 case NEWLINE: 2284 { 2285 setState(423); 2286 match(NEWLINE); 2287 } 2288 break; 2289 case LEADING_ASTERISK: 2290 { 2291 setState(424); 2292 match(LEADING_ASTERISK); 2293 } 2294 break; 2295 case WS: 2296 { 2297 setState(425); 2298 match(WS); 2299 } 2300 break; 2301 default: 2302 throw new NoViableAltException(this); 2303 } 2304 } 2305 setState(430); 2306 _errHandler.sync(this); 2307 _la = _input.LA(1); 2308 } 2309 setState(431); 2310 match(END); 2311 } 2312 _ctx.stop = _input.LT(-1); 2313 2314 if (isNonTight && nonTightTagStartContext == null) { 2315 nonTightTagStartContext = _localctx; 2316 } 2317 2318 } 2319 catch (RecognitionException re) { 2320 _localctx.exception = re; 2321 _errHandler.reportError(this, re); 2322 _errHandler.recover(this, re); 2323 } 2324 finally { 2325 exitRule(); 2326 } 2327 return _localctx; 2328 } 2329 2330 public static class LiTagEndContext extends ParserRuleContext { 2331 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 2332 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2333 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2334 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 2335 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2336 public TerminalNode NEWLINE(int i) { 2337 return getToken(JavadocParser.NEWLINE, i); 2338 } 2339 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2340 public TerminalNode LEADING_ASTERISK(int i) { 2341 return getToken(JavadocParser.LEADING_ASTERISK, i); 2342 } 2343 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2344 public TerminalNode WS(int i) { 2345 return getToken(JavadocParser.WS, i); 2346 } 2347 public LiTagEndContext(ParserRuleContext parent, int invokingState) { 2348 super(parent, invokingState); 2349 } 2350 @Override public int getRuleIndex() { return RULE_liTagEnd; } 2351 } 2352 2353 public final LiTagEndContext liTagEnd() throws RecognitionException { 2354 LiTagEndContext _localctx = new LiTagEndContext(_ctx, getState()); 2355 enterRule(_localctx, 20, RULE_liTagEnd); 2356 int _la; 2357 try { 2358 enterOuterAlt(_localctx, 1); 2359 { 2360 setState(433); 2361 match(START); 2362 setState(434); 2363 match(SLASH); 2364 setState(435); 2365 match(LI_HTML_TAG_NAME); 2366 setState(439); 2367 _errHandler.sync(this); 2368 _la = _input.LA(1); 2369 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2370 { 2371 { 2372 setState(436); 2373 _la = _input.LA(1); 2374 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2375 _errHandler.recoverInline(this); 2376 } 2377 else { 2378 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 2379 _errHandler.reportMatch(this); 2380 consume(); 2381 } 2382 } 2383 } 2384 setState(441); 2385 _errHandler.sync(this); 2386 _la = _input.LA(1); 2387 } 2388 setState(442); 2389 match(END); 2390 } 2391 } 2392 catch (RecognitionException re) { 2393 _localctx.exception = re; 2394 _errHandler.reportError(this, re); 2395 _errHandler.recover(this, re); 2396 } 2397 finally { 2398 exitRule(); 2399 } 2400 return _localctx; 2401 } 2402 2403 public static class LiContext extends ParserRuleContext { 2404 public LiTagStartContext liTagStart() { 2405 return getRuleContext(LiTagStartContext.class,0); 2406 } 2407 public LiTagEndContext liTagEnd() { 2408 return getRuleContext(LiTagEndContext.class,0); 2409 } 2410 public List<HtmlTagContext> htmlTag() { 2411 return getRuleContexts(HtmlTagContext.class); 2412 } 2413 public HtmlTagContext htmlTag(int i) { 2414 return getRuleContext(HtmlTagContext.class,i); 2415 } 2416 public List<SingletonElementContext> singletonElement() { 2417 return getRuleContexts(SingletonElementContext.class); 2418 } 2419 public SingletonElementContext singletonElement(int i) { 2420 return getRuleContext(SingletonElementContext.class,i); 2421 } 2422 public List<ParagraphContext> paragraph() { 2423 return getRuleContexts(ParagraphContext.class); 2424 } 2425 public ParagraphContext paragraph(int i) { 2426 return getRuleContext(ParagraphContext.class,i); 2427 } 2428 public List<TrContext> tr() { 2429 return getRuleContexts(TrContext.class); 2430 } 2431 public TrContext tr(int i) { 2432 return getRuleContext(TrContext.class,i); 2433 } 2434 public List<TdContext> td() { 2435 return getRuleContexts(TdContext.class); 2436 } 2437 public TdContext td(int i) { 2438 return getRuleContext(TdContext.class,i); 2439 } 2440 public List<ThContext> th() { 2441 return getRuleContexts(ThContext.class); 2442 } 2443 public ThContext th(int i) { 2444 return getRuleContext(ThContext.class,i); 2445 } 2446 public List<BodyContext> body() { 2447 return getRuleContexts(BodyContext.class); 2448 } 2449 public BodyContext body(int i) { 2450 return getRuleContext(BodyContext.class,i); 2451 } 2452 public List<ColgroupContext> colgroup() { 2453 return getRuleContexts(ColgroupContext.class); 2454 } 2455 public ColgroupContext colgroup(int i) { 2456 return getRuleContext(ColgroupContext.class,i); 2457 } 2458 public List<DdContext> dd() { 2459 return getRuleContexts(DdContext.class); 2460 } 2461 public DdContext dd(int i) { 2462 return getRuleContext(DdContext.class,i); 2463 } 2464 public List<DtContext> dt() { 2465 return getRuleContexts(DtContext.class); 2466 } 2467 public DtContext dt(int i) { 2468 return getRuleContext(DtContext.class,i); 2469 } 2470 public List<HeadContext> head() { 2471 return getRuleContexts(HeadContext.class); 2472 } 2473 public HeadContext head(int i) { 2474 return getRuleContext(HeadContext.class,i); 2475 } 2476 public List<HtmlContext> html() { 2477 return getRuleContexts(HtmlContext.class); 2478 } 2479 public HtmlContext html(int i) { 2480 return getRuleContext(HtmlContext.class,i); 2481 } 2482 public List<OptionContext> option() { 2483 return getRuleContexts(OptionContext.class); 2484 } 2485 public OptionContext option(int i) { 2486 return getRuleContext(OptionContext.class,i); 2487 } 2488 public List<TbodyContext> tbody() { 2489 return getRuleContexts(TbodyContext.class); 2490 } 2491 public TbodyContext tbody(int i) { 2492 return getRuleContext(TbodyContext.class,i); 2493 } 2494 public List<TheadContext> thead() { 2495 return getRuleContexts(TheadContext.class); 2496 } 2497 public TheadContext thead(int i) { 2498 return getRuleContext(TheadContext.class,i); 2499 } 2500 public List<TfootContext> tfoot() { 2501 return getRuleContexts(TfootContext.class); 2502 } 2503 public TfootContext tfoot(int i) { 2504 return getRuleContext(TfootContext.class,i); 2505 } 2506 public List<OptgroupContext> optgroup() { 2507 return getRuleContexts(OptgroupContext.class); 2508 } 2509 public OptgroupContext optgroup(int i) { 2510 return getRuleContext(OptgroupContext.class,i); 2511 } 2512 public List<RbContext> rb() { 2513 return getRuleContexts(RbContext.class); 2514 } 2515 public RbContext rb(int i) { 2516 return getRuleContext(RbContext.class,i); 2517 } 2518 public List<RtContext> rt() { 2519 return getRuleContexts(RtContext.class); 2520 } 2521 public RtContext rt(int i) { 2522 return getRuleContext(RtContext.class,i); 2523 } 2524 public List<RtcContext> rtc() { 2525 return getRuleContexts(RtcContext.class); 2526 } 2527 public RtcContext rtc(int i) { 2528 return getRuleContext(RtcContext.class,i); 2529 } 2530 public List<RpContext> rp() { 2531 return getRuleContexts(RpContext.class); 2532 } 2533 public RpContext rp(int i) { 2534 return getRuleContext(RpContext.class,i); 2535 } 2536 public List<PTagStartContext> pTagStart() { 2537 return getRuleContexts(PTagStartContext.class); 2538 } 2539 public PTagStartContext pTagStart(int i) { 2540 return getRuleContext(PTagStartContext.class,i); 2541 } 2542 public List<TrTagStartContext> trTagStart() { 2543 return getRuleContexts(TrTagStartContext.class); 2544 } 2545 public TrTagStartContext trTagStart(int i) { 2546 return getRuleContext(TrTagStartContext.class,i); 2547 } 2548 public List<TdTagStartContext> tdTagStart() { 2549 return getRuleContexts(TdTagStartContext.class); 2550 } 2551 public TdTagStartContext tdTagStart(int i) { 2552 return getRuleContext(TdTagStartContext.class,i); 2553 } 2554 public List<ThTagStartContext> thTagStart() { 2555 return getRuleContexts(ThTagStartContext.class); 2556 } 2557 public ThTagStartContext thTagStart(int i) { 2558 return getRuleContext(ThTagStartContext.class,i); 2559 } 2560 public List<BodyTagStartContext> bodyTagStart() { 2561 return getRuleContexts(BodyTagStartContext.class); 2562 } 2563 public BodyTagStartContext bodyTagStart(int i) { 2564 return getRuleContext(BodyTagStartContext.class,i); 2565 } 2566 public List<ColgroupTagStartContext> colgroupTagStart() { 2567 return getRuleContexts(ColgroupTagStartContext.class); 2568 } 2569 public ColgroupTagStartContext colgroupTagStart(int i) { 2570 return getRuleContext(ColgroupTagStartContext.class,i); 2571 } 2572 public List<DdTagStartContext> ddTagStart() { 2573 return getRuleContexts(DdTagStartContext.class); 2574 } 2575 public DdTagStartContext ddTagStart(int i) { 2576 return getRuleContext(DdTagStartContext.class,i); 2577 } 2578 public List<DtTagStartContext> dtTagStart() { 2579 return getRuleContexts(DtTagStartContext.class); 2580 } 2581 public DtTagStartContext dtTagStart(int i) { 2582 return getRuleContext(DtTagStartContext.class,i); 2583 } 2584 public List<HeadTagStartContext> headTagStart() { 2585 return getRuleContexts(HeadTagStartContext.class); 2586 } 2587 public HeadTagStartContext headTagStart(int i) { 2588 return getRuleContext(HeadTagStartContext.class,i); 2589 } 2590 public List<HtmlTagStartContext> htmlTagStart() { 2591 return getRuleContexts(HtmlTagStartContext.class); 2592 } 2593 public HtmlTagStartContext htmlTagStart(int i) { 2594 return getRuleContext(HtmlTagStartContext.class,i); 2595 } 2596 public List<OptionTagStartContext> optionTagStart() { 2597 return getRuleContexts(OptionTagStartContext.class); 2598 } 2599 public OptionTagStartContext optionTagStart(int i) { 2600 return getRuleContext(OptionTagStartContext.class,i); 2601 } 2602 public List<TbodyTagStartContext> tbodyTagStart() { 2603 return getRuleContexts(TbodyTagStartContext.class); 2604 } 2605 public TbodyTagStartContext tbodyTagStart(int i) { 2606 return getRuleContext(TbodyTagStartContext.class,i); 2607 } 2608 public List<TheadTagStartContext> theadTagStart() { 2609 return getRuleContexts(TheadTagStartContext.class); 2610 } 2611 public TheadTagStartContext theadTagStart(int i) { 2612 return getRuleContext(TheadTagStartContext.class,i); 2613 } 2614 public List<TfootTagStartContext> tfootTagStart() { 2615 return getRuleContexts(TfootTagStartContext.class); 2616 } 2617 public TfootTagStartContext tfootTagStart(int i) { 2618 return getRuleContext(TfootTagStartContext.class,i); 2619 } 2620 public List<OptgroupTagStartContext> optgroupTagStart() { 2621 return getRuleContexts(OptgroupTagStartContext.class); 2622 } 2623 public OptgroupTagStartContext optgroupTagStart(int i) { 2624 return getRuleContext(OptgroupTagStartContext.class,i); 2625 } 2626 public List<RbTagStartContext> rbTagStart() { 2627 return getRuleContexts(RbTagStartContext.class); 2628 } 2629 public RbTagStartContext rbTagStart(int i) { 2630 return getRuleContext(RbTagStartContext.class,i); 2631 } 2632 public List<RtTagStartContext> rtTagStart() { 2633 return getRuleContexts(RtTagStartContext.class); 2634 } 2635 public RtTagStartContext rtTagStart(int i) { 2636 return getRuleContext(RtTagStartContext.class,i); 2637 } 2638 public List<RtcTagStartContext> rtcTagStart() { 2639 return getRuleContexts(RtcTagStartContext.class); 2640 } 2641 public RtcTagStartContext rtcTagStart(int i) { 2642 return getRuleContext(RtcTagStartContext.class,i); 2643 } 2644 public List<RpTagStartContext> rpTagStart() { 2645 return getRuleContexts(RpTagStartContext.class); 2646 } 2647 public RpTagStartContext rpTagStart(int i) { 2648 return getRuleContext(RpTagStartContext.class,i); 2649 } 2650 public List<HtmlCommentContext> htmlComment() { 2651 return getRuleContexts(HtmlCommentContext.class); 2652 } 2653 public HtmlCommentContext htmlComment(int i) { 2654 return getRuleContext(HtmlCommentContext.class,i); 2655 } 2656 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2657 public TerminalNode NEWLINE(int i) { 2658 return getToken(JavadocParser.NEWLINE, i); 2659 } 2660 public List<TextContext> text() { 2661 return getRuleContexts(TextContext.class); 2662 } 2663 public TextContext text(int i) { 2664 return getRuleContext(TextContext.class,i); 2665 } 2666 public List<JavadocInlineTagContext> javadocInlineTag() { 2667 return getRuleContexts(JavadocInlineTagContext.class); 2668 } 2669 public JavadocInlineTagContext javadocInlineTag(int i) { 2670 return getRuleContext(JavadocInlineTagContext.class,i); 2671 } 2672 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2673 public TerminalNode LEADING_ASTERISK(int i) { 2674 return getToken(JavadocParser.LEADING_ASTERISK, i); 2675 } 2676 public LiContext(ParserRuleContext parent, int invokingState) { 2677 super(parent, invokingState); 2678 } 2679 @Override public int getRuleIndex() { return RULE_li; } 2680 } 2681 2682 public final LiContext li() throws RecognitionException { 2683 LiContext _localctx = new LiContext(_ctx, getState()); 2684 enterRule(_localctx, 22, RULE_li); 2685 try { 2686 int _alt; 2687 enterOuterAlt(_localctx, 1); 2688 { 2689 setState(444); 2690 liTagStart(false); 2691 setState(493); 2692 _errHandler.sync(this); 2693 _alt = getInterpreter().adaptivePredict(_input,23,_ctx); 2694 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 2695 if ( _alt==1 ) { 2696 { 2697 setState(491); 2698 _errHandler.sync(this); 2699 switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) { 2700 case 1: 2701 { 2702 setState(445); 2703 htmlTag(); 2704 } 2705 break; 2706 case 2: 2707 { 2708 setState(446); 2709 singletonElement(); 2710 } 2711 break; 2712 case 3: 2713 { 2714 setState(447); 2715 paragraph(); 2716 } 2717 break; 2718 case 4: 2719 { 2720 setState(448); 2721 tr(); 2722 } 2723 break; 2724 case 5: 2725 { 2726 setState(449); 2727 td(); 2728 } 2729 break; 2730 case 6: 2731 { 2732 setState(450); 2733 th(); 2734 } 2735 break; 2736 case 7: 2737 { 2738 setState(451); 2739 body(); 2740 } 2741 break; 2742 case 8: 2743 { 2744 setState(452); 2745 colgroup(); 2746 } 2747 break; 2748 case 9: 2749 { 2750 setState(453); 2751 dd(); 2752 } 2753 break; 2754 case 10: 2755 { 2756 setState(454); 2757 dt(); 2758 } 2759 break; 2760 case 11: 2761 { 2762 setState(455); 2763 head(); 2764 } 2765 break; 2766 case 12: 2767 { 2768 setState(456); 2769 html(); 2770 } 2771 break; 2772 case 13: 2773 { 2774 setState(457); 2775 option(); 2776 } 2777 break; 2778 case 14: 2779 { 2780 setState(458); 2781 tbody(); 2782 } 2783 break; 2784 case 15: 2785 { 2786 setState(459); 2787 thead(); 2788 } 2789 break; 2790 case 16: 2791 { 2792 setState(460); 2793 tfoot(); 2794 } 2795 break; 2796 case 17: 2797 { 2798 setState(461); 2799 optgroup(); 2800 } 2801 break; 2802 case 18: 2803 { 2804 setState(462); 2805 rb(); 2806 } 2807 break; 2808 case 19: 2809 { 2810 setState(463); 2811 rt(); 2812 } 2813 break; 2814 case 20: 2815 { 2816 setState(464); 2817 rtc(); 2818 } 2819 break; 2820 case 21: 2821 { 2822 setState(465); 2823 rp(); 2824 } 2825 break; 2826 case 22: 2827 { 2828 setState(466); 2829 pTagStart(true); 2830 } 2831 break; 2832 case 23: 2833 { 2834 setState(467); 2835 trTagStart(true); 2836 } 2837 break; 2838 case 24: 2839 { 2840 setState(468); 2841 tdTagStart(true); 2842 } 2843 break; 2844 case 25: 2845 { 2846 setState(469); 2847 thTagStart(true); 2848 } 2849 break; 2850 case 26: 2851 { 2852 setState(470); 2853 bodyTagStart(true); 2854 } 2855 break; 2856 case 27: 2857 { 2858 setState(471); 2859 colgroupTagStart(true); 2860 } 2861 break; 2862 case 28: 2863 { 2864 setState(472); 2865 ddTagStart(true); 2866 } 2867 break; 2868 case 29: 2869 { 2870 setState(473); 2871 dtTagStart(true); 2872 } 2873 break; 2874 case 30: 2875 { 2876 setState(474); 2877 headTagStart(true); 2878 } 2879 break; 2880 case 31: 2881 { 2882 setState(475); 2883 htmlTagStart(true); 2884 } 2885 break; 2886 case 32: 2887 { 2888 setState(476); 2889 optionTagStart(true); 2890 } 2891 break; 2892 case 33: 2893 { 2894 setState(477); 2895 tbodyTagStart(true); 2896 } 2897 break; 2898 case 34: 2899 { 2900 setState(478); 2901 theadTagStart(true); 2902 } 2903 break; 2904 case 35: 2905 { 2906 setState(479); 2907 tfootTagStart(true); 2908 } 2909 break; 2910 case 36: 2911 { 2912 setState(480); 2913 optgroupTagStart(true); 2914 } 2915 break; 2916 case 37: 2917 { 2918 setState(481); 2919 rbTagStart(true); 2920 } 2921 break; 2922 case 38: 2923 { 2924 setState(482); 2925 rtTagStart(true); 2926 } 2927 break; 2928 case 39: 2929 { 2930 setState(483); 2931 rtcTagStart(true); 2932 } 2933 break; 2934 case 40: 2935 { 2936 setState(484); 2937 rpTagStart(true); 2938 } 2939 break; 2940 case 41: 2941 { 2942 { 2943 setState(485); 2944 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2945 setState(486); 2946 match(LEADING_ASTERISK); 2947 } 2948 } 2949 break; 2950 case 42: 2951 { 2952 setState(487); 2953 htmlComment(); 2954 } 2955 break; 2956 case 43: 2957 { 2958 setState(488); 2959 match(NEWLINE); 2960 } 2961 break; 2962 case 44: 2963 { 2964 setState(489); 2965 text(); 2966 } 2967 break; 2968 case 45: 2969 { 2970 setState(490); 2971 javadocInlineTag(); 2972 } 2973 break; 2974 } 2975 } 2976 } 2977 setState(495); 2978 _errHandler.sync(this); 2979 _alt = getInterpreter().adaptivePredict(_input,23,_ctx); 2980 } 2981 setState(496); 2982 liTagEnd(); 2983 } 2984 } 2985 catch (RecognitionException re) { 2986 _localctx.exception = re; 2987 _errHandler.reportError(this, re); 2988 _errHandler.recover(this, re); 2989 } 2990 finally { 2991 exitRule(); 2992 } 2993 return _localctx; 2994 } 2995 2996 public static class TrTagStartContext extends ParserRuleContext { 2997 public boolean isNonTight; 2998 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 2999 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 3000 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 3001 public List<AttributeContext> attribute() { 3002 return getRuleContexts(AttributeContext.class); 3003 } 3004 public AttributeContext attribute(int i) { 3005 return getRuleContext(AttributeContext.class,i); 3006 } 3007 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3008 public TerminalNode NEWLINE(int i) { 3009 return getToken(JavadocParser.NEWLINE, i); 3010 } 3011 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3012 public TerminalNode LEADING_ASTERISK(int i) { 3013 return getToken(JavadocParser.LEADING_ASTERISK, i); 3014 } 3015 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3016 public TerminalNode WS(int i) { 3017 return getToken(JavadocParser.WS, i); 3018 } 3019 public TrTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 3020 public TrTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 3021 super(parent, invokingState); 3022 this.isNonTight = isNonTight; 3023 } 3024 @Override public int getRuleIndex() { return RULE_trTagStart; } 3025 } 3026 3027 public final TrTagStartContext trTagStart(boolean isNonTight) throws RecognitionException { 3028 TrTagStartContext _localctx = new TrTagStartContext(_ctx, getState(), isNonTight); 3029 enterRule(_localctx, 24, RULE_trTagStart); 3030 int _la; 3031 try { 3032 enterOuterAlt(_localctx, 1); 3033 { 3034 setState(498); 3035 match(START); 3036 setState(499); 3037 match(TR_HTML_TAG_NAME); 3038 setState(506); 3039 _errHandler.sync(this); 3040 _la = _input.LA(1); 3041 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 3042 { 3043 setState(504); 3044 _errHandler.sync(this); 3045 switch (_input.LA(1)) { 3046 case HTML_TAG_NAME: 3047 { 3048 setState(500); 3049 attribute(); 3050 } 3051 break; 3052 case NEWLINE: 3053 { 3054 setState(501); 3055 match(NEWLINE); 3056 } 3057 break; 3058 case LEADING_ASTERISK: 3059 { 3060 setState(502); 3061 match(LEADING_ASTERISK); 3062 } 3063 break; 3064 case WS: 3065 { 3066 setState(503); 3067 match(WS); 3068 } 3069 break; 3070 default: 3071 throw new NoViableAltException(this); 3072 } 3073 } 3074 setState(508); 3075 _errHandler.sync(this); 3076 _la = _input.LA(1); 3077 } 3078 setState(509); 3079 match(END); 3080 } 3081 _ctx.stop = _input.LT(-1); 3082 3083 if (isNonTight && nonTightTagStartContext == null) { 3084 nonTightTagStartContext = _localctx; 3085 } 3086 3087 } 3088 catch (RecognitionException re) { 3089 _localctx.exception = re; 3090 _errHandler.reportError(this, re); 3091 _errHandler.recover(this, re); 3092 } 3093 finally { 3094 exitRule(); 3095 } 3096 return _localctx; 3097 } 3098 3099 public static class TrTagEndContext extends ParserRuleContext { 3100 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 3101 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 3102 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 3103 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 3104 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3105 public TerminalNode NEWLINE(int i) { 3106 return getToken(JavadocParser.NEWLINE, i); 3107 } 3108 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3109 public TerminalNode LEADING_ASTERISK(int i) { 3110 return getToken(JavadocParser.LEADING_ASTERISK, i); 3111 } 3112 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3113 public TerminalNode WS(int i) { 3114 return getToken(JavadocParser.WS, i); 3115 } 3116 public TrTagEndContext(ParserRuleContext parent, int invokingState) { 3117 super(parent, invokingState); 3118 } 3119 @Override public int getRuleIndex() { return RULE_trTagEnd; } 3120 } 3121 3122 public final TrTagEndContext trTagEnd() throws RecognitionException { 3123 TrTagEndContext _localctx = new TrTagEndContext(_ctx, getState()); 3124 enterRule(_localctx, 26, RULE_trTagEnd); 3125 int _la; 3126 try { 3127 enterOuterAlt(_localctx, 1); 3128 { 3129 setState(511); 3130 match(START); 3131 setState(512); 3132 match(SLASH); 3133 setState(513); 3134 match(TR_HTML_TAG_NAME); 3135 setState(517); 3136 _errHandler.sync(this); 3137 _la = _input.LA(1); 3138 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 3139 { 3140 { 3141 setState(514); 3142 _la = _input.LA(1); 3143 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 3144 _errHandler.recoverInline(this); 3145 } 3146 else { 3147 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3148 _errHandler.reportMatch(this); 3149 consume(); 3150 } 3151 } 3152 } 3153 setState(519); 3154 _errHandler.sync(this); 3155 _la = _input.LA(1); 3156 } 3157 setState(520); 3158 match(END); 3159 } 3160 } 3161 catch (RecognitionException re) { 3162 _localctx.exception = re; 3163 _errHandler.reportError(this, re); 3164 _errHandler.recover(this, re); 3165 } 3166 finally { 3167 exitRule(); 3168 } 3169 return _localctx; 3170 } 3171 3172 public static class TrContext extends ParserRuleContext { 3173 public TrTagStartContext trTagStart() { 3174 return getRuleContext(TrTagStartContext.class,0); 3175 } 3176 public TrTagEndContext trTagEnd() { 3177 return getRuleContext(TrTagEndContext.class,0); 3178 } 3179 public List<HtmlTagContext> htmlTag() { 3180 return getRuleContexts(HtmlTagContext.class); 3181 } 3182 public HtmlTagContext htmlTag(int i) { 3183 return getRuleContext(HtmlTagContext.class,i); 3184 } 3185 public List<SingletonElementContext> singletonElement() { 3186 return getRuleContexts(SingletonElementContext.class); 3187 } 3188 public SingletonElementContext singletonElement(int i) { 3189 return getRuleContext(SingletonElementContext.class,i); 3190 } 3191 public List<ParagraphContext> paragraph() { 3192 return getRuleContexts(ParagraphContext.class); 3193 } 3194 public ParagraphContext paragraph(int i) { 3195 return getRuleContext(ParagraphContext.class,i); 3196 } 3197 public List<LiContext> li() { 3198 return getRuleContexts(LiContext.class); 3199 } 3200 public LiContext li(int i) { 3201 return getRuleContext(LiContext.class,i); 3202 } 3203 public List<TdContext> td() { 3204 return getRuleContexts(TdContext.class); 3205 } 3206 public TdContext td(int i) { 3207 return getRuleContext(TdContext.class,i); 3208 } 3209 public List<ThContext> th() { 3210 return getRuleContexts(ThContext.class); 3211 } 3212 public ThContext th(int i) { 3213 return getRuleContext(ThContext.class,i); 3214 } 3215 public List<BodyContext> body() { 3216 return getRuleContexts(BodyContext.class); 3217 } 3218 public BodyContext body(int i) { 3219 return getRuleContext(BodyContext.class,i); 3220 } 3221 public List<ColgroupContext> colgroup() { 3222 return getRuleContexts(ColgroupContext.class); 3223 } 3224 public ColgroupContext colgroup(int i) { 3225 return getRuleContext(ColgroupContext.class,i); 3226 } 3227 public List<DdContext> dd() { 3228 return getRuleContexts(DdContext.class); 3229 } 3230 public DdContext dd(int i) { 3231 return getRuleContext(DdContext.class,i); 3232 } 3233 public List<DtContext> dt() { 3234 return getRuleContexts(DtContext.class); 3235 } 3236 public DtContext dt(int i) { 3237 return getRuleContext(DtContext.class,i); 3238 } 3239 public List<HeadContext> head() { 3240 return getRuleContexts(HeadContext.class); 3241 } 3242 public HeadContext head(int i) { 3243 return getRuleContext(HeadContext.class,i); 3244 } 3245 public List<HtmlContext> html() { 3246 return getRuleContexts(HtmlContext.class); 3247 } 3248 public HtmlContext html(int i) { 3249 return getRuleContext(HtmlContext.class,i); 3250 } 3251 public List<OptionContext> option() { 3252 return getRuleContexts(OptionContext.class); 3253 } 3254 public OptionContext option(int i) { 3255 return getRuleContext(OptionContext.class,i); 3256 } 3257 public List<TbodyContext> tbody() { 3258 return getRuleContexts(TbodyContext.class); 3259 } 3260 public TbodyContext tbody(int i) { 3261 return getRuleContext(TbodyContext.class,i); 3262 } 3263 public List<TheadContext> thead() { 3264 return getRuleContexts(TheadContext.class); 3265 } 3266 public TheadContext thead(int i) { 3267 return getRuleContext(TheadContext.class,i); 3268 } 3269 public List<TfootContext> tfoot() { 3270 return getRuleContexts(TfootContext.class); 3271 } 3272 public TfootContext tfoot(int i) { 3273 return getRuleContext(TfootContext.class,i); 3274 } 3275 public List<OptgroupContext> optgroup() { 3276 return getRuleContexts(OptgroupContext.class); 3277 } 3278 public OptgroupContext optgroup(int i) { 3279 return getRuleContext(OptgroupContext.class,i); 3280 } 3281 public List<RbContext> rb() { 3282 return getRuleContexts(RbContext.class); 3283 } 3284 public RbContext rb(int i) { 3285 return getRuleContext(RbContext.class,i); 3286 } 3287 public List<RtContext> rt() { 3288 return getRuleContexts(RtContext.class); 3289 } 3290 public RtContext rt(int i) { 3291 return getRuleContext(RtContext.class,i); 3292 } 3293 public List<RtcContext> rtc() { 3294 return getRuleContexts(RtcContext.class); 3295 } 3296 public RtcContext rtc(int i) { 3297 return getRuleContext(RtcContext.class,i); 3298 } 3299 public List<RpContext> rp() { 3300 return getRuleContexts(RpContext.class); 3301 } 3302 public RpContext rp(int i) { 3303 return getRuleContext(RpContext.class,i); 3304 } 3305 public List<PTagStartContext> pTagStart() { 3306 return getRuleContexts(PTagStartContext.class); 3307 } 3308 public PTagStartContext pTagStart(int i) { 3309 return getRuleContext(PTagStartContext.class,i); 3310 } 3311 public List<LiTagStartContext> liTagStart() { 3312 return getRuleContexts(LiTagStartContext.class); 3313 } 3314 public LiTagStartContext liTagStart(int i) { 3315 return getRuleContext(LiTagStartContext.class,i); 3316 } 3317 public List<TdTagStartContext> tdTagStart() { 3318 return getRuleContexts(TdTagStartContext.class); 3319 } 3320 public TdTagStartContext tdTagStart(int i) { 3321 return getRuleContext(TdTagStartContext.class,i); 3322 } 3323 public List<ThTagStartContext> thTagStart() { 3324 return getRuleContexts(ThTagStartContext.class); 3325 } 3326 public ThTagStartContext thTagStart(int i) { 3327 return getRuleContext(ThTagStartContext.class,i); 3328 } 3329 public List<BodyTagStartContext> bodyTagStart() { 3330 return getRuleContexts(BodyTagStartContext.class); 3331 } 3332 public BodyTagStartContext bodyTagStart(int i) { 3333 return getRuleContext(BodyTagStartContext.class,i); 3334 } 3335 public List<ColgroupTagStartContext> colgroupTagStart() { 3336 return getRuleContexts(ColgroupTagStartContext.class); 3337 } 3338 public ColgroupTagStartContext colgroupTagStart(int i) { 3339 return getRuleContext(ColgroupTagStartContext.class,i); 3340 } 3341 public List<DdTagStartContext> ddTagStart() { 3342 return getRuleContexts(DdTagStartContext.class); 3343 } 3344 public DdTagStartContext ddTagStart(int i) { 3345 return getRuleContext(DdTagStartContext.class,i); 3346 } 3347 public List<DtTagStartContext> dtTagStart() { 3348 return getRuleContexts(DtTagStartContext.class); 3349 } 3350 public DtTagStartContext dtTagStart(int i) { 3351 return getRuleContext(DtTagStartContext.class,i); 3352 } 3353 public List<HeadTagStartContext> headTagStart() { 3354 return getRuleContexts(HeadTagStartContext.class); 3355 } 3356 public HeadTagStartContext headTagStart(int i) { 3357 return getRuleContext(HeadTagStartContext.class,i); 3358 } 3359 public List<HtmlTagStartContext> htmlTagStart() { 3360 return getRuleContexts(HtmlTagStartContext.class); 3361 } 3362 public HtmlTagStartContext htmlTagStart(int i) { 3363 return getRuleContext(HtmlTagStartContext.class,i); 3364 } 3365 public List<OptionTagStartContext> optionTagStart() { 3366 return getRuleContexts(OptionTagStartContext.class); 3367 } 3368 public OptionTagStartContext optionTagStart(int i) { 3369 return getRuleContext(OptionTagStartContext.class,i); 3370 } 3371 public List<TbodyTagStartContext> tbodyTagStart() { 3372 return getRuleContexts(TbodyTagStartContext.class); 3373 } 3374 public TbodyTagStartContext tbodyTagStart(int i) { 3375 return getRuleContext(TbodyTagStartContext.class,i); 3376 } 3377 public List<TheadTagStartContext> theadTagStart() { 3378 return getRuleContexts(TheadTagStartContext.class); 3379 } 3380 public TheadTagStartContext theadTagStart(int i) { 3381 return getRuleContext(TheadTagStartContext.class,i); 3382 } 3383 public List<TfootTagStartContext> tfootTagStart() { 3384 return getRuleContexts(TfootTagStartContext.class); 3385 } 3386 public TfootTagStartContext tfootTagStart(int i) { 3387 return getRuleContext(TfootTagStartContext.class,i); 3388 } 3389 public List<OptgroupTagStartContext> optgroupTagStart() { 3390 return getRuleContexts(OptgroupTagStartContext.class); 3391 } 3392 public OptgroupTagStartContext optgroupTagStart(int i) { 3393 return getRuleContext(OptgroupTagStartContext.class,i); 3394 } 3395 public List<RbTagStartContext> rbTagStart() { 3396 return getRuleContexts(RbTagStartContext.class); 3397 } 3398 public RbTagStartContext rbTagStart(int i) { 3399 return getRuleContext(RbTagStartContext.class,i); 3400 } 3401 public List<RtTagStartContext> rtTagStart() { 3402 return getRuleContexts(RtTagStartContext.class); 3403 } 3404 public RtTagStartContext rtTagStart(int i) { 3405 return getRuleContext(RtTagStartContext.class,i); 3406 } 3407 public List<RtcTagStartContext> rtcTagStart() { 3408 return getRuleContexts(RtcTagStartContext.class); 3409 } 3410 public RtcTagStartContext rtcTagStart(int i) { 3411 return getRuleContext(RtcTagStartContext.class,i); 3412 } 3413 public List<RpTagStartContext> rpTagStart() { 3414 return getRuleContexts(RpTagStartContext.class); 3415 } 3416 public RpTagStartContext rpTagStart(int i) { 3417 return getRuleContext(RpTagStartContext.class,i); 3418 } 3419 public List<HtmlCommentContext> htmlComment() { 3420 return getRuleContexts(HtmlCommentContext.class); 3421 } 3422 public HtmlCommentContext htmlComment(int i) { 3423 return getRuleContext(HtmlCommentContext.class,i); 3424 } 3425 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3426 public TerminalNode NEWLINE(int i) { 3427 return getToken(JavadocParser.NEWLINE, i); 3428 } 3429 public List<TextContext> text() { 3430 return getRuleContexts(TextContext.class); 3431 } 3432 public TextContext text(int i) { 3433 return getRuleContext(TextContext.class,i); 3434 } 3435 public List<JavadocInlineTagContext> javadocInlineTag() { 3436 return getRuleContexts(JavadocInlineTagContext.class); 3437 } 3438 public JavadocInlineTagContext javadocInlineTag(int i) { 3439 return getRuleContext(JavadocInlineTagContext.class,i); 3440 } 3441 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3442 public TerminalNode LEADING_ASTERISK(int i) { 3443 return getToken(JavadocParser.LEADING_ASTERISK, i); 3444 } 3445 public TrContext(ParserRuleContext parent, int invokingState) { 3446 super(parent, invokingState); 3447 } 3448 @Override public int getRuleIndex() { return RULE_tr; } 3449 } 3450 3451 public final TrContext tr() throws RecognitionException { 3452 TrContext _localctx = new TrContext(_ctx, getState()); 3453 enterRule(_localctx, 28, RULE_tr); 3454 try { 3455 int _alt; 3456 enterOuterAlt(_localctx, 1); 3457 { 3458 setState(522); 3459 trTagStart(false); 3460 setState(571); 3461 _errHandler.sync(this); 3462 _alt = getInterpreter().adaptivePredict(_input,28,_ctx); 3463 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3464 if ( _alt==1 ) { 3465 { 3466 setState(569); 3467 _errHandler.sync(this); 3468 switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) { 3469 case 1: 3470 { 3471 setState(523); 3472 htmlTag(); 3473 } 3474 break; 3475 case 2: 3476 { 3477 setState(524); 3478 singletonElement(); 3479 } 3480 break; 3481 case 3: 3482 { 3483 setState(525); 3484 paragraph(); 3485 } 3486 break; 3487 case 4: 3488 { 3489 setState(526); 3490 li(); 3491 } 3492 break; 3493 case 5: 3494 { 3495 setState(527); 3496 td(); 3497 } 3498 break; 3499 case 6: 3500 { 3501 setState(528); 3502 th(); 3503 } 3504 break; 3505 case 7: 3506 { 3507 setState(529); 3508 body(); 3509 } 3510 break; 3511 case 8: 3512 { 3513 setState(530); 3514 colgroup(); 3515 } 3516 break; 3517 case 9: 3518 { 3519 setState(531); 3520 dd(); 3521 } 3522 break; 3523 case 10: 3524 { 3525 setState(532); 3526 dt(); 3527 } 3528 break; 3529 case 11: 3530 { 3531 setState(533); 3532 head(); 3533 } 3534 break; 3535 case 12: 3536 { 3537 setState(534); 3538 html(); 3539 } 3540 break; 3541 case 13: 3542 { 3543 setState(535); 3544 option(); 3545 } 3546 break; 3547 case 14: 3548 { 3549 setState(536); 3550 tbody(); 3551 } 3552 break; 3553 case 15: 3554 { 3555 setState(537); 3556 thead(); 3557 } 3558 break; 3559 case 16: 3560 { 3561 setState(538); 3562 tfoot(); 3563 } 3564 break; 3565 case 17: 3566 { 3567 setState(539); 3568 optgroup(); 3569 } 3570 break; 3571 case 18: 3572 { 3573 setState(540); 3574 rb(); 3575 } 3576 break; 3577 case 19: 3578 { 3579 setState(541); 3580 rt(); 3581 } 3582 break; 3583 case 20: 3584 { 3585 setState(542); 3586 rtc(); 3587 } 3588 break; 3589 case 21: 3590 { 3591 setState(543); 3592 rp(); 3593 } 3594 break; 3595 case 22: 3596 { 3597 setState(544); 3598 pTagStart(true); 3599 } 3600 break; 3601 case 23: 3602 { 3603 setState(545); 3604 liTagStart(true); 3605 } 3606 break; 3607 case 24: 3608 { 3609 setState(546); 3610 tdTagStart(true); 3611 } 3612 break; 3613 case 25: 3614 { 3615 setState(547); 3616 thTagStart(true); 3617 } 3618 break; 3619 case 26: 3620 { 3621 setState(548); 3622 bodyTagStart(true); 3623 } 3624 break; 3625 case 27: 3626 { 3627 setState(549); 3628 colgroupTagStart(true); 3629 } 3630 break; 3631 case 28: 3632 { 3633 setState(550); 3634 ddTagStart(true); 3635 } 3636 break; 3637 case 29: 3638 { 3639 setState(551); 3640 dtTagStart(true); 3641 } 3642 break; 3643 case 30: 3644 { 3645 setState(552); 3646 headTagStart(true); 3647 } 3648 break; 3649 case 31: 3650 { 3651 setState(553); 3652 htmlTagStart(true); 3653 } 3654 break; 3655 case 32: 3656 { 3657 setState(554); 3658 optionTagStart(true); 3659 } 3660 break; 3661 case 33: 3662 { 3663 setState(555); 3664 tbodyTagStart(true); 3665 } 3666 break; 3667 case 34: 3668 { 3669 setState(556); 3670 theadTagStart(true); 3671 } 3672 break; 3673 case 35: 3674 { 3675 setState(557); 3676 tfootTagStart(true); 3677 } 3678 break; 3679 case 36: 3680 { 3681 setState(558); 3682 optgroupTagStart(true); 3683 } 3684 break; 3685 case 37: 3686 { 3687 setState(559); 3688 rbTagStart(true); 3689 } 3690 break; 3691 case 38: 3692 { 3693 setState(560); 3694 rtTagStart(true); 3695 } 3696 break; 3697 case 39: 3698 { 3699 setState(561); 3700 rtcTagStart(true); 3701 } 3702 break; 3703 case 40: 3704 { 3705 setState(562); 3706 rpTagStart(true); 3707 } 3708 break; 3709 case 41: 3710 { 3711 { 3712 setState(563); 3713 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 3714 setState(564); 3715 match(LEADING_ASTERISK); 3716 } 3717 } 3718 break; 3719 case 42: 3720 { 3721 setState(565); 3722 htmlComment(); 3723 } 3724 break; 3725 case 43: 3726 { 3727 setState(566); 3728 match(NEWLINE); 3729 } 3730 break; 3731 case 44: 3732 { 3733 setState(567); 3734 text(); 3735 } 3736 break; 3737 case 45: 3738 { 3739 setState(568); 3740 javadocInlineTag(); 3741 } 3742 break; 3743 } 3744 } 3745 } 3746 setState(573); 3747 _errHandler.sync(this); 3748 _alt = getInterpreter().adaptivePredict(_input,28,_ctx); 3749 } 3750 setState(574); 3751 trTagEnd(); 3752 } 3753 } 3754 catch (RecognitionException re) { 3755 _localctx.exception = re; 3756 _errHandler.reportError(this, re); 3757 _errHandler.recover(this, re); 3758 } 3759 finally { 3760 exitRule(); 3761 } 3762 return _localctx; 3763 } 3764 3765 public static class TdTagStartContext extends ParserRuleContext { 3766 public boolean isNonTight; 3767 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 3768 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3769 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 3770 public List<AttributeContext> attribute() { 3771 return getRuleContexts(AttributeContext.class); 3772 } 3773 public AttributeContext attribute(int i) { 3774 return getRuleContext(AttributeContext.class,i); 3775 } 3776 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3777 public TerminalNode NEWLINE(int i) { 3778 return getToken(JavadocParser.NEWLINE, i); 3779 } 3780 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3781 public TerminalNode LEADING_ASTERISK(int i) { 3782 return getToken(JavadocParser.LEADING_ASTERISK, i); 3783 } 3784 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3785 public TerminalNode WS(int i) { 3786 return getToken(JavadocParser.WS, i); 3787 } 3788 public TdTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 3789 public TdTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 3790 super(parent, invokingState); 3791 this.isNonTight = isNonTight; 3792 } 3793 @Override public int getRuleIndex() { return RULE_tdTagStart; } 3794 } 3795 3796 public final TdTagStartContext tdTagStart(boolean isNonTight) throws RecognitionException { 3797 TdTagStartContext _localctx = new TdTagStartContext(_ctx, getState(), isNonTight); 3798 enterRule(_localctx, 30, RULE_tdTagStart); 3799 int _la; 3800 try { 3801 enterOuterAlt(_localctx, 1); 3802 { 3803 setState(576); 3804 match(START); 3805 setState(577); 3806 match(TD_HTML_TAG_NAME); 3807 setState(584); 3808 _errHandler.sync(this); 3809 _la = _input.LA(1); 3810 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 3811 { 3812 setState(582); 3813 _errHandler.sync(this); 3814 switch (_input.LA(1)) { 3815 case HTML_TAG_NAME: 3816 { 3817 setState(578); 3818 attribute(); 3819 } 3820 break; 3821 case NEWLINE: 3822 { 3823 setState(579); 3824 match(NEWLINE); 3825 } 3826 break; 3827 case LEADING_ASTERISK: 3828 { 3829 setState(580); 3830 match(LEADING_ASTERISK); 3831 } 3832 break; 3833 case WS: 3834 { 3835 setState(581); 3836 match(WS); 3837 } 3838 break; 3839 default: 3840 throw new NoViableAltException(this); 3841 } 3842 } 3843 setState(586); 3844 _errHandler.sync(this); 3845 _la = _input.LA(1); 3846 } 3847 setState(587); 3848 match(END); 3849 } 3850 _ctx.stop = _input.LT(-1); 3851 3852 if (isNonTight && nonTightTagStartContext == null) { 3853 nonTightTagStartContext = _localctx; 3854 } 3855 3856 } 3857 catch (RecognitionException re) { 3858 _localctx.exception = re; 3859 _errHandler.reportError(this, re); 3860 _errHandler.recover(this, re); 3861 } 3862 finally { 3863 exitRule(); 3864 } 3865 return _localctx; 3866 } 3867 3868 public static class TdTagEndContext extends ParserRuleContext { 3869 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 3870 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 3871 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3872 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 3873 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3874 public TerminalNode NEWLINE(int i) { 3875 return getToken(JavadocParser.NEWLINE, i); 3876 } 3877 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3878 public TerminalNode LEADING_ASTERISK(int i) { 3879 return getToken(JavadocParser.LEADING_ASTERISK, i); 3880 } 3881 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3882 public TerminalNode WS(int i) { 3883 return getToken(JavadocParser.WS, i); 3884 } 3885 public TdTagEndContext(ParserRuleContext parent, int invokingState) { 3886 super(parent, invokingState); 3887 } 3888 @Override public int getRuleIndex() { return RULE_tdTagEnd; } 3889 } 3890 3891 public final TdTagEndContext tdTagEnd() throws RecognitionException { 3892 TdTagEndContext _localctx = new TdTagEndContext(_ctx, getState()); 3893 enterRule(_localctx, 32, RULE_tdTagEnd); 3894 int _la; 3895 try { 3896 enterOuterAlt(_localctx, 1); 3897 { 3898 setState(589); 3899 match(START); 3900 setState(590); 3901 match(SLASH); 3902 setState(591); 3903 match(TD_HTML_TAG_NAME); 3904 setState(595); 3905 _errHandler.sync(this); 3906 _la = _input.LA(1); 3907 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 3908 { 3909 { 3910 setState(592); 3911 _la = _input.LA(1); 3912 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 3913 _errHandler.recoverInline(this); 3914 } 3915 else { 3916 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3917 _errHandler.reportMatch(this); 3918 consume(); 3919 } 3920 } 3921 } 3922 setState(597); 3923 _errHandler.sync(this); 3924 _la = _input.LA(1); 3925 } 3926 setState(598); 3927 match(END); 3928 } 3929 } 3930 catch (RecognitionException re) { 3931 _localctx.exception = re; 3932 _errHandler.reportError(this, re); 3933 _errHandler.recover(this, re); 3934 } 3935 finally { 3936 exitRule(); 3937 } 3938 return _localctx; 3939 } 3940 3941 public static class TdContext extends ParserRuleContext { 3942 public List<TdTagStartContext> tdTagStart() { 3943 return getRuleContexts(TdTagStartContext.class); 3944 } 3945 public TdTagStartContext tdTagStart(int i) { 3946 return getRuleContext(TdTagStartContext.class,i); 3947 } 3948 public TdTagEndContext tdTagEnd() { 3949 return getRuleContext(TdTagEndContext.class,0); 3950 } 3951 public List<HtmlTagContext> htmlTag() { 3952 return getRuleContexts(HtmlTagContext.class); 3953 } 3954 public HtmlTagContext htmlTag(int i) { 3955 return getRuleContext(HtmlTagContext.class,i); 3956 } 3957 public List<SingletonElementContext> singletonElement() { 3958 return getRuleContexts(SingletonElementContext.class); 3959 } 3960 public SingletonElementContext singletonElement(int i) { 3961 return getRuleContext(SingletonElementContext.class,i); 3962 } 3963 public List<ParagraphContext> paragraph() { 3964 return getRuleContexts(ParagraphContext.class); 3965 } 3966 public ParagraphContext paragraph(int i) { 3967 return getRuleContext(ParagraphContext.class,i); 3968 } 3969 public List<LiContext> li() { 3970 return getRuleContexts(LiContext.class); 3971 } 3972 public LiContext li(int i) { 3973 return getRuleContext(LiContext.class,i); 3974 } 3975 public List<TrContext> tr() { 3976 return getRuleContexts(TrContext.class); 3977 } 3978 public TrContext tr(int i) { 3979 return getRuleContext(TrContext.class,i); 3980 } 3981 public List<ThContext> th() { 3982 return getRuleContexts(ThContext.class); 3983 } 3984 public ThContext th(int i) { 3985 return getRuleContext(ThContext.class,i); 3986 } 3987 public List<BodyContext> body() { 3988 return getRuleContexts(BodyContext.class); 3989 } 3990 public BodyContext body(int i) { 3991 return getRuleContext(BodyContext.class,i); 3992 } 3993 public List<ColgroupContext> colgroup() { 3994 return getRuleContexts(ColgroupContext.class); 3995 } 3996 public ColgroupContext colgroup(int i) { 3997 return getRuleContext(ColgroupContext.class,i); 3998 } 3999 public List<DdContext> dd() { 4000 return getRuleContexts(DdContext.class); 4001 } 4002 public DdContext dd(int i) { 4003 return getRuleContext(DdContext.class,i); 4004 } 4005 public List<DtContext> dt() { 4006 return getRuleContexts(DtContext.class); 4007 } 4008 public DtContext dt(int i) { 4009 return getRuleContext(DtContext.class,i); 4010 } 4011 public List<HeadContext> head() { 4012 return getRuleContexts(HeadContext.class); 4013 } 4014 public HeadContext head(int i) { 4015 return getRuleContext(HeadContext.class,i); 4016 } 4017 public List<HtmlContext> html() { 4018 return getRuleContexts(HtmlContext.class); 4019 } 4020 public HtmlContext html(int i) { 4021 return getRuleContext(HtmlContext.class,i); 4022 } 4023 public List<OptionContext> option() { 4024 return getRuleContexts(OptionContext.class); 4025 } 4026 public OptionContext option(int i) { 4027 return getRuleContext(OptionContext.class,i); 4028 } 4029 public List<TbodyContext> tbody() { 4030 return getRuleContexts(TbodyContext.class); 4031 } 4032 public TbodyContext tbody(int i) { 4033 return getRuleContext(TbodyContext.class,i); 4034 } 4035 public List<TheadContext> thead() { 4036 return getRuleContexts(TheadContext.class); 4037 } 4038 public TheadContext thead(int i) { 4039 return getRuleContext(TheadContext.class,i); 4040 } 4041 public List<TfootContext> tfoot() { 4042 return getRuleContexts(TfootContext.class); 4043 } 4044 public TfootContext tfoot(int i) { 4045 return getRuleContext(TfootContext.class,i); 4046 } 4047 public List<OptgroupContext> optgroup() { 4048 return getRuleContexts(OptgroupContext.class); 4049 } 4050 public OptgroupContext optgroup(int i) { 4051 return getRuleContext(OptgroupContext.class,i); 4052 } 4053 public List<RbContext> rb() { 4054 return getRuleContexts(RbContext.class); 4055 } 4056 public RbContext rb(int i) { 4057 return getRuleContext(RbContext.class,i); 4058 } 4059 public List<RtContext> rt() { 4060 return getRuleContexts(RtContext.class); 4061 } 4062 public RtContext rt(int i) { 4063 return getRuleContext(RtContext.class,i); 4064 } 4065 public List<RtcContext> rtc() { 4066 return getRuleContexts(RtcContext.class); 4067 } 4068 public RtcContext rtc(int i) { 4069 return getRuleContext(RtcContext.class,i); 4070 } 4071 public List<RpContext> rp() { 4072 return getRuleContexts(RpContext.class); 4073 } 4074 public RpContext rp(int i) { 4075 return getRuleContext(RpContext.class,i); 4076 } 4077 public List<PTagStartContext> pTagStart() { 4078 return getRuleContexts(PTagStartContext.class); 4079 } 4080 public PTagStartContext pTagStart(int i) { 4081 return getRuleContext(PTagStartContext.class,i); 4082 } 4083 public List<LiTagStartContext> liTagStart() { 4084 return getRuleContexts(LiTagStartContext.class); 4085 } 4086 public LiTagStartContext liTagStart(int i) { 4087 return getRuleContext(LiTagStartContext.class,i); 4088 } 4089 public List<ThTagStartContext> thTagStart() { 4090 return getRuleContexts(ThTagStartContext.class); 4091 } 4092 public ThTagStartContext thTagStart(int i) { 4093 return getRuleContext(ThTagStartContext.class,i); 4094 } 4095 public List<BodyTagStartContext> bodyTagStart() { 4096 return getRuleContexts(BodyTagStartContext.class); 4097 } 4098 public BodyTagStartContext bodyTagStart(int i) { 4099 return getRuleContext(BodyTagStartContext.class,i); 4100 } 4101 public List<ColgroupTagStartContext> colgroupTagStart() { 4102 return getRuleContexts(ColgroupTagStartContext.class); 4103 } 4104 public ColgroupTagStartContext colgroupTagStart(int i) { 4105 return getRuleContext(ColgroupTagStartContext.class,i); 4106 } 4107 public List<DdTagStartContext> ddTagStart() { 4108 return getRuleContexts(DdTagStartContext.class); 4109 } 4110 public DdTagStartContext ddTagStart(int i) { 4111 return getRuleContext(DdTagStartContext.class,i); 4112 } 4113 public List<DtTagStartContext> dtTagStart() { 4114 return getRuleContexts(DtTagStartContext.class); 4115 } 4116 public DtTagStartContext dtTagStart(int i) { 4117 return getRuleContext(DtTagStartContext.class,i); 4118 } 4119 public List<HeadTagStartContext> headTagStart() { 4120 return getRuleContexts(HeadTagStartContext.class); 4121 } 4122 public HeadTagStartContext headTagStart(int i) { 4123 return getRuleContext(HeadTagStartContext.class,i); 4124 } 4125 public List<HtmlTagStartContext> htmlTagStart() { 4126 return getRuleContexts(HtmlTagStartContext.class); 4127 } 4128 public HtmlTagStartContext htmlTagStart(int i) { 4129 return getRuleContext(HtmlTagStartContext.class,i); 4130 } 4131 public List<OptionTagStartContext> optionTagStart() { 4132 return getRuleContexts(OptionTagStartContext.class); 4133 } 4134 public OptionTagStartContext optionTagStart(int i) { 4135 return getRuleContext(OptionTagStartContext.class,i); 4136 } 4137 public List<TbodyTagStartContext> tbodyTagStart() { 4138 return getRuleContexts(TbodyTagStartContext.class); 4139 } 4140 public TbodyTagStartContext tbodyTagStart(int i) { 4141 return getRuleContext(TbodyTagStartContext.class,i); 4142 } 4143 public List<TheadTagStartContext> theadTagStart() { 4144 return getRuleContexts(TheadTagStartContext.class); 4145 } 4146 public TheadTagStartContext theadTagStart(int i) { 4147 return getRuleContext(TheadTagStartContext.class,i); 4148 } 4149 public List<TfootTagStartContext> tfootTagStart() { 4150 return getRuleContexts(TfootTagStartContext.class); 4151 } 4152 public TfootTagStartContext tfootTagStart(int i) { 4153 return getRuleContext(TfootTagStartContext.class,i); 4154 } 4155 public List<OptgroupTagStartContext> optgroupTagStart() { 4156 return getRuleContexts(OptgroupTagStartContext.class); 4157 } 4158 public OptgroupTagStartContext optgroupTagStart(int i) { 4159 return getRuleContext(OptgroupTagStartContext.class,i); 4160 } 4161 public List<RbTagStartContext> rbTagStart() { 4162 return getRuleContexts(RbTagStartContext.class); 4163 } 4164 public RbTagStartContext rbTagStart(int i) { 4165 return getRuleContext(RbTagStartContext.class,i); 4166 } 4167 public List<RtTagStartContext> rtTagStart() { 4168 return getRuleContexts(RtTagStartContext.class); 4169 } 4170 public RtTagStartContext rtTagStart(int i) { 4171 return getRuleContext(RtTagStartContext.class,i); 4172 } 4173 public List<RtcTagStartContext> rtcTagStart() { 4174 return getRuleContexts(RtcTagStartContext.class); 4175 } 4176 public RtcTagStartContext rtcTagStart(int i) { 4177 return getRuleContext(RtcTagStartContext.class,i); 4178 } 4179 public List<RpTagStartContext> rpTagStart() { 4180 return getRuleContexts(RpTagStartContext.class); 4181 } 4182 public RpTagStartContext rpTagStart(int i) { 4183 return getRuleContext(RpTagStartContext.class,i); 4184 } 4185 public List<HtmlCommentContext> htmlComment() { 4186 return getRuleContexts(HtmlCommentContext.class); 4187 } 4188 public HtmlCommentContext htmlComment(int i) { 4189 return getRuleContext(HtmlCommentContext.class,i); 4190 } 4191 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4192 public TerminalNode NEWLINE(int i) { 4193 return getToken(JavadocParser.NEWLINE, i); 4194 } 4195 public List<TextContext> text() { 4196 return getRuleContexts(TextContext.class); 4197 } 4198 public TextContext text(int i) { 4199 return getRuleContext(TextContext.class,i); 4200 } 4201 public List<JavadocInlineTagContext> javadocInlineTag() { 4202 return getRuleContexts(JavadocInlineTagContext.class); 4203 } 4204 public JavadocInlineTagContext javadocInlineTag(int i) { 4205 return getRuleContext(JavadocInlineTagContext.class,i); 4206 } 4207 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4208 public TerminalNode LEADING_ASTERISK(int i) { 4209 return getToken(JavadocParser.LEADING_ASTERISK, i); 4210 } 4211 public TdContext(ParserRuleContext parent, int invokingState) { 4212 super(parent, invokingState); 4213 } 4214 @Override public int getRuleIndex() { return RULE_td; } 4215 } 4216 4217 public final TdContext td() throws RecognitionException { 4218 TdContext _localctx = new TdContext(_ctx, getState()); 4219 enterRule(_localctx, 34, RULE_td); 4220 try { 4221 int _alt; 4222 enterOuterAlt(_localctx, 1); 4223 { 4224 setState(600); 4225 tdTagStart(false); 4226 setState(649); 4227 _errHandler.sync(this); 4228 _alt = getInterpreter().adaptivePredict(_input,33,_ctx); 4229 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 4230 if ( _alt==1 ) { 4231 { 4232 setState(647); 4233 _errHandler.sync(this); 4234 switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) { 4235 case 1: 4236 { 4237 setState(601); 4238 htmlTag(); 4239 } 4240 break; 4241 case 2: 4242 { 4243 setState(602); 4244 singletonElement(); 4245 } 4246 break; 4247 case 3: 4248 { 4249 setState(603); 4250 paragraph(); 4251 } 4252 break; 4253 case 4: 4254 { 4255 setState(604); 4256 li(); 4257 } 4258 break; 4259 case 5: 4260 { 4261 setState(605); 4262 tr(); 4263 } 4264 break; 4265 case 6: 4266 { 4267 setState(606); 4268 th(); 4269 } 4270 break; 4271 case 7: 4272 { 4273 setState(607); 4274 body(); 4275 } 4276 break; 4277 case 8: 4278 { 4279 setState(608); 4280 colgroup(); 4281 } 4282 break; 4283 case 9: 4284 { 4285 setState(609); 4286 dd(); 4287 } 4288 break; 4289 case 10: 4290 { 4291 setState(610); 4292 dt(); 4293 } 4294 break; 4295 case 11: 4296 { 4297 setState(611); 4298 head(); 4299 } 4300 break; 4301 case 12: 4302 { 4303 setState(612); 4304 html(); 4305 } 4306 break; 4307 case 13: 4308 { 4309 setState(613); 4310 option(); 4311 } 4312 break; 4313 case 14: 4314 { 4315 setState(614); 4316 tbody(); 4317 } 4318 break; 4319 case 15: 4320 { 4321 setState(615); 4322 thead(); 4323 } 4324 break; 4325 case 16: 4326 { 4327 setState(616); 4328 tfoot(); 4329 } 4330 break; 4331 case 17: 4332 { 4333 setState(617); 4334 optgroup(); 4335 } 4336 break; 4337 case 18: 4338 { 4339 setState(618); 4340 rb(); 4341 } 4342 break; 4343 case 19: 4344 { 4345 setState(619); 4346 rt(); 4347 } 4348 break; 4349 case 20: 4350 { 4351 setState(620); 4352 rtc(); 4353 } 4354 break; 4355 case 21: 4356 { 4357 setState(621); 4358 rp(); 4359 } 4360 break; 4361 case 22: 4362 { 4363 setState(622); 4364 pTagStart(true); 4365 } 4366 break; 4367 case 23: 4368 { 4369 setState(623); 4370 liTagStart(true); 4371 } 4372 break; 4373 case 24: 4374 { 4375 setState(624); 4376 tdTagStart(true); 4377 } 4378 break; 4379 case 25: 4380 { 4381 setState(625); 4382 thTagStart(true); 4383 } 4384 break; 4385 case 26: 4386 { 4387 setState(626); 4388 bodyTagStart(true); 4389 } 4390 break; 4391 case 27: 4392 { 4393 setState(627); 4394 colgroupTagStart(true); 4395 } 4396 break; 4397 case 28: 4398 { 4399 setState(628); 4400 ddTagStart(true); 4401 } 4402 break; 4403 case 29: 4404 { 4405 setState(629); 4406 dtTagStart(true); 4407 } 4408 break; 4409 case 30: 4410 { 4411 setState(630); 4412 headTagStart(true); 4413 } 4414 break; 4415 case 31: 4416 { 4417 setState(631); 4418 htmlTagStart(true); 4419 } 4420 break; 4421 case 32: 4422 { 4423 setState(632); 4424 optionTagStart(true); 4425 } 4426 break; 4427 case 33: 4428 { 4429 setState(633); 4430 tbodyTagStart(true); 4431 } 4432 break; 4433 case 34: 4434 { 4435 setState(634); 4436 theadTagStart(true); 4437 } 4438 break; 4439 case 35: 4440 { 4441 setState(635); 4442 tfootTagStart(true); 4443 } 4444 break; 4445 case 36: 4446 { 4447 setState(636); 4448 optgroupTagStart(true); 4449 } 4450 break; 4451 case 37: 4452 { 4453 setState(637); 4454 rbTagStart(true); 4455 } 4456 break; 4457 case 38: 4458 { 4459 setState(638); 4460 rtTagStart(true); 4461 } 4462 break; 4463 case 39: 4464 { 4465 setState(639); 4466 rtcTagStart(true); 4467 } 4468 break; 4469 case 40: 4470 { 4471 setState(640); 4472 rpTagStart(true); 4473 } 4474 break; 4475 case 41: 4476 { 4477 { 4478 setState(641); 4479 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4480 setState(642); 4481 match(LEADING_ASTERISK); 4482 } 4483 } 4484 break; 4485 case 42: 4486 { 4487 setState(643); 4488 htmlComment(); 4489 } 4490 break; 4491 case 43: 4492 { 4493 setState(644); 4494 match(NEWLINE); 4495 } 4496 break; 4497 case 44: 4498 { 4499 setState(645); 4500 text(); 4501 } 4502 break; 4503 case 45: 4504 { 4505 setState(646); 4506 javadocInlineTag(); 4507 } 4508 break; 4509 } 4510 } 4511 } 4512 setState(651); 4513 _errHandler.sync(this); 4514 _alt = getInterpreter().adaptivePredict(_input,33,_ctx); 4515 } 4516 setState(652); 4517 tdTagEnd(); 4518 } 4519 } 4520 catch (RecognitionException re) { 4521 _localctx.exception = re; 4522 _errHandler.reportError(this, re); 4523 _errHandler.recover(this, re); 4524 } 4525 finally { 4526 exitRule(); 4527 } 4528 return _localctx; 4529 } 4530 4531 public static class ThTagStartContext extends ParserRuleContext { 4532 public boolean isNonTight; 4533 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 4534 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4535 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 4536 public List<AttributeContext> attribute() { 4537 return getRuleContexts(AttributeContext.class); 4538 } 4539 public AttributeContext attribute(int i) { 4540 return getRuleContext(AttributeContext.class,i); 4541 } 4542 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4543 public TerminalNode NEWLINE(int i) { 4544 return getToken(JavadocParser.NEWLINE, i); 4545 } 4546 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4547 public TerminalNode LEADING_ASTERISK(int i) { 4548 return getToken(JavadocParser.LEADING_ASTERISK, i); 4549 } 4550 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4551 public TerminalNode WS(int i) { 4552 return getToken(JavadocParser.WS, i); 4553 } 4554 public ThTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 4555 public ThTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 4556 super(parent, invokingState); 4557 this.isNonTight = isNonTight; 4558 } 4559 @Override public int getRuleIndex() { return RULE_thTagStart; } 4560 } 4561 4562 public final ThTagStartContext thTagStart(boolean isNonTight) throws RecognitionException { 4563 ThTagStartContext _localctx = new ThTagStartContext(_ctx, getState(), isNonTight); 4564 enterRule(_localctx, 36, RULE_thTagStart); 4565 int _la; 4566 try { 4567 enterOuterAlt(_localctx, 1); 4568 { 4569 setState(654); 4570 match(START); 4571 setState(655); 4572 match(TH_HTML_TAG_NAME); 4573 setState(662); 4574 _errHandler.sync(this); 4575 _la = _input.LA(1); 4576 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4577 { 4578 setState(660); 4579 _errHandler.sync(this); 4580 switch (_input.LA(1)) { 4581 case HTML_TAG_NAME: 4582 { 4583 setState(656); 4584 attribute(); 4585 } 4586 break; 4587 case NEWLINE: 4588 { 4589 setState(657); 4590 match(NEWLINE); 4591 } 4592 break; 4593 case LEADING_ASTERISK: 4594 { 4595 setState(658); 4596 match(LEADING_ASTERISK); 4597 } 4598 break; 4599 case WS: 4600 { 4601 setState(659); 4602 match(WS); 4603 } 4604 break; 4605 default: 4606 throw new NoViableAltException(this); 4607 } 4608 } 4609 setState(664); 4610 _errHandler.sync(this); 4611 _la = _input.LA(1); 4612 } 4613 setState(665); 4614 match(END); 4615 } 4616 _ctx.stop = _input.LT(-1); 4617 4618 if (isNonTight && nonTightTagStartContext == null) { 4619 nonTightTagStartContext = _localctx; 4620 } 4621 4622 } 4623 catch (RecognitionException re) { 4624 _localctx.exception = re; 4625 _errHandler.reportError(this, re); 4626 _errHandler.recover(this, re); 4627 } 4628 finally { 4629 exitRule(); 4630 } 4631 return _localctx; 4632 } 4633 4634 public static class ThTagEndContext extends ParserRuleContext { 4635 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 4636 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4637 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4638 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 4639 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4640 public TerminalNode NEWLINE(int i) { 4641 return getToken(JavadocParser.NEWLINE, i); 4642 } 4643 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4644 public TerminalNode LEADING_ASTERISK(int i) { 4645 return getToken(JavadocParser.LEADING_ASTERISK, i); 4646 } 4647 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4648 public TerminalNode WS(int i) { 4649 return getToken(JavadocParser.WS, i); 4650 } 4651 public ThTagEndContext(ParserRuleContext parent, int invokingState) { 4652 super(parent, invokingState); 4653 } 4654 @Override public int getRuleIndex() { return RULE_thTagEnd; } 4655 } 4656 4657 public final ThTagEndContext thTagEnd() throws RecognitionException { 4658 ThTagEndContext _localctx = new ThTagEndContext(_ctx, getState()); 4659 enterRule(_localctx, 38, RULE_thTagEnd); 4660 int _la; 4661 try { 4662 enterOuterAlt(_localctx, 1); 4663 { 4664 setState(667); 4665 match(START); 4666 setState(668); 4667 match(SLASH); 4668 setState(669); 4669 match(TH_HTML_TAG_NAME); 4670 setState(673); 4671 _errHandler.sync(this); 4672 _la = _input.LA(1); 4673 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 4674 { 4675 { 4676 setState(670); 4677 _la = _input.LA(1); 4678 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 4679 _errHandler.recoverInline(this); 4680 } 4681 else { 4682 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 4683 _errHandler.reportMatch(this); 4684 consume(); 4685 } 4686 } 4687 } 4688 setState(675); 4689 _errHandler.sync(this); 4690 _la = _input.LA(1); 4691 } 4692 setState(676); 4693 match(END); 4694 } 4695 } 4696 catch (RecognitionException re) { 4697 _localctx.exception = re; 4698 _errHandler.reportError(this, re); 4699 _errHandler.recover(this, re); 4700 } 4701 finally { 4702 exitRule(); 4703 } 4704 return _localctx; 4705 } 4706 4707 public static class ThContext extends ParserRuleContext { 4708 public ThTagStartContext thTagStart() { 4709 return getRuleContext(ThTagStartContext.class,0); 4710 } 4711 public ThTagEndContext thTagEnd() { 4712 return getRuleContext(ThTagEndContext.class,0); 4713 } 4714 public List<HtmlTagContext> htmlTag() { 4715 return getRuleContexts(HtmlTagContext.class); 4716 } 4717 public HtmlTagContext htmlTag(int i) { 4718 return getRuleContext(HtmlTagContext.class,i); 4719 } 4720 public List<SingletonElementContext> singletonElement() { 4721 return getRuleContexts(SingletonElementContext.class); 4722 } 4723 public SingletonElementContext singletonElement(int i) { 4724 return getRuleContext(SingletonElementContext.class,i); 4725 } 4726 public List<ParagraphContext> paragraph() { 4727 return getRuleContexts(ParagraphContext.class); 4728 } 4729 public ParagraphContext paragraph(int i) { 4730 return getRuleContext(ParagraphContext.class,i); 4731 } 4732 public List<LiContext> li() { 4733 return getRuleContexts(LiContext.class); 4734 } 4735 public LiContext li(int i) { 4736 return getRuleContext(LiContext.class,i); 4737 } 4738 public List<TrContext> tr() { 4739 return getRuleContexts(TrContext.class); 4740 } 4741 public TrContext tr(int i) { 4742 return getRuleContext(TrContext.class,i); 4743 } 4744 public List<TdContext> td() { 4745 return getRuleContexts(TdContext.class); 4746 } 4747 public TdContext td(int i) { 4748 return getRuleContext(TdContext.class,i); 4749 } 4750 public List<BodyContext> body() { 4751 return getRuleContexts(BodyContext.class); 4752 } 4753 public BodyContext body(int i) { 4754 return getRuleContext(BodyContext.class,i); 4755 } 4756 public List<ColgroupContext> colgroup() { 4757 return getRuleContexts(ColgroupContext.class); 4758 } 4759 public ColgroupContext colgroup(int i) { 4760 return getRuleContext(ColgroupContext.class,i); 4761 } 4762 public List<DdContext> dd() { 4763 return getRuleContexts(DdContext.class); 4764 } 4765 public DdContext dd(int i) { 4766 return getRuleContext(DdContext.class,i); 4767 } 4768 public List<DtContext> dt() { 4769 return getRuleContexts(DtContext.class); 4770 } 4771 public DtContext dt(int i) { 4772 return getRuleContext(DtContext.class,i); 4773 } 4774 public List<HeadContext> head() { 4775 return getRuleContexts(HeadContext.class); 4776 } 4777 public HeadContext head(int i) { 4778 return getRuleContext(HeadContext.class,i); 4779 } 4780 public List<HtmlContext> html() { 4781 return getRuleContexts(HtmlContext.class); 4782 } 4783 public HtmlContext html(int i) { 4784 return getRuleContext(HtmlContext.class,i); 4785 } 4786 public List<OptionContext> option() { 4787 return getRuleContexts(OptionContext.class); 4788 } 4789 public OptionContext option(int i) { 4790 return getRuleContext(OptionContext.class,i); 4791 } 4792 public List<TbodyContext> tbody() { 4793 return getRuleContexts(TbodyContext.class); 4794 } 4795 public TbodyContext tbody(int i) { 4796 return getRuleContext(TbodyContext.class,i); 4797 } 4798 public List<TheadContext> thead() { 4799 return getRuleContexts(TheadContext.class); 4800 } 4801 public TheadContext thead(int i) { 4802 return getRuleContext(TheadContext.class,i); 4803 } 4804 public List<TfootContext> tfoot() { 4805 return getRuleContexts(TfootContext.class); 4806 } 4807 public TfootContext tfoot(int i) { 4808 return getRuleContext(TfootContext.class,i); 4809 } 4810 public List<OptgroupContext> optgroup() { 4811 return getRuleContexts(OptgroupContext.class); 4812 } 4813 public OptgroupContext optgroup(int i) { 4814 return getRuleContext(OptgroupContext.class,i); 4815 } 4816 public List<RbContext> rb() { 4817 return getRuleContexts(RbContext.class); 4818 } 4819 public RbContext rb(int i) { 4820 return getRuleContext(RbContext.class,i); 4821 } 4822 public List<RtContext> rt() { 4823 return getRuleContexts(RtContext.class); 4824 } 4825 public RtContext rt(int i) { 4826 return getRuleContext(RtContext.class,i); 4827 } 4828 public List<RtcContext> rtc() { 4829 return getRuleContexts(RtcContext.class); 4830 } 4831 public RtcContext rtc(int i) { 4832 return getRuleContext(RtcContext.class,i); 4833 } 4834 public List<RpContext> rp() { 4835 return getRuleContexts(RpContext.class); 4836 } 4837 public RpContext rp(int i) { 4838 return getRuleContext(RpContext.class,i); 4839 } 4840 public List<PTagStartContext> pTagStart() { 4841 return getRuleContexts(PTagStartContext.class); 4842 } 4843 public PTagStartContext pTagStart(int i) { 4844 return getRuleContext(PTagStartContext.class,i); 4845 } 4846 public List<LiTagStartContext> liTagStart() { 4847 return getRuleContexts(LiTagStartContext.class); 4848 } 4849 public LiTagStartContext liTagStart(int i) { 4850 return getRuleContext(LiTagStartContext.class,i); 4851 } 4852 public List<TrTagStartContext> trTagStart() { 4853 return getRuleContexts(TrTagStartContext.class); 4854 } 4855 public TrTagStartContext trTagStart(int i) { 4856 return getRuleContext(TrTagStartContext.class,i); 4857 } 4858 public List<TdTagStartContext> tdTagStart() { 4859 return getRuleContexts(TdTagStartContext.class); 4860 } 4861 public TdTagStartContext tdTagStart(int i) { 4862 return getRuleContext(TdTagStartContext.class,i); 4863 } 4864 public List<BodyTagStartContext> bodyTagStart() { 4865 return getRuleContexts(BodyTagStartContext.class); 4866 } 4867 public BodyTagStartContext bodyTagStart(int i) { 4868 return getRuleContext(BodyTagStartContext.class,i); 4869 } 4870 public List<ColgroupTagStartContext> colgroupTagStart() { 4871 return getRuleContexts(ColgroupTagStartContext.class); 4872 } 4873 public ColgroupTagStartContext colgroupTagStart(int i) { 4874 return getRuleContext(ColgroupTagStartContext.class,i); 4875 } 4876 public List<DdTagStartContext> ddTagStart() { 4877 return getRuleContexts(DdTagStartContext.class); 4878 } 4879 public DdTagStartContext ddTagStart(int i) { 4880 return getRuleContext(DdTagStartContext.class,i); 4881 } 4882 public List<DtTagStartContext> dtTagStart() { 4883 return getRuleContexts(DtTagStartContext.class); 4884 } 4885 public DtTagStartContext dtTagStart(int i) { 4886 return getRuleContext(DtTagStartContext.class,i); 4887 } 4888 public List<HeadTagStartContext> headTagStart() { 4889 return getRuleContexts(HeadTagStartContext.class); 4890 } 4891 public HeadTagStartContext headTagStart(int i) { 4892 return getRuleContext(HeadTagStartContext.class,i); 4893 } 4894 public List<HtmlTagStartContext> htmlTagStart() { 4895 return getRuleContexts(HtmlTagStartContext.class); 4896 } 4897 public HtmlTagStartContext htmlTagStart(int i) { 4898 return getRuleContext(HtmlTagStartContext.class,i); 4899 } 4900 public List<OptionTagStartContext> optionTagStart() { 4901 return getRuleContexts(OptionTagStartContext.class); 4902 } 4903 public OptionTagStartContext optionTagStart(int i) { 4904 return getRuleContext(OptionTagStartContext.class,i); 4905 } 4906 public List<TbodyTagStartContext> tbodyTagStart() { 4907 return getRuleContexts(TbodyTagStartContext.class); 4908 } 4909 public TbodyTagStartContext tbodyTagStart(int i) { 4910 return getRuleContext(TbodyTagStartContext.class,i); 4911 } 4912 public List<TheadTagStartContext> theadTagStart() { 4913 return getRuleContexts(TheadTagStartContext.class); 4914 } 4915 public TheadTagStartContext theadTagStart(int i) { 4916 return getRuleContext(TheadTagStartContext.class,i); 4917 } 4918 public List<TfootTagStartContext> tfootTagStart() { 4919 return getRuleContexts(TfootTagStartContext.class); 4920 } 4921 public TfootTagStartContext tfootTagStart(int i) { 4922 return getRuleContext(TfootTagStartContext.class,i); 4923 } 4924 public List<OptgroupTagStartContext> optgroupTagStart() { 4925 return getRuleContexts(OptgroupTagStartContext.class); 4926 } 4927 public OptgroupTagStartContext optgroupTagStart(int i) { 4928 return getRuleContext(OptgroupTagStartContext.class,i); 4929 } 4930 public List<RbTagStartContext> rbTagStart() { 4931 return getRuleContexts(RbTagStartContext.class); 4932 } 4933 public RbTagStartContext rbTagStart(int i) { 4934 return getRuleContext(RbTagStartContext.class,i); 4935 } 4936 public List<RtTagStartContext> rtTagStart() { 4937 return getRuleContexts(RtTagStartContext.class); 4938 } 4939 public RtTagStartContext rtTagStart(int i) { 4940 return getRuleContext(RtTagStartContext.class,i); 4941 } 4942 public List<RtcTagStartContext> rtcTagStart() { 4943 return getRuleContexts(RtcTagStartContext.class); 4944 } 4945 public RtcTagStartContext rtcTagStart(int i) { 4946 return getRuleContext(RtcTagStartContext.class,i); 4947 } 4948 public List<RpTagStartContext> rpTagStart() { 4949 return getRuleContexts(RpTagStartContext.class); 4950 } 4951 public RpTagStartContext rpTagStart(int i) { 4952 return getRuleContext(RpTagStartContext.class,i); 4953 } 4954 public List<HtmlCommentContext> htmlComment() { 4955 return getRuleContexts(HtmlCommentContext.class); 4956 } 4957 public HtmlCommentContext htmlComment(int i) { 4958 return getRuleContext(HtmlCommentContext.class,i); 4959 } 4960 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4961 public TerminalNode NEWLINE(int i) { 4962 return getToken(JavadocParser.NEWLINE, i); 4963 } 4964 public List<TextContext> text() { 4965 return getRuleContexts(TextContext.class); 4966 } 4967 public TextContext text(int i) { 4968 return getRuleContext(TextContext.class,i); 4969 } 4970 public List<JavadocInlineTagContext> javadocInlineTag() { 4971 return getRuleContexts(JavadocInlineTagContext.class); 4972 } 4973 public JavadocInlineTagContext javadocInlineTag(int i) { 4974 return getRuleContext(JavadocInlineTagContext.class,i); 4975 } 4976 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4977 public TerminalNode LEADING_ASTERISK(int i) { 4978 return getToken(JavadocParser.LEADING_ASTERISK, i); 4979 } 4980 public ThContext(ParserRuleContext parent, int invokingState) { 4981 super(parent, invokingState); 4982 } 4983 @Override public int getRuleIndex() { return RULE_th; } 4984 } 4985 4986 public final ThContext th() throws RecognitionException { 4987 ThContext _localctx = new ThContext(_ctx, getState()); 4988 enterRule(_localctx, 40, RULE_th); 4989 try { 4990 int _alt; 4991 enterOuterAlt(_localctx, 1); 4992 { 4993 setState(678); 4994 thTagStart(false); 4995 setState(727); 4996 _errHandler.sync(this); 4997 _alt = getInterpreter().adaptivePredict(_input,38,_ctx); 4998 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 4999 if ( _alt==1 ) { 5000 { 5001 setState(725); 5002 _errHandler.sync(this); 5003 switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) { 5004 case 1: 5005 { 5006 setState(679); 5007 htmlTag(); 5008 } 5009 break; 5010 case 2: 5011 { 5012 setState(680); 5013 singletonElement(); 5014 } 5015 break; 5016 case 3: 5017 { 5018 setState(681); 5019 paragraph(); 5020 } 5021 break; 5022 case 4: 5023 { 5024 setState(682); 5025 li(); 5026 } 5027 break; 5028 case 5: 5029 { 5030 setState(683); 5031 tr(); 5032 } 5033 break; 5034 case 6: 5035 { 5036 setState(684); 5037 td(); 5038 } 5039 break; 5040 case 7: 5041 { 5042 setState(685); 5043 body(); 5044 } 5045 break; 5046 case 8: 5047 { 5048 setState(686); 5049 colgroup(); 5050 } 5051 break; 5052 case 9: 5053 { 5054 setState(687); 5055 dd(); 5056 } 5057 break; 5058 case 10: 5059 { 5060 setState(688); 5061 dt(); 5062 } 5063 break; 5064 case 11: 5065 { 5066 setState(689); 5067 head(); 5068 } 5069 break; 5070 case 12: 5071 { 5072 setState(690); 5073 html(); 5074 } 5075 break; 5076 case 13: 5077 { 5078 setState(691); 5079 option(); 5080 } 5081 break; 5082 case 14: 5083 { 5084 setState(692); 5085 tbody(); 5086 } 5087 break; 5088 case 15: 5089 { 5090 setState(693); 5091 thead(); 5092 } 5093 break; 5094 case 16: 5095 { 5096 setState(694); 5097 tfoot(); 5098 } 5099 break; 5100 case 17: 5101 { 5102 setState(695); 5103 optgroup(); 5104 } 5105 break; 5106 case 18: 5107 { 5108 setState(696); 5109 rb(); 5110 } 5111 break; 5112 case 19: 5113 { 5114 setState(697); 5115 rt(); 5116 } 5117 break; 5118 case 20: 5119 { 5120 setState(698); 5121 rtc(); 5122 } 5123 break; 5124 case 21: 5125 { 5126 setState(699); 5127 rp(); 5128 } 5129 break; 5130 case 22: 5131 { 5132 setState(700); 5133 pTagStart(true); 5134 } 5135 break; 5136 case 23: 5137 { 5138 setState(701); 5139 liTagStart(true); 5140 } 5141 break; 5142 case 24: 5143 { 5144 setState(702); 5145 trTagStart(true); 5146 } 5147 break; 5148 case 25: 5149 { 5150 setState(703); 5151 tdTagStart(true); 5152 } 5153 break; 5154 case 26: 5155 { 5156 setState(704); 5157 bodyTagStart(true); 5158 } 5159 break; 5160 case 27: 5161 { 5162 setState(705); 5163 colgroupTagStart(true); 5164 } 5165 break; 5166 case 28: 5167 { 5168 setState(706); 5169 ddTagStart(true); 5170 } 5171 break; 5172 case 29: 5173 { 5174 setState(707); 5175 dtTagStart(true); 5176 } 5177 break; 5178 case 30: 5179 { 5180 setState(708); 5181 headTagStart(true); 5182 } 5183 break; 5184 case 31: 5185 { 5186 setState(709); 5187 htmlTagStart(true); 5188 } 5189 break; 5190 case 32: 5191 { 5192 setState(710); 5193 optionTagStart(true); 5194 } 5195 break; 5196 case 33: 5197 { 5198 setState(711); 5199 tbodyTagStart(true); 5200 } 5201 break; 5202 case 34: 5203 { 5204 setState(712); 5205 theadTagStart(true); 5206 } 5207 break; 5208 case 35: 5209 { 5210 setState(713); 5211 tfootTagStart(true); 5212 } 5213 break; 5214 case 36: 5215 { 5216 setState(714); 5217 optgroupTagStart(true); 5218 } 5219 break; 5220 case 37: 5221 { 5222 setState(715); 5223 rbTagStart(true); 5224 } 5225 break; 5226 case 38: 5227 { 5228 setState(716); 5229 rtTagStart(true); 5230 } 5231 break; 5232 case 39: 5233 { 5234 setState(717); 5235 rtcTagStart(true); 5236 } 5237 break; 5238 case 40: 5239 { 5240 setState(718); 5241 rpTagStart(true); 5242 } 5243 break; 5244 case 41: 5245 { 5246 { 5247 setState(719); 5248 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 5249 setState(720); 5250 match(LEADING_ASTERISK); 5251 } 5252 } 5253 break; 5254 case 42: 5255 { 5256 setState(721); 5257 htmlComment(); 5258 } 5259 break; 5260 case 43: 5261 { 5262 setState(722); 5263 match(NEWLINE); 5264 } 5265 break; 5266 case 44: 5267 { 5268 setState(723); 5269 text(); 5270 } 5271 break; 5272 case 45: 5273 { 5274 setState(724); 5275 javadocInlineTag(); 5276 } 5277 break; 5278 } 5279 } 5280 } 5281 setState(729); 5282 _errHandler.sync(this); 5283 _alt = getInterpreter().adaptivePredict(_input,38,_ctx); 5284 } 5285 setState(730); 5286 thTagEnd(); 5287 } 5288 } 5289 catch (RecognitionException re) { 5290 _localctx.exception = re; 5291 _errHandler.reportError(this, re); 5292 _errHandler.recover(this, re); 5293 } 5294 finally { 5295 exitRule(); 5296 } 5297 return _localctx; 5298 } 5299 5300 public static class BodyTagStartContext extends ParserRuleContext { 5301 public boolean isNonTight; 5302 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 5303 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 5304 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 5305 public List<AttributeContext> attribute() { 5306 return getRuleContexts(AttributeContext.class); 5307 } 5308 public AttributeContext attribute(int i) { 5309 return getRuleContext(AttributeContext.class,i); 5310 } 5311 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5312 public TerminalNode NEWLINE(int i) { 5313 return getToken(JavadocParser.NEWLINE, i); 5314 } 5315 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5316 public TerminalNode LEADING_ASTERISK(int i) { 5317 return getToken(JavadocParser.LEADING_ASTERISK, i); 5318 } 5319 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5320 public TerminalNode WS(int i) { 5321 return getToken(JavadocParser.WS, i); 5322 } 5323 public BodyTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 5324 public BodyTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 5325 super(parent, invokingState); 5326 this.isNonTight = isNonTight; 5327 } 5328 @Override public int getRuleIndex() { return RULE_bodyTagStart; } 5329 } 5330 5331 public final BodyTagStartContext bodyTagStart(boolean isNonTight) throws RecognitionException { 5332 BodyTagStartContext _localctx = new BodyTagStartContext(_ctx, getState(), isNonTight); 5333 enterRule(_localctx, 42, RULE_bodyTagStart); 5334 int _la; 5335 try { 5336 enterOuterAlt(_localctx, 1); 5337 { 5338 setState(732); 5339 match(START); 5340 setState(733); 5341 match(BODY_HTML_TAG_NAME); 5342 setState(740); 5343 _errHandler.sync(this); 5344 _la = _input.LA(1); 5345 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 5346 { 5347 setState(738); 5348 _errHandler.sync(this); 5349 switch (_input.LA(1)) { 5350 case HTML_TAG_NAME: 5351 { 5352 setState(734); 5353 attribute(); 5354 } 5355 break; 5356 case NEWLINE: 5357 { 5358 setState(735); 5359 match(NEWLINE); 5360 } 5361 break; 5362 case LEADING_ASTERISK: 5363 { 5364 setState(736); 5365 match(LEADING_ASTERISK); 5366 } 5367 break; 5368 case WS: 5369 { 5370 setState(737); 5371 match(WS); 5372 } 5373 break; 5374 default: 5375 throw new NoViableAltException(this); 5376 } 5377 } 5378 setState(742); 5379 _errHandler.sync(this); 5380 _la = _input.LA(1); 5381 } 5382 setState(743); 5383 match(END); 5384 } 5385 _ctx.stop = _input.LT(-1); 5386 5387 if (isNonTight && nonTightTagStartContext == null) { 5388 nonTightTagStartContext = _localctx; 5389 } 5390 5391 } 5392 catch (RecognitionException re) { 5393 _localctx.exception = re; 5394 _errHandler.reportError(this, re); 5395 _errHandler.recover(this, re); 5396 } 5397 finally { 5398 exitRule(); 5399 } 5400 return _localctx; 5401 } 5402 5403 public static class BodyTagEndContext extends ParserRuleContext { 5404 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 5405 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 5406 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 5407 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 5408 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5409 public TerminalNode NEWLINE(int i) { 5410 return getToken(JavadocParser.NEWLINE, i); 5411 } 5412 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5413 public TerminalNode LEADING_ASTERISK(int i) { 5414 return getToken(JavadocParser.LEADING_ASTERISK, i); 5415 } 5416 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5417 public TerminalNode WS(int i) { 5418 return getToken(JavadocParser.WS, i); 5419 } 5420 public BodyTagEndContext(ParserRuleContext parent, int invokingState) { 5421 super(parent, invokingState); 5422 } 5423 @Override public int getRuleIndex() { return RULE_bodyTagEnd; } 5424 } 5425 5426 public final BodyTagEndContext bodyTagEnd() throws RecognitionException { 5427 BodyTagEndContext _localctx = new BodyTagEndContext(_ctx, getState()); 5428 enterRule(_localctx, 44, RULE_bodyTagEnd); 5429 int _la; 5430 try { 5431 enterOuterAlt(_localctx, 1); 5432 { 5433 setState(745); 5434 match(START); 5435 setState(746); 5436 match(SLASH); 5437 setState(747); 5438 match(BODY_HTML_TAG_NAME); 5439 setState(751); 5440 _errHandler.sync(this); 5441 _la = _input.LA(1); 5442 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5443 { 5444 { 5445 setState(748); 5446 _la = _input.LA(1); 5447 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5448 _errHandler.recoverInline(this); 5449 } 5450 else { 5451 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 5452 _errHandler.reportMatch(this); 5453 consume(); 5454 } 5455 } 5456 } 5457 setState(753); 5458 _errHandler.sync(this); 5459 _la = _input.LA(1); 5460 } 5461 setState(754); 5462 match(END); 5463 } 5464 } 5465 catch (RecognitionException re) { 5466 _localctx.exception = re; 5467 _errHandler.reportError(this, re); 5468 _errHandler.recover(this, re); 5469 } 5470 finally { 5471 exitRule(); 5472 } 5473 return _localctx; 5474 } 5475 5476 public static class BodyContext extends ParserRuleContext { 5477 public BodyTagStartContext bodyTagStart() { 5478 return getRuleContext(BodyTagStartContext.class,0); 5479 } 5480 public BodyTagEndContext bodyTagEnd() { 5481 return getRuleContext(BodyTagEndContext.class,0); 5482 } 5483 public List<HtmlTagContext> htmlTag() { 5484 return getRuleContexts(HtmlTagContext.class); 5485 } 5486 public HtmlTagContext htmlTag(int i) { 5487 return getRuleContext(HtmlTagContext.class,i); 5488 } 5489 public List<SingletonElementContext> singletonElement() { 5490 return getRuleContexts(SingletonElementContext.class); 5491 } 5492 public SingletonElementContext singletonElement(int i) { 5493 return getRuleContext(SingletonElementContext.class,i); 5494 } 5495 public List<ParagraphContext> paragraph() { 5496 return getRuleContexts(ParagraphContext.class); 5497 } 5498 public ParagraphContext paragraph(int i) { 5499 return getRuleContext(ParagraphContext.class,i); 5500 } 5501 public List<LiContext> li() { 5502 return getRuleContexts(LiContext.class); 5503 } 5504 public LiContext li(int i) { 5505 return getRuleContext(LiContext.class,i); 5506 } 5507 public List<TrContext> tr() { 5508 return getRuleContexts(TrContext.class); 5509 } 5510 public TrContext tr(int i) { 5511 return getRuleContext(TrContext.class,i); 5512 } 5513 public List<TdContext> td() { 5514 return getRuleContexts(TdContext.class); 5515 } 5516 public TdContext td(int i) { 5517 return getRuleContext(TdContext.class,i); 5518 } 5519 public List<ThContext> th() { 5520 return getRuleContexts(ThContext.class); 5521 } 5522 public ThContext th(int i) { 5523 return getRuleContext(ThContext.class,i); 5524 } 5525 public List<ColgroupContext> colgroup() { 5526 return getRuleContexts(ColgroupContext.class); 5527 } 5528 public ColgroupContext colgroup(int i) { 5529 return getRuleContext(ColgroupContext.class,i); 5530 } 5531 public List<DdContext> dd() { 5532 return getRuleContexts(DdContext.class); 5533 } 5534 public DdContext dd(int i) { 5535 return getRuleContext(DdContext.class,i); 5536 } 5537 public List<DtContext> dt() { 5538 return getRuleContexts(DtContext.class); 5539 } 5540 public DtContext dt(int i) { 5541 return getRuleContext(DtContext.class,i); 5542 } 5543 public List<HeadContext> head() { 5544 return getRuleContexts(HeadContext.class); 5545 } 5546 public HeadContext head(int i) { 5547 return getRuleContext(HeadContext.class,i); 5548 } 5549 public List<HtmlContext> html() { 5550 return getRuleContexts(HtmlContext.class); 5551 } 5552 public HtmlContext html(int i) { 5553 return getRuleContext(HtmlContext.class,i); 5554 } 5555 public List<OptionContext> option() { 5556 return getRuleContexts(OptionContext.class); 5557 } 5558 public OptionContext option(int i) { 5559 return getRuleContext(OptionContext.class,i); 5560 } 5561 public List<TbodyContext> tbody() { 5562 return getRuleContexts(TbodyContext.class); 5563 } 5564 public TbodyContext tbody(int i) { 5565 return getRuleContext(TbodyContext.class,i); 5566 } 5567 public List<TheadContext> thead() { 5568 return getRuleContexts(TheadContext.class); 5569 } 5570 public TheadContext thead(int i) { 5571 return getRuleContext(TheadContext.class,i); 5572 } 5573 public List<TfootContext> tfoot() { 5574 return getRuleContexts(TfootContext.class); 5575 } 5576 public TfootContext tfoot(int i) { 5577 return getRuleContext(TfootContext.class,i); 5578 } 5579 public List<OptgroupContext> optgroup() { 5580 return getRuleContexts(OptgroupContext.class); 5581 } 5582 public OptgroupContext optgroup(int i) { 5583 return getRuleContext(OptgroupContext.class,i); 5584 } 5585 public List<RbContext> rb() { 5586 return getRuleContexts(RbContext.class); 5587 } 5588 public RbContext rb(int i) { 5589 return getRuleContext(RbContext.class,i); 5590 } 5591 public List<RtContext> rt() { 5592 return getRuleContexts(RtContext.class); 5593 } 5594 public RtContext rt(int i) { 5595 return getRuleContext(RtContext.class,i); 5596 } 5597 public List<RtcContext> rtc() { 5598 return getRuleContexts(RtcContext.class); 5599 } 5600 public RtcContext rtc(int i) { 5601 return getRuleContext(RtcContext.class,i); 5602 } 5603 public List<RpContext> rp() { 5604 return getRuleContexts(RpContext.class); 5605 } 5606 public RpContext rp(int i) { 5607 return getRuleContext(RpContext.class,i); 5608 } 5609 public List<PTagStartContext> pTagStart() { 5610 return getRuleContexts(PTagStartContext.class); 5611 } 5612 public PTagStartContext pTagStart(int i) { 5613 return getRuleContext(PTagStartContext.class,i); 5614 } 5615 public List<LiTagStartContext> liTagStart() { 5616 return getRuleContexts(LiTagStartContext.class); 5617 } 5618 public LiTagStartContext liTagStart(int i) { 5619 return getRuleContext(LiTagStartContext.class,i); 5620 } 5621 public List<TrTagStartContext> trTagStart() { 5622 return getRuleContexts(TrTagStartContext.class); 5623 } 5624 public TrTagStartContext trTagStart(int i) { 5625 return getRuleContext(TrTagStartContext.class,i); 5626 } 5627 public List<TdTagStartContext> tdTagStart() { 5628 return getRuleContexts(TdTagStartContext.class); 5629 } 5630 public TdTagStartContext tdTagStart(int i) { 5631 return getRuleContext(TdTagStartContext.class,i); 5632 } 5633 public List<ThTagStartContext> thTagStart() { 5634 return getRuleContexts(ThTagStartContext.class); 5635 } 5636 public ThTagStartContext thTagStart(int i) { 5637 return getRuleContext(ThTagStartContext.class,i); 5638 } 5639 public List<ColgroupTagStartContext> colgroupTagStart() { 5640 return getRuleContexts(ColgroupTagStartContext.class); 5641 } 5642 public ColgroupTagStartContext colgroupTagStart(int i) { 5643 return getRuleContext(ColgroupTagStartContext.class,i); 5644 } 5645 public List<DdTagStartContext> ddTagStart() { 5646 return getRuleContexts(DdTagStartContext.class); 5647 } 5648 public DdTagStartContext ddTagStart(int i) { 5649 return getRuleContext(DdTagStartContext.class,i); 5650 } 5651 public List<DtTagStartContext> dtTagStart() { 5652 return getRuleContexts(DtTagStartContext.class); 5653 } 5654 public DtTagStartContext dtTagStart(int i) { 5655 return getRuleContext(DtTagStartContext.class,i); 5656 } 5657 public List<HeadTagStartContext> headTagStart() { 5658 return getRuleContexts(HeadTagStartContext.class); 5659 } 5660 public HeadTagStartContext headTagStart(int i) { 5661 return getRuleContext(HeadTagStartContext.class,i); 5662 } 5663 public List<HtmlTagStartContext> htmlTagStart() { 5664 return getRuleContexts(HtmlTagStartContext.class); 5665 } 5666 public HtmlTagStartContext htmlTagStart(int i) { 5667 return getRuleContext(HtmlTagStartContext.class,i); 5668 } 5669 public List<OptionTagStartContext> optionTagStart() { 5670 return getRuleContexts(OptionTagStartContext.class); 5671 } 5672 public OptionTagStartContext optionTagStart(int i) { 5673 return getRuleContext(OptionTagStartContext.class,i); 5674 } 5675 public List<TbodyTagStartContext> tbodyTagStart() { 5676 return getRuleContexts(TbodyTagStartContext.class); 5677 } 5678 public TbodyTagStartContext tbodyTagStart(int i) { 5679 return getRuleContext(TbodyTagStartContext.class,i); 5680 } 5681 public List<TheadTagStartContext> theadTagStart() { 5682 return getRuleContexts(TheadTagStartContext.class); 5683 } 5684 public TheadTagStartContext theadTagStart(int i) { 5685 return getRuleContext(TheadTagStartContext.class,i); 5686 } 5687 public List<TfootTagStartContext> tfootTagStart() { 5688 return getRuleContexts(TfootTagStartContext.class); 5689 } 5690 public TfootTagStartContext tfootTagStart(int i) { 5691 return getRuleContext(TfootTagStartContext.class,i); 5692 } 5693 public List<OptgroupTagStartContext> optgroupTagStart() { 5694 return getRuleContexts(OptgroupTagStartContext.class); 5695 } 5696 public OptgroupTagStartContext optgroupTagStart(int i) { 5697 return getRuleContext(OptgroupTagStartContext.class,i); 5698 } 5699 public List<RbTagStartContext> rbTagStart() { 5700 return getRuleContexts(RbTagStartContext.class); 5701 } 5702 public RbTagStartContext rbTagStart(int i) { 5703 return getRuleContext(RbTagStartContext.class,i); 5704 } 5705 public List<RtTagStartContext> rtTagStart() { 5706 return getRuleContexts(RtTagStartContext.class); 5707 } 5708 public RtTagStartContext rtTagStart(int i) { 5709 return getRuleContext(RtTagStartContext.class,i); 5710 } 5711 public List<RtcTagStartContext> rtcTagStart() { 5712 return getRuleContexts(RtcTagStartContext.class); 5713 } 5714 public RtcTagStartContext rtcTagStart(int i) { 5715 return getRuleContext(RtcTagStartContext.class,i); 5716 } 5717 public List<RpTagStartContext> rpTagStart() { 5718 return getRuleContexts(RpTagStartContext.class); 5719 } 5720 public RpTagStartContext rpTagStart(int i) { 5721 return getRuleContext(RpTagStartContext.class,i); 5722 } 5723 public List<HtmlCommentContext> htmlComment() { 5724 return getRuleContexts(HtmlCommentContext.class); 5725 } 5726 public HtmlCommentContext htmlComment(int i) { 5727 return getRuleContext(HtmlCommentContext.class,i); 5728 } 5729 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5730 public TerminalNode NEWLINE(int i) { 5731 return getToken(JavadocParser.NEWLINE, i); 5732 } 5733 public List<TextContext> text() { 5734 return getRuleContexts(TextContext.class); 5735 } 5736 public TextContext text(int i) { 5737 return getRuleContext(TextContext.class,i); 5738 } 5739 public List<JavadocInlineTagContext> javadocInlineTag() { 5740 return getRuleContexts(JavadocInlineTagContext.class); 5741 } 5742 public JavadocInlineTagContext javadocInlineTag(int i) { 5743 return getRuleContext(JavadocInlineTagContext.class,i); 5744 } 5745 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5746 public TerminalNode LEADING_ASTERISK(int i) { 5747 return getToken(JavadocParser.LEADING_ASTERISK, i); 5748 } 5749 public BodyContext(ParserRuleContext parent, int invokingState) { 5750 super(parent, invokingState); 5751 } 5752 @Override public int getRuleIndex() { return RULE_body; } 5753 } 5754 5755 public final BodyContext body() throws RecognitionException { 5756 BodyContext _localctx = new BodyContext(_ctx, getState()); 5757 enterRule(_localctx, 46, RULE_body); 5758 try { 5759 int _alt; 5760 enterOuterAlt(_localctx, 1); 5761 { 5762 setState(756); 5763 bodyTagStart(false); 5764 setState(805); 5765 _errHandler.sync(this); 5766 _alt = getInterpreter().adaptivePredict(_input,43,_ctx); 5767 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5768 if ( _alt==1 ) { 5769 { 5770 setState(803); 5771 _errHandler.sync(this); 5772 switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) { 5773 case 1: 5774 { 5775 setState(757); 5776 htmlTag(); 5777 } 5778 break; 5779 case 2: 5780 { 5781 setState(758); 5782 singletonElement(); 5783 } 5784 break; 5785 case 3: 5786 { 5787 setState(759); 5788 paragraph(); 5789 } 5790 break; 5791 case 4: 5792 { 5793 setState(760); 5794 li(); 5795 } 5796 break; 5797 case 5: 5798 { 5799 setState(761); 5800 tr(); 5801 } 5802 break; 5803 case 6: 5804 { 5805 setState(762); 5806 td(); 5807 } 5808 break; 5809 case 7: 5810 { 5811 setState(763); 5812 th(); 5813 } 5814 break; 5815 case 8: 5816 { 5817 setState(764); 5818 colgroup(); 5819 } 5820 break; 5821 case 9: 5822 { 5823 setState(765); 5824 dd(); 5825 } 5826 break; 5827 case 10: 5828 { 5829 setState(766); 5830 dt(); 5831 } 5832 break; 5833 case 11: 5834 { 5835 setState(767); 5836 head(); 5837 } 5838 break; 5839 case 12: 5840 { 5841 setState(768); 5842 html(); 5843 } 5844 break; 5845 case 13: 5846 { 5847 setState(769); 5848 option(); 5849 } 5850 break; 5851 case 14: 5852 { 5853 setState(770); 5854 tbody(); 5855 } 5856 break; 5857 case 15: 5858 { 5859 setState(771); 5860 thead(); 5861 } 5862 break; 5863 case 16: 5864 { 5865 setState(772); 5866 tfoot(); 5867 } 5868 break; 5869 case 17: 5870 { 5871 setState(773); 5872 optgroup(); 5873 } 5874 break; 5875 case 18: 5876 { 5877 setState(774); 5878 rb(); 5879 } 5880 break; 5881 case 19: 5882 { 5883 setState(775); 5884 rt(); 5885 } 5886 break; 5887 case 20: 5888 { 5889 setState(776); 5890 rtc(); 5891 } 5892 break; 5893 case 21: 5894 { 5895 setState(777); 5896 rp(); 5897 } 5898 break; 5899 case 22: 5900 { 5901 setState(778); 5902 pTagStart(true); 5903 } 5904 break; 5905 case 23: 5906 { 5907 setState(779); 5908 liTagStart(true); 5909 } 5910 break; 5911 case 24: 5912 { 5913 setState(780); 5914 trTagStart(true); 5915 } 5916 break; 5917 case 25: 5918 { 5919 setState(781); 5920 tdTagStart(true); 5921 } 5922 break; 5923 case 26: 5924 { 5925 setState(782); 5926 thTagStart(true); 5927 } 5928 break; 5929 case 27: 5930 { 5931 setState(783); 5932 colgroupTagStart(true); 5933 } 5934 break; 5935 case 28: 5936 { 5937 setState(784); 5938 ddTagStart(true); 5939 } 5940 break; 5941 case 29: 5942 { 5943 setState(785); 5944 dtTagStart(true); 5945 } 5946 break; 5947 case 30: 5948 { 5949 setState(786); 5950 headTagStart(true); 5951 } 5952 break; 5953 case 31: 5954 { 5955 setState(787); 5956 htmlTagStart(true); 5957 } 5958 break; 5959 case 32: 5960 { 5961 setState(788); 5962 optionTagStart(true); 5963 } 5964 break; 5965 case 33: 5966 { 5967 setState(789); 5968 tbodyTagStart(true); 5969 } 5970 break; 5971 case 34: 5972 { 5973 setState(790); 5974 theadTagStart(true); 5975 } 5976 break; 5977 case 35: 5978 { 5979 setState(791); 5980 tfootTagStart(true); 5981 } 5982 break; 5983 case 36: 5984 { 5985 setState(792); 5986 optgroupTagStart(true); 5987 } 5988 break; 5989 case 37: 5990 { 5991 setState(793); 5992 rbTagStart(true); 5993 } 5994 break; 5995 case 38: 5996 { 5997 setState(794); 5998 rtTagStart(true); 5999 } 6000 break; 6001 case 39: 6002 { 6003 setState(795); 6004 rtcTagStart(true); 6005 } 6006 break; 6007 case 40: 6008 { 6009 setState(796); 6010 rpTagStart(true); 6011 } 6012 break; 6013 case 41: 6014 { 6015 { 6016 setState(797); 6017 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6018 setState(798); 6019 match(LEADING_ASTERISK); 6020 } 6021 } 6022 break; 6023 case 42: 6024 { 6025 setState(799); 6026 htmlComment(); 6027 } 6028 break; 6029 case 43: 6030 { 6031 setState(800); 6032 match(NEWLINE); 6033 } 6034 break; 6035 case 44: 6036 { 6037 setState(801); 6038 text(); 6039 } 6040 break; 6041 case 45: 6042 { 6043 setState(802); 6044 javadocInlineTag(); 6045 } 6046 break; 6047 } 6048 } 6049 } 6050 setState(807); 6051 _errHandler.sync(this); 6052 _alt = getInterpreter().adaptivePredict(_input,43,_ctx); 6053 } 6054 setState(808); 6055 bodyTagEnd(); 6056 } 6057 } 6058 catch (RecognitionException re) { 6059 _localctx.exception = re; 6060 _errHandler.reportError(this, re); 6061 _errHandler.recover(this, re); 6062 } 6063 finally { 6064 exitRule(); 6065 } 6066 return _localctx; 6067 } 6068 6069 public static class ColgroupTagStartContext extends ParserRuleContext { 6070 public boolean isNonTight; 6071 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 6072 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 6073 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 6074 public List<AttributeContext> attribute() { 6075 return getRuleContexts(AttributeContext.class); 6076 } 6077 public AttributeContext attribute(int i) { 6078 return getRuleContext(AttributeContext.class,i); 6079 } 6080 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6081 public TerminalNode NEWLINE(int i) { 6082 return getToken(JavadocParser.NEWLINE, i); 6083 } 6084 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6085 public TerminalNode LEADING_ASTERISK(int i) { 6086 return getToken(JavadocParser.LEADING_ASTERISK, i); 6087 } 6088 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6089 public TerminalNode WS(int i) { 6090 return getToken(JavadocParser.WS, i); 6091 } 6092 public ColgroupTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 6093 public ColgroupTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 6094 super(parent, invokingState); 6095 this.isNonTight = isNonTight; 6096 } 6097 @Override public int getRuleIndex() { return RULE_colgroupTagStart; } 6098 } 6099 6100 public final ColgroupTagStartContext colgroupTagStart(boolean isNonTight) throws RecognitionException { 6101 ColgroupTagStartContext _localctx = new ColgroupTagStartContext(_ctx, getState(), isNonTight); 6102 enterRule(_localctx, 48, RULE_colgroupTagStart); 6103 int _la; 6104 try { 6105 enterOuterAlt(_localctx, 1); 6106 { 6107 setState(810); 6108 match(START); 6109 setState(811); 6110 match(COLGROUP_HTML_TAG_NAME); 6111 setState(818); 6112 _errHandler.sync(this); 6113 _la = _input.LA(1); 6114 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6115 { 6116 setState(816); 6117 _errHandler.sync(this); 6118 switch (_input.LA(1)) { 6119 case HTML_TAG_NAME: 6120 { 6121 setState(812); 6122 attribute(); 6123 } 6124 break; 6125 case NEWLINE: 6126 { 6127 setState(813); 6128 match(NEWLINE); 6129 } 6130 break; 6131 case LEADING_ASTERISK: 6132 { 6133 setState(814); 6134 match(LEADING_ASTERISK); 6135 } 6136 break; 6137 case WS: 6138 { 6139 setState(815); 6140 match(WS); 6141 } 6142 break; 6143 default: 6144 throw new NoViableAltException(this); 6145 } 6146 } 6147 setState(820); 6148 _errHandler.sync(this); 6149 _la = _input.LA(1); 6150 } 6151 setState(821); 6152 match(END); 6153 } 6154 _ctx.stop = _input.LT(-1); 6155 6156 if (isNonTight && nonTightTagStartContext == null) { 6157 nonTightTagStartContext = _localctx; 6158 } 6159 6160 } 6161 catch (RecognitionException re) { 6162 _localctx.exception = re; 6163 _errHandler.reportError(this, re); 6164 _errHandler.recover(this, re); 6165 } 6166 finally { 6167 exitRule(); 6168 } 6169 return _localctx; 6170 } 6171 6172 public static class ColgroupTagEndContext extends ParserRuleContext { 6173 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 6174 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 6175 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 6176 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 6177 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6178 public TerminalNode NEWLINE(int i) { 6179 return getToken(JavadocParser.NEWLINE, i); 6180 } 6181 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6182 public TerminalNode LEADING_ASTERISK(int i) { 6183 return getToken(JavadocParser.LEADING_ASTERISK, i); 6184 } 6185 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6186 public TerminalNode WS(int i) { 6187 return getToken(JavadocParser.WS, i); 6188 } 6189 public ColgroupTagEndContext(ParserRuleContext parent, int invokingState) { 6190 super(parent, invokingState); 6191 } 6192 @Override public int getRuleIndex() { return RULE_colgroupTagEnd; } 6193 } 6194 6195 public final ColgroupTagEndContext colgroupTagEnd() throws RecognitionException { 6196 ColgroupTagEndContext _localctx = new ColgroupTagEndContext(_ctx, getState()); 6197 enterRule(_localctx, 50, RULE_colgroupTagEnd); 6198 int _la; 6199 try { 6200 enterOuterAlt(_localctx, 1); 6201 { 6202 setState(823); 6203 match(START); 6204 setState(824); 6205 match(SLASH); 6206 setState(825); 6207 match(COLGROUP_HTML_TAG_NAME); 6208 setState(829); 6209 _errHandler.sync(this); 6210 _la = _input.LA(1); 6211 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 6212 { 6213 { 6214 setState(826); 6215 _la = _input.LA(1); 6216 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 6217 _errHandler.recoverInline(this); 6218 } 6219 else { 6220 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 6221 _errHandler.reportMatch(this); 6222 consume(); 6223 } 6224 } 6225 } 6226 setState(831); 6227 _errHandler.sync(this); 6228 _la = _input.LA(1); 6229 } 6230 setState(832); 6231 match(END); 6232 } 6233 } 6234 catch (RecognitionException re) { 6235 _localctx.exception = re; 6236 _errHandler.reportError(this, re); 6237 _errHandler.recover(this, re); 6238 } 6239 finally { 6240 exitRule(); 6241 } 6242 return _localctx; 6243 } 6244 6245 public static class ColgroupContext extends ParserRuleContext { 6246 public ColgroupTagStartContext colgroupTagStart() { 6247 return getRuleContext(ColgroupTagStartContext.class,0); 6248 } 6249 public ColgroupTagEndContext colgroupTagEnd() { 6250 return getRuleContext(ColgroupTagEndContext.class,0); 6251 } 6252 public List<HtmlTagContext> htmlTag() { 6253 return getRuleContexts(HtmlTagContext.class); 6254 } 6255 public HtmlTagContext htmlTag(int i) { 6256 return getRuleContext(HtmlTagContext.class,i); 6257 } 6258 public List<SingletonElementContext> singletonElement() { 6259 return getRuleContexts(SingletonElementContext.class); 6260 } 6261 public SingletonElementContext singletonElement(int i) { 6262 return getRuleContext(SingletonElementContext.class,i); 6263 } 6264 public List<ParagraphContext> paragraph() { 6265 return getRuleContexts(ParagraphContext.class); 6266 } 6267 public ParagraphContext paragraph(int i) { 6268 return getRuleContext(ParagraphContext.class,i); 6269 } 6270 public List<LiContext> li() { 6271 return getRuleContexts(LiContext.class); 6272 } 6273 public LiContext li(int i) { 6274 return getRuleContext(LiContext.class,i); 6275 } 6276 public List<TrContext> tr() { 6277 return getRuleContexts(TrContext.class); 6278 } 6279 public TrContext tr(int i) { 6280 return getRuleContext(TrContext.class,i); 6281 } 6282 public List<TdContext> td() { 6283 return getRuleContexts(TdContext.class); 6284 } 6285 public TdContext td(int i) { 6286 return getRuleContext(TdContext.class,i); 6287 } 6288 public List<ThContext> th() { 6289 return getRuleContexts(ThContext.class); 6290 } 6291 public ThContext th(int i) { 6292 return getRuleContext(ThContext.class,i); 6293 } 6294 public List<BodyContext> body() { 6295 return getRuleContexts(BodyContext.class); 6296 } 6297 public BodyContext body(int i) { 6298 return getRuleContext(BodyContext.class,i); 6299 } 6300 public List<DdContext> dd() { 6301 return getRuleContexts(DdContext.class); 6302 } 6303 public DdContext dd(int i) { 6304 return getRuleContext(DdContext.class,i); 6305 } 6306 public List<DtContext> dt() { 6307 return getRuleContexts(DtContext.class); 6308 } 6309 public DtContext dt(int i) { 6310 return getRuleContext(DtContext.class,i); 6311 } 6312 public List<HeadContext> head() { 6313 return getRuleContexts(HeadContext.class); 6314 } 6315 public HeadContext head(int i) { 6316 return getRuleContext(HeadContext.class,i); 6317 } 6318 public List<HtmlContext> html() { 6319 return getRuleContexts(HtmlContext.class); 6320 } 6321 public HtmlContext html(int i) { 6322 return getRuleContext(HtmlContext.class,i); 6323 } 6324 public List<OptionContext> option() { 6325 return getRuleContexts(OptionContext.class); 6326 } 6327 public OptionContext option(int i) { 6328 return getRuleContext(OptionContext.class,i); 6329 } 6330 public List<TbodyContext> tbody() { 6331 return getRuleContexts(TbodyContext.class); 6332 } 6333 public TbodyContext tbody(int i) { 6334 return getRuleContext(TbodyContext.class,i); 6335 } 6336 public List<TheadContext> thead() { 6337 return getRuleContexts(TheadContext.class); 6338 } 6339 public TheadContext thead(int i) { 6340 return getRuleContext(TheadContext.class,i); 6341 } 6342 public List<TfootContext> tfoot() { 6343 return getRuleContexts(TfootContext.class); 6344 } 6345 public TfootContext tfoot(int i) { 6346 return getRuleContext(TfootContext.class,i); 6347 } 6348 public List<OptgroupContext> optgroup() { 6349 return getRuleContexts(OptgroupContext.class); 6350 } 6351 public OptgroupContext optgroup(int i) { 6352 return getRuleContext(OptgroupContext.class,i); 6353 } 6354 public List<RbContext> rb() { 6355 return getRuleContexts(RbContext.class); 6356 } 6357 public RbContext rb(int i) { 6358 return getRuleContext(RbContext.class,i); 6359 } 6360 public List<RtContext> rt() { 6361 return getRuleContexts(RtContext.class); 6362 } 6363 public RtContext rt(int i) { 6364 return getRuleContext(RtContext.class,i); 6365 } 6366 public List<RtcContext> rtc() { 6367 return getRuleContexts(RtcContext.class); 6368 } 6369 public RtcContext rtc(int i) { 6370 return getRuleContext(RtcContext.class,i); 6371 } 6372 public List<RpContext> rp() { 6373 return getRuleContexts(RpContext.class); 6374 } 6375 public RpContext rp(int i) { 6376 return getRuleContext(RpContext.class,i); 6377 } 6378 public List<PTagStartContext> pTagStart() { 6379 return getRuleContexts(PTagStartContext.class); 6380 } 6381 public PTagStartContext pTagStart(int i) { 6382 return getRuleContext(PTagStartContext.class,i); 6383 } 6384 public List<LiTagStartContext> liTagStart() { 6385 return getRuleContexts(LiTagStartContext.class); 6386 } 6387 public LiTagStartContext liTagStart(int i) { 6388 return getRuleContext(LiTagStartContext.class,i); 6389 } 6390 public List<TrTagStartContext> trTagStart() { 6391 return getRuleContexts(TrTagStartContext.class); 6392 } 6393 public TrTagStartContext trTagStart(int i) { 6394 return getRuleContext(TrTagStartContext.class,i); 6395 } 6396 public List<TdTagStartContext> tdTagStart() { 6397 return getRuleContexts(TdTagStartContext.class); 6398 } 6399 public TdTagStartContext tdTagStart(int i) { 6400 return getRuleContext(TdTagStartContext.class,i); 6401 } 6402 public List<ThTagStartContext> thTagStart() { 6403 return getRuleContexts(ThTagStartContext.class); 6404 } 6405 public ThTagStartContext thTagStart(int i) { 6406 return getRuleContext(ThTagStartContext.class,i); 6407 } 6408 public List<BodyTagStartContext> bodyTagStart() { 6409 return getRuleContexts(BodyTagStartContext.class); 6410 } 6411 public BodyTagStartContext bodyTagStart(int i) { 6412 return getRuleContext(BodyTagStartContext.class,i); 6413 } 6414 public List<DdTagStartContext> ddTagStart() { 6415 return getRuleContexts(DdTagStartContext.class); 6416 } 6417 public DdTagStartContext ddTagStart(int i) { 6418 return getRuleContext(DdTagStartContext.class,i); 6419 } 6420 public List<DtTagStartContext> dtTagStart() { 6421 return getRuleContexts(DtTagStartContext.class); 6422 } 6423 public DtTagStartContext dtTagStart(int i) { 6424 return getRuleContext(DtTagStartContext.class,i); 6425 } 6426 public List<HeadTagStartContext> headTagStart() { 6427 return getRuleContexts(HeadTagStartContext.class); 6428 } 6429 public HeadTagStartContext headTagStart(int i) { 6430 return getRuleContext(HeadTagStartContext.class,i); 6431 } 6432 public List<HtmlTagStartContext> htmlTagStart() { 6433 return getRuleContexts(HtmlTagStartContext.class); 6434 } 6435 public HtmlTagStartContext htmlTagStart(int i) { 6436 return getRuleContext(HtmlTagStartContext.class,i); 6437 } 6438 public List<OptionTagStartContext> optionTagStart() { 6439 return getRuleContexts(OptionTagStartContext.class); 6440 } 6441 public OptionTagStartContext optionTagStart(int i) { 6442 return getRuleContext(OptionTagStartContext.class,i); 6443 } 6444 public List<TbodyTagStartContext> tbodyTagStart() { 6445 return getRuleContexts(TbodyTagStartContext.class); 6446 } 6447 public TbodyTagStartContext tbodyTagStart(int i) { 6448 return getRuleContext(TbodyTagStartContext.class,i); 6449 } 6450 public List<TheadTagStartContext> theadTagStart() { 6451 return getRuleContexts(TheadTagStartContext.class); 6452 } 6453 public TheadTagStartContext theadTagStart(int i) { 6454 return getRuleContext(TheadTagStartContext.class,i); 6455 } 6456 public List<TfootTagStartContext> tfootTagStart() { 6457 return getRuleContexts(TfootTagStartContext.class); 6458 } 6459 public TfootTagStartContext tfootTagStart(int i) { 6460 return getRuleContext(TfootTagStartContext.class,i); 6461 } 6462 public List<OptgroupTagStartContext> optgroupTagStart() { 6463 return getRuleContexts(OptgroupTagStartContext.class); 6464 } 6465 public OptgroupTagStartContext optgroupTagStart(int i) { 6466 return getRuleContext(OptgroupTagStartContext.class,i); 6467 } 6468 public List<RbTagStartContext> rbTagStart() { 6469 return getRuleContexts(RbTagStartContext.class); 6470 } 6471 public RbTagStartContext rbTagStart(int i) { 6472 return getRuleContext(RbTagStartContext.class,i); 6473 } 6474 public List<RtTagStartContext> rtTagStart() { 6475 return getRuleContexts(RtTagStartContext.class); 6476 } 6477 public RtTagStartContext rtTagStart(int i) { 6478 return getRuleContext(RtTagStartContext.class,i); 6479 } 6480 public List<RtcTagStartContext> rtcTagStart() { 6481 return getRuleContexts(RtcTagStartContext.class); 6482 } 6483 public RtcTagStartContext rtcTagStart(int i) { 6484 return getRuleContext(RtcTagStartContext.class,i); 6485 } 6486 public List<RpTagStartContext> rpTagStart() { 6487 return getRuleContexts(RpTagStartContext.class); 6488 } 6489 public RpTagStartContext rpTagStart(int i) { 6490 return getRuleContext(RpTagStartContext.class,i); 6491 } 6492 public List<HtmlCommentContext> htmlComment() { 6493 return getRuleContexts(HtmlCommentContext.class); 6494 } 6495 public HtmlCommentContext htmlComment(int i) { 6496 return getRuleContext(HtmlCommentContext.class,i); 6497 } 6498 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6499 public TerminalNode NEWLINE(int i) { 6500 return getToken(JavadocParser.NEWLINE, i); 6501 } 6502 public List<TextContext> text() { 6503 return getRuleContexts(TextContext.class); 6504 } 6505 public TextContext text(int i) { 6506 return getRuleContext(TextContext.class,i); 6507 } 6508 public List<JavadocInlineTagContext> javadocInlineTag() { 6509 return getRuleContexts(JavadocInlineTagContext.class); 6510 } 6511 public JavadocInlineTagContext javadocInlineTag(int i) { 6512 return getRuleContext(JavadocInlineTagContext.class,i); 6513 } 6514 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6515 public TerminalNode LEADING_ASTERISK(int i) { 6516 return getToken(JavadocParser.LEADING_ASTERISK, i); 6517 } 6518 public ColgroupContext(ParserRuleContext parent, int invokingState) { 6519 super(parent, invokingState); 6520 } 6521 @Override public int getRuleIndex() { return RULE_colgroup; } 6522 } 6523 6524 public final ColgroupContext colgroup() throws RecognitionException { 6525 ColgroupContext _localctx = new ColgroupContext(_ctx, getState()); 6526 enterRule(_localctx, 52, RULE_colgroup); 6527 try { 6528 int _alt; 6529 enterOuterAlt(_localctx, 1); 6530 { 6531 setState(834); 6532 colgroupTagStart(false); 6533 setState(883); 6534 _errHandler.sync(this); 6535 _alt = getInterpreter().adaptivePredict(_input,48,_ctx); 6536 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6537 if ( _alt==1 ) { 6538 { 6539 setState(881); 6540 _errHandler.sync(this); 6541 switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) { 6542 case 1: 6543 { 6544 setState(835); 6545 htmlTag(); 6546 } 6547 break; 6548 case 2: 6549 { 6550 setState(836); 6551 singletonElement(); 6552 } 6553 break; 6554 case 3: 6555 { 6556 setState(837); 6557 paragraph(); 6558 } 6559 break; 6560 case 4: 6561 { 6562 setState(838); 6563 li(); 6564 } 6565 break; 6566 case 5: 6567 { 6568 setState(839); 6569 tr(); 6570 } 6571 break; 6572 case 6: 6573 { 6574 setState(840); 6575 td(); 6576 } 6577 break; 6578 case 7: 6579 { 6580 setState(841); 6581 th(); 6582 } 6583 break; 6584 case 8: 6585 { 6586 setState(842); 6587 body(); 6588 } 6589 break; 6590 case 9: 6591 { 6592 setState(843); 6593 dd(); 6594 } 6595 break; 6596 case 10: 6597 { 6598 setState(844); 6599 dt(); 6600 } 6601 break; 6602 case 11: 6603 { 6604 setState(845); 6605 head(); 6606 } 6607 break; 6608 case 12: 6609 { 6610 setState(846); 6611 html(); 6612 } 6613 break; 6614 case 13: 6615 { 6616 setState(847); 6617 option(); 6618 } 6619 break; 6620 case 14: 6621 { 6622 setState(848); 6623 tbody(); 6624 } 6625 break; 6626 case 15: 6627 { 6628 setState(849); 6629 thead(); 6630 } 6631 break; 6632 case 16: 6633 { 6634 setState(850); 6635 tfoot(); 6636 } 6637 break; 6638 case 17: 6639 { 6640 setState(851); 6641 optgroup(); 6642 } 6643 break; 6644 case 18: 6645 { 6646 setState(852); 6647 rb(); 6648 } 6649 break; 6650 case 19: 6651 { 6652 setState(853); 6653 rt(); 6654 } 6655 break; 6656 case 20: 6657 { 6658 setState(854); 6659 rtc(); 6660 } 6661 break; 6662 case 21: 6663 { 6664 setState(855); 6665 rp(); 6666 } 6667 break; 6668 case 22: 6669 { 6670 setState(856); 6671 pTagStart(true); 6672 } 6673 break; 6674 case 23: 6675 { 6676 setState(857); 6677 liTagStart(true); 6678 } 6679 break; 6680 case 24: 6681 { 6682 setState(858); 6683 trTagStart(true); 6684 } 6685 break; 6686 case 25: 6687 { 6688 setState(859); 6689 tdTagStart(true); 6690 } 6691 break; 6692 case 26: 6693 { 6694 setState(860); 6695 thTagStart(true); 6696 } 6697 break; 6698 case 27: 6699 { 6700 setState(861); 6701 bodyTagStart(true); 6702 } 6703 break; 6704 case 28: 6705 { 6706 setState(862); 6707 ddTagStart(true); 6708 } 6709 break; 6710 case 29: 6711 { 6712 setState(863); 6713 dtTagStart(true); 6714 } 6715 break; 6716 case 30: 6717 { 6718 setState(864); 6719 headTagStart(true); 6720 } 6721 break; 6722 case 31: 6723 { 6724 setState(865); 6725 htmlTagStart(true); 6726 } 6727 break; 6728 case 32: 6729 { 6730 setState(866); 6731 optionTagStart(true); 6732 } 6733 break; 6734 case 33: 6735 { 6736 setState(867); 6737 tbodyTagStart(true); 6738 } 6739 break; 6740 case 34: 6741 { 6742 setState(868); 6743 theadTagStart(true); 6744 } 6745 break; 6746 case 35: 6747 { 6748 setState(869); 6749 tfootTagStart(true); 6750 } 6751 break; 6752 case 36: 6753 { 6754 setState(870); 6755 optgroupTagStart(true); 6756 } 6757 break; 6758 case 37: 6759 { 6760 setState(871); 6761 rbTagStart(true); 6762 } 6763 break; 6764 case 38: 6765 { 6766 setState(872); 6767 rtTagStart(true); 6768 } 6769 break; 6770 case 39: 6771 { 6772 setState(873); 6773 rtcTagStart(true); 6774 } 6775 break; 6776 case 40: 6777 { 6778 setState(874); 6779 rpTagStart(true); 6780 } 6781 break; 6782 case 41: 6783 { 6784 { 6785 setState(875); 6786 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6787 setState(876); 6788 match(LEADING_ASTERISK); 6789 } 6790 } 6791 break; 6792 case 42: 6793 { 6794 setState(877); 6795 htmlComment(); 6796 } 6797 break; 6798 case 43: 6799 { 6800 setState(878); 6801 match(NEWLINE); 6802 } 6803 break; 6804 case 44: 6805 { 6806 setState(879); 6807 text(); 6808 } 6809 break; 6810 case 45: 6811 { 6812 setState(880); 6813 javadocInlineTag(); 6814 } 6815 break; 6816 } 6817 } 6818 } 6819 setState(885); 6820 _errHandler.sync(this); 6821 _alt = getInterpreter().adaptivePredict(_input,48,_ctx); 6822 } 6823 setState(886); 6824 colgroupTagEnd(); 6825 } 6826 } 6827 catch (RecognitionException re) { 6828 _localctx.exception = re; 6829 _errHandler.reportError(this, re); 6830 _errHandler.recover(this, re); 6831 } 6832 finally { 6833 exitRule(); 6834 } 6835 return _localctx; 6836 } 6837 6838 public static class DdTagStartContext extends ParserRuleContext { 6839 public boolean isNonTight; 6840 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 6841 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6842 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 6843 public List<AttributeContext> attribute() { 6844 return getRuleContexts(AttributeContext.class); 6845 } 6846 public AttributeContext attribute(int i) { 6847 return getRuleContext(AttributeContext.class,i); 6848 } 6849 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6850 public TerminalNode NEWLINE(int i) { 6851 return getToken(JavadocParser.NEWLINE, i); 6852 } 6853 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6854 public TerminalNode LEADING_ASTERISK(int i) { 6855 return getToken(JavadocParser.LEADING_ASTERISK, i); 6856 } 6857 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6858 public TerminalNode WS(int i) { 6859 return getToken(JavadocParser.WS, i); 6860 } 6861 public DdTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 6862 public DdTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 6863 super(parent, invokingState); 6864 this.isNonTight = isNonTight; 6865 } 6866 @Override public int getRuleIndex() { return RULE_ddTagStart; } 6867 } 6868 6869 public final DdTagStartContext ddTagStart(boolean isNonTight) throws RecognitionException { 6870 DdTagStartContext _localctx = new DdTagStartContext(_ctx, getState(), isNonTight); 6871 enterRule(_localctx, 54, RULE_ddTagStart); 6872 int _la; 6873 try { 6874 enterOuterAlt(_localctx, 1); 6875 { 6876 setState(888); 6877 match(START); 6878 setState(889); 6879 match(DD_HTML_TAG_NAME); 6880 setState(896); 6881 _errHandler.sync(this); 6882 _la = _input.LA(1); 6883 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6884 { 6885 setState(894); 6886 _errHandler.sync(this); 6887 switch (_input.LA(1)) { 6888 case HTML_TAG_NAME: 6889 { 6890 setState(890); 6891 attribute(); 6892 } 6893 break; 6894 case NEWLINE: 6895 { 6896 setState(891); 6897 match(NEWLINE); 6898 } 6899 break; 6900 case LEADING_ASTERISK: 6901 { 6902 setState(892); 6903 match(LEADING_ASTERISK); 6904 } 6905 break; 6906 case WS: 6907 { 6908 setState(893); 6909 match(WS); 6910 } 6911 break; 6912 default: 6913 throw new NoViableAltException(this); 6914 } 6915 } 6916 setState(898); 6917 _errHandler.sync(this); 6918 _la = _input.LA(1); 6919 } 6920 setState(899); 6921 match(END); 6922 } 6923 _ctx.stop = _input.LT(-1); 6924 6925 if (isNonTight && nonTightTagStartContext == null) { 6926 nonTightTagStartContext = _localctx; 6927 } 6928 6929 } 6930 catch (RecognitionException re) { 6931 _localctx.exception = re; 6932 _errHandler.reportError(this, re); 6933 _errHandler.recover(this, re); 6934 } 6935 finally { 6936 exitRule(); 6937 } 6938 return _localctx; 6939 } 6940 6941 public static class DdTagEndContext extends ParserRuleContext { 6942 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 6943 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 6944 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6945 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 6946 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6947 public TerminalNode NEWLINE(int i) { 6948 return getToken(JavadocParser.NEWLINE, i); 6949 } 6950 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6951 public TerminalNode LEADING_ASTERISK(int i) { 6952 return getToken(JavadocParser.LEADING_ASTERISK, i); 6953 } 6954 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6955 public TerminalNode WS(int i) { 6956 return getToken(JavadocParser.WS, i); 6957 } 6958 public DdTagEndContext(ParserRuleContext parent, int invokingState) { 6959 super(parent, invokingState); 6960 } 6961 @Override public int getRuleIndex() { return RULE_ddTagEnd; } 6962 } 6963 6964 public final DdTagEndContext ddTagEnd() throws RecognitionException { 6965 DdTagEndContext _localctx = new DdTagEndContext(_ctx, getState()); 6966 enterRule(_localctx, 56, RULE_ddTagEnd); 6967 int _la; 6968 try { 6969 enterOuterAlt(_localctx, 1); 6970 { 6971 setState(901); 6972 match(START); 6973 setState(902); 6974 match(SLASH); 6975 setState(903); 6976 match(DD_HTML_TAG_NAME); 6977 setState(907); 6978 _errHandler.sync(this); 6979 _la = _input.LA(1); 6980 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 6981 { 6982 { 6983 setState(904); 6984 _la = _input.LA(1); 6985 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 6986 _errHandler.recoverInline(this); 6987 } 6988 else { 6989 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 6990 _errHandler.reportMatch(this); 6991 consume(); 6992 } 6993 } 6994 } 6995 setState(909); 6996 _errHandler.sync(this); 6997 _la = _input.LA(1); 6998 } 6999 setState(910); 7000 match(END); 7001 } 7002 } 7003 catch (RecognitionException re) { 7004 _localctx.exception = re; 7005 _errHandler.reportError(this, re); 7006 _errHandler.recover(this, re); 7007 } 7008 finally { 7009 exitRule(); 7010 } 7011 return _localctx; 7012 } 7013 7014 public static class DdContext extends ParserRuleContext { 7015 public DdTagStartContext ddTagStart() { 7016 return getRuleContext(DdTagStartContext.class,0); 7017 } 7018 public DdTagEndContext ddTagEnd() { 7019 return getRuleContext(DdTagEndContext.class,0); 7020 } 7021 public List<HtmlTagContext> htmlTag() { 7022 return getRuleContexts(HtmlTagContext.class); 7023 } 7024 public HtmlTagContext htmlTag(int i) { 7025 return getRuleContext(HtmlTagContext.class,i); 7026 } 7027 public List<SingletonElementContext> singletonElement() { 7028 return getRuleContexts(SingletonElementContext.class); 7029 } 7030 public SingletonElementContext singletonElement(int i) { 7031 return getRuleContext(SingletonElementContext.class,i); 7032 } 7033 public List<ParagraphContext> paragraph() { 7034 return getRuleContexts(ParagraphContext.class); 7035 } 7036 public ParagraphContext paragraph(int i) { 7037 return getRuleContext(ParagraphContext.class,i); 7038 } 7039 public List<LiContext> li() { 7040 return getRuleContexts(LiContext.class); 7041 } 7042 public LiContext li(int i) { 7043 return getRuleContext(LiContext.class,i); 7044 } 7045 public List<TrContext> tr() { 7046 return getRuleContexts(TrContext.class); 7047 } 7048 public TrContext tr(int i) { 7049 return getRuleContext(TrContext.class,i); 7050 } 7051 public List<TdContext> td() { 7052 return getRuleContexts(TdContext.class); 7053 } 7054 public TdContext td(int i) { 7055 return getRuleContext(TdContext.class,i); 7056 } 7057 public List<ThContext> th() { 7058 return getRuleContexts(ThContext.class); 7059 } 7060 public ThContext th(int i) { 7061 return getRuleContext(ThContext.class,i); 7062 } 7063 public List<BodyContext> body() { 7064 return getRuleContexts(BodyContext.class); 7065 } 7066 public BodyContext body(int i) { 7067 return getRuleContext(BodyContext.class,i); 7068 } 7069 public List<ColgroupContext> colgroup() { 7070 return getRuleContexts(ColgroupContext.class); 7071 } 7072 public ColgroupContext colgroup(int i) { 7073 return getRuleContext(ColgroupContext.class,i); 7074 } 7075 public List<DtContext> dt() { 7076 return getRuleContexts(DtContext.class); 7077 } 7078 public DtContext dt(int i) { 7079 return getRuleContext(DtContext.class,i); 7080 } 7081 public List<HeadContext> head() { 7082 return getRuleContexts(HeadContext.class); 7083 } 7084 public HeadContext head(int i) { 7085 return getRuleContext(HeadContext.class,i); 7086 } 7087 public List<HtmlContext> html() { 7088 return getRuleContexts(HtmlContext.class); 7089 } 7090 public HtmlContext html(int i) { 7091 return getRuleContext(HtmlContext.class,i); 7092 } 7093 public List<OptionContext> option() { 7094 return getRuleContexts(OptionContext.class); 7095 } 7096 public OptionContext option(int i) { 7097 return getRuleContext(OptionContext.class,i); 7098 } 7099 public List<TbodyContext> tbody() { 7100 return getRuleContexts(TbodyContext.class); 7101 } 7102 public TbodyContext tbody(int i) { 7103 return getRuleContext(TbodyContext.class,i); 7104 } 7105 public List<TheadContext> thead() { 7106 return getRuleContexts(TheadContext.class); 7107 } 7108 public TheadContext thead(int i) { 7109 return getRuleContext(TheadContext.class,i); 7110 } 7111 public List<TfootContext> tfoot() { 7112 return getRuleContexts(TfootContext.class); 7113 } 7114 public TfootContext tfoot(int i) { 7115 return getRuleContext(TfootContext.class,i); 7116 } 7117 public List<OptgroupContext> optgroup() { 7118 return getRuleContexts(OptgroupContext.class); 7119 } 7120 public OptgroupContext optgroup(int i) { 7121 return getRuleContext(OptgroupContext.class,i); 7122 } 7123 public List<RbContext> rb() { 7124 return getRuleContexts(RbContext.class); 7125 } 7126 public RbContext rb(int i) { 7127 return getRuleContext(RbContext.class,i); 7128 } 7129 public List<RtContext> rt() { 7130 return getRuleContexts(RtContext.class); 7131 } 7132 public RtContext rt(int i) { 7133 return getRuleContext(RtContext.class,i); 7134 } 7135 public List<RtcContext> rtc() { 7136 return getRuleContexts(RtcContext.class); 7137 } 7138 public RtcContext rtc(int i) { 7139 return getRuleContext(RtcContext.class,i); 7140 } 7141 public List<RpContext> rp() { 7142 return getRuleContexts(RpContext.class); 7143 } 7144 public RpContext rp(int i) { 7145 return getRuleContext(RpContext.class,i); 7146 } 7147 public List<PTagStartContext> pTagStart() { 7148 return getRuleContexts(PTagStartContext.class); 7149 } 7150 public PTagStartContext pTagStart(int i) { 7151 return getRuleContext(PTagStartContext.class,i); 7152 } 7153 public List<LiTagStartContext> liTagStart() { 7154 return getRuleContexts(LiTagStartContext.class); 7155 } 7156 public LiTagStartContext liTagStart(int i) { 7157 return getRuleContext(LiTagStartContext.class,i); 7158 } 7159 public List<TrTagStartContext> trTagStart() { 7160 return getRuleContexts(TrTagStartContext.class); 7161 } 7162 public TrTagStartContext trTagStart(int i) { 7163 return getRuleContext(TrTagStartContext.class,i); 7164 } 7165 public List<TdTagStartContext> tdTagStart() { 7166 return getRuleContexts(TdTagStartContext.class); 7167 } 7168 public TdTagStartContext tdTagStart(int i) { 7169 return getRuleContext(TdTagStartContext.class,i); 7170 } 7171 public List<ThTagStartContext> thTagStart() { 7172 return getRuleContexts(ThTagStartContext.class); 7173 } 7174 public ThTagStartContext thTagStart(int i) { 7175 return getRuleContext(ThTagStartContext.class,i); 7176 } 7177 public List<BodyTagStartContext> bodyTagStart() { 7178 return getRuleContexts(BodyTagStartContext.class); 7179 } 7180 public BodyTagStartContext bodyTagStart(int i) { 7181 return getRuleContext(BodyTagStartContext.class,i); 7182 } 7183 public List<ColgroupTagStartContext> colgroupTagStart() { 7184 return getRuleContexts(ColgroupTagStartContext.class); 7185 } 7186 public ColgroupTagStartContext colgroupTagStart(int i) { 7187 return getRuleContext(ColgroupTagStartContext.class,i); 7188 } 7189 public List<DtTagStartContext> dtTagStart() { 7190 return getRuleContexts(DtTagStartContext.class); 7191 } 7192 public DtTagStartContext dtTagStart(int i) { 7193 return getRuleContext(DtTagStartContext.class,i); 7194 } 7195 public List<HeadTagStartContext> headTagStart() { 7196 return getRuleContexts(HeadTagStartContext.class); 7197 } 7198 public HeadTagStartContext headTagStart(int i) { 7199 return getRuleContext(HeadTagStartContext.class,i); 7200 } 7201 public List<HtmlTagStartContext> htmlTagStart() { 7202 return getRuleContexts(HtmlTagStartContext.class); 7203 } 7204 public HtmlTagStartContext htmlTagStart(int i) { 7205 return getRuleContext(HtmlTagStartContext.class,i); 7206 } 7207 public List<OptionTagStartContext> optionTagStart() { 7208 return getRuleContexts(OptionTagStartContext.class); 7209 } 7210 public OptionTagStartContext optionTagStart(int i) { 7211 return getRuleContext(OptionTagStartContext.class,i); 7212 } 7213 public List<TbodyTagStartContext> tbodyTagStart() { 7214 return getRuleContexts(TbodyTagStartContext.class); 7215 } 7216 public TbodyTagStartContext tbodyTagStart(int i) { 7217 return getRuleContext(TbodyTagStartContext.class,i); 7218 } 7219 public List<TheadTagStartContext> theadTagStart() { 7220 return getRuleContexts(TheadTagStartContext.class); 7221 } 7222 public TheadTagStartContext theadTagStart(int i) { 7223 return getRuleContext(TheadTagStartContext.class,i); 7224 } 7225 public List<TfootTagStartContext> tfootTagStart() { 7226 return getRuleContexts(TfootTagStartContext.class); 7227 } 7228 public TfootTagStartContext tfootTagStart(int i) { 7229 return getRuleContext(TfootTagStartContext.class,i); 7230 } 7231 public List<OptgroupTagStartContext> optgroupTagStart() { 7232 return getRuleContexts(OptgroupTagStartContext.class); 7233 } 7234 public OptgroupTagStartContext optgroupTagStart(int i) { 7235 return getRuleContext(OptgroupTagStartContext.class,i); 7236 } 7237 public List<RbTagStartContext> rbTagStart() { 7238 return getRuleContexts(RbTagStartContext.class); 7239 } 7240 public RbTagStartContext rbTagStart(int i) { 7241 return getRuleContext(RbTagStartContext.class,i); 7242 } 7243 public List<RtTagStartContext> rtTagStart() { 7244 return getRuleContexts(RtTagStartContext.class); 7245 } 7246 public RtTagStartContext rtTagStart(int i) { 7247 return getRuleContext(RtTagStartContext.class,i); 7248 } 7249 public List<RtcTagStartContext> rtcTagStart() { 7250 return getRuleContexts(RtcTagStartContext.class); 7251 } 7252 public RtcTagStartContext rtcTagStart(int i) { 7253 return getRuleContext(RtcTagStartContext.class,i); 7254 } 7255 public List<RpTagStartContext> rpTagStart() { 7256 return getRuleContexts(RpTagStartContext.class); 7257 } 7258 public RpTagStartContext rpTagStart(int i) { 7259 return getRuleContext(RpTagStartContext.class,i); 7260 } 7261 public List<HtmlCommentContext> htmlComment() { 7262 return getRuleContexts(HtmlCommentContext.class); 7263 } 7264 public HtmlCommentContext htmlComment(int i) { 7265 return getRuleContext(HtmlCommentContext.class,i); 7266 } 7267 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7268 public TerminalNode NEWLINE(int i) { 7269 return getToken(JavadocParser.NEWLINE, i); 7270 } 7271 public List<TextContext> text() { 7272 return getRuleContexts(TextContext.class); 7273 } 7274 public TextContext text(int i) { 7275 return getRuleContext(TextContext.class,i); 7276 } 7277 public List<JavadocInlineTagContext> javadocInlineTag() { 7278 return getRuleContexts(JavadocInlineTagContext.class); 7279 } 7280 public JavadocInlineTagContext javadocInlineTag(int i) { 7281 return getRuleContext(JavadocInlineTagContext.class,i); 7282 } 7283 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7284 public TerminalNode LEADING_ASTERISK(int i) { 7285 return getToken(JavadocParser.LEADING_ASTERISK, i); 7286 } 7287 public DdContext(ParserRuleContext parent, int invokingState) { 7288 super(parent, invokingState); 7289 } 7290 @Override public int getRuleIndex() { return RULE_dd; } 7291 } 7292 7293 public final DdContext dd() throws RecognitionException { 7294 DdContext _localctx = new DdContext(_ctx, getState()); 7295 enterRule(_localctx, 58, RULE_dd); 7296 try { 7297 int _alt; 7298 enterOuterAlt(_localctx, 1); 7299 { 7300 setState(912); 7301 ddTagStart(false); 7302 setState(961); 7303 _errHandler.sync(this); 7304 _alt = getInterpreter().adaptivePredict(_input,53,_ctx); 7305 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 7306 if ( _alt==1 ) { 7307 { 7308 setState(959); 7309 _errHandler.sync(this); 7310 switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) { 7311 case 1: 7312 { 7313 setState(913); 7314 htmlTag(); 7315 } 7316 break; 7317 case 2: 7318 { 7319 setState(914); 7320 singletonElement(); 7321 } 7322 break; 7323 case 3: 7324 { 7325 setState(915); 7326 paragraph(); 7327 } 7328 break; 7329 case 4: 7330 { 7331 setState(916); 7332 li(); 7333 } 7334 break; 7335 case 5: 7336 { 7337 setState(917); 7338 tr(); 7339 } 7340 break; 7341 case 6: 7342 { 7343 setState(918); 7344 td(); 7345 } 7346 break; 7347 case 7: 7348 { 7349 setState(919); 7350 th(); 7351 } 7352 break; 7353 case 8: 7354 { 7355 setState(920); 7356 body(); 7357 } 7358 break; 7359 case 9: 7360 { 7361 setState(921); 7362 colgroup(); 7363 } 7364 break; 7365 case 10: 7366 { 7367 setState(922); 7368 dt(); 7369 } 7370 break; 7371 case 11: 7372 { 7373 setState(923); 7374 head(); 7375 } 7376 break; 7377 case 12: 7378 { 7379 setState(924); 7380 html(); 7381 } 7382 break; 7383 case 13: 7384 { 7385 setState(925); 7386 option(); 7387 } 7388 break; 7389 case 14: 7390 { 7391 setState(926); 7392 tbody(); 7393 } 7394 break; 7395 case 15: 7396 { 7397 setState(927); 7398 thead(); 7399 } 7400 break; 7401 case 16: 7402 { 7403 setState(928); 7404 tfoot(); 7405 } 7406 break; 7407 case 17: 7408 { 7409 setState(929); 7410 optgroup(); 7411 } 7412 break; 7413 case 18: 7414 { 7415 setState(930); 7416 rb(); 7417 } 7418 break; 7419 case 19: 7420 { 7421 setState(931); 7422 rt(); 7423 } 7424 break; 7425 case 20: 7426 { 7427 setState(932); 7428 rtc(); 7429 } 7430 break; 7431 case 21: 7432 { 7433 setState(933); 7434 rp(); 7435 } 7436 break; 7437 case 22: 7438 { 7439 setState(934); 7440 pTagStart(true); 7441 } 7442 break; 7443 case 23: 7444 { 7445 setState(935); 7446 liTagStart(true); 7447 } 7448 break; 7449 case 24: 7450 { 7451 setState(936); 7452 trTagStart(true); 7453 } 7454 break; 7455 case 25: 7456 { 7457 setState(937); 7458 tdTagStart(true); 7459 } 7460 break; 7461 case 26: 7462 { 7463 setState(938); 7464 thTagStart(true); 7465 } 7466 break; 7467 case 27: 7468 { 7469 setState(939); 7470 bodyTagStart(true); 7471 } 7472 break; 7473 case 28: 7474 { 7475 setState(940); 7476 colgroupTagStart(true); 7477 } 7478 break; 7479 case 29: 7480 { 7481 setState(941); 7482 dtTagStart(true); 7483 } 7484 break; 7485 case 30: 7486 { 7487 setState(942); 7488 headTagStart(true); 7489 } 7490 break; 7491 case 31: 7492 { 7493 setState(943); 7494 htmlTagStart(true); 7495 } 7496 break; 7497 case 32: 7498 { 7499 setState(944); 7500 optionTagStart(true); 7501 } 7502 break; 7503 case 33: 7504 { 7505 setState(945); 7506 tbodyTagStart(true); 7507 } 7508 break; 7509 case 34: 7510 { 7511 setState(946); 7512 theadTagStart(true); 7513 } 7514 break; 7515 case 35: 7516 { 7517 setState(947); 7518 tfootTagStart(true); 7519 } 7520 break; 7521 case 36: 7522 { 7523 setState(948); 7524 optgroupTagStart(true); 7525 } 7526 break; 7527 case 37: 7528 { 7529 setState(949); 7530 rbTagStart(true); 7531 } 7532 break; 7533 case 38: 7534 { 7535 setState(950); 7536 rtTagStart(true); 7537 } 7538 break; 7539 case 39: 7540 { 7541 setState(951); 7542 rtcTagStart(true); 7543 } 7544 break; 7545 case 40: 7546 { 7547 setState(952); 7548 rpTagStart(true); 7549 } 7550 break; 7551 case 41: 7552 { 7553 { 7554 setState(953); 7555 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 7556 setState(954); 7557 match(LEADING_ASTERISK); 7558 } 7559 } 7560 break; 7561 case 42: 7562 { 7563 setState(955); 7564 htmlComment(); 7565 } 7566 break; 7567 case 43: 7568 { 7569 setState(956); 7570 match(NEWLINE); 7571 } 7572 break; 7573 case 44: 7574 { 7575 setState(957); 7576 text(); 7577 } 7578 break; 7579 case 45: 7580 { 7581 setState(958); 7582 javadocInlineTag(); 7583 } 7584 break; 7585 } 7586 } 7587 } 7588 setState(963); 7589 _errHandler.sync(this); 7590 _alt = getInterpreter().adaptivePredict(_input,53,_ctx); 7591 } 7592 setState(964); 7593 ddTagEnd(); 7594 } 7595 } 7596 catch (RecognitionException re) { 7597 _localctx.exception = re; 7598 _errHandler.reportError(this, re); 7599 _errHandler.recover(this, re); 7600 } 7601 finally { 7602 exitRule(); 7603 } 7604 return _localctx; 7605 } 7606 7607 public static class DtTagStartContext extends ParserRuleContext { 7608 public boolean isNonTight; 7609 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 7610 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 7611 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 7612 public List<AttributeContext> attribute() { 7613 return getRuleContexts(AttributeContext.class); 7614 } 7615 public AttributeContext attribute(int i) { 7616 return getRuleContext(AttributeContext.class,i); 7617 } 7618 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7619 public TerminalNode NEWLINE(int i) { 7620 return getToken(JavadocParser.NEWLINE, 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 List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7627 public TerminalNode WS(int i) { 7628 return getToken(JavadocParser.WS, i); 7629 } 7630 public DtTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 7631 public DtTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 7632 super(parent, invokingState); 7633 this.isNonTight = isNonTight; 7634 } 7635 @Override public int getRuleIndex() { return RULE_dtTagStart; } 7636 } 7637 7638 public final DtTagStartContext dtTagStart(boolean isNonTight) throws RecognitionException { 7639 DtTagStartContext _localctx = new DtTagStartContext(_ctx, getState(), isNonTight); 7640 enterRule(_localctx, 60, RULE_dtTagStart); 7641 int _la; 7642 try { 7643 enterOuterAlt(_localctx, 1); 7644 { 7645 setState(966); 7646 match(START); 7647 setState(967); 7648 match(DT_HTML_TAG_NAME); 7649 setState(974); 7650 _errHandler.sync(this); 7651 _la = _input.LA(1); 7652 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 7653 { 7654 setState(972); 7655 _errHandler.sync(this); 7656 switch (_input.LA(1)) { 7657 case HTML_TAG_NAME: 7658 { 7659 setState(968); 7660 attribute(); 7661 } 7662 break; 7663 case NEWLINE: 7664 { 7665 setState(969); 7666 match(NEWLINE); 7667 } 7668 break; 7669 case LEADING_ASTERISK: 7670 { 7671 setState(970); 7672 match(LEADING_ASTERISK); 7673 } 7674 break; 7675 case WS: 7676 { 7677 setState(971); 7678 match(WS); 7679 } 7680 break; 7681 default: 7682 throw new NoViableAltException(this); 7683 } 7684 } 7685 setState(976); 7686 _errHandler.sync(this); 7687 _la = _input.LA(1); 7688 } 7689 setState(977); 7690 match(END); 7691 } 7692 _ctx.stop = _input.LT(-1); 7693 7694 if (isNonTight && nonTightTagStartContext == null) { 7695 nonTightTagStartContext = _localctx; 7696 } 7697 7698 } 7699 catch (RecognitionException re) { 7700 _localctx.exception = re; 7701 _errHandler.reportError(this, re); 7702 _errHandler.recover(this, re); 7703 } 7704 finally { 7705 exitRule(); 7706 } 7707 return _localctx; 7708 } 7709 7710 public static class DtTagEndContext extends ParserRuleContext { 7711 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 7712 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7713 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 7714 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 7715 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7716 public TerminalNode NEWLINE(int i) { 7717 return getToken(JavadocParser.NEWLINE, i); 7718 } 7719 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7720 public TerminalNode LEADING_ASTERISK(int i) { 7721 return getToken(JavadocParser.LEADING_ASTERISK, i); 7722 } 7723 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7724 public TerminalNode WS(int i) { 7725 return getToken(JavadocParser.WS, i); 7726 } 7727 public DtTagEndContext(ParserRuleContext parent, int invokingState) { 7728 super(parent, invokingState); 7729 } 7730 @Override public int getRuleIndex() { return RULE_dtTagEnd; } 7731 } 7732 7733 public final DtTagEndContext dtTagEnd() throws RecognitionException { 7734 DtTagEndContext _localctx = new DtTagEndContext(_ctx, getState()); 7735 enterRule(_localctx, 62, RULE_dtTagEnd); 7736 int _la; 7737 try { 7738 enterOuterAlt(_localctx, 1); 7739 { 7740 setState(979); 7741 match(START); 7742 setState(980); 7743 match(SLASH); 7744 setState(981); 7745 match(DT_HTML_TAG_NAME); 7746 setState(985); 7747 _errHandler.sync(this); 7748 _la = _input.LA(1); 7749 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7750 { 7751 { 7752 setState(982); 7753 _la = _input.LA(1); 7754 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7755 _errHandler.recoverInline(this); 7756 } 7757 else { 7758 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 7759 _errHandler.reportMatch(this); 7760 consume(); 7761 } 7762 } 7763 } 7764 setState(987); 7765 _errHandler.sync(this); 7766 _la = _input.LA(1); 7767 } 7768 setState(988); 7769 match(END); 7770 } 7771 } 7772 catch (RecognitionException re) { 7773 _localctx.exception = re; 7774 _errHandler.reportError(this, re); 7775 _errHandler.recover(this, re); 7776 } 7777 finally { 7778 exitRule(); 7779 } 7780 return _localctx; 7781 } 7782 7783 public static class DtContext extends ParserRuleContext { 7784 public DtTagStartContext dtTagStart() { 7785 return getRuleContext(DtTagStartContext.class,0); 7786 } 7787 public DtTagEndContext dtTagEnd() { 7788 return getRuleContext(DtTagEndContext.class,0); 7789 } 7790 public List<HtmlTagContext> htmlTag() { 7791 return getRuleContexts(HtmlTagContext.class); 7792 } 7793 public HtmlTagContext htmlTag(int i) { 7794 return getRuleContext(HtmlTagContext.class,i); 7795 } 7796 public List<SingletonElementContext> singletonElement() { 7797 return getRuleContexts(SingletonElementContext.class); 7798 } 7799 public SingletonElementContext singletonElement(int i) { 7800 return getRuleContext(SingletonElementContext.class,i); 7801 } 7802 public List<ParagraphContext> paragraph() { 7803 return getRuleContexts(ParagraphContext.class); 7804 } 7805 public ParagraphContext paragraph(int i) { 7806 return getRuleContext(ParagraphContext.class,i); 7807 } 7808 public List<LiContext> li() { 7809 return getRuleContexts(LiContext.class); 7810 } 7811 public LiContext li(int i) { 7812 return getRuleContext(LiContext.class,i); 7813 } 7814 public List<TrContext> tr() { 7815 return getRuleContexts(TrContext.class); 7816 } 7817 public TrContext tr(int i) { 7818 return getRuleContext(TrContext.class,i); 7819 } 7820 public List<TdContext> td() { 7821 return getRuleContexts(TdContext.class); 7822 } 7823 public TdContext td(int i) { 7824 return getRuleContext(TdContext.class,i); 7825 } 7826 public List<ThContext> th() { 7827 return getRuleContexts(ThContext.class); 7828 } 7829 public ThContext th(int i) { 7830 return getRuleContext(ThContext.class,i); 7831 } 7832 public List<BodyContext> body() { 7833 return getRuleContexts(BodyContext.class); 7834 } 7835 public BodyContext body(int i) { 7836 return getRuleContext(BodyContext.class,i); 7837 } 7838 public List<ColgroupContext> colgroup() { 7839 return getRuleContexts(ColgroupContext.class); 7840 } 7841 public ColgroupContext colgroup(int i) { 7842 return getRuleContext(ColgroupContext.class,i); 7843 } 7844 public List<DdContext> dd() { 7845 return getRuleContexts(DdContext.class); 7846 } 7847 public DdContext dd(int i) { 7848 return getRuleContext(DdContext.class,i); 7849 } 7850 public List<HeadContext> head() { 7851 return getRuleContexts(HeadContext.class); 7852 } 7853 public HeadContext head(int i) { 7854 return getRuleContext(HeadContext.class,i); 7855 } 7856 public List<HtmlContext> html() { 7857 return getRuleContexts(HtmlContext.class); 7858 } 7859 public HtmlContext html(int i) { 7860 return getRuleContext(HtmlContext.class,i); 7861 } 7862 public List<OptionContext> option() { 7863 return getRuleContexts(OptionContext.class); 7864 } 7865 public OptionContext option(int i) { 7866 return getRuleContext(OptionContext.class,i); 7867 } 7868 public List<TbodyContext> tbody() { 7869 return getRuleContexts(TbodyContext.class); 7870 } 7871 public TbodyContext tbody(int i) { 7872 return getRuleContext(TbodyContext.class,i); 7873 } 7874 public List<TheadContext> thead() { 7875 return getRuleContexts(TheadContext.class); 7876 } 7877 public TheadContext thead(int i) { 7878 return getRuleContext(TheadContext.class,i); 7879 } 7880 public List<TfootContext> tfoot() { 7881 return getRuleContexts(TfootContext.class); 7882 } 7883 public TfootContext tfoot(int i) { 7884 return getRuleContext(TfootContext.class,i); 7885 } 7886 public List<OptgroupContext> optgroup() { 7887 return getRuleContexts(OptgroupContext.class); 7888 } 7889 public OptgroupContext optgroup(int i) { 7890 return getRuleContext(OptgroupContext.class,i); 7891 } 7892 public List<RbContext> rb() { 7893 return getRuleContexts(RbContext.class); 7894 } 7895 public RbContext rb(int i) { 7896 return getRuleContext(RbContext.class,i); 7897 } 7898 public List<RtContext> rt() { 7899 return getRuleContexts(RtContext.class); 7900 } 7901 public RtContext rt(int i) { 7902 return getRuleContext(RtContext.class,i); 7903 } 7904 public List<RtcContext> rtc() { 7905 return getRuleContexts(RtcContext.class); 7906 } 7907 public RtcContext rtc(int i) { 7908 return getRuleContext(RtcContext.class,i); 7909 } 7910 public List<RpContext> rp() { 7911 return getRuleContexts(RpContext.class); 7912 } 7913 public RpContext rp(int i) { 7914 return getRuleContext(RpContext.class,i); 7915 } 7916 public List<PTagStartContext> pTagStart() { 7917 return getRuleContexts(PTagStartContext.class); 7918 } 7919 public PTagStartContext pTagStart(int i) { 7920 return getRuleContext(PTagStartContext.class,i); 7921 } 7922 public List<LiTagStartContext> liTagStart() { 7923 return getRuleContexts(LiTagStartContext.class); 7924 } 7925 public LiTagStartContext liTagStart(int i) { 7926 return getRuleContext(LiTagStartContext.class,i); 7927 } 7928 public List<TrTagStartContext> trTagStart() { 7929 return getRuleContexts(TrTagStartContext.class); 7930 } 7931 public TrTagStartContext trTagStart(int i) { 7932 return getRuleContext(TrTagStartContext.class,i); 7933 } 7934 public List<TdTagStartContext> tdTagStart() { 7935 return getRuleContexts(TdTagStartContext.class); 7936 } 7937 public TdTagStartContext tdTagStart(int i) { 7938 return getRuleContext(TdTagStartContext.class,i); 7939 } 7940 public List<ThTagStartContext> thTagStart() { 7941 return getRuleContexts(ThTagStartContext.class); 7942 } 7943 public ThTagStartContext thTagStart(int i) { 7944 return getRuleContext(ThTagStartContext.class,i); 7945 } 7946 public List<BodyTagStartContext> bodyTagStart() { 7947 return getRuleContexts(BodyTagStartContext.class); 7948 } 7949 public BodyTagStartContext bodyTagStart(int i) { 7950 return getRuleContext(BodyTagStartContext.class,i); 7951 } 7952 public List<ColgroupTagStartContext> colgroupTagStart() { 7953 return getRuleContexts(ColgroupTagStartContext.class); 7954 } 7955 public ColgroupTagStartContext colgroupTagStart(int i) { 7956 return getRuleContext(ColgroupTagStartContext.class,i); 7957 } 7958 public List<DdTagStartContext> ddTagStart() { 7959 return getRuleContexts(DdTagStartContext.class); 7960 } 7961 public DdTagStartContext ddTagStart(int i) { 7962 return getRuleContext(DdTagStartContext.class,i); 7963 } 7964 public List<HeadTagStartContext> headTagStart() { 7965 return getRuleContexts(HeadTagStartContext.class); 7966 } 7967 public HeadTagStartContext headTagStart(int i) { 7968 return getRuleContext(HeadTagStartContext.class,i); 7969 } 7970 public List<HtmlTagStartContext> htmlTagStart() { 7971 return getRuleContexts(HtmlTagStartContext.class); 7972 } 7973 public HtmlTagStartContext htmlTagStart(int i) { 7974 return getRuleContext(HtmlTagStartContext.class,i); 7975 } 7976 public List<OptionTagStartContext> optionTagStart() { 7977 return getRuleContexts(OptionTagStartContext.class); 7978 } 7979 public OptionTagStartContext optionTagStart(int i) { 7980 return getRuleContext(OptionTagStartContext.class,i); 7981 } 7982 public List<TbodyTagStartContext> tbodyTagStart() { 7983 return getRuleContexts(TbodyTagStartContext.class); 7984 } 7985 public TbodyTagStartContext tbodyTagStart(int i) { 7986 return getRuleContext(TbodyTagStartContext.class,i); 7987 } 7988 public List<TheadTagStartContext> theadTagStart() { 7989 return getRuleContexts(TheadTagStartContext.class); 7990 } 7991 public TheadTagStartContext theadTagStart(int i) { 7992 return getRuleContext(TheadTagStartContext.class,i); 7993 } 7994 public List<TfootTagStartContext> tfootTagStart() { 7995 return getRuleContexts(TfootTagStartContext.class); 7996 } 7997 public TfootTagStartContext tfootTagStart(int i) { 7998 return getRuleContext(TfootTagStartContext.class,i); 7999 } 8000 public List<OptgroupTagStartContext> optgroupTagStart() { 8001 return getRuleContexts(OptgroupTagStartContext.class); 8002 } 8003 public OptgroupTagStartContext optgroupTagStart(int i) { 8004 return getRuleContext(OptgroupTagStartContext.class,i); 8005 } 8006 public List<RbTagStartContext> rbTagStart() { 8007 return getRuleContexts(RbTagStartContext.class); 8008 } 8009 public RbTagStartContext rbTagStart(int i) { 8010 return getRuleContext(RbTagStartContext.class,i); 8011 } 8012 public List<RtTagStartContext> rtTagStart() { 8013 return getRuleContexts(RtTagStartContext.class); 8014 } 8015 public RtTagStartContext rtTagStart(int i) { 8016 return getRuleContext(RtTagStartContext.class,i); 8017 } 8018 public List<RtcTagStartContext> rtcTagStart() { 8019 return getRuleContexts(RtcTagStartContext.class); 8020 } 8021 public RtcTagStartContext rtcTagStart(int i) { 8022 return getRuleContext(RtcTagStartContext.class,i); 8023 } 8024 public List<RpTagStartContext> rpTagStart() { 8025 return getRuleContexts(RpTagStartContext.class); 8026 } 8027 public RpTagStartContext rpTagStart(int i) { 8028 return getRuleContext(RpTagStartContext.class,i); 8029 } 8030 public List<HtmlCommentContext> htmlComment() { 8031 return getRuleContexts(HtmlCommentContext.class); 8032 } 8033 public HtmlCommentContext htmlComment(int i) { 8034 return getRuleContext(HtmlCommentContext.class,i); 8035 } 8036 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8037 public TerminalNode NEWLINE(int i) { 8038 return getToken(JavadocParser.NEWLINE, i); 8039 } 8040 public List<TextContext> text() { 8041 return getRuleContexts(TextContext.class); 8042 } 8043 public TextContext text(int i) { 8044 return getRuleContext(TextContext.class,i); 8045 } 8046 public List<JavadocInlineTagContext> javadocInlineTag() { 8047 return getRuleContexts(JavadocInlineTagContext.class); 8048 } 8049 public JavadocInlineTagContext javadocInlineTag(int i) { 8050 return getRuleContext(JavadocInlineTagContext.class,i); 8051 } 8052 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8053 public TerminalNode LEADING_ASTERISK(int i) { 8054 return getToken(JavadocParser.LEADING_ASTERISK, i); 8055 } 8056 public DtContext(ParserRuleContext parent, int invokingState) { 8057 super(parent, invokingState); 8058 } 8059 @Override public int getRuleIndex() { return RULE_dt; } 8060 } 8061 8062 public final DtContext dt() throws RecognitionException { 8063 DtContext _localctx = new DtContext(_ctx, getState()); 8064 enterRule(_localctx, 64, RULE_dt); 8065 try { 8066 int _alt; 8067 enterOuterAlt(_localctx, 1); 8068 { 8069 setState(990); 8070 dtTagStart(false); 8071 setState(1039); 8072 _errHandler.sync(this); 8073 _alt = getInterpreter().adaptivePredict(_input,58,_ctx); 8074 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8075 if ( _alt==1 ) { 8076 { 8077 setState(1037); 8078 _errHandler.sync(this); 8079 switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) { 8080 case 1: 8081 { 8082 setState(991); 8083 htmlTag(); 8084 } 8085 break; 8086 case 2: 8087 { 8088 setState(992); 8089 singletonElement(); 8090 } 8091 break; 8092 case 3: 8093 { 8094 setState(993); 8095 paragraph(); 8096 } 8097 break; 8098 case 4: 8099 { 8100 setState(994); 8101 li(); 8102 } 8103 break; 8104 case 5: 8105 { 8106 setState(995); 8107 tr(); 8108 } 8109 break; 8110 case 6: 8111 { 8112 setState(996); 8113 td(); 8114 } 8115 break; 8116 case 7: 8117 { 8118 setState(997); 8119 th(); 8120 } 8121 break; 8122 case 8: 8123 { 8124 setState(998); 8125 body(); 8126 } 8127 break; 8128 case 9: 8129 { 8130 setState(999); 8131 colgroup(); 8132 } 8133 break; 8134 case 10: 8135 { 8136 setState(1000); 8137 dd(); 8138 } 8139 break; 8140 case 11: 8141 { 8142 setState(1001); 8143 head(); 8144 } 8145 break; 8146 case 12: 8147 { 8148 setState(1002); 8149 html(); 8150 } 8151 break; 8152 case 13: 8153 { 8154 setState(1003); 8155 option(); 8156 } 8157 break; 8158 case 14: 8159 { 8160 setState(1004); 8161 tbody(); 8162 } 8163 break; 8164 case 15: 8165 { 8166 setState(1005); 8167 thead(); 8168 } 8169 break; 8170 case 16: 8171 { 8172 setState(1006); 8173 tfoot(); 8174 } 8175 break; 8176 case 17: 8177 { 8178 setState(1007); 8179 optgroup(); 8180 } 8181 break; 8182 case 18: 8183 { 8184 setState(1008); 8185 rb(); 8186 } 8187 break; 8188 case 19: 8189 { 8190 setState(1009); 8191 rt(); 8192 } 8193 break; 8194 case 20: 8195 { 8196 setState(1010); 8197 rtc(); 8198 } 8199 break; 8200 case 21: 8201 { 8202 setState(1011); 8203 rp(); 8204 } 8205 break; 8206 case 22: 8207 { 8208 setState(1012); 8209 pTagStart(true); 8210 } 8211 break; 8212 case 23: 8213 { 8214 setState(1013); 8215 liTagStart(true); 8216 } 8217 break; 8218 case 24: 8219 { 8220 setState(1014); 8221 trTagStart(true); 8222 } 8223 break; 8224 case 25: 8225 { 8226 setState(1015); 8227 tdTagStart(true); 8228 } 8229 break; 8230 case 26: 8231 { 8232 setState(1016); 8233 thTagStart(true); 8234 } 8235 break; 8236 case 27: 8237 { 8238 setState(1017); 8239 bodyTagStart(true); 8240 } 8241 break; 8242 case 28: 8243 { 8244 setState(1018); 8245 colgroupTagStart(true); 8246 } 8247 break; 8248 case 29: 8249 { 8250 setState(1019); 8251 ddTagStart(true); 8252 } 8253 break; 8254 case 30: 8255 { 8256 setState(1020); 8257 headTagStart(true); 8258 } 8259 break; 8260 case 31: 8261 { 8262 setState(1021); 8263 htmlTagStart(true); 8264 } 8265 break; 8266 case 32: 8267 { 8268 setState(1022); 8269 optionTagStart(true); 8270 } 8271 break; 8272 case 33: 8273 { 8274 setState(1023); 8275 tbodyTagStart(true); 8276 } 8277 break; 8278 case 34: 8279 { 8280 setState(1024); 8281 theadTagStart(true); 8282 } 8283 break; 8284 case 35: 8285 { 8286 setState(1025); 8287 tfootTagStart(true); 8288 } 8289 break; 8290 case 36: 8291 { 8292 setState(1026); 8293 optgroupTagStart(true); 8294 } 8295 break; 8296 case 37: 8297 { 8298 setState(1027); 8299 rbTagStart(true); 8300 } 8301 break; 8302 case 38: 8303 { 8304 setState(1028); 8305 rtTagStart(true); 8306 } 8307 break; 8308 case 39: 8309 { 8310 setState(1029); 8311 rtcTagStart(true); 8312 } 8313 break; 8314 case 40: 8315 { 8316 setState(1030); 8317 rpTagStart(true); 8318 } 8319 break; 8320 case 41: 8321 { 8322 { 8323 setState(1031); 8324 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8325 setState(1032); 8326 match(LEADING_ASTERISK); 8327 } 8328 } 8329 break; 8330 case 42: 8331 { 8332 setState(1033); 8333 htmlComment(); 8334 } 8335 break; 8336 case 43: 8337 { 8338 setState(1034); 8339 match(NEWLINE); 8340 } 8341 break; 8342 case 44: 8343 { 8344 setState(1035); 8345 text(); 8346 } 8347 break; 8348 case 45: 8349 { 8350 setState(1036); 8351 javadocInlineTag(); 8352 } 8353 break; 8354 } 8355 } 8356 } 8357 setState(1041); 8358 _errHandler.sync(this); 8359 _alt = getInterpreter().adaptivePredict(_input,58,_ctx); 8360 } 8361 setState(1042); 8362 dtTagEnd(); 8363 } 8364 } 8365 catch (RecognitionException re) { 8366 _localctx.exception = re; 8367 _errHandler.reportError(this, re); 8368 _errHandler.recover(this, re); 8369 } 8370 finally { 8371 exitRule(); 8372 } 8373 return _localctx; 8374 } 8375 8376 public static class HeadTagStartContext extends ParserRuleContext { 8377 public boolean isNonTight; 8378 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 8379 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 8380 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 8381 public List<AttributeContext> attribute() { 8382 return getRuleContexts(AttributeContext.class); 8383 } 8384 public AttributeContext attribute(int i) { 8385 return getRuleContext(AttributeContext.class,i); 8386 } 8387 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8388 public TerminalNode NEWLINE(int i) { 8389 return getToken(JavadocParser.NEWLINE, i); 8390 } 8391 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8392 public TerminalNode LEADING_ASTERISK(int i) { 8393 return getToken(JavadocParser.LEADING_ASTERISK, i); 8394 } 8395 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8396 public TerminalNode WS(int i) { 8397 return getToken(JavadocParser.WS, i); 8398 } 8399 public HeadTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 8400 public HeadTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 8401 super(parent, invokingState); 8402 this.isNonTight = isNonTight; 8403 } 8404 @Override public int getRuleIndex() { return RULE_headTagStart; } 8405 } 8406 8407 public final HeadTagStartContext headTagStart(boolean isNonTight) throws RecognitionException { 8408 HeadTagStartContext _localctx = new HeadTagStartContext(_ctx, getState(), isNonTight); 8409 enterRule(_localctx, 66, RULE_headTagStart); 8410 int _la; 8411 try { 8412 enterOuterAlt(_localctx, 1); 8413 { 8414 setState(1044); 8415 match(START); 8416 setState(1045); 8417 match(HEAD_HTML_TAG_NAME); 8418 setState(1052); 8419 _errHandler.sync(this); 8420 _la = _input.LA(1); 8421 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 8422 { 8423 setState(1050); 8424 _errHandler.sync(this); 8425 switch (_input.LA(1)) { 8426 case HTML_TAG_NAME: 8427 { 8428 setState(1046); 8429 attribute(); 8430 } 8431 break; 8432 case NEWLINE: 8433 { 8434 setState(1047); 8435 match(NEWLINE); 8436 } 8437 break; 8438 case LEADING_ASTERISK: 8439 { 8440 setState(1048); 8441 match(LEADING_ASTERISK); 8442 } 8443 break; 8444 case WS: 8445 { 8446 setState(1049); 8447 match(WS); 8448 } 8449 break; 8450 default: 8451 throw new NoViableAltException(this); 8452 } 8453 } 8454 setState(1054); 8455 _errHandler.sync(this); 8456 _la = _input.LA(1); 8457 } 8458 setState(1055); 8459 match(END); 8460 } 8461 _ctx.stop = _input.LT(-1); 8462 8463 if (isNonTight && nonTightTagStartContext == null) { 8464 nonTightTagStartContext = _localctx; 8465 } 8466 8467 } 8468 catch (RecognitionException re) { 8469 _localctx.exception = re; 8470 _errHandler.reportError(this, re); 8471 _errHandler.recover(this, re); 8472 } 8473 finally { 8474 exitRule(); 8475 } 8476 return _localctx; 8477 } 8478 8479 public static class HeadTagEndContext extends ParserRuleContext { 8480 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 8481 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 8482 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 8483 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 8484 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8485 public TerminalNode NEWLINE(int i) { 8486 return getToken(JavadocParser.NEWLINE, i); 8487 } 8488 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8489 public TerminalNode LEADING_ASTERISK(int i) { 8490 return getToken(JavadocParser.LEADING_ASTERISK, i); 8491 } 8492 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8493 public TerminalNode WS(int i) { 8494 return getToken(JavadocParser.WS, i); 8495 } 8496 public HeadTagEndContext(ParserRuleContext parent, int invokingState) { 8497 super(parent, invokingState); 8498 } 8499 @Override public int getRuleIndex() { return RULE_headTagEnd; } 8500 } 8501 8502 public final HeadTagEndContext headTagEnd() throws RecognitionException { 8503 HeadTagEndContext _localctx = new HeadTagEndContext(_ctx, getState()); 8504 enterRule(_localctx, 68, RULE_headTagEnd); 8505 int _la; 8506 try { 8507 enterOuterAlt(_localctx, 1); 8508 { 8509 setState(1057); 8510 match(START); 8511 setState(1058); 8512 match(SLASH); 8513 setState(1059); 8514 match(HEAD_HTML_TAG_NAME); 8515 setState(1063); 8516 _errHandler.sync(this); 8517 _la = _input.LA(1); 8518 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 8519 { 8520 { 8521 setState(1060); 8522 _la = _input.LA(1); 8523 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 8524 _errHandler.recoverInline(this); 8525 } 8526 else { 8527 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 8528 _errHandler.reportMatch(this); 8529 consume(); 8530 } 8531 } 8532 } 8533 setState(1065); 8534 _errHandler.sync(this); 8535 _la = _input.LA(1); 8536 } 8537 setState(1066); 8538 match(END); 8539 } 8540 } 8541 catch (RecognitionException re) { 8542 _localctx.exception = re; 8543 _errHandler.reportError(this, re); 8544 _errHandler.recover(this, re); 8545 } 8546 finally { 8547 exitRule(); 8548 } 8549 return _localctx; 8550 } 8551 8552 public static class HeadContext extends ParserRuleContext { 8553 public HeadTagStartContext headTagStart() { 8554 return getRuleContext(HeadTagStartContext.class,0); 8555 } 8556 public HeadTagEndContext headTagEnd() { 8557 return getRuleContext(HeadTagEndContext.class,0); 8558 } 8559 public List<HtmlTagContext> htmlTag() { 8560 return getRuleContexts(HtmlTagContext.class); 8561 } 8562 public HtmlTagContext htmlTag(int i) { 8563 return getRuleContext(HtmlTagContext.class,i); 8564 } 8565 public List<SingletonElementContext> singletonElement() { 8566 return getRuleContexts(SingletonElementContext.class); 8567 } 8568 public SingletonElementContext singletonElement(int i) { 8569 return getRuleContext(SingletonElementContext.class,i); 8570 } 8571 public List<ParagraphContext> paragraph() { 8572 return getRuleContexts(ParagraphContext.class); 8573 } 8574 public ParagraphContext paragraph(int i) { 8575 return getRuleContext(ParagraphContext.class,i); 8576 } 8577 public List<LiContext> li() { 8578 return getRuleContexts(LiContext.class); 8579 } 8580 public LiContext li(int i) { 8581 return getRuleContext(LiContext.class,i); 8582 } 8583 public List<TrContext> tr() { 8584 return getRuleContexts(TrContext.class); 8585 } 8586 public TrContext tr(int i) { 8587 return getRuleContext(TrContext.class,i); 8588 } 8589 public List<TdContext> td() { 8590 return getRuleContexts(TdContext.class); 8591 } 8592 public TdContext td(int i) { 8593 return getRuleContext(TdContext.class,i); 8594 } 8595 public List<ThContext> th() { 8596 return getRuleContexts(ThContext.class); 8597 } 8598 public ThContext th(int i) { 8599 return getRuleContext(ThContext.class,i); 8600 } 8601 public List<BodyContext> body() { 8602 return getRuleContexts(BodyContext.class); 8603 } 8604 public BodyContext body(int i) { 8605 return getRuleContext(BodyContext.class,i); 8606 } 8607 public List<ColgroupContext> colgroup() { 8608 return getRuleContexts(ColgroupContext.class); 8609 } 8610 public ColgroupContext colgroup(int i) { 8611 return getRuleContext(ColgroupContext.class,i); 8612 } 8613 public List<DdContext> dd() { 8614 return getRuleContexts(DdContext.class); 8615 } 8616 public DdContext dd(int i) { 8617 return getRuleContext(DdContext.class,i); 8618 } 8619 public List<DtContext> dt() { 8620 return getRuleContexts(DtContext.class); 8621 } 8622 public DtContext dt(int i) { 8623 return getRuleContext(DtContext.class,i); 8624 } 8625 public List<HtmlContext> html() { 8626 return getRuleContexts(HtmlContext.class); 8627 } 8628 public HtmlContext html(int i) { 8629 return getRuleContext(HtmlContext.class,i); 8630 } 8631 public List<OptionContext> option() { 8632 return getRuleContexts(OptionContext.class); 8633 } 8634 public OptionContext option(int i) { 8635 return getRuleContext(OptionContext.class,i); 8636 } 8637 public List<TbodyContext> tbody() { 8638 return getRuleContexts(TbodyContext.class); 8639 } 8640 public TbodyContext tbody(int i) { 8641 return getRuleContext(TbodyContext.class,i); 8642 } 8643 public List<TheadContext> thead() { 8644 return getRuleContexts(TheadContext.class); 8645 } 8646 public TheadContext thead(int i) { 8647 return getRuleContext(TheadContext.class,i); 8648 } 8649 public List<TfootContext> tfoot() { 8650 return getRuleContexts(TfootContext.class); 8651 } 8652 public TfootContext tfoot(int i) { 8653 return getRuleContext(TfootContext.class,i); 8654 } 8655 public List<OptgroupContext> optgroup() { 8656 return getRuleContexts(OptgroupContext.class); 8657 } 8658 public OptgroupContext optgroup(int i) { 8659 return getRuleContext(OptgroupContext.class,i); 8660 } 8661 public List<RbContext> rb() { 8662 return getRuleContexts(RbContext.class); 8663 } 8664 public RbContext rb(int i) { 8665 return getRuleContext(RbContext.class,i); 8666 } 8667 public List<RtContext> rt() { 8668 return getRuleContexts(RtContext.class); 8669 } 8670 public RtContext rt(int i) { 8671 return getRuleContext(RtContext.class,i); 8672 } 8673 public List<RtcContext> rtc() { 8674 return getRuleContexts(RtcContext.class); 8675 } 8676 public RtcContext rtc(int i) { 8677 return getRuleContext(RtcContext.class,i); 8678 } 8679 public List<RpContext> rp() { 8680 return getRuleContexts(RpContext.class); 8681 } 8682 public RpContext rp(int i) { 8683 return getRuleContext(RpContext.class,i); 8684 } 8685 public List<PTagStartContext> pTagStart() { 8686 return getRuleContexts(PTagStartContext.class); 8687 } 8688 public PTagStartContext pTagStart(int i) { 8689 return getRuleContext(PTagStartContext.class,i); 8690 } 8691 public List<LiTagStartContext> liTagStart() { 8692 return getRuleContexts(LiTagStartContext.class); 8693 } 8694 public LiTagStartContext liTagStart(int i) { 8695 return getRuleContext(LiTagStartContext.class,i); 8696 } 8697 public List<TrTagStartContext> trTagStart() { 8698 return getRuleContexts(TrTagStartContext.class); 8699 } 8700 public TrTagStartContext trTagStart(int i) { 8701 return getRuleContext(TrTagStartContext.class,i); 8702 } 8703 public List<TdTagStartContext> tdTagStart() { 8704 return getRuleContexts(TdTagStartContext.class); 8705 } 8706 public TdTagStartContext tdTagStart(int i) { 8707 return getRuleContext(TdTagStartContext.class,i); 8708 } 8709 public List<ThTagStartContext> thTagStart() { 8710 return getRuleContexts(ThTagStartContext.class); 8711 } 8712 public ThTagStartContext thTagStart(int i) { 8713 return getRuleContext(ThTagStartContext.class,i); 8714 } 8715 public List<BodyTagStartContext> bodyTagStart() { 8716 return getRuleContexts(BodyTagStartContext.class); 8717 } 8718 public BodyTagStartContext bodyTagStart(int i) { 8719 return getRuleContext(BodyTagStartContext.class,i); 8720 } 8721 public List<ColgroupTagStartContext> colgroupTagStart() { 8722 return getRuleContexts(ColgroupTagStartContext.class); 8723 } 8724 public ColgroupTagStartContext colgroupTagStart(int i) { 8725 return getRuleContext(ColgroupTagStartContext.class,i); 8726 } 8727 public List<DdTagStartContext> ddTagStart() { 8728 return getRuleContexts(DdTagStartContext.class); 8729 } 8730 public DdTagStartContext ddTagStart(int i) { 8731 return getRuleContext(DdTagStartContext.class,i); 8732 } 8733 public List<DtTagStartContext> dtTagStart() { 8734 return getRuleContexts(DtTagStartContext.class); 8735 } 8736 public DtTagStartContext dtTagStart(int i) { 8737 return getRuleContext(DtTagStartContext.class,i); 8738 } 8739 public List<HtmlTagStartContext> htmlTagStart() { 8740 return getRuleContexts(HtmlTagStartContext.class); 8741 } 8742 public HtmlTagStartContext htmlTagStart(int i) { 8743 return getRuleContext(HtmlTagStartContext.class,i); 8744 } 8745 public List<OptionTagStartContext> optionTagStart() { 8746 return getRuleContexts(OptionTagStartContext.class); 8747 } 8748 public OptionTagStartContext optionTagStart(int i) { 8749 return getRuleContext(OptionTagStartContext.class,i); 8750 } 8751 public List<TbodyTagStartContext> tbodyTagStart() { 8752 return getRuleContexts(TbodyTagStartContext.class); 8753 } 8754 public TbodyTagStartContext tbodyTagStart(int i) { 8755 return getRuleContext(TbodyTagStartContext.class,i); 8756 } 8757 public List<TheadTagStartContext> theadTagStart() { 8758 return getRuleContexts(TheadTagStartContext.class); 8759 } 8760 public TheadTagStartContext theadTagStart(int i) { 8761 return getRuleContext(TheadTagStartContext.class,i); 8762 } 8763 public List<TfootTagStartContext> tfootTagStart() { 8764 return getRuleContexts(TfootTagStartContext.class); 8765 } 8766 public TfootTagStartContext tfootTagStart(int i) { 8767 return getRuleContext(TfootTagStartContext.class,i); 8768 } 8769 public List<OptgroupTagStartContext> optgroupTagStart() { 8770 return getRuleContexts(OptgroupTagStartContext.class); 8771 } 8772 public OptgroupTagStartContext optgroupTagStart(int i) { 8773 return getRuleContext(OptgroupTagStartContext.class,i); 8774 } 8775 public List<RbTagStartContext> rbTagStart() { 8776 return getRuleContexts(RbTagStartContext.class); 8777 } 8778 public RbTagStartContext rbTagStart(int i) { 8779 return getRuleContext(RbTagStartContext.class,i); 8780 } 8781 public List<RtTagStartContext> rtTagStart() { 8782 return getRuleContexts(RtTagStartContext.class); 8783 } 8784 public RtTagStartContext rtTagStart(int i) { 8785 return getRuleContext(RtTagStartContext.class,i); 8786 } 8787 public List<RtcTagStartContext> rtcTagStart() { 8788 return getRuleContexts(RtcTagStartContext.class); 8789 } 8790 public RtcTagStartContext rtcTagStart(int i) { 8791 return getRuleContext(RtcTagStartContext.class,i); 8792 } 8793 public List<RpTagStartContext> rpTagStart() { 8794 return getRuleContexts(RpTagStartContext.class); 8795 } 8796 public RpTagStartContext rpTagStart(int i) { 8797 return getRuleContext(RpTagStartContext.class,i); 8798 } 8799 public List<HtmlCommentContext> htmlComment() { 8800 return getRuleContexts(HtmlCommentContext.class); 8801 } 8802 public HtmlCommentContext htmlComment(int i) { 8803 return getRuleContext(HtmlCommentContext.class,i); 8804 } 8805 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8806 public TerminalNode NEWLINE(int i) { 8807 return getToken(JavadocParser.NEWLINE, i); 8808 } 8809 public List<TextContext> text() { 8810 return getRuleContexts(TextContext.class); 8811 } 8812 public TextContext text(int i) { 8813 return getRuleContext(TextContext.class,i); 8814 } 8815 public List<JavadocInlineTagContext> javadocInlineTag() { 8816 return getRuleContexts(JavadocInlineTagContext.class); 8817 } 8818 public JavadocInlineTagContext javadocInlineTag(int i) { 8819 return getRuleContext(JavadocInlineTagContext.class,i); 8820 } 8821 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8822 public TerminalNode LEADING_ASTERISK(int i) { 8823 return getToken(JavadocParser.LEADING_ASTERISK, i); 8824 } 8825 public HeadContext(ParserRuleContext parent, int invokingState) { 8826 super(parent, invokingState); 8827 } 8828 @Override public int getRuleIndex() { return RULE_head; } 8829 } 8830 8831 public final HeadContext head() throws RecognitionException { 8832 HeadContext _localctx = new HeadContext(_ctx, getState()); 8833 enterRule(_localctx, 70, RULE_head); 8834 try { 8835 int _alt; 8836 enterOuterAlt(_localctx, 1); 8837 { 8838 setState(1068); 8839 headTagStart(false); 8840 setState(1117); 8841 _errHandler.sync(this); 8842 _alt = getInterpreter().adaptivePredict(_input,63,_ctx); 8843 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8844 if ( _alt==1 ) { 8845 { 8846 setState(1115); 8847 _errHandler.sync(this); 8848 switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) { 8849 case 1: 8850 { 8851 setState(1069); 8852 htmlTag(); 8853 } 8854 break; 8855 case 2: 8856 { 8857 setState(1070); 8858 singletonElement(); 8859 } 8860 break; 8861 case 3: 8862 { 8863 setState(1071); 8864 paragraph(); 8865 } 8866 break; 8867 case 4: 8868 { 8869 setState(1072); 8870 li(); 8871 } 8872 break; 8873 case 5: 8874 { 8875 setState(1073); 8876 tr(); 8877 } 8878 break; 8879 case 6: 8880 { 8881 setState(1074); 8882 td(); 8883 } 8884 break; 8885 case 7: 8886 { 8887 setState(1075); 8888 th(); 8889 } 8890 break; 8891 case 8: 8892 { 8893 setState(1076); 8894 body(); 8895 } 8896 break; 8897 case 9: 8898 { 8899 setState(1077); 8900 colgroup(); 8901 } 8902 break; 8903 case 10: 8904 { 8905 setState(1078); 8906 dd(); 8907 } 8908 break; 8909 case 11: 8910 { 8911 setState(1079); 8912 dt(); 8913 } 8914 break; 8915 case 12: 8916 { 8917 setState(1080); 8918 html(); 8919 } 8920 break; 8921 case 13: 8922 { 8923 setState(1081); 8924 option(); 8925 } 8926 break; 8927 case 14: 8928 { 8929 setState(1082); 8930 tbody(); 8931 } 8932 break; 8933 case 15: 8934 { 8935 setState(1083); 8936 thead(); 8937 } 8938 break; 8939 case 16: 8940 { 8941 setState(1084); 8942 tfoot(); 8943 } 8944 break; 8945 case 17: 8946 { 8947 setState(1085); 8948 optgroup(); 8949 } 8950 break; 8951 case 18: 8952 { 8953 setState(1086); 8954 rb(); 8955 } 8956 break; 8957 case 19: 8958 { 8959 setState(1087); 8960 rt(); 8961 } 8962 break; 8963 case 20: 8964 { 8965 setState(1088); 8966 rtc(); 8967 } 8968 break; 8969 case 21: 8970 { 8971 setState(1089); 8972 rp(); 8973 } 8974 break; 8975 case 22: 8976 { 8977 setState(1090); 8978 pTagStart(true); 8979 } 8980 break; 8981 case 23: 8982 { 8983 setState(1091); 8984 liTagStart(true); 8985 } 8986 break; 8987 case 24: 8988 { 8989 setState(1092); 8990 trTagStart(true); 8991 } 8992 break; 8993 case 25: 8994 { 8995 setState(1093); 8996 tdTagStart(true); 8997 } 8998 break; 8999 case 26: 9000 { 9001 setState(1094); 9002 thTagStart(true); 9003 } 9004 break; 9005 case 27: 9006 { 9007 setState(1095); 9008 bodyTagStart(true); 9009 } 9010 break; 9011 case 28: 9012 { 9013 setState(1096); 9014 colgroupTagStart(true); 9015 } 9016 break; 9017 case 29: 9018 { 9019 setState(1097); 9020 ddTagStart(true); 9021 } 9022 break; 9023 case 30: 9024 { 9025 setState(1098); 9026 dtTagStart(true); 9027 } 9028 break; 9029 case 31: 9030 { 9031 setState(1099); 9032 htmlTagStart(true); 9033 } 9034 break; 9035 case 32: 9036 { 9037 setState(1100); 9038 optionTagStart(true); 9039 } 9040 break; 9041 case 33: 9042 { 9043 setState(1101); 9044 tbodyTagStart(true); 9045 } 9046 break; 9047 case 34: 9048 { 9049 setState(1102); 9050 theadTagStart(true); 9051 } 9052 break; 9053 case 35: 9054 { 9055 setState(1103); 9056 tfootTagStart(true); 9057 } 9058 break; 9059 case 36: 9060 { 9061 setState(1104); 9062 optgroupTagStart(true); 9063 } 9064 break; 9065 case 37: 9066 { 9067 setState(1105); 9068 rbTagStart(true); 9069 } 9070 break; 9071 case 38: 9072 { 9073 setState(1106); 9074 rtTagStart(true); 9075 } 9076 break; 9077 case 39: 9078 { 9079 setState(1107); 9080 rtcTagStart(true); 9081 } 9082 break; 9083 case 40: 9084 { 9085 setState(1108); 9086 rpTagStart(true); 9087 } 9088 break; 9089 case 41: 9090 { 9091 { 9092 setState(1109); 9093 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 9094 setState(1110); 9095 match(LEADING_ASTERISK); 9096 } 9097 } 9098 break; 9099 case 42: 9100 { 9101 setState(1111); 9102 htmlComment(); 9103 } 9104 break; 9105 case 43: 9106 { 9107 setState(1112); 9108 match(NEWLINE); 9109 } 9110 break; 9111 case 44: 9112 { 9113 setState(1113); 9114 text(); 9115 } 9116 break; 9117 case 45: 9118 { 9119 setState(1114); 9120 javadocInlineTag(); 9121 } 9122 break; 9123 } 9124 } 9125 } 9126 setState(1119); 9127 _errHandler.sync(this); 9128 _alt = getInterpreter().adaptivePredict(_input,63,_ctx); 9129 } 9130 setState(1120); 9131 headTagEnd(); 9132 } 9133 } 9134 catch (RecognitionException re) { 9135 _localctx.exception = re; 9136 _errHandler.reportError(this, re); 9137 _errHandler.recover(this, re); 9138 } 9139 finally { 9140 exitRule(); 9141 } 9142 return _localctx; 9143 } 9144 9145 public static class HtmlTagStartContext extends ParserRuleContext { 9146 public boolean isNonTight; 9147 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 9148 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 9149 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 9150 public List<AttributeContext> attribute() { 9151 return getRuleContexts(AttributeContext.class); 9152 } 9153 public AttributeContext attribute(int i) { 9154 return getRuleContext(AttributeContext.class,i); 9155 } 9156 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9157 public TerminalNode NEWLINE(int i) { 9158 return getToken(JavadocParser.NEWLINE, i); 9159 } 9160 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9161 public TerminalNode LEADING_ASTERISK(int i) { 9162 return getToken(JavadocParser.LEADING_ASTERISK, i); 9163 } 9164 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9165 public TerminalNode WS(int i) { 9166 return getToken(JavadocParser.WS, i); 9167 } 9168 public HtmlTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 9169 public HtmlTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 9170 super(parent, invokingState); 9171 this.isNonTight = isNonTight; 9172 } 9173 @Override public int getRuleIndex() { return RULE_htmlTagStart; } 9174 } 9175 9176 public final HtmlTagStartContext htmlTagStart(boolean isNonTight) throws RecognitionException { 9177 HtmlTagStartContext _localctx = new HtmlTagStartContext(_ctx, getState(), isNonTight); 9178 enterRule(_localctx, 72, RULE_htmlTagStart); 9179 int _la; 9180 try { 9181 enterOuterAlt(_localctx, 1); 9182 { 9183 setState(1122); 9184 match(START); 9185 setState(1123); 9186 match(HTML_HTML_TAG_NAME); 9187 setState(1130); 9188 _errHandler.sync(this); 9189 _la = _input.LA(1); 9190 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9191 { 9192 setState(1128); 9193 _errHandler.sync(this); 9194 switch (_input.LA(1)) { 9195 case HTML_TAG_NAME: 9196 { 9197 setState(1124); 9198 attribute(); 9199 } 9200 break; 9201 case NEWLINE: 9202 { 9203 setState(1125); 9204 match(NEWLINE); 9205 } 9206 break; 9207 case LEADING_ASTERISK: 9208 { 9209 setState(1126); 9210 match(LEADING_ASTERISK); 9211 } 9212 break; 9213 case WS: 9214 { 9215 setState(1127); 9216 match(WS); 9217 } 9218 break; 9219 default: 9220 throw new NoViableAltException(this); 9221 } 9222 } 9223 setState(1132); 9224 _errHandler.sync(this); 9225 _la = _input.LA(1); 9226 } 9227 setState(1133); 9228 match(END); 9229 } 9230 _ctx.stop = _input.LT(-1); 9231 9232 if (isNonTight && nonTightTagStartContext == null) { 9233 nonTightTagStartContext = _localctx; 9234 } 9235 9236 } 9237 catch (RecognitionException re) { 9238 _localctx.exception = re; 9239 _errHandler.reportError(this, re); 9240 _errHandler.recover(this, re); 9241 } 9242 finally { 9243 exitRule(); 9244 } 9245 return _localctx; 9246 } 9247 9248 public static class HtmlTagEndContext extends ParserRuleContext { 9249 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 9250 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9251 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 9252 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 9253 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9254 public TerminalNode NEWLINE(int i) { 9255 return getToken(JavadocParser.NEWLINE, i); 9256 } 9257 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9258 public TerminalNode LEADING_ASTERISK(int i) { 9259 return getToken(JavadocParser.LEADING_ASTERISK, i); 9260 } 9261 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9262 public TerminalNode WS(int i) { 9263 return getToken(JavadocParser.WS, i); 9264 } 9265 public HtmlTagEndContext(ParserRuleContext parent, int invokingState) { 9266 super(parent, invokingState); 9267 } 9268 @Override public int getRuleIndex() { return RULE_htmlTagEnd; } 9269 } 9270 9271 public final HtmlTagEndContext htmlTagEnd() throws RecognitionException { 9272 HtmlTagEndContext _localctx = new HtmlTagEndContext(_ctx, getState()); 9273 enterRule(_localctx, 74, RULE_htmlTagEnd); 9274 int _la; 9275 try { 9276 enterOuterAlt(_localctx, 1); 9277 { 9278 setState(1135); 9279 match(START); 9280 setState(1136); 9281 match(SLASH); 9282 setState(1137); 9283 match(HTML_HTML_TAG_NAME); 9284 setState(1141); 9285 _errHandler.sync(this); 9286 _la = _input.LA(1); 9287 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9288 { 9289 { 9290 setState(1138); 9291 _la = _input.LA(1); 9292 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9293 _errHandler.recoverInline(this); 9294 } 9295 else { 9296 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 9297 _errHandler.reportMatch(this); 9298 consume(); 9299 } 9300 } 9301 } 9302 setState(1143); 9303 _errHandler.sync(this); 9304 _la = _input.LA(1); 9305 } 9306 setState(1144); 9307 match(END); 9308 } 9309 } 9310 catch (RecognitionException re) { 9311 _localctx.exception = re; 9312 _errHandler.reportError(this, re); 9313 _errHandler.recover(this, re); 9314 } 9315 finally { 9316 exitRule(); 9317 } 9318 return _localctx; 9319 } 9320 9321 public static class HtmlContext extends ParserRuleContext { 9322 public HtmlTagStartContext htmlTagStart() { 9323 return getRuleContext(HtmlTagStartContext.class,0); 9324 } 9325 public HtmlTagEndContext htmlTagEnd() { 9326 return getRuleContext(HtmlTagEndContext.class,0); 9327 } 9328 public List<HtmlTagContext> htmlTag() { 9329 return getRuleContexts(HtmlTagContext.class); 9330 } 9331 public HtmlTagContext htmlTag(int i) { 9332 return getRuleContext(HtmlTagContext.class,i); 9333 } 9334 public List<SingletonElementContext> singletonElement() { 9335 return getRuleContexts(SingletonElementContext.class); 9336 } 9337 public SingletonElementContext singletonElement(int i) { 9338 return getRuleContext(SingletonElementContext.class,i); 9339 } 9340 public List<ParagraphContext> paragraph() { 9341 return getRuleContexts(ParagraphContext.class); 9342 } 9343 public ParagraphContext paragraph(int i) { 9344 return getRuleContext(ParagraphContext.class,i); 9345 } 9346 public List<LiContext> li() { 9347 return getRuleContexts(LiContext.class); 9348 } 9349 public LiContext li(int i) { 9350 return getRuleContext(LiContext.class,i); 9351 } 9352 public List<TrContext> tr() { 9353 return getRuleContexts(TrContext.class); 9354 } 9355 public TrContext tr(int i) { 9356 return getRuleContext(TrContext.class,i); 9357 } 9358 public List<TdContext> td() { 9359 return getRuleContexts(TdContext.class); 9360 } 9361 public TdContext td(int i) { 9362 return getRuleContext(TdContext.class,i); 9363 } 9364 public List<ThContext> th() { 9365 return getRuleContexts(ThContext.class); 9366 } 9367 public ThContext th(int i) { 9368 return getRuleContext(ThContext.class,i); 9369 } 9370 public List<BodyContext> body() { 9371 return getRuleContexts(BodyContext.class); 9372 } 9373 public BodyContext body(int i) { 9374 return getRuleContext(BodyContext.class,i); 9375 } 9376 public List<ColgroupContext> colgroup() { 9377 return getRuleContexts(ColgroupContext.class); 9378 } 9379 public ColgroupContext colgroup(int i) { 9380 return getRuleContext(ColgroupContext.class,i); 9381 } 9382 public List<DdContext> dd() { 9383 return getRuleContexts(DdContext.class); 9384 } 9385 public DdContext dd(int i) { 9386 return getRuleContext(DdContext.class,i); 9387 } 9388 public List<DtContext> dt() { 9389 return getRuleContexts(DtContext.class); 9390 } 9391 public DtContext dt(int i) { 9392 return getRuleContext(DtContext.class,i); 9393 } 9394 public List<HeadContext> head() { 9395 return getRuleContexts(HeadContext.class); 9396 } 9397 public HeadContext head(int i) { 9398 return getRuleContext(HeadContext.class,i); 9399 } 9400 public List<OptionContext> option() { 9401 return getRuleContexts(OptionContext.class); 9402 } 9403 public OptionContext option(int i) { 9404 return getRuleContext(OptionContext.class,i); 9405 } 9406 public List<TbodyContext> tbody() { 9407 return getRuleContexts(TbodyContext.class); 9408 } 9409 public TbodyContext tbody(int i) { 9410 return getRuleContext(TbodyContext.class,i); 9411 } 9412 public List<TheadContext> thead() { 9413 return getRuleContexts(TheadContext.class); 9414 } 9415 public TheadContext thead(int i) { 9416 return getRuleContext(TheadContext.class,i); 9417 } 9418 public List<TfootContext> tfoot() { 9419 return getRuleContexts(TfootContext.class); 9420 } 9421 public TfootContext tfoot(int i) { 9422 return getRuleContext(TfootContext.class,i); 9423 } 9424 public List<OptgroupContext> optgroup() { 9425 return getRuleContexts(OptgroupContext.class); 9426 } 9427 public OptgroupContext optgroup(int i) { 9428 return getRuleContext(OptgroupContext.class,i); 9429 } 9430 public List<RbContext> rb() { 9431 return getRuleContexts(RbContext.class); 9432 } 9433 public RbContext rb(int i) { 9434 return getRuleContext(RbContext.class,i); 9435 } 9436 public List<RtContext> rt() { 9437 return getRuleContexts(RtContext.class); 9438 } 9439 public RtContext rt(int i) { 9440 return getRuleContext(RtContext.class,i); 9441 } 9442 public List<RtcContext> rtc() { 9443 return getRuleContexts(RtcContext.class); 9444 } 9445 public RtcContext rtc(int i) { 9446 return getRuleContext(RtcContext.class,i); 9447 } 9448 public List<RpContext> rp() { 9449 return getRuleContexts(RpContext.class); 9450 } 9451 public RpContext rp(int i) { 9452 return getRuleContext(RpContext.class,i); 9453 } 9454 public List<PTagStartContext> pTagStart() { 9455 return getRuleContexts(PTagStartContext.class); 9456 } 9457 public PTagStartContext pTagStart(int i) { 9458 return getRuleContext(PTagStartContext.class,i); 9459 } 9460 public List<LiTagStartContext> liTagStart() { 9461 return getRuleContexts(LiTagStartContext.class); 9462 } 9463 public LiTagStartContext liTagStart(int i) { 9464 return getRuleContext(LiTagStartContext.class,i); 9465 } 9466 public List<TrTagStartContext> trTagStart() { 9467 return getRuleContexts(TrTagStartContext.class); 9468 } 9469 public TrTagStartContext trTagStart(int i) { 9470 return getRuleContext(TrTagStartContext.class,i); 9471 } 9472 public List<TdTagStartContext> tdTagStart() { 9473 return getRuleContexts(TdTagStartContext.class); 9474 } 9475 public TdTagStartContext tdTagStart(int i) { 9476 return getRuleContext(TdTagStartContext.class,i); 9477 } 9478 public List<ThTagStartContext> thTagStart() { 9479 return getRuleContexts(ThTagStartContext.class); 9480 } 9481 public ThTagStartContext thTagStart(int i) { 9482 return getRuleContext(ThTagStartContext.class,i); 9483 } 9484 public List<BodyTagStartContext> bodyTagStart() { 9485 return getRuleContexts(BodyTagStartContext.class); 9486 } 9487 public BodyTagStartContext bodyTagStart(int i) { 9488 return getRuleContext(BodyTagStartContext.class,i); 9489 } 9490 public List<ColgroupTagStartContext> colgroupTagStart() { 9491 return getRuleContexts(ColgroupTagStartContext.class); 9492 } 9493 public ColgroupTagStartContext colgroupTagStart(int i) { 9494 return getRuleContext(ColgroupTagStartContext.class,i); 9495 } 9496 public List<DdTagStartContext> ddTagStart() { 9497 return getRuleContexts(DdTagStartContext.class); 9498 } 9499 public DdTagStartContext ddTagStart(int i) { 9500 return getRuleContext(DdTagStartContext.class,i); 9501 } 9502 public List<DtTagStartContext> dtTagStart() { 9503 return getRuleContexts(DtTagStartContext.class); 9504 } 9505 public DtTagStartContext dtTagStart(int i) { 9506 return getRuleContext(DtTagStartContext.class,i); 9507 } 9508 public List<HeadTagStartContext> headTagStart() { 9509 return getRuleContexts(HeadTagStartContext.class); 9510 } 9511 public HeadTagStartContext headTagStart(int i) { 9512 return getRuleContext(HeadTagStartContext.class,i); 9513 } 9514 public List<OptionTagStartContext> optionTagStart() { 9515 return getRuleContexts(OptionTagStartContext.class); 9516 } 9517 public OptionTagStartContext optionTagStart(int i) { 9518 return getRuleContext(OptionTagStartContext.class,i); 9519 } 9520 public List<TbodyTagStartContext> tbodyTagStart() { 9521 return getRuleContexts(TbodyTagStartContext.class); 9522 } 9523 public TbodyTagStartContext tbodyTagStart(int i) { 9524 return getRuleContext(TbodyTagStartContext.class,i); 9525 } 9526 public List<TheadTagStartContext> theadTagStart() { 9527 return getRuleContexts(TheadTagStartContext.class); 9528 } 9529 public TheadTagStartContext theadTagStart(int i) { 9530 return getRuleContext(TheadTagStartContext.class,i); 9531 } 9532 public List<TfootTagStartContext> tfootTagStart() { 9533 return getRuleContexts(TfootTagStartContext.class); 9534 } 9535 public TfootTagStartContext tfootTagStart(int i) { 9536 return getRuleContext(TfootTagStartContext.class,i); 9537 } 9538 public List<OptgroupTagStartContext> optgroupTagStart() { 9539 return getRuleContexts(OptgroupTagStartContext.class); 9540 } 9541 public OptgroupTagStartContext optgroupTagStart(int i) { 9542 return getRuleContext(OptgroupTagStartContext.class,i); 9543 } 9544 public List<RbTagStartContext> rbTagStart() { 9545 return getRuleContexts(RbTagStartContext.class); 9546 } 9547 public RbTagStartContext rbTagStart(int i) { 9548 return getRuleContext(RbTagStartContext.class,i); 9549 } 9550 public List<RtTagStartContext> rtTagStart() { 9551 return getRuleContexts(RtTagStartContext.class); 9552 } 9553 public RtTagStartContext rtTagStart(int i) { 9554 return getRuleContext(RtTagStartContext.class,i); 9555 } 9556 public List<RtcTagStartContext> rtcTagStart() { 9557 return getRuleContexts(RtcTagStartContext.class); 9558 } 9559 public RtcTagStartContext rtcTagStart(int i) { 9560 return getRuleContext(RtcTagStartContext.class,i); 9561 } 9562 public List<RpTagStartContext> rpTagStart() { 9563 return getRuleContexts(RpTagStartContext.class); 9564 } 9565 public RpTagStartContext rpTagStart(int i) { 9566 return getRuleContext(RpTagStartContext.class,i); 9567 } 9568 public List<HtmlCommentContext> htmlComment() { 9569 return getRuleContexts(HtmlCommentContext.class); 9570 } 9571 public HtmlCommentContext htmlComment(int i) { 9572 return getRuleContext(HtmlCommentContext.class,i); 9573 } 9574 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9575 public TerminalNode NEWLINE(int i) { 9576 return getToken(JavadocParser.NEWLINE, i); 9577 } 9578 public List<TextContext> text() { 9579 return getRuleContexts(TextContext.class); 9580 } 9581 public TextContext text(int i) { 9582 return getRuleContext(TextContext.class,i); 9583 } 9584 public List<JavadocInlineTagContext> javadocInlineTag() { 9585 return getRuleContexts(JavadocInlineTagContext.class); 9586 } 9587 public JavadocInlineTagContext javadocInlineTag(int i) { 9588 return getRuleContext(JavadocInlineTagContext.class,i); 9589 } 9590 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9591 public TerminalNode LEADING_ASTERISK(int i) { 9592 return getToken(JavadocParser.LEADING_ASTERISK, i); 9593 } 9594 public HtmlContext(ParserRuleContext parent, int invokingState) { 9595 super(parent, invokingState); 9596 } 9597 @Override public int getRuleIndex() { return RULE_html; } 9598 } 9599 9600 public final HtmlContext html() throws RecognitionException { 9601 HtmlContext _localctx = new HtmlContext(_ctx, getState()); 9602 enterRule(_localctx, 76, RULE_html); 9603 try { 9604 int _alt; 9605 enterOuterAlt(_localctx, 1); 9606 { 9607 setState(1146); 9608 htmlTagStart(false); 9609 setState(1195); 9610 _errHandler.sync(this); 9611 _alt = getInterpreter().adaptivePredict(_input,68,_ctx); 9612 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 9613 if ( _alt==1 ) { 9614 { 9615 setState(1193); 9616 _errHandler.sync(this); 9617 switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) { 9618 case 1: 9619 { 9620 setState(1147); 9621 htmlTag(); 9622 } 9623 break; 9624 case 2: 9625 { 9626 setState(1148); 9627 singletonElement(); 9628 } 9629 break; 9630 case 3: 9631 { 9632 setState(1149); 9633 paragraph(); 9634 } 9635 break; 9636 case 4: 9637 { 9638 setState(1150); 9639 li(); 9640 } 9641 break; 9642 case 5: 9643 { 9644 setState(1151); 9645 tr(); 9646 } 9647 break; 9648 case 6: 9649 { 9650 setState(1152); 9651 td(); 9652 } 9653 break; 9654 case 7: 9655 { 9656 setState(1153); 9657 th(); 9658 } 9659 break; 9660 case 8: 9661 { 9662 setState(1154); 9663 body(); 9664 } 9665 break; 9666 case 9: 9667 { 9668 setState(1155); 9669 colgroup(); 9670 } 9671 break; 9672 case 10: 9673 { 9674 setState(1156); 9675 dd(); 9676 } 9677 break; 9678 case 11: 9679 { 9680 setState(1157); 9681 dt(); 9682 } 9683 break; 9684 case 12: 9685 { 9686 setState(1158); 9687 head(); 9688 } 9689 break; 9690 case 13: 9691 { 9692 setState(1159); 9693 option(); 9694 } 9695 break; 9696 case 14: 9697 { 9698 setState(1160); 9699 tbody(); 9700 } 9701 break; 9702 case 15: 9703 { 9704 setState(1161); 9705 thead(); 9706 } 9707 break; 9708 case 16: 9709 { 9710 setState(1162); 9711 tfoot(); 9712 } 9713 break; 9714 case 17: 9715 { 9716 setState(1163); 9717 optgroup(); 9718 } 9719 break; 9720 case 18: 9721 { 9722 setState(1164); 9723 rb(); 9724 } 9725 break; 9726 case 19: 9727 { 9728 setState(1165); 9729 rt(); 9730 } 9731 break; 9732 case 20: 9733 { 9734 setState(1166); 9735 rtc(); 9736 } 9737 break; 9738 case 21: 9739 { 9740 setState(1167); 9741 rp(); 9742 } 9743 break; 9744 case 22: 9745 { 9746 setState(1168); 9747 pTagStart(true); 9748 } 9749 break; 9750 case 23: 9751 { 9752 setState(1169); 9753 liTagStart(true); 9754 } 9755 break; 9756 case 24: 9757 { 9758 setState(1170); 9759 trTagStart(true); 9760 } 9761 break; 9762 case 25: 9763 { 9764 setState(1171); 9765 tdTagStart(true); 9766 } 9767 break; 9768 case 26: 9769 { 9770 setState(1172); 9771 thTagStart(true); 9772 } 9773 break; 9774 case 27: 9775 { 9776 setState(1173); 9777 bodyTagStart(true); 9778 } 9779 break; 9780 case 28: 9781 { 9782 setState(1174); 9783 colgroupTagStart(true); 9784 } 9785 break; 9786 case 29: 9787 { 9788 setState(1175); 9789 ddTagStart(true); 9790 } 9791 break; 9792 case 30: 9793 { 9794 setState(1176); 9795 dtTagStart(true); 9796 } 9797 break; 9798 case 31: 9799 { 9800 setState(1177); 9801 headTagStart(true); 9802 } 9803 break; 9804 case 32: 9805 { 9806 setState(1178); 9807 optionTagStart(true); 9808 } 9809 break; 9810 case 33: 9811 { 9812 setState(1179); 9813 tbodyTagStart(true); 9814 } 9815 break; 9816 case 34: 9817 { 9818 setState(1180); 9819 theadTagStart(true); 9820 } 9821 break; 9822 case 35: 9823 { 9824 setState(1181); 9825 tfootTagStart(true); 9826 } 9827 break; 9828 case 36: 9829 { 9830 setState(1182); 9831 optgroupTagStart(true); 9832 } 9833 break; 9834 case 37: 9835 { 9836 setState(1183); 9837 rbTagStart(true); 9838 } 9839 break; 9840 case 38: 9841 { 9842 setState(1184); 9843 rtTagStart(true); 9844 } 9845 break; 9846 case 39: 9847 { 9848 setState(1185); 9849 rtcTagStart(true); 9850 } 9851 break; 9852 case 40: 9853 { 9854 setState(1186); 9855 rpTagStart(true); 9856 } 9857 break; 9858 case 41: 9859 { 9860 { 9861 setState(1187); 9862 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 9863 setState(1188); 9864 match(LEADING_ASTERISK); 9865 } 9866 } 9867 break; 9868 case 42: 9869 { 9870 setState(1189); 9871 htmlComment(); 9872 } 9873 break; 9874 case 43: 9875 { 9876 setState(1190); 9877 match(NEWLINE); 9878 } 9879 break; 9880 case 44: 9881 { 9882 setState(1191); 9883 text(); 9884 } 9885 break; 9886 case 45: 9887 { 9888 setState(1192); 9889 javadocInlineTag(); 9890 } 9891 break; 9892 } 9893 } 9894 } 9895 setState(1197); 9896 _errHandler.sync(this); 9897 _alt = getInterpreter().adaptivePredict(_input,68,_ctx); 9898 } 9899 setState(1198); 9900 htmlTagEnd(); 9901 } 9902 } 9903 catch (RecognitionException re) { 9904 _localctx.exception = re; 9905 _errHandler.reportError(this, re); 9906 _errHandler.recover(this, re); 9907 } 9908 finally { 9909 exitRule(); 9910 } 9911 return _localctx; 9912 } 9913 9914 public static class OptionTagStartContext extends ParserRuleContext { 9915 public boolean isNonTight; 9916 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 9917 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 9918 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 9919 public List<AttributeContext> attribute() { 9920 return getRuleContexts(AttributeContext.class); 9921 } 9922 public AttributeContext attribute(int i) { 9923 return getRuleContext(AttributeContext.class,i); 9924 } 9925 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9926 public TerminalNode NEWLINE(int i) { 9927 return getToken(JavadocParser.NEWLINE, i); 9928 } 9929 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9930 public TerminalNode LEADING_ASTERISK(int i) { 9931 return getToken(JavadocParser.LEADING_ASTERISK, i); 9932 } 9933 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9934 public TerminalNode WS(int i) { 9935 return getToken(JavadocParser.WS, i); 9936 } 9937 public OptionTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 9938 public OptionTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 9939 super(parent, invokingState); 9940 this.isNonTight = isNonTight; 9941 } 9942 @Override public int getRuleIndex() { return RULE_optionTagStart; } 9943 } 9944 9945 public final OptionTagStartContext optionTagStart(boolean isNonTight) throws RecognitionException { 9946 OptionTagStartContext _localctx = new OptionTagStartContext(_ctx, getState(), isNonTight); 9947 enterRule(_localctx, 78, RULE_optionTagStart); 9948 int _la; 9949 try { 9950 enterOuterAlt(_localctx, 1); 9951 { 9952 setState(1200); 9953 match(START); 9954 setState(1201); 9955 match(OPTION_HTML_TAG_NAME); 9956 setState(1208); 9957 _errHandler.sync(this); 9958 _la = _input.LA(1); 9959 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9960 { 9961 setState(1206); 9962 _errHandler.sync(this); 9963 switch (_input.LA(1)) { 9964 case HTML_TAG_NAME: 9965 { 9966 setState(1202); 9967 attribute(); 9968 } 9969 break; 9970 case NEWLINE: 9971 { 9972 setState(1203); 9973 match(NEWLINE); 9974 } 9975 break; 9976 case LEADING_ASTERISK: 9977 { 9978 setState(1204); 9979 match(LEADING_ASTERISK); 9980 } 9981 break; 9982 case WS: 9983 { 9984 setState(1205); 9985 match(WS); 9986 } 9987 break; 9988 default: 9989 throw new NoViableAltException(this); 9990 } 9991 } 9992 setState(1210); 9993 _errHandler.sync(this); 9994 _la = _input.LA(1); 9995 } 9996 setState(1211); 9997 match(END); 9998 } 9999 _ctx.stop = _input.LT(-1); 10000 10001 if (isNonTight && nonTightTagStartContext == null) { 10002 nonTightTagStartContext = _localctx; 10003 } 10004 10005 } 10006 catch (RecognitionException re) { 10007 _localctx.exception = re; 10008 _errHandler.reportError(this, re); 10009 _errHandler.recover(this, re); 10010 } 10011 finally { 10012 exitRule(); 10013 } 10014 return _localctx; 10015 } 10016 10017 public static class OptionTagEndContext extends ParserRuleContext { 10018 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 10019 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 10020 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 10021 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 10022 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10023 public TerminalNode NEWLINE(int i) { 10024 return getToken(JavadocParser.NEWLINE, i); 10025 } 10026 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10027 public TerminalNode LEADING_ASTERISK(int i) { 10028 return getToken(JavadocParser.LEADING_ASTERISK, i); 10029 } 10030 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10031 public TerminalNode WS(int i) { 10032 return getToken(JavadocParser.WS, i); 10033 } 10034 public OptionTagEndContext(ParserRuleContext parent, int invokingState) { 10035 super(parent, invokingState); 10036 } 10037 @Override public int getRuleIndex() { return RULE_optionTagEnd; } 10038 } 10039 10040 public final OptionTagEndContext optionTagEnd() throws RecognitionException { 10041 OptionTagEndContext _localctx = new OptionTagEndContext(_ctx, getState()); 10042 enterRule(_localctx, 80, RULE_optionTagEnd); 10043 int _la; 10044 try { 10045 enterOuterAlt(_localctx, 1); 10046 { 10047 setState(1213); 10048 match(START); 10049 setState(1214); 10050 match(SLASH); 10051 setState(1215); 10052 match(OPTION_HTML_TAG_NAME); 10053 setState(1219); 10054 _errHandler.sync(this); 10055 _la = _input.LA(1); 10056 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 10057 { 10058 { 10059 setState(1216); 10060 _la = _input.LA(1); 10061 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 10062 _errHandler.recoverInline(this); 10063 } 10064 else { 10065 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 10066 _errHandler.reportMatch(this); 10067 consume(); 10068 } 10069 } 10070 } 10071 setState(1221); 10072 _errHandler.sync(this); 10073 _la = _input.LA(1); 10074 } 10075 setState(1222); 10076 match(END); 10077 } 10078 } 10079 catch (RecognitionException re) { 10080 _localctx.exception = re; 10081 _errHandler.reportError(this, re); 10082 _errHandler.recover(this, re); 10083 } 10084 finally { 10085 exitRule(); 10086 } 10087 return _localctx; 10088 } 10089 10090 public static class OptionContext extends ParserRuleContext { 10091 public OptionTagStartContext optionTagStart() { 10092 return getRuleContext(OptionTagStartContext.class,0); 10093 } 10094 public OptionTagEndContext optionTagEnd() { 10095 return getRuleContext(OptionTagEndContext.class,0); 10096 } 10097 public List<HtmlTagContext> htmlTag() { 10098 return getRuleContexts(HtmlTagContext.class); 10099 } 10100 public HtmlTagContext htmlTag(int i) { 10101 return getRuleContext(HtmlTagContext.class,i); 10102 } 10103 public List<SingletonElementContext> singletonElement() { 10104 return getRuleContexts(SingletonElementContext.class); 10105 } 10106 public SingletonElementContext singletonElement(int i) { 10107 return getRuleContext(SingletonElementContext.class,i); 10108 } 10109 public List<ParagraphContext> paragraph() { 10110 return getRuleContexts(ParagraphContext.class); 10111 } 10112 public ParagraphContext paragraph(int i) { 10113 return getRuleContext(ParagraphContext.class,i); 10114 } 10115 public List<LiContext> li() { 10116 return getRuleContexts(LiContext.class); 10117 } 10118 public LiContext li(int i) { 10119 return getRuleContext(LiContext.class,i); 10120 } 10121 public List<TrContext> tr() { 10122 return getRuleContexts(TrContext.class); 10123 } 10124 public TrContext tr(int i) { 10125 return getRuleContext(TrContext.class,i); 10126 } 10127 public List<TdContext> td() { 10128 return getRuleContexts(TdContext.class); 10129 } 10130 public TdContext td(int i) { 10131 return getRuleContext(TdContext.class,i); 10132 } 10133 public List<ThContext> th() { 10134 return getRuleContexts(ThContext.class); 10135 } 10136 public ThContext th(int i) { 10137 return getRuleContext(ThContext.class,i); 10138 } 10139 public List<BodyContext> body() { 10140 return getRuleContexts(BodyContext.class); 10141 } 10142 public BodyContext body(int i) { 10143 return getRuleContext(BodyContext.class,i); 10144 } 10145 public List<ColgroupContext> colgroup() { 10146 return getRuleContexts(ColgroupContext.class); 10147 } 10148 public ColgroupContext colgroup(int i) { 10149 return getRuleContext(ColgroupContext.class,i); 10150 } 10151 public List<DdContext> dd() { 10152 return getRuleContexts(DdContext.class); 10153 } 10154 public DdContext dd(int i) { 10155 return getRuleContext(DdContext.class,i); 10156 } 10157 public List<DtContext> dt() { 10158 return getRuleContexts(DtContext.class); 10159 } 10160 public DtContext dt(int i) { 10161 return getRuleContext(DtContext.class,i); 10162 } 10163 public List<HeadContext> head() { 10164 return getRuleContexts(HeadContext.class); 10165 } 10166 public HeadContext head(int i) { 10167 return getRuleContext(HeadContext.class,i); 10168 } 10169 public List<HtmlContext> html() { 10170 return getRuleContexts(HtmlContext.class); 10171 } 10172 public HtmlContext html(int i) { 10173 return getRuleContext(HtmlContext.class,i); 10174 } 10175 public List<TbodyContext> tbody() { 10176 return getRuleContexts(TbodyContext.class); 10177 } 10178 public TbodyContext tbody(int i) { 10179 return getRuleContext(TbodyContext.class,i); 10180 } 10181 public List<TheadContext> thead() { 10182 return getRuleContexts(TheadContext.class); 10183 } 10184 public TheadContext thead(int i) { 10185 return getRuleContext(TheadContext.class,i); 10186 } 10187 public List<TfootContext> tfoot() { 10188 return getRuleContexts(TfootContext.class); 10189 } 10190 public TfootContext tfoot(int i) { 10191 return getRuleContext(TfootContext.class,i); 10192 } 10193 public List<OptgroupContext> optgroup() { 10194 return getRuleContexts(OptgroupContext.class); 10195 } 10196 public OptgroupContext optgroup(int i) { 10197 return getRuleContext(OptgroupContext.class,i); 10198 } 10199 public List<RbContext> rb() { 10200 return getRuleContexts(RbContext.class); 10201 } 10202 public RbContext rb(int i) { 10203 return getRuleContext(RbContext.class,i); 10204 } 10205 public List<RtContext> rt() { 10206 return getRuleContexts(RtContext.class); 10207 } 10208 public RtContext rt(int i) { 10209 return getRuleContext(RtContext.class,i); 10210 } 10211 public List<RtcContext> rtc() { 10212 return getRuleContexts(RtcContext.class); 10213 } 10214 public RtcContext rtc(int i) { 10215 return getRuleContext(RtcContext.class,i); 10216 } 10217 public List<RpContext> rp() { 10218 return getRuleContexts(RpContext.class); 10219 } 10220 public RpContext rp(int i) { 10221 return getRuleContext(RpContext.class,i); 10222 } 10223 public List<PTagStartContext> pTagStart() { 10224 return getRuleContexts(PTagStartContext.class); 10225 } 10226 public PTagStartContext pTagStart(int i) { 10227 return getRuleContext(PTagStartContext.class,i); 10228 } 10229 public List<LiTagStartContext> liTagStart() { 10230 return getRuleContexts(LiTagStartContext.class); 10231 } 10232 public LiTagStartContext liTagStart(int i) { 10233 return getRuleContext(LiTagStartContext.class,i); 10234 } 10235 public List<TrTagStartContext> trTagStart() { 10236 return getRuleContexts(TrTagStartContext.class); 10237 } 10238 public TrTagStartContext trTagStart(int i) { 10239 return getRuleContext(TrTagStartContext.class,i); 10240 } 10241 public List<TdTagStartContext> tdTagStart() { 10242 return getRuleContexts(TdTagStartContext.class); 10243 } 10244 public TdTagStartContext tdTagStart(int i) { 10245 return getRuleContext(TdTagStartContext.class,i); 10246 } 10247 public List<ThTagStartContext> thTagStart() { 10248 return getRuleContexts(ThTagStartContext.class); 10249 } 10250 public ThTagStartContext thTagStart(int i) { 10251 return getRuleContext(ThTagStartContext.class,i); 10252 } 10253 public List<BodyTagStartContext> bodyTagStart() { 10254 return getRuleContexts(BodyTagStartContext.class); 10255 } 10256 public BodyTagStartContext bodyTagStart(int i) { 10257 return getRuleContext(BodyTagStartContext.class,i); 10258 } 10259 public List<ColgroupTagStartContext> colgroupTagStart() { 10260 return getRuleContexts(ColgroupTagStartContext.class); 10261 } 10262 public ColgroupTagStartContext colgroupTagStart(int i) { 10263 return getRuleContext(ColgroupTagStartContext.class,i); 10264 } 10265 public List<DdTagStartContext> ddTagStart() { 10266 return getRuleContexts(DdTagStartContext.class); 10267 } 10268 public DdTagStartContext ddTagStart(int i) { 10269 return getRuleContext(DdTagStartContext.class,i); 10270 } 10271 public List<DtTagStartContext> dtTagStart() { 10272 return getRuleContexts(DtTagStartContext.class); 10273 } 10274 public DtTagStartContext dtTagStart(int i) { 10275 return getRuleContext(DtTagStartContext.class,i); 10276 } 10277 public List<HeadTagStartContext> headTagStart() { 10278 return getRuleContexts(HeadTagStartContext.class); 10279 } 10280 public HeadTagStartContext headTagStart(int i) { 10281 return getRuleContext(HeadTagStartContext.class,i); 10282 } 10283 public List<HtmlTagStartContext> htmlTagStart() { 10284 return getRuleContexts(HtmlTagStartContext.class); 10285 } 10286 public HtmlTagStartContext htmlTagStart(int i) { 10287 return getRuleContext(HtmlTagStartContext.class,i); 10288 } 10289 public List<TbodyTagStartContext> tbodyTagStart() { 10290 return getRuleContexts(TbodyTagStartContext.class); 10291 } 10292 public TbodyTagStartContext tbodyTagStart(int i) { 10293 return getRuleContext(TbodyTagStartContext.class,i); 10294 } 10295 public List<TheadTagStartContext> theadTagStart() { 10296 return getRuleContexts(TheadTagStartContext.class); 10297 } 10298 public TheadTagStartContext theadTagStart(int i) { 10299 return getRuleContext(TheadTagStartContext.class,i); 10300 } 10301 public List<TfootTagStartContext> tfootTagStart() { 10302 return getRuleContexts(TfootTagStartContext.class); 10303 } 10304 public TfootTagStartContext tfootTagStart(int i) { 10305 return getRuleContext(TfootTagStartContext.class,i); 10306 } 10307 public List<OptgroupTagStartContext> optgroupTagStart() { 10308 return getRuleContexts(OptgroupTagStartContext.class); 10309 } 10310 public OptgroupTagStartContext optgroupTagStart(int i) { 10311 return getRuleContext(OptgroupTagStartContext.class,i); 10312 } 10313 public List<RbTagStartContext> rbTagStart() { 10314 return getRuleContexts(RbTagStartContext.class); 10315 } 10316 public RbTagStartContext rbTagStart(int i) { 10317 return getRuleContext(RbTagStartContext.class,i); 10318 } 10319 public List<RtTagStartContext> rtTagStart() { 10320 return getRuleContexts(RtTagStartContext.class); 10321 } 10322 public RtTagStartContext rtTagStart(int i) { 10323 return getRuleContext(RtTagStartContext.class,i); 10324 } 10325 public List<RtcTagStartContext> rtcTagStart() { 10326 return getRuleContexts(RtcTagStartContext.class); 10327 } 10328 public RtcTagStartContext rtcTagStart(int i) { 10329 return getRuleContext(RtcTagStartContext.class,i); 10330 } 10331 public List<RpTagStartContext> rpTagStart() { 10332 return getRuleContexts(RpTagStartContext.class); 10333 } 10334 public RpTagStartContext rpTagStart(int i) { 10335 return getRuleContext(RpTagStartContext.class,i); 10336 } 10337 public List<HtmlCommentContext> htmlComment() { 10338 return getRuleContexts(HtmlCommentContext.class); 10339 } 10340 public HtmlCommentContext htmlComment(int i) { 10341 return getRuleContext(HtmlCommentContext.class,i); 10342 } 10343 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10344 public TerminalNode NEWLINE(int i) { 10345 return getToken(JavadocParser.NEWLINE, i); 10346 } 10347 public List<TextContext> text() { 10348 return getRuleContexts(TextContext.class); 10349 } 10350 public TextContext text(int i) { 10351 return getRuleContext(TextContext.class,i); 10352 } 10353 public List<JavadocInlineTagContext> javadocInlineTag() { 10354 return getRuleContexts(JavadocInlineTagContext.class); 10355 } 10356 public JavadocInlineTagContext javadocInlineTag(int i) { 10357 return getRuleContext(JavadocInlineTagContext.class,i); 10358 } 10359 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10360 public TerminalNode LEADING_ASTERISK(int i) { 10361 return getToken(JavadocParser.LEADING_ASTERISK, i); 10362 } 10363 public OptionContext(ParserRuleContext parent, int invokingState) { 10364 super(parent, invokingState); 10365 } 10366 @Override public int getRuleIndex() { return RULE_option; } 10367 } 10368 10369 public final OptionContext option() throws RecognitionException { 10370 OptionContext _localctx = new OptionContext(_ctx, getState()); 10371 enterRule(_localctx, 82, RULE_option); 10372 try { 10373 int _alt; 10374 enterOuterAlt(_localctx, 1); 10375 { 10376 setState(1224); 10377 optionTagStart(false); 10378 setState(1273); 10379 _errHandler.sync(this); 10380 _alt = getInterpreter().adaptivePredict(_input,73,_ctx); 10381 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10382 if ( _alt==1 ) { 10383 { 10384 setState(1271); 10385 _errHandler.sync(this); 10386 switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) { 10387 case 1: 10388 { 10389 setState(1225); 10390 htmlTag(); 10391 } 10392 break; 10393 case 2: 10394 { 10395 setState(1226); 10396 singletonElement(); 10397 } 10398 break; 10399 case 3: 10400 { 10401 setState(1227); 10402 paragraph(); 10403 } 10404 break; 10405 case 4: 10406 { 10407 setState(1228); 10408 li(); 10409 } 10410 break; 10411 case 5: 10412 { 10413 setState(1229); 10414 tr(); 10415 } 10416 break; 10417 case 6: 10418 { 10419 setState(1230); 10420 td(); 10421 } 10422 break; 10423 case 7: 10424 { 10425 setState(1231); 10426 th(); 10427 } 10428 break; 10429 case 8: 10430 { 10431 setState(1232); 10432 body(); 10433 } 10434 break; 10435 case 9: 10436 { 10437 setState(1233); 10438 colgroup(); 10439 } 10440 break; 10441 case 10: 10442 { 10443 setState(1234); 10444 dd(); 10445 } 10446 break; 10447 case 11: 10448 { 10449 setState(1235); 10450 dt(); 10451 } 10452 break; 10453 case 12: 10454 { 10455 setState(1236); 10456 head(); 10457 } 10458 break; 10459 case 13: 10460 { 10461 setState(1237); 10462 html(); 10463 } 10464 break; 10465 case 14: 10466 { 10467 setState(1238); 10468 tbody(); 10469 } 10470 break; 10471 case 15: 10472 { 10473 setState(1239); 10474 thead(); 10475 } 10476 break; 10477 case 16: 10478 { 10479 setState(1240); 10480 tfoot(); 10481 } 10482 break; 10483 case 17: 10484 { 10485 setState(1241); 10486 optgroup(); 10487 } 10488 break; 10489 case 18: 10490 { 10491 setState(1242); 10492 rb(); 10493 } 10494 break; 10495 case 19: 10496 { 10497 setState(1243); 10498 rt(); 10499 } 10500 break; 10501 case 20: 10502 { 10503 setState(1244); 10504 rtc(); 10505 } 10506 break; 10507 case 21: 10508 { 10509 setState(1245); 10510 rp(); 10511 } 10512 break; 10513 case 22: 10514 { 10515 setState(1246); 10516 pTagStart(true); 10517 } 10518 break; 10519 case 23: 10520 { 10521 setState(1247); 10522 liTagStart(true); 10523 } 10524 break; 10525 case 24: 10526 { 10527 setState(1248); 10528 trTagStart(true); 10529 } 10530 break; 10531 case 25: 10532 { 10533 setState(1249); 10534 tdTagStart(true); 10535 } 10536 break; 10537 case 26: 10538 { 10539 setState(1250); 10540 thTagStart(true); 10541 } 10542 break; 10543 case 27: 10544 { 10545 setState(1251); 10546 bodyTagStart(true); 10547 } 10548 break; 10549 case 28: 10550 { 10551 setState(1252); 10552 colgroupTagStart(true); 10553 } 10554 break; 10555 case 29: 10556 { 10557 setState(1253); 10558 ddTagStart(true); 10559 } 10560 break; 10561 case 30: 10562 { 10563 setState(1254); 10564 dtTagStart(true); 10565 } 10566 break; 10567 case 31: 10568 { 10569 setState(1255); 10570 headTagStart(true); 10571 } 10572 break; 10573 case 32: 10574 { 10575 setState(1256); 10576 htmlTagStart(true); 10577 } 10578 break; 10579 case 33: 10580 { 10581 setState(1257); 10582 tbodyTagStart(true); 10583 } 10584 break; 10585 case 34: 10586 { 10587 setState(1258); 10588 theadTagStart(true); 10589 } 10590 break; 10591 case 35: 10592 { 10593 setState(1259); 10594 tfootTagStart(true); 10595 } 10596 break; 10597 case 36: 10598 { 10599 setState(1260); 10600 optgroupTagStart(true); 10601 } 10602 break; 10603 case 37: 10604 { 10605 setState(1261); 10606 rbTagStart(true); 10607 } 10608 break; 10609 case 38: 10610 { 10611 setState(1262); 10612 rtTagStart(true); 10613 } 10614 break; 10615 case 39: 10616 { 10617 setState(1263); 10618 rtcTagStart(true); 10619 } 10620 break; 10621 case 40: 10622 { 10623 setState(1264); 10624 rpTagStart(true); 10625 } 10626 break; 10627 case 41: 10628 { 10629 { 10630 setState(1265); 10631 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 10632 setState(1266); 10633 match(LEADING_ASTERISK); 10634 } 10635 } 10636 break; 10637 case 42: 10638 { 10639 setState(1267); 10640 htmlComment(); 10641 } 10642 break; 10643 case 43: 10644 { 10645 setState(1268); 10646 match(NEWLINE); 10647 } 10648 break; 10649 case 44: 10650 { 10651 setState(1269); 10652 text(); 10653 } 10654 break; 10655 case 45: 10656 { 10657 setState(1270); 10658 javadocInlineTag(); 10659 } 10660 break; 10661 } 10662 } 10663 } 10664 setState(1275); 10665 _errHandler.sync(this); 10666 _alt = getInterpreter().adaptivePredict(_input,73,_ctx); 10667 } 10668 setState(1276); 10669 optionTagEnd(); 10670 } 10671 } 10672 catch (RecognitionException re) { 10673 _localctx.exception = re; 10674 _errHandler.reportError(this, re); 10675 _errHandler.recover(this, re); 10676 } 10677 finally { 10678 exitRule(); 10679 } 10680 return _localctx; 10681 } 10682 10683 public static class TbodyTagStartContext extends ParserRuleContext { 10684 public boolean isNonTight; 10685 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 10686 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 10687 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 10688 public List<AttributeContext> attribute() { 10689 return getRuleContexts(AttributeContext.class); 10690 } 10691 public AttributeContext attribute(int i) { 10692 return getRuleContext(AttributeContext.class,i); 10693 } 10694 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10695 public TerminalNode NEWLINE(int i) { 10696 return getToken(JavadocParser.NEWLINE, i); 10697 } 10698 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10699 public TerminalNode LEADING_ASTERISK(int i) { 10700 return getToken(JavadocParser.LEADING_ASTERISK, i); 10701 } 10702 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10703 public TerminalNode WS(int i) { 10704 return getToken(JavadocParser.WS, i); 10705 } 10706 public TbodyTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 10707 public TbodyTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 10708 super(parent, invokingState); 10709 this.isNonTight = isNonTight; 10710 } 10711 @Override public int getRuleIndex() { return RULE_tbodyTagStart; } 10712 } 10713 10714 public final TbodyTagStartContext tbodyTagStart(boolean isNonTight) throws RecognitionException { 10715 TbodyTagStartContext _localctx = new TbodyTagStartContext(_ctx, getState(), isNonTight); 10716 enterRule(_localctx, 84, RULE_tbodyTagStart); 10717 int _la; 10718 try { 10719 enterOuterAlt(_localctx, 1); 10720 { 10721 setState(1278); 10722 match(START); 10723 setState(1279); 10724 match(TBODY_HTML_TAG_NAME); 10725 setState(1286); 10726 _errHandler.sync(this); 10727 _la = _input.LA(1); 10728 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 10729 { 10730 setState(1284); 10731 _errHandler.sync(this); 10732 switch (_input.LA(1)) { 10733 case HTML_TAG_NAME: 10734 { 10735 setState(1280); 10736 attribute(); 10737 } 10738 break; 10739 case NEWLINE: 10740 { 10741 setState(1281); 10742 match(NEWLINE); 10743 } 10744 break; 10745 case LEADING_ASTERISK: 10746 { 10747 setState(1282); 10748 match(LEADING_ASTERISK); 10749 } 10750 break; 10751 case WS: 10752 { 10753 setState(1283); 10754 match(WS); 10755 } 10756 break; 10757 default: 10758 throw new NoViableAltException(this); 10759 } 10760 } 10761 setState(1288); 10762 _errHandler.sync(this); 10763 _la = _input.LA(1); 10764 } 10765 setState(1289); 10766 match(END); 10767 } 10768 _ctx.stop = _input.LT(-1); 10769 10770 if (isNonTight && nonTightTagStartContext == null) { 10771 nonTightTagStartContext = _localctx; 10772 } 10773 10774 } 10775 catch (RecognitionException re) { 10776 _localctx.exception = re; 10777 _errHandler.reportError(this, re); 10778 _errHandler.recover(this, re); 10779 } 10780 finally { 10781 exitRule(); 10782 } 10783 return _localctx; 10784 } 10785 10786 public static class TbodyTagEndContext extends ParserRuleContext { 10787 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 10788 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 10789 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 10790 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 10791 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10792 public TerminalNode NEWLINE(int i) { 10793 return getToken(JavadocParser.NEWLINE, i); 10794 } 10795 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10796 public TerminalNode LEADING_ASTERISK(int i) { 10797 return getToken(JavadocParser.LEADING_ASTERISK, i); 10798 } 10799 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10800 public TerminalNode WS(int i) { 10801 return getToken(JavadocParser.WS, i); 10802 } 10803 public TbodyTagEndContext(ParserRuleContext parent, int invokingState) { 10804 super(parent, invokingState); 10805 } 10806 @Override public int getRuleIndex() { return RULE_tbodyTagEnd; } 10807 } 10808 10809 public final TbodyTagEndContext tbodyTagEnd() throws RecognitionException { 10810 TbodyTagEndContext _localctx = new TbodyTagEndContext(_ctx, getState()); 10811 enterRule(_localctx, 86, RULE_tbodyTagEnd); 10812 int _la; 10813 try { 10814 enterOuterAlt(_localctx, 1); 10815 { 10816 setState(1291); 10817 match(START); 10818 setState(1292); 10819 match(SLASH); 10820 setState(1293); 10821 match(TBODY_HTML_TAG_NAME); 10822 setState(1297); 10823 _errHandler.sync(this); 10824 _la = _input.LA(1); 10825 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 10826 { 10827 { 10828 setState(1294); 10829 _la = _input.LA(1); 10830 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 10831 _errHandler.recoverInline(this); 10832 } 10833 else { 10834 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 10835 _errHandler.reportMatch(this); 10836 consume(); 10837 } 10838 } 10839 } 10840 setState(1299); 10841 _errHandler.sync(this); 10842 _la = _input.LA(1); 10843 } 10844 setState(1300); 10845 match(END); 10846 } 10847 } 10848 catch (RecognitionException re) { 10849 _localctx.exception = re; 10850 _errHandler.reportError(this, re); 10851 _errHandler.recover(this, re); 10852 } 10853 finally { 10854 exitRule(); 10855 } 10856 return _localctx; 10857 } 10858 10859 public static class TbodyContext extends ParserRuleContext { 10860 public TbodyTagStartContext tbodyTagStart() { 10861 return getRuleContext(TbodyTagStartContext.class,0); 10862 } 10863 public TbodyTagEndContext tbodyTagEnd() { 10864 return getRuleContext(TbodyTagEndContext.class,0); 10865 } 10866 public List<HtmlTagContext> htmlTag() { 10867 return getRuleContexts(HtmlTagContext.class); 10868 } 10869 public HtmlTagContext htmlTag(int i) { 10870 return getRuleContext(HtmlTagContext.class,i); 10871 } 10872 public List<SingletonElementContext> singletonElement() { 10873 return getRuleContexts(SingletonElementContext.class); 10874 } 10875 public SingletonElementContext singletonElement(int i) { 10876 return getRuleContext(SingletonElementContext.class,i); 10877 } 10878 public List<ParagraphContext> paragraph() { 10879 return getRuleContexts(ParagraphContext.class); 10880 } 10881 public ParagraphContext paragraph(int i) { 10882 return getRuleContext(ParagraphContext.class,i); 10883 } 10884 public List<LiContext> li() { 10885 return getRuleContexts(LiContext.class); 10886 } 10887 public LiContext li(int i) { 10888 return getRuleContext(LiContext.class,i); 10889 } 10890 public List<TrContext> tr() { 10891 return getRuleContexts(TrContext.class); 10892 } 10893 public TrContext tr(int i) { 10894 return getRuleContext(TrContext.class,i); 10895 } 10896 public List<TdContext> td() { 10897 return getRuleContexts(TdContext.class); 10898 } 10899 public TdContext td(int i) { 10900 return getRuleContext(TdContext.class,i); 10901 } 10902 public List<ThContext> th() { 10903 return getRuleContexts(ThContext.class); 10904 } 10905 public ThContext th(int i) { 10906 return getRuleContext(ThContext.class,i); 10907 } 10908 public List<BodyContext> body() { 10909 return getRuleContexts(BodyContext.class); 10910 } 10911 public BodyContext body(int i) { 10912 return getRuleContext(BodyContext.class,i); 10913 } 10914 public List<ColgroupContext> colgroup() { 10915 return getRuleContexts(ColgroupContext.class); 10916 } 10917 public ColgroupContext colgroup(int i) { 10918 return getRuleContext(ColgroupContext.class,i); 10919 } 10920 public List<DdContext> dd() { 10921 return getRuleContexts(DdContext.class); 10922 } 10923 public DdContext dd(int i) { 10924 return getRuleContext(DdContext.class,i); 10925 } 10926 public List<DtContext> dt() { 10927 return getRuleContexts(DtContext.class); 10928 } 10929 public DtContext dt(int i) { 10930 return getRuleContext(DtContext.class,i); 10931 } 10932 public List<HeadContext> head() { 10933 return getRuleContexts(HeadContext.class); 10934 } 10935 public HeadContext head(int i) { 10936 return getRuleContext(HeadContext.class,i); 10937 } 10938 public List<HtmlContext> html() { 10939 return getRuleContexts(HtmlContext.class); 10940 } 10941 public HtmlContext html(int i) { 10942 return getRuleContext(HtmlContext.class,i); 10943 } 10944 public List<OptionContext> option() { 10945 return getRuleContexts(OptionContext.class); 10946 } 10947 public OptionContext option(int i) { 10948 return getRuleContext(OptionContext.class,i); 10949 } 10950 public List<TheadContext> thead() { 10951 return getRuleContexts(TheadContext.class); 10952 } 10953 public TheadContext thead(int i) { 10954 return getRuleContext(TheadContext.class,i); 10955 } 10956 public List<TfootContext> tfoot() { 10957 return getRuleContexts(TfootContext.class); 10958 } 10959 public TfootContext tfoot(int i) { 10960 return getRuleContext(TfootContext.class,i); 10961 } 10962 public List<OptgroupContext> optgroup() { 10963 return getRuleContexts(OptgroupContext.class); 10964 } 10965 public OptgroupContext optgroup(int i) { 10966 return getRuleContext(OptgroupContext.class,i); 10967 } 10968 public List<RbContext> rb() { 10969 return getRuleContexts(RbContext.class); 10970 } 10971 public RbContext rb(int i) { 10972 return getRuleContext(RbContext.class,i); 10973 } 10974 public List<RtContext> rt() { 10975 return getRuleContexts(RtContext.class); 10976 } 10977 public RtContext rt(int i) { 10978 return getRuleContext(RtContext.class,i); 10979 } 10980 public List<RtcContext> rtc() { 10981 return getRuleContexts(RtcContext.class); 10982 } 10983 public RtcContext rtc(int i) { 10984 return getRuleContext(RtcContext.class,i); 10985 } 10986 public List<RpContext> rp() { 10987 return getRuleContexts(RpContext.class); 10988 } 10989 public RpContext rp(int i) { 10990 return getRuleContext(RpContext.class,i); 10991 } 10992 public List<PTagStartContext> pTagStart() { 10993 return getRuleContexts(PTagStartContext.class); 10994 } 10995 public PTagStartContext pTagStart(int i) { 10996 return getRuleContext(PTagStartContext.class,i); 10997 } 10998 public List<LiTagStartContext> liTagStart() { 10999 return getRuleContexts(LiTagStartContext.class); 11000 } 11001 public LiTagStartContext liTagStart(int i) { 11002 return getRuleContext(LiTagStartContext.class,i); 11003 } 11004 public List<TrTagStartContext> trTagStart() { 11005 return getRuleContexts(TrTagStartContext.class); 11006 } 11007 public TrTagStartContext trTagStart(int i) { 11008 return getRuleContext(TrTagStartContext.class,i); 11009 } 11010 public List<TdTagStartContext> tdTagStart() { 11011 return getRuleContexts(TdTagStartContext.class); 11012 } 11013 public TdTagStartContext tdTagStart(int i) { 11014 return getRuleContext(TdTagStartContext.class,i); 11015 } 11016 public List<ThTagStartContext> thTagStart() { 11017 return getRuleContexts(ThTagStartContext.class); 11018 } 11019 public ThTagStartContext thTagStart(int i) { 11020 return getRuleContext(ThTagStartContext.class,i); 11021 } 11022 public List<BodyTagStartContext> bodyTagStart() { 11023 return getRuleContexts(BodyTagStartContext.class); 11024 } 11025 public BodyTagStartContext bodyTagStart(int i) { 11026 return getRuleContext(BodyTagStartContext.class,i); 11027 } 11028 public List<ColgroupTagStartContext> colgroupTagStart() { 11029 return getRuleContexts(ColgroupTagStartContext.class); 11030 } 11031 public ColgroupTagStartContext colgroupTagStart(int i) { 11032 return getRuleContext(ColgroupTagStartContext.class,i); 11033 } 11034 public List<DdTagStartContext> ddTagStart() { 11035 return getRuleContexts(DdTagStartContext.class); 11036 } 11037 public DdTagStartContext ddTagStart(int i) { 11038 return getRuleContext(DdTagStartContext.class,i); 11039 } 11040 public List<DtTagStartContext> dtTagStart() { 11041 return getRuleContexts(DtTagStartContext.class); 11042 } 11043 public DtTagStartContext dtTagStart(int i) { 11044 return getRuleContext(DtTagStartContext.class,i); 11045 } 11046 public List<HeadTagStartContext> headTagStart() { 11047 return getRuleContexts(HeadTagStartContext.class); 11048 } 11049 public HeadTagStartContext headTagStart(int i) { 11050 return getRuleContext(HeadTagStartContext.class,i); 11051 } 11052 public List<HtmlTagStartContext> htmlTagStart() { 11053 return getRuleContexts(HtmlTagStartContext.class); 11054 } 11055 public HtmlTagStartContext htmlTagStart(int i) { 11056 return getRuleContext(HtmlTagStartContext.class,i); 11057 } 11058 public List<OptionTagStartContext> optionTagStart() { 11059 return getRuleContexts(OptionTagStartContext.class); 11060 } 11061 public OptionTagStartContext optionTagStart(int i) { 11062 return getRuleContext(OptionTagStartContext.class,i); 11063 } 11064 public List<TheadTagStartContext> theadTagStart() { 11065 return getRuleContexts(TheadTagStartContext.class); 11066 } 11067 public TheadTagStartContext theadTagStart(int i) { 11068 return getRuleContext(TheadTagStartContext.class,i); 11069 } 11070 public List<TfootTagStartContext> tfootTagStart() { 11071 return getRuleContexts(TfootTagStartContext.class); 11072 } 11073 public TfootTagStartContext tfootTagStart(int i) { 11074 return getRuleContext(TfootTagStartContext.class,i); 11075 } 11076 public List<OptgroupTagStartContext> optgroupTagStart() { 11077 return getRuleContexts(OptgroupTagStartContext.class); 11078 } 11079 public OptgroupTagStartContext optgroupTagStart(int i) { 11080 return getRuleContext(OptgroupTagStartContext.class,i); 11081 } 11082 public List<RbTagStartContext> rbTagStart() { 11083 return getRuleContexts(RbTagStartContext.class); 11084 } 11085 public RbTagStartContext rbTagStart(int i) { 11086 return getRuleContext(RbTagStartContext.class,i); 11087 } 11088 public List<RtTagStartContext> rtTagStart() { 11089 return getRuleContexts(RtTagStartContext.class); 11090 } 11091 public RtTagStartContext rtTagStart(int i) { 11092 return getRuleContext(RtTagStartContext.class,i); 11093 } 11094 public List<RtcTagStartContext> rtcTagStart() { 11095 return getRuleContexts(RtcTagStartContext.class); 11096 } 11097 public RtcTagStartContext rtcTagStart(int i) { 11098 return getRuleContext(RtcTagStartContext.class,i); 11099 } 11100 public List<RpTagStartContext> rpTagStart() { 11101 return getRuleContexts(RpTagStartContext.class); 11102 } 11103 public RpTagStartContext rpTagStart(int i) { 11104 return getRuleContext(RpTagStartContext.class,i); 11105 } 11106 public List<HtmlCommentContext> htmlComment() { 11107 return getRuleContexts(HtmlCommentContext.class); 11108 } 11109 public HtmlCommentContext htmlComment(int i) { 11110 return getRuleContext(HtmlCommentContext.class,i); 11111 } 11112 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11113 public TerminalNode NEWLINE(int i) { 11114 return getToken(JavadocParser.NEWLINE, i); 11115 } 11116 public List<TextContext> text() { 11117 return getRuleContexts(TextContext.class); 11118 } 11119 public TextContext text(int i) { 11120 return getRuleContext(TextContext.class,i); 11121 } 11122 public List<JavadocInlineTagContext> javadocInlineTag() { 11123 return getRuleContexts(JavadocInlineTagContext.class); 11124 } 11125 public JavadocInlineTagContext javadocInlineTag(int i) { 11126 return getRuleContext(JavadocInlineTagContext.class,i); 11127 } 11128 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11129 public TerminalNode LEADING_ASTERISK(int i) { 11130 return getToken(JavadocParser.LEADING_ASTERISK, i); 11131 } 11132 public TbodyContext(ParserRuleContext parent, int invokingState) { 11133 super(parent, invokingState); 11134 } 11135 @Override public int getRuleIndex() { return RULE_tbody; } 11136 } 11137 11138 public final TbodyContext tbody() throws RecognitionException { 11139 TbodyContext _localctx = new TbodyContext(_ctx, getState()); 11140 enterRule(_localctx, 88, RULE_tbody); 11141 try { 11142 int _alt; 11143 enterOuterAlt(_localctx, 1); 11144 { 11145 setState(1302); 11146 tbodyTagStart(false); 11147 setState(1351); 11148 _errHandler.sync(this); 11149 _alt = getInterpreter().adaptivePredict(_input,78,_ctx); 11150 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 11151 if ( _alt==1 ) { 11152 { 11153 setState(1349); 11154 _errHandler.sync(this); 11155 switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) { 11156 case 1: 11157 { 11158 setState(1303); 11159 htmlTag(); 11160 } 11161 break; 11162 case 2: 11163 { 11164 setState(1304); 11165 singletonElement(); 11166 } 11167 break; 11168 case 3: 11169 { 11170 setState(1305); 11171 paragraph(); 11172 } 11173 break; 11174 case 4: 11175 { 11176 setState(1306); 11177 li(); 11178 } 11179 break; 11180 case 5: 11181 { 11182 setState(1307); 11183 tr(); 11184 } 11185 break; 11186 case 6: 11187 { 11188 setState(1308); 11189 td(); 11190 } 11191 break; 11192 case 7: 11193 { 11194 setState(1309); 11195 th(); 11196 } 11197 break; 11198 case 8: 11199 { 11200 setState(1310); 11201 body(); 11202 } 11203 break; 11204 case 9: 11205 { 11206 setState(1311); 11207 colgroup(); 11208 } 11209 break; 11210 case 10: 11211 { 11212 setState(1312); 11213 dd(); 11214 } 11215 break; 11216 case 11: 11217 { 11218 setState(1313); 11219 dt(); 11220 } 11221 break; 11222 case 12: 11223 { 11224 setState(1314); 11225 head(); 11226 } 11227 break; 11228 case 13: 11229 { 11230 setState(1315); 11231 html(); 11232 } 11233 break; 11234 case 14: 11235 { 11236 setState(1316); 11237 option(); 11238 } 11239 break; 11240 case 15: 11241 { 11242 setState(1317); 11243 thead(); 11244 } 11245 break; 11246 case 16: 11247 { 11248 setState(1318); 11249 tfoot(); 11250 } 11251 break; 11252 case 17: 11253 { 11254 setState(1319); 11255 optgroup(); 11256 } 11257 break; 11258 case 18: 11259 { 11260 setState(1320); 11261 rb(); 11262 } 11263 break; 11264 case 19: 11265 { 11266 setState(1321); 11267 rt(); 11268 } 11269 break; 11270 case 20: 11271 { 11272 setState(1322); 11273 rtc(); 11274 } 11275 break; 11276 case 21: 11277 { 11278 setState(1323); 11279 rp(); 11280 } 11281 break; 11282 case 22: 11283 { 11284 setState(1324); 11285 pTagStart(true); 11286 } 11287 break; 11288 case 23: 11289 { 11290 setState(1325); 11291 liTagStart(true); 11292 } 11293 break; 11294 case 24: 11295 { 11296 setState(1326); 11297 trTagStart(true); 11298 } 11299 break; 11300 case 25: 11301 { 11302 setState(1327); 11303 tdTagStart(true); 11304 } 11305 break; 11306 case 26: 11307 { 11308 setState(1328); 11309 thTagStart(true); 11310 } 11311 break; 11312 case 27: 11313 { 11314 setState(1329); 11315 bodyTagStart(true); 11316 } 11317 break; 11318 case 28: 11319 { 11320 setState(1330); 11321 colgroupTagStart(true); 11322 } 11323 break; 11324 case 29: 11325 { 11326 setState(1331); 11327 ddTagStart(true); 11328 } 11329 break; 11330 case 30: 11331 { 11332 setState(1332); 11333 dtTagStart(true); 11334 } 11335 break; 11336 case 31: 11337 { 11338 setState(1333); 11339 headTagStart(true); 11340 } 11341 break; 11342 case 32: 11343 { 11344 setState(1334); 11345 htmlTagStart(true); 11346 } 11347 break; 11348 case 33: 11349 { 11350 setState(1335); 11351 optionTagStart(true); 11352 } 11353 break; 11354 case 34: 11355 { 11356 setState(1336); 11357 theadTagStart(true); 11358 } 11359 break; 11360 case 35: 11361 { 11362 setState(1337); 11363 tfootTagStart(true); 11364 } 11365 break; 11366 case 36: 11367 { 11368 setState(1338); 11369 optgroupTagStart(true); 11370 } 11371 break; 11372 case 37: 11373 { 11374 setState(1339); 11375 rbTagStart(true); 11376 } 11377 break; 11378 case 38: 11379 { 11380 setState(1340); 11381 rtTagStart(true); 11382 } 11383 break; 11384 case 39: 11385 { 11386 setState(1341); 11387 rtcTagStart(true); 11388 } 11389 break; 11390 case 40: 11391 { 11392 setState(1342); 11393 rpTagStart(true); 11394 } 11395 break; 11396 case 41: 11397 { 11398 { 11399 setState(1343); 11400 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 11401 setState(1344); 11402 match(LEADING_ASTERISK); 11403 } 11404 } 11405 break; 11406 case 42: 11407 { 11408 setState(1345); 11409 htmlComment(); 11410 } 11411 break; 11412 case 43: 11413 { 11414 setState(1346); 11415 match(NEWLINE); 11416 } 11417 break; 11418 case 44: 11419 { 11420 setState(1347); 11421 text(); 11422 } 11423 break; 11424 case 45: 11425 { 11426 setState(1348); 11427 javadocInlineTag(); 11428 } 11429 break; 11430 } 11431 } 11432 } 11433 setState(1353); 11434 _errHandler.sync(this); 11435 _alt = getInterpreter().adaptivePredict(_input,78,_ctx); 11436 } 11437 setState(1354); 11438 tbodyTagEnd(); 11439 } 11440 } 11441 catch (RecognitionException re) { 11442 _localctx.exception = re; 11443 _errHandler.reportError(this, re); 11444 _errHandler.recover(this, re); 11445 } 11446 finally { 11447 exitRule(); 11448 } 11449 return _localctx; 11450 } 11451 11452 public static class TfootTagStartContext extends ParserRuleContext { 11453 public boolean isNonTight; 11454 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 11455 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 11456 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 11457 public List<AttributeContext> attribute() { 11458 return getRuleContexts(AttributeContext.class); 11459 } 11460 public AttributeContext attribute(int i) { 11461 return getRuleContext(AttributeContext.class,i); 11462 } 11463 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11464 public TerminalNode NEWLINE(int i) { 11465 return getToken(JavadocParser.NEWLINE, i); 11466 } 11467 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11468 public TerminalNode LEADING_ASTERISK(int i) { 11469 return getToken(JavadocParser.LEADING_ASTERISK, i); 11470 } 11471 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11472 public TerminalNode WS(int i) { 11473 return getToken(JavadocParser.WS, i); 11474 } 11475 public TfootTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 11476 public TfootTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 11477 super(parent, invokingState); 11478 this.isNonTight = isNonTight; 11479 } 11480 @Override public int getRuleIndex() { return RULE_tfootTagStart; } 11481 } 11482 11483 public final TfootTagStartContext tfootTagStart(boolean isNonTight) throws RecognitionException { 11484 TfootTagStartContext _localctx = new TfootTagStartContext(_ctx, getState(), isNonTight); 11485 enterRule(_localctx, 90, RULE_tfootTagStart); 11486 int _la; 11487 try { 11488 enterOuterAlt(_localctx, 1); 11489 { 11490 setState(1356); 11491 match(START); 11492 setState(1357); 11493 match(TFOOT_HTML_TAG_NAME); 11494 setState(1364); 11495 _errHandler.sync(this); 11496 _la = _input.LA(1); 11497 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11498 { 11499 setState(1362); 11500 _errHandler.sync(this); 11501 switch (_input.LA(1)) { 11502 case HTML_TAG_NAME: 11503 { 11504 setState(1358); 11505 attribute(); 11506 } 11507 break; 11508 case NEWLINE: 11509 { 11510 setState(1359); 11511 match(NEWLINE); 11512 } 11513 break; 11514 case LEADING_ASTERISK: 11515 { 11516 setState(1360); 11517 match(LEADING_ASTERISK); 11518 } 11519 break; 11520 case WS: 11521 { 11522 setState(1361); 11523 match(WS); 11524 } 11525 break; 11526 default: 11527 throw new NoViableAltException(this); 11528 } 11529 } 11530 setState(1366); 11531 _errHandler.sync(this); 11532 _la = _input.LA(1); 11533 } 11534 setState(1367); 11535 match(END); 11536 } 11537 _ctx.stop = _input.LT(-1); 11538 11539 if (isNonTight && nonTightTagStartContext == null) { 11540 nonTightTagStartContext = _localctx; 11541 } 11542 11543 } 11544 catch (RecognitionException re) { 11545 _localctx.exception = re; 11546 _errHandler.reportError(this, re); 11547 _errHandler.recover(this, re); 11548 } 11549 finally { 11550 exitRule(); 11551 } 11552 return _localctx; 11553 } 11554 11555 public static class TfootTagEndContext extends ParserRuleContext { 11556 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 11557 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 11558 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 11559 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 11560 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11561 public TerminalNode NEWLINE(int i) { 11562 return getToken(JavadocParser.NEWLINE, i); 11563 } 11564 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11565 public TerminalNode LEADING_ASTERISK(int i) { 11566 return getToken(JavadocParser.LEADING_ASTERISK, i); 11567 } 11568 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11569 public TerminalNode WS(int i) { 11570 return getToken(JavadocParser.WS, i); 11571 } 11572 public TfootTagEndContext(ParserRuleContext parent, int invokingState) { 11573 super(parent, invokingState); 11574 } 11575 @Override public int getRuleIndex() { return RULE_tfootTagEnd; } 11576 } 11577 11578 public final TfootTagEndContext tfootTagEnd() throws RecognitionException { 11579 TfootTagEndContext _localctx = new TfootTagEndContext(_ctx, getState()); 11580 enterRule(_localctx, 92, RULE_tfootTagEnd); 11581 int _la; 11582 try { 11583 enterOuterAlt(_localctx, 1); 11584 { 11585 setState(1369); 11586 match(START); 11587 setState(1370); 11588 match(SLASH); 11589 setState(1371); 11590 match(TFOOT_HTML_TAG_NAME); 11591 setState(1375); 11592 _errHandler.sync(this); 11593 _la = _input.LA(1); 11594 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 11595 { 11596 { 11597 setState(1372); 11598 _la = _input.LA(1); 11599 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 11600 _errHandler.recoverInline(this); 11601 } 11602 else { 11603 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 11604 _errHandler.reportMatch(this); 11605 consume(); 11606 } 11607 } 11608 } 11609 setState(1377); 11610 _errHandler.sync(this); 11611 _la = _input.LA(1); 11612 } 11613 setState(1378); 11614 match(END); 11615 } 11616 } 11617 catch (RecognitionException re) { 11618 _localctx.exception = re; 11619 _errHandler.reportError(this, re); 11620 _errHandler.recover(this, re); 11621 } 11622 finally { 11623 exitRule(); 11624 } 11625 return _localctx; 11626 } 11627 11628 public static class TfootContext extends ParserRuleContext { 11629 public TfootTagStartContext tfootTagStart() { 11630 return getRuleContext(TfootTagStartContext.class,0); 11631 } 11632 public TfootTagEndContext tfootTagEnd() { 11633 return getRuleContext(TfootTagEndContext.class,0); 11634 } 11635 public List<HtmlTagContext> htmlTag() { 11636 return getRuleContexts(HtmlTagContext.class); 11637 } 11638 public HtmlTagContext htmlTag(int i) { 11639 return getRuleContext(HtmlTagContext.class,i); 11640 } 11641 public List<SingletonElementContext> singletonElement() { 11642 return getRuleContexts(SingletonElementContext.class); 11643 } 11644 public SingletonElementContext singletonElement(int i) { 11645 return getRuleContext(SingletonElementContext.class,i); 11646 } 11647 public List<ParagraphContext> paragraph() { 11648 return getRuleContexts(ParagraphContext.class); 11649 } 11650 public ParagraphContext paragraph(int i) { 11651 return getRuleContext(ParagraphContext.class,i); 11652 } 11653 public List<LiContext> li() { 11654 return getRuleContexts(LiContext.class); 11655 } 11656 public LiContext li(int i) { 11657 return getRuleContext(LiContext.class,i); 11658 } 11659 public List<TrContext> tr() { 11660 return getRuleContexts(TrContext.class); 11661 } 11662 public TrContext tr(int i) { 11663 return getRuleContext(TrContext.class,i); 11664 } 11665 public List<TdContext> td() { 11666 return getRuleContexts(TdContext.class); 11667 } 11668 public TdContext td(int i) { 11669 return getRuleContext(TdContext.class,i); 11670 } 11671 public List<ThContext> th() { 11672 return getRuleContexts(ThContext.class); 11673 } 11674 public ThContext th(int i) { 11675 return getRuleContext(ThContext.class,i); 11676 } 11677 public List<BodyContext> body() { 11678 return getRuleContexts(BodyContext.class); 11679 } 11680 public BodyContext body(int i) { 11681 return getRuleContext(BodyContext.class,i); 11682 } 11683 public List<ColgroupContext> colgroup() { 11684 return getRuleContexts(ColgroupContext.class); 11685 } 11686 public ColgroupContext colgroup(int i) { 11687 return getRuleContext(ColgroupContext.class,i); 11688 } 11689 public List<DdContext> dd() { 11690 return getRuleContexts(DdContext.class); 11691 } 11692 public DdContext dd(int i) { 11693 return getRuleContext(DdContext.class,i); 11694 } 11695 public List<DtContext> dt() { 11696 return getRuleContexts(DtContext.class); 11697 } 11698 public DtContext dt(int i) { 11699 return getRuleContext(DtContext.class,i); 11700 } 11701 public List<HeadContext> head() { 11702 return getRuleContexts(HeadContext.class); 11703 } 11704 public HeadContext head(int i) { 11705 return getRuleContext(HeadContext.class,i); 11706 } 11707 public List<HtmlContext> html() { 11708 return getRuleContexts(HtmlContext.class); 11709 } 11710 public HtmlContext html(int i) { 11711 return getRuleContext(HtmlContext.class,i); 11712 } 11713 public List<OptionContext> option() { 11714 return getRuleContexts(OptionContext.class); 11715 } 11716 public OptionContext option(int i) { 11717 return getRuleContext(OptionContext.class,i); 11718 } 11719 public List<TbodyContext> tbody() { 11720 return getRuleContexts(TbodyContext.class); 11721 } 11722 public TbodyContext tbody(int i) { 11723 return getRuleContext(TbodyContext.class,i); 11724 } 11725 public List<TheadContext> thead() { 11726 return getRuleContexts(TheadContext.class); 11727 } 11728 public TheadContext thead(int i) { 11729 return getRuleContext(TheadContext.class,i); 11730 } 11731 public List<OptgroupContext> optgroup() { 11732 return getRuleContexts(OptgroupContext.class); 11733 } 11734 public OptgroupContext optgroup(int i) { 11735 return getRuleContext(OptgroupContext.class,i); 11736 } 11737 public List<RbContext> rb() { 11738 return getRuleContexts(RbContext.class); 11739 } 11740 public RbContext rb(int i) { 11741 return getRuleContext(RbContext.class,i); 11742 } 11743 public List<RtContext> rt() { 11744 return getRuleContexts(RtContext.class); 11745 } 11746 public RtContext rt(int i) { 11747 return getRuleContext(RtContext.class,i); 11748 } 11749 public List<RtcContext> rtc() { 11750 return getRuleContexts(RtcContext.class); 11751 } 11752 public RtcContext rtc(int i) { 11753 return getRuleContext(RtcContext.class,i); 11754 } 11755 public List<RpContext> rp() { 11756 return getRuleContexts(RpContext.class); 11757 } 11758 public RpContext rp(int i) { 11759 return getRuleContext(RpContext.class,i); 11760 } 11761 public List<PTagStartContext> pTagStart() { 11762 return getRuleContexts(PTagStartContext.class); 11763 } 11764 public PTagStartContext pTagStart(int i) { 11765 return getRuleContext(PTagStartContext.class,i); 11766 } 11767 public List<LiTagStartContext> liTagStart() { 11768 return getRuleContexts(LiTagStartContext.class); 11769 } 11770 public LiTagStartContext liTagStart(int i) { 11771 return getRuleContext(LiTagStartContext.class,i); 11772 } 11773 public List<TrTagStartContext> trTagStart() { 11774 return getRuleContexts(TrTagStartContext.class); 11775 } 11776 public TrTagStartContext trTagStart(int i) { 11777 return getRuleContext(TrTagStartContext.class,i); 11778 } 11779 public List<TdTagStartContext> tdTagStart() { 11780 return getRuleContexts(TdTagStartContext.class); 11781 } 11782 public TdTagStartContext tdTagStart(int i) { 11783 return getRuleContext(TdTagStartContext.class,i); 11784 } 11785 public List<ThTagStartContext> thTagStart() { 11786 return getRuleContexts(ThTagStartContext.class); 11787 } 11788 public ThTagStartContext thTagStart(int i) { 11789 return getRuleContext(ThTagStartContext.class,i); 11790 } 11791 public List<BodyTagStartContext> bodyTagStart() { 11792 return getRuleContexts(BodyTagStartContext.class); 11793 } 11794 public BodyTagStartContext bodyTagStart(int i) { 11795 return getRuleContext(BodyTagStartContext.class,i); 11796 } 11797 public List<ColgroupTagStartContext> colgroupTagStart() { 11798 return getRuleContexts(ColgroupTagStartContext.class); 11799 } 11800 public ColgroupTagStartContext colgroupTagStart(int i) { 11801 return getRuleContext(ColgroupTagStartContext.class,i); 11802 } 11803 public List<DdTagStartContext> ddTagStart() { 11804 return getRuleContexts(DdTagStartContext.class); 11805 } 11806 public DdTagStartContext ddTagStart(int i) { 11807 return getRuleContext(DdTagStartContext.class,i); 11808 } 11809 public List<DtTagStartContext> dtTagStart() { 11810 return getRuleContexts(DtTagStartContext.class); 11811 } 11812 public DtTagStartContext dtTagStart(int i) { 11813 return getRuleContext(DtTagStartContext.class,i); 11814 } 11815 public List<HeadTagStartContext> headTagStart() { 11816 return getRuleContexts(HeadTagStartContext.class); 11817 } 11818 public HeadTagStartContext headTagStart(int i) { 11819 return getRuleContext(HeadTagStartContext.class,i); 11820 } 11821 public List<HtmlTagStartContext> htmlTagStart() { 11822 return getRuleContexts(HtmlTagStartContext.class); 11823 } 11824 public HtmlTagStartContext htmlTagStart(int i) { 11825 return getRuleContext(HtmlTagStartContext.class,i); 11826 } 11827 public List<OptionTagStartContext> optionTagStart() { 11828 return getRuleContexts(OptionTagStartContext.class); 11829 } 11830 public OptionTagStartContext optionTagStart(int i) { 11831 return getRuleContext(OptionTagStartContext.class,i); 11832 } 11833 public List<TbodyTagStartContext> tbodyTagStart() { 11834 return getRuleContexts(TbodyTagStartContext.class); 11835 } 11836 public TbodyTagStartContext tbodyTagStart(int i) { 11837 return getRuleContext(TbodyTagStartContext.class,i); 11838 } 11839 public List<TheadTagStartContext> theadTagStart() { 11840 return getRuleContexts(TheadTagStartContext.class); 11841 } 11842 public TheadTagStartContext theadTagStart(int i) { 11843 return getRuleContext(TheadTagStartContext.class,i); 11844 } 11845 public List<OptgroupTagStartContext> optgroupTagStart() { 11846 return getRuleContexts(OptgroupTagStartContext.class); 11847 } 11848 public OptgroupTagStartContext optgroupTagStart(int i) { 11849 return getRuleContext(OptgroupTagStartContext.class,i); 11850 } 11851 public List<RbTagStartContext> rbTagStart() { 11852 return getRuleContexts(RbTagStartContext.class); 11853 } 11854 public RbTagStartContext rbTagStart(int i) { 11855 return getRuleContext(RbTagStartContext.class,i); 11856 } 11857 public List<RtTagStartContext> rtTagStart() { 11858 return getRuleContexts(RtTagStartContext.class); 11859 } 11860 public RtTagStartContext rtTagStart(int i) { 11861 return getRuleContext(RtTagStartContext.class,i); 11862 } 11863 public List<RtcTagStartContext> rtcTagStart() { 11864 return getRuleContexts(RtcTagStartContext.class); 11865 } 11866 public RtcTagStartContext rtcTagStart(int i) { 11867 return getRuleContext(RtcTagStartContext.class,i); 11868 } 11869 public List<RpTagStartContext> rpTagStart() { 11870 return getRuleContexts(RpTagStartContext.class); 11871 } 11872 public RpTagStartContext rpTagStart(int i) { 11873 return getRuleContext(RpTagStartContext.class,i); 11874 } 11875 public List<HtmlCommentContext> htmlComment() { 11876 return getRuleContexts(HtmlCommentContext.class); 11877 } 11878 public HtmlCommentContext htmlComment(int i) { 11879 return getRuleContext(HtmlCommentContext.class,i); 11880 } 11881 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11882 public TerminalNode NEWLINE(int i) { 11883 return getToken(JavadocParser.NEWLINE, i); 11884 } 11885 public List<TextContext> text() { 11886 return getRuleContexts(TextContext.class); 11887 } 11888 public TextContext text(int i) { 11889 return getRuleContext(TextContext.class,i); 11890 } 11891 public List<JavadocInlineTagContext> javadocInlineTag() { 11892 return getRuleContexts(JavadocInlineTagContext.class); 11893 } 11894 public JavadocInlineTagContext javadocInlineTag(int i) { 11895 return getRuleContext(JavadocInlineTagContext.class,i); 11896 } 11897 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11898 public TerminalNode LEADING_ASTERISK(int i) { 11899 return getToken(JavadocParser.LEADING_ASTERISK, i); 11900 } 11901 public TfootContext(ParserRuleContext parent, int invokingState) { 11902 super(parent, invokingState); 11903 } 11904 @Override public int getRuleIndex() { return RULE_tfoot; } 11905 } 11906 11907 public final TfootContext tfoot() throws RecognitionException { 11908 TfootContext _localctx = new TfootContext(_ctx, getState()); 11909 enterRule(_localctx, 94, RULE_tfoot); 11910 try { 11911 int _alt; 11912 enterOuterAlt(_localctx, 1); 11913 { 11914 setState(1380); 11915 tfootTagStart(false); 11916 setState(1429); 11917 _errHandler.sync(this); 11918 _alt = getInterpreter().adaptivePredict(_input,83,_ctx); 11919 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 11920 if ( _alt==1 ) { 11921 { 11922 setState(1427); 11923 _errHandler.sync(this); 11924 switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) { 11925 case 1: 11926 { 11927 setState(1381); 11928 htmlTag(); 11929 } 11930 break; 11931 case 2: 11932 { 11933 setState(1382); 11934 singletonElement(); 11935 } 11936 break; 11937 case 3: 11938 { 11939 setState(1383); 11940 paragraph(); 11941 } 11942 break; 11943 case 4: 11944 { 11945 setState(1384); 11946 li(); 11947 } 11948 break; 11949 case 5: 11950 { 11951 setState(1385); 11952 tr(); 11953 } 11954 break; 11955 case 6: 11956 { 11957 setState(1386); 11958 td(); 11959 } 11960 break; 11961 case 7: 11962 { 11963 setState(1387); 11964 th(); 11965 } 11966 break; 11967 case 8: 11968 { 11969 setState(1388); 11970 body(); 11971 } 11972 break; 11973 case 9: 11974 { 11975 setState(1389); 11976 colgroup(); 11977 } 11978 break; 11979 case 10: 11980 { 11981 setState(1390); 11982 dd(); 11983 } 11984 break; 11985 case 11: 11986 { 11987 setState(1391); 11988 dt(); 11989 } 11990 break; 11991 case 12: 11992 { 11993 setState(1392); 11994 head(); 11995 } 11996 break; 11997 case 13: 11998 { 11999 setState(1393); 12000 html(); 12001 } 12002 break; 12003 case 14: 12004 { 12005 setState(1394); 12006 option(); 12007 } 12008 break; 12009 case 15: 12010 { 12011 setState(1395); 12012 tbody(); 12013 } 12014 break; 12015 case 16: 12016 { 12017 setState(1396); 12018 thead(); 12019 } 12020 break; 12021 case 17: 12022 { 12023 setState(1397); 12024 optgroup(); 12025 } 12026 break; 12027 case 18: 12028 { 12029 setState(1398); 12030 rb(); 12031 } 12032 break; 12033 case 19: 12034 { 12035 setState(1399); 12036 rt(); 12037 } 12038 break; 12039 case 20: 12040 { 12041 setState(1400); 12042 rtc(); 12043 } 12044 break; 12045 case 21: 12046 { 12047 setState(1401); 12048 rp(); 12049 } 12050 break; 12051 case 22: 12052 { 12053 setState(1402); 12054 pTagStart(true); 12055 } 12056 break; 12057 case 23: 12058 { 12059 setState(1403); 12060 liTagStart(true); 12061 } 12062 break; 12063 case 24: 12064 { 12065 setState(1404); 12066 trTagStart(true); 12067 } 12068 break; 12069 case 25: 12070 { 12071 setState(1405); 12072 tdTagStart(true); 12073 } 12074 break; 12075 case 26: 12076 { 12077 setState(1406); 12078 thTagStart(true); 12079 } 12080 break; 12081 case 27: 12082 { 12083 setState(1407); 12084 bodyTagStart(true); 12085 } 12086 break; 12087 case 28: 12088 { 12089 setState(1408); 12090 colgroupTagStart(true); 12091 } 12092 break; 12093 case 29: 12094 { 12095 setState(1409); 12096 ddTagStart(true); 12097 } 12098 break; 12099 case 30: 12100 { 12101 setState(1410); 12102 dtTagStart(true); 12103 } 12104 break; 12105 case 31: 12106 { 12107 setState(1411); 12108 headTagStart(true); 12109 } 12110 break; 12111 case 32: 12112 { 12113 setState(1412); 12114 htmlTagStart(true); 12115 } 12116 break; 12117 case 33: 12118 { 12119 setState(1413); 12120 optionTagStart(true); 12121 } 12122 break; 12123 case 34: 12124 { 12125 setState(1414); 12126 tbodyTagStart(true); 12127 } 12128 break; 12129 case 35: 12130 { 12131 setState(1415); 12132 theadTagStart(true); 12133 } 12134 break; 12135 case 36: 12136 { 12137 setState(1416); 12138 optgroupTagStart(true); 12139 } 12140 break; 12141 case 37: 12142 { 12143 setState(1417); 12144 rbTagStart(true); 12145 } 12146 break; 12147 case 38: 12148 { 12149 setState(1418); 12150 rtTagStart(true); 12151 } 12152 break; 12153 case 39: 12154 { 12155 setState(1419); 12156 rtcTagStart(true); 12157 } 12158 break; 12159 case 40: 12160 { 12161 setState(1420); 12162 rpTagStart(true); 12163 } 12164 break; 12165 case 41: 12166 { 12167 { 12168 setState(1421); 12169 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 12170 setState(1422); 12171 match(LEADING_ASTERISK); 12172 } 12173 } 12174 break; 12175 case 42: 12176 { 12177 setState(1423); 12178 htmlComment(); 12179 } 12180 break; 12181 case 43: 12182 { 12183 setState(1424); 12184 match(NEWLINE); 12185 } 12186 break; 12187 case 44: 12188 { 12189 setState(1425); 12190 text(); 12191 } 12192 break; 12193 case 45: 12194 { 12195 setState(1426); 12196 javadocInlineTag(); 12197 } 12198 break; 12199 } 12200 } 12201 } 12202 setState(1431); 12203 _errHandler.sync(this); 12204 _alt = getInterpreter().adaptivePredict(_input,83,_ctx); 12205 } 12206 setState(1432); 12207 tfootTagEnd(); 12208 } 12209 } 12210 catch (RecognitionException re) { 12211 _localctx.exception = re; 12212 _errHandler.reportError(this, re); 12213 _errHandler.recover(this, re); 12214 } 12215 finally { 12216 exitRule(); 12217 } 12218 return _localctx; 12219 } 12220 12221 public static class TheadTagStartContext extends ParserRuleContext { 12222 public boolean isNonTight; 12223 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 12224 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 12225 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 12226 public List<AttributeContext> attribute() { 12227 return getRuleContexts(AttributeContext.class); 12228 } 12229 public AttributeContext attribute(int i) { 12230 return getRuleContext(AttributeContext.class,i); 12231 } 12232 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12233 public TerminalNode NEWLINE(int i) { 12234 return getToken(JavadocParser.NEWLINE, i); 12235 } 12236 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12237 public TerminalNode LEADING_ASTERISK(int i) { 12238 return getToken(JavadocParser.LEADING_ASTERISK, i); 12239 } 12240 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12241 public TerminalNode WS(int i) { 12242 return getToken(JavadocParser.WS, i); 12243 } 12244 public TheadTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 12245 public TheadTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 12246 super(parent, invokingState); 12247 this.isNonTight = isNonTight; 12248 } 12249 @Override public int getRuleIndex() { return RULE_theadTagStart; } 12250 } 12251 12252 public final TheadTagStartContext theadTagStart(boolean isNonTight) throws RecognitionException { 12253 TheadTagStartContext _localctx = new TheadTagStartContext(_ctx, getState(), isNonTight); 12254 enterRule(_localctx, 96, RULE_theadTagStart); 12255 int _la; 12256 try { 12257 enterOuterAlt(_localctx, 1); 12258 { 12259 setState(1434); 12260 match(START); 12261 setState(1435); 12262 match(THEAD_HTML_TAG_NAME); 12263 setState(1442); 12264 _errHandler.sync(this); 12265 _la = _input.LA(1); 12266 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12267 { 12268 setState(1440); 12269 _errHandler.sync(this); 12270 switch (_input.LA(1)) { 12271 case HTML_TAG_NAME: 12272 { 12273 setState(1436); 12274 attribute(); 12275 } 12276 break; 12277 case NEWLINE: 12278 { 12279 setState(1437); 12280 match(NEWLINE); 12281 } 12282 break; 12283 case LEADING_ASTERISK: 12284 { 12285 setState(1438); 12286 match(LEADING_ASTERISK); 12287 } 12288 break; 12289 case WS: 12290 { 12291 setState(1439); 12292 match(WS); 12293 } 12294 break; 12295 default: 12296 throw new NoViableAltException(this); 12297 } 12298 } 12299 setState(1444); 12300 _errHandler.sync(this); 12301 _la = _input.LA(1); 12302 } 12303 setState(1445); 12304 match(END); 12305 } 12306 _ctx.stop = _input.LT(-1); 12307 12308 if (isNonTight && nonTightTagStartContext == null) { 12309 nonTightTagStartContext = _localctx; 12310 } 12311 12312 } 12313 catch (RecognitionException re) { 12314 _localctx.exception = re; 12315 _errHandler.reportError(this, re); 12316 _errHandler.recover(this, re); 12317 } 12318 finally { 12319 exitRule(); 12320 } 12321 return _localctx; 12322 } 12323 12324 public static class TheadTagEndContext extends ParserRuleContext { 12325 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 12326 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 12327 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 12328 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 12329 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12330 public TerminalNode NEWLINE(int i) { 12331 return getToken(JavadocParser.NEWLINE, i); 12332 } 12333 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12334 public TerminalNode LEADING_ASTERISK(int i) { 12335 return getToken(JavadocParser.LEADING_ASTERISK, i); 12336 } 12337 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12338 public TerminalNode WS(int i) { 12339 return getToken(JavadocParser.WS, i); 12340 } 12341 public TheadTagEndContext(ParserRuleContext parent, int invokingState) { 12342 super(parent, invokingState); 12343 } 12344 @Override public int getRuleIndex() { return RULE_theadTagEnd; } 12345 } 12346 12347 public final TheadTagEndContext theadTagEnd() throws RecognitionException { 12348 TheadTagEndContext _localctx = new TheadTagEndContext(_ctx, getState()); 12349 enterRule(_localctx, 98, RULE_theadTagEnd); 12350 int _la; 12351 try { 12352 enterOuterAlt(_localctx, 1); 12353 { 12354 setState(1447); 12355 match(START); 12356 setState(1448); 12357 match(SLASH); 12358 setState(1449); 12359 match(THEAD_HTML_TAG_NAME); 12360 setState(1453); 12361 _errHandler.sync(this); 12362 _la = _input.LA(1); 12363 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 12364 { 12365 { 12366 setState(1450); 12367 _la = _input.LA(1); 12368 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 12369 _errHandler.recoverInline(this); 12370 } 12371 else { 12372 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12373 _errHandler.reportMatch(this); 12374 consume(); 12375 } 12376 } 12377 } 12378 setState(1455); 12379 _errHandler.sync(this); 12380 _la = _input.LA(1); 12381 } 12382 setState(1456); 12383 match(END); 12384 } 12385 } 12386 catch (RecognitionException re) { 12387 _localctx.exception = re; 12388 _errHandler.reportError(this, re); 12389 _errHandler.recover(this, re); 12390 } 12391 finally { 12392 exitRule(); 12393 } 12394 return _localctx; 12395 } 12396 12397 public static class TheadContext extends ParserRuleContext { 12398 public TheadTagStartContext theadTagStart() { 12399 return getRuleContext(TheadTagStartContext.class,0); 12400 } 12401 public TheadTagEndContext theadTagEnd() { 12402 return getRuleContext(TheadTagEndContext.class,0); 12403 } 12404 public List<HtmlTagContext> htmlTag() { 12405 return getRuleContexts(HtmlTagContext.class); 12406 } 12407 public HtmlTagContext htmlTag(int i) { 12408 return getRuleContext(HtmlTagContext.class,i); 12409 } 12410 public List<SingletonElementContext> singletonElement() { 12411 return getRuleContexts(SingletonElementContext.class); 12412 } 12413 public SingletonElementContext singletonElement(int i) { 12414 return getRuleContext(SingletonElementContext.class,i); 12415 } 12416 public List<ParagraphContext> paragraph() { 12417 return getRuleContexts(ParagraphContext.class); 12418 } 12419 public ParagraphContext paragraph(int i) { 12420 return getRuleContext(ParagraphContext.class,i); 12421 } 12422 public List<LiContext> li() { 12423 return getRuleContexts(LiContext.class); 12424 } 12425 public LiContext li(int i) { 12426 return getRuleContext(LiContext.class,i); 12427 } 12428 public List<TrContext> tr() { 12429 return getRuleContexts(TrContext.class); 12430 } 12431 public TrContext tr(int i) { 12432 return getRuleContext(TrContext.class,i); 12433 } 12434 public List<TdContext> td() { 12435 return getRuleContexts(TdContext.class); 12436 } 12437 public TdContext td(int i) { 12438 return getRuleContext(TdContext.class,i); 12439 } 12440 public List<ThContext> th() { 12441 return getRuleContexts(ThContext.class); 12442 } 12443 public ThContext th(int i) { 12444 return getRuleContext(ThContext.class,i); 12445 } 12446 public List<BodyContext> body() { 12447 return getRuleContexts(BodyContext.class); 12448 } 12449 public BodyContext body(int i) { 12450 return getRuleContext(BodyContext.class,i); 12451 } 12452 public List<ColgroupContext> colgroup() { 12453 return getRuleContexts(ColgroupContext.class); 12454 } 12455 public ColgroupContext colgroup(int i) { 12456 return getRuleContext(ColgroupContext.class,i); 12457 } 12458 public List<DdContext> dd() { 12459 return getRuleContexts(DdContext.class); 12460 } 12461 public DdContext dd(int i) { 12462 return getRuleContext(DdContext.class,i); 12463 } 12464 public List<DtContext> dt() { 12465 return getRuleContexts(DtContext.class); 12466 } 12467 public DtContext dt(int i) { 12468 return getRuleContext(DtContext.class,i); 12469 } 12470 public List<HeadContext> head() { 12471 return getRuleContexts(HeadContext.class); 12472 } 12473 public HeadContext head(int i) { 12474 return getRuleContext(HeadContext.class,i); 12475 } 12476 public List<HtmlContext> html() { 12477 return getRuleContexts(HtmlContext.class); 12478 } 12479 public HtmlContext html(int i) { 12480 return getRuleContext(HtmlContext.class,i); 12481 } 12482 public List<OptionContext> option() { 12483 return getRuleContexts(OptionContext.class); 12484 } 12485 public OptionContext option(int i) { 12486 return getRuleContext(OptionContext.class,i); 12487 } 12488 public List<TbodyContext> tbody() { 12489 return getRuleContexts(TbodyContext.class); 12490 } 12491 public TbodyContext tbody(int i) { 12492 return getRuleContext(TbodyContext.class,i); 12493 } 12494 public List<TfootContext> tfoot() { 12495 return getRuleContexts(TfootContext.class); 12496 } 12497 public TfootContext tfoot(int i) { 12498 return getRuleContext(TfootContext.class,i); 12499 } 12500 public List<OptgroupContext> optgroup() { 12501 return getRuleContexts(OptgroupContext.class); 12502 } 12503 public OptgroupContext optgroup(int i) { 12504 return getRuleContext(OptgroupContext.class,i); 12505 } 12506 public List<RbContext> rb() { 12507 return getRuleContexts(RbContext.class); 12508 } 12509 public RbContext rb(int i) { 12510 return getRuleContext(RbContext.class,i); 12511 } 12512 public List<RtContext> rt() { 12513 return getRuleContexts(RtContext.class); 12514 } 12515 public RtContext rt(int i) { 12516 return getRuleContext(RtContext.class,i); 12517 } 12518 public List<RtcContext> rtc() { 12519 return getRuleContexts(RtcContext.class); 12520 } 12521 public RtcContext rtc(int i) { 12522 return getRuleContext(RtcContext.class,i); 12523 } 12524 public List<RpContext> rp() { 12525 return getRuleContexts(RpContext.class); 12526 } 12527 public RpContext rp(int i) { 12528 return getRuleContext(RpContext.class,i); 12529 } 12530 public List<PTagStartContext> pTagStart() { 12531 return getRuleContexts(PTagStartContext.class); 12532 } 12533 public PTagStartContext pTagStart(int i) { 12534 return getRuleContext(PTagStartContext.class,i); 12535 } 12536 public List<LiTagStartContext> liTagStart() { 12537 return getRuleContexts(LiTagStartContext.class); 12538 } 12539 public LiTagStartContext liTagStart(int i) { 12540 return getRuleContext(LiTagStartContext.class,i); 12541 } 12542 public List<TrTagStartContext> trTagStart() { 12543 return getRuleContexts(TrTagStartContext.class); 12544 } 12545 public TrTagStartContext trTagStart(int i) { 12546 return getRuleContext(TrTagStartContext.class,i); 12547 } 12548 public List<TdTagStartContext> tdTagStart() { 12549 return getRuleContexts(TdTagStartContext.class); 12550 } 12551 public TdTagStartContext tdTagStart(int i) { 12552 return getRuleContext(TdTagStartContext.class,i); 12553 } 12554 public List<ThTagStartContext> thTagStart() { 12555 return getRuleContexts(ThTagStartContext.class); 12556 } 12557 public ThTagStartContext thTagStart(int i) { 12558 return getRuleContext(ThTagStartContext.class,i); 12559 } 12560 public List<BodyTagStartContext> bodyTagStart() { 12561 return getRuleContexts(BodyTagStartContext.class); 12562 } 12563 public BodyTagStartContext bodyTagStart(int i) { 12564 return getRuleContext(BodyTagStartContext.class,i); 12565 } 12566 public List<ColgroupTagStartContext> colgroupTagStart() { 12567 return getRuleContexts(ColgroupTagStartContext.class); 12568 } 12569 public ColgroupTagStartContext colgroupTagStart(int i) { 12570 return getRuleContext(ColgroupTagStartContext.class,i); 12571 } 12572 public List<DdTagStartContext> ddTagStart() { 12573 return getRuleContexts(DdTagStartContext.class); 12574 } 12575 public DdTagStartContext ddTagStart(int i) { 12576 return getRuleContext(DdTagStartContext.class,i); 12577 } 12578 public List<DtTagStartContext> dtTagStart() { 12579 return getRuleContexts(DtTagStartContext.class); 12580 } 12581 public DtTagStartContext dtTagStart(int i) { 12582 return getRuleContext(DtTagStartContext.class,i); 12583 } 12584 public List<HeadTagStartContext> headTagStart() { 12585 return getRuleContexts(HeadTagStartContext.class); 12586 } 12587 public HeadTagStartContext headTagStart(int i) { 12588 return getRuleContext(HeadTagStartContext.class,i); 12589 } 12590 public List<HtmlTagStartContext> htmlTagStart() { 12591 return getRuleContexts(HtmlTagStartContext.class); 12592 } 12593 public HtmlTagStartContext htmlTagStart(int i) { 12594 return getRuleContext(HtmlTagStartContext.class,i); 12595 } 12596 public List<OptionTagStartContext> optionTagStart() { 12597 return getRuleContexts(OptionTagStartContext.class); 12598 } 12599 public OptionTagStartContext optionTagStart(int i) { 12600 return getRuleContext(OptionTagStartContext.class,i); 12601 } 12602 public List<TbodyTagStartContext> tbodyTagStart() { 12603 return getRuleContexts(TbodyTagStartContext.class); 12604 } 12605 public TbodyTagStartContext tbodyTagStart(int i) { 12606 return getRuleContext(TbodyTagStartContext.class,i); 12607 } 12608 public List<TfootTagStartContext> tfootTagStart() { 12609 return getRuleContexts(TfootTagStartContext.class); 12610 } 12611 public TfootTagStartContext tfootTagStart(int i) { 12612 return getRuleContext(TfootTagStartContext.class,i); 12613 } 12614 public List<OptgroupTagStartContext> optgroupTagStart() { 12615 return getRuleContexts(OptgroupTagStartContext.class); 12616 } 12617 public OptgroupTagStartContext optgroupTagStart(int i) { 12618 return getRuleContext(OptgroupTagStartContext.class,i); 12619 } 12620 public List<RbTagStartContext> rbTagStart() { 12621 return getRuleContexts(RbTagStartContext.class); 12622 } 12623 public RbTagStartContext rbTagStart(int i) { 12624 return getRuleContext(RbTagStartContext.class,i); 12625 } 12626 public List<RtTagStartContext> rtTagStart() { 12627 return getRuleContexts(RtTagStartContext.class); 12628 } 12629 public RtTagStartContext rtTagStart(int i) { 12630 return getRuleContext(RtTagStartContext.class,i); 12631 } 12632 public List<RtcTagStartContext> rtcTagStart() { 12633 return getRuleContexts(RtcTagStartContext.class); 12634 } 12635 public RtcTagStartContext rtcTagStart(int i) { 12636 return getRuleContext(RtcTagStartContext.class,i); 12637 } 12638 public List<RpTagStartContext> rpTagStart() { 12639 return getRuleContexts(RpTagStartContext.class); 12640 } 12641 public RpTagStartContext rpTagStart(int i) { 12642 return getRuleContext(RpTagStartContext.class,i); 12643 } 12644 public List<HtmlCommentContext> htmlComment() { 12645 return getRuleContexts(HtmlCommentContext.class); 12646 } 12647 public HtmlCommentContext htmlComment(int i) { 12648 return getRuleContext(HtmlCommentContext.class,i); 12649 } 12650 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12651 public TerminalNode NEWLINE(int i) { 12652 return getToken(JavadocParser.NEWLINE, i); 12653 } 12654 public List<TextContext> text() { 12655 return getRuleContexts(TextContext.class); 12656 } 12657 public TextContext text(int i) { 12658 return getRuleContext(TextContext.class,i); 12659 } 12660 public List<JavadocInlineTagContext> javadocInlineTag() { 12661 return getRuleContexts(JavadocInlineTagContext.class); 12662 } 12663 public JavadocInlineTagContext javadocInlineTag(int i) { 12664 return getRuleContext(JavadocInlineTagContext.class,i); 12665 } 12666 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12667 public TerminalNode LEADING_ASTERISK(int i) { 12668 return getToken(JavadocParser.LEADING_ASTERISK, i); 12669 } 12670 public TheadContext(ParserRuleContext parent, int invokingState) { 12671 super(parent, invokingState); 12672 } 12673 @Override public int getRuleIndex() { return RULE_thead; } 12674 } 12675 12676 public final TheadContext thead() throws RecognitionException { 12677 TheadContext _localctx = new TheadContext(_ctx, getState()); 12678 enterRule(_localctx, 100, RULE_thead); 12679 try { 12680 int _alt; 12681 enterOuterAlt(_localctx, 1); 12682 { 12683 setState(1458); 12684 theadTagStart(false); 12685 setState(1507); 12686 _errHandler.sync(this); 12687 _alt = getInterpreter().adaptivePredict(_input,88,_ctx); 12688 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 12689 if ( _alt==1 ) { 12690 { 12691 setState(1505); 12692 _errHandler.sync(this); 12693 switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) { 12694 case 1: 12695 { 12696 setState(1459); 12697 htmlTag(); 12698 } 12699 break; 12700 case 2: 12701 { 12702 setState(1460); 12703 singletonElement(); 12704 } 12705 break; 12706 case 3: 12707 { 12708 setState(1461); 12709 paragraph(); 12710 } 12711 break; 12712 case 4: 12713 { 12714 setState(1462); 12715 li(); 12716 } 12717 break; 12718 case 5: 12719 { 12720 setState(1463); 12721 tr(); 12722 } 12723 break; 12724 case 6: 12725 { 12726 setState(1464); 12727 td(); 12728 } 12729 break; 12730 case 7: 12731 { 12732 setState(1465); 12733 th(); 12734 } 12735 break; 12736 case 8: 12737 { 12738 setState(1466); 12739 body(); 12740 } 12741 break; 12742 case 9: 12743 { 12744 setState(1467); 12745 colgroup(); 12746 } 12747 break; 12748 case 10: 12749 { 12750 setState(1468); 12751 dd(); 12752 } 12753 break; 12754 case 11: 12755 { 12756 setState(1469); 12757 dt(); 12758 } 12759 break; 12760 case 12: 12761 { 12762 setState(1470); 12763 head(); 12764 } 12765 break; 12766 case 13: 12767 { 12768 setState(1471); 12769 html(); 12770 } 12771 break; 12772 case 14: 12773 { 12774 setState(1472); 12775 option(); 12776 } 12777 break; 12778 case 15: 12779 { 12780 setState(1473); 12781 tbody(); 12782 } 12783 break; 12784 case 16: 12785 { 12786 setState(1474); 12787 tfoot(); 12788 } 12789 break; 12790 case 17: 12791 { 12792 setState(1475); 12793 optgroup(); 12794 } 12795 break; 12796 case 18: 12797 { 12798 setState(1476); 12799 rb(); 12800 } 12801 break; 12802 case 19: 12803 { 12804 setState(1477); 12805 rt(); 12806 } 12807 break; 12808 case 20: 12809 { 12810 setState(1478); 12811 rtc(); 12812 } 12813 break; 12814 case 21: 12815 { 12816 setState(1479); 12817 rp(); 12818 } 12819 break; 12820 case 22: 12821 { 12822 setState(1480); 12823 pTagStart(true); 12824 } 12825 break; 12826 case 23: 12827 { 12828 setState(1481); 12829 liTagStart(true); 12830 } 12831 break; 12832 case 24: 12833 { 12834 setState(1482); 12835 trTagStart(true); 12836 } 12837 break; 12838 case 25: 12839 { 12840 setState(1483); 12841 tdTagStart(true); 12842 } 12843 break; 12844 case 26: 12845 { 12846 setState(1484); 12847 thTagStart(true); 12848 } 12849 break; 12850 case 27: 12851 { 12852 setState(1485); 12853 bodyTagStart(true); 12854 } 12855 break; 12856 case 28: 12857 { 12858 setState(1486); 12859 colgroupTagStart(true); 12860 } 12861 break; 12862 case 29: 12863 { 12864 setState(1487); 12865 ddTagStart(true); 12866 } 12867 break; 12868 case 30: 12869 { 12870 setState(1488); 12871 dtTagStart(true); 12872 } 12873 break; 12874 case 31: 12875 { 12876 setState(1489); 12877 headTagStart(true); 12878 } 12879 break; 12880 case 32: 12881 { 12882 setState(1490); 12883 htmlTagStart(true); 12884 } 12885 break; 12886 case 33: 12887 { 12888 setState(1491); 12889 optionTagStart(true); 12890 } 12891 break; 12892 case 34: 12893 { 12894 setState(1492); 12895 tbodyTagStart(true); 12896 } 12897 break; 12898 case 35: 12899 { 12900 setState(1493); 12901 tfootTagStart(true); 12902 } 12903 break; 12904 case 36: 12905 { 12906 setState(1494); 12907 optgroupTagStart(true); 12908 } 12909 break; 12910 case 37: 12911 { 12912 setState(1495); 12913 rbTagStart(true); 12914 } 12915 break; 12916 case 38: 12917 { 12918 setState(1496); 12919 rtTagStart(true); 12920 } 12921 break; 12922 case 39: 12923 { 12924 setState(1497); 12925 rtcTagStart(true); 12926 } 12927 break; 12928 case 40: 12929 { 12930 setState(1498); 12931 rpTagStart(true); 12932 } 12933 break; 12934 case 41: 12935 { 12936 { 12937 setState(1499); 12938 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 12939 setState(1500); 12940 match(LEADING_ASTERISK); 12941 } 12942 } 12943 break; 12944 case 42: 12945 { 12946 setState(1501); 12947 htmlComment(); 12948 } 12949 break; 12950 case 43: 12951 { 12952 setState(1502); 12953 match(NEWLINE); 12954 } 12955 break; 12956 case 44: 12957 { 12958 setState(1503); 12959 text(); 12960 } 12961 break; 12962 case 45: 12963 { 12964 setState(1504); 12965 javadocInlineTag(); 12966 } 12967 break; 12968 } 12969 } 12970 } 12971 setState(1509); 12972 _errHandler.sync(this); 12973 _alt = getInterpreter().adaptivePredict(_input,88,_ctx); 12974 } 12975 setState(1510); 12976 theadTagEnd(); 12977 } 12978 } 12979 catch (RecognitionException re) { 12980 _localctx.exception = re; 12981 _errHandler.reportError(this, re); 12982 _errHandler.recover(this, re); 12983 } 12984 finally { 12985 exitRule(); 12986 } 12987 return _localctx; 12988 } 12989 12990 public static class SingletonElementContext extends ParserRuleContext { 12991 public EmptyTagContext emptyTag() { 12992 return getRuleContext(EmptyTagContext.class,0); 12993 } 12994 public AreaTagContext areaTag() { 12995 return getRuleContext(AreaTagContext.class,0); 12996 } 12997 public BaseTagContext baseTag() { 12998 return getRuleContext(BaseTagContext.class,0); 12999 } 13000 public BasefontTagContext basefontTag() { 13001 return getRuleContext(BasefontTagContext.class,0); 13002 } 13003 public BrTagContext brTag() { 13004 return getRuleContext(BrTagContext.class,0); 13005 } 13006 public ColTagContext colTag() { 13007 return getRuleContext(ColTagContext.class,0); 13008 } 13009 public FrameTagContext frameTag() { 13010 return getRuleContext(FrameTagContext.class,0); 13011 } 13012 public HrTagContext hrTag() { 13013 return getRuleContext(HrTagContext.class,0); 13014 } 13015 public ImgTagContext imgTag() { 13016 return getRuleContext(ImgTagContext.class,0); 13017 } 13018 public InputTagContext inputTag() { 13019 return getRuleContext(InputTagContext.class,0); 13020 } 13021 public IsindexTagContext isindexTag() { 13022 return getRuleContext(IsindexTagContext.class,0); 13023 } 13024 public LinkTagContext linkTag() { 13025 return getRuleContext(LinkTagContext.class,0); 13026 } 13027 public MetaTagContext metaTag() { 13028 return getRuleContext(MetaTagContext.class,0); 13029 } 13030 public ParamTagContext paramTag() { 13031 return getRuleContext(ParamTagContext.class,0); 13032 } 13033 public EmbedTagContext embedTag() { 13034 return getRuleContext(EmbedTagContext.class,0); 13035 } 13036 public KeygenTagContext keygenTag() { 13037 return getRuleContext(KeygenTagContext.class,0); 13038 } 13039 public SourceTagContext sourceTag() { 13040 return getRuleContext(SourceTagContext.class,0); 13041 } 13042 public TrackTagContext trackTag() { 13043 return getRuleContext(TrackTagContext.class,0); 13044 } 13045 public WbrTagContext wbrTag() { 13046 return getRuleContext(WbrTagContext.class,0); 13047 } 13048 public WrongSingletonTagContext wrongSingletonTag() { 13049 return getRuleContext(WrongSingletonTagContext.class,0); 13050 } 13051 public SingletonElementContext(ParserRuleContext parent, int invokingState) { 13052 super(parent, invokingState); 13053 } 13054 @Override public int getRuleIndex() { return RULE_singletonElement; } 13055 } 13056 13057 public final SingletonElementContext singletonElement() throws RecognitionException { 13058 SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState()); 13059 enterRule(_localctx, 102, RULE_singletonElement); 13060 try { 13061 setState(1532); 13062 _errHandler.sync(this); 13063 switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) { 13064 case 1: 13065 enterOuterAlt(_localctx, 1); 13066 { 13067 setState(1512); 13068 emptyTag(); 13069 } 13070 break; 13071 case 2: 13072 enterOuterAlt(_localctx, 2); 13073 { 13074 setState(1513); 13075 areaTag(); 13076 } 13077 break; 13078 case 3: 13079 enterOuterAlt(_localctx, 3); 13080 { 13081 setState(1514); 13082 baseTag(); 13083 } 13084 break; 13085 case 4: 13086 enterOuterAlt(_localctx, 4); 13087 { 13088 setState(1515); 13089 basefontTag(); 13090 } 13091 break; 13092 case 5: 13093 enterOuterAlt(_localctx, 5); 13094 { 13095 setState(1516); 13096 brTag(); 13097 } 13098 break; 13099 case 6: 13100 enterOuterAlt(_localctx, 6); 13101 { 13102 setState(1517); 13103 colTag(); 13104 } 13105 break; 13106 case 7: 13107 enterOuterAlt(_localctx, 7); 13108 { 13109 setState(1518); 13110 frameTag(); 13111 } 13112 break; 13113 case 8: 13114 enterOuterAlt(_localctx, 8); 13115 { 13116 setState(1519); 13117 hrTag(); 13118 } 13119 break; 13120 case 9: 13121 enterOuterAlt(_localctx, 9); 13122 { 13123 setState(1520); 13124 imgTag(); 13125 } 13126 break; 13127 case 10: 13128 enterOuterAlt(_localctx, 10); 13129 { 13130 setState(1521); 13131 inputTag(); 13132 } 13133 break; 13134 case 11: 13135 enterOuterAlt(_localctx, 11); 13136 { 13137 setState(1522); 13138 isindexTag(); 13139 } 13140 break; 13141 case 12: 13142 enterOuterAlt(_localctx, 12); 13143 { 13144 setState(1523); 13145 linkTag(); 13146 } 13147 break; 13148 case 13: 13149 enterOuterAlt(_localctx, 13); 13150 { 13151 setState(1524); 13152 metaTag(); 13153 } 13154 break; 13155 case 14: 13156 enterOuterAlt(_localctx, 14); 13157 { 13158 setState(1525); 13159 paramTag(); 13160 } 13161 break; 13162 case 15: 13163 enterOuterAlt(_localctx, 15); 13164 { 13165 setState(1526); 13166 embedTag(); 13167 } 13168 break; 13169 case 16: 13170 enterOuterAlt(_localctx, 16); 13171 { 13172 setState(1527); 13173 keygenTag(); 13174 } 13175 break; 13176 case 17: 13177 enterOuterAlt(_localctx, 17); 13178 { 13179 setState(1528); 13180 sourceTag(); 13181 } 13182 break; 13183 case 18: 13184 enterOuterAlt(_localctx, 18); 13185 { 13186 setState(1529); 13187 trackTag(); 13188 } 13189 break; 13190 case 19: 13191 enterOuterAlt(_localctx, 19); 13192 { 13193 setState(1530); 13194 wbrTag(); 13195 } 13196 break; 13197 case 20: 13198 enterOuterAlt(_localctx, 20); 13199 { 13200 setState(1531); 13201 wrongSingletonTag(); 13202 } 13203 break; 13204 } 13205 } 13206 catch (RecognitionException re) { 13207 _localctx.exception = re; 13208 _errHandler.reportError(this, re); 13209 _errHandler.recover(this, re); 13210 } 13211 finally { 13212 exitRule(); 13213 } 13214 return _localctx; 13215 } 13216 13217 public static class EmptyTagContext extends ParserRuleContext { 13218 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13219 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13220 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 13221 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 13222 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 13223 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 13224 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 13225 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 13226 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 13227 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 13228 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 13229 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 13230 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 13231 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 13232 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 13233 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 13234 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 13235 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 13236 public List<AttributeContext> attribute() { 13237 return getRuleContexts(AttributeContext.class); 13238 } 13239 public AttributeContext attribute(int i) { 13240 return getRuleContext(AttributeContext.class,i); 13241 } 13242 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13243 public TerminalNode NEWLINE(int i) { 13244 return getToken(JavadocParser.NEWLINE, i); 13245 } 13246 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13247 public TerminalNode LEADING_ASTERISK(int i) { 13248 return getToken(JavadocParser.LEADING_ASTERISK, i); 13249 } 13250 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13251 public TerminalNode WS(int i) { 13252 return getToken(JavadocParser.WS, i); 13253 } 13254 public EmptyTagContext(ParserRuleContext parent, int invokingState) { 13255 super(parent, invokingState); 13256 } 13257 @Override public int getRuleIndex() { return RULE_emptyTag; } 13258 } 13259 13260 public final EmptyTagContext emptyTag() throws RecognitionException { 13261 EmptyTagContext _localctx = new EmptyTagContext(_ctx, getState()); 13262 enterRule(_localctx, 104, RULE_emptyTag); 13263 int _la; 13264 try { 13265 enterOuterAlt(_localctx, 1); 13266 { 13267 setState(1534); 13268 match(START); 13269 setState(1535); 13270 _la = _input.LA(1); 13271 if ( !(((((_la - 59)) & ~0x3f) == 0 && ((1L << (_la - 59)) & ((1L << (P_HTML_TAG_NAME - 59)) | (1L << (LI_HTML_TAG_NAME - 59)) | (1L << (TR_HTML_TAG_NAME - 59)) | (1L << (TD_HTML_TAG_NAME - 59)) | (1L << (TH_HTML_TAG_NAME - 59)) | (1L << (BODY_HTML_TAG_NAME - 59)) | (1L << (COLGROUP_HTML_TAG_NAME - 59)) | (1L << (DD_HTML_TAG_NAME - 59)) | (1L << (DT_HTML_TAG_NAME - 59)) | (1L << (HEAD_HTML_TAG_NAME - 59)) | (1L << (HTML_HTML_TAG_NAME - 59)) | (1L << (OPTION_HTML_TAG_NAME - 59)) | (1L << (TBODY_HTML_TAG_NAME - 59)) | (1L << (TFOOT_HTML_TAG_NAME - 59)) | (1L << (THEAD_HTML_TAG_NAME - 59)) | (1L << (HTML_TAG_NAME - 59)))) != 0)) ) { 13272 _errHandler.recoverInline(this); 13273 } 13274 else { 13275 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13276 _errHandler.reportMatch(this); 13277 consume(); 13278 } 13279 setState(1542); 13280 _errHandler.sync(this); 13281 _la = _input.LA(1); 13282 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13283 { 13284 setState(1540); 13285 _errHandler.sync(this); 13286 switch (_input.LA(1)) { 13287 case HTML_TAG_NAME: 13288 { 13289 setState(1536); 13290 attribute(); 13291 } 13292 break; 13293 case NEWLINE: 13294 { 13295 setState(1537); 13296 match(NEWLINE); 13297 } 13298 break; 13299 case LEADING_ASTERISK: 13300 { 13301 setState(1538); 13302 match(LEADING_ASTERISK); 13303 } 13304 break; 13305 case WS: 13306 { 13307 setState(1539); 13308 match(WS); 13309 } 13310 break; 13311 default: 13312 throw new NoViableAltException(this); 13313 } 13314 } 13315 setState(1544); 13316 _errHandler.sync(this); 13317 _la = _input.LA(1); 13318 } 13319 setState(1545); 13320 match(SLASH_END); 13321 } 13322 } 13323 catch (RecognitionException re) { 13324 _localctx.exception = re; 13325 _errHandler.reportError(this, re); 13326 _errHandler.recover(this, re); 13327 } 13328 finally { 13329 exitRule(); 13330 } 13331 return _localctx; 13332 } 13333 13334 public static class AreaTagContext extends ParserRuleContext { 13335 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13336 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 13337 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13338 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 13339 public List<AttributeContext> attribute() { 13340 return getRuleContexts(AttributeContext.class); 13341 } 13342 public AttributeContext attribute(int i) { 13343 return getRuleContext(AttributeContext.class,i); 13344 } 13345 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13346 public TerminalNode NEWLINE(int i) { 13347 return getToken(JavadocParser.NEWLINE, i); 13348 } 13349 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13350 public TerminalNode LEADING_ASTERISK(int i) { 13351 return getToken(JavadocParser.LEADING_ASTERISK, i); 13352 } 13353 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13354 public TerminalNode WS(int i) { 13355 return getToken(JavadocParser.WS, i); 13356 } 13357 public AreaTagContext(ParserRuleContext parent, int invokingState) { 13358 super(parent, invokingState); 13359 } 13360 @Override public int getRuleIndex() { return RULE_areaTag; } 13361 } 13362 13363 public final AreaTagContext areaTag() throws RecognitionException { 13364 AreaTagContext _localctx = new AreaTagContext(_ctx, getState()); 13365 enterRule(_localctx, 106, RULE_areaTag); 13366 int _la; 13367 try { 13368 enterOuterAlt(_localctx, 1); 13369 { 13370 setState(1547); 13371 match(START); 13372 setState(1548); 13373 match(AREA_HTML_TAG_NAME); 13374 setState(1555); 13375 _errHandler.sync(this); 13376 _la = _input.LA(1); 13377 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13378 { 13379 setState(1553); 13380 _errHandler.sync(this); 13381 switch (_input.LA(1)) { 13382 case HTML_TAG_NAME: 13383 { 13384 setState(1549); 13385 attribute(); 13386 } 13387 break; 13388 case NEWLINE: 13389 { 13390 setState(1550); 13391 match(NEWLINE); 13392 } 13393 break; 13394 case LEADING_ASTERISK: 13395 { 13396 setState(1551); 13397 match(LEADING_ASTERISK); 13398 } 13399 break; 13400 case WS: 13401 { 13402 setState(1552); 13403 match(WS); 13404 } 13405 break; 13406 default: 13407 throw new NoViableAltException(this); 13408 } 13409 } 13410 setState(1557); 13411 _errHandler.sync(this); 13412 _la = _input.LA(1); 13413 } 13414 setState(1558); 13415 _la = _input.LA(1); 13416 if ( !(_la==END || _la==SLASH_END) ) { 13417 _errHandler.recoverInline(this); 13418 } 13419 else { 13420 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13421 _errHandler.reportMatch(this); 13422 consume(); 13423 } 13424 } 13425 } 13426 catch (RecognitionException re) { 13427 _localctx.exception = re; 13428 _errHandler.reportError(this, re); 13429 _errHandler.recover(this, re); 13430 } 13431 finally { 13432 exitRule(); 13433 } 13434 return _localctx; 13435 } 13436 13437 public static class BaseTagContext extends ParserRuleContext { 13438 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13439 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 13440 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13441 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 13442 public List<AttributeContext> attribute() { 13443 return getRuleContexts(AttributeContext.class); 13444 } 13445 public AttributeContext attribute(int i) { 13446 return getRuleContext(AttributeContext.class,i); 13447 } 13448 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13449 public TerminalNode NEWLINE(int i) { 13450 return getToken(JavadocParser.NEWLINE, i); 13451 } 13452 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13453 public TerminalNode LEADING_ASTERISK(int i) { 13454 return getToken(JavadocParser.LEADING_ASTERISK, i); 13455 } 13456 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13457 public TerminalNode WS(int i) { 13458 return getToken(JavadocParser.WS, i); 13459 } 13460 public BaseTagContext(ParserRuleContext parent, int invokingState) { 13461 super(parent, invokingState); 13462 } 13463 @Override public int getRuleIndex() { return RULE_baseTag; } 13464 } 13465 13466 public final BaseTagContext baseTag() throws RecognitionException { 13467 BaseTagContext _localctx = new BaseTagContext(_ctx, getState()); 13468 enterRule(_localctx, 108, RULE_baseTag); 13469 int _la; 13470 try { 13471 enterOuterAlt(_localctx, 1); 13472 { 13473 setState(1560); 13474 match(START); 13475 setState(1561); 13476 match(BASE_HTML_TAG_NAME); 13477 setState(1568); 13478 _errHandler.sync(this); 13479 _la = _input.LA(1); 13480 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13481 { 13482 setState(1566); 13483 _errHandler.sync(this); 13484 switch (_input.LA(1)) { 13485 case HTML_TAG_NAME: 13486 { 13487 setState(1562); 13488 attribute(); 13489 } 13490 break; 13491 case NEWLINE: 13492 { 13493 setState(1563); 13494 match(NEWLINE); 13495 } 13496 break; 13497 case LEADING_ASTERISK: 13498 { 13499 setState(1564); 13500 match(LEADING_ASTERISK); 13501 } 13502 break; 13503 case WS: 13504 { 13505 setState(1565); 13506 match(WS); 13507 } 13508 break; 13509 default: 13510 throw new NoViableAltException(this); 13511 } 13512 } 13513 setState(1570); 13514 _errHandler.sync(this); 13515 _la = _input.LA(1); 13516 } 13517 setState(1571); 13518 _la = _input.LA(1); 13519 if ( !(_la==END || _la==SLASH_END) ) { 13520 _errHandler.recoverInline(this); 13521 } 13522 else { 13523 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13524 _errHandler.reportMatch(this); 13525 consume(); 13526 } 13527 } 13528 } 13529 catch (RecognitionException re) { 13530 _localctx.exception = re; 13531 _errHandler.reportError(this, re); 13532 _errHandler.recover(this, re); 13533 } 13534 finally { 13535 exitRule(); 13536 } 13537 return _localctx; 13538 } 13539 13540 public static class BasefontTagContext extends ParserRuleContext { 13541 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13542 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 13543 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13544 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 13545 public List<AttributeContext> attribute() { 13546 return getRuleContexts(AttributeContext.class); 13547 } 13548 public AttributeContext attribute(int i) { 13549 return getRuleContext(AttributeContext.class,i); 13550 } 13551 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13552 public TerminalNode NEWLINE(int i) { 13553 return getToken(JavadocParser.NEWLINE, i); 13554 } 13555 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13556 public TerminalNode LEADING_ASTERISK(int i) { 13557 return getToken(JavadocParser.LEADING_ASTERISK, i); 13558 } 13559 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13560 public TerminalNode WS(int i) { 13561 return getToken(JavadocParser.WS, i); 13562 } 13563 public BasefontTagContext(ParserRuleContext parent, int invokingState) { 13564 super(parent, invokingState); 13565 } 13566 @Override public int getRuleIndex() { return RULE_basefontTag; } 13567 } 13568 13569 public final BasefontTagContext basefontTag() throws RecognitionException { 13570 BasefontTagContext _localctx = new BasefontTagContext(_ctx, getState()); 13571 enterRule(_localctx, 110, RULE_basefontTag); 13572 int _la; 13573 try { 13574 enterOuterAlt(_localctx, 1); 13575 { 13576 setState(1573); 13577 match(START); 13578 setState(1574); 13579 match(BASEFONT_HTML_TAG_NAME); 13580 setState(1581); 13581 _errHandler.sync(this); 13582 _la = _input.LA(1); 13583 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13584 { 13585 setState(1579); 13586 _errHandler.sync(this); 13587 switch (_input.LA(1)) { 13588 case HTML_TAG_NAME: 13589 { 13590 setState(1575); 13591 attribute(); 13592 } 13593 break; 13594 case NEWLINE: 13595 { 13596 setState(1576); 13597 match(NEWLINE); 13598 } 13599 break; 13600 case LEADING_ASTERISK: 13601 { 13602 setState(1577); 13603 match(LEADING_ASTERISK); 13604 } 13605 break; 13606 case WS: 13607 { 13608 setState(1578); 13609 match(WS); 13610 } 13611 break; 13612 default: 13613 throw new NoViableAltException(this); 13614 } 13615 } 13616 setState(1583); 13617 _errHandler.sync(this); 13618 _la = _input.LA(1); 13619 } 13620 setState(1584); 13621 _la = _input.LA(1); 13622 if ( !(_la==END || _la==SLASH_END) ) { 13623 _errHandler.recoverInline(this); 13624 } 13625 else { 13626 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13627 _errHandler.reportMatch(this); 13628 consume(); 13629 } 13630 } 13631 } 13632 catch (RecognitionException re) { 13633 _localctx.exception = re; 13634 _errHandler.reportError(this, re); 13635 _errHandler.recover(this, re); 13636 } 13637 finally { 13638 exitRule(); 13639 } 13640 return _localctx; 13641 } 13642 13643 public static class BrTagContext extends ParserRuleContext { 13644 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13645 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 13646 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13647 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 13648 public List<AttributeContext> attribute() { 13649 return getRuleContexts(AttributeContext.class); 13650 } 13651 public AttributeContext attribute(int i) { 13652 return getRuleContext(AttributeContext.class,i); 13653 } 13654 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13655 public TerminalNode NEWLINE(int i) { 13656 return getToken(JavadocParser.NEWLINE, i); 13657 } 13658 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13659 public TerminalNode LEADING_ASTERISK(int i) { 13660 return getToken(JavadocParser.LEADING_ASTERISK, i); 13661 } 13662 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13663 public TerminalNode WS(int i) { 13664 return getToken(JavadocParser.WS, i); 13665 } 13666 public BrTagContext(ParserRuleContext parent, int invokingState) { 13667 super(parent, invokingState); 13668 } 13669 @Override public int getRuleIndex() { return RULE_brTag; } 13670 } 13671 13672 public final BrTagContext brTag() throws RecognitionException { 13673 BrTagContext _localctx = new BrTagContext(_ctx, getState()); 13674 enterRule(_localctx, 112, RULE_brTag); 13675 int _la; 13676 try { 13677 enterOuterAlt(_localctx, 1); 13678 { 13679 setState(1586); 13680 match(START); 13681 setState(1587); 13682 match(BR_HTML_TAG_NAME); 13683 setState(1594); 13684 _errHandler.sync(this); 13685 _la = _input.LA(1); 13686 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13687 { 13688 setState(1592); 13689 _errHandler.sync(this); 13690 switch (_input.LA(1)) { 13691 case HTML_TAG_NAME: 13692 { 13693 setState(1588); 13694 attribute(); 13695 } 13696 break; 13697 case NEWLINE: 13698 { 13699 setState(1589); 13700 match(NEWLINE); 13701 } 13702 break; 13703 case LEADING_ASTERISK: 13704 { 13705 setState(1590); 13706 match(LEADING_ASTERISK); 13707 } 13708 break; 13709 case WS: 13710 { 13711 setState(1591); 13712 match(WS); 13713 } 13714 break; 13715 default: 13716 throw new NoViableAltException(this); 13717 } 13718 } 13719 setState(1596); 13720 _errHandler.sync(this); 13721 _la = _input.LA(1); 13722 } 13723 setState(1597); 13724 _la = _input.LA(1); 13725 if ( !(_la==END || _la==SLASH_END) ) { 13726 _errHandler.recoverInline(this); 13727 } 13728 else { 13729 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13730 _errHandler.reportMatch(this); 13731 consume(); 13732 } 13733 } 13734 } 13735 catch (RecognitionException re) { 13736 _localctx.exception = re; 13737 _errHandler.reportError(this, re); 13738 _errHandler.recover(this, re); 13739 } 13740 finally { 13741 exitRule(); 13742 } 13743 return _localctx; 13744 } 13745 13746 public static class ColTagContext extends ParserRuleContext { 13747 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13748 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 13749 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13750 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 13751 public List<AttributeContext> attribute() { 13752 return getRuleContexts(AttributeContext.class); 13753 } 13754 public AttributeContext attribute(int i) { 13755 return getRuleContext(AttributeContext.class,i); 13756 } 13757 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13758 public TerminalNode NEWLINE(int i) { 13759 return getToken(JavadocParser.NEWLINE, i); 13760 } 13761 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13762 public TerminalNode LEADING_ASTERISK(int i) { 13763 return getToken(JavadocParser.LEADING_ASTERISK, i); 13764 } 13765 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13766 public TerminalNode WS(int i) { 13767 return getToken(JavadocParser.WS, i); 13768 } 13769 public ColTagContext(ParserRuleContext parent, int invokingState) { 13770 super(parent, invokingState); 13771 } 13772 @Override public int getRuleIndex() { return RULE_colTag; } 13773 } 13774 13775 public final ColTagContext colTag() throws RecognitionException { 13776 ColTagContext _localctx = new ColTagContext(_ctx, getState()); 13777 enterRule(_localctx, 114, RULE_colTag); 13778 int _la; 13779 try { 13780 enterOuterAlt(_localctx, 1); 13781 { 13782 setState(1599); 13783 match(START); 13784 setState(1600); 13785 match(COL_HTML_TAG_NAME); 13786 setState(1607); 13787 _errHandler.sync(this); 13788 _la = _input.LA(1); 13789 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13790 { 13791 setState(1605); 13792 _errHandler.sync(this); 13793 switch (_input.LA(1)) { 13794 case HTML_TAG_NAME: 13795 { 13796 setState(1601); 13797 attribute(); 13798 } 13799 break; 13800 case NEWLINE: 13801 { 13802 setState(1602); 13803 match(NEWLINE); 13804 } 13805 break; 13806 case LEADING_ASTERISK: 13807 { 13808 setState(1603); 13809 match(LEADING_ASTERISK); 13810 } 13811 break; 13812 case WS: 13813 { 13814 setState(1604); 13815 match(WS); 13816 } 13817 break; 13818 default: 13819 throw new NoViableAltException(this); 13820 } 13821 } 13822 setState(1609); 13823 _errHandler.sync(this); 13824 _la = _input.LA(1); 13825 } 13826 setState(1610); 13827 _la = _input.LA(1); 13828 if ( !(_la==END || _la==SLASH_END) ) { 13829 _errHandler.recoverInline(this); 13830 } 13831 else { 13832 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13833 _errHandler.reportMatch(this); 13834 consume(); 13835 } 13836 } 13837 } 13838 catch (RecognitionException re) { 13839 _localctx.exception = re; 13840 _errHandler.reportError(this, re); 13841 _errHandler.recover(this, re); 13842 } 13843 finally { 13844 exitRule(); 13845 } 13846 return _localctx; 13847 } 13848 13849 public static class FrameTagContext extends ParserRuleContext { 13850 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13851 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 13852 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13853 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 13854 public List<AttributeContext> attribute() { 13855 return getRuleContexts(AttributeContext.class); 13856 } 13857 public AttributeContext attribute(int i) { 13858 return getRuleContext(AttributeContext.class,i); 13859 } 13860 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13861 public TerminalNode NEWLINE(int i) { 13862 return getToken(JavadocParser.NEWLINE, i); 13863 } 13864 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13865 public TerminalNode LEADING_ASTERISK(int i) { 13866 return getToken(JavadocParser.LEADING_ASTERISK, i); 13867 } 13868 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13869 public TerminalNode WS(int i) { 13870 return getToken(JavadocParser.WS, i); 13871 } 13872 public FrameTagContext(ParserRuleContext parent, int invokingState) { 13873 super(parent, invokingState); 13874 } 13875 @Override public int getRuleIndex() { return RULE_frameTag; } 13876 } 13877 13878 public final FrameTagContext frameTag() throws RecognitionException { 13879 FrameTagContext _localctx = new FrameTagContext(_ctx, getState()); 13880 enterRule(_localctx, 116, RULE_frameTag); 13881 int _la; 13882 try { 13883 enterOuterAlt(_localctx, 1); 13884 { 13885 setState(1612); 13886 match(START); 13887 setState(1613); 13888 match(FRAME_HTML_TAG_NAME); 13889 setState(1620); 13890 _errHandler.sync(this); 13891 _la = _input.LA(1); 13892 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13893 { 13894 setState(1618); 13895 _errHandler.sync(this); 13896 switch (_input.LA(1)) { 13897 case HTML_TAG_NAME: 13898 { 13899 setState(1614); 13900 attribute(); 13901 } 13902 break; 13903 case NEWLINE: 13904 { 13905 setState(1615); 13906 match(NEWLINE); 13907 } 13908 break; 13909 case LEADING_ASTERISK: 13910 { 13911 setState(1616); 13912 match(LEADING_ASTERISK); 13913 } 13914 break; 13915 case WS: 13916 { 13917 setState(1617); 13918 match(WS); 13919 } 13920 break; 13921 default: 13922 throw new NoViableAltException(this); 13923 } 13924 } 13925 setState(1622); 13926 _errHandler.sync(this); 13927 _la = _input.LA(1); 13928 } 13929 setState(1623); 13930 _la = _input.LA(1); 13931 if ( !(_la==END || _la==SLASH_END) ) { 13932 _errHandler.recoverInline(this); 13933 } 13934 else { 13935 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13936 _errHandler.reportMatch(this); 13937 consume(); 13938 } 13939 } 13940 } 13941 catch (RecognitionException re) { 13942 _localctx.exception = re; 13943 _errHandler.reportError(this, re); 13944 _errHandler.recover(this, re); 13945 } 13946 finally { 13947 exitRule(); 13948 } 13949 return _localctx; 13950 } 13951 13952 public static class HrTagContext extends ParserRuleContext { 13953 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13954 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 13955 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13956 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 13957 public List<AttributeContext> attribute() { 13958 return getRuleContexts(AttributeContext.class); 13959 } 13960 public AttributeContext attribute(int i) { 13961 return getRuleContext(AttributeContext.class,i); 13962 } 13963 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13964 public TerminalNode NEWLINE(int i) { 13965 return getToken(JavadocParser.NEWLINE, i); 13966 } 13967 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13968 public TerminalNode LEADING_ASTERISK(int i) { 13969 return getToken(JavadocParser.LEADING_ASTERISK, i); 13970 } 13971 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13972 public TerminalNode WS(int i) { 13973 return getToken(JavadocParser.WS, i); 13974 } 13975 public HrTagContext(ParserRuleContext parent, int invokingState) { 13976 super(parent, invokingState); 13977 } 13978 @Override public int getRuleIndex() { return RULE_hrTag; } 13979 } 13980 13981 public final HrTagContext hrTag() throws RecognitionException { 13982 HrTagContext _localctx = new HrTagContext(_ctx, getState()); 13983 enterRule(_localctx, 118, RULE_hrTag); 13984 int _la; 13985 try { 13986 enterOuterAlt(_localctx, 1); 13987 { 13988 setState(1625); 13989 match(START); 13990 setState(1626); 13991 match(HR_HTML_TAG_NAME); 13992 setState(1633); 13993 _errHandler.sync(this); 13994 _la = _input.LA(1); 13995 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13996 { 13997 setState(1631); 13998 _errHandler.sync(this); 13999 switch (_input.LA(1)) { 14000 case HTML_TAG_NAME: 14001 { 14002 setState(1627); 14003 attribute(); 14004 } 14005 break; 14006 case NEWLINE: 14007 { 14008 setState(1628); 14009 match(NEWLINE); 14010 } 14011 break; 14012 case LEADING_ASTERISK: 14013 { 14014 setState(1629); 14015 match(LEADING_ASTERISK); 14016 } 14017 break; 14018 case WS: 14019 { 14020 setState(1630); 14021 match(WS); 14022 } 14023 break; 14024 default: 14025 throw new NoViableAltException(this); 14026 } 14027 } 14028 setState(1635); 14029 _errHandler.sync(this); 14030 _la = _input.LA(1); 14031 } 14032 setState(1636); 14033 _la = _input.LA(1); 14034 if ( !(_la==END || _la==SLASH_END) ) { 14035 _errHandler.recoverInline(this); 14036 } 14037 else { 14038 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14039 _errHandler.reportMatch(this); 14040 consume(); 14041 } 14042 } 14043 } 14044 catch (RecognitionException re) { 14045 _localctx.exception = re; 14046 _errHandler.reportError(this, re); 14047 _errHandler.recover(this, re); 14048 } 14049 finally { 14050 exitRule(); 14051 } 14052 return _localctx; 14053 } 14054 14055 public static class ImgTagContext extends ParserRuleContext { 14056 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14057 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 14058 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14059 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14060 public List<AttributeContext> attribute() { 14061 return getRuleContexts(AttributeContext.class); 14062 } 14063 public AttributeContext attribute(int i) { 14064 return getRuleContext(AttributeContext.class,i); 14065 } 14066 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14067 public TerminalNode NEWLINE(int i) { 14068 return getToken(JavadocParser.NEWLINE, i); 14069 } 14070 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14071 public TerminalNode LEADING_ASTERISK(int i) { 14072 return getToken(JavadocParser.LEADING_ASTERISK, i); 14073 } 14074 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14075 public TerminalNode WS(int i) { 14076 return getToken(JavadocParser.WS, i); 14077 } 14078 public ImgTagContext(ParserRuleContext parent, int invokingState) { 14079 super(parent, invokingState); 14080 } 14081 @Override public int getRuleIndex() { return RULE_imgTag; } 14082 } 14083 14084 public final ImgTagContext imgTag() throws RecognitionException { 14085 ImgTagContext _localctx = new ImgTagContext(_ctx, getState()); 14086 enterRule(_localctx, 120, RULE_imgTag); 14087 int _la; 14088 try { 14089 enterOuterAlt(_localctx, 1); 14090 { 14091 setState(1638); 14092 match(START); 14093 setState(1639); 14094 match(IMG_HTML_TAG_NAME); 14095 setState(1646); 14096 _errHandler.sync(this); 14097 _la = _input.LA(1); 14098 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14099 { 14100 setState(1644); 14101 _errHandler.sync(this); 14102 switch (_input.LA(1)) { 14103 case HTML_TAG_NAME: 14104 { 14105 setState(1640); 14106 attribute(); 14107 } 14108 break; 14109 case NEWLINE: 14110 { 14111 setState(1641); 14112 match(NEWLINE); 14113 } 14114 break; 14115 case LEADING_ASTERISK: 14116 { 14117 setState(1642); 14118 match(LEADING_ASTERISK); 14119 } 14120 break; 14121 case WS: 14122 { 14123 setState(1643); 14124 match(WS); 14125 } 14126 break; 14127 default: 14128 throw new NoViableAltException(this); 14129 } 14130 } 14131 setState(1648); 14132 _errHandler.sync(this); 14133 _la = _input.LA(1); 14134 } 14135 setState(1649); 14136 _la = _input.LA(1); 14137 if ( !(_la==END || _la==SLASH_END) ) { 14138 _errHandler.recoverInline(this); 14139 } 14140 else { 14141 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14142 _errHandler.reportMatch(this); 14143 consume(); 14144 } 14145 } 14146 } 14147 catch (RecognitionException re) { 14148 _localctx.exception = re; 14149 _errHandler.reportError(this, re); 14150 _errHandler.recover(this, re); 14151 } 14152 finally { 14153 exitRule(); 14154 } 14155 return _localctx; 14156 } 14157 14158 public static class InputTagContext extends ParserRuleContext { 14159 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14160 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 14161 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14162 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14163 public List<AttributeContext> attribute() { 14164 return getRuleContexts(AttributeContext.class); 14165 } 14166 public AttributeContext attribute(int i) { 14167 return getRuleContext(AttributeContext.class,i); 14168 } 14169 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14170 public TerminalNode NEWLINE(int i) { 14171 return getToken(JavadocParser.NEWLINE, i); 14172 } 14173 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14174 public TerminalNode LEADING_ASTERISK(int i) { 14175 return getToken(JavadocParser.LEADING_ASTERISK, i); 14176 } 14177 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14178 public TerminalNode WS(int i) { 14179 return getToken(JavadocParser.WS, i); 14180 } 14181 public InputTagContext(ParserRuleContext parent, int invokingState) { 14182 super(parent, invokingState); 14183 } 14184 @Override public int getRuleIndex() { return RULE_inputTag; } 14185 } 14186 14187 public final InputTagContext inputTag() throws RecognitionException { 14188 InputTagContext _localctx = new InputTagContext(_ctx, getState()); 14189 enterRule(_localctx, 122, RULE_inputTag); 14190 int _la; 14191 try { 14192 enterOuterAlt(_localctx, 1); 14193 { 14194 setState(1651); 14195 match(START); 14196 setState(1652); 14197 match(INPUT_HTML_TAG_NAME); 14198 setState(1659); 14199 _errHandler.sync(this); 14200 _la = _input.LA(1); 14201 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14202 { 14203 setState(1657); 14204 _errHandler.sync(this); 14205 switch (_input.LA(1)) { 14206 case HTML_TAG_NAME: 14207 { 14208 setState(1653); 14209 attribute(); 14210 } 14211 break; 14212 case NEWLINE: 14213 { 14214 setState(1654); 14215 match(NEWLINE); 14216 } 14217 break; 14218 case LEADING_ASTERISK: 14219 { 14220 setState(1655); 14221 match(LEADING_ASTERISK); 14222 } 14223 break; 14224 case WS: 14225 { 14226 setState(1656); 14227 match(WS); 14228 } 14229 break; 14230 default: 14231 throw new NoViableAltException(this); 14232 } 14233 } 14234 setState(1661); 14235 _errHandler.sync(this); 14236 _la = _input.LA(1); 14237 } 14238 setState(1662); 14239 _la = _input.LA(1); 14240 if ( !(_la==END || _la==SLASH_END) ) { 14241 _errHandler.recoverInline(this); 14242 } 14243 else { 14244 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14245 _errHandler.reportMatch(this); 14246 consume(); 14247 } 14248 } 14249 } 14250 catch (RecognitionException re) { 14251 _localctx.exception = re; 14252 _errHandler.reportError(this, re); 14253 _errHandler.recover(this, re); 14254 } 14255 finally { 14256 exitRule(); 14257 } 14258 return _localctx; 14259 } 14260 14261 public static class IsindexTagContext extends ParserRuleContext { 14262 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14263 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 14264 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14265 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14266 public List<AttributeContext> attribute() { 14267 return getRuleContexts(AttributeContext.class); 14268 } 14269 public AttributeContext attribute(int i) { 14270 return getRuleContext(AttributeContext.class,i); 14271 } 14272 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14273 public TerminalNode NEWLINE(int i) { 14274 return getToken(JavadocParser.NEWLINE, i); 14275 } 14276 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14277 public TerminalNode LEADING_ASTERISK(int i) { 14278 return getToken(JavadocParser.LEADING_ASTERISK, i); 14279 } 14280 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14281 public TerminalNode WS(int i) { 14282 return getToken(JavadocParser.WS, i); 14283 } 14284 public IsindexTagContext(ParserRuleContext parent, int invokingState) { 14285 super(parent, invokingState); 14286 } 14287 @Override public int getRuleIndex() { return RULE_isindexTag; } 14288 } 14289 14290 public final IsindexTagContext isindexTag() throws RecognitionException { 14291 IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState()); 14292 enterRule(_localctx, 124, RULE_isindexTag); 14293 int _la; 14294 try { 14295 enterOuterAlt(_localctx, 1); 14296 { 14297 setState(1664); 14298 match(START); 14299 setState(1665); 14300 match(ISINDEX_HTML_TAG_NAME); 14301 setState(1672); 14302 _errHandler.sync(this); 14303 _la = _input.LA(1); 14304 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14305 { 14306 setState(1670); 14307 _errHandler.sync(this); 14308 switch (_input.LA(1)) { 14309 case HTML_TAG_NAME: 14310 { 14311 setState(1666); 14312 attribute(); 14313 } 14314 break; 14315 case NEWLINE: 14316 { 14317 setState(1667); 14318 match(NEWLINE); 14319 } 14320 break; 14321 case LEADING_ASTERISK: 14322 { 14323 setState(1668); 14324 match(LEADING_ASTERISK); 14325 } 14326 break; 14327 case WS: 14328 { 14329 setState(1669); 14330 match(WS); 14331 } 14332 break; 14333 default: 14334 throw new NoViableAltException(this); 14335 } 14336 } 14337 setState(1674); 14338 _errHandler.sync(this); 14339 _la = _input.LA(1); 14340 } 14341 setState(1675); 14342 _la = _input.LA(1); 14343 if ( !(_la==END || _la==SLASH_END) ) { 14344 _errHandler.recoverInline(this); 14345 } 14346 else { 14347 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14348 _errHandler.reportMatch(this); 14349 consume(); 14350 } 14351 } 14352 } 14353 catch (RecognitionException re) { 14354 _localctx.exception = re; 14355 _errHandler.reportError(this, re); 14356 _errHandler.recover(this, re); 14357 } 14358 finally { 14359 exitRule(); 14360 } 14361 return _localctx; 14362 } 14363 14364 public static class LinkTagContext extends ParserRuleContext { 14365 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14366 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 14367 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14368 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14369 public List<AttributeContext> attribute() { 14370 return getRuleContexts(AttributeContext.class); 14371 } 14372 public AttributeContext attribute(int i) { 14373 return getRuleContext(AttributeContext.class,i); 14374 } 14375 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14376 public TerminalNode NEWLINE(int i) { 14377 return getToken(JavadocParser.NEWLINE, i); 14378 } 14379 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14380 public TerminalNode LEADING_ASTERISK(int i) { 14381 return getToken(JavadocParser.LEADING_ASTERISK, i); 14382 } 14383 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14384 public TerminalNode WS(int i) { 14385 return getToken(JavadocParser.WS, i); 14386 } 14387 public LinkTagContext(ParserRuleContext parent, int invokingState) { 14388 super(parent, invokingState); 14389 } 14390 @Override public int getRuleIndex() { return RULE_linkTag; } 14391 } 14392 14393 public final LinkTagContext linkTag() throws RecognitionException { 14394 LinkTagContext _localctx = new LinkTagContext(_ctx, getState()); 14395 enterRule(_localctx, 126, RULE_linkTag); 14396 int _la; 14397 try { 14398 enterOuterAlt(_localctx, 1); 14399 { 14400 setState(1677); 14401 match(START); 14402 setState(1678); 14403 match(LINK_HTML_TAG_NAME); 14404 setState(1685); 14405 _errHandler.sync(this); 14406 _la = _input.LA(1); 14407 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14408 { 14409 setState(1683); 14410 _errHandler.sync(this); 14411 switch (_input.LA(1)) { 14412 case HTML_TAG_NAME: 14413 { 14414 setState(1679); 14415 attribute(); 14416 } 14417 break; 14418 case NEWLINE: 14419 { 14420 setState(1680); 14421 match(NEWLINE); 14422 } 14423 break; 14424 case LEADING_ASTERISK: 14425 { 14426 setState(1681); 14427 match(LEADING_ASTERISK); 14428 } 14429 break; 14430 case WS: 14431 { 14432 setState(1682); 14433 match(WS); 14434 } 14435 break; 14436 default: 14437 throw new NoViableAltException(this); 14438 } 14439 } 14440 setState(1687); 14441 _errHandler.sync(this); 14442 _la = _input.LA(1); 14443 } 14444 setState(1688); 14445 _la = _input.LA(1); 14446 if ( !(_la==END || _la==SLASH_END) ) { 14447 _errHandler.recoverInline(this); 14448 } 14449 else { 14450 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14451 _errHandler.reportMatch(this); 14452 consume(); 14453 } 14454 } 14455 } 14456 catch (RecognitionException re) { 14457 _localctx.exception = re; 14458 _errHandler.reportError(this, re); 14459 _errHandler.recover(this, re); 14460 } 14461 finally { 14462 exitRule(); 14463 } 14464 return _localctx; 14465 } 14466 14467 public static class MetaTagContext extends ParserRuleContext { 14468 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14469 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 14470 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14471 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14472 public List<AttributeContext> attribute() { 14473 return getRuleContexts(AttributeContext.class); 14474 } 14475 public AttributeContext attribute(int i) { 14476 return getRuleContext(AttributeContext.class,i); 14477 } 14478 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14479 public TerminalNode NEWLINE(int i) { 14480 return getToken(JavadocParser.NEWLINE, i); 14481 } 14482 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14483 public TerminalNode LEADING_ASTERISK(int i) { 14484 return getToken(JavadocParser.LEADING_ASTERISK, i); 14485 } 14486 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14487 public TerminalNode WS(int i) { 14488 return getToken(JavadocParser.WS, i); 14489 } 14490 public MetaTagContext(ParserRuleContext parent, int invokingState) { 14491 super(parent, invokingState); 14492 } 14493 @Override public int getRuleIndex() { return RULE_metaTag; } 14494 } 14495 14496 public final MetaTagContext metaTag() throws RecognitionException { 14497 MetaTagContext _localctx = new MetaTagContext(_ctx, getState()); 14498 enterRule(_localctx, 128, RULE_metaTag); 14499 int _la; 14500 try { 14501 enterOuterAlt(_localctx, 1); 14502 { 14503 setState(1690); 14504 match(START); 14505 setState(1691); 14506 match(META_HTML_TAG_NAME); 14507 setState(1698); 14508 _errHandler.sync(this); 14509 _la = _input.LA(1); 14510 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14511 { 14512 setState(1696); 14513 _errHandler.sync(this); 14514 switch (_input.LA(1)) { 14515 case HTML_TAG_NAME: 14516 { 14517 setState(1692); 14518 attribute(); 14519 } 14520 break; 14521 case NEWLINE: 14522 { 14523 setState(1693); 14524 match(NEWLINE); 14525 } 14526 break; 14527 case LEADING_ASTERISK: 14528 { 14529 setState(1694); 14530 match(LEADING_ASTERISK); 14531 } 14532 break; 14533 case WS: 14534 { 14535 setState(1695); 14536 match(WS); 14537 } 14538 break; 14539 default: 14540 throw new NoViableAltException(this); 14541 } 14542 } 14543 setState(1700); 14544 _errHandler.sync(this); 14545 _la = _input.LA(1); 14546 } 14547 setState(1701); 14548 _la = _input.LA(1); 14549 if ( !(_la==END || _la==SLASH_END) ) { 14550 _errHandler.recoverInline(this); 14551 } 14552 else { 14553 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14554 _errHandler.reportMatch(this); 14555 consume(); 14556 } 14557 } 14558 } 14559 catch (RecognitionException re) { 14560 _localctx.exception = re; 14561 _errHandler.reportError(this, re); 14562 _errHandler.recover(this, re); 14563 } 14564 finally { 14565 exitRule(); 14566 } 14567 return _localctx; 14568 } 14569 14570 public static class ParamTagContext extends ParserRuleContext { 14571 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14572 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 14573 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14574 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14575 public List<AttributeContext> attribute() { 14576 return getRuleContexts(AttributeContext.class); 14577 } 14578 public AttributeContext attribute(int i) { 14579 return getRuleContext(AttributeContext.class,i); 14580 } 14581 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14582 public TerminalNode NEWLINE(int i) { 14583 return getToken(JavadocParser.NEWLINE, i); 14584 } 14585 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14586 public TerminalNode LEADING_ASTERISK(int i) { 14587 return getToken(JavadocParser.LEADING_ASTERISK, i); 14588 } 14589 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14590 public TerminalNode WS(int i) { 14591 return getToken(JavadocParser.WS, i); 14592 } 14593 public ParamTagContext(ParserRuleContext parent, int invokingState) { 14594 super(parent, invokingState); 14595 } 14596 @Override public int getRuleIndex() { return RULE_paramTag; } 14597 } 14598 14599 public final ParamTagContext paramTag() throws RecognitionException { 14600 ParamTagContext _localctx = new ParamTagContext(_ctx, getState()); 14601 enterRule(_localctx, 130, RULE_paramTag); 14602 int _la; 14603 try { 14604 enterOuterAlt(_localctx, 1); 14605 { 14606 setState(1703); 14607 match(START); 14608 setState(1704); 14609 match(PARAM_HTML_TAG_NAME); 14610 setState(1711); 14611 _errHandler.sync(this); 14612 _la = _input.LA(1); 14613 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14614 { 14615 setState(1709); 14616 _errHandler.sync(this); 14617 switch (_input.LA(1)) { 14618 case HTML_TAG_NAME: 14619 { 14620 setState(1705); 14621 attribute(); 14622 } 14623 break; 14624 case NEWLINE: 14625 { 14626 setState(1706); 14627 match(NEWLINE); 14628 } 14629 break; 14630 case LEADING_ASTERISK: 14631 { 14632 setState(1707); 14633 match(LEADING_ASTERISK); 14634 } 14635 break; 14636 case WS: 14637 { 14638 setState(1708); 14639 match(WS); 14640 } 14641 break; 14642 default: 14643 throw new NoViableAltException(this); 14644 } 14645 } 14646 setState(1713); 14647 _errHandler.sync(this); 14648 _la = _input.LA(1); 14649 } 14650 setState(1714); 14651 _la = _input.LA(1); 14652 if ( !(_la==END || _la==SLASH_END) ) { 14653 _errHandler.recoverInline(this); 14654 } 14655 else { 14656 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14657 _errHandler.reportMatch(this); 14658 consume(); 14659 } 14660 } 14661 } 14662 catch (RecognitionException re) { 14663 _localctx.exception = re; 14664 _errHandler.reportError(this, re); 14665 _errHandler.recover(this, re); 14666 } 14667 finally { 14668 exitRule(); 14669 } 14670 return _localctx; 14671 } 14672 14673 public static class WrongSingletonTagContext extends ParserRuleContext { 14674 public SingletonTagNameContext singletonTagName; 14675 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14676 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 14677 public SingletonTagNameContext singletonTagName() { 14678 return getRuleContext(SingletonTagNameContext.class,0); 14679 } 14680 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14681 public WrongSingletonTagContext(ParserRuleContext parent, int invokingState) { 14682 super(parent, invokingState); 14683 } 14684 @Override public int getRuleIndex() { return RULE_wrongSingletonTag; } 14685 } 14686 14687 public final WrongSingletonTagContext wrongSingletonTag() throws RecognitionException { 14688 WrongSingletonTagContext _localctx = new WrongSingletonTagContext(_ctx, getState()); 14689 enterRule(_localctx, 132, RULE_wrongSingletonTag); 14690 try { 14691 enterOuterAlt(_localctx, 1); 14692 { 14693 setState(1716); 14694 match(START); 14695 setState(1717); 14696 match(SLASH); 14697 setState(1718); 14698 ((WrongSingletonTagContext)_localctx).singletonTagName = singletonTagName(); 14699 setState(1719); 14700 match(END); 14701 notifyErrorListeners((((WrongSingletonTagContext)_localctx).singletonTagName!=null?(((WrongSingletonTagContext)_localctx).singletonTagName.start):null), 14702 "javadoc.wrong.singleton.html.tag", null); 14703 } 14704 } 14705 catch (RecognitionException re) { 14706 _localctx.exception = re; 14707 _errHandler.reportError(this, re); 14708 _errHandler.recover(this, re); 14709 } 14710 finally { 14711 exitRule(); 14712 } 14713 return _localctx; 14714 } 14715 14716 public static class SingletonTagNameContext extends ParserRuleContext { 14717 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 14718 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 14719 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 14720 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 14721 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 14722 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 14723 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 14724 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 14725 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 14726 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 14727 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 14728 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 14729 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 14730 public TerminalNode EMBED_HTML_TAG_NAME() { return getToken(JavadocParser.EMBED_HTML_TAG_NAME, 0); } 14731 public TerminalNode KEYGEN_HTML_TAG_NAME() { return getToken(JavadocParser.KEYGEN_HTML_TAG_NAME, 0); } 14732 public TerminalNode SOURCE_HTML_TAG_NAME() { return getToken(JavadocParser.SOURCE_HTML_TAG_NAME, 0); } 14733 public TerminalNode TRACK_HTML_TAG_NAME() { return getToken(JavadocParser.TRACK_HTML_TAG_NAME, 0); } 14734 public TerminalNode WBR_HTML_TAG_NAME() { return getToken(JavadocParser.WBR_HTML_TAG_NAME, 0); } 14735 public SingletonTagNameContext(ParserRuleContext parent, int invokingState) { 14736 super(parent, invokingState); 14737 } 14738 @Override public int getRuleIndex() { return RULE_singletonTagName; } 14739 } 14740 14741 public final SingletonTagNameContext singletonTagName() throws RecognitionException { 14742 SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState()); 14743 enterRule(_localctx, 134, RULE_singletonTagName); 14744 int _la; 14745 try { 14746 enterOuterAlt(_localctx, 1); 14747 { 14748 setState(1722); 14749 _la = _input.LA(1); 14750 if ( !(((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (AREA_HTML_TAG_NAME - 74)) | (1L << (BASE_HTML_TAG_NAME - 74)) | (1L << (BASEFONT_HTML_TAG_NAME - 74)) | (1L << (BR_HTML_TAG_NAME - 74)) | (1L << (COL_HTML_TAG_NAME - 74)) | (1L << (FRAME_HTML_TAG_NAME - 74)) | (1L << (HR_HTML_TAG_NAME - 74)) | (1L << (IMG_HTML_TAG_NAME - 74)) | (1L << (INPUT_HTML_TAG_NAME - 74)) | (1L << (ISINDEX_HTML_TAG_NAME - 74)) | (1L << (LINK_HTML_TAG_NAME - 74)) | (1L << (META_HTML_TAG_NAME - 74)) | (1L << (PARAM_HTML_TAG_NAME - 74)) | (1L << (EMBED_HTML_TAG_NAME - 74)) | (1L << (KEYGEN_HTML_TAG_NAME - 74)) | (1L << (SOURCE_HTML_TAG_NAME - 74)) | (1L << (TRACK_HTML_TAG_NAME - 74)) | (1L << (WBR_HTML_TAG_NAME - 74)))) != 0)) ) { 14751 _errHandler.recoverInline(this); 14752 } 14753 else { 14754 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14755 _errHandler.reportMatch(this); 14756 consume(); 14757 } 14758 } 14759 } 14760 catch (RecognitionException re) { 14761 _localctx.exception = re; 14762 _errHandler.reportError(this, re); 14763 _errHandler.recover(this, re); 14764 } 14765 finally { 14766 exitRule(); 14767 } 14768 return _localctx; 14769 } 14770 14771 public static class DescriptionContext extends ParserRuleContext { 14772 public List<HtmlCommentContext> htmlComment() { 14773 return getRuleContexts(HtmlCommentContext.class); 14774 } 14775 public HtmlCommentContext htmlComment(int i) { 14776 return getRuleContext(HtmlCommentContext.class,i); 14777 } 14778 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14779 public TerminalNode NEWLINE(int i) { 14780 return getToken(JavadocParser.NEWLINE, i); 14781 } 14782 public List<TextContext> text() { 14783 return getRuleContexts(TextContext.class); 14784 } 14785 public TextContext text(int i) { 14786 return getRuleContext(TextContext.class,i); 14787 } 14788 public List<JavadocInlineTagContext> javadocInlineTag() { 14789 return getRuleContexts(JavadocInlineTagContext.class); 14790 } 14791 public JavadocInlineTagContext javadocInlineTag(int i) { 14792 return getRuleContext(JavadocInlineTagContext.class,i); 14793 } 14794 public List<HtmlElementContext> htmlElement() { 14795 return getRuleContexts(HtmlElementContext.class); 14796 } 14797 public HtmlElementContext htmlElement(int i) { 14798 return getRuleContext(HtmlElementContext.class,i); 14799 } 14800 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14801 public TerminalNode LEADING_ASTERISK(int i) { 14802 return getToken(JavadocParser.LEADING_ASTERISK, i); 14803 } 14804 public DescriptionContext(ParserRuleContext parent, int invokingState) { 14805 super(parent, invokingState); 14806 } 14807 @Override public int getRuleIndex() { return RULE_description; } 14808 } 14809 14810 public final DescriptionContext description() throws RecognitionException { 14811 DescriptionContext _localctx = new DescriptionContext(_ctx, getState()); 14812 enterRule(_localctx, 136, RULE_description); 14813 try { 14814 int _alt; 14815 enterOuterAlt(_localctx, 1); 14816 { 14817 setState(1731); 14818 _errHandler.sync(this); 14819 _alt = 1; 14820 do { 14821 switch (_alt) { 14822 case 1: 14823 { 14824 setState(1731); 14825 _errHandler.sync(this); 14826 switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) { 14827 case 1: 14828 { 14829 { 14830 setState(1724); 14831 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 14832 setState(1725); 14833 match(LEADING_ASTERISK); 14834 } 14835 } 14836 break; 14837 case 2: 14838 { 14839 setState(1726); 14840 htmlComment(); 14841 } 14842 break; 14843 case 3: 14844 { 14845 setState(1727); 14846 match(NEWLINE); 14847 } 14848 break; 14849 case 4: 14850 { 14851 setState(1728); 14852 text(); 14853 } 14854 break; 14855 case 5: 14856 { 14857 setState(1729); 14858 javadocInlineTag(); 14859 } 14860 break; 14861 case 6: 14862 { 14863 setState(1730); 14864 htmlElement(); 14865 } 14866 break; 14867 } 14868 } 14869 break; 14870 default: 14871 throw new NoViableAltException(this); 14872 } 14873 setState(1733); 14874 _errHandler.sync(this); 14875 _alt = getInterpreter().adaptivePredict(_input,119,_ctx); 14876 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 14877 } 14878 } 14879 catch (RecognitionException re) { 14880 _localctx.exception = re; 14881 _errHandler.reportError(this, re); 14882 _errHandler.recover(this, re); 14883 } 14884 finally { 14885 exitRule(); 14886 } 14887 return _localctx; 14888 } 14889 14890 public static class ReferenceContext extends ParserRuleContext { 14891 public TerminalNode PACKAGE_CLASS() { return getToken(JavadocParser.PACKAGE_CLASS, 0); } 14892 public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); } 14893 public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); } 14894 public ParametersContext parameters() { 14895 return getRuleContext(ParametersContext.class,0); 14896 } 14897 public ReferenceContext(ParserRuleContext parent, int invokingState) { 14898 super(parent, invokingState); 14899 } 14900 @Override public int getRuleIndex() { return RULE_reference; } 14901 } 14902 14903 public final ReferenceContext reference() throws RecognitionException { 14904 ReferenceContext _localctx = new ReferenceContext(_ctx, getState()); 14905 enterRule(_localctx, 138, RULE_reference); 14906 int _la; 14907 try { 14908 setState(1748); 14909 _errHandler.sync(this); 14910 switch (_input.LA(1)) { 14911 case PACKAGE_CLASS: 14912 enterOuterAlt(_localctx, 1); 14913 { 14914 setState(1735); 14915 match(PACKAGE_CLASS); 14916 setState(1741); 14917 _errHandler.sync(this); 14918 _la = _input.LA(1); 14919 if (_la==HASH) { 14920 { 14921 setState(1736); 14922 match(HASH); 14923 setState(1737); 14924 match(MEMBER); 14925 setState(1739); 14926 _errHandler.sync(this); 14927 _la = _input.LA(1); 14928 if (_la==LEFT_BRACE) { 14929 { 14930 setState(1738); 14931 parameters(); 14932 } 14933 } 14934 14935 } 14936 } 14937 14938 } 14939 break; 14940 case HASH: 14941 enterOuterAlt(_localctx, 2); 14942 { 14943 setState(1743); 14944 match(HASH); 14945 setState(1744); 14946 match(MEMBER); 14947 setState(1746); 14948 _errHandler.sync(this); 14949 _la = _input.LA(1); 14950 if (_la==LEFT_BRACE) { 14951 { 14952 setState(1745); 14953 parameters(); 14954 } 14955 } 14956 14957 } 14958 break; 14959 default: 14960 throw new NoViableAltException(this); 14961 } 14962 } 14963 catch (RecognitionException re) { 14964 _localctx.exception = re; 14965 _errHandler.reportError(this, re); 14966 _errHandler.recover(this, re); 14967 } 14968 finally { 14969 exitRule(); 14970 } 14971 return _localctx; 14972 } 14973 14974 public static class ParametersContext extends ParserRuleContext { 14975 public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); } 14976 public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); } 14977 public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); } 14978 public TerminalNode ARGUMENT(int i) { 14979 return getToken(JavadocParser.ARGUMENT, i); 14980 } 14981 public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); } 14982 public TerminalNode COMMA(int i) { 14983 return getToken(JavadocParser.COMMA, i); 14984 } 14985 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14986 public TerminalNode WS(int i) { 14987 return getToken(JavadocParser.WS, i); 14988 } 14989 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14990 public TerminalNode NEWLINE(int i) { 14991 return getToken(JavadocParser.NEWLINE, i); 14992 } 14993 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14994 public TerminalNode LEADING_ASTERISK(int i) { 14995 return getToken(JavadocParser.LEADING_ASTERISK, i); 14996 } 14997 public ParametersContext(ParserRuleContext parent, int invokingState) { 14998 super(parent, invokingState); 14999 } 15000 @Override public int getRuleIndex() { return RULE_parameters; } 15001 } 15002 15003 public final ParametersContext parameters() throws RecognitionException { 15004 ParametersContext _localctx = new ParametersContext(_ctx, getState()); 15005 enterRule(_localctx, 140, RULE_parameters); 15006 int _la; 15007 try { 15008 enterOuterAlt(_localctx, 1); 15009 { 15010 setState(1750); 15011 match(LEFT_BRACE); 15012 setState(1754); 15013 _errHandler.sync(this); 15014 _la = _input.LA(1); 15015 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) { 15016 { 15017 { 15018 setState(1751); 15019 _la = _input.LA(1); 15020 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) { 15021 _errHandler.recoverInline(this); 15022 } 15023 else { 15024 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15025 _errHandler.reportMatch(this); 15026 consume(); 15027 } 15028 } 15029 } 15030 setState(1756); 15031 _errHandler.sync(this); 15032 _la = _input.LA(1); 15033 } 15034 setState(1757); 15035 match(RIGHT_BRACE); 15036 } 15037 } 15038 catch (RecognitionException re) { 15039 _localctx.exception = re; 15040 _errHandler.reportError(this, re); 15041 _errHandler.recover(this, re); 15042 } 15043 finally { 15044 exitRule(); 15045 } 15046 return _localctx; 15047 } 15048 15049 public static class JavadocTagContext extends ParserRuleContext { 15050 public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); } 15051 public DescriptionContext description() { 15052 return getRuleContext(DescriptionContext.class,0); 15053 } 15054 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15055 public TerminalNode WS(int i) { 15056 return getToken(JavadocParser.WS, i); 15057 } 15058 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15059 public TerminalNode NEWLINE(int i) { 15060 return getToken(JavadocParser.NEWLINE, i); 15061 } 15062 public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); } 15063 public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); } 15064 public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); } 15065 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15066 public TerminalNode LEADING_ASTERISK(int i) { 15067 return getToken(JavadocParser.LEADING_ASTERISK, i); 15068 } 15069 public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); } 15070 public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); } 15071 public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); } 15072 public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); } 15073 public ReferenceContext reference() { 15074 return getRuleContext(ReferenceContext.class,0); 15075 } 15076 public TerminalNode STRING() { return getToken(JavadocParser.STRING, 0); } 15077 public HtmlElementContext htmlElement() { 15078 return getRuleContext(HtmlElementContext.class,0); 15079 } 15080 public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); } 15081 public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); } 15082 public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); } 15083 public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); } 15084 public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); } 15085 public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); } 15086 public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); } 15087 public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); } 15088 public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); } 15089 public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); } 15090 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 15091 public JavadocTagContext(ParserRuleContext parent, int invokingState) { 15092 super(parent, invokingState); 15093 } 15094 @Override public int getRuleIndex() { return RULE_javadocTag; } 15095 } 15096 15097 public final JavadocTagContext javadocTag() throws RecognitionException { 15098 JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState()); 15099 enterRule(_localctx, 142, RULE_javadocTag); 15100 int _la; 15101 try { 15102 int _alt; 15103 setState(1954); 15104 _errHandler.sync(this); 15105 switch (_input.LA(1)) { 15106 case AUTHOR_LITERAL: 15107 enterOuterAlt(_localctx, 1); 15108 { 15109 setState(1759); 15110 match(AUTHOR_LITERAL); 15111 setState(1761); 15112 _errHandler.sync(this); 15113 _alt = 1; 15114 do { 15115 switch (_alt) { 15116 case 1: 15117 { 15118 { 15119 setState(1760); 15120 _la = _input.LA(1); 15121 if ( !(_la==WS || _la==NEWLINE) ) { 15122 _errHandler.recoverInline(this); 15123 } 15124 else { 15125 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15126 _errHandler.reportMatch(this); 15127 consume(); 15128 } 15129 } 15130 } 15131 break; 15132 default: 15133 throw new NoViableAltException(this); 15134 } 15135 setState(1763); 15136 _errHandler.sync(this); 15137 _alt = getInterpreter().adaptivePredict(_input,125,_ctx); 15138 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15139 setState(1765); 15140 description(); 15141 } 15142 break; 15143 case DEPRECATED_LITERAL: 15144 enterOuterAlt(_localctx, 2); 15145 { 15146 setState(1766); 15147 match(DEPRECATED_LITERAL); 15148 setState(1770); 15149 _errHandler.sync(this); 15150 _alt = getInterpreter().adaptivePredict(_input,126,_ctx); 15151 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15152 if ( _alt==1 ) { 15153 { 15154 { 15155 setState(1767); 15156 _la = _input.LA(1); 15157 if ( !(_la==WS || _la==NEWLINE) ) { 15158 _errHandler.recoverInline(this); 15159 } 15160 else { 15161 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15162 _errHandler.reportMatch(this); 15163 consume(); 15164 } 15165 } 15166 } 15167 } 15168 setState(1772); 15169 _errHandler.sync(this); 15170 _alt = getInterpreter().adaptivePredict(_input,126,_ctx); 15171 } 15172 setState(1775); 15173 _errHandler.sync(this); 15174 switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) { 15175 case 1: 15176 { 15177 setState(1773); 15178 _la = _input.LA(1); 15179 if ( !(_la==WS || _la==NEWLINE) ) { 15180 _errHandler.recoverInline(this); 15181 } 15182 else { 15183 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15184 _errHandler.reportMatch(this); 15185 consume(); 15186 } 15187 setState(1774); 15188 description(); 15189 } 15190 break; 15191 } 15192 } 15193 break; 15194 case EXCEPTION_LITERAL: 15195 enterOuterAlt(_localctx, 3); 15196 { 15197 setState(1777); 15198 match(EXCEPTION_LITERAL); 15199 setState(1782); 15200 _errHandler.sync(this); 15201 _alt = 1; 15202 do { 15203 switch (_alt) { 15204 case 1: 15205 { 15206 setState(1782); 15207 _errHandler.sync(this); 15208 switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { 15209 case 1: 15210 { 15211 setState(1778); 15212 match(WS); 15213 } 15214 break; 15215 case 2: 15216 { 15217 setState(1779); 15218 match(NEWLINE); 15219 } 15220 break; 15221 case 3: 15222 { 15223 setState(1780); 15224 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 15225 setState(1781); 15226 match(LEADING_ASTERISK); 15227 } 15228 break; 15229 } 15230 } 15231 break; 15232 default: 15233 throw new NoViableAltException(this); 15234 } 15235 setState(1784); 15236 _errHandler.sync(this); 15237 _alt = getInterpreter().adaptivePredict(_input,129,_ctx); 15238 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15239 setState(1786); 15240 match(CLASS_NAME); 15241 setState(1790); 15242 _errHandler.sync(this); 15243 _alt = getInterpreter().adaptivePredict(_input,130,_ctx); 15244 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15245 if ( _alt==1 ) { 15246 { 15247 { 15248 setState(1787); 15249 _la = _input.LA(1); 15250 if ( !(_la==WS || _la==NEWLINE) ) { 15251 _errHandler.recoverInline(this); 15252 } 15253 else { 15254 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15255 _errHandler.reportMatch(this); 15256 consume(); 15257 } 15258 } 15259 } 15260 } 15261 setState(1792); 15262 _errHandler.sync(this); 15263 _alt = getInterpreter().adaptivePredict(_input,130,_ctx); 15264 } 15265 setState(1795); 15266 _errHandler.sync(this); 15267 switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { 15268 case 1: 15269 { 15270 setState(1793); 15271 _la = _input.LA(1); 15272 if ( !(_la==WS || _la==NEWLINE) ) { 15273 _errHandler.recoverInline(this); 15274 } 15275 else { 15276 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15277 _errHandler.reportMatch(this); 15278 consume(); 15279 } 15280 setState(1794); 15281 description(); 15282 } 15283 break; 15284 } 15285 } 15286 break; 15287 case PARAM_LITERAL: 15288 enterOuterAlt(_localctx, 4); 15289 { 15290 setState(1797); 15291 match(PARAM_LITERAL); 15292 setState(1802); 15293 _errHandler.sync(this); 15294 _alt = 1; 15295 do { 15296 switch (_alt) { 15297 case 1: 15298 { 15299 setState(1802); 15300 _errHandler.sync(this); 15301 switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { 15302 case 1: 15303 { 15304 setState(1798); 15305 match(WS); 15306 } 15307 break; 15308 case 2: 15309 { 15310 setState(1799); 15311 match(NEWLINE); 15312 } 15313 break; 15314 case 3: 15315 { 15316 setState(1800); 15317 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 15318 setState(1801); 15319 match(LEADING_ASTERISK); 15320 } 15321 break; 15322 } 15323 } 15324 break; 15325 default: 15326 throw new NoViableAltException(this); 15327 } 15328 setState(1804); 15329 _errHandler.sync(this); 15330 _alt = getInterpreter().adaptivePredict(_input,133,_ctx); 15331 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15332 setState(1806); 15333 match(PARAMETER_NAME); 15334 setState(1810); 15335 _errHandler.sync(this); 15336 _alt = getInterpreter().adaptivePredict(_input,134,_ctx); 15337 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15338 if ( _alt==1 ) { 15339 { 15340 { 15341 setState(1807); 15342 _la = _input.LA(1); 15343 if ( !(_la==WS || _la==NEWLINE) ) { 15344 _errHandler.recoverInline(this); 15345 } 15346 else { 15347 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15348 _errHandler.reportMatch(this); 15349 consume(); 15350 } 15351 } 15352 } 15353 } 15354 setState(1812); 15355 _errHandler.sync(this); 15356 _alt = getInterpreter().adaptivePredict(_input,134,_ctx); 15357 } 15358 setState(1815); 15359 _errHandler.sync(this); 15360 switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) { 15361 case 1: 15362 { 15363 setState(1813); 15364 _la = _input.LA(1); 15365 if ( !(_la==WS || _la==NEWLINE) ) { 15366 _errHandler.recoverInline(this); 15367 } 15368 else { 15369 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15370 _errHandler.reportMatch(this); 15371 consume(); 15372 } 15373 setState(1814); 15374 description(); 15375 } 15376 break; 15377 } 15378 } 15379 break; 15380 case RETURN_LITERAL: 15381 enterOuterAlt(_localctx, 5); 15382 { 15383 setState(1817); 15384 match(RETURN_LITERAL); 15385 setState(1819); 15386 _errHandler.sync(this); 15387 _alt = 1; 15388 do { 15389 switch (_alt) { 15390 case 1: 15391 { 15392 { 15393 setState(1818); 15394 _la = _input.LA(1); 15395 if ( !(_la==WS || _la==NEWLINE) ) { 15396 _errHandler.recoverInline(this); 15397 } 15398 else { 15399 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15400 _errHandler.reportMatch(this); 15401 consume(); 15402 } 15403 } 15404 } 15405 break; 15406 default: 15407 throw new NoViableAltException(this); 15408 } 15409 setState(1821); 15410 _errHandler.sync(this); 15411 _alt = getInterpreter().adaptivePredict(_input,136,_ctx); 15412 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15413 setState(1823); 15414 description(); 15415 } 15416 break; 15417 case SEE_LITERAL: 15418 enterOuterAlt(_localctx, 6); 15419 { 15420 setState(1824); 15421 match(SEE_LITERAL); 15422 setState(1829); 15423 _errHandler.sync(this); 15424 _alt = 1; 15425 do { 15426 switch (_alt) { 15427 case 1: 15428 { 15429 setState(1829); 15430 _errHandler.sync(this); 15431 switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) { 15432 case 1: 15433 { 15434 setState(1825); 15435 match(WS); 15436 } 15437 break; 15438 case 2: 15439 { 15440 setState(1826); 15441 match(NEWLINE); 15442 } 15443 break; 15444 case 3: 15445 { 15446 setState(1827); 15447 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 15448 setState(1828); 15449 match(LEADING_ASTERISK); 15450 } 15451 break; 15452 } 15453 } 15454 break; 15455 default: 15456 throw new NoViableAltException(this); 15457 } 15458 setState(1831); 15459 _errHandler.sync(this); 15460 _alt = getInterpreter().adaptivePredict(_input,138,_ctx); 15461 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15462 setState(1836); 15463 _errHandler.sync(this); 15464 switch (_input.LA(1)) { 15465 case PACKAGE_CLASS: 15466 case HASH: 15467 { 15468 setState(1833); 15469 reference(); 15470 } 15471 break; 15472 case STRING: 15473 { 15474 setState(1834); 15475 match(STRING); 15476 } 15477 break; 15478 case START: 15479 { 15480 setState(1835); 15481 htmlElement(); 15482 } 15483 break; 15484 default: 15485 throw new NoViableAltException(this); 15486 } 15487 setState(1841); 15488 _errHandler.sync(this); 15489 _alt = getInterpreter().adaptivePredict(_input,140,_ctx); 15490 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15491 if ( _alt==1 ) { 15492 { 15493 { 15494 setState(1838); 15495 _la = _input.LA(1); 15496 if ( !(_la==WS || _la==NEWLINE) ) { 15497 _errHandler.recoverInline(this); 15498 } 15499 else { 15500 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15501 _errHandler.reportMatch(this); 15502 consume(); 15503 } 15504 } 15505 } 15506 } 15507 setState(1843); 15508 _errHandler.sync(this); 15509 _alt = getInterpreter().adaptivePredict(_input,140,_ctx); 15510 } 15511 setState(1846); 15512 _errHandler.sync(this); 15513 switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) { 15514 case 1: 15515 { 15516 setState(1844); 15517 _la = _input.LA(1); 15518 if ( !(_la==WS || _la==NEWLINE) ) { 15519 _errHandler.recoverInline(this); 15520 } 15521 else { 15522 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15523 _errHandler.reportMatch(this); 15524 consume(); 15525 } 15526 setState(1845); 15527 description(); 15528 } 15529 break; 15530 } 15531 } 15532 break; 15533 case SERIAL_LITERAL: 15534 enterOuterAlt(_localctx, 7); 15535 { 15536 setState(1848); 15537 match(SERIAL_LITERAL); 15538 setState(1852); 15539 _errHandler.sync(this); 15540 _alt = getInterpreter().adaptivePredict(_input,142,_ctx); 15541 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15542 if ( _alt==1 ) { 15543 { 15544 { 15545 setState(1849); 15546 _la = _input.LA(1); 15547 if ( !(_la==WS || _la==NEWLINE) ) { 15548 _errHandler.recoverInline(this); 15549 } 15550 else { 15551 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15552 _errHandler.reportMatch(this); 15553 consume(); 15554 } 15555 } 15556 } 15557 } 15558 setState(1854); 15559 _errHandler.sync(this); 15560 _alt = getInterpreter().adaptivePredict(_input,142,_ctx); 15561 } 15562 setState(1859); 15563 _errHandler.sync(this); 15564 switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) { 15565 case 1: 15566 { 15567 setState(1855); 15568 _la = _input.LA(1); 15569 if ( !(_la==WS || _la==NEWLINE) ) { 15570 _errHandler.recoverInline(this); 15571 } 15572 else { 15573 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15574 _errHandler.reportMatch(this); 15575 consume(); 15576 } 15577 setState(1856); 15578 description(); 15579 } 15580 break; 15581 case 2: 15582 { 15583 setState(1857); 15584 match(LITERAL_INCLUDE); 15585 } 15586 break; 15587 case 3: 15588 { 15589 setState(1858); 15590 match(LITERAL_EXCLUDE); 15591 } 15592 break; 15593 } 15594 setState(1864); 15595 _errHandler.sync(this); 15596 _alt = getInterpreter().adaptivePredict(_input,144,_ctx); 15597 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15598 if ( _alt==1 ) { 15599 { 15600 { 15601 setState(1861); 15602 _la = _input.LA(1); 15603 if ( !(_la==WS || _la==NEWLINE) ) { 15604 _errHandler.recoverInline(this); 15605 } 15606 else { 15607 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15608 _errHandler.reportMatch(this); 15609 consume(); 15610 } 15611 } 15612 } 15613 } 15614 setState(1866); 15615 _errHandler.sync(this); 15616 _alt = getInterpreter().adaptivePredict(_input,144,_ctx); 15617 } 15618 } 15619 break; 15620 case SERIAL_DATA_LITERAL: 15621 enterOuterAlt(_localctx, 8); 15622 { 15623 setState(1867); 15624 match(SERIAL_DATA_LITERAL); 15625 setState(1871); 15626 _errHandler.sync(this); 15627 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 15628 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15629 if ( _alt==1 ) { 15630 { 15631 { 15632 setState(1868); 15633 _la = _input.LA(1); 15634 if ( !(_la==WS || _la==NEWLINE) ) { 15635 _errHandler.recoverInline(this); 15636 } 15637 else { 15638 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15639 _errHandler.reportMatch(this); 15640 consume(); 15641 } 15642 } 15643 } 15644 } 15645 setState(1873); 15646 _errHandler.sync(this); 15647 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 15648 } 15649 setState(1876); 15650 _errHandler.sync(this); 15651 switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { 15652 case 1: 15653 { 15654 setState(1874); 15655 _la = _input.LA(1); 15656 if ( !(_la==WS || _la==NEWLINE) ) { 15657 _errHandler.recoverInline(this); 15658 } 15659 else { 15660 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15661 _errHandler.reportMatch(this); 15662 consume(); 15663 } 15664 setState(1875); 15665 description(); 15666 } 15667 break; 15668 } 15669 } 15670 break; 15671 case SERIAL_FIELD_LITERAL: 15672 enterOuterAlt(_localctx, 9); 15673 { 15674 setState(1878); 15675 match(SERIAL_FIELD_LITERAL); 15676 setState(1882); 15677 _errHandler.sync(this); 15678 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 15679 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15680 if ( _alt==1 ) { 15681 { 15682 { 15683 setState(1879); 15684 _la = _input.LA(1); 15685 if ( !(_la==WS || _la==NEWLINE) ) { 15686 _errHandler.recoverInline(this); 15687 } 15688 else { 15689 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15690 _errHandler.reportMatch(this); 15691 consume(); 15692 } 15693 } 15694 } 15695 } 15696 setState(1884); 15697 _errHandler.sync(this); 15698 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 15699 } 15700 setState(1887); 15701 _errHandler.sync(this); 15702 switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { 15703 case 1: 15704 { 15705 setState(1885); 15706 _la = _input.LA(1); 15707 if ( !(_la==WS || _la==NEWLINE) ) { 15708 _errHandler.recoverInline(this); 15709 } 15710 else { 15711 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15712 _errHandler.reportMatch(this); 15713 consume(); 15714 } 15715 setState(1886); 15716 match(FIELD_NAME); 15717 } 15718 break; 15719 } 15720 setState(1892); 15721 _errHandler.sync(this); 15722 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 15723 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15724 if ( _alt==1 ) { 15725 { 15726 { 15727 setState(1889); 15728 _la = _input.LA(1); 15729 if ( !(_la==WS || _la==NEWLINE) ) { 15730 _errHandler.recoverInline(this); 15731 } 15732 else { 15733 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15734 _errHandler.reportMatch(this); 15735 consume(); 15736 } 15737 } 15738 } 15739 } 15740 setState(1894); 15741 _errHandler.sync(this); 15742 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 15743 } 15744 setState(1897); 15745 _errHandler.sync(this); 15746 switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { 15747 case 1: 15748 { 15749 setState(1895); 15750 _la = _input.LA(1); 15751 if ( !(_la==WS || _la==NEWLINE) ) { 15752 _errHandler.recoverInline(this); 15753 } 15754 else { 15755 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15756 _errHandler.reportMatch(this); 15757 consume(); 15758 } 15759 setState(1896); 15760 match(FIELD_TYPE); 15761 } 15762 break; 15763 } 15764 setState(1902); 15765 _errHandler.sync(this); 15766 _alt = getInterpreter().adaptivePredict(_input,151,_ctx); 15767 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15768 if ( _alt==1 ) { 15769 { 15770 { 15771 setState(1899); 15772 _la = _input.LA(1); 15773 if ( !(_la==WS || _la==NEWLINE) ) { 15774 _errHandler.recoverInline(this); 15775 } 15776 else { 15777 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15778 _errHandler.reportMatch(this); 15779 consume(); 15780 } 15781 } 15782 } 15783 } 15784 setState(1904); 15785 _errHandler.sync(this); 15786 _alt = getInterpreter().adaptivePredict(_input,151,_ctx); 15787 } 15788 setState(1907); 15789 _errHandler.sync(this); 15790 switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) { 15791 case 1: 15792 { 15793 setState(1905); 15794 _la = _input.LA(1); 15795 if ( !(_la==WS || _la==NEWLINE) ) { 15796 _errHandler.recoverInline(this); 15797 } 15798 else { 15799 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15800 _errHandler.reportMatch(this); 15801 consume(); 15802 } 15803 setState(1906); 15804 description(); 15805 } 15806 break; 15807 } 15808 } 15809 break; 15810 case SINCE_LITERAL: 15811 enterOuterAlt(_localctx, 10); 15812 { 15813 setState(1909); 15814 match(SINCE_LITERAL); 15815 setState(1911); 15816 _errHandler.sync(this); 15817 _alt = 1; 15818 do { 15819 switch (_alt) { 15820 case 1: 15821 { 15822 { 15823 setState(1910); 15824 _la = _input.LA(1); 15825 if ( !(_la==WS || _la==NEWLINE) ) { 15826 _errHandler.recoverInline(this); 15827 } 15828 else { 15829 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15830 _errHandler.reportMatch(this); 15831 consume(); 15832 } 15833 } 15834 } 15835 break; 15836 default: 15837 throw new NoViableAltException(this); 15838 } 15839 setState(1913); 15840 _errHandler.sync(this); 15841 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 15842 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15843 setState(1915); 15844 description(); 15845 } 15846 break; 15847 case THROWS_LITERAL: 15848 enterOuterAlt(_localctx, 11); 15849 { 15850 setState(1916); 15851 match(THROWS_LITERAL); 15852 setState(1921); 15853 _errHandler.sync(this); 15854 _alt = 1; 15855 do { 15856 switch (_alt) { 15857 case 1: 15858 { 15859 setState(1921); 15860 _errHandler.sync(this); 15861 switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) { 15862 case 1: 15863 { 15864 setState(1917); 15865 match(WS); 15866 } 15867 break; 15868 case 2: 15869 { 15870 setState(1918); 15871 match(NEWLINE); 15872 } 15873 break; 15874 case 3: 15875 { 15876 setState(1919); 15877 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 15878 setState(1920); 15879 match(LEADING_ASTERISK); 15880 } 15881 break; 15882 } 15883 } 15884 break; 15885 default: 15886 throw new NoViableAltException(this); 15887 } 15888 setState(1923); 15889 _errHandler.sync(this); 15890 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 15891 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15892 setState(1925); 15893 match(CLASS_NAME); 15894 setState(1929); 15895 _errHandler.sync(this); 15896 _alt = getInterpreter().adaptivePredict(_input,156,_ctx); 15897 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15898 if ( _alt==1 ) { 15899 { 15900 { 15901 setState(1926); 15902 _la = _input.LA(1); 15903 if ( !(_la==WS || _la==NEWLINE) ) { 15904 _errHandler.recoverInline(this); 15905 } 15906 else { 15907 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15908 _errHandler.reportMatch(this); 15909 consume(); 15910 } 15911 } 15912 } 15913 } 15914 setState(1931); 15915 _errHandler.sync(this); 15916 _alt = getInterpreter().adaptivePredict(_input,156,_ctx); 15917 } 15918 setState(1934); 15919 _errHandler.sync(this); 15920 switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { 15921 case 1: 15922 { 15923 setState(1932); 15924 _la = _input.LA(1); 15925 if ( !(_la==WS || _la==NEWLINE) ) { 15926 _errHandler.recoverInline(this); 15927 } 15928 else { 15929 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15930 _errHandler.reportMatch(this); 15931 consume(); 15932 } 15933 setState(1933); 15934 description(); 15935 } 15936 break; 15937 } 15938 } 15939 break; 15940 case VERSION_LITERAL: 15941 enterOuterAlt(_localctx, 12); 15942 { 15943 setState(1936); 15944 match(VERSION_LITERAL); 15945 setState(1938); 15946 _errHandler.sync(this); 15947 _alt = 1; 15948 do { 15949 switch (_alt) { 15950 case 1: 15951 { 15952 { 15953 setState(1937); 15954 _la = _input.LA(1); 15955 if ( !(_la==WS || _la==NEWLINE) ) { 15956 _errHandler.recoverInline(this); 15957 } 15958 else { 15959 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15960 _errHandler.reportMatch(this); 15961 consume(); 15962 } 15963 } 15964 } 15965 break; 15966 default: 15967 throw new NoViableAltException(this); 15968 } 15969 setState(1940); 15970 _errHandler.sync(this); 15971 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 15972 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15973 setState(1942); 15974 description(); 15975 } 15976 break; 15977 case CUSTOM_NAME: 15978 enterOuterAlt(_localctx, 13); 15979 { 15980 setState(1943); 15981 match(CUSTOM_NAME); 15982 setState(1947); 15983 _errHandler.sync(this); 15984 _alt = getInterpreter().adaptivePredict(_input,159,_ctx); 15985 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15986 if ( _alt==1 ) { 15987 { 15988 { 15989 setState(1944); 15990 _la = _input.LA(1); 15991 if ( !(_la==WS || _la==NEWLINE) ) { 15992 _errHandler.recoverInline(this); 15993 } 15994 else { 15995 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15996 _errHandler.reportMatch(this); 15997 consume(); 15998 } 15999 } 16000 } 16001 } 16002 setState(1949); 16003 _errHandler.sync(this); 16004 _alt = getInterpreter().adaptivePredict(_input,159,_ctx); 16005 } 16006 setState(1952); 16007 _errHandler.sync(this); 16008 switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) { 16009 case 1: 16010 { 16011 setState(1950); 16012 _la = _input.LA(1); 16013 if ( !(_la==WS || _la==NEWLINE) ) { 16014 _errHandler.recoverInline(this); 16015 } 16016 else { 16017 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16018 _errHandler.reportMatch(this); 16019 consume(); 16020 } 16021 setState(1951); 16022 description(); 16023 } 16024 break; 16025 } 16026 } 16027 break; 16028 default: 16029 throw new NoViableAltException(this); 16030 } 16031 } 16032 catch (RecognitionException re) { 16033 _localctx.exception = re; 16034 _errHandler.reportError(this, re); 16035 _errHandler.recover(this, re); 16036 } 16037 finally { 16038 exitRule(); 16039 } 16040 return _localctx; 16041 } 16042 16043 public static class JavadocInlineTagContext extends ParserRuleContext { 16044 public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); } 16045 public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); } 16046 public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); } 16047 public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); } 16048 public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); } 16049 public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); } 16050 public ReferenceContext reference() { 16051 return getRuleContext(ReferenceContext.class,0); 16052 } 16053 public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); } 16054 public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); } 16055 public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); } 16056 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 16057 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 16058 public TerminalNode WS(int i) { 16059 return getToken(JavadocParser.WS, i); 16060 } 16061 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 16062 public TerminalNode NEWLINE(int i) { 16063 return getToken(JavadocParser.NEWLINE, i); 16064 } 16065 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 16066 public TerminalNode LEADING_ASTERISK(int i) { 16067 return getToken(JavadocParser.LEADING_ASTERISK, i); 16068 } 16069 public List<TextContext> text() { 16070 return getRuleContexts(TextContext.class); 16071 } 16072 public TextContext text(int i) { 16073 return getRuleContext(TextContext.class,i); 16074 } 16075 public DescriptionContext description() { 16076 return getRuleContext(DescriptionContext.class,0); 16077 } 16078 public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) { 16079 super(parent, invokingState); 16080 } 16081 @Override public int getRuleIndex() { return RULE_javadocInlineTag; } 16082 } 16083 16084 public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException { 16085 JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState()); 16086 enterRule(_localctx, 144, RULE_javadocInlineTag); 16087 int _la; 16088 try { 16089 int _alt; 16090 enterOuterAlt(_localctx, 1); 16091 { 16092 setState(1956); 16093 match(JAVADOC_INLINE_TAG_START); 16094 setState(2047); 16095 _errHandler.sync(this); 16096 switch (_input.LA(1)) { 16097 case CODE_LITERAL: 16098 { 16099 setState(1957); 16100 match(CODE_LITERAL); 16101 setState(1964); 16102 _errHandler.sync(this); 16103 _la = _input.LA(1); 16104 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 16105 { 16106 setState(1962); 16107 _errHandler.sync(this); 16108 switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) { 16109 case 1: 16110 { 16111 setState(1958); 16112 match(WS); 16113 } 16114 break; 16115 case 2: 16116 { 16117 setState(1959); 16118 match(NEWLINE); 16119 } 16120 break; 16121 case 3: 16122 { 16123 setState(1960); 16124 match(LEADING_ASTERISK); 16125 } 16126 break; 16127 case 4: 16128 { 16129 setState(1961); 16130 text(); 16131 } 16132 break; 16133 } 16134 } 16135 setState(1966); 16136 _errHandler.sync(this); 16137 _la = _input.LA(1); 16138 } 16139 } 16140 break; 16141 case DOC_ROOT_LITERAL: 16142 { 16143 setState(1967); 16144 match(DOC_ROOT_LITERAL); 16145 setState(1971); 16146 _errHandler.sync(this); 16147 _la = _input.LA(1); 16148 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 16149 { 16150 { 16151 setState(1968); 16152 _la = _input.LA(1); 16153 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16154 _errHandler.recoverInline(this); 16155 } 16156 else { 16157 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16158 _errHandler.reportMatch(this); 16159 consume(); 16160 } 16161 } 16162 } 16163 setState(1973); 16164 _errHandler.sync(this); 16165 _la = _input.LA(1); 16166 } 16167 } 16168 break; 16169 case INHERIT_DOC_LITERAL: 16170 { 16171 setState(1974); 16172 match(INHERIT_DOC_LITERAL); 16173 setState(1978); 16174 _errHandler.sync(this); 16175 _la = _input.LA(1); 16176 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 16177 { 16178 { 16179 setState(1975); 16180 _la = _input.LA(1); 16181 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16182 _errHandler.recoverInline(this); 16183 } 16184 else { 16185 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16186 _errHandler.reportMatch(this); 16187 consume(); 16188 } 16189 } 16190 } 16191 setState(1980); 16192 _errHandler.sync(this); 16193 _la = _input.LA(1); 16194 } 16195 } 16196 break; 16197 case LINK_LITERAL: 16198 { 16199 setState(1981); 16200 match(LINK_LITERAL); 16201 setState(1983); 16202 _errHandler.sync(this); 16203 _la = _input.LA(1); 16204 do { 16205 { 16206 { 16207 setState(1982); 16208 _la = _input.LA(1); 16209 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16210 _errHandler.recoverInline(this); 16211 } 16212 else { 16213 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16214 _errHandler.reportMatch(this); 16215 consume(); 16216 } 16217 } 16218 } 16219 setState(1985); 16220 _errHandler.sync(this); 16221 _la = _input.LA(1); 16222 } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) ); 16223 setState(1987); 16224 reference(); 16225 setState(1991); 16226 _errHandler.sync(this); 16227 _alt = getInterpreter().adaptivePredict(_input,167,_ctx); 16228 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 16229 if ( _alt==1 ) { 16230 { 16231 { 16232 setState(1988); 16233 _la = _input.LA(1); 16234 if ( !(_la==WS || _la==NEWLINE) ) { 16235 _errHandler.recoverInline(this); 16236 } 16237 else { 16238 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16239 _errHandler.reportMatch(this); 16240 consume(); 16241 } 16242 } 16243 } 16244 } 16245 setState(1993); 16246 _errHandler.sync(this); 16247 _alt = getInterpreter().adaptivePredict(_input,167,_ctx); 16248 } 16249 setState(1996); 16250 _errHandler.sync(this); 16251 _la = _input.LA(1); 16252 if (_la==WS || _la==NEWLINE) { 16253 { 16254 setState(1994); 16255 _la = _input.LA(1); 16256 if ( !(_la==WS || _la==NEWLINE) ) { 16257 _errHandler.recoverInline(this); 16258 } 16259 else { 16260 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16261 _errHandler.reportMatch(this); 16262 consume(); 16263 } 16264 setState(1995); 16265 description(); 16266 } 16267 } 16268 16269 } 16270 break; 16271 case LINKPLAIN_LITERAL: 16272 { 16273 setState(1998); 16274 match(LINKPLAIN_LITERAL); 16275 setState(2000); 16276 _errHandler.sync(this); 16277 _la = _input.LA(1); 16278 do { 16279 { 16280 { 16281 setState(1999); 16282 _la = _input.LA(1); 16283 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16284 _errHandler.recoverInline(this); 16285 } 16286 else { 16287 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16288 _errHandler.reportMatch(this); 16289 consume(); 16290 } 16291 } 16292 } 16293 setState(2002); 16294 _errHandler.sync(this); 16295 _la = _input.LA(1); 16296 } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) ); 16297 setState(2004); 16298 reference(); 16299 setState(2008); 16300 _errHandler.sync(this); 16301 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 16302 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 16303 if ( _alt==1 ) { 16304 { 16305 { 16306 setState(2005); 16307 _la = _input.LA(1); 16308 if ( !(_la==WS || _la==NEWLINE) ) { 16309 _errHandler.recoverInline(this); 16310 } 16311 else { 16312 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16313 _errHandler.reportMatch(this); 16314 consume(); 16315 } 16316 } 16317 } 16318 } 16319 setState(2010); 16320 _errHandler.sync(this); 16321 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 16322 } 16323 setState(2013); 16324 _errHandler.sync(this); 16325 _la = _input.LA(1); 16326 if (_la==WS || _la==NEWLINE) { 16327 { 16328 setState(2011); 16329 _la = _input.LA(1); 16330 if ( !(_la==WS || _la==NEWLINE) ) { 16331 _errHandler.recoverInline(this); 16332 } 16333 else { 16334 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16335 _errHandler.reportMatch(this); 16336 consume(); 16337 } 16338 setState(2012); 16339 description(); 16340 } 16341 } 16342 16343 } 16344 break; 16345 case LITERAL_LITERAL: 16346 { 16347 setState(2015); 16348 match(LITERAL_LITERAL); 16349 setState(2022); 16350 _errHandler.sync(this); 16351 _la = _input.LA(1); 16352 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 16353 { 16354 setState(2020); 16355 _errHandler.sync(this); 16356 switch ( getInterpreter().adaptivePredict(_input,172,_ctx) ) { 16357 case 1: 16358 { 16359 setState(2016); 16360 match(WS); 16361 } 16362 break; 16363 case 2: 16364 { 16365 setState(2017); 16366 match(NEWLINE); 16367 } 16368 break; 16369 case 3: 16370 { 16371 setState(2018); 16372 match(LEADING_ASTERISK); 16373 } 16374 break; 16375 case 4: 16376 { 16377 setState(2019); 16378 text(); 16379 } 16380 break; 16381 } 16382 } 16383 setState(2024); 16384 _errHandler.sync(this); 16385 _la = _input.LA(1); 16386 } 16387 } 16388 break; 16389 case VALUE_LITERAL: 16390 { 16391 setState(2025); 16392 match(VALUE_LITERAL); 16393 setState(2029); 16394 _errHandler.sync(this); 16395 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 16396 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 16397 if ( _alt==1 ) { 16398 { 16399 { 16400 setState(2026); 16401 _la = _input.LA(1); 16402 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16403 _errHandler.recoverInline(this); 16404 } 16405 else { 16406 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16407 _errHandler.reportMatch(this); 16408 consume(); 16409 } 16410 } 16411 } 16412 } 16413 setState(2031); 16414 _errHandler.sync(this); 16415 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 16416 } 16417 setState(2034); 16418 _errHandler.sync(this); 16419 _la = _input.LA(1); 16420 if (_la==WS || _la==NEWLINE) { 16421 { 16422 setState(2032); 16423 _la = _input.LA(1); 16424 if ( !(_la==WS || _la==NEWLINE) ) { 16425 _errHandler.recoverInline(this); 16426 } 16427 else { 16428 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16429 _errHandler.reportMatch(this); 16430 consume(); 16431 } 16432 setState(2033); 16433 reference(); 16434 } 16435 } 16436 16437 } 16438 break; 16439 case CUSTOM_NAME: 16440 { 16441 setState(2036); 16442 match(CUSTOM_NAME); 16443 setState(2040); 16444 _errHandler.sync(this); 16445 _alt = getInterpreter().adaptivePredict(_input,176,_ctx); 16446 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 16447 if ( _alt==1 ) { 16448 { 16449 { 16450 setState(2037); 16451 _la = _input.LA(1); 16452 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16453 _errHandler.recoverInline(this); 16454 } 16455 else { 16456 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16457 _errHandler.reportMatch(this); 16458 consume(); 16459 } 16460 } 16461 } 16462 } 16463 setState(2042); 16464 _errHandler.sync(this); 16465 _alt = getInterpreter().adaptivePredict(_input,176,_ctx); 16466 } 16467 setState(2045); 16468 _errHandler.sync(this); 16469 _la = _input.LA(1); 16470 if (_la==WS || _la==NEWLINE) { 16471 { 16472 setState(2043); 16473 _la = _input.LA(1); 16474 if ( !(_la==WS || _la==NEWLINE) ) { 16475 _errHandler.recoverInline(this); 16476 } 16477 else { 16478 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16479 _errHandler.reportMatch(this); 16480 consume(); 16481 } 16482 setState(2044); 16483 description(); 16484 } 16485 } 16486 16487 } 16488 break; 16489 default: 16490 throw new NoViableAltException(this); 16491 } 16492 setState(2049); 16493 match(JAVADOC_INLINE_TAG_END); 16494 } 16495 } 16496 catch (RecognitionException re) { 16497 _localctx.exception = re; 16498 _errHandler.reportError(this, re); 16499 _errHandler.recover(this, re); 16500 } 16501 finally { 16502 exitRule(); 16503 } 16504 return _localctx; 16505 } 16506 16507 public static class HtmlCommentContext extends ParserRuleContext { 16508 public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); } 16509 public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); } 16510 public List<TextContext> text() { 16511 return getRuleContexts(TextContext.class); 16512 } 16513 public TextContext text(int i) { 16514 return getRuleContext(TextContext.class,i); 16515 } 16516 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 16517 public TerminalNode NEWLINE(int i) { 16518 return getToken(JavadocParser.NEWLINE, i); 16519 } 16520 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 16521 public TerminalNode LEADING_ASTERISK(int i) { 16522 return getToken(JavadocParser.LEADING_ASTERISK, i); 16523 } 16524 public HtmlCommentContext(ParserRuleContext parent, int invokingState) { 16525 super(parent, invokingState); 16526 } 16527 @Override public int getRuleIndex() { return RULE_htmlComment; } 16528 } 16529 16530 public final HtmlCommentContext htmlComment() throws RecognitionException { 16531 HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState()); 16532 enterRule(_localctx, 146, RULE_htmlComment); 16533 int _la; 16534 try { 16535 enterOuterAlt(_localctx, 1); 16536 { 16537 setState(2051); 16538 match(HTML_COMMENT_START); 16539 setState(2057); 16540 _errHandler.sync(this); 16541 _la = _input.LA(1); 16542 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 16543 { 16544 setState(2055); 16545 _errHandler.sync(this); 16546 switch (_input.LA(1)) { 16547 case WS: 16548 case CHAR: 16549 { 16550 setState(2052); 16551 text(); 16552 } 16553 break; 16554 case NEWLINE: 16555 { 16556 setState(2053); 16557 match(NEWLINE); 16558 } 16559 break; 16560 case LEADING_ASTERISK: 16561 { 16562 setState(2054); 16563 match(LEADING_ASTERISK); 16564 } 16565 break; 16566 default: 16567 throw new NoViableAltException(this); 16568 } 16569 } 16570 setState(2059); 16571 _errHandler.sync(this); 16572 _la = _input.LA(1); 16573 } 16574 setState(2060); 16575 match(HTML_COMMENT_END); 16576 } 16577 } 16578 catch (RecognitionException re) { 16579 _localctx.exception = re; 16580 _errHandler.reportError(this, re); 16581 _errHandler.recover(this, re); 16582 } 16583 finally { 16584 exitRule(); 16585 } 16586 return _localctx; 16587 } 16588 16589 public static class TextContext extends ParserRuleContext { 16590 public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); } 16591 public TerminalNode CHAR(int i) { 16592 return getToken(JavadocParser.CHAR, i); 16593 } 16594 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 16595 public TerminalNode WS(int i) { 16596 return getToken(JavadocParser.WS, i); 16597 } 16598 public TextContext(ParserRuleContext parent, int invokingState) { 16599 super(parent, invokingState); 16600 } 16601 @Override public int getRuleIndex() { return RULE_text; } 16602 } 16603 16604 public final TextContext text() throws RecognitionException { 16605 TextContext _localctx = new TextContext(_ctx, getState()); 16606 enterRule(_localctx, 148, RULE_text); 16607 int _la; 16608 try { 16609 int _alt; 16610 enterOuterAlt(_localctx, 1); 16611 { 16612 setState(2064); 16613 _errHandler.sync(this); 16614 _alt = 1; 16615 do { 16616 switch (_alt) { 16617 case 1: 16618 { 16619 { 16620 setState(2062); 16621 _la = _input.LA(1); 16622 if ( !(_la==WS || _la==CHAR) ) { 16623 _errHandler.recoverInline(this); 16624 } 16625 else { 16626 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16627 _errHandler.reportMatch(this); 16628 consume(); 16629 } 16630 16631 _la = _input.LA(1); 16632 if ((_la != WS) && (_la != CHAR)) return _localctx; 16633 else if (_alt == 1) continue; 16634 16635 } 16636 } 16637 break; 16638 default: 16639 throw new NoViableAltException(this); 16640 } 16641 setState(2066); 16642 _errHandler.sync(this); 16643 _alt = getInterpreter().adaptivePredict(_input,181,_ctx); 16644 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 16645 } 16646 } 16647 catch (RecognitionException re) { 16648 _localctx.exception = re; 16649 _errHandler.reportError(this, re); 16650 _errHandler.recover(this, re); 16651 } 16652 finally { 16653 exitRule(); 16654 } 16655 return _localctx; 16656 } 16657 16658 public static class EmbedTagContext extends ParserRuleContext { 16659 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 16660 public TerminalNode EMBED_HTML_TAG_NAME() { return getToken(JavadocParser.EMBED_HTML_TAG_NAME, 0); } 16661 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 16662 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 16663 public List<AttributeContext> attribute() { 16664 return getRuleContexts(AttributeContext.class); 16665 } 16666 public AttributeContext attribute(int i) { 16667 return getRuleContext(AttributeContext.class,i); 16668 } 16669 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 16670 public TerminalNode NEWLINE(int i) { 16671 return getToken(JavadocParser.NEWLINE, i); 16672 } 16673 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 16674 public TerminalNode LEADING_ASTERISK(int i) { 16675 return getToken(JavadocParser.LEADING_ASTERISK, i); 16676 } 16677 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 16678 public TerminalNode WS(int i) { 16679 return getToken(JavadocParser.WS, i); 16680 } 16681 public EmbedTagContext(ParserRuleContext parent, int invokingState) { 16682 super(parent, invokingState); 16683 } 16684 @Override public int getRuleIndex() { return RULE_embedTag; } 16685 } 16686 16687 public final EmbedTagContext embedTag() throws RecognitionException { 16688 EmbedTagContext _localctx = new EmbedTagContext(_ctx, getState()); 16689 enterRule(_localctx, 150, RULE_embedTag); 16690 int _la; 16691 try { 16692 enterOuterAlt(_localctx, 1); 16693 { 16694 setState(2068); 16695 match(START); 16696 setState(2069); 16697 match(EMBED_HTML_TAG_NAME); 16698 setState(2076); 16699 _errHandler.sync(this); 16700 _la = _input.LA(1); 16701 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 16702 { 16703 setState(2074); 16704 _errHandler.sync(this); 16705 switch (_input.LA(1)) { 16706 case HTML_TAG_NAME: 16707 { 16708 setState(2070); 16709 attribute(); 16710 } 16711 break; 16712 case NEWLINE: 16713 { 16714 setState(2071); 16715 match(NEWLINE); 16716 } 16717 break; 16718 case LEADING_ASTERISK: 16719 { 16720 setState(2072); 16721 match(LEADING_ASTERISK); 16722 } 16723 break; 16724 case WS: 16725 { 16726 setState(2073); 16727 match(WS); 16728 } 16729 break; 16730 default: 16731 throw new NoViableAltException(this); 16732 } 16733 } 16734 setState(2078); 16735 _errHandler.sync(this); 16736 _la = _input.LA(1); 16737 } 16738 setState(2079); 16739 _la = _input.LA(1); 16740 if ( !(_la==END || _la==SLASH_END) ) { 16741 _errHandler.recoverInline(this); 16742 } 16743 else { 16744 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16745 _errHandler.reportMatch(this); 16746 consume(); 16747 } 16748 } 16749 } 16750 catch (RecognitionException re) { 16751 _localctx.exception = re; 16752 _errHandler.reportError(this, re); 16753 _errHandler.recover(this, re); 16754 } 16755 finally { 16756 exitRule(); 16757 } 16758 return _localctx; 16759 } 16760 16761 public static class KeygenTagContext extends ParserRuleContext { 16762 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 16763 public TerminalNode KEYGEN_HTML_TAG_NAME() { return getToken(JavadocParser.KEYGEN_HTML_TAG_NAME, 0); } 16764 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 16765 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 16766 public List<AttributeContext> attribute() { 16767 return getRuleContexts(AttributeContext.class); 16768 } 16769 public AttributeContext attribute(int i) { 16770 return getRuleContext(AttributeContext.class,i); 16771 } 16772 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 16773 public TerminalNode NEWLINE(int i) { 16774 return getToken(JavadocParser.NEWLINE, i); 16775 } 16776 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 16777 public TerminalNode LEADING_ASTERISK(int i) { 16778 return getToken(JavadocParser.LEADING_ASTERISK, i); 16779 } 16780 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 16781 public TerminalNode WS(int i) { 16782 return getToken(JavadocParser.WS, i); 16783 } 16784 public KeygenTagContext(ParserRuleContext parent, int invokingState) { 16785 super(parent, invokingState); 16786 } 16787 @Override public int getRuleIndex() { return RULE_keygenTag; } 16788 } 16789 16790 public final KeygenTagContext keygenTag() throws RecognitionException { 16791 KeygenTagContext _localctx = new KeygenTagContext(_ctx, getState()); 16792 enterRule(_localctx, 152, RULE_keygenTag); 16793 int _la; 16794 try { 16795 enterOuterAlt(_localctx, 1); 16796 { 16797 setState(2081); 16798 match(START); 16799 setState(2082); 16800 match(KEYGEN_HTML_TAG_NAME); 16801 setState(2089); 16802 _errHandler.sync(this); 16803 _la = _input.LA(1); 16804 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 16805 { 16806 setState(2087); 16807 _errHandler.sync(this); 16808 switch (_input.LA(1)) { 16809 case HTML_TAG_NAME: 16810 { 16811 setState(2083); 16812 attribute(); 16813 } 16814 break; 16815 case NEWLINE: 16816 { 16817 setState(2084); 16818 match(NEWLINE); 16819 } 16820 break; 16821 case LEADING_ASTERISK: 16822 { 16823 setState(2085); 16824 match(LEADING_ASTERISK); 16825 } 16826 break; 16827 case WS: 16828 { 16829 setState(2086); 16830 match(WS); 16831 } 16832 break; 16833 default: 16834 throw new NoViableAltException(this); 16835 } 16836 } 16837 setState(2091); 16838 _errHandler.sync(this); 16839 _la = _input.LA(1); 16840 } 16841 setState(2092); 16842 _la = _input.LA(1); 16843 if ( !(_la==END || _la==SLASH_END) ) { 16844 _errHandler.recoverInline(this); 16845 } 16846 else { 16847 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16848 _errHandler.reportMatch(this); 16849 consume(); 16850 } 16851 } 16852 } 16853 catch (RecognitionException re) { 16854 _localctx.exception = re; 16855 _errHandler.reportError(this, re); 16856 _errHandler.recover(this, re); 16857 } 16858 finally { 16859 exitRule(); 16860 } 16861 return _localctx; 16862 } 16863 16864 public static class SourceTagContext extends ParserRuleContext { 16865 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 16866 public TerminalNode SOURCE_HTML_TAG_NAME() { return getToken(JavadocParser.SOURCE_HTML_TAG_NAME, 0); } 16867 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 16868 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 16869 public List<AttributeContext> attribute() { 16870 return getRuleContexts(AttributeContext.class); 16871 } 16872 public AttributeContext attribute(int i) { 16873 return getRuleContext(AttributeContext.class,i); 16874 } 16875 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 16876 public TerminalNode NEWLINE(int i) { 16877 return getToken(JavadocParser.NEWLINE, i); 16878 } 16879 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 16880 public TerminalNode LEADING_ASTERISK(int i) { 16881 return getToken(JavadocParser.LEADING_ASTERISK, i); 16882 } 16883 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 16884 public TerminalNode WS(int i) { 16885 return getToken(JavadocParser.WS, i); 16886 } 16887 public SourceTagContext(ParserRuleContext parent, int invokingState) { 16888 super(parent, invokingState); 16889 } 16890 @Override public int getRuleIndex() { return RULE_sourceTag; } 16891 } 16892 16893 public final SourceTagContext sourceTag() throws RecognitionException { 16894 SourceTagContext _localctx = new SourceTagContext(_ctx, getState()); 16895 enterRule(_localctx, 154, RULE_sourceTag); 16896 int _la; 16897 try { 16898 enterOuterAlt(_localctx, 1); 16899 { 16900 setState(2094); 16901 match(START); 16902 setState(2095); 16903 match(SOURCE_HTML_TAG_NAME); 16904 setState(2102); 16905 _errHandler.sync(this); 16906 _la = _input.LA(1); 16907 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 16908 { 16909 setState(2100); 16910 _errHandler.sync(this); 16911 switch (_input.LA(1)) { 16912 case HTML_TAG_NAME: 16913 { 16914 setState(2096); 16915 attribute(); 16916 } 16917 break; 16918 case NEWLINE: 16919 { 16920 setState(2097); 16921 match(NEWLINE); 16922 } 16923 break; 16924 case LEADING_ASTERISK: 16925 { 16926 setState(2098); 16927 match(LEADING_ASTERISK); 16928 } 16929 break; 16930 case WS: 16931 { 16932 setState(2099); 16933 match(WS); 16934 } 16935 break; 16936 default: 16937 throw new NoViableAltException(this); 16938 } 16939 } 16940 setState(2104); 16941 _errHandler.sync(this); 16942 _la = _input.LA(1); 16943 } 16944 setState(2105); 16945 _la = _input.LA(1); 16946 if ( !(_la==END || _la==SLASH_END) ) { 16947 _errHandler.recoverInline(this); 16948 } 16949 else { 16950 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16951 _errHandler.reportMatch(this); 16952 consume(); 16953 } 16954 } 16955 } 16956 catch (RecognitionException re) { 16957 _localctx.exception = re; 16958 _errHandler.reportError(this, re); 16959 _errHandler.recover(this, re); 16960 } 16961 finally { 16962 exitRule(); 16963 } 16964 return _localctx; 16965 } 16966 16967 public static class TrackTagContext extends ParserRuleContext { 16968 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 16969 public TerminalNode TRACK_HTML_TAG_NAME() { return getToken(JavadocParser.TRACK_HTML_TAG_NAME, 0); } 16970 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 16971 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 16972 public List<AttributeContext> attribute() { 16973 return getRuleContexts(AttributeContext.class); 16974 } 16975 public AttributeContext attribute(int i) { 16976 return getRuleContext(AttributeContext.class,i); 16977 } 16978 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 16979 public TerminalNode NEWLINE(int i) { 16980 return getToken(JavadocParser.NEWLINE, i); 16981 } 16982 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 16983 public TerminalNode LEADING_ASTERISK(int i) { 16984 return getToken(JavadocParser.LEADING_ASTERISK, i); 16985 } 16986 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 16987 public TerminalNode WS(int i) { 16988 return getToken(JavadocParser.WS, i); 16989 } 16990 public TrackTagContext(ParserRuleContext parent, int invokingState) { 16991 super(parent, invokingState); 16992 } 16993 @Override public int getRuleIndex() { return RULE_trackTag; } 16994 } 16995 16996 public final TrackTagContext trackTag() throws RecognitionException { 16997 TrackTagContext _localctx = new TrackTagContext(_ctx, getState()); 16998 enterRule(_localctx, 156, RULE_trackTag); 16999 int _la; 17000 try { 17001 enterOuterAlt(_localctx, 1); 17002 { 17003 setState(2107); 17004 match(START); 17005 setState(2108); 17006 match(TRACK_HTML_TAG_NAME); 17007 setState(2115); 17008 _errHandler.sync(this); 17009 _la = _input.LA(1); 17010 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 17011 { 17012 setState(2113); 17013 _errHandler.sync(this); 17014 switch (_input.LA(1)) { 17015 case HTML_TAG_NAME: 17016 { 17017 setState(2109); 17018 attribute(); 17019 } 17020 break; 17021 case NEWLINE: 17022 { 17023 setState(2110); 17024 match(NEWLINE); 17025 } 17026 break; 17027 case LEADING_ASTERISK: 17028 { 17029 setState(2111); 17030 match(LEADING_ASTERISK); 17031 } 17032 break; 17033 case WS: 17034 { 17035 setState(2112); 17036 match(WS); 17037 } 17038 break; 17039 default: 17040 throw new NoViableAltException(this); 17041 } 17042 } 17043 setState(2117); 17044 _errHandler.sync(this); 17045 _la = _input.LA(1); 17046 } 17047 setState(2118); 17048 _la = _input.LA(1); 17049 if ( !(_la==END || _la==SLASH_END) ) { 17050 _errHandler.recoverInline(this); 17051 } 17052 else { 17053 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 17054 _errHandler.reportMatch(this); 17055 consume(); 17056 } 17057 } 17058 } 17059 catch (RecognitionException re) { 17060 _localctx.exception = re; 17061 _errHandler.reportError(this, re); 17062 _errHandler.recover(this, re); 17063 } 17064 finally { 17065 exitRule(); 17066 } 17067 return _localctx; 17068 } 17069 17070 public static class WbrTagContext extends ParserRuleContext { 17071 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 17072 public TerminalNode WBR_HTML_TAG_NAME() { return getToken(JavadocParser.WBR_HTML_TAG_NAME, 0); } 17073 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 17074 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 17075 public List<AttributeContext> attribute() { 17076 return getRuleContexts(AttributeContext.class); 17077 } 17078 public AttributeContext attribute(int i) { 17079 return getRuleContext(AttributeContext.class,i); 17080 } 17081 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17082 public TerminalNode NEWLINE(int i) { 17083 return getToken(JavadocParser.NEWLINE, i); 17084 } 17085 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17086 public TerminalNode LEADING_ASTERISK(int i) { 17087 return getToken(JavadocParser.LEADING_ASTERISK, i); 17088 } 17089 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 17090 public TerminalNode WS(int i) { 17091 return getToken(JavadocParser.WS, i); 17092 } 17093 public WbrTagContext(ParserRuleContext parent, int invokingState) { 17094 super(parent, invokingState); 17095 } 17096 @Override public int getRuleIndex() { return RULE_wbrTag; } 17097 } 17098 17099 public final WbrTagContext wbrTag() throws RecognitionException { 17100 WbrTagContext _localctx = new WbrTagContext(_ctx, getState()); 17101 enterRule(_localctx, 158, RULE_wbrTag); 17102 int _la; 17103 try { 17104 enterOuterAlt(_localctx, 1); 17105 { 17106 setState(2120); 17107 match(START); 17108 setState(2121); 17109 match(WBR_HTML_TAG_NAME); 17110 setState(2128); 17111 _errHandler.sync(this); 17112 _la = _input.LA(1); 17113 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 17114 { 17115 setState(2126); 17116 _errHandler.sync(this); 17117 switch (_input.LA(1)) { 17118 case HTML_TAG_NAME: 17119 { 17120 setState(2122); 17121 attribute(); 17122 } 17123 break; 17124 case NEWLINE: 17125 { 17126 setState(2123); 17127 match(NEWLINE); 17128 } 17129 break; 17130 case LEADING_ASTERISK: 17131 { 17132 setState(2124); 17133 match(LEADING_ASTERISK); 17134 } 17135 break; 17136 case WS: 17137 { 17138 setState(2125); 17139 match(WS); 17140 } 17141 break; 17142 default: 17143 throw new NoViableAltException(this); 17144 } 17145 } 17146 setState(2130); 17147 _errHandler.sync(this); 17148 _la = _input.LA(1); 17149 } 17150 setState(2131); 17151 _la = _input.LA(1); 17152 if ( !(_la==END || _la==SLASH_END) ) { 17153 _errHandler.recoverInline(this); 17154 } 17155 else { 17156 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 17157 _errHandler.reportMatch(this); 17158 consume(); 17159 } 17160 } 17161 } 17162 catch (RecognitionException re) { 17163 _localctx.exception = re; 17164 _errHandler.reportError(this, re); 17165 _errHandler.recover(this, re); 17166 } 17167 finally { 17168 exitRule(); 17169 } 17170 return _localctx; 17171 } 17172 17173 public static class OptgroupTagStartContext extends ParserRuleContext { 17174 public boolean isNonTight; 17175 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 17176 public TerminalNode OPTGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.OPTGROUP_HTML_TAG_NAME, 0); } 17177 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 17178 public List<AttributeContext> attribute() { 17179 return getRuleContexts(AttributeContext.class); 17180 } 17181 public AttributeContext attribute(int i) { 17182 return getRuleContext(AttributeContext.class,i); 17183 } 17184 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17185 public TerminalNode NEWLINE(int i) { 17186 return getToken(JavadocParser.NEWLINE, i); 17187 } 17188 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17189 public TerminalNode LEADING_ASTERISK(int i) { 17190 return getToken(JavadocParser.LEADING_ASTERISK, i); 17191 } 17192 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 17193 public TerminalNode WS(int i) { 17194 return getToken(JavadocParser.WS, i); 17195 } 17196 public OptgroupTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 17197 public OptgroupTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 17198 super(parent, invokingState); 17199 this.isNonTight = isNonTight; 17200 } 17201 @Override public int getRuleIndex() { return RULE_optgroupTagStart; } 17202 } 17203 17204 public final OptgroupTagStartContext optgroupTagStart(boolean isNonTight) throws RecognitionException { 17205 OptgroupTagStartContext _localctx = new OptgroupTagStartContext(_ctx, getState(), isNonTight); 17206 enterRule(_localctx, 160, RULE_optgroupTagStart); 17207 int _la; 17208 try { 17209 enterOuterAlt(_localctx, 1); 17210 { 17211 setState(2133); 17212 match(START); 17213 setState(2134); 17214 match(OPTGROUP_HTML_TAG_NAME); 17215 setState(2141); 17216 _errHandler.sync(this); 17217 _la = _input.LA(1); 17218 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 17219 { 17220 setState(2139); 17221 _errHandler.sync(this); 17222 switch (_input.LA(1)) { 17223 case HTML_TAG_NAME: 17224 { 17225 setState(2135); 17226 attribute(); 17227 } 17228 break; 17229 case NEWLINE: 17230 { 17231 setState(2136); 17232 match(NEWLINE); 17233 } 17234 break; 17235 case LEADING_ASTERISK: 17236 { 17237 setState(2137); 17238 match(LEADING_ASTERISK); 17239 } 17240 break; 17241 case WS: 17242 { 17243 setState(2138); 17244 match(WS); 17245 } 17246 break; 17247 default: 17248 throw new NoViableAltException(this); 17249 } 17250 } 17251 setState(2143); 17252 _errHandler.sync(this); 17253 _la = _input.LA(1); 17254 } 17255 setState(2144); 17256 match(END); 17257 } 17258 _ctx.stop = _input.LT(-1); 17259 17260 if (isNonTight && nonTightTagStartContext == null) { 17261 nonTightTagStartContext = _localctx; 17262 } 17263 17264 } 17265 catch (RecognitionException re) { 17266 _localctx.exception = re; 17267 _errHandler.reportError(this, re); 17268 _errHandler.recover(this, re); 17269 } 17270 finally { 17271 exitRule(); 17272 } 17273 return _localctx; 17274 } 17275 17276 public static class OptgroupTagEndContext extends ParserRuleContext { 17277 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 17278 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 17279 public TerminalNode OPTGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.OPTGROUP_HTML_TAG_NAME, 0); } 17280 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 17281 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17282 public TerminalNode NEWLINE(int i) { 17283 return getToken(JavadocParser.NEWLINE, i); 17284 } 17285 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17286 public TerminalNode LEADING_ASTERISK(int i) { 17287 return getToken(JavadocParser.LEADING_ASTERISK, i); 17288 } 17289 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 17290 public TerminalNode WS(int i) { 17291 return getToken(JavadocParser.WS, i); 17292 } 17293 public OptgroupTagEndContext(ParserRuleContext parent, int invokingState) { 17294 super(parent, invokingState); 17295 } 17296 @Override public int getRuleIndex() { return RULE_optgroupTagEnd; } 17297 } 17298 17299 public final OptgroupTagEndContext optgroupTagEnd() throws RecognitionException { 17300 OptgroupTagEndContext _localctx = new OptgroupTagEndContext(_ctx, getState()); 17301 enterRule(_localctx, 162, RULE_optgroupTagEnd); 17302 int _la; 17303 try { 17304 enterOuterAlt(_localctx, 1); 17305 { 17306 setState(2146); 17307 match(START); 17308 setState(2147); 17309 match(SLASH); 17310 setState(2148); 17311 match(OPTGROUP_HTML_TAG_NAME); 17312 setState(2152); 17313 _errHandler.sync(this); 17314 _la = _input.LA(1); 17315 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 17316 { 17317 { 17318 setState(2149); 17319 _la = _input.LA(1); 17320 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 17321 _errHandler.recoverInline(this); 17322 } 17323 else { 17324 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 17325 _errHandler.reportMatch(this); 17326 consume(); 17327 } 17328 } 17329 } 17330 setState(2154); 17331 _errHandler.sync(this); 17332 _la = _input.LA(1); 17333 } 17334 setState(2155); 17335 match(END); 17336 } 17337 } 17338 catch (RecognitionException re) { 17339 _localctx.exception = re; 17340 _errHandler.reportError(this, re); 17341 _errHandler.recover(this, re); 17342 } 17343 finally { 17344 exitRule(); 17345 } 17346 return _localctx; 17347 } 17348 17349 public static class OptgroupContext extends ParserRuleContext { 17350 public OptgroupTagStartContext optgroupTagStart() { 17351 return getRuleContext(OptgroupTagStartContext.class,0); 17352 } 17353 public OptgroupTagEndContext optgroupTagEnd() { 17354 return getRuleContext(OptgroupTagEndContext.class,0); 17355 } 17356 public List<HtmlTagContext> htmlTag() { 17357 return getRuleContexts(HtmlTagContext.class); 17358 } 17359 public HtmlTagContext htmlTag(int i) { 17360 return getRuleContext(HtmlTagContext.class,i); 17361 } 17362 public List<SingletonElementContext> singletonElement() { 17363 return getRuleContexts(SingletonElementContext.class); 17364 } 17365 public SingletonElementContext singletonElement(int i) { 17366 return getRuleContext(SingletonElementContext.class,i); 17367 } 17368 public List<ParagraphContext> paragraph() { 17369 return getRuleContexts(ParagraphContext.class); 17370 } 17371 public ParagraphContext paragraph(int i) { 17372 return getRuleContext(ParagraphContext.class,i); 17373 } 17374 public List<LiContext> li() { 17375 return getRuleContexts(LiContext.class); 17376 } 17377 public LiContext li(int i) { 17378 return getRuleContext(LiContext.class,i); 17379 } 17380 public List<TrContext> tr() { 17381 return getRuleContexts(TrContext.class); 17382 } 17383 public TrContext tr(int i) { 17384 return getRuleContext(TrContext.class,i); 17385 } 17386 public List<TdContext> td() { 17387 return getRuleContexts(TdContext.class); 17388 } 17389 public TdContext td(int i) { 17390 return getRuleContext(TdContext.class,i); 17391 } 17392 public List<ThContext> th() { 17393 return getRuleContexts(ThContext.class); 17394 } 17395 public ThContext th(int i) { 17396 return getRuleContext(ThContext.class,i); 17397 } 17398 public List<BodyContext> body() { 17399 return getRuleContexts(BodyContext.class); 17400 } 17401 public BodyContext body(int i) { 17402 return getRuleContext(BodyContext.class,i); 17403 } 17404 public List<ColgroupContext> colgroup() { 17405 return getRuleContexts(ColgroupContext.class); 17406 } 17407 public ColgroupContext colgroup(int i) { 17408 return getRuleContext(ColgroupContext.class,i); 17409 } 17410 public List<DdContext> dd() { 17411 return getRuleContexts(DdContext.class); 17412 } 17413 public DdContext dd(int i) { 17414 return getRuleContext(DdContext.class,i); 17415 } 17416 public List<DtContext> dt() { 17417 return getRuleContexts(DtContext.class); 17418 } 17419 public DtContext dt(int i) { 17420 return getRuleContext(DtContext.class,i); 17421 } 17422 public List<HeadContext> head() { 17423 return getRuleContexts(HeadContext.class); 17424 } 17425 public HeadContext head(int i) { 17426 return getRuleContext(HeadContext.class,i); 17427 } 17428 public List<HtmlContext> html() { 17429 return getRuleContexts(HtmlContext.class); 17430 } 17431 public HtmlContext html(int i) { 17432 return getRuleContext(HtmlContext.class,i); 17433 } 17434 public List<OptionContext> option() { 17435 return getRuleContexts(OptionContext.class); 17436 } 17437 public OptionContext option(int i) { 17438 return getRuleContext(OptionContext.class,i); 17439 } 17440 public List<TbodyContext> tbody() { 17441 return getRuleContexts(TbodyContext.class); 17442 } 17443 public TbodyContext tbody(int i) { 17444 return getRuleContext(TbodyContext.class,i); 17445 } 17446 public List<TfootContext> tfoot() { 17447 return getRuleContexts(TfootContext.class); 17448 } 17449 public TfootContext tfoot(int i) { 17450 return getRuleContext(TfootContext.class,i); 17451 } 17452 public List<PTagStartContext> pTagStart() { 17453 return getRuleContexts(PTagStartContext.class); 17454 } 17455 public PTagStartContext pTagStart(int i) { 17456 return getRuleContext(PTagStartContext.class,i); 17457 } 17458 public List<LiTagStartContext> liTagStart() { 17459 return getRuleContexts(LiTagStartContext.class); 17460 } 17461 public LiTagStartContext liTagStart(int i) { 17462 return getRuleContext(LiTagStartContext.class,i); 17463 } 17464 public List<TrTagStartContext> trTagStart() { 17465 return getRuleContexts(TrTagStartContext.class); 17466 } 17467 public TrTagStartContext trTagStart(int i) { 17468 return getRuleContext(TrTagStartContext.class,i); 17469 } 17470 public List<TdTagStartContext> tdTagStart() { 17471 return getRuleContexts(TdTagStartContext.class); 17472 } 17473 public TdTagStartContext tdTagStart(int i) { 17474 return getRuleContext(TdTagStartContext.class,i); 17475 } 17476 public List<ThTagStartContext> thTagStart() { 17477 return getRuleContexts(ThTagStartContext.class); 17478 } 17479 public ThTagStartContext thTagStart(int i) { 17480 return getRuleContext(ThTagStartContext.class,i); 17481 } 17482 public List<BodyTagStartContext> bodyTagStart() { 17483 return getRuleContexts(BodyTagStartContext.class); 17484 } 17485 public BodyTagStartContext bodyTagStart(int i) { 17486 return getRuleContext(BodyTagStartContext.class,i); 17487 } 17488 public List<ColgroupTagStartContext> colgroupTagStart() { 17489 return getRuleContexts(ColgroupTagStartContext.class); 17490 } 17491 public ColgroupTagStartContext colgroupTagStart(int i) { 17492 return getRuleContext(ColgroupTagStartContext.class,i); 17493 } 17494 public List<DdTagStartContext> ddTagStart() { 17495 return getRuleContexts(DdTagStartContext.class); 17496 } 17497 public DdTagStartContext ddTagStart(int i) { 17498 return getRuleContext(DdTagStartContext.class,i); 17499 } 17500 public List<DtTagStartContext> dtTagStart() { 17501 return getRuleContexts(DtTagStartContext.class); 17502 } 17503 public DtTagStartContext dtTagStart(int i) { 17504 return getRuleContext(DtTagStartContext.class,i); 17505 } 17506 public List<HeadTagStartContext> headTagStart() { 17507 return getRuleContexts(HeadTagStartContext.class); 17508 } 17509 public HeadTagStartContext headTagStart(int i) { 17510 return getRuleContext(HeadTagStartContext.class,i); 17511 } 17512 public List<HtmlTagStartContext> htmlTagStart() { 17513 return getRuleContexts(HtmlTagStartContext.class); 17514 } 17515 public HtmlTagStartContext htmlTagStart(int i) { 17516 return getRuleContext(HtmlTagStartContext.class,i); 17517 } 17518 public List<OptionTagStartContext> optionTagStart() { 17519 return getRuleContexts(OptionTagStartContext.class); 17520 } 17521 public OptionTagStartContext optionTagStart(int i) { 17522 return getRuleContext(OptionTagStartContext.class,i); 17523 } 17524 public List<TbodyTagStartContext> tbodyTagStart() { 17525 return getRuleContexts(TbodyTagStartContext.class); 17526 } 17527 public TbodyTagStartContext tbodyTagStart(int i) { 17528 return getRuleContext(TbodyTagStartContext.class,i); 17529 } 17530 public List<TfootTagStartContext> tfootTagStart() { 17531 return getRuleContexts(TfootTagStartContext.class); 17532 } 17533 public TfootTagStartContext tfootTagStart(int i) { 17534 return getRuleContext(TfootTagStartContext.class,i); 17535 } 17536 public List<HtmlCommentContext> htmlComment() { 17537 return getRuleContexts(HtmlCommentContext.class); 17538 } 17539 public HtmlCommentContext htmlComment(int i) { 17540 return getRuleContext(HtmlCommentContext.class,i); 17541 } 17542 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17543 public TerminalNode NEWLINE(int i) { 17544 return getToken(JavadocParser.NEWLINE, i); 17545 } 17546 public List<TextContext> text() { 17547 return getRuleContexts(TextContext.class); 17548 } 17549 public TextContext text(int i) { 17550 return getRuleContext(TextContext.class,i); 17551 } 17552 public List<JavadocInlineTagContext> javadocInlineTag() { 17553 return getRuleContexts(JavadocInlineTagContext.class); 17554 } 17555 public JavadocInlineTagContext javadocInlineTag(int i) { 17556 return getRuleContext(JavadocInlineTagContext.class,i); 17557 } 17558 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17559 public TerminalNode LEADING_ASTERISK(int i) { 17560 return getToken(JavadocParser.LEADING_ASTERISK, i); 17561 } 17562 public OptgroupContext(ParserRuleContext parent, int invokingState) { 17563 super(parent, invokingState); 17564 } 17565 @Override public int getRuleIndex() { return RULE_optgroup; } 17566 } 17567 17568 public final OptgroupContext optgroup() throws RecognitionException { 17569 OptgroupContext _localctx = new OptgroupContext(_ctx, getState()); 17570 enterRule(_localctx, 164, RULE_optgroup); 17571 try { 17572 int _alt; 17573 enterOuterAlt(_localctx, 1); 17574 { 17575 setState(2157); 17576 optgroupTagStart(false); 17577 setState(2196); 17578 _errHandler.sync(this); 17579 _alt = getInterpreter().adaptivePredict(_input,196,_ctx); 17580 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 17581 if ( _alt==1 ) { 17582 { 17583 setState(2194); 17584 _errHandler.sync(this); 17585 switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) { 17586 case 1: 17587 { 17588 setState(2158); 17589 htmlTag(); 17590 } 17591 break; 17592 case 2: 17593 { 17594 setState(2159); 17595 singletonElement(); 17596 } 17597 break; 17598 case 3: 17599 { 17600 setState(2160); 17601 paragraph(); 17602 } 17603 break; 17604 case 4: 17605 { 17606 setState(2161); 17607 li(); 17608 } 17609 break; 17610 case 5: 17611 { 17612 setState(2162); 17613 tr(); 17614 } 17615 break; 17616 case 6: 17617 { 17618 setState(2163); 17619 td(); 17620 } 17621 break; 17622 case 7: 17623 { 17624 setState(2164); 17625 th(); 17626 } 17627 break; 17628 case 8: 17629 { 17630 setState(2165); 17631 body(); 17632 } 17633 break; 17634 case 9: 17635 { 17636 setState(2166); 17637 colgroup(); 17638 } 17639 break; 17640 case 10: 17641 { 17642 setState(2167); 17643 dd(); 17644 } 17645 break; 17646 case 11: 17647 { 17648 setState(2168); 17649 dt(); 17650 } 17651 break; 17652 case 12: 17653 { 17654 setState(2169); 17655 head(); 17656 } 17657 break; 17658 case 13: 17659 { 17660 setState(2170); 17661 html(); 17662 } 17663 break; 17664 case 14: 17665 { 17666 setState(2171); 17667 option(); 17668 } 17669 break; 17670 case 15: 17671 { 17672 setState(2172); 17673 tbody(); 17674 } 17675 break; 17676 case 16: 17677 { 17678 setState(2173); 17679 tfoot(); 17680 } 17681 break; 17682 case 17: 17683 { 17684 setState(2174); 17685 pTagStart(true); 17686 } 17687 break; 17688 case 18: 17689 { 17690 setState(2175); 17691 liTagStart(true); 17692 } 17693 break; 17694 case 19: 17695 { 17696 setState(2176); 17697 trTagStart(true); 17698 } 17699 break; 17700 case 20: 17701 { 17702 setState(2177); 17703 tdTagStart(true); 17704 } 17705 break; 17706 case 21: 17707 { 17708 setState(2178); 17709 thTagStart(true); 17710 } 17711 break; 17712 case 22: 17713 { 17714 setState(2179); 17715 bodyTagStart(true); 17716 } 17717 break; 17718 case 23: 17719 { 17720 setState(2180); 17721 colgroupTagStart(true); 17722 } 17723 break; 17724 case 24: 17725 { 17726 setState(2181); 17727 ddTagStart(true); 17728 } 17729 break; 17730 case 25: 17731 { 17732 setState(2182); 17733 dtTagStart(true); 17734 } 17735 break; 17736 case 26: 17737 { 17738 setState(2183); 17739 headTagStart(true); 17740 } 17741 break; 17742 case 27: 17743 { 17744 setState(2184); 17745 htmlTagStart(true); 17746 } 17747 break; 17748 case 28: 17749 { 17750 setState(2185); 17751 optionTagStart(true); 17752 } 17753 break; 17754 case 29: 17755 { 17756 setState(2186); 17757 tbodyTagStart(true); 17758 } 17759 break; 17760 case 30: 17761 { 17762 setState(2187); 17763 tfootTagStart(true); 17764 } 17765 break; 17766 case 31: 17767 { 17768 { 17769 setState(2188); 17770 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 17771 setState(2189); 17772 match(LEADING_ASTERISK); 17773 } 17774 } 17775 break; 17776 case 32: 17777 { 17778 setState(2190); 17779 htmlComment(); 17780 } 17781 break; 17782 case 33: 17783 { 17784 setState(2191); 17785 match(NEWLINE); 17786 } 17787 break; 17788 case 34: 17789 { 17790 setState(2192); 17791 text(); 17792 } 17793 break; 17794 case 35: 17795 { 17796 setState(2193); 17797 javadocInlineTag(); 17798 } 17799 break; 17800 } 17801 } 17802 } 17803 setState(2198); 17804 _errHandler.sync(this); 17805 _alt = getInterpreter().adaptivePredict(_input,196,_ctx); 17806 } 17807 setState(2199); 17808 optgroupTagEnd(); 17809 } 17810 } 17811 catch (RecognitionException re) { 17812 _localctx.exception = re; 17813 _errHandler.reportError(this, re); 17814 _errHandler.recover(this, re); 17815 } 17816 finally { 17817 exitRule(); 17818 } 17819 return _localctx; 17820 } 17821 17822 public static class RbTagStartContext extends ParserRuleContext { 17823 public boolean isNonTight; 17824 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 17825 public TerminalNode RB_HTML_TAG_NAME() { return getToken(JavadocParser.RB_HTML_TAG_NAME, 0); } 17826 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 17827 public List<AttributeContext> attribute() { 17828 return getRuleContexts(AttributeContext.class); 17829 } 17830 public AttributeContext attribute(int i) { 17831 return getRuleContext(AttributeContext.class,i); 17832 } 17833 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17834 public TerminalNode NEWLINE(int i) { 17835 return getToken(JavadocParser.NEWLINE, i); 17836 } 17837 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17838 public TerminalNode LEADING_ASTERISK(int i) { 17839 return getToken(JavadocParser.LEADING_ASTERISK, i); 17840 } 17841 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 17842 public TerminalNode WS(int i) { 17843 return getToken(JavadocParser.WS, i); 17844 } 17845 public RbTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 17846 public RbTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 17847 super(parent, invokingState); 17848 this.isNonTight = isNonTight; 17849 } 17850 @Override public int getRuleIndex() { return RULE_rbTagStart; } 17851 } 17852 17853 public final RbTagStartContext rbTagStart(boolean isNonTight) throws RecognitionException { 17854 RbTagStartContext _localctx = new RbTagStartContext(_ctx, getState(), isNonTight); 17855 enterRule(_localctx, 166, RULE_rbTagStart); 17856 int _la; 17857 try { 17858 enterOuterAlt(_localctx, 1); 17859 { 17860 setState(2201); 17861 match(START); 17862 setState(2202); 17863 match(RB_HTML_TAG_NAME); 17864 setState(2209); 17865 _errHandler.sync(this); 17866 _la = _input.LA(1); 17867 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 17868 { 17869 setState(2207); 17870 _errHandler.sync(this); 17871 switch (_input.LA(1)) { 17872 case HTML_TAG_NAME: 17873 { 17874 setState(2203); 17875 attribute(); 17876 } 17877 break; 17878 case NEWLINE: 17879 { 17880 setState(2204); 17881 match(NEWLINE); 17882 } 17883 break; 17884 case LEADING_ASTERISK: 17885 { 17886 setState(2205); 17887 match(LEADING_ASTERISK); 17888 } 17889 break; 17890 case WS: 17891 { 17892 setState(2206); 17893 match(WS); 17894 } 17895 break; 17896 default: 17897 throw new NoViableAltException(this); 17898 } 17899 } 17900 setState(2211); 17901 _errHandler.sync(this); 17902 _la = _input.LA(1); 17903 } 17904 setState(2212); 17905 match(END); 17906 } 17907 _ctx.stop = _input.LT(-1); 17908 17909 if (isNonTight && nonTightTagStartContext == null) { 17910 nonTightTagStartContext = _localctx; 17911 } 17912 17913 } 17914 catch (RecognitionException re) { 17915 _localctx.exception = re; 17916 _errHandler.reportError(this, re); 17917 _errHandler.recover(this, re); 17918 } 17919 finally { 17920 exitRule(); 17921 } 17922 return _localctx; 17923 } 17924 17925 public static class RbTagEndContext extends ParserRuleContext { 17926 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 17927 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 17928 public TerminalNode RB_HTML_TAG_NAME() { return getToken(JavadocParser.RB_HTML_TAG_NAME, 0); } 17929 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 17930 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17931 public TerminalNode NEWLINE(int i) { 17932 return getToken(JavadocParser.NEWLINE, i); 17933 } 17934 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17935 public TerminalNode LEADING_ASTERISK(int i) { 17936 return getToken(JavadocParser.LEADING_ASTERISK, i); 17937 } 17938 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 17939 public TerminalNode WS(int i) { 17940 return getToken(JavadocParser.WS, i); 17941 } 17942 public RbTagEndContext(ParserRuleContext parent, int invokingState) { 17943 super(parent, invokingState); 17944 } 17945 @Override public int getRuleIndex() { return RULE_rbTagEnd; } 17946 } 17947 17948 public final RbTagEndContext rbTagEnd() throws RecognitionException { 17949 RbTagEndContext _localctx = new RbTagEndContext(_ctx, getState()); 17950 enterRule(_localctx, 168, RULE_rbTagEnd); 17951 int _la; 17952 try { 17953 enterOuterAlt(_localctx, 1); 17954 { 17955 setState(2214); 17956 match(START); 17957 setState(2215); 17958 match(SLASH); 17959 setState(2216); 17960 match(RB_HTML_TAG_NAME); 17961 setState(2220); 17962 _errHandler.sync(this); 17963 _la = _input.LA(1); 17964 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 17965 { 17966 { 17967 setState(2217); 17968 _la = _input.LA(1); 17969 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 17970 _errHandler.recoverInline(this); 17971 } 17972 else { 17973 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 17974 _errHandler.reportMatch(this); 17975 consume(); 17976 } 17977 } 17978 } 17979 setState(2222); 17980 _errHandler.sync(this); 17981 _la = _input.LA(1); 17982 } 17983 setState(2223); 17984 match(END); 17985 } 17986 } 17987 catch (RecognitionException re) { 17988 _localctx.exception = re; 17989 _errHandler.reportError(this, re); 17990 _errHandler.recover(this, re); 17991 } 17992 finally { 17993 exitRule(); 17994 } 17995 return _localctx; 17996 } 17997 17998 public static class RbContext extends ParserRuleContext { 17999 public RbTagStartContext rbTagStart() { 18000 return getRuleContext(RbTagStartContext.class,0); 18001 } 18002 public RbTagEndContext rbTagEnd() { 18003 return getRuleContext(RbTagEndContext.class,0); 18004 } 18005 public List<HtmlTagContext> htmlTag() { 18006 return getRuleContexts(HtmlTagContext.class); 18007 } 18008 public HtmlTagContext htmlTag(int i) { 18009 return getRuleContext(HtmlTagContext.class,i); 18010 } 18011 public List<SingletonElementContext> singletonElement() { 18012 return getRuleContexts(SingletonElementContext.class); 18013 } 18014 public SingletonElementContext singletonElement(int i) { 18015 return getRuleContext(SingletonElementContext.class,i); 18016 } 18017 public List<ParagraphContext> paragraph() { 18018 return getRuleContexts(ParagraphContext.class); 18019 } 18020 public ParagraphContext paragraph(int i) { 18021 return getRuleContext(ParagraphContext.class,i); 18022 } 18023 public List<LiContext> li() { 18024 return getRuleContexts(LiContext.class); 18025 } 18026 public LiContext li(int i) { 18027 return getRuleContext(LiContext.class,i); 18028 } 18029 public List<TrContext> tr() { 18030 return getRuleContexts(TrContext.class); 18031 } 18032 public TrContext tr(int i) { 18033 return getRuleContext(TrContext.class,i); 18034 } 18035 public List<TdContext> td() { 18036 return getRuleContexts(TdContext.class); 18037 } 18038 public TdContext td(int i) { 18039 return getRuleContext(TdContext.class,i); 18040 } 18041 public List<ThContext> th() { 18042 return getRuleContexts(ThContext.class); 18043 } 18044 public ThContext th(int i) { 18045 return getRuleContext(ThContext.class,i); 18046 } 18047 public List<BodyContext> body() { 18048 return getRuleContexts(BodyContext.class); 18049 } 18050 public BodyContext body(int i) { 18051 return getRuleContext(BodyContext.class,i); 18052 } 18053 public List<ColgroupContext> colgroup() { 18054 return getRuleContexts(ColgroupContext.class); 18055 } 18056 public ColgroupContext colgroup(int i) { 18057 return getRuleContext(ColgroupContext.class,i); 18058 } 18059 public List<DdContext> dd() { 18060 return getRuleContexts(DdContext.class); 18061 } 18062 public DdContext dd(int i) { 18063 return getRuleContext(DdContext.class,i); 18064 } 18065 public List<DtContext> dt() { 18066 return getRuleContexts(DtContext.class); 18067 } 18068 public DtContext dt(int i) { 18069 return getRuleContext(DtContext.class,i); 18070 } 18071 public List<HeadContext> head() { 18072 return getRuleContexts(HeadContext.class); 18073 } 18074 public HeadContext head(int i) { 18075 return getRuleContext(HeadContext.class,i); 18076 } 18077 public List<HtmlContext> html() { 18078 return getRuleContexts(HtmlContext.class); 18079 } 18080 public HtmlContext html(int i) { 18081 return getRuleContext(HtmlContext.class,i); 18082 } 18083 public List<OptionContext> option() { 18084 return getRuleContexts(OptionContext.class); 18085 } 18086 public OptionContext option(int i) { 18087 return getRuleContext(OptionContext.class,i); 18088 } 18089 public List<TbodyContext> tbody() { 18090 return getRuleContexts(TbodyContext.class); 18091 } 18092 public TbodyContext tbody(int i) { 18093 return getRuleContext(TbodyContext.class,i); 18094 } 18095 public List<TfootContext> tfoot() { 18096 return getRuleContexts(TfootContext.class); 18097 } 18098 public TfootContext tfoot(int i) { 18099 return getRuleContext(TfootContext.class,i); 18100 } 18101 public List<PTagStartContext> pTagStart() { 18102 return getRuleContexts(PTagStartContext.class); 18103 } 18104 public PTagStartContext pTagStart(int i) { 18105 return getRuleContext(PTagStartContext.class,i); 18106 } 18107 public List<LiTagStartContext> liTagStart() { 18108 return getRuleContexts(LiTagStartContext.class); 18109 } 18110 public LiTagStartContext liTagStart(int i) { 18111 return getRuleContext(LiTagStartContext.class,i); 18112 } 18113 public List<TrTagStartContext> trTagStart() { 18114 return getRuleContexts(TrTagStartContext.class); 18115 } 18116 public TrTagStartContext trTagStart(int i) { 18117 return getRuleContext(TrTagStartContext.class,i); 18118 } 18119 public List<TdTagStartContext> tdTagStart() { 18120 return getRuleContexts(TdTagStartContext.class); 18121 } 18122 public TdTagStartContext tdTagStart(int i) { 18123 return getRuleContext(TdTagStartContext.class,i); 18124 } 18125 public List<ThTagStartContext> thTagStart() { 18126 return getRuleContexts(ThTagStartContext.class); 18127 } 18128 public ThTagStartContext thTagStart(int i) { 18129 return getRuleContext(ThTagStartContext.class,i); 18130 } 18131 public List<BodyTagStartContext> bodyTagStart() { 18132 return getRuleContexts(BodyTagStartContext.class); 18133 } 18134 public BodyTagStartContext bodyTagStart(int i) { 18135 return getRuleContext(BodyTagStartContext.class,i); 18136 } 18137 public List<ColgroupTagStartContext> colgroupTagStart() { 18138 return getRuleContexts(ColgroupTagStartContext.class); 18139 } 18140 public ColgroupTagStartContext colgroupTagStart(int i) { 18141 return getRuleContext(ColgroupTagStartContext.class,i); 18142 } 18143 public List<DdTagStartContext> ddTagStart() { 18144 return getRuleContexts(DdTagStartContext.class); 18145 } 18146 public DdTagStartContext ddTagStart(int i) { 18147 return getRuleContext(DdTagStartContext.class,i); 18148 } 18149 public List<DtTagStartContext> dtTagStart() { 18150 return getRuleContexts(DtTagStartContext.class); 18151 } 18152 public DtTagStartContext dtTagStart(int i) { 18153 return getRuleContext(DtTagStartContext.class,i); 18154 } 18155 public List<HeadTagStartContext> headTagStart() { 18156 return getRuleContexts(HeadTagStartContext.class); 18157 } 18158 public HeadTagStartContext headTagStart(int i) { 18159 return getRuleContext(HeadTagStartContext.class,i); 18160 } 18161 public List<HtmlTagStartContext> htmlTagStart() { 18162 return getRuleContexts(HtmlTagStartContext.class); 18163 } 18164 public HtmlTagStartContext htmlTagStart(int i) { 18165 return getRuleContext(HtmlTagStartContext.class,i); 18166 } 18167 public List<OptionTagStartContext> optionTagStart() { 18168 return getRuleContexts(OptionTagStartContext.class); 18169 } 18170 public OptionTagStartContext optionTagStart(int i) { 18171 return getRuleContext(OptionTagStartContext.class,i); 18172 } 18173 public List<TbodyTagStartContext> tbodyTagStart() { 18174 return getRuleContexts(TbodyTagStartContext.class); 18175 } 18176 public TbodyTagStartContext tbodyTagStart(int i) { 18177 return getRuleContext(TbodyTagStartContext.class,i); 18178 } 18179 public List<TfootTagStartContext> tfootTagStart() { 18180 return getRuleContexts(TfootTagStartContext.class); 18181 } 18182 public TfootTagStartContext tfootTagStart(int i) { 18183 return getRuleContext(TfootTagStartContext.class,i); 18184 } 18185 public List<HtmlCommentContext> htmlComment() { 18186 return getRuleContexts(HtmlCommentContext.class); 18187 } 18188 public HtmlCommentContext htmlComment(int i) { 18189 return getRuleContext(HtmlCommentContext.class,i); 18190 } 18191 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 18192 public TerminalNode NEWLINE(int i) { 18193 return getToken(JavadocParser.NEWLINE, i); 18194 } 18195 public List<TextContext> text() { 18196 return getRuleContexts(TextContext.class); 18197 } 18198 public TextContext text(int i) { 18199 return getRuleContext(TextContext.class,i); 18200 } 18201 public List<JavadocInlineTagContext> javadocInlineTag() { 18202 return getRuleContexts(JavadocInlineTagContext.class); 18203 } 18204 public JavadocInlineTagContext javadocInlineTag(int i) { 18205 return getRuleContext(JavadocInlineTagContext.class,i); 18206 } 18207 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 18208 public TerminalNode LEADING_ASTERISK(int i) { 18209 return getToken(JavadocParser.LEADING_ASTERISK, i); 18210 } 18211 public RbContext(ParserRuleContext parent, int invokingState) { 18212 super(parent, invokingState); 18213 } 18214 @Override public int getRuleIndex() { return RULE_rb; } 18215 } 18216 18217 public final RbContext rb() throws RecognitionException { 18218 RbContext _localctx = new RbContext(_ctx, getState()); 18219 enterRule(_localctx, 170, RULE_rb); 18220 try { 18221 int _alt; 18222 enterOuterAlt(_localctx, 1); 18223 { 18224 setState(2225); 18225 rbTagStart(false); 18226 setState(2264); 18227 _errHandler.sync(this); 18228 _alt = getInterpreter().adaptivePredict(_input,201,_ctx); 18229 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 18230 if ( _alt==1 ) { 18231 { 18232 setState(2262); 18233 _errHandler.sync(this); 18234 switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) { 18235 case 1: 18236 { 18237 setState(2226); 18238 htmlTag(); 18239 } 18240 break; 18241 case 2: 18242 { 18243 setState(2227); 18244 singletonElement(); 18245 } 18246 break; 18247 case 3: 18248 { 18249 setState(2228); 18250 paragraph(); 18251 } 18252 break; 18253 case 4: 18254 { 18255 setState(2229); 18256 li(); 18257 } 18258 break; 18259 case 5: 18260 { 18261 setState(2230); 18262 tr(); 18263 } 18264 break; 18265 case 6: 18266 { 18267 setState(2231); 18268 td(); 18269 } 18270 break; 18271 case 7: 18272 { 18273 setState(2232); 18274 th(); 18275 } 18276 break; 18277 case 8: 18278 { 18279 setState(2233); 18280 body(); 18281 } 18282 break; 18283 case 9: 18284 { 18285 setState(2234); 18286 colgroup(); 18287 } 18288 break; 18289 case 10: 18290 { 18291 setState(2235); 18292 dd(); 18293 } 18294 break; 18295 case 11: 18296 { 18297 setState(2236); 18298 dt(); 18299 } 18300 break; 18301 case 12: 18302 { 18303 setState(2237); 18304 head(); 18305 } 18306 break; 18307 case 13: 18308 { 18309 setState(2238); 18310 html(); 18311 } 18312 break; 18313 case 14: 18314 { 18315 setState(2239); 18316 option(); 18317 } 18318 break; 18319 case 15: 18320 { 18321 setState(2240); 18322 tbody(); 18323 } 18324 break; 18325 case 16: 18326 { 18327 setState(2241); 18328 tfoot(); 18329 } 18330 break; 18331 case 17: 18332 { 18333 setState(2242); 18334 pTagStart(true); 18335 } 18336 break; 18337 case 18: 18338 { 18339 setState(2243); 18340 liTagStart(true); 18341 } 18342 break; 18343 case 19: 18344 { 18345 setState(2244); 18346 trTagStart(true); 18347 } 18348 break; 18349 case 20: 18350 { 18351 setState(2245); 18352 tdTagStart(true); 18353 } 18354 break; 18355 case 21: 18356 { 18357 setState(2246); 18358 thTagStart(true); 18359 } 18360 break; 18361 case 22: 18362 { 18363 setState(2247); 18364 bodyTagStart(true); 18365 } 18366 break; 18367 case 23: 18368 { 18369 setState(2248); 18370 colgroupTagStart(true); 18371 } 18372 break; 18373 case 24: 18374 { 18375 setState(2249); 18376 ddTagStart(true); 18377 } 18378 break; 18379 case 25: 18380 { 18381 setState(2250); 18382 dtTagStart(true); 18383 } 18384 break; 18385 case 26: 18386 { 18387 setState(2251); 18388 headTagStart(true); 18389 } 18390 break; 18391 case 27: 18392 { 18393 setState(2252); 18394 htmlTagStart(true); 18395 } 18396 break; 18397 case 28: 18398 { 18399 setState(2253); 18400 optionTagStart(true); 18401 } 18402 break; 18403 case 29: 18404 { 18405 setState(2254); 18406 tbodyTagStart(true); 18407 } 18408 break; 18409 case 30: 18410 { 18411 setState(2255); 18412 tfootTagStart(true); 18413 } 18414 break; 18415 case 31: 18416 { 18417 { 18418 setState(2256); 18419 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 18420 setState(2257); 18421 match(LEADING_ASTERISK); 18422 } 18423 } 18424 break; 18425 case 32: 18426 { 18427 setState(2258); 18428 htmlComment(); 18429 } 18430 break; 18431 case 33: 18432 { 18433 setState(2259); 18434 match(NEWLINE); 18435 } 18436 break; 18437 case 34: 18438 { 18439 setState(2260); 18440 text(); 18441 } 18442 break; 18443 case 35: 18444 { 18445 setState(2261); 18446 javadocInlineTag(); 18447 } 18448 break; 18449 } 18450 } 18451 } 18452 setState(2266); 18453 _errHandler.sync(this); 18454 _alt = getInterpreter().adaptivePredict(_input,201,_ctx); 18455 } 18456 setState(2267); 18457 rbTagEnd(); 18458 } 18459 } 18460 catch (RecognitionException re) { 18461 _localctx.exception = re; 18462 _errHandler.reportError(this, re); 18463 _errHandler.recover(this, re); 18464 } 18465 finally { 18466 exitRule(); 18467 } 18468 return _localctx; 18469 } 18470 18471 public static class RtTagStartContext extends ParserRuleContext { 18472 public boolean isNonTight; 18473 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 18474 public TerminalNode RT_HTML_TAG_NAME() { return getToken(JavadocParser.RT_HTML_TAG_NAME, 0); } 18475 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 18476 public List<AttributeContext> attribute() { 18477 return getRuleContexts(AttributeContext.class); 18478 } 18479 public AttributeContext attribute(int i) { 18480 return getRuleContext(AttributeContext.class,i); 18481 } 18482 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 18483 public TerminalNode NEWLINE(int i) { 18484 return getToken(JavadocParser.NEWLINE, i); 18485 } 18486 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 18487 public TerminalNode LEADING_ASTERISK(int i) { 18488 return getToken(JavadocParser.LEADING_ASTERISK, i); 18489 } 18490 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 18491 public TerminalNode WS(int i) { 18492 return getToken(JavadocParser.WS, i); 18493 } 18494 public RtTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 18495 public RtTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 18496 super(parent, invokingState); 18497 this.isNonTight = isNonTight; 18498 } 18499 @Override public int getRuleIndex() { return RULE_rtTagStart; } 18500 } 18501 18502 public final RtTagStartContext rtTagStart(boolean isNonTight) throws RecognitionException { 18503 RtTagStartContext _localctx = new RtTagStartContext(_ctx, getState(), isNonTight); 18504 enterRule(_localctx, 172, RULE_rtTagStart); 18505 int _la; 18506 try { 18507 enterOuterAlt(_localctx, 1); 18508 { 18509 setState(2269); 18510 match(START); 18511 setState(2270); 18512 match(RT_HTML_TAG_NAME); 18513 setState(2277); 18514 _errHandler.sync(this); 18515 _la = _input.LA(1); 18516 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 18517 { 18518 setState(2275); 18519 _errHandler.sync(this); 18520 switch (_input.LA(1)) { 18521 case HTML_TAG_NAME: 18522 { 18523 setState(2271); 18524 attribute(); 18525 } 18526 break; 18527 case NEWLINE: 18528 { 18529 setState(2272); 18530 match(NEWLINE); 18531 } 18532 break; 18533 case LEADING_ASTERISK: 18534 { 18535 setState(2273); 18536 match(LEADING_ASTERISK); 18537 } 18538 break; 18539 case WS: 18540 { 18541 setState(2274); 18542 match(WS); 18543 } 18544 break; 18545 default: 18546 throw new NoViableAltException(this); 18547 } 18548 } 18549 setState(2279); 18550 _errHandler.sync(this); 18551 _la = _input.LA(1); 18552 } 18553 setState(2280); 18554 match(END); 18555 } 18556 _ctx.stop = _input.LT(-1); 18557 18558 if (isNonTight && nonTightTagStartContext == null) { 18559 nonTightTagStartContext = _localctx; 18560 } 18561 18562 } 18563 catch (RecognitionException re) { 18564 _localctx.exception = re; 18565 _errHandler.reportError(this, re); 18566 _errHandler.recover(this, re); 18567 } 18568 finally { 18569 exitRule(); 18570 } 18571 return _localctx; 18572 } 18573 18574 public static class RtTagEndContext extends ParserRuleContext { 18575 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 18576 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 18577 public TerminalNode RT_HTML_TAG_NAME() { return getToken(JavadocParser.RT_HTML_TAG_NAME, 0); } 18578 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 18579 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 18580 public TerminalNode NEWLINE(int i) { 18581 return getToken(JavadocParser.NEWLINE, i); 18582 } 18583 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 18584 public TerminalNode LEADING_ASTERISK(int i) { 18585 return getToken(JavadocParser.LEADING_ASTERISK, i); 18586 } 18587 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 18588 public TerminalNode WS(int i) { 18589 return getToken(JavadocParser.WS, i); 18590 } 18591 public RtTagEndContext(ParserRuleContext parent, int invokingState) { 18592 super(parent, invokingState); 18593 } 18594 @Override public int getRuleIndex() { return RULE_rtTagEnd; } 18595 } 18596 18597 public final RtTagEndContext rtTagEnd() throws RecognitionException { 18598 RtTagEndContext _localctx = new RtTagEndContext(_ctx, getState()); 18599 enterRule(_localctx, 174, RULE_rtTagEnd); 18600 int _la; 18601 try { 18602 enterOuterAlt(_localctx, 1); 18603 { 18604 setState(2282); 18605 match(START); 18606 setState(2283); 18607 match(SLASH); 18608 setState(2284); 18609 match(RT_HTML_TAG_NAME); 18610 setState(2288); 18611 _errHandler.sync(this); 18612 _la = _input.LA(1); 18613 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 18614 { 18615 { 18616 setState(2285); 18617 _la = _input.LA(1); 18618 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 18619 _errHandler.recoverInline(this); 18620 } 18621 else { 18622 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 18623 _errHandler.reportMatch(this); 18624 consume(); 18625 } 18626 } 18627 } 18628 setState(2290); 18629 _errHandler.sync(this); 18630 _la = _input.LA(1); 18631 } 18632 setState(2291); 18633 match(END); 18634 } 18635 } 18636 catch (RecognitionException re) { 18637 _localctx.exception = re; 18638 _errHandler.reportError(this, re); 18639 _errHandler.recover(this, re); 18640 } 18641 finally { 18642 exitRule(); 18643 } 18644 return _localctx; 18645 } 18646 18647 public static class RtContext extends ParserRuleContext { 18648 public RtTagStartContext rtTagStart() { 18649 return getRuleContext(RtTagStartContext.class,0); 18650 } 18651 public RtTagEndContext rtTagEnd() { 18652 return getRuleContext(RtTagEndContext.class,0); 18653 } 18654 public List<HtmlTagContext> htmlTag() { 18655 return getRuleContexts(HtmlTagContext.class); 18656 } 18657 public HtmlTagContext htmlTag(int i) { 18658 return getRuleContext(HtmlTagContext.class,i); 18659 } 18660 public List<SingletonElementContext> singletonElement() { 18661 return getRuleContexts(SingletonElementContext.class); 18662 } 18663 public SingletonElementContext singletonElement(int i) { 18664 return getRuleContext(SingletonElementContext.class,i); 18665 } 18666 public List<ParagraphContext> paragraph() { 18667 return getRuleContexts(ParagraphContext.class); 18668 } 18669 public ParagraphContext paragraph(int i) { 18670 return getRuleContext(ParagraphContext.class,i); 18671 } 18672 public List<LiContext> li() { 18673 return getRuleContexts(LiContext.class); 18674 } 18675 public LiContext li(int i) { 18676 return getRuleContext(LiContext.class,i); 18677 } 18678 public List<TrContext> tr() { 18679 return getRuleContexts(TrContext.class); 18680 } 18681 public TrContext tr(int i) { 18682 return getRuleContext(TrContext.class,i); 18683 } 18684 public List<TdContext> td() { 18685 return getRuleContexts(TdContext.class); 18686 } 18687 public TdContext td(int i) { 18688 return getRuleContext(TdContext.class,i); 18689 } 18690 public List<ThContext> th() { 18691 return getRuleContexts(ThContext.class); 18692 } 18693 public ThContext th(int i) { 18694 return getRuleContext(ThContext.class,i); 18695 } 18696 public List<BodyContext> body() { 18697 return getRuleContexts(BodyContext.class); 18698 } 18699 public BodyContext body(int i) { 18700 return getRuleContext(BodyContext.class,i); 18701 } 18702 public List<ColgroupContext> colgroup() { 18703 return getRuleContexts(ColgroupContext.class); 18704 } 18705 public ColgroupContext colgroup(int i) { 18706 return getRuleContext(ColgroupContext.class,i); 18707 } 18708 public List<DdContext> dd() { 18709 return getRuleContexts(DdContext.class); 18710 } 18711 public DdContext dd(int i) { 18712 return getRuleContext(DdContext.class,i); 18713 } 18714 public List<DtContext> dt() { 18715 return getRuleContexts(DtContext.class); 18716 } 18717 public DtContext dt(int i) { 18718 return getRuleContext(DtContext.class,i); 18719 } 18720 public List<HeadContext> head() { 18721 return getRuleContexts(HeadContext.class); 18722 } 18723 public HeadContext head(int i) { 18724 return getRuleContext(HeadContext.class,i); 18725 } 18726 public List<HtmlContext> html() { 18727 return getRuleContexts(HtmlContext.class); 18728 } 18729 public HtmlContext html(int i) { 18730 return getRuleContext(HtmlContext.class,i); 18731 } 18732 public List<OptionContext> option() { 18733 return getRuleContexts(OptionContext.class); 18734 } 18735 public OptionContext option(int i) { 18736 return getRuleContext(OptionContext.class,i); 18737 } 18738 public List<TbodyContext> tbody() { 18739 return getRuleContexts(TbodyContext.class); 18740 } 18741 public TbodyContext tbody(int i) { 18742 return getRuleContext(TbodyContext.class,i); 18743 } 18744 public List<TfootContext> tfoot() { 18745 return getRuleContexts(TfootContext.class); 18746 } 18747 public TfootContext tfoot(int i) { 18748 return getRuleContext(TfootContext.class,i); 18749 } 18750 public List<PTagStartContext> pTagStart() { 18751 return getRuleContexts(PTagStartContext.class); 18752 } 18753 public PTagStartContext pTagStart(int i) { 18754 return getRuleContext(PTagStartContext.class,i); 18755 } 18756 public List<LiTagStartContext> liTagStart() { 18757 return getRuleContexts(LiTagStartContext.class); 18758 } 18759 public LiTagStartContext liTagStart(int i) { 18760 return getRuleContext(LiTagStartContext.class,i); 18761 } 18762 public List<TrTagStartContext> trTagStart() { 18763 return getRuleContexts(TrTagStartContext.class); 18764 } 18765 public TrTagStartContext trTagStart(int i) { 18766 return getRuleContext(TrTagStartContext.class,i); 18767 } 18768 public List<TdTagStartContext> tdTagStart() { 18769 return getRuleContexts(TdTagStartContext.class); 18770 } 18771 public TdTagStartContext tdTagStart(int i) { 18772 return getRuleContext(TdTagStartContext.class,i); 18773 } 18774 public List<ThTagStartContext> thTagStart() { 18775 return getRuleContexts(ThTagStartContext.class); 18776 } 18777 public ThTagStartContext thTagStart(int i) { 18778 return getRuleContext(ThTagStartContext.class,i); 18779 } 18780 public List<BodyTagStartContext> bodyTagStart() { 18781 return getRuleContexts(BodyTagStartContext.class); 18782 } 18783 public BodyTagStartContext bodyTagStart(int i) { 18784 return getRuleContext(BodyTagStartContext.class,i); 18785 } 18786 public List<ColgroupTagStartContext> colgroupTagStart() { 18787 return getRuleContexts(ColgroupTagStartContext.class); 18788 } 18789 public ColgroupTagStartContext colgroupTagStart(int i) { 18790 return getRuleContext(ColgroupTagStartContext.class,i); 18791 } 18792 public List<DdTagStartContext> ddTagStart() { 18793 return getRuleContexts(DdTagStartContext.class); 18794 } 18795 public DdTagStartContext ddTagStart(int i) { 18796 return getRuleContext(DdTagStartContext.class,i); 18797 } 18798 public List<DtTagStartContext> dtTagStart() { 18799 return getRuleContexts(DtTagStartContext.class); 18800 } 18801 public DtTagStartContext dtTagStart(int i) { 18802 return getRuleContext(DtTagStartContext.class,i); 18803 } 18804 public List<HeadTagStartContext> headTagStart() { 18805 return getRuleContexts(HeadTagStartContext.class); 18806 } 18807 public HeadTagStartContext headTagStart(int i) { 18808 return getRuleContext(HeadTagStartContext.class,i); 18809 } 18810 public List<HtmlTagStartContext> htmlTagStart() { 18811 return getRuleContexts(HtmlTagStartContext.class); 18812 } 18813 public HtmlTagStartContext htmlTagStart(int i) { 18814 return getRuleContext(HtmlTagStartContext.class,i); 18815 } 18816 public List<OptionTagStartContext> optionTagStart() { 18817 return getRuleContexts(OptionTagStartContext.class); 18818 } 18819 public OptionTagStartContext optionTagStart(int i) { 18820 return getRuleContext(OptionTagStartContext.class,i); 18821 } 18822 public List<TbodyTagStartContext> tbodyTagStart() { 18823 return getRuleContexts(TbodyTagStartContext.class); 18824 } 18825 public TbodyTagStartContext tbodyTagStart(int i) { 18826 return getRuleContext(TbodyTagStartContext.class,i); 18827 } 18828 public List<TfootTagStartContext> tfootTagStart() { 18829 return getRuleContexts(TfootTagStartContext.class); 18830 } 18831 public TfootTagStartContext tfootTagStart(int i) { 18832 return getRuleContext(TfootTagStartContext.class,i); 18833 } 18834 public List<HtmlCommentContext> htmlComment() { 18835 return getRuleContexts(HtmlCommentContext.class); 18836 } 18837 public HtmlCommentContext htmlComment(int i) { 18838 return getRuleContext(HtmlCommentContext.class,i); 18839 } 18840 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 18841 public TerminalNode NEWLINE(int i) { 18842 return getToken(JavadocParser.NEWLINE, i); 18843 } 18844 public List<TextContext> text() { 18845 return getRuleContexts(TextContext.class); 18846 } 18847 public TextContext text(int i) { 18848 return getRuleContext(TextContext.class,i); 18849 } 18850 public List<JavadocInlineTagContext> javadocInlineTag() { 18851 return getRuleContexts(JavadocInlineTagContext.class); 18852 } 18853 public JavadocInlineTagContext javadocInlineTag(int i) { 18854 return getRuleContext(JavadocInlineTagContext.class,i); 18855 } 18856 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 18857 public TerminalNode LEADING_ASTERISK(int i) { 18858 return getToken(JavadocParser.LEADING_ASTERISK, i); 18859 } 18860 public RtContext(ParserRuleContext parent, int invokingState) { 18861 super(parent, invokingState); 18862 } 18863 @Override public int getRuleIndex() { return RULE_rt; } 18864 } 18865 18866 public final RtContext rt() throws RecognitionException { 18867 RtContext _localctx = new RtContext(_ctx, getState()); 18868 enterRule(_localctx, 176, RULE_rt); 18869 try { 18870 int _alt; 18871 enterOuterAlt(_localctx, 1); 18872 { 18873 setState(2293); 18874 rtTagStart(false); 18875 setState(2332); 18876 _errHandler.sync(this); 18877 _alt = getInterpreter().adaptivePredict(_input,206,_ctx); 18878 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 18879 if ( _alt==1 ) { 18880 { 18881 setState(2330); 18882 _errHandler.sync(this); 18883 switch ( getInterpreter().adaptivePredict(_input,205,_ctx) ) { 18884 case 1: 18885 { 18886 setState(2294); 18887 htmlTag(); 18888 } 18889 break; 18890 case 2: 18891 { 18892 setState(2295); 18893 singletonElement(); 18894 } 18895 break; 18896 case 3: 18897 { 18898 setState(2296); 18899 paragraph(); 18900 } 18901 break; 18902 case 4: 18903 { 18904 setState(2297); 18905 li(); 18906 } 18907 break; 18908 case 5: 18909 { 18910 setState(2298); 18911 tr(); 18912 } 18913 break; 18914 case 6: 18915 { 18916 setState(2299); 18917 td(); 18918 } 18919 break; 18920 case 7: 18921 { 18922 setState(2300); 18923 th(); 18924 } 18925 break; 18926 case 8: 18927 { 18928 setState(2301); 18929 body(); 18930 } 18931 break; 18932 case 9: 18933 { 18934 setState(2302); 18935 colgroup(); 18936 } 18937 break; 18938 case 10: 18939 { 18940 setState(2303); 18941 dd(); 18942 } 18943 break; 18944 case 11: 18945 { 18946 setState(2304); 18947 dt(); 18948 } 18949 break; 18950 case 12: 18951 { 18952 setState(2305); 18953 head(); 18954 } 18955 break; 18956 case 13: 18957 { 18958 setState(2306); 18959 html(); 18960 } 18961 break; 18962 case 14: 18963 { 18964 setState(2307); 18965 option(); 18966 } 18967 break; 18968 case 15: 18969 { 18970 setState(2308); 18971 tbody(); 18972 } 18973 break; 18974 case 16: 18975 { 18976 setState(2309); 18977 tfoot(); 18978 } 18979 break; 18980 case 17: 18981 { 18982 setState(2310); 18983 pTagStart(true); 18984 } 18985 break; 18986 case 18: 18987 { 18988 setState(2311); 18989 liTagStart(true); 18990 } 18991 break; 18992 case 19: 18993 { 18994 setState(2312); 18995 trTagStart(true); 18996 } 18997 break; 18998 case 20: 18999 { 19000 setState(2313); 19001 tdTagStart(true); 19002 } 19003 break; 19004 case 21: 19005 { 19006 setState(2314); 19007 thTagStart(true); 19008 } 19009 break; 19010 case 22: 19011 { 19012 setState(2315); 19013 bodyTagStart(true); 19014 } 19015 break; 19016 case 23: 19017 { 19018 setState(2316); 19019 colgroupTagStart(true); 19020 } 19021 break; 19022 case 24: 19023 { 19024 setState(2317); 19025 ddTagStart(true); 19026 } 19027 break; 19028 case 25: 19029 { 19030 setState(2318); 19031 dtTagStart(true); 19032 } 19033 break; 19034 case 26: 19035 { 19036 setState(2319); 19037 headTagStart(true); 19038 } 19039 break; 19040 case 27: 19041 { 19042 setState(2320); 19043 htmlTagStart(true); 19044 } 19045 break; 19046 case 28: 19047 { 19048 setState(2321); 19049 optionTagStart(true); 19050 } 19051 break; 19052 case 29: 19053 { 19054 setState(2322); 19055 tbodyTagStart(true); 19056 } 19057 break; 19058 case 30: 19059 { 19060 setState(2323); 19061 tfootTagStart(true); 19062 } 19063 break; 19064 case 31: 19065 { 19066 { 19067 setState(2324); 19068 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 19069 setState(2325); 19070 match(LEADING_ASTERISK); 19071 } 19072 } 19073 break; 19074 case 32: 19075 { 19076 setState(2326); 19077 htmlComment(); 19078 } 19079 break; 19080 case 33: 19081 { 19082 setState(2327); 19083 match(NEWLINE); 19084 } 19085 break; 19086 case 34: 19087 { 19088 setState(2328); 19089 text(); 19090 } 19091 break; 19092 case 35: 19093 { 19094 setState(2329); 19095 javadocInlineTag(); 19096 } 19097 break; 19098 } 19099 } 19100 } 19101 setState(2334); 19102 _errHandler.sync(this); 19103 _alt = getInterpreter().adaptivePredict(_input,206,_ctx); 19104 } 19105 setState(2335); 19106 rtTagEnd(); 19107 } 19108 } 19109 catch (RecognitionException re) { 19110 _localctx.exception = re; 19111 _errHandler.reportError(this, re); 19112 _errHandler.recover(this, re); 19113 } 19114 finally { 19115 exitRule(); 19116 } 19117 return _localctx; 19118 } 19119 19120 public static class RtcTagStartContext extends ParserRuleContext { 19121 public boolean isNonTight; 19122 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 19123 public TerminalNode RTC_HTML_TAG_NAME() { return getToken(JavadocParser.RTC_HTML_TAG_NAME, 0); } 19124 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 19125 public List<AttributeContext> attribute() { 19126 return getRuleContexts(AttributeContext.class); 19127 } 19128 public AttributeContext attribute(int i) { 19129 return getRuleContext(AttributeContext.class,i); 19130 } 19131 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 19132 public TerminalNode NEWLINE(int i) { 19133 return getToken(JavadocParser.NEWLINE, i); 19134 } 19135 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 19136 public TerminalNode LEADING_ASTERISK(int i) { 19137 return getToken(JavadocParser.LEADING_ASTERISK, i); 19138 } 19139 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 19140 public TerminalNode WS(int i) { 19141 return getToken(JavadocParser.WS, i); 19142 } 19143 public RtcTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 19144 public RtcTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 19145 super(parent, invokingState); 19146 this.isNonTight = isNonTight; 19147 } 19148 @Override public int getRuleIndex() { return RULE_rtcTagStart; } 19149 } 19150 19151 public final RtcTagStartContext rtcTagStart(boolean isNonTight) throws RecognitionException { 19152 RtcTagStartContext _localctx = new RtcTagStartContext(_ctx, getState(), isNonTight); 19153 enterRule(_localctx, 178, RULE_rtcTagStart); 19154 int _la; 19155 try { 19156 enterOuterAlt(_localctx, 1); 19157 { 19158 setState(2337); 19159 match(START); 19160 setState(2338); 19161 match(RTC_HTML_TAG_NAME); 19162 setState(2345); 19163 _errHandler.sync(this); 19164 _la = _input.LA(1); 19165 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 19166 { 19167 setState(2343); 19168 _errHandler.sync(this); 19169 switch (_input.LA(1)) { 19170 case HTML_TAG_NAME: 19171 { 19172 setState(2339); 19173 attribute(); 19174 } 19175 break; 19176 case NEWLINE: 19177 { 19178 setState(2340); 19179 match(NEWLINE); 19180 } 19181 break; 19182 case LEADING_ASTERISK: 19183 { 19184 setState(2341); 19185 match(LEADING_ASTERISK); 19186 } 19187 break; 19188 case WS: 19189 { 19190 setState(2342); 19191 match(WS); 19192 } 19193 break; 19194 default: 19195 throw new NoViableAltException(this); 19196 } 19197 } 19198 setState(2347); 19199 _errHandler.sync(this); 19200 _la = _input.LA(1); 19201 } 19202 setState(2348); 19203 match(END); 19204 } 19205 _ctx.stop = _input.LT(-1); 19206 19207 if (isNonTight && nonTightTagStartContext == null) { 19208 nonTightTagStartContext = _localctx; 19209 } 19210 19211 } 19212 catch (RecognitionException re) { 19213 _localctx.exception = re; 19214 _errHandler.reportError(this, re); 19215 _errHandler.recover(this, re); 19216 } 19217 finally { 19218 exitRule(); 19219 } 19220 return _localctx; 19221 } 19222 19223 public static class RtcTagEndContext extends ParserRuleContext { 19224 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 19225 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 19226 public TerminalNode RTC_HTML_TAG_NAME() { return getToken(JavadocParser.RTC_HTML_TAG_NAME, 0); } 19227 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 19228 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 19229 public TerminalNode NEWLINE(int i) { 19230 return getToken(JavadocParser.NEWLINE, i); 19231 } 19232 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 19233 public TerminalNode LEADING_ASTERISK(int i) { 19234 return getToken(JavadocParser.LEADING_ASTERISK, i); 19235 } 19236 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 19237 public TerminalNode WS(int i) { 19238 return getToken(JavadocParser.WS, i); 19239 } 19240 public RtcTagEndContext(ParserRuleContext parent, int invokingState) { 19241 super(parent, invokingState); 19242 } 19243 @Override public int getRuleIndex() { return RULE_rtcTagEnd; } 19244 } 19245 19246 public final RtcTagEndContext rtcTagEnd() throws RecognitionException { 19247 RtcTagEndContext _localctx = new RtcTagEndContext(_ctx, getState()); 19248 enterRule(_localctx, 180, RULE_rtcTagEnd); 19249 int _la; 19250 try { 19251 enterOuterAlt(_localctx, 1); 19252 { 19253 setState(2350); 19254 match(START); 19255 setState(2351); 19256 match(SLASH); 19257 setState(2352); 19258 match(RTC_HTML_TAG_NAME); 19259 setState(2356); 19260 _errHandler.sync(this); 19261 _la = _input.LA(1); 19262 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 19263 { 19264 { 19265 setState(2353); 19266 _la = _input.LA(1); 19267 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 19268 _errHandler.recoverInline(this); 19269 } 19270 else { 19271 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 19272 _errHandler.reportMatch(this); 19273 consume(); 19274 } 19275 } 19276 } 19277 setState(2358); 19278 _errHandler.sync(this); 19279 _la = _input.LA(1); 19280 } 19281 setState(2359); 19282 match(END); 19283 } 19284 } 19285 catch (RecognitionException re) { 19286 _localctx.exception = re; 19287 _errHandler.reportError(this, re); 19288 _errHandler.recover(this, re); 19289 } 19290 finally { 19291 exitRule(); 19292 } 19293 return _localctx; 19294 } 19295 19296 public static class RtcContext extends ParserRuleContext { 19297 public RtcTagStartContext rtcTagStart() { 19298 return getRuleContext(RtcTagStartContext.class,0); 19299 } 19300 public RtcTagEndContext rtcTagEnd() { 19301 return getRuleContext(RtcTagEndContext.class,0); 19302 } 19303 public List<HtmlTagContext> htmlTag() { 19304 return getRuleContexts(HtmlTagContext.class); 19305 } 19306 public HtmlTagContext htmlTag(int i) { 19307 return getRuleContext(HtmlTagContext.class,i); 19308 } 19309 public List<SingletonElementContext> singletonElement() { 19310 return getRuleContexts(SingletonElementContext.class); 19311 } 19312 public SingletonElementContext singletonElement(int i) { 19313 return getRuleContext(SingletonElementContext.class,i); 19314 } 19315 public List<ParagraphContext> paragraph() { 19316 return getRuleContexts(ParagraphContext.class); 19317 } 19318 public ParagraphContext paragraph(int i) { 19319 return getRuleContext(ParagraphContext.class,i); 19320 } 19321 public List<LiContext> li() { 19322 return getRuleContexts(LiContext.class); 19323 } 19324 public LiContext li(int i) { 19325 return getRuleContext(LiContext.class,i); 19326 } 19327 public List<TrContext> tr() { 19328 return getRuleContexts(TrContext.class); 19329 } 19330 public TrContext tr(int i) { 19331 return getRuleContext(TrContext.class,i); 19332 } 19333 public List<TdContext> td() { 19334 return getRuleContexts(TdContext.class); 19335 } 19336 public TdContext td(int i) { 19337 return getRuleContext(TdContext.class,i); 19338 } 19339 public List<ThContext> th() { 19340 return getRuleContexts(ThContext.class); 19341 } 19342 public ThContext th(int i) { 19343 return getRuleContext(ThContext.class,i); 19344 } 19345 public List<BodyContext> body() { 19346 return getRuleContexts(BodyContext.class); 19347 } 19348 public BodyContext body(int i) { 19349 return getRuleContext(BodyContext.class,i); 19350 } 19351 public List<ColgroupContext> colgroup() { 19352 return getRuleContexts(ColgroupContext.class); 19353 } 19354 public ColgroupContext colgroup(int i) { 19355 return getRuleContext(ColgroupContext.class,i); 19356 } 19357 public List<DdContext> dd() { 19358 return getRuleContexts(DdContext.class); 19359 } 19360 public DdContext dd(int i) { 19361 return getRuleContext(DdContext.class,i); 19362 } 19363 public List<DtContext> dt() { 19364 return getRuleContexts(DtContext.class); 19365 } 19366 public DtContext dt(int i) { 19367 return getRuleContext(DtContext.class,i); 19368 } 19369 public List<HeadContext> head() { 19370 return getRuleContexts(HeadContext.class); 19371 } 19372 public HeadContext head(int i) { 19373 return getRuleContext(HeadContext.class,i); 19374 } 19375 public List<HtmlContext> html() { 19376 return getRuleContexts(HtmlContext.class); 19377 } 19378 public HtmlContext html(int i) { 19379 return getRuleContext(HtmlContext.class,i); 19380 } 19381 public List<OptionContext> option() { 19382 return getRuleContexts(OptionContext.class); 19383 } 19384 public OptionContext option(int i) { 19385 return getRuleContext(OptionContext.class,i); 19386 } 19387 public List<TbodyContext> tbody() { 19388 return getRuleContexts(TbodyContext.class); 19389 } 19390 public TbodyContext tbody(int i) { 19391 return getRuleContext(TbodyContext.class,i); 19392 } 19393 public List<TfootContext> tfoot() { 19394 return getRuleContexts(TfootContext.class); 19395 } 19396 public TfootContext tfoot(int i) { 19397 return getRuleContext(TfootContext.class,i); 19398 } 19399 public List<PTagStartContext> pTagStart() { 19400 return getRuleContexts(PTagStartContext.class); 19401 } 19402 public PTagStartContext pTagStart(int i) { 19403 return getRuleContext(PTagStartContext.class,i); 19404 } 19405 public List<LiTagStartContext> liTagStart() { 19406 return getRuleContexts(LiTagStartContext.class); 19407 } 19408 public LiTagStartContext liTagStart(int i) { 19409 return getRuleContext(LiTagStartContext.class,i); 19410 } 19411 public List<TrTagStartContext> trTagStart() { 19412 return getRuleContexts(TrTagStartContext.class); 19413 } 19414 public TrTagStartContext trTagStart(int i) { 19415 return getRuleContext(TrTagStartContext.class,i); 19416 } 19417 public List<TdTagStartContext> tdTagStart() { 19418 return getRuleContexts(TdTagStartContext.class); 19419 } 19420 public TdTagStartContext tdTagStart(int i) { 19421 return getRuleContext(TdTagStartContext.class,i); 19422 } 19423 public List<ThTagStartContext> thTagStart() { 19424 return getRuleContexts(ThTagStartContext.class); 19425 } 19426 public ThTagStartContext thTagStart(int i) { 19427 return getRuleContext(ThTagStartContext.class,i); 19428 } 19429 public List<BodyTagStartContext> bodyTagStart() { 19430 return getRuleContexts(BodyTagStartContext.class); 19431 } 19432 public BodyTagStartContext bodyTagStart(int i) { 19433 return getRuleContext(BodyTagStartContext.class,i); 19434 } 19435 public List<ColgroupTagStartContext> colgroupTagStart() { 19436 return getRuleContexts(ColgroupTagStartContext.class); 19437 } 19438 public ColgroupTagStartContext colgroupTagStart(int i) { 19439 return getRuleContext(ColgroupTagStartContext.class,i); 19440 } 19441 public List<DdTagStartContext> ddTagStart() { 19442 return getRuleContexts(DdTagStartContext.class); 19443 } 19444 public DdTagStartContext ddTagStart(int i) { 19445 return getRuleContext(DdTagStartContext.class,i); 19446 } 19447 public List<DtTagStartContext> dtTagStart() { 19448 return getRuleContexts(DtTagStartContext.class); 19449 } 19450 public DtTagStartContext dtTagStart(int i) { 19451 return getRuleContext(DtTagStartContext.class,i); 19452 } 19453 public List<HeadTagStartContext> headTagStart() { 19454 return getRuleContexts(HeadTagStartContext.class); 19455 } 19456 public HeadTagStartContext headTagStart(int i) { 19457 return getRuleContext(HeadTagStartContext.class,i); 19458 } 19459 public List<HtmlTagStartContext> htmlTagStart() { 19460 return getRuleContexts(HtmlTagStartContext.class); 19461 } 19462 public HtmlTagStartContext htmlTagStart(int i) { 19463 return getRuleContext(HtmlTagStartContext.class,i); 19464 } 19465 public List<OptionTagStartContext> optionTagStart() { 19466 return getRuleContexts(OptionTagStartContext.class); 19467 } 19468 public OptionTagStartContext optionTagStart(int i) { 19469 return getRuleContext(OptionTagStartContext.class,i); 19470 } 19471 public List<TbodyTagStartContext> tbodyTagStart() { 19472 return getRuleContexts(TbodyTagStartContext.class); 19473 } 19474 public TbodyTagStartContext tbodyTagStart(int i) { 19475 return getRuleContext(TbodyTagStartContext.class,i); 19476 } 19477 public List<TfootTagStartContext> tfootTagStart() { 19478 return getRuleContexts(TfootTagStartContext.class); 19479 } 19480 public TfootTagStartContext tfootTagStart(int i) { 19481 return getRuleContext(TfootTagStartContext.class,i); 19482 } 19483 public List<HtmlCommentContext> htmlComment() { 19484 return getRuleContexts(HtmlCommentContext.class); 19485 } 19486 public HtmlCommentContext htmlComment(int i) { 19487 return getRuleContext(HtmlCommentContext.class,i); 19488 } 19489 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 19490 public TerminalNode NEWLINE(int i) { 19491 return getToken(JavadocParser.NEWLINE, i); 19492 } 19493 public List<TextContext> text() { 19494 return getRuleContexts(TextContext.class); 19495 } 19496 public TextContext text(int i) { 19497 return getRuleContext(TextContext.class,i); 19498 } 19499 public List<JavadocInlineTagContext> javadocInlineTag() { 19500 return getRuleContexts(JavadocInlineTagContext.class); 19501 } 19502 public JavadocInlineTagContext javadocInlineTag(int i) { 19503 return getRuleContext(JavadocInlineTagContext.class,i); 19504 } 19505 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 19506 public TerminalNode LEADING_ASTERISK(int i) { 19507 return getToken(JavadocParser.LEADING_ASTERISK, i); 19508 } 19509 public RtcContext(ParserRuleContext parent, int invokingState) { 19510 super(parent, invokingState); 19511 } 19512 @Override public int getRuleIndex() { return RULE_rtc; } 19513 } 19514 19515 public final RtcContext rtc() throws RecognitionException { 19516 RtcContext _localctx = new RtcContext(_ctx, getState()); 19517 enterRule(_localctx, 182, RULE_rtc); 19518 try { 19519 int _alt; 19520 enterOuterAlt(_localctx, 1); 19521 { 19522 setState(2361); 19523 rtcTagStart(false); 19524 setState(2400); 19525 _errHandler.sync(this); 19526 _alt = getInterpreter().adaptivePredict(_input,211,_ctx); 19527 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 19528 if ( _alt==1 ) { 19529 { 19530 setState(2398); 19531 _errHandler.sync(this); 19532 switch ( getInterpreter().adaptivePredict(_input,210,_ctx) ) { 19533 case 1: 19534 { 19535 setState(2362); 19536 htmlTag(); 19537 } 19538 break; 19539 case 2: 19540 { 19541 setState(2363); 19542 singletonElement(); 19543 } 19544 break; 19545 case 3: 19546 { 19547 setState(2364); 19548 paragraph(); 19549 } 19550 break; 19551 case 4: 19552 { 19553 setState(2365); 19554 li(); 19555 } 19556 break; 19557 case 5: 19558 { 19559 setState(2366); 19560 tr(); 19561 } 19562 break; 19563 case 6: 19564 { 19565 setState(2367); 19566 td(); 19567 } 19568 break; 19569 case 7: 19570 { 19571 setState(2368); 19572 th(); 19573 } 19574 break; 19575 case 8: 19576 { 19577 setState(2369); 19578 body(); 19579 } 19580 break; 19581 case 9: 19582 { 19583 setState(2370); 19584 colgroup(); 19585 } 19586 break; 19587 case 10: 19588 { 19589 setState(2371); 19590 dd(); 19591 } 19592 break; 19593 case 11: 19594 { 19595 setState(2372); 19596 dt(); 19597 } 19598 break; 19599 case 12: 19600 { 19601 setState(2373); 19602 head(); 19603 } 19604 break; 19605 case 13: 19606 { 19607 setState(2374); 19608 html(); 19609 } 19610 break; 19611 case 14: 19612 { 19613 setState(2375); 19614 option(); 19615 } 19616 break; 19617 case 15: 19618 { 19619 setState(2376); 19620 tbody(); 19621 } 19622 break; 19623 case 16: 19624 { 19625 setState(2377); 19626 tfoot(); 19627 } 19628 break; 19629 case 17: 19630 { 19631 setState(2378); 19632 pTagStart(true); 19633 } 19634 break; 19635 case 18: 19636 { 19637 setState(2379); 19638 liTagStart(true); 19639 } 19640 break; 19641 case 19: 19642 { 19643 setState(2380); 19644 trTagStart(true); 19645 } 19646 break; 19647 case 20: 19648 { 19649 setState(2381); 19650 tdTagStart(true); 19651 } 19652 break; 19653 case 21: 19654 { 19655 setState(2382); 19656 thTagStart(true); 19657 } 19658 break; 19659 case 22: 19660 { 19661 setState(2383); 19662 bodyTagStart(true); 19663 } 19664 break; 19665 case 23: 19666 { 19667 setState(2384); 19668 colgroupTagStart(true); 19669 } 19670 break; 19671 case 24: 19672 { 19673 setState(2385); 19674 ddTagStart(true); 19675 } 19676 break; 19677 case 25: 19678 { 19679 setState(2386); 19680 dtTagStart(true); 19681 } 19682 break; 19683 case 26: 19684 { 19685 setState(2387); 19686 headTagStart(true); 19687 } 19688 break; 19689 case 27: 19690 { 19691 setState(2388); 19692 htmlTagStart(true); 19693 } 19694 break; 19695 case 28: 19696 { 19697 setState(2389); 19698 optionTagStart(true); 19699 } 19700 break; 19701 case 29: 19702 { 19703 setState(2390); 19704 tbodyTagStart(true); 19705 } 19706 break; 19707 case 30: 19708 { 19709 setState(2391); 19710 tfootTagStart(true); 19711 } 19712 break; 19713 case 31: 19714 { 19715 { 19716 setState(2392); 19717 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 19718 setState(2393); 19719 match(LEADING_ASTERISK); 19720 } 19721 } 19722 break; 19723 case 32: 19724 { 19725 setState(2394); 19726 htmlComment(); 19727 } 19728 break; 19729 case 33: 19730 { 19731 setState(2395); 19732 match(NEWLINE); 19733 } 19734 break; 19735 case 34: 19736 { 19737 setState(2396); 19738 text(); 19739 } 19740 break; 19741 case 35: 19742 { 19743 setState(2397); 19744 javadocInlineTag(); 19745 } 19746 break; 19747 } 19748 } 19749 } 19750 setState(2402); 19751 _errHandler.sync(this); 19752 _alt = getInterpreter().adaptivePredict(_input,211,_ctx); 19753 } 19754 setState(2403); 19755 rtcTagEnd(); 19756 } 19757 } 19758 catch (RecognitionException re) { 19759 _localctx.exception = re; 19760 _errHandler.reportError(this, re); 19761 _errHandler.recover(this, re); 19762 } 19763 finally { 19764 exitRule(); 19765 } 19766 return _localctx; 19767 } 19768 19769 public static class RpTagStartContext extends ParserRuleContext { 19770 public boolean isNonTight; 19771 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 19772 public TerminalNode RP_HTML_TAG_NAME() { return getToken(JavadocParser.RP_HTML_TAG_NAME, 0); } 19773 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 19774 public List<AttributeContext> attribute() { 19775 return getRuleContexts(AttributeContext.class); 19776 } 19777 public AttributeContext attribute(int i) { 19778 return getRuleContext(AttributeContext.class,i); 19779 } 19780 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 19781 public TerminalNode NEWLINE(int i) { 19782 return getToken(JavadocParser.NEWLINE, i); 19783 } 19784 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 19785 public TerminalNode LEADING_ASTERISK(int i) { 19786 return getToken(JavadocParser.LEADING_ASTERISK, i); 19787 } 19788 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 19789 public TerminalNode WS(int i) { 19790 return getToken(JavadocParser.WS, i); 19791 } 19792 public RpTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 19793 public RpTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 19794 super(parent, invokingState); 19795 this.isNonTight = isNonTight; 19796 } 19797 @Override public int getRuleIndex() { return RULE_rpTagStart; } 19798 } 19799 19800 public final RpTagStartContext rpTagStart(boolean isNonTight) throws RecognitionException { 19801 RpTagStartContext _localctx = new RpTagStartContext(_ctx, getState(), isNonTight); 19802 enterRule(_localctx, 184, RULE_rpTagStart); 19803 int _la; 19804 try { 19805 enterOuterAlt(_localctx, 1); 19806 { 19807 setState(2405); 19808 match(START); 19809 setState(2406); 19810 match(RP_HTML_TAG_NAME); 19811 setState(2413); 19812 _errHandler.sync(this); 19813 _la = _input.LA(1); 19814 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 19815 { 19816 setState(2411); 19817 _errHandler.sync(this); 19818 switch (_input.LA(1)) { 19819 case HTML_TAG_NAME: 19820 { 19821 setState(2407); 19822 attribute(); 19823 } 19824 break; 19825 case NEWLINE: 19826 { 19827 setState(2408); 19828 match(NEWLINE); 19829 } 19830 break; 19831 case LEADING_ASTERISK: 19832 { 19833 setState(2409); 19834 match(LEADING_ASTERISK); 19835 } 19836 break; 19837 case WS: 19838 { 19839 setState(2410); 19840 match(WS); 19841 } 19842 break; 19843 default: 19844 throw new NoViableAltException(this); 19845 } 19846 } 19847 setState(2415); 19848 _errHandler.sync(this); 19849 _la = _input.LA(1); 19850 } 19851 setState(2416); 19852 match(END); 19853 } 19854 _ctx.stop = _input.LT(-1); 19855 19856 if (isNonTight && nonTightTagStartContext == null) { 19857 nonTightTagStartContext = _localctx; 19858 } 19859 19860 } 19861 catch (RecognitionException re) { 19862 _localctx.exception = re; 19863 _errHandler.reportError(this, re); 19864 _errHandler.recover(this, re); 19865 } 19866 finally { 19867 exitRule(); 19868 } 19869 return _localctx; 19870 } 19871 19872 public static class RpTagEndContext extends ParserRuleContext { 19873 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 19874 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 19875 public TerminalNode RP_HTML_TAG_NAME() { return getToken(JavadocParser.RP_HTML_TAG_NAME, 0); } 19876 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 19877 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 19878 public TerminalNode NEWLINE(int i) { 19879 return getToken(JavadocParser.NEWLINE, i); 19880 } 19881 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 19882 public TerminalNode LEADING_ASTERISK(int i) { 19883 return getToken(JavadocParser.LEADING_ASTERISK, i); 19884 } 19885 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 19886 public TerminalNode WS(int i) { 19887 return getToken(JavadocParser.WS, i); 19888 } 19889 public RpTagEndContext(ParserRuleContext parent, int invokingState) { 19890 super(parent, invokingState); 19891 } 19892 @Override public int getRuleIndex() { return RULE_rpTagEnd; } 19893 } 19894 19895 public final RpTagEndContext rpTagEnd() throws RecognitionException { 19896 RpTagEndContext _localctx = new RpTagEndContext(_ctx, getState()); 19897 enterRule(_localctx, 186, RULE_rpTagEnd); 19898 int _la; 19899 try { 19900 enterOuterAlt(_localctx, 1); 19901 { 19902 setState(2418); 19903 match(START); 19904 setState(2419); 19905 match(SLASH); 19906 setState(2420); 19907 match(RP_HTML_TAG_NAME); 19908 setState(2424); 19909 _errHandler.sync(this); 19910 _la = _input.LA(1); 19911 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 19912 { 19913 { 19914 setState(2421); 19915 _la = _input.LA(1); 19916 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 19917 _errHandler.recoverInline(this); 19918 } 19919 else { 19920 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 19921 _errHandler.reportMatch(this); 19922 consume(); 19923 } 19924 } 19925 } 19926 setState(2426); 19927 _errHandler.sync(this); 19928 _la = _input.LA(1); 19929 } 19930 setState(2427); 19931 match(END); 19932 } 19933 } 19934 catch (RecognitionException re) { 19935 _localctx.exception = re; 19936 _errHandler.reportError(this, re); 19937 _errHandler.recover(this, re); 19938 } 19939 finally { 19940 exitRule(); 19941 } 19942 return _localctx; 19943 } 19944 19945 public static class RpContext extends ParserRuleContext { 19946 public RpTagStartContext rpTagStart() { 19947 return getRuleContext(RpTagStartContext.class,0); 19948 } 19949 public RpTagEndContext rpTagEnd() { 19950 return getRuleContext(RpTagEndContext.class,0); 19951 } 19952 public List<HtmlTagContext> htmlTag() { 19953 return getRuleContexts(HtmlTagContext.class); 19954 } 19955 public HtmlTagContext htmlTag(int i) { 19956 return getRuleContext(HtmlTagContext.class,i); 19957 } 19958 public List<SingletonElementContext> singletonElement() { 19959 return getRuleContexts(SingletonElementContext.class); 19960 } 19961 public SingletonElementContext singletonElement(int i) { 19962 return getRuleContext(SingletonElementContext.class,i); 19963 } 19964 public List<ParagraphContext> paragraph() { 19965 return getRuleContexts(ParagraphContext.class); 19966 } 19967 public ParagraphContext paragraph(int i) { 19968 return getRuleContext(ParagraphContext.class,i); 19969 } 19970 public List<LiContext> li() { 19971 return getRuleContexts(LiContext.class); 19972 } 19973 public LiContext li(int i) { 19974 return getRuleContext(LiContext.class,i); 19975 } 19976 public List<TrContext> tr() { 19977 return getRuleContexts(TrContext.class); 19978 } 19979 public TrContext tr(int i) { 19980 return getRuleContext(TrContext.class,i); 19981 } 19982 public List<TdContext> td() { 19983 return getRuleContexts(TdContext.class); 19984 } 19985 public TdContext td(int i) { 19986 return getRuleContext(TdContext.class,i); 19987 } 19988 public List<ThContext> th() { 19989 return getRuleContexts(ThContext.class); 19990 } 19991 public ThContext th(int i) { 19992 return getRuleContext(ThContext.class,i); 19993 } 19994 public List<BodyContext> body() { 19995 return getRuleContexts(BodyContext.class); 19996 } 19997 public BodyContext body(int i) { 19998 return getRuleContext(BodyContext.class,i); 19999 } 20000 public List<ColgroupContext> colgroup() { 20001 return getRuleContexts(ColgroupContext.class); 20002 } 20003 public ColgroupContext colgroup(int i) { 20004 return getRuleContext(ColgroupContext.class,i); 20005 } 20006 public List<DdContext> dd() { 20007 return getRuleContexts(DdContext.class); 20008 } 20009 public DdContext dd(int i) { 20010 return getRuleContext(DdContext.class,i); 20011 } 20012 public List<DtContext> dt() { 20013 return getRuleContexts(DtContext.class); 20014 } 20015 public DtContext dt(int i) { 20016 return getRuleContext(DtContext.class,i); 20017 } 20018 public List<HeadContext> head() { 20019 return getRuleContexts(HeadContext.class); 20020 } 20021 public HeadContext head(int i) { 20022 return getRuleContext(HeadContext.class,i); 20023 } 20024 public List<HtmlContext> html() { 20025 return getRuleContexts(HtmlContext.class); 20026 } 20027 public HtmlContext html(int i) { 20028 return getRuleContext(HtmlContext.class,i); 20029 } 20030 public List<OptionContext> option() { 20031 return getRuleContexts(OptionContext.class); 20032 } 20033 public OptionContext option(int i) { 20034 return getRuleContext(OptionContext.class,i); 20035 } 20036 public List<TbodyContext> tbody() { 20037 return getRuleContexts(TbodyContext.class); 20038 } 20039 public TbodyContext tbody(int i) { 20040 return getRuleContext(TbodyContext.class,i); 20041 } 20042 public List<TfootContext> tfoot() { 20043 return getRuleContexts(TfootContext.class); 20044 } 20045 public TfootContext tfoot(int i) { 20046 return getRuleContext(TfootContext.class,i); 20047 } 20048 public List<PTagStartContext> pTagStart() { 20049 return getRuleContexts(PTagStartContext.class); 20050 } 20051 public PTagStartContext pTagStart(int i) { 20052 return getRuleContext(PTagStartContext.class,i); 20053 } 20054 public List<LiTagStartContext> liTagStart() { 20055 return getRuleContexts(LiTagStartContext.class); 20056 } 20057 public LiTagStartContext liTagStart(int i) { 20058 return getRuleContext(LiTagStartContext.class,i); 20059 } 20060 public List<TrTagStartContext> trTagStart() { 20061 return getRuleContexts(TrTagStartContext.class); 20062 } 20063 public TrTagStartContext trTagStart(int i) { 20064 return getRuleContext(TrTagStartContext.class,i); 20065 } 20066 public List<TdTagStartContext> tdTagStart() { 20067 return getRuleContexts(TdTagStartContext.class); 20068 } 20069 public TdTagStartContext tdTagStart(int i) { 20070 return getRuleContext(TdTagStartContext.class,i); 20071 } 20072 public List<ThTagStartContext> thTagStart() { 20073 return getRuleContexts(ThTagStartContext.class); 20074 } 20075 public ThTagStartContext thTagStart(int i) { 20076 return getRuleContext(ThTagStartContext.class,i); 20077 } 20078 public List<BodyTagStartContext> bodyTagStart() { 20079 return getRuleContexts(BodyTagStartContext.class); 20080 } 20081 public BodyTagStartContext bodyTagStart(int i) { 20082 return getRuleContext(BodyTagStartContext.class,i); 20083 } 20084 public List<ColgroupTagStartContext> colgroupTagStart() { 20085 return getRuleContexts(ColgroupTagStartContext.class); 20086 } 20087 public ColgroupTagStartContext colgroupTagStart(int i) { 20088 return getRuleContext(ColgroupTagStartContext.class,i); 20089 } 20090 public List<DdTagStartContext> ddTagStart() { 20091 return getRuleContexts(DdTagStartContext.class); 20092 } 20093 public DdTagStartContext ddTagStart(int i) { 20094 return getRuleContext(DdTagStartContext.class,i); 20095 } 20096 public List<DtTagStartContext> dtTagStart() { 20097 return getRuleContexts(DtTagStartContext.class); 20098 } 20099 public DtTagStartContext dtTagStart(int i) { 20100 return getRuleContext(DtTagStartContext.class,i); 20101 } 20102 public List<HeadTagStartContext> headTagStart() { 20103 return getRuleContexts(HeadTagStartContext.class); 20104 } 20105 public HeadTagStartContext headTagStart(int i) { 20106 return getRuleContext(HeadTagStartContext.class,i); 20107 } 20108 public List<HtmlTagStartContext> htmlTagStart() { 20109 return getRuleContexts(HtmlTagStartContext.class); 20110 } 20111 public HtmlTagStartContext htmlTagStart(int i) { 20112 return getRuleContext(HtmlTagStartContext.class,i); 20113 } 20114 public List<OptionTagStartContext> optionTagStart() { 20115 return getRuleContexts(OptionTagStartContext.class); 20116 } 20117 public OptionTagStartContext optionTagStart(int i) { 20118 return getRuleContext(OptionTagStartContext.class,i); 20119 } 20120 public List<TbodyTagStartContext> tbodyTagStart() { 20121 return getRuleContexts(TbodyTagStartContext.class); 20122 } 20123 public TbodyTagStartContext tbodyTagStart(int i) { 20124 return getRuleContext(TbodyTagStartContext.class,i); 20125 } 20126 public List<TfootTagStartContext> tfootTagStart() { 20127 return getRuleContexts(TfootTagStartContext.class); 20128 } 20129 public TfootTagStartContext tfootTagStart(int i) { 20130 return getRuleContext(TfootTagStartContext.class,i); 20131 } 20132 public List<HtmlCommentContext> htmlComment() { 20133 return getRuleContexts(HtmlCommentContext.class); 20134 } 20135 public HtmlCommentContext htmlComment(int i) { 20136 return getRuleContext(HtmlCommentContext.class,i); 20137 } 20138 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 20139 public TerminalNode NEWLINE(int i) { 20140 return getToken(JavadocParser.NEWLINE, i); 20141 } 20142 public List<TextContext> text() { 20143 return getRuleContexts(TextContext.class); 20144 } 20145 public TextContext text(int i) { 20146 return getRuleContext(TextContext.class,i); 20147 } 20148 public List<JavadocInlineTagContext> javadocInlineTag() { 20149 return getRuleContexts(JavadocInlineTagContext.class); 20150 } 20151 public JavadocInlineTagContext javadocInlineTag(int i) { 20152 return getRuleContext(JavadocInlineTagContext.class,i); 20153 } 20154 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 20155 public TerminalNode LEADING_ASTERISK(int i) { 20156 return getToken(JavadocParser.LEADING_ASTERISK, i); 20157 } 20158 public RpContext(ParserRuleContext parent, int invokingState) { 20159 super(parent, invokingState); 20160 } 20161 @Override public int getRuleIndex() { return RULE_rp; } 20162 } 20163 20164 public final RpContext rp() throws RecognitionException { 20165 RpContext _localctx = new RpContext(_ctx, getState()); 20166 enterRule(_localctx, 188, RULE_rp); 20167 try { 20168 int _alt; 20169 enterOuterAlt(_localctx, 1); 20170 { 20171 setState(2429); 20172 rpTagStart(false); 20173 setState(2468); 20174 _errHandler.sync(this); 20175 _alt = getInterpreter().adaptivePredict(_input,216,_ctx); 20176 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 20177 if ( _alt==1 ) { 20178 { 20179 setState(2466); 20180 _errHandler.sync(this); 20181 switch ( getInterpreter().adaptivePredict(_input,215,_ctx) ) { 20182 case 1: 20183 { 20184 setState(2430); 20185 htmlTag(); 20186 } 20187 break; 20188 case 2: 20189 { 20190 setState(2431); 20191 singletonElement(); 20192 } 20193 break; 20194 case 3: 20195 { 20196 setState(2432); 20197 paragraph(); 20198 } 20199 break; 20200 case 4: 20201 { 20202 setState(2433); 20203 li(); 20204 } 20205 break; 20206 case 5: 20207 { 20208 setState(2434); 20209 tr(); 20210 } 20211 break; 20212 case 6: 20213 { 20214 setState(2435); 20215 td(); 20216 } 20217 break; 20218 case 7: 20219 { 20220 setState(2436); 20221 th(); 20222 } 20223 break; 20224 case 8: 20225 { 20226 setState(2437); 20227 body(); 20228 } 20229 break; 20230 case 9: 20231 { 20232 setState(2438); 20233 colgroup(); 20234 } 20235 break; 20236 case 10: 20237 { 20238 setState(2439); 20239 dd(); 20240 } 20241 break; 20242 case 11: 20243 { 20244 setState(2440); 20245 dt(); 20246 } 20247 break; 20248 case 12: 20249 { 20250 setState(2441); 20251 head(); 20252 } 20253 break; 20254 case 13: 20255 { 20256 setState(2442); 20257 html(); 20258 } 20259 break; 20260 case 14: 20261 { 20262 setState(2443); 20263 option(); 20264 } 20265 break; 20266 case 15: 20267 { 20268 setState(2444); 20269 tbody(); 20270 } 20271 break; 20272 case 16: 20273 { 20274 setState(2445); 20275 tfoot(); 20276 } 20277 break; 20278 case 17: 20279 { 20280 setState(2446); 20281 pTagStart(true); 20282 } 20283 break; 20284 case 18: 20285 { 20286 setState(2447); 20287 liTagStart(true); 20288 } 20289 break; 20290 case 19: 20291 { 20292 setState(2448); 20293 trTagStart(true); 20294 } 20295 break; 20296 case 20: 20297 { 20298 setState(2449); 20299 tdTagStart(true); 20300 } 20301 break; 20302 case 21: 20303 { 20304 setState(2450); 20305 thTagStart(true); 20306 } 20307 break; 20308 case 22: 20309 { 20310 setState(2451); 20311 bodyTagStart(true); 20312 } 20313 break; 20314 case 23: 20315 { 20316 setState(2452); 20317 colgroupTagStart(true); 20318 } 20319 break; 20320 case 24: 20321 { 20322 setState(2453); 20323 ddTagStart(true); 20324 } 20325 break; 20326 case 25: 20327 { 20328 setState(2454); 20329 dtTagStart(true); 20330 } 20331 break; 20332 case 26: 20333 { 20334 setState(2455); 20335 headTagStart(true); 20336 } 20337 break; 20338 case 27: 20339 { 20340 setState(2456); 20341 htmlTagStart(true); 20342 } 20343 break; 20344 case 28: 20345 { 20346 setState(2457); 20347 optionTagStart(true); 20348 } 20349 break; 20350 case 29: 20351 { 20352 setState(2458); 20353 tbodyTagStart(true); 20354 } 20355 break; 20356 case 30: 20357 { 20358 setState(2459); 20359 tfootTagStart(true); 20360 } 20361 break; 20362 case 31: 20363 { 20364 { 20365 setState(2460); 20366 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 20367 setState(2461); 20368 match(LEADING_ASTERISK); 20369 } 20370 } 20371 break; 20372 case 32: 20373 { 20374 setState(2462); 20375 htmlComment(); 20376 } 20377 break; 20378 case 33: 20379 { 20380 setState(2463); 20381 match(NEWLINE); 20382 } 20383 break; 20384 case 34: 20385 { 20386 setState(2464); 20387 text(); 20388 } 20389 break; 20390 case 35: 20391 { 20392 setState(2465); 20393 javadocInlineTag(); 20394 } 20395 break; 20396 } 20397 } 20398 } 20399 setState(2470); 20400 _errHandler.sync(this); 20401 _alt = getInterpreter().adaptivePredict(_input,216,_ctx); 20402 } 20403 setState(2471); 20404 rpTagEnd(); 20405 } 20406 } 20407 catch (RecognitionException re) { 20408 _localctx.exception = re; 20409 _errHandler.reportError(this, re); 20410 _errHandler.recover(this, re); 20411 } 20412 finally { 20413 exitRule(); 20414 } 20415 return _localctx; 20416 } 20417 20418 public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { 20419 switch (ruleIndex) { 20420 case 0: 20421 return javadoc_sempred((JavadocContext)_localctx, predIndex); 20422 case 5: 20423 return htmlTag_sempred((HtmlTagContext)_localctx, predIndex); 20424 case 8: 20425 return paragraph_sempred((ParagraphContext)_localctx, predIndex); 20426 case 11: 20427 return li_sempred((LiContext)_localctx, predIndex); 20428 case 14: 20429 return tr_sempred((TrContext)_localctx, predIndex); 20430 case 17: 20431 return td_sempred((TdContext)_localctx, predIndex); 20432 case 20: 20433 return th_sempred((ThContext)_localctx, predIndex); 20434 case 23: 20435 return body_sempred((BodyContext)_localctx, predIndex); 20436 case 26: 20437 return colgroup_sempred((ColgroupContext)_localctx, predIndex); 20438 case 29: 20439 return dd_sempred((DdContext)_localctx, predIndex); 20440 case 32: 20441 return dt_sempred((DtContext)_localctx, predIndex); 20442 case 35: 20443 return head_sempred((HeadContext)_localctx, predIndex); 20444 case 38: 20445 return html_sempred((HtmlContext)_localctx, predIndex); 20446 case 41: 20447 return option_sempred((OptionContext)_localctx, predIndex); 20448 case 44: 20449 return tbody_sempred((TbodyContext)_localctx, predIndex); 20450 case 47: 20451 return tfoot_sempred((TfootContext)_localctx, predIndex); 20452 case 50: 20453 return thead_sempred((TheadContext)_localctx, predIndex); 20454 case 68: 20455 return description_sempred((DescriptionContext)_localctx, predIndex); 20456 case 71: 20457 return javadocTag_sempred((JavadocTagContext)_localctx, predIndex); 20458 case 82: 20459 return optgroup_sempred((OptgroupContext)_localctx, predIndex); 20460 case 85: 20461 return rb_sempred((RbContext)_localctx, predIndex); 20462 case 88: 20463 return rt_sempred((RtContext)_localctx, predIndex); 20464 case 91: 20465 return rtc_sempred((RtcContext)_localctx, predIndex); 20466 case 94: 20467 return rp_sempred((RpContext)_localctx, predIndex); 20468 } 20469 return true; 20470 } 20471 private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) { 20472 switch (predIndex) { 20473 case 0: 20474 return !isNextJavadocTag(); 20475 } 20476 return true; 20477 } 20478 private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) { 20479 switch (predIndex) { 20480 case 1: 20481 return !isNextJavadocTag(); 20482 case 2: 20483 return isSameTagNames(((HtmlTagContext)_localctx).htmlElementStart, ((HtmlTagContext)_localctx).htmlElementEnd); 20484 } 20485 return true; 20486 } 20487 private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) { 20488 switch (predIndex) { 20489 case 3: 20490 return !isNextJavadocTag(); 20491 } 20492 return true; 20493 } 20494 private boolean li_sempred(LiContext _localctx, int predIndex) { 20495 switch (predIndex) { 20496 case 4: 20497 return !isNextJavadocTag(); 20498 } 20499 return true; 20500 } 20501 private boolean tr_sempred(TrContext _localctx, int predIndex) { 20502 switch (predIndex) { 20503 case 5: 20504 return !isNextJavadocTag(); 20505 } 20506 return true; 20507 } 20508 private boolean td_sempred(TdContext _localctx, int predIndex) { 20509 switch (predIndex) { 20510 case 6: 20511 return !isNextJavadocTag(); 20512 } 20513 return true; 20514 } 20515 private boolean th_sempred(ThContext _localctx, int predIndex) { 20516 switch (predIndex) { 20517 case 7: 20518 return !isNextJavadocTag(); 20519 } 20520 return true; 20521 } 20522 private boolean body_sempred(BodyContext _localctx, int predIndex) { 20523 switch (predIndex) { 20524 case 8: 20525 return !isNextJavadocTag(); 20526 } 20527 return true; 20528 } 20529 private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) { 20530 switch (predIndex) { 20531 case 9: 20532 return !isNextJavadocTag(); 20533 } 20534 return true; 20535 } 20536 private boolean dd_sempred(DdContext _localctx, int predIndex) { 20537 switch (predIndex) { 20538 case 10: 20539 return !isNextJavadocTag(); 20540 } 20541 return true; 20542 } 20543 private boolean dt_sempred(DtContext _localctx, int predIndex) { 20544 switch (predIndex) { 20545 case 11: 20546 return !isNextJavadocTag(); 20547 } 20548 return true; 20549 } 20550 private boolean head_sempred(HeadContext _localctx, int predIndex) { 20551 switch (predIndex) { 20552 case 12: 20553 return !isNextJavadocTag(); 20554 } 20555 return true; 20556 } 20557 private boolean html_sempred(HtmlContext _localctx, int predIndex) { 20558 switch (predIndex) { 20559 case 13: 20560 return !isNextJavadocTag(); 20561 } 20562 return true; 20563 } 20564 private boolean option_sempred(OptionContext _localctx, int predIndex) { 20565 switch (predIndex) { 20566 case 14: 20567 return !isNextJavadocTag(); 20568 } 20569 return true; 20570 } 20571 private boolean tbody_sempred(TbodyContext _localctx, int predIndex) { 20572 switch (predIndex) { 20573 case 15: 20574 return !isNextJavadocTag(); 20575 } 20576 return true; 20577 } 20578 private boolean tfoot_sempred(TfootContext _localctx, int predIndex) { 20579 switch (predIndex) { 20580 case 16: 20581 return !isNextJavadocTag(); 20582 } 20583 return true; 20584 } 20585 private boolean thead_sempred(TheadContext _localctx, int predIndex) { 20586 switch (predIndex) { 20587 case 17: 20588 return !isNextJavadocTag(); 20589 } 20590 return true; 20591 } 20592 private boolean description_sempred(DescriptionContext _localctx, int predIndex) { 20593 switch (predIndex) { 20594 case 18: 20595 return !isNextJavadocTag(); 20596 } 20597 return true; 20598 } 20599 private boolean javadocTag_sempred(JavadocTagContext _localctx, int predIndex) { 20600 switch (predIndex) { 20601 case 19: 20602 return !isNextJavadocTag(); 20603 case 20: 20604 return !isNextJavadocTag(); 20605 case 21: 20606 return !isNextJavadocTag(); 20607 case 22: 20608 return !isNextJavadocTag(); 20609 } 20610 return true; 20611 } 20612 private boolean optgroup_sempred(OptgroupContext _localctx, int predIndex) { 20613 switch (predIndex) { 20614 case 23: 20615 return !isNextJavadocTag(); 20616 } 20617 return true; 20618 } 20619 private boolean rb_sempred(RbContext _localctx, int predIndex) { 20620 switch (predIndex) { 20621 case 24: 20622 return !isNextJavadocTag(); 20623 } 20624 return true; 20625 } 20626 private boolean rt_sempred(RtContext _localctx, int predIndex) { 20627 switch (predIndex) { 20628 case 25: 20629 return !isNextJavadocTag(); 20630 } 20631 return true; 20632 } 20633 private boolean rtc_sempred(RtcContext _localctx, int predIndex) { 20634 switch (predIndex) { 20635 case 26: 20636 return !isNextJavadocTag(); 20637 } 20638 return true; 20639 } 20640 private boolean rp_sempred(RpContext _localctx, int predIndex) { 20641 switch (predIndex) { 20642 case 27: 20643 return !isNextJavadocTag(); 20644 } 20645 return true; 20646 } 20647 20648 private static final int _serializedATNSegments = 2; 20649 private static final String _serializedATNSegment0 = 20650 "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3g\u09ac\4\2\t\2\4"+ 20651 "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+ 20652 "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ 20653 "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ 20654 "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ 20655 "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ 20656 ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ 20657 "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ 20658 "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ 20659 "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ 20660 "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+ 20661 "`\t`\3\2\3\2\3\2\3\2\3\2\3\2\3\2\7\2\u00c8\n\2\f\2\16\2\u00cb\13\2\3\2"+ 20662 "\5\2\u00ce\n\2\3\2\7\2\u00d1\n\2\f\2\16\2\u00d4\13\2\3\2\7\2\u00d7\n\2"+ 20663 "\f\2\16\2\u00da\13\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+ 20664 "\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+ 20665 "\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+ 20666 "\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3"+ 20667 "\u011c\n\3\3\4\3\4\3\4\3\4\3\4\3\4\7\4\u0124\n\4\f\4\16\4\u0127\13\4\3"+ 20668 "\4\3\4\3\5\3\5\3\5\3\5\7\5\u012f\n\5\f\5\16\5\u0132\13\5\3\5\3\5\3\6\3"+ 20669 "\6\7\6\u0138\n\6\f\6\16\6\u013b\13\6\3\6\3\6\7\6\u013f\n\6\f\6\16\6\u0142"+ 20670 "\13\6\3\6\3\6\3\6\5\6\u0147\n\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\7\7\u0151"+ 20671 "\n\7\f\7\16\7\u0154\13\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\7\b\u015f"+ 20672 "\n\b\f\b\16\b\u0162\13\b\3\b\3\b\3\t\3\t\3\t\3\t\7\t\u016a\n\t\f\t\16"+ 20673 "\t\u016d\13\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n"+ 20674 "\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3"+ 20675 "\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n"+ 20676 "\7\n\u01a0\n\n\f\n\16\n\u01a3\13\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3"+ 20677 "\13\7\13\u01ad\n\13\f\13\16\13\u01b0\13\13\3\13\3\13\3\f\3\f\3\f\3\f\7"+ 20678 "\f\u01b8\n\f\f\f\16\f\u01bb\13\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3"+ 20679 "\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r"+ 20680 "\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3"+ 20681 "\r\3\r\3\r\3\r\3\r\7\r\u01ee\n\r\f\r\16\r\u01f1\13\r\3\r\3\r\3\16\3\16"+ 20682 "\3\16\3\16\3\16\3\16\7\16\u01fb\n\16\f\16\16\16\u01fe\13\16\3\16\3\16"+ 20683 "\3\17\3\17\3\17\3\17\7\17\u0206\n\17\f\17\16\17\u0209\13\17\3\17\3\17"+ 20684 "\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20"+ 20685 "\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20"+ 20686 "\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20"+ 20687 "\3\20\3\20\3\20\3\20\3\20\7\20\u023c\n\20\f\20\16\20\u023f\13\20\3\20"+ 20688 "\3\20\3\21\3\21\3\21\3\21\3\21\3\21\7\21\u0249\n\21\f\21\16\21\u024c\13"+ 20689 "\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0254\n\22\f\22\16\22\u0257\13"+ 20690 "\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3"+ 20691 "\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3"+ 20692 "\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3"+ 20693 "\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\7\23\u028a\n\23\f\23\16\23\u028d"+ 20694 "\13\23\3\23\3\23\3\24\3\24\3\24\3\24\3\24\3\24\7\24\u0297\n\24\f\24\16"+ 20695 "\24\u029a\13\24\3\24\3\24\3\25\3\25\3\25\3\25\7\25\u02a2\n\25\f\25\16"+ 20696 "\25\u02a5\13\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26"+ 20697 "\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26"+ 20698 "\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26"+ 20699 "\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\7\26\u02d8\n\26\f\26"+ 20700 "\16\26\u02db\13\26\3\26\3\26\3\27\3\27\3\27\3\27\3\27\3\27\7\27\u02e5"+ 20701 "\n\27\f\27\16\27\u02e8\13\27\3\27\3\27\3\30\3\30\3\30\3\30\7\30\u02f0"+ 20702 "\n\30\f\30\16\30\u02f3\13\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31\3"+ 20703 "\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3"+ 20704 "\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3"+ 20705 "\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\7\31\u0326"+ 20706 "\n\31\f\31\16\31\u0329\13\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\7"+ 20707 "\32\u0333\n\32\f\32\16\32\u0336\13\32\3\32\3\32\3\33\3\33\3\33\3\33\7"+ 20708 "\33\u033e\n\33\f\33\16\33\u0341\13\33\3\33\3\33\3\34\3\34\3\34\3\34\3"+ 20709 "\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3"+ 20710 "\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3"+ 20711 "\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3"+ 20712 "\34\7\34\u0374\n\34\f\34\16\34\u0377\13\34\3\34\3\34\3\35\3\35\3\35\3"+ 20713 "\35\3\35\3\35\7\35\u0381\n\35\f\35\16\35\u0384\13\35\3\35\3\35\3\36\3"+ 20714 "\36\3\36\3\36\7\36\u038c\n\36\f\36\16\36\u038f\13\36\3\36\3\36\3\37\3"+ 20715 "\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3"+ 20716 "\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3"+ 20717 "\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3"+ 20718 "\37\3\37\3\37\3\37\7\37\u03c2\n\37\f\37\16\37\u03c5\13\37\3\37\3\37\3"+ 20719 " \3 \3 \3 \3 \3 \7 \u03cf\n \f \16 \u03d2\13 \3 \3 \3!\3!\3!\3!\7!\u03da"+ 20720 "\n!\f!\16!\u03dd\13!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+ 20721 "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+ 20722 "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+ 20723 "\3\"\7\"\u0410\n\"\f\"\16\"\u0413\13\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u041d"+ 20724 "\n#\f#\16#\u0420\13#\3#\3#\3$\3$\3$\3$\7$\u0428\n$\f$\16$\u042b\13$\3"+ 20725 "$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 20726 "%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 20727 "%\3%\3%\7%\u045e\n%\f%\16%\u0461\13%\3%\3%\3&\3&\3&\3&\3&\3&\7&\u046b"+ 20728 "\n&\f&\16&\u046e\13&\3&\3&\3\'\3\'\3\'\3\'\7\'\u0476\n\'\f\'\16\'\u0479"+ 20729 "\13\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3"+ 20730 "(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3"+ 20731 "(\3(\3(\3(\3(\3(\7(\u04ac\n(\f(\16(\u04af\13(\3(\3(\3)\3)\3)\3)\3)\3)"+ 20732 "\7)\u04b9\n)\f)\16)\u04bc\13)\3)\3)\3*\3*\3*\3*\7*\u04c4\n*\f*\16*\u04c7"+ 20733 "\13*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3"+ 20734 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3"+ 20735 "+\3+\3+\3+\3+\7+\u04fa\n+\f+\16+\u04fd\13+\3+\3+\3,\3,\3,\3,\3,\3,\7,"+ 20736 "\u0507\n,\f,\16,\u050a\13,\3,\3,\3-\3-\3-\3-\7-\u0512\n-\f-\16-\u0515"+ 20737 "\13-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3"+ 20738 ".\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3"+ 20739 ".\3.\3.\3.\3.\7.\u0548\n.\f.\16.\u054b\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/"+ 20740 "\u0555\n/\f/\16/\u0558\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u0560\n\60\f"+ 20741 "\60\16\60\u0563\13\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61"+ 20742 "\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61"+ 20743 "\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61"+ 20744 "\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\7\61\u0596\n\61"+ 20745 "\f\61\16\61\u0599\13\61\3\61\3\61\3\62\3\62\3\62\3\62\3\62\3\62\7\62\u05a3"+ 20746 "\n\62\f\62\16\62\u05a6\13\62\3\62\3\62\3\63\3\63\3\63\3\63\7\63\u05ae"+ 20747 "\n\63\f\63\16\63\u05b1\13\63\3\63\3\63\3\64\3\64\3\64\3\64\3\64\3\64\3"+ 20748 "\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3"+ 20749 "\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3"+ 20750 "\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\7\64\u05e4"+ 20751 "\n\64\f\64\16\64\u05e7\13\64\3\64\3\64\3\65\3\65\3\65\3\65\3\65\3\65\3"+ 20752 "\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\5"+ 20753 "\65\u05ff\n\65\3\66\3\66\3\66\3\66\3\66\3\66\7\66\u0607\n\66\f\66\16\66"+ 20754 "\u060a\13\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67\3\67\7\67\u0614\n\67\f"+ 20755 "\67\16\67\u0617\13\67\3\67\3\67\38\38\38\38\38\38\78\u0621\n8\f8\168\u0624"+ 20756 "\138\38\38\39\39\39\39\39\39\79\u062e\n9\f9\169\u0631\139\39\39\3:\3:"+ 20757 "\3:\3:\3:\3:\7:\u063b\n:\f:\16:\u063e\13:\3:\3:\3;\3;\3;\3;\3;\3;\7;\u0648"+ 20758 "\n;\f;\16;\u064b\13;\3;\3;\3<\3<\3<\3<\3<\3<\7<\u0655\n<\f<\16<\u0658"+ 20759 "\13<\3<\3<\3=\3=\3=\3=\3=\3=\7=\u0662\n=\f=\16=\u0665\13=\3=\3=\3>\3>"+ 20760 "\3>\3>\3>\3>\7>\u066f\n>\f>\16>\u0672\13>\3>\3>\3?\3?\3?\3?\3?\3?\7?\u067c"+ 20761 "\n?\f?\16?\u067f\13?\3?\3?\3@\3@\3@\3@\3@\3@\7@\u0689\n@\f@\16@\u068c"+ 20762 "\13@\3@\3@\3A\3A\3A\3A\3A\3A\7A\u0696\nA\fA\16A\u0699\13A\3A\3A\3B\3B"+ 20763 "\3B\3B\3B\3B\7B\u06a3\nB\fB\16B\u06a6\13B\3B\3B\3C\3C\3C\3C\3C\3C\7C\u06b0"+ 20764 "\nC\fC\16C\u06b3\13C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3"+ 20765 "F\6F\u06c6\nF\rF\16F\u06c7\3G\3G\3G\3G\5G\u06ce\nG\5G\u06d0\nG\3G\3G\3"+ 20766 "G\5G\u06d5\nG\5G\u06d7\nG\3H\3H\7H\u06db\nH\fH\16H\u06de\13H\3H\3H\3I"+ 20767 "\3I\6I\u06e4\nI\rI\16I\u06e5\3I\3I\3I\7I\u06eb\nI\fI\16I\u06ee\13I\3I"+ 20768 "\3I\5I\u06f2\nI\3I\3I\3I\3I\3I\6I\u06f9\nI\rI\16I\u06fa\3I\3I\7I\u06ff"+ 20769 "\nI\fI\16I\u0702\13I\3I\3I\5I\u0706\nI\3I\3I\3I\3I\3I\6I\u070d\nI\rI\16"+ 20770 "I\u070e\3I\3I\7I\u0713\nI\fI\16I\u0716\13I\3I\3I\5I\u071a\nI\3I\3I\6I"+ 20771 "\u071e\nI\rI\16I\u071f\3I\3I\3I\3I\3I\3I\6I\u0728\nI\rI\16I\u0729\3I\3"+ 20772 "I\3I\5I\u072f\nI\3I\7I\u0732\nI\fI\16I\u0735\13I\3I\3I\5I\u0739\nI\3I"+ 20773 "\3I\7I\u073d\nI\fI\16I\u0740\13I\3I\3I\3I\3I\5I\u0746\nI\3I\7I\u0749\n"+ 20774 "I\fI\16I\u074c\13I\3I\3I\7I\u0750\nI\fI\16I\u0753\13I\3I\3I\5I\u0757\n"+ 20775 "I\3I\3I\7I\u075b\nI\fI\16I\u075e\13I\3I\3I\5I\u0762\nI\3I\7I\u0765\nI"+ 20776 "\fI\16I\u0768\13I\3I\3I\5I\u076c\nI\3I\7I\u076f\nI\fI\16I\u0772\13I\3"+ 20777 "I\3I\5I\u0776\nI\3I\3I\6I\u077a\nI\rI\16I\u077b\3I\3I\3I\3I\3I\3I\6I\u0784"+ 20778 "\nI\rI\16I\u0785\3I\3I\7I\u078a\nI\fI\16I\u078d\13I\3I\3I\5I\u0791\nI"+ 20779 "\3I\3I\6I\u0795\nI\rI\16I\u0796\3I\3I\3I\7I\u079c\nI\fI\16I\u079f\13I"+ 20780 "\3I\3I\5I\u07a3\nI\5I\u07a5\nI\3J\3J\3J\3J\3J\3J\7J\u07ad\nJ\fJ\16J\u07b0"+ 20781 "\13J\3J\3J\7J\u07b4\nJ\fJ\16J\u07b7\13J\3J\3J\7J\u07bb\nJ\fJ\16J\u07be"+ 20782 "\13J\3J\3J\6J\u07c2\nJ\rJ\16J\u07c3\3J\3J\7J\u07c8\nJ\fJ\16J\u07cb\13"+ 20783 "J\3J\3J\5J\u07cf\nJ\3J\3J\6J\u07d3\nJ\rJ\16J\u07d4\3J\3J\7J\u07d9\nJ\f"+ 20784 "J\16J\u07dc\13J\3J\3J\5J\u07e0\nJ\3J\3J\3J\3J\3J\7J\u07e7\nJ\fJ\16J\u07ea"+ 20785 "\13J\3J\3J\7J\u07ee\nJ\fJ\16J\u07f1\13J\3J\3J\5J\u07f5\nJ\3J\3J\7J\u07f9"+ 20786 "\nJ\fJ\16J\u07fc\13J\3J\3J\5J\u0800\nJ\5J\u0802\nJ\3J\3J\3K\3K\3K\3K\7"+ 20787 "K\u080a\nK\fK\16K\u080d\13K\3K\3K\3L\3L\6L\u0813\nL\rL\16L\u0814\3M\3"+ 20788 "M\3M\3M\3M\3M\7M\u081d\nM\fM\16M\u0820\13M\3M\3M\3N\3N\3N\3N\3N\3N\7N"+ 20789 "\u082a\nN\fN\16N\u082d\13N\3N\3N\3O\3O\3O\3O\3O\3O\7O\u0837\nO\fO\16O"+ 20790 "\u083a\13O\3O\3O\3P\3P\3P\3P\3P\3P\7P\u0844\nP\fP\16P\u0847\13P\3P\3P"+ 20791 "\3Q\3Q\3Q\3Q\3Q\3Q\7Q\u0851\nQ\fQ\16Q\u0854\13Q\3Q\3Q\3R\3R\3R\3R\3R\3"+ 20792 "R\7R\u085e\nR\fR\16R\u0861\13R\3R\3R\3S\3S\3S\3S\7S\u0869\nS\fS\16S\u086c"+ 20793 "\13S\3S\3S\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3"+ 20794 "T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\7T\u0895\nT\fT\16"+ 20795 "T\u0898\13T\3T\3T\3U\3U\3U\3U\3U\3U\7U\u08a2\nU\fU\16U\u08a5\13U\3U\3"+ 20796 "U\3V\3V\3V\3V\7V\u08ad\nV\fV\16V\u08b0\13V\3V\3V\3W\3W\3W\3W\3W\3W\3W"+ 20797 "\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W"+ 20798 "\3W\3W\3W\3W\3W\3W\3W\7W\u08d9\nW\fW\16W\u08dc\13W\3W\3W\3X\3X\3X\3X\3"+ 20799 "X\3X\7X\u08e6\nX\fX\16X\u08e9\13X\3X\3X\3Y\3Y\3Y\3Y\7Y\u08f1\nY\fY\16"+ 20800 "Y\u08f4\13Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3"+ 20801 "Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\7Z\u091d\n"+ 20802 "Z\fZ\16Z\u0920\13Z\3Z\3Z\3[\3[\3[\3[\3[\3[\7[\u092a\n[\f[\16[\u092d\13"+ 20803 "[\3[\3[\3\\\3\\\3\\\3\\\7\\\u0935\n\\\f\\\16\\\u0938\13\\\3\\\3\\\3]\3"+ 20804 "]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3"+ 20805 "]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\7]\u0961\n]\f]\16]\u0964\13]\3]"+ 20806 "\3]\3^\3^\3^\3^\3^\3^\7^\u096e\n^\f^\16^\u0971\13^\3^\3^\3_\3_\3_\3_\7"+ 20807 "_\u0979\n_\f_\16_\u097c\13_\3_\3_\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`"+ 20808 "\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`"+ 20809 "\3`\3`\7`\u09a5\n`\f`\16`\u09a8\13`\3`\3`\3`\2\2a\2\4\6\b\n\f\16\20\22"+ 20810 "\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnp"+ 20811 "rtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094"+ 20812 "\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac"+ 20813 "\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\2\t\5\2\3\3\6\6"+ 20814 "\b\b\4\2=Kff\3\29:\4\2LZ^`\6\2\3\3\6\6\b\b&\'\4\2\6\6\b\b\4\2\6\6\32\32"+ 20815 "\2\u0e17\2\u00c9\3\2\2\2\4\u011b\3\2\2\2\6\u011d\3\2\2\2\b\u012a\3\2\2"+ 20816 "\2\n\u0135\3\2\2\2\f\u0148\3\2\2\2\16\u0158\3\2\2\2\20\u0165\3\2\2\2\22"+ 20817 "\u0170\3\2\2\2\24\u01a6\3\2\2\2\26\u01b3\3\2\2\2\30\u01be\3\2\2\2\32\u01f4"+ 20818 "\3\2\2\2\34\u0201\3\2\2\2\36\u020c\3\2\2\2 \u0242\3\2\2\2\"\u024f\3\2"+ 20819 "\2\2$\u025a\3\2\2\2&\u0290\3\2\2\2(\u029d\3\2\2\2*\u02a8\3\2\2\2,\u02de"+ 20820 "\3\2\2\2.\u02eb\3\2\2\2\60\u02f6\3\2\2\2\62\u032c\3\2\2\2\64\u0339\3\2"+ 20821 "\2\2\66\u0344\3\2\2\28\u037a\3\2\2\2:\u0387\3\2\2\2<\u0392\3\2\2\2>\u03c8"+ 20822 "\3\2\2\2@\u03d5\3\2\2\2B\u03e0\3\2\2\2D\u0416\3\2\2\2F\u0423\3\2\2\2H"+ 20823 "\u042e\3\2\2\2J\u0464\3\2\2\2L\u0471\3\2\2\2N\u047c\3\2\2\2P\u04b2\3\2"+ 20824 "\2\2R\u04bf\3\2\2\2T\u04ca\3\2\2\2V\u0500\3\2\2\2X\u050d\3\2\2\2Z\u0518"+ 20825 "\3\2\2\2\\\u054e\3\2\2\2^\u055b\3\2\2\2`\u0566\3\2\2\2b\u059c\3\2\2\2"+ 20826 "d\u05a9\3\2\2\2f\u05b4\3\2\2\2h\u05fe\3\2\2\2j\u0600\3\2\2\2l\u060d\3"+ 20827 "\2\2\2n\u061a\3\2\2\2p\u0627\3\2\2\2r\u0634\3\2\2\2t\u0641\3\2\2\2v\u064e"+ 20828 "\3\2\2\2x\u065b\3\2\2\2z\u0668\3\2\2\2|\u0675\3\2\2\2~\u0682\3\2\2\2\u0080"+ 20829 "\u068f\3\2\2\2\u0082\u069c\3\2\2\2\u0084\u06a9\3\2\2\2\u0086\u06b6\3\2"+ 20830 "\2\2\u0088\u06bc\3\2\2\2\u008a\u06c5\3\2\2\2\u008c\u06d6\3\2\2\2\u008e"+ 20831 "\u06d8\3\2\2\2\u0090\u07a4\3\2\2\2\u0092\u07a6\3\2\2\2\u0094\u0805\3\2"+ 20832 "\2\2\u0096\u0812\3\2\2\2\u0098\u0816\3\2\2\2\u009a\u0823\3\2\2\2\u009c"+ 20833 "\u0830\3\2\2\2\u009e\u083d\3\2\2\2\u00a0\u084a\3\2\2\2\u00a2\u0857\3\2"+ 20834 "\2\2\u00a4\u0864\3\2\2\2\u00a6\u086f\3\2\2\2\u00a8\u089b\3\2\2\2\u00aa"+ 20835 "\u08a8\3\2\2\2\u00ac\u08b3\3\2\2\2\u00ae\u08df\3\2\2\2\u00b0\u08ec\3\2"+ 20836 "\2\2\u00b2\u08f7\3\2\2\2\u00b4\u0923\3\2\2\2\u00b6\u0930\3\2\2\2\u00b8"+ 20837 "\u093b\3\2\2\2\u00ba\u0967\3\2\2\2\u00bc\u0974\3\2\2\2\u00be\u097f\3\2"+ 20838 "\2\2\u00c0\u00c8\5\4\3\2\u00c1\u00c2\6\2\2\2\u00c2\u00c8\7\3\2\2\u00c3"+ 20839 "\u00c8\5\u0094K\2\u00c4\u00c8\7\b\2\2\u00c5\u00c8\5\u0096L\2\u00c6\u00c8"+ 20840 "\5\u0092J\2\u00c7\u00c0\3\2\2\2\u00c7\u00c1\3\2\2\2\u00c7\u00c3\3\2\2"+ 20841 "\2\u00c7\u00c4\3\2\2\2\u00c7\u00c5\3\2\2\2\u00c7\u00c6\3\2\2\2\u00c8\u00cb"+ 20842 "\3\2\2\2\u00c9\u00c7\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00d8\3\2\2\2\u00cb"+ 20843 "\u00c9\3\2\2\2\u00cc\u00ce\7\3\2\2\u00cd\u00cc\3\2\2\2\u00cd\u00ce\3\2"+ 20844 "\2\2\u00ce\u00d2\3\2\2\2\u00cf\u00d1\7\6\2\2\u00d0\u00cf\3\2\2\2\u00d1"+ 20845 "\u00d4\3\2\2\2\u00d2\u00d0\3\2\2\2\u00d2\u00d3\3\2\2\2\u00d3\u00d5\3\2"+ 20846 "\2\2\u00d4\u00d2\3\2\2\2\u00d5\u00d7\5\u0090I\2\u00d6\u00cd\3\2\2\2\u00d7"+ 20847 "\u00da\3\2\2\2\u00d8\u00d6\3\2\2\2\u00d8\u00d9\3\2\2\2\u00d9\u00db\3\2"+ 20848 "\2\2\u00da\u00d8\3\2\2\2\u00db\u00dc\7\2\2\3\u00dc\3\3\2\2\2\u00dd\u011c"+ 20849 "\5\f\7\2\u00de\u011c\5h\65\2\u00df\u011c\5\22\n\2\u00e0\u011c\5\30\r\2"+ 20850 "\u00e1\u011c\5\36\20\2\u00e2\u011c\5$\23\2\u00e3\u011c\5*\26\2\u00e4\u011c"+ 20851 "\5\60\31\2\u00e5\u011c\5\66\34\2\u00e6\u011c\5<\37\2\u00e7\u011c\5B\""+ 20852 "\2\u00e8\u011c\5H%\2\u00e9\u011c\5N(\2\u00ea\u011c\5T+\2\u00eb\u011c\5"+ 20853 "Z.\2\u00ec\u011c\5f\64\2\u00ed\u011c\5`\61\2\u00ee\u011c\5\u00a6T\2\u00ef"+ 20854 "\u011c\5\u00acW\2\u00f0\u011c\5\u00b2Z\2\u00f1\u011c\5\u00b8]\2\u00f2"+ 20855 "\u011c\5\u00be`\2\u00f3\u011c\5\16\b\2\u00f4\u011c\5\24\13\2\u00f5\u011c"+ 20856 "\5\32\16\2\u00f6\u011c\5 \21\2\u00f7\u011c\5&\24\2\u00f8\u011c\5,\27\2"+ 20857 "\u00f9\u011c\5\62\32\2\u00fa\u011c\58\35\2\u00fb\u011c\5> \2\u00fc\u011c"+ 20858 "\5D#\2\u00fd\u011c\5J&\2\u00fe\u011c\5P)\2\u00ff\u011c\5V,\2\u0100\u011c"+ 20859 "\5b\62\2\u0101\u011c\5\\/\2\u0102\u011c\5\u00a2R\2\u0103\u011c\5\u00a8"+ 20860 "U\2\u0104\u011c\5\u00aeX\2\u0105\u011c\5\u00b4[\2\u0106\u011c\5\u00ba"+ 20861 "^\2\u0107\u011c\5\20\t\2\u0108\u011c\5\26\f\2\u0109\u011c\5\34\17\2\u010a"+ 20862 "\u011c\5\"\22\2\u010b\u011c\5(\25\2\u010c\u011c\5.\30\2\u010d\u011c\5"+ 20863 "\64\33\2\u010e\u011c\5:\36\2\u010f\u011c\5@!\2\u0110\u011c\5F$\2\u0111"+ 20864 "\u011c\5L\'\2\u0112\u011c\5R*\2\u0113\u011c\5X-\2\u0114\u011c\5d\63\2"+ 20865 "\u0115\u011c\5^\60\2\u0116\u011c\5\u00a4S\2\u0117\u011c\5\u00aaV\2\u0118"+ 20866 "\u011c\5\u00b0Y\2\u0119\u011c\5\u00b6\\\2\u011a\u011c\5\u00bc_\2\u011b"+ 20867 "\u00dd\3\2\2\2\u011b\u00de\3\2\2\2\u011b\u00df\3\2\2\2\u011b\u00e0\3\2"+ 20868 "\2\2\u011b\u00e1\3\2\2\2\u011b\u00e2\3\2\2\2\u011b\u00e3\3\2\2\2\u011b"+ 20869 "\u00e4\3\2\2\2\u011b\u00e5\3\2\2\2\u011b\u00e6\3\2\2\2\u011b\u00e7\3\2"+ 20870 "\2\2\u011b\u00e8\3\2\2\2\u011b\u00e9\3\2\2\2\u011b\u00ea\3\2\2\2\u011b"+ 20871 "\u00eb\3\2\2\2\u011b\u00ec\3\2\2\2\u011b\u00ed\3\2\2\2\u011b\u00ee\3\2"+ 20872 "\2\2\u011b\u00ef\3\2\2\2\u011b\u00f0\3\2\2\2\u011b\u00f1\3\2\2\2\u011b"+ 20873 "\u00f2\3\2\2\2\u011b\u00f3\3\2\2\2\u011b\u00f4\3\2\2\2\u011b\u00f5\3\2"+ 20874 "\2\2\u011b\u00f6\3\2\2\2\u011b\u00f7\3\2\2\2\u011b\u00f8\3\2\2\2\u011b"+ 20875 "\u00f9\3\2\2\2\u011b\u00fa\3\2\2\2\u011b\u00fb\3\2\2\2\u011b\u00fc\3\2"+ 20876 "\2\2\u011b\u00fd\3\2\2\2\u011b\u00fe\3\2\2\2\u011b\u00ff\3\2\2\2\u011b"+ 20877 "\u0100\3\2\2\2\u011b\u0101\3\2\2\2\u011b\u0102\3\2\2\2\u011b\u0103\3\2"+ 20878 "\2\2\u011b\u0104\3\2\2\2\u011b\u0105\3\2\2\2\u011b\u0106\3\2\2\2\u011b"+ 20879 "\u0107\3\2\2\2\u011b\u0108\3\2\2\2\u011b\u0109\3\2\2\2\u011b\u010a\3\2"+ 20880 "\2\2\u011b\u010b\3\2\2\2\u011b\u010c\3\2\2\2\u011b\u010d\3\2\2\2\u011b"+ 20881 "\u010e\3\2\2\2\u011b\u010f\3\2\2\2\u011b\u0110\3\2\2\2\u011b\u0111\3\2"+ 20882 "\2\2\u011b\u0112\3\2\2\2\u011b\u0113\3\2\2\2\u011b\u0114\3\2\2\2\u011b"+ 20883 "\u0115\3\2\2\2\u011b\u0116\3\2\2\2\u011b\u0117\3\2\2\2\u011b\u0118\3\2"+ 20884 "\2\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2\2\2\u011c\5\3\2\2\2\u011d\u011e"+ 20885 "\7\7\2\2\u011e\u0125\7f\2\2\u011f\u0124\5\n\6\2\u0120\u0124\7\b\2\2\u0121"+ 20886 "\u0124\7\3\2\2\u0122\u0124\7\6\2\2\u0123\u011f\3\2\2\2\u0123\u0120\3\2"+ 20887 "\2\2\u0123\u0121\3\2\2\2\u0123\u0122\3\2\2\2\u0124\u0127\3\2\2\2\u0125"+ 20888 "\u0123\3\2\2\2\u0125\u0126\3\2\2\2\u0126\u0128\3\2\2\2\u0127\u0125\3\2"+ 20889 "\2\2\u0128\u0129\79\2\2\u0129\7\3\2\2\2\u012a\u012b\7\7\2\2\u012b\u012c"+ 20890 "\7;\2\2\u012c\u0130\7f\2\2\u012d\u012f\t\2\2\2\u012e\u012d\3\2\2\2\u012f"+ 20891 "\u0132\3\2\2\2\u0130\u012e\3\2\2\2\u0130\u0131\3\2\2\2\u0131\u0133\3\2"+ 20892 "\2\2\u0132\u0130\3\2\2\2\u0133\u0134\79\2\2\u0134\t\3\2\2\2\u0135\u0139"+ 20893 "\7f\2\2\u0136\u0138\t\2\2\2\u0137\u0136\3\2\2\2\u0138\u013b\3\2\2\2\u0139"+ 20894 "\u0137\3\2\2\2\u0139\u013a\3\2\2\2\u013a\u013c\3\2\2\2\u013b\u0139\3\2"+ 20895 "\2\2\u013c\u0140\7<\2\2\u013d\u013f\t\2\2\2\u013e\u013d\3\2\2\2\u013f"+ 20896 "\u0142\3\2\2\2\u0140\u013e\3\2\2\2\u0140\u0141\3\2\2\2\u0141\u0146\3\2"+ 20897 "\2\2\u0142\u0140\3\2\2\2\u0143\u0147\7[\2\2\u0144\u0147\5\u0096L\2\u0145"+ 20898 "\u0147\7f\2\2\u0146\u0143\3\2\2\2\u0146\u0144\3\2\2\2\u0146\u0145\3\2"+ 20899 "\2\2\u0147\13\3\2\2\2\u0148\u0152\5\6\4\2\u0149\u0151\5\4\3\2\u014a\u014b"+ 20900 "\6\7\3\2\u014b\u0151\7\3\2\2\u014c\u0151\5\u0094K\2\u014d\u0151\7\b\2"+ 20901 "\2\u014e\u0151\5\u0096L\2\u014f\u0151\5\u0092J\2\u0150\u0149\3\2\2\2\u0150"+ 20902 "\u014a\3\2\2\2\u0150\u014c\3\2\2\2\u0150\u014d\3\2\2\2\u0150\u014e\3\2"+ 20903 "\2\2\u0150\u014f\3\2\2\2\u0151\u0154\3\2\2\2\u0152\u0150\3\2\2\2\u0152"+ 20904 "\u0153\3\2\2\2\u0153\u0155\3\2\2\2\u0154\u0152\3\2\2\2\u0155\u0156\5\b"+ 20905 "\5\2\u0156\u0157\6\7\4\3\u0157\r\3\2\2\2\u0158\u0159\7\7\2\2\u0159\u0160"+ 20906 "\7=\2\2\u015a\u015f\5\n\6\2\u015b\u015f\7\b\2\2\u015c\u015f\7\3\2\2\u015d"+ 20907 "\u015f\7\6\2\2\u015e\u015a\3\2\2\2\u015e\u015b\3\2\2\2\u015e\u015c\3\2"+ 20908 "\2\2\u015e\u015d\3\2\2\2\u015f\u0162\3\2\2\2\u0160\u015e\3\2\2\2\u0160"+ 20909 "\u0161\3\2\2\2\u0161\u0163\3\2\2\2\u0162\u0160\3\2\2\2\u0163\u0164\79"+ 20910 "\2\2\u0164\17\3\2\2\2\u0165\u0166\7\7\2\2\u0166\u0167\7;\2\2\u0167\u016b"+ 20911 "\7=\2\2\u0168\u016a\t\2\2\2\u0169\u0168\3\2\2\2\u016a\u016d\3\2\2\2\u016b"+ 20912 "\u0169\3\2\2\2\u016b\u016c\3\2\2\2\u016c\u016e\3\2\2\2\u016d\u016b\3\2"+ 20913 "\2\2\u016e\u016f\79\2\2\u016f\21\3\2\2\2\u0170\u01a1\5\16\b\2\u0171\u01a0"+ 20914 "\5\f\7\2\u0172\u01a0\5h\65\2\u0173\u01a0\5\30\r\2\u0174\u01a0\5\36\20"+ 20915 "\2\u0175\u01a0\5$\23\2\u0176\u01a0\5*\26\2\u0177\u01a0\5\60\31\2\u0178"+ 20916 "\u01a0\5\66\34\2\u0179\u01a0\5<\37\2\u017a\u01a0\5B\"\2\u017b\u01a0\5"+ 20917 "H%\2\u017c\u01a0\5N(\2\u017d\u01a0\5T+\2\u017e\u01a0\5Z.\2\u017f\u01a0"+ 20918 "\5f\64\2\u0180\u01a0\5`\61\2\u0181\u01a0\5\u00a6T\2\u0182\u01a0\5\u00ac"+ 20919 "W\2\u0183\u01a0\5\u00b2Z\2\u0184\u01a0\5\u00b8]\2\u0185\u01a0\5\u00be"+ 20920 "`\2\u0186\u01a0\5\24\13\2\u0187\u01a0\5\32\16\2\u0188\u01a0\5 \21\2\u0189"+ 20921 "\u01a0\5&\24\2\u018a\u01a0\5,\27\2\u018b\u01a0\5\62\32\2\u018c\u01a0\5"+ 20922 "8\35\2\u018d\u01a0\5> \2\u018e\u01a0\5D#\2\u018f\u01a0\5J&\2\u0190\u01a0"+ 20923 "\5P)\2\u0191\u01a0\5V,\2\u0192\u01a0\5b\62\2\u0193\u01a0\5\\/\2\u0194"+ 20924 "\u01a0\5\u00a2R\2\u0195\u01a0\5\u00a8U\2\u0196\u01a0\5\u00aeX\2\u0197"+ 20925 "\u01a0\5\u00b4[\2\u0198\u01a0\5\u00ba^\2\u0199\u019a\6\n\5\2\u019a\u01a0"+ 20926 "\7\3\2\2\u019b\u01a0\5\u0094K\2\u019c\u01a0\7\b\2\2\u019d\u01a0\5\u0096"+ 20927 "L\2\u019e\u01a0\5\u0092J\2\u019f\u0171\3\2\2\2\u019f\u0172\3\2\2\2\u019f"+ 20928 "\u0173\3\2\2\2\u019f\u0174\3\2\2\2\u019f\u0175\3\2\2\2\u019f\u0176\3\2"+ 20929 "\2\2\u019f\u0177\3\2\2\2\u019f\u0178\3\2\2\2\u019f\u0179\3\2\2\2\u019f"+ 20930 "\u017a\3\2\2\2\u019f\u017b\3\2\2\2\u019f\u017c\3\2\2\2\u019f\u017d\3\2"+ 20931 "\2\2\u019f\u017e\3\2\2\2\u019f\u017f\3\2\2\2\u019f\u0180\3\2\2\2\u019f"+ 20932 "\u0181\3\2\2\2\u019f\u0182\3\2\2\2\u019f\u0183\3\2\2\2\u019f\u0184\3\2"+ 20933 "\2\2\u019f\u0185\3\2\2\2\u019f\u0186\3\2\2\2\u019f\u0187\3\2\2\2\u019f"+ 20934 "\u0188\3\2\2\2\u019f\u0189\3\2\2\2\u019f\u018a\3\2\2\2\u019f\u018b\3\2"+ 20935 "\2\2\u019f\u018c\3\2\2\2\u019f\u018d\3\2\2\2\u019f\u018e\3\2\2\2\u019f"+ 20936 "\u018f\3\2\2\2\u019f\u0190\3\2\2\2\u019f\u0191\3\2\2\2\u019f\u0192\3\2"+ 20937 "\2\2\u019f\u0193\3\2\2\2\u019f\u0194\3\2\2\2\u019f\u0195\3\2\2\2\u019f"+ 20938 "\u0196\3\2\2\2\u019f\u0197\3\2\2\2\u019f\u0198\3\2\2\2\u019f\u0199\3\2"+ 20939 "\2\2\u019f\u019b\3\2\2\2\u019f\u019c\3\2\2\2\u019f\u019d\3\2\2\2\u019f"+ 20940 "\u019e\3\2\2\2\u01a0\u01a3\3\2\2\2\u01a1\u019f\3\2\2\2\u01a1\u01a2\3\2"+ 20941 "\2\2\u01a2\u01a4\3\2\2\2\u01a3\u01a1\3\2\2\2\u01a4\u01a5\5\20\t\2\u01a5"+ 20942 "\23\3\2\2\2\u01a6\u01a7\7\7\2\2\u01a7\u01ae\7>\2\2\u01a8\u01ad\5\n\6\2"+ 20943 "\u01a9\u01ad\7\b\2\2\u01aa\u01ad\7\3\2\2\u01ab\u01ad\7\6\2\2\u01ac\u01a8"+ 20944 "\3\2\2\2\u01ac\u01a9\3\2\2\2\u01ac\u01aa\3\2\2\2\u01ac\u01ab\3\2\2\2\u01ad"+ 20945 "\u01b0\3\2\2\2\u01ae\u01ac\3\2\2\2\u01ae\u01af\3\2\2\2\u01af\u01b1\3\2"+ 20946 "\2\2\u01b0\u01ae\3\2\2\2\u01b1\u01b2\79\2\2\u01b2\25\3\2\2\2\u01b3\u01b4"+ 20947 "\7\7\2\2\u01b4\u01b5\7;\2\2\u01b5\u01b9\7>\2\2\u01b6\u01b8\t\2\2\2\u01b7"+ 20948 "\u01b6\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9\u01b7\3\2\2\2\u01b9\u01ba\3\2"+ 20949 "\2\2\u01ba\u01bc\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bc\u01bd\79\2\2\u01bd"+ 20950 "\27\3\2\2\2\u01be\u01ef\5\24\13\2\u01bf\u01ee\5\f\7\2\u01c0\u01ee\5h\65"+ 20951 "\2\u01c1\u01ee\5\22\n\2\u01c2\u01ee\5\36\20\2\u01c3\u01ee\5$\23\2\u01c4"+ 20952 "\u01ee\5*\26\2\u01c5\u01ee\5\60\31\2\u01c6\u01ee\5\66\34\2\u01c7\u01ee"+ 20953 "\5<\37\2\u01c8\u01ee\5B\"\2\u01c9\u01ee\5H%\2\u01ca\u01ee\5N(\2\u01cb"+ 20954 "\u01ee\5T+\2\u01cc\u01ee\5Z.\2\u01cd\u01ee\5f\64\2\u01ce\u01ee\5`\61\2"+ 20955 "\u01cf\u01ee\5\u00a6T\2\u01d0\u01ee\5\u00acW\2\u01d1\u01ee\5\u00b2Z\2"+ 20956 "\u01d2\u01ee\5\u00b8]\2\u01d3\u01ee\5\u00be`\2\u01d4\u01ee\5\16\b\2\u01d5"+ 20957 "\u01ee\5\32\16\2\u01d6\u01ee\5 \21\2\u01d7\u01ee\5&\24\2\u01d8\u01ee\5"+ 20958 ",\27\2\u01d9\u01ee\5\62\32\2\u01da\u01ee\58\35\2\u01db\u01ee\5> \2\u01dc"+ 20959 "\u01ee\5D#\2\u01dd\u01ee\5J&\2\u01de\u01ee\5P)\2\u01df\u01ee\5V,\2\u01e0"+ 20960 "\u01ee\5b\62\2\u01e1\u01ee\5\\/\2\u01e2\u01ee\5\u00a2R\2\u01e3\u01ee\5"+ 20961 "\u00a8U\2\u01e4\u01ee\5\u00aeX\2\u01e5\u01ee\5\u00b4[\2\u01e6\u01ee\5"+ 20962 "\u00ba^\2\u01e7\u01e8\6\r\6\2\u01e8\u01ee\7\3\2\2\u01e9\u01ee\5\u0094"+ 20963 "K\2\u01ea\u01ee\7\b\2\2\u01eb\u01ee\5\u0096L\2\u01ec\u01ee\5\u0092J\2"+ 20964 "\u01ed\u01bf\3\2\2\2\u01ed\u01c0\3\2\2\2\u01ed\u01c1\3\2\2\2\u01ed\u01c2"+ 20965 "\3\2\2\2\u01ed\u01c3\3\2\2\2\u01ed\u01c4\3\2\2\2\u01ed\u01c5\3\2\2\2\u01ed"+ 20966 "\u01c6\3\2\2\2\u01ed\u01c7\3\2\2\2\u01ed\u01c8\3\2\2\2\u01ed\u01c9\3\2"+ 20967 "\2\2\u01ed\u01ca\3\2\2\2\u01ed\u01cb\3\2\2\2\u01ed\u01cc\3\2\2\2\u01ed"+ 20968 "\u01cd\3\2\2\2\u01ed\u01ce\3\2\2\2\u01ed\u01cf\3\2\2\2\u01ed\u01d0\3\2"+ 20969 "\2\2\u01ed\u01d1\3\2\2\2\u01ed\u01d2\3\2\2\2\u01ed\u01d3\3\2\2\2\u01ed"+ 20970 "\u01d4\3\2\2\2\u01ed\u01d5\3\2\2\2\u01ed\u01d6\3\2\2\2\u01ed\u01d7\3\2"+ 20971 "\2\2\u01ed\u01d8\3\2\2\2\u01ed\u01d9\3\2\2\2\u01ed\u01da\3\2\2\2\u01ed"+ 20972 "\u01db\3\2\2\2\u01ed\u01dc\3\2\2\2\u01ed\u01dd\3\2\2\2\u01ed\u01de\3\2"+ 20973 "\2\2\u01ed\u01df\3\2\2\2\u01ed\u01e0\3\2\2\2\u01ed\u01e1\3\2\2\2\u01ed"+ 20974 "\u01e2\3\2\2\2\u01ed\u01e3\3\2\2\2\u01ed\u01e4\3\2\2\2\u01ed\u01e5\3\2"+ 20975 "\2\2\u01ed\u01e6\3\2\2\2\u01ed\u01e7\3\2\2\2\u01ed\u01e9\3\2\2\2\u01ed"+ 20976 "\u01ea\3\2\2\2\u01ed\u01eb\3\2\2\2\u01ed\u01ec\3\2\2\2\u01ee\u01f1\3\2"+ 20977 "\2\2\u01ef\u01ed\3\2\2\2\u01ef\u01f0\3\2\2\2\u01f0\u01f2\3\2\2\2\u01f1"+ 20978 "\u01ef\3\2\2\2\u01f2\u01f3\5\26\f\2\u01f3\31\3\2\2\2\u01f4\u01f5\7\7\2"+ 20979 "\2\u01f5\u01fc\7?\2\2\u01f6\u01fb\5\n\6\2\u01f7\u01fb\7\b\2\2\u01f8\u01fb"+ 20980 "\7\3\2\2\u01f9\u01fb\7\6\2\2\u01fa\u01f6\3\2\2\2\u01fa\u01f7\3\2\2\2\u01fa"+ 20981 "\u01f8\3\2\2\2\u01fa\u01f9\3\2\2\2\u01fb\u01fe\3\2\2\2\u01fc\u01fa\3\2"+ 20982 "\2\2\u01fc\u01fd\3\2\2\2\u01fd\u01ff\3\2\2\2\u01fe\u01fc\3\2\2\2\u01ff"+ 20983 "\u0200\79\2\2\u0200\33\3\2\2\2\u0201\u0202\7\7\2\2\u0202\u0203\7;\2\2"+ 20984 "\u0203\u0207\7?\2\2\u0204\u0206\t\2\2\2\u0205\u0204\3\2\2\2\u0206\u0209"+ 20985 "\3\2\2\2\u0207\u0205\3\2\2\2\u0207\u0208\3\2\2\2\u0208\u020a\3\2\2\2\u0209"+ 20986 "\u0207\3\2\2\2\u020a\u020b\79\2\2\u020b\35\3\2\2\2\u020c\u023d\5\32\16"+ 20987 "\2\u020d\u023c\5\f\7\2\u020e\u023c\5h\65\2\u020f\u023c\5\22\n\2\u0210"+ 20988 "\u023c\5\30\r\2\u0211\u023c\5$\23\2\u0212\u023c\5*\26\2\u0213\u023c\5"+ 20989 "\60\31\2\u0214\u023c\5\66\34\2\u0215\u023c\5<\37\2\u0216\u023c\5B\"\2"+ 20990 "\u0217\u023c\5H%\2\u0218\u023c\5N(\2\u0219\u023c\5T+\2\u021a\u023c\5Z"+ 20991 ".\2\u021b\u023c\5f\64\2\u021c\u023c\5`\61\2\u021d\u023c\5\u00a6T\2\u021e"+ 20992 "\u023c\5\u00acW\2\u021f\u023c\5\u00b2Z\2\u0220\u023c\5\u00b8]\2\u0221"+ 20993 "\u023c\5\u00be`\2\u0222\u023c\5\16\b\2\u0223\u023c\5\24\13\2\u0224\u023c"+ 20994 "\5 \21\2\u0225\u023c\5&\24\2\u0226\u023c\5,\27\2\u0227\u023c\5\62\32\2"+ 20995 "\u0228\u023c\58\35\2\u0229\u023c\5> \2\u022a\u023c\5D#\2\u022b\u023c\5"+ 20996 "J&\2\u022c\u023c\5P)\2\u022d\u023c\5V,\2\u022e\u023c\5b\62\2\u022f\u023c"+ 20997 "\5\\/\2\u0230\u023c\5\u00a2R\2\u0231\u023c\5\u00a8U\2\u0232\u023c\5\u00ae"+ 20998 "X\2\u0233\u023c\5\u00b4[\2\u0234\u023c\5\u00ba^\2\u0235\u0236\6\20\7\2"+ 20999 "\u0236\u023c\7\3\2\2\u0237\u023c\5\u0094K\2\u0238\u023c\7\b\2\2\u0239"+ 21000 "\u023c\5\u0096L\2\u023a\u023c\5\u0092J\2\u023b\u020d\3\2\2\2\u023b\u020e"+ 21001 "\3\2\2\2\u023b\u020f\3\2\2\2\u023b\u0210\3\2\2\2\u023b\u0211\3\2\2\2\u023b"+ 21002 "\u0212\3\2\2\2\u023b\u0213\3\2\2\2\u023b\u0214\3\2\2\2\u023b\u0215\3\2"+ 21003 "\2\2\u023b\u0216\3\2\2\2\u023b\u0217\3\2\2\2\u023b\u0218\3\2\2\2\u023b"+ 21004 "\u0219\3\2\2\2\u023b\u021a\3\2\2\2\u023b\u021b\3\2\2\2\u023b\u021c\3\2"+ 21005 "\2\2\u023b\u021d\3\2\2\2\u023b\u021e\3\2\2\2\u023b\u021f\3\2\2\2\u023b"+ 21006 "\u0220\3\2\2\2\u023b\u0221\3\2\2\2\u023b\u0222\3\2\2\2\u023b\u0223\3\2"+ 21007 "\2\2\u023b\u0224\3\2\2\2\u023b\u0225\3\2\2\2\u023b\u0226\3\2\2\2\u023b"+ 21008 "\u0227\3\2\2\2\u023b\u0228\3\2\2\2\u023b\u0229\3\2\2\2\u023b\u022a\3\2"+ 21009 "\2\2\u023b\u022b\3\2\2\2\u023b\u022c\3\2\2\2\u023b\u022d\3\2\2\2\u023b"+ 21010 "\u022e\3\2\2\2\u023b\u022f\3\2\2\2\u023b\u0230\3\2\2\2\u023b\u0231\3\2"+ 21011 "\2\2\u023b\u0232\3\2\2\2\u023b\u0233\3\2\2\2\u023b\u0234\3\2\2\2\u023b"+ 21012 "\u0235\3\2\2\2\u023b\u0237\3\2\2\2\u023b\u0238\3\2\2\2\u023b\u0239\3\2"+ 21013 "\2\2\u023b\u023a\3\2\2\2\u023c\u023f\3\2\2\2\u023d\u023b\3\2\2\2\u023d"+ 21014 "\u023e\3\2\2\2\u023e\u0240\3\2\2\2\u023f\u023d\3\2\2\2\u0240\u0241\5\34"+ 21015 "\17\2\u0241\37\3\2\2\2\u0242\u0243\7\7\2\2\u0243\u024a\7@\2\2\u0244\u0249"+ 21016 "\5\n\6\2\u0245\u0249\7\b\2\2\u0246\u0249\7\3\2\2\u0247\u0249\7\6\2\2\u0248"+ 21017 "\u0244\3\2\2\2\u0248\u0245\3\2\2\2\u0248\u0246\3\2\2\2\u0248\u0247\3\2"+ 21018 "\2\2\u0249\u024c\3\2\2\2\u024a\u0248\3\2\2\2\u024a\u024b\3\2\2\2\u024b"+ 21019 "\u024d\3\2\2\2\u024c\u024a\3\2\2\2\u024d\u024e\79\2\2\u024e!\3\2\2\2\u024f"+ 21020 "\u0250\7\7\2\2\u0250\u0251\7;\2\2\u0251\u0255\7@\2\2\u0252\u0254\t\2\2"+ 21021 "\2\u0253\u0252\3\2\2\2\u0254\u0257\3\2\2\2\u0255\u0253\3\2\2\2\u0255\u0256"+ 21022 "\3\2\2\2\u0256\u0258\3\2\2\2\u0257\u0255\3\2\2\2\u0258\u0259\79\2\2\u0259"+ 21023 "#\3\2\2\2\u025a\u028b\5 \21\2\u025b\u028a\5\f\7\2\u025c\u028a\5h\65\2"+ 21024 "\u025d\u028a\5\22\n\2\u025e\u028a\5\30\r\2\u025f\u028a\5\36\20\2\u0260"+ 21025 "\u028a\5*\26\2\u0261\u028a\5\60\31\2\u0262\u028a\5\66\34\2\u0263\u028a"+ 21026 "\5<\37\2\u0264\u028a\5B\"\2\u0265\u028a\5H%\2\u0266\u028a\5N(\2\u0267"+ 21027 "\u028a\5T+\2\u0268\u028a\5Z.\2\u0269\u028a\5f\64\2\u026a\u028a\5`\61\2"+ 21028 "\u026b\u028a\5\u00a6T\2\u026c\u028a\5\u00acW\2\u026d\u028a\5\u00b2Z\2"+ 21029 "\u026e\u028a\5\u00b8]\2\u026f\u028a\5\u00be`\2\u0270\u028a\5\16\b\2\u0271"+ 21030 "\u028a\5\24\13\2\u0272\u028a\5 \21\2\u0273\u028a\5&\24\2\u0274\u028a\5"+ 21031 ",\27\2\u0275\u028a\5\62\32\2\u0276\u028a\58\35\2\u0277\u028a\5> \2\u0278"+ 21032 "\u028a\5D#\2\u0279\u028a\5J&\2\u027a\u028a\5P)\2\u027b\u028a\5V,\2\u027c"+ 21033 "\u028a\5b\62\2\u027d\u028a\5\\/\2\u027e\u028a\5\u00a2R\2\u027f\u028a\5"+ 21034 "\u00a8U\2\u0280\u028a\5\u00aeX\2\u0281\u028a\5\u00b4[\2\u0282\u028a\5"+ 21035 "\u00ba^\2\u0283\u0284\6\23\b\2\u0284\u028a\7\3\2\2\u0285\u028a\5\u0094"+ 21036 "K\2\u0286\u028a\7\b\2\2\u0287\u028a\5\u0096L\2\u0288\u028a\5\u0092J\2"+ 21037 "\u0289\u025b\3\2\2\2\u0289\u025c\3\2\2\2\u0289\u025d\3\2\2\2\u0289\u025e"+ 21038 "\3\2\2\2\u0289\u025f\3\2\2\2\u0289\u0260\3\2\2\2\u0289\u0261\3\2\2\2\u0289"+ 21039 "\u0262\3\2\2\2\u0289\u0263\3\2\2\2\u0289\u0264\3\2\2\2\u0289\u0265\3\2"+ 21040 "\2\2\u0289\u0266\3\2\2\2\u0289\u0267\3\2\2\2\u0289\u0268\3\2\2\2\u0289"+ 21041 "\u0269\3\2\2\2\u0289\u026a\3\2\2\2\u0289\u026b\3\2\2\2\u0289\u026c\3\2"+ 21042 "\2\2\u0289\u026d\3\2\2\2\u0289\u026e\3\2\2\2\u0289\u026f\3\2\2\2\u0289"+ 21043 "\u0270\3\2\2\2\u0289\u0271\3\2\2\2\u0289\u0272\3\2\2\2\u0289\u0273\3\2"+ 21044 "\2\2\u0289\u0274\3\2\2\2\u0289\u0275\3\2\2\2\u0289\u0276\3\2\2\2\u0289"+ 21045 "\u0277\3\2\2\2\u0289\u0278\3\2\2\2\u0289\u0279\3\2\2\2\u0289\u027a\3\2"+ 21046 "\2\2\u0289\u027b\3\2\2\2\u0289\u027c\3\2\2\2\u0289\u027d\3\2\2\2\u0289"+ 21047 "\u027e\3\2\2\2\u0289\u027f\3\2\2\2\u0289\u0280\3\2\2\2\u0289\u0281\3\2"+ 21048 "\2\2\u0289\u0282\3\2\2\2\u0289\u0283\3\2\2\2\u0289\u0285\3\2\2\2\u0289"+ 21049 "\u0286\3\2\2\2\u0289\u0287\3\2\2\2\u0289\u0288\3\2\2\2\u028a\u028d\3\2"+ 21050 "\2\2\u028b\u0289\3\2\2\2\u028b\u028c\3\2\2\2\u028c\u028e\3\2\2\2\u028d"+ 21051 "\u028b\3\2\2\2\u028e\u028f\5\"\22\2\u028f%\3\2\2\2\u0290\u0291\7\7\2\2"+ 21052 "\u0291\u0298\7A\2\2\u0292\u0297\5\n\6\2\u0293\u0297\7\b\2\2\u0294\u0297"+ 21053 "\7\3\2\2\u0295\u0297\7\6\2\2\u0296\u0292\3\2\2\2\u0296\u0293\3\2\2\2\u0296"+ 21054 "\u0294\3\2\2\2\u0296\u0295\3\2\2\2\u0297\u029a\3\2\2\2\u0298\u0296\3\2"+ 21055 "\2\2\u0298\u0299\3\2\2\2\u0299\u029b\3\2\2\2\u029a\u0298\3\2\2\2\u029b"+ 21056 "\u029c\79\2\2\u029c\'\3\2\2\2\u029d\u029e\7\7\2\2\u029e\u029f\7;\2\2\u029f"+ 21057 "\u02a3\7A\2\2\u02a0\u02a2\t\2\2\2\u02a1\u02a0\3\2\2\2\u02a2\u02a5\3\2"+ 21058 "\2\2\u02a3\u02a1\3\2\2\2\u02a3\u02a4\3\2\2\2\u02a4\u02a6\3\2\2\2\u02a5"+ 21059 "\u02a3\3\2\2\2\u02a6\u02a7\79\2\2\u02a7)\3\2\2\2\u02a8\u02d9\5&\24\2\u02a9"+ 21060 "\u02d8\5\f\7\2\u02aa\u02d8\5h\65\2\u02ab\u02d8\5\22\n\2\u02ac\u02d8\5"+ 21061 "\30\r\2\u02ad\u02d8\5\36\20\2\u02ae\u02d8\5$\23\2\u02af\u02d8\5\60\31"+ 21062 "\2\u02b0\u02d8\5\66\34\2\u02b1\u02d8\5<\37\2\u02b2\u02d8\5B\"\2\u02b3"+ 21063 "\u02d8\5H%\2\u02b4\u02d8\5N(\2\u02b5\u02d8\5T+\2\u02b6\u02d8\5Z.\2\u02b7"+ 21064 "\u02d8\5f\64\2\u02b8\u02d8\5`\61\2\u02b9\u02d8\5\u00a6T\2\u02ba\u02d8"+ 21065 "\5\u00acW\2\u02bb\u02d8\5\u00b2Z\2\u02bc\u02d8\5\u00b8]\2\u02bd\u02d8"+ 21066 "\5\u00be`\2\u02be\u02d8\5\16\b\2\u02bf\u02d8\5\24\13\2\u02c0\u02d8\5\32"+ 21067 "\16\2\u02c1\u02d8\5 \21\2\u02c2\u02d8\5,\27\2\u02c3\u02d8\5\62\32\2\u02c4"+ 21068 "\u02d8\58\35\2\u02c5\u02d8\5> \2\u02c6\u02d8\5D#\2\u02c7\u02d8\5J&\2\u02c8"+ 21069 "\u02d8\5P)\2\u02c9\u02d8\5V,\2\u02ca\u02d8\5b\62\2\u02cb\u02d8\5\\/\2"+ 21070 "\u02cc\u02d8\5\u00a2R\2\u02cd\u02d8\5\u00a8U\2\u02ce\u02d8\5\u00aeX\2"+ 21071 "\u02cf\u02d8\5\u00b4[\2\u02d0\u02d8\5\u00ba^\2\u02d1\u02d2\6\26\t\2\u02d2"+ 21072 "\u02d8\7\3\2\2\u02d3\u02d8\5\u0094K\2\u02d4\u02d8\7\b\2\2\u02d5\u02d8"+ 21073 "\5\u0096L\2\u02d6\u02d8\5\u0092J\2\u02d7\u02a9\3\2\2\2\u02d7\u02aa\3\2"+ 21074 "\2\2\u02d7\u02ab\3\2\2\2\u02d7\u02ac\3\2\2\2\u02d7\u02ad\3\2\2\2\u02d7"+ 21075 "\u02ae\3\2\2\2\u02d7\u02af\3\2\2\2\u02d7\u02b0\3\2\2\2\u02d7\u02b1\3\2"+ 21076 "\2\2\u02d7\u02b2\3\2\2\2\u02d7\u02b3\3\2\2\2\u02d7\u02b4\3\2\2\2\u02d7"+ 21077 "\u02b5\3\2\2\2\u02d7\u02b6\3\2\2\2\u02d7\u02b7\3\2\2\2\u02d7\u02b8\3\2"+ 21078 "\2\2\u02d7\u02b9\3\2\2\2\u02d7\u02ba\3\2\2\2\u02d7\u02bb\3\2\2\2\u02d7"+ 21079 "\u02bc\3\2\2\2\u02d7\u02bd\3\2\2\2\u02d7\u02be\3\2\2\2\u02d7\u02bf\3\2"+ 21080 "\2\2\u02d7\u02c0\3\2\2\2\u02d7\u02c1\3\2\2\2\u02d7\u02c2\3\2\2\2\u02d7"+ 21081 "\u02c3\3\2\2\2\u02d7\u02c4\3\2\2\2\u02d7\u02c5\3\2\2\2\u02d7\u02c6\3\2"+ 21082 "\2\2\u02d7\u02c7\3\2\2\2\u02d7\u02c8\3\2\2\2\u02d7\u02c9\3\2\2\2\u02d7"+ 21083 "\u02ca\3\2\2\2\u02d7\u02cb\3\2\2\2\u02d7\u02cc\3\2\2\2\u02d7\u02cd\3\2"+ 21084 "\2\2\u02d7\u02ce\3\2\2\2\u02d7\u02cf\3\2\2\2\u02d7\u02d0\3\2\2\2\u02d7"+ 21085 "\u02d1\3\2\2\2\u02d7\u02d3\3\2\2\2\u02d7\u02d4\3\2\2\2\u02d7\u02d5\3\2"+ 21086 "\2\2\u02d7\u02d6\3\2\2\2\u02d8\u02db\3\2\2\2\u02d9\u02d7\3\2\2\2\u02d9"+ 21087 "\u02da\3\2\2\2\u02da\u02dc\3\2\2\2\u02db\u02d9\3\2\2\2\u02dc\u02dd\5("+ 21088 "\25\2\u02dd+\3\2\2\2\u02de\u02df\7\7\2\2\u02df\u02e6\7B\2\2\u02e0\u02e5"+ 21089 "\5\n\6\2\u02e1\u02e5\7\b\2\2\u02e2\u02e5\7\3\2\2\u02e3\u02e5\7\6\2\2\u02e4"+ 21090 "\u02e0\3\2\2\2\u02e4\u02e1\3\2\2\2\u02e4\u02e2\3\2\2\2\u02e4\u02e3\3\2"+ 21091 "\2\2\u02e5\u02e8\3\2\2\2\u02e6\u02e4\3\2\2\2\u02e6\u02e7\3\2\2\2\u02e7"+ 21092 "\u02e9\3\2\2\2\u02e8\u02e6\3\2\2\2\u02e9\u02ea\79\2\2\u02ea-\3\2\2\2\u02eb"+ 21093 "\u02ec\7\7\2\2\u02ec\u02ed\7;\2\2\u02ed\u02f1\7B\2\2\u02ee\u02f0\t\2\2"+ 21094 "\2\u02ef\u02ee\3\2\2\2\u02f0\u02f3\3\2\2\2\u02f1\u02ef\3\2\2\2\u02f1\u02f2"+ 21095 "\3\2\2\2\u02f2\u02f4\3\2\2\2\u02f3\u02f1\3\2\2\2\u02f4\u02f5\79\2\2\u02f5"+ 21096 "/\3\2\2\2\u02f6\u0327\5,\27\2\u02f7\u0326\5\f\7\2\u02f8\u0326\5h\65\2"+ 21097 "\u02f9\u0326\5\22\n\2\u02fa\u0326\5\30\r\2\u02fb\u0326\5\36\20\2\u02fc"+ 21098 "\u0326\5$\23\2\u02fd\u0326\5*\26\2\u02fe\u0326\5\66\34\2\u02ff\u0326\5"+ 21099 "<\37\2\u0300\u0326\5B\"\2\u0301\u0326\5H%\2\u0302\u0326\5N(\2\u0303\u0326"+ 21100 "\5T+\2\u0304\u0326\5Z.\2\u0305\u0326\5f\64\2\u0306\u0326\5`\61\2\u0307"+ 21101 "\u0326\5\u00a6T\2\u0308\u0326\5\u00acW\2\u0309\u0326\5\u00b2Z\2\u030a"+ 21102 "\u0326\5\u00b8]\2\u030b\u0326\5\u00be`\2\u030c\u0326\5\16\b\2\u030d\u0326"+ 21103 "\5\24\13\2\u030e\u0326\5\32\16\2\u030f\u0326\5 \21\2\u0310\u0326\5&\24"+ 21104 "\2\u0311\u0326\5\62\32\2\u0312\u0326\58\35\2\u0313\u0326\5> \2\u0314\u0326"+ 21105 "\5D#\2\u0315\u0326\5J&\2\u0316\u0326\5P)\2\u0317\u0326\5V,\2\u0318\u0326"+ 21106 "\5b\62\2\u0319\u0326\5\\/\2\u031a\u0326\5\u00a2R\2\u031b\u0326\5\u00a8"+ 21107 "U\2\u031c\u0326\5\u00aeX\2\u031d\u0326\5\u00b4[\2\u031e\u0326\5\u00ba"+ 21108 "^\2\u031f\u0320\6\31\n\2\u0320\u0326\7\3\2\2\u0321\u0326\5\u0094K\2\u0322"+ 21109 "\u0326\7\b\2\2\u0323\u0326\5\u0096L\2\u0324\u0326\5\u0092J\2\u0325\u02f7"+ 21110 "\3\2\2\2\u0325\u02f8\3\2\2\2\u0325\u02f9\3\2\2\2\u0325\u02fa\3\2\2\2\u0325"+ 21111 "\u02fb\3\2\2\2\u0325\u02fc\3\2\2\2\u0325\u02fd\3\2\2\2\u0325\u02fe\3\2"+ 21112 "\2\2\u0325\u02ff\3\2\2\2\u0325\u0300\3\2\2\2\u0325\u0301\3\2\2\2\u0325"+ 21113 "\u0302\3\2\2\2\u0325\u0303\3\2\2\2\u0325\u0304\3\2\2\2\u0325\u0305\3\2"+ 21114 "\2\2\u0325\u0306\3\2\2\2\u0325\u0307\3\2\2\2\u0325\u0308\3\2\2\2\u0325"+ 21115 "\u0309\3\2\2\2\u0325\u030a\3\2\2\2\u0325\u030b\3\2\2\2\u0325\u030c\3\2"+ 21116 "\2\2\u0325\u030d\3\2\2\2\u0325\u030e\3\2\2\2\u0325\u030f\3\2\2\2\u0325"+ 21117 "\u0310\3\2\2\2\u0325\u0311\3\2\2\2\u0325\u0312\3\2\2\2\u0325\u0313\3\2"+ 21118 "\2\2\u0325\u0314\3\2\2\2\u0325\u0315\3\2\2\2\u0325\u0316\3\2\2\2\u0325"+ 21119 "\u0317\3\2\2\2\u0325\u0318\3\2\2\2\u0325\u0319\3\2\2\2\u0325\u031a\3\2"+ 21120 "\2\2\u0325\u031b\3\2\2\2\u0325\u031c\3\2\2\2\u0325\u031d\3\2\2\2\u0325"+ 21121 "\u031e\3\2\2\2\u0325\u031f\3\2\2\2\u0325\u0321\3\2\2\2\u0325\u0322\3\2"+ 21122 "\2\2\u0325\u0323\3\2\2\2\u0325\u0324\3\2\2\2\u0326\u0329\3\2\2\2\u0327"+ 21123 "\u0325\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u032a\3\2\2\2\u0329\u0327\3\2"+ 21124 "\2\2\u032a\u032b\5.\30\2\u032b\61\3\2\2\2\u032c\u032d\7\7\2\2\u032d\u0334"+ 21125 "\7C\2\2\u032e\u0333\5\n\6\2\u032f\u0333\7\b\2\2\u0330\u0333\7\3\2\2\u0331"+ 21126 "\u0333\7\6\2\2\u0332\u032e\3\2\2\2\u0332\u032f\3\2\2\2\u0332\u0330\3\2"+ 21127 "\2\2\u0332\u0331\3\2\2\2\u0333\u0336\3\2\2\2\u0334\u0332\3\2\2\2\u0334"+ 21128 "\u0335\3\2\2\2\u0335\u0337\3\2\2\2\u0336\u0334\3\2\2\2\u0337\u0338\79"+ 21129 "\2\2\u0338\63\3\2\2\2\u0339\u033a\7\7\2\2\u033a\u033b\7;\2\2\u033b\u033f"+ 21130 "\7C\2\2\u033c\u033e\t\2\2\2\u033d\u033c\3\2\2\2\u033e\u0341\3\2\2\2\u033f"+ 21131 "\u033d\3\2\2\2\u033f\u0340\3\2\2\2\u0340\u0342\3\2\2\2\u0341\u033f\3\2"+ 21132 "\2\2\u0342\u0343\79\2\2\u0343\65\3\2\2\2\u0344\u0375\5\62\32\2\u0345\u0374"+ 21133 "\5\f\7\2\u0346\u0374\5h\65\2\u0347\u0374\5\22\n\2\u0348\u0374\5\30\r\2"+ 21134 "\u0349\u0374\5\36\20\2\u034a\u0374\5$\23\2\u034b\u0374\5*\26\2\u034c\u0374"+ 21135 "\5\60\31\2\u034d\u0374\5<\37\2\u034e\u0374\5B\"\2\u034f\u0374\5H%\2\u0350"+ 21136 "\u0374\5N(\2\u0351\u0374\5T+\2\u0352\u0374\5Z.\2\u0353\u0374\5f\64\2\u0354"+ 21137 "\u0374\5`\61\2\u0355\u0374\5\u00a6T\2\u0356\u0374\5\u00acW\2\u0357\u0374"+ 21138 "\5\u00b2Z\2\u0358\u0374\5\u00b8]\2\u0359\u0374\5\u00be`\2\u035a\u0374"+ 21139 "\5\16\b\2\u035b\u0374\5\24\13\2\u035c\u0374\5\32\16\2\u035d\u0374\5 \21"+ 21140 "\2\u035e\u0374\5&\24\2\u035f\u0374\5,\27\2\u0360\u0374\58\35\2\u0361\u0374"+ 21141 "\5> \2\u0362\u0374\5D#\2\u0363\u0374\5J&\2\u0364\u0374\5P)\2\u0365\u0374"+ 21142 "\5V,\2\u0366\u0374\5b\62\2\u0367\u0374\5\\/\2\u0368\u0374\5\u00a2R\2\u0369"+ 21143 "\u0374\5\u00a8U\2\u036a\u0374\5\u00aeX\2\u036b\u0374\5\u00b4[\2\u036c"+ 21144 "\u0374\5\u00ba^\2\u036d\u036e\6\34\13\2\u036e\u0374\7\3\2\2\u036f\u0374"+ 21145 "\5\u0094K\2\u0370\u0374\7\b\2\2\u0371\u0374\5\u0096L\2\u0372\u0374\5\u0092"+ 21146 "J\2\u0373\u0345\3\2\2\2\u0373\u0346\3\2\2\2\u0373\u0347\3\2\2\2\u0373"+ 21147 "\u0348\3\2\2\2\u0373\u0349\3\2\2\2\u0373\u034a\3\2\2\2\u0373\u034b\3\2"+ 21148 "\2\2\u0373\u034c\3\2\2\2\u0373\u034d\3\2\2\2\u0373\u034e\3\2\2\2\u0373"+ 21149 "\u034f\3\2\2\2\u0373\u0350\3\2\2\2\u0373\u0351\3\2\2\2\u0373\u0352\3\2"+ 21150 "\2\2\u0373\u0353\3\2\2\2\u0373\u0354\3\2\2\2\u0373\u0355\3\2\2\2\u0373"+ 21151 "\u0356\3\2\2\2\u0373\u0357\3\2\2\2\u0373\u0358\3\2\2\2\u0373\u0359\3\2"+ 21152 "\2\2\u0373\u035a\3\2\2\2\u0373\u035b\3\2\2\2\u0373\u035c\3\2\2\2\u0373"+ 21153 "\u035d\3\2\2\2\u0373\u035e\3\2\2\2\u0373\u035f\3\2\2\2\u0373\u0360\3\2"+ 21154 "\2\2\u0373\u0361\3\2\2\2\u0373\u0362\3\2\2\2\u0373\u0363\3\2\2\2\u0373"+ 21155 "\u0364\3\2\2\2\u0373\u0365\3\2\2\2\u0373\u0366\3\2\2\2\u0373\u0367\3\2"+ 21156 "\2\2\u0373\u0368\3\2\2\2\u0373\u0369\3\2\2\2\u0373\u036a\3\2\2\2\u0373"+ 21157 "\u036b\3\2\2\2\u0373\u036c\3\2\2\2\u0373\u036d\3\2\2\2\u0373\u036f\3\2"+ 21158 "\2\2\u0373\u0370\3\2\2\2\u0373\u0371\3\2\2\2\u0373\u0372\3\2\2\2\u0374"+ 21159 "\u0377\3\2\2\2\u0375\u0373\3\2\2\2\u0375\u0376\3\2\2\2\u0376\u0378\3\2"+ 21160 "\2\2\u0377\u0375\3\2\2\2\u0378\u0379\5\64\33\2\u0379\67\3\2\2\2\u037a"+ 21161 "\u037b\7\7\2\2\u037b\u0382\7D\2\2\u037c\u0381\5\n\6\2\u037d\u0381\7\b"+ 21162 "\2\2\u037e\u0381\7\3\2\2\u037f\u0381\7\6\2\2\u0380\u037c\3\2\2\2\u0380"+ 21163 "\u037d\3\2\2\2\u0380\u037e\3\2\2\2\u0380\u037f\3\2\2\2\u0381\u0384\3\2"+ 21164 "\2\2\u0382\u0380\3\2\2\2\u0382\u0383\3\2\2\2\u0383\u0385\3\2\2\2\u0384"+ 21165 "\u0382\3\2\2\2\u0385\u0386\79\2\2\u03869\3\2\2\2\u0387\u0388\7\7\2\2\u0388"+ 21166 "\u0389\7;\2\2\u0389\u038d\7D\2\2\u038a\u038c\t\2\2\2\u038b\u038a\3\2\2"+ 21167 "\2\u038c\u038f\3\2\2\2\u038d\u038b\3\2\2\2\u038d\u038e\3\2\2\2\u038e\u0390"+ 21168 "\3\2\2\2\u038f\u038d\3\2\2\2\u0390\u0391\79\2\2\u0391;\3\2\2\2\u0392\u03c3"+ 21169 "\58\35\2\u0393\u03c2\5\f\7\2\u0394\u03c2\5h\65\2\u0395\u03c2\5\22\n\2"+ 21170 "\u0396\u03c2\5\30\r\2\u0397\u03c2\5\36\20\2\u0398\u03c2\5$\23\2\u0399"+ 21171 "\u03c2\5*\26\2\u039a\u03c2\5\60\31\2\u039b\u03c2\5\66\34\2\u039c\u03c2"+ 21172 "\5B\"\2\u039d\u03c2\5H%\2\u039e\u03c2\5N(\2\u039f\u03c2\5T+\2\u03a0\u03c2"+ 21173 "\5Z.\2\u03a1\u03c2\5f\64\2\u03a2\u03c2\5`\61\2\u03a3\u03c2\5\u00a6T\2"+ 21174 "\u03a4\u03c2\5\u00acW\2\u03a5\u03c2\5\u00b2Z\2\u03a6\u03c2\5\u00b8]\2"+ 21175 "\u03a7\u03c2\5\u00be`\2\u03a8\u03c2\5\16\b\2\u03a9\u03c2\5\24\13\2\u03aa"+ 21176 "\u03c2\5\32\16\2\u03ab\u03c2\5 \21\2\u03ac\u03c2\5&\24\2\u03ad\u03c2\5"+ 21177 ",\27\2\u03ae\u03c2\5\62\32\2\u03af\u03c2\5> \2\u03b0\u03c2\5D#\2\u03b1"+ 21178 "\u03c2\5J&\2\u03b2\u03c2\5P)\2\u03b3\u03c2\5V,\2\u03b4\u03c2\5b\62\2\u03b5"+ 21179 "\u03c2\5\\/\2\u03b6\u03c2\5\u00a2R\2\u03b7\u03c2\5\u00a8U\2\u03b8\u03c2"+ 21180 "\5\u00aeX\2\u03b9\u03c2\5\u00b4[\2\u03ba\u03c2\5\u00ba^\2\u03bb\u03bc"+ 21181 "\6\37\f\2\u03bc\u03c2\7\3\2\2\u03bd\u03c2\5\u0094K\2\u03be\u03c2\7\b\2"+ 21182 "\2\u03bf\u03c2\5\u0096L\2\u03c0\u03c2\5\u0092J\2\u03c1\u0393\3\2\2\2\u03c1"+ 21183 "\u0394\3\2\2\2\u03c1\u0395\3\2\2\2\u03c1\u0396\3\2\2\2\u03c1\u0397\3\2"+ 21184 "\2\2\u03c1\u0398\3\2\2\2\u03c1\u0399\3\2\2\2\u03c1\u039a\3\2\2\2\u03c1"+ 21185 "\u039b\3\2\2\2\u03c1\u039c\3\2\2\2\u03c1\u039d\3\2\2\2\u03c1\u039e\3\2"+ 21186 "\2\2\u03c1\u039f\3\2\2\2\u03c1\u03a0\3\2\2\2\u03c1\u03a1\3\2\2\2\u03c1"+ 21187 "\u03a2\3\2\2\2\u03c1\u03a3\3\2\2\2\u03c1\u03a4\3\2\2\2\u03c1\u03a5\3\2"+ 21188 "\2\2\u03c1\u03a6\3\2\2\2\u03c1\u03a7\3\2\2\2\u03c1\u03a8\3\2\2\2\u03c1"+ 21189 "\u03a9\3\2\2\2\u03c1\u03aa\3\2\2\2\u03c1\u03ab\3\2\2\2\u03c1\u03ac\3\2"+ 21190 "\2\2\u03c1\u03ad\3\2\2\2\u03c1\u03ae\3\2\2\2\u03c1\u03af\3\2\2\2\u03c1"+ 21191 "\u03b0\3\2\2\2\u03c1\u03b1\3\2\2\2\u03c1\u03b2\3\2\2\2\u03c1\u03b3\3\2"+ 21192 "\2\2\u03c1\u03b4\3\2\2\2\u03c1\u03b5\3\2\2\2\u03c1\u03b6\3\2\2\2\u03c1"+ 21193 "\u03b7\3\2\2\2\u03c1\u03b8\3\2\2\2\u03c1\u03b9\3\2\2\2\u03c1\u03ba\3\2"+ 21194 "\2\2\u03c1\u03bb\3\2\2\2\u03c1\u03bd\3\2\2\2\u03c1\u03be\3\2\2\2\u03c1"+ 21195 "\u03bf\3\2\2\2\u03c1\u03c0\3\2\2\2\u03c2\u03c5\3\2\2\2\u03c3\u03c1\3\2"+ 21196 "\2\2\u03c3\u03c4\3\2\2\2\u03c4\u03c6\3\2\2\2\u03c5\u03c3\3\2\2\2\u03c6"+ 21197 "\u03c7\5:\36\2\u03c7=\3\2\2\2\u03c8\u03c9\7\7\2\2\u03c9\u03d0\7E\2\2\u03ca"+ 21198 "\u03cf\5\n\6\2\u03cb\u03cf\7\b\2\2\u03cc\u03cf\7\3\2\2\u03cd\u03cf\7\6"+ 21199 "\2\2\u03ce\u03ca\3\2\2\2\u03ce\u03cb\3\2\2\2\u03ce\u03cc\3\2\2\2\u03ce"+ 21200 "\u03cd\3\2\2\2\u03cf\u03d2\3\2\2\2\u03d0\u03ce\3\2\2\2\u03d0\u03d1\3\2"+ 21201 "\2\2\u03d1\u03d3\3\2\2\2\u03d2\u03d0\3\2\2\2\u03d3\u03d4\79\2\2\u03d4"+ 21202 "?\3\2\2\2\u03d5\u03d6\7\7\2\2\u03d6\u03d7\7;\2\2\u03d7\u03db\7E\2\2\u03d8"+ 21203 "\u03da\t\2\2\2\u03d9\u03d8\3\2\2\2\u03da\u03dd\3\2\2\2\u03db\u03d9\3\2"+ 21204 "\2\2\u03db\u03dc\3\2\2\2\u03dc\u03de\3\2\2\2\u03dd\u03db\3\2\2\2\u03de"+ 21205 "\u03df\79\2\2\u03dfA\3\2\2\2\u03e0\u0411\5> \2\u03e1\u0410\5\f\7\2\u03e2"+ 21206 "\u0410\5h\65\2\u03e3\u0410\5\22\n\2\u03e4\u0410\5\30\r\2\u03e5\u0410\5"+ 21207 "\36\20\2\u03e6\u0410\5$\23\2\u03e7\u0410\5*\26\2\u03e8\u0410\5\60\31\2"+ 21208 "\u03e9\u0410\5\66\34\2\u03ea\u0410\5<\37\2\u03eb\u0410\5H%\2\u03ec\u0410"+ 21209 "\5N(\2\u03ed\u0410\5T+\2\u03ee\u0410\5Z.\2\u03ef\u0410\5f\64\2\u03f0\u0410"+ 21210 "\5`\61\2\u03f1\u0410\5\u00a6T\2\u03f2\u0410\5\u00acW\2\u03f3\u0410\5\u00b2"+ 21211 "Z\2\u03f4\u0410\5\u00b8]\2\u03f5\u0410\5\u00be`\2\u03f6\u0410\5\16\b\2"+ 21212 "\u03f7\u0410\5\24\13\2\u03f8\u0410\5\32\16\2\u03f9\u0410\5 \21\2\u03fa"+ 21213 "\u0410\5&\24\2\u03fb\u0410\5,\27\2\u03fc\u0410\5\62\32\2\u03fd\u0410\5"+ 21214 "8\35\2\u03fe\u0410\5D#\2\u03ff\u0410\5J&\2\u0400\u0410\5P)\2\u0401\u0410"+ 21215 "\5V,\2\u0402\u0410\5b\62\2\u0403\u0410\5\\/\2\u0404\u0410\5\u00a2R\2\u0405"+ 21216 "\u0410\5\u00a8U\2\u0406\u0410\5\u00aeX\2\u0407\u0410\5\u00b4[\2\u0408"+ 21217 "\u0410\5\u00ba^\2\u0409\u040a\6\"\r\2\u040a\u0410\7\3\2\2\u040b\u0410"+ 21218 "\5\u0094K\2\u040c\u0410\7\b\2\2\u040d\u0410\5\u0096L\2\u040e\u0410\5\u0092"+ 21219 "J\2\u040f\u03e1\3\2\2\2\u040f\u03e2\3\2\2\2\u040f\u03e3\3\2\2\2\u040f"+ 21220 "\u03e4\3\2\2\2\u040f\u03e5\3\2\2\2\u040f\u03e6\3\2\2\2\u040f\u03e7\3\2"+ 21221 "\2\2\u040f\u03e8\3\2\2\2\u040f\u03e9\3\2\2\2\u040f\u03ea\3\2\2\2\u040f"+ 21222 "\u03eb\3\2\2\2\u040f\u03ec\3\2\2\2\u040f\u03ed\3\2\2\2\u040f\u03ee\3\2"+ 21223 "\2\2\u040f\u03ef\3\2\2\2\u040f\u03f0\3\2\2\2\u040f\u03f1\3\2\2\2\u040f"+ 21224 "\u03f2\3\2\2\2\u040f\u03f3\3\2\2\2\u040f\u03f4\3\2\2\2\u040f\u03f5\3\2"+ 21225 "\2\2\u040f\u03f6\3\2\2\2\u040f\u03f7\3\2\2\2\u040f\u03f8\3\2\2\2\u040f"+ 21226 "\u03f9\3\2\2\2\u040f\u03fa\3\2\2\2\u040f\u03fb\3\2\2\2\u040f\u03fc\3\2"+ 21227 "\2\2\u040f\u03fd\3\2\2\2\u040f\u03fe\3\2\2\2\u040f\u03ff\3\2\2\2\u040f"+ 21228 "\u0400\3\2\2\2\u040f\u0401\3\2\2\2\u040f\u0402\3\2\2\2\u040f\u0403\3\2"+ 21229 "\2\2\u040f\u0404\3\2\2\2\u040f\u0405\3\2\2\2\u040f\u0406\3\2\2\2\u040f"+ 21230 "\u0407\3\2\2\2\u040f\u0408\3\2\2\2\u040f\u0409\3\2\2\2\u040f\u040b\3\2"+ 21231 "\2\2\u040f\u040c\3\2\2\2\u040f\u040d\3\2\2\2\u040f\u040e\3\2\2\2\u0410"+ 21232 "\u0413\3\2\2\2\u0411\u040f\3\2\2\2\u0411\u0412\3\2\2\2\u0412\u0414\3\2"+ 21233 "\2\2\u0413\u0411\3\2\2\2\u0414\u0415\5@!\2\u0415C\3\2\2\2\u0416\u0417"+ 21234 "\7\7\2\2\u0417\u041e\7F\2\2\u0418\u041d\5\n\6\2\u0419\u041d\7\b\2\2\u041a"+ 21235 "\u041d\7\3\2\2\u041b\u041d\7\6\2\2\u041c\u0418\3\2\2\2\u041c\u0419\3\2"+ 21236 "\2\2\u041c\u041a\3\2\2\2\u041c\u041b\3\2\2\2\u041d\u0420\3\2\2\2\u041e"+ 21237 "\u041c\3\2\2\2\u041e\u041f\3\2\2\2\u041f\u0421\3\2\2\2\u0420\u041e\3\2"+ 21238 "\2\2\u0421\u0422\79\2\2\u0422E\3\2\2\2\u0423\u0424\7\7\2\2\u0424\u0425"+ 21239 "\7;\2\2\u0425\u0429\7F\2\2\u0426\u0428\t\2\2\2\u0427\u0426\3\2\2\2\u0428"+ 21240 "\u042b\3\2\2\2\u0429\u0427\3\2\2\2\u0429\u042a\3\2\2\2\u042a\u042c\3\2"+ 21241 "\2\2\u042b\u0429\3\2\2\2\u042c\u042d\79\2\2\u042dG\3\2\2\2\u042e\u045f"+ 21242 "\5D#\2\u042f\u045e\5\f\7\2\u0430\u045e\5h\65\2\u0431\u045e\5\22\n\2\u0432"+ 21243 "\u045e\5\30\r\2\u0433\u045e\5\36\20\2\u0434\u045e\5$\23\2\u0435\u045e"+ 21244 "\5*\26\2\u0436\u045e\5\60\31\2\u0437\u045e\5\66\34\2\u0438\u045e\5<\37"+ 21245 "\2\u0439\u045e\5B\"\2\u043a\u045e\5N(\2\u043b\u045e\5T+\2\u043c\u045e"+ 21246 "\5Z.\2\u043d\u045e\5f\64\2\u043e\u045e\5`\61\2\u043f\u045e\5\u00a6T\2"+ 21247 "\u0440\u045e\5\u00acW\2\u0441\u045e\5\u00b2Z\2\u0442\u045e\5\u00b8]\2"+ 21248 "\u0443\u045e\5\u00be`\2\u0444\u045e\5\16\b\2\u0445\u045e\5\24\13\2\u0446"+ 21249 "\u045e\5\32\16\2\u0447\u045e\5 \21\2\u0448\u045e\5&\24\2\u0449\u045e\5"+ 21250 ",\27\2\u044a\u045e\5\62\32\2\u044b\u045e\58\35\2\u044c\u045e\5> \2\u044d"+ 21251 "\u045e\5J&\2\u044e\u045e\5P)\2\u044f\u045e\5V,\2\u0450\u045e\5b\62\2\u0451"+ 21252 "\u045e\5\\/\2\u0452\u045e\5\u00a2R\2\u0453\u045e\5\u00a8U\2\u0454\u045e"+ 21253 "\5\u00aeX\2\u0455\u045e\5\u00b4[\2\u0456\u045e\5\u00ba^\2\u0457\u0458"+ 21254 "\6%\16\2\u0458\u045e\7\3\2\2\u0459\u045e\5\u0094K\2\u045a\u045e\7\b\2"+ 21255 "\2\u045b\u045e\5\u0096L\2\u045c\u045e\5\u0092J\2\u045d\u042f\3\2\2\2\u045d"+ 21256 "\u0430\3\2\2\2\u045d\u0431\3\2\2\2\u045d\u0432\3\2\2\2\u045d\u0433\3\2"+ 21257 "\2\2\u045d\u0434\3\2\2\2\u045d\u0435\3\2\2\2\u045d\u0436\3\2\2\2\u045d"+ 21258 "\u0437\3\2\2\2\u045d\u0438\3\2\2\2\u045d\u0439\3\2\2\2\u045d\u043a\3\2"+ 21259 "\2\2\u045d\u043b\3\2\2\2\u045d\u043c\3\2\2\2\u045d\u043d\3\2\2\2\u045d"+ 21260 "\u043e\3\2\2\2\u045d\u043f\3\2\2\2\u045d\u0440\3\2\2\2\u045d\u0441\3\2"+ 21261 "\2\2\u045d\u0442\3\2\2\2\u045d\u0443\3\2\2\2\u045d\u0444\3\2\2\2\u045d"+ 21262 "\u0445\3\2\2\2\u045d\u0446\3\2\2\2\u045d\u0447\3\2\2\2\u045d\u0448\3\2"+ 21263 "\2\2\u045d\u0449\3\2\2\2\u045d\u044a\3\2\2\2\u045d\u044b\3\2\2\2\u045d"+ 21264 "\u044c\3\2\2\2\u045d\u044d\3\2\2\2\u045d\u044e\3\2\2\2\u045d\u044f\3\2"+ 21265 "\2\2\u045d\u0450\3\2\2\2\u045d\u0451\3\2\2\2\u045d\u0452\3\2\2\2\u045d"+ 21266 "\u0453\3\2\2\2\u045d\u0454\3\2\2\2\u045d\u0455\3\2\2\2\u045d\u0456\3\2"+ 21267 "\2\2\u045d\u0457\3\2\2\2\u045d\u0459\3\2\2\2\u045d\u045a\3\2\2\2\u045d"+ 21268 "\u045b\3\2\2\2\u045d\u045c\3\2\2\2\u045e\u0461\3\2\2\2\u045f\u045d\3\2"+ 21269 "\2\2\u045f\u0460\3\2\2\2\u0460\u0462\3\2\2\2\u0461\u045f\3\2\2\2\u0462"+ 21270 "\u0463\5F$\2\u0463I\3\2\2\2\u0464\u0465\7\7\2\2\u0465\u046c\7G\2\2\u0466"+ 21271 "\u046b\5\n\6\2\u0467\u046b\7\b\2\2\u0468\u046b\7\3\2\2\u0469\u046b\7\6"+ 21272 "\2\2\u046a\u0466\3\2\2\2\u046a\u0467\3\2\2\2\u046a\u0468\3\2\2\2\u046a"+ 21273 "\u0469\3\2\2\2\u046b\u046e\3\2\2\2\u046c\u046a\3\2\2\2\u046c\u046d\3\2"+ 21274 "\2\2\u046d\u046f\3\2\2\2\u046e\u046c\3\2\2\2\u046f\u0470\79\2\2\u0470"+ 21275 "K\3\2\2\2\u0471\u0472\7\7\2\2\u0472\u0473\7;\2\2\u0473\u0477\7G\2\2\u0474"+ 21276 "\u0476\t\2\2\2\u0475\u0474\3\2\2\2\u0476\u0479\3\2\2\2\u0477\u0475\3\2"+ 21277 "\2\2\u0477\u0478\3\2\2\2\u0478\u047a\3\2\2\2\u0479\u0477\3\2\2\2\u047a"+ 21278 "\u047b\79\2\2\u047bM\3\2\2\2\u047c\u04ad\5J&\2\u047d\u04ac\5\f\7\2\u047e"+ 21279 "\u04ac\5h\65\2\u047f\u04ac\5\22\n\2\u0480\u04ac\5\30\r\2\u0481\u04ac\5"+ 21280 "\36\20\2\u0482\u04ac\5$\23\2\u0483\u04ac\5*\26\2\u0484\u04ac\5\60\31\2"+ 21281 "\u0485\u04ac\5\66\34\2\u0486\u04ac\5<\37\2\u0487\u04ac\5B\"\2\u0488\u04ac"+ 21282 "\5H%\2\u0489\u04ac\5T+\2\u048a\u04ac\5Z.\2\u048b\u04ac\5f\64\2\u048c\u04ac"+ 21283 "\5`\61\2\u048d\u04ac\5\u00a6T\2\u048e\u04ac\5\u00acW\2\u048f\u04ac\5\u00b2"+ 21284 "Z\2\u0490\u04ac\5\u00b8]\2\u0491\u04ac\5\u00be`\2\u0492\u04ac\5\16\b\2"+ 21285 "\u0493\u04ac\5\24\13\2\u0494\u04ac\5\32\16\2\u0495\u04ac\5 \21\2\u0496"+ 21286 "\u04ac\5&\24\2\u0497\u04ac\5,\27\2\u0498\u04ac\5\62\32\2\u0499\u04ac\5"+ 21287 "8\35\2\u049a\u04ac\5> \2\u049b\u04ac\5D#\2\u049c\u04ac\5P)\2\u049d\u04ac"+ 21288 "\5V,\2\u049e\u04ac\5b\62\2\u049f\u04ac\5\\/\2\u04a0\u04ac\5\u00a2R\2\u04a1"+ 21289 "\u04ac\5\u00a8U\2\u04a2\u04ac\5\u00aeX\2\u04a3\u04ac\5\u00b4[\2\u04a4"+ 21290 "\u04ac\5\u00ba^\2\u04a5\u04a6\6(\17\2\u04a6\u04ac\7\3\2\2\u04a7\u04ac"+ 21291 "\5\u0094K\2\u04a8\u04ac\7\b\2\2\u04a9\u04ac\5\u0096L\2\u04aa\u04ac\5\u0092"+ 21292 "J\2\u04ab\u047d\3\2\2\2\u04ab\u047e\3\2\2\2\u04ab\u047f\3\2\2\2\u04ab"+ 21293 "\u0480\3\2\2\2\u04ab\u0481\3\2\2\2\u04ab\u0482\3\2\2\2\u04ab\u0483\3\2"+ 21294 "\2\2\u04ab\u0484\3\2\2\2\u04ab\u0485\3\2\2\2\u04ab\u0486\3\2\2\2\u04ab"+ 21295 "\u0487\3\2\2\2\u04ab\u0488\3\2\2\2\u04ab\u0489\3\2\2\2\u04ab\u048a\3\2"+ 21296 "\2\2\u04ab\u048b\3\2\2\2\u04ab\u048c\3\2\2\2\u04ab\u048d\3\2\2\2\u04ab"+ 21297 "\u048e\3\2\2\2\u04ab\u048f\3\2\2\2\u04ab\u0490\3\2\2\2\u04ab\u0491\3\2"+ 21298 "\2\2\u04ab\u0492\3\2\2\2\u04ab\u0493\3\2\2\2\u04ab\u0494\3\2\2\2\u04ab"+ 21299 "\u0495\3\2\2\2\u04ab\u0496\3\2\2\2\u04ab\u0497\3\2\2\2\u04ab\u0498\3\2"+ 21300 "\2\2\u04ab\u0499\3\2\2\2\u04ab\u049a\3\2\2\2\u04ab\u049b\3\2\2\2\u04ab"+ 21301 "\u049c\3\2\2\2\u04ab\u049d\3\2\2\2\u04ab\u049e\3\2\2\2\u04ab\u049f\3\2"+ 21302 "\2\2\u04ab\u04a0\3\2\2\2\u04ab\u04a1\3\2\2\2\u04ab\u04a2\3\2\2\2\u04ab"+ 21303 "\u04a3\3\2\2\2\u04ab\u04a4\3\2\2\2\u04ab\u04a5\3\2\2\2\u04ab\u04a7\3\2"+ 21304 "\2\2\u04ab\u04a8\3\2\2\2\u04ab\u04a9\3\2\2\2\u04ab\u04aa\3\2\2\2\u04ac"+ 21305 "\u04af\3\2\2\2\u04ad\u04ab\3\2\2\2\u04ad\u04ae\3\2\2\2\u04ae\u04b0\3\2"+ 21306 "\2\2\u04af\u04ad\3\2\2\2\u04b0\u04b1\5L\'\2\u04b1O\3\2\2\2\u04b2\u04b3"+ 21307 "\7\7\2\2\u04b3\u04ba\7H\2\2\u04b4\u04b9\5\n\6\2\u04b5\u04b9\7\b\2\2\u04b6"+ 21308 "\u04b9\7\3\2\2\u04b7\u04b9\7\6\2\2\u04b8\u04b4\3\2\2\2\u04b8\u04b5\3\2"+ 21309 "\2\2\u04b8\u04b6\3\2\2\2\u04b8\u04b7\3\2\2\2\u04b9\u04bc\3\2\2\2\u04ba"+ 21310 "\u04b8\3\2\2\2\u04ba\u04bb\3\2\2\2\u04bb\u04bd\3\2\2\2\u04bc\u04ba\3\2"+ 21311 "\2\2\u04bd\u04be\79\2\2\u04beQ\3\2\2\2\u04bf\u04c0\7\7\2\2\u04c0\u04c1"+ 21312 "\7;\2\2\u04c1\u04c5\7H\2\2\u04c2\u04c4\t\2\2\2\u04c3\u04c2\3\2\2\2\u04c4"+ 21313 "\u04c7\3\2\2\2\u04c5\u04c3\3\2\2\2\u04c5\u04c6\3\2\2\2\u04c6\u04c8\3\2"+ 21314 "\2\2\u04c7\u04c5\3\2\2\2\u04c8\u04c9\79\2\2\u04c9S\3\2\2\2\u04ca\u04fb"+ 21315 "\5P)\2\u04cb\u04fa\5\f\7\2\u04cc\u04fa\5h\65\2\u04cd\u04fa\5\22\n\2\u04ce"+ 21316 "\u04fa\5\30\r\2\u04cf\u04fa\5\36\20\2\u04d0\u04fa\5$\23\2\u04d1\u04fa"+ 21317 "\5*\26\2\u04d2\u04fa\5\60\31\2\u04d3\u04fa\5\66\34\2\u04d4\u04fa\5<\37"+ 21318 "\2\u04d5\u04fa\5B\"\2\u04d6\u04fa\5H%\2\u04d7\u04fa\5N(\2\u04d8\u04fa"+ 21319 "\5Z.\2\u04d9\u04fa\5f\64\2\u04da\u04fa\5`\61\2\u04db\u04fa\5\u00a6T\2"+ 21320 "\u04dc\u04fa\5\u00acW\2\u04dd\u04fa\5\u00b2Z\2\u04de\u04fa\5\u00b8]\2"+ 21321 "\u04df\u04fa\5\u00be`\2\u04e0\u04fa\5\16\b\2\u04e1\u04fa\5\24\13\2\u04e2"+ 21322 "\u04fa\5\32\16\2\u04e3\u04fa\5 \21\2\u04e4\u04fa\5&\24\2\u04e5\u04fa\5"+ 21323 ",\27\2\u04e6\u04fa\5\62\32\2\u04e7\u04fa\58\35\2\u04e8\u04fa\5> \2\u04e9"+ 21324 "\u04fa\5D#\2\u04ea\u04fa\5J&\2\u04eb\u04fa\5V,\2\u04ec\u04fa\5b\62\2\u04ed"+ 21325 "\u04fa\5\\/\2\u04ee\u04fa\5\u00a2R\2\u04ef\u04fa\5\u00a8U\2\u04f0\u04fa"+ 21326 "\5\u00aeX\2\u04f1\u04fa\5\u00b4[\2\u04f2\u04fa\5\u00ba^\2\u04f3\u04f4"+ 21327 "\6+\20\2\u04f4\u04fa\7\3\2\2\u04f5\u04fa\5\u0094K\2\u04f6\u04fa\7\b\2"+ 21328 "\2\u04f7\u04fa\5\u0096L\2\u04f8\u04fa\5\u0092J\2\u04f9\u04cb\3\2\2\2\u04f9"+ 21329 "\u04cc\3\2\2\2\u04f9\u04cd\3\2\2\2\u04f9\u04ce\3\2\2\2\u04f9\u04cf\3\2"+ 21330 "\2\2\u04f9\u04d0\3\2\2\2\u04f9\u04d1\3\2\2\2\u04f9\u04d2\3\2\2\2\u04f9"+ 21331 "\u04d3\3\2\2\2\u04f9\u04d4\3\2\2\2\u04f9\u04d5\3\2\2\2\u04f9\u04d6\3\2"+ 21332 "\2\2\u04f9\u04d7\3\2\2\2\u04f9\u04d8\3\2\2\2\u04f9\u04d9\3\2\2\2\u04f9"+ 21333 "\u04da\3\2\2\2\u04f9\u04db\3\2\2\2\u04f9\u04dc\3\2\2\2\u04f9\u04dd\3\2"+ 21334 "\2\2\u04f9\u04de\3\2\2\2\u04f9\u04df\3\2\2\2\u04f9\u04e0\3\2\2\2\u04f9"+ 21335 "\u04e1\3\2\2\2\u04f9\u04e2\3\2\2\2\u04f9\u04e3\3\2\2\2\u04f9\u04e4\3\2"+ 21336 "\2\2\u04f9\u04e5\3\2\2\2\u04f9\u04e6\3\2\2\2\u04f9\u04e7\3\2\2\2\u04f9"+ 21337 "\u04e8\3\2\2\2\u04f9\u04e9\3\2\2\2\u04f9\u04ea\3\2\2\2\u04f9\u04eb\3\2"+ 21338 "\2\2\u04f9\u04ec\3\2\2\2\u04f9\u04ed\3\2\2\2\u04f9\u04ee\3\2\2\2\u04f9"+ 21339 "\u04ef\3\2\2\2\u04f9\u04f0\3\2\2\2\u04f9\u04f1\3\2\2\2\u04f9\u04f2\3\2"+ 21340 "\2\2\u04f9\u04f3\3\2\2\2\u04f9\u04f5\3\2\2\2\u04f9\u04f6\3\2\2\2\u04f9"+ 21341 "\u04f7\3\2\2\2\u04f9\u04f8\3\2\2\2\u04fa\u04fd\3\2\2\2\u04fb\u04f9\3\2"+ 21342 "\2\2\u04fb\u04fc\3\2\2\2\u04fc\u04fe\3\2\2\2\u04fd\u04fb\3\2\2\2\u04fe"+ 21343 "\u04ff\5R*\2\u04ffU\3\2\2\2\u0500\u0501\7\7\2\2\u0501\u0508\7I\2\2\u0502"+ 21344 "\u0507\5\n\6\2\u0503\u0507\7\b\2\2\u0504\u0507\7\3\2\2\u0505\u0507\7\6"+ 21345 "\2\2\u0506\u0502\3\2\2\2\u0506\u0503\3\2\2\2\u0506\u0504\3\2\2\2\u0506"+ 21346 "\u0505\3\2\2\2\u0507\u050a\3\2\2\2\u0508\u0506\3\2\2\2\u0508\u0509\3\2"+ 21347 "\2\2\u0509\u050b\3\2\2\2\u050a\u0508\3\2\2\2\u050b\u050c\79\2\2\u050c"+ 21348 "W\3\2\2\2\u050d\u050e\7\7\2\2\u050e\u050f\7;\2\2\u050f\u0513\7I\2\2\u0510"+ 21349 "\u0512\t\2\2\2\u0511\u0510\3\2\2\2\u0512\u0515\3\2\2\2\u0513\u0511\3\2"+ 21350 "\2\2\u0513\u0514\3\2\2\2\u0514\u0516\3\2\2\2\u0515\u0513\3\2\2\2\u0516"+ 21351 "\u0517\79\2\2\u0517Y\3\2\2\2\u0518\u0549\5V,\2\u0519\u0548\5\f\7\2\u051a"+ 21352 "\u0548\5h\65\2\u051b\u0548\5\22\n\2\u051c\u0548\5\30\r\2\u051d\u0548\5"+ 21353 "\36\20\2\u051e\u0548\5$\23\2\u051f\u0548\5*\26\2\u0520\u0548\5\60\31\2"+ 21354 "\u0521\u0548\5\66\34\2\u0522\u0548\5<\37\2\u0523\u0548\5B\"\2\u0524\u0548"+ 21355 "\5H%\2\u0525\u0548\5N(\2\u0526\u0548\5T+\2\u0527\u0548\5f\64\2\u0528\u0548"+ 21356 "\5`\61\2\u0529\u0548\5\u00a6T\2\u052a\u0548\5\u00acW\2\u052b\u0548\5\u00b2"+ 21357 "Z\2\u052c\u0548\5\u00b8]\2\u052d\u0548\5\u00be`\2\u052e\u0548\5\16\b\2"+ 21358 "\u052f\u0548\5\24\13\2\u0530\u0548\5\32\16\2\u0531\u0548\5 \21\2\u0532"+ 21359 "\u0548\5&\24\2\u0533\u0548\5,\27\2\u0534\u0548\5\62\32\2\u0535\u0548\5"+ 21360 "8\35\2\u0536\u0548\5> \2\u0537\u0548\5D#\2\u0538\u0548\5J&\2\u0539\u0548"+ 21361 "\5P)\2\u053a\u0548\5b\62\2\u053b\u0548\5\\/\2\u053c\u0548\5\u00a2R\2\u053d"+ 21362 "\u0548\5\u00a8U\2\u053e\u0548\5\u00aeX\2\u053f\u0548\5\u00b4[\2\u0540"+ 21363 "\u0548\5\u00ba^\2\u0541\u0542\6.\21\2\u0542\u0548\7\3\2\2\u0543\u0548"+ 21364 "\5\u0094K\2\u0544\u0548\7\b\2\2\u0545\u0548\5\u0096L\2\u0546\u0548\5\u0092"+ 21365 "J\2\u0547\u0519\3\2\2\2\u0547\u051a\3\2\2\2\u0547\u051b\3\2\2\2\u0547"+ 21366 "\u051c\3\2\2\2\u0547\u051d\3\2\2\2\u0547\u051e\3\2\2\2\u0547\u051f\3\2"+ 21367 "\2\2\u0547\u0520\3\2\2\2\u0547\u0521\3\2\2\2\u0547\u0522\3\2\2\2\u0547"+ 21368 "\u0523\3\2\2\2\u0547\u0524\3\2\2\2\u0547\u0525\3\2\2\2\u0547\u0526\3\2"+ 21369 "\2\2\u0547\u0527\3\2\2\2\u0547\u0528\3\2\2\2\u0547\u0529\3\2\2\2\u0547"+ 21370 "\u052a\3\2\2\2\u0547\u052b\3\2\2\2\u0547\u052c\3\2\2\2\u0547\u052d\3\2"+ 21371 "\2\2\u0547\u052e\3\2\2\2\u0547\u052f\3\2\2\2\u0547\u0530\3\2\2\2\u0547"+ 21372 "\u0531\3\2\2\2\u0547\u0532\3\2\2\2\u0547\u0533\3\2\2\2\u0547\u0534\3\2"+ 21373 "\2\2\u0547\u0535\3\2\2\2\u0547\u0536\3\2\2\2\u0547\u0537\3\2\2\2\u0547"+ 21374 "\u0538\3\2\2\2\u0547\u0539\3\2\2\2\u0547\u053a\3\2\2\2\u0547\u053b\3\2"+ 21375 "\2\2\u0547\u053c\3\2\2\2\u0547\u053d\3\2\2\2\u0547\u053e\3\2\2\2\u0547"+ 21376 "\u053f\3\2\2\2\u0547\u0540\3\2\2\2\u0547\u0541\3\2\2\2\u0547\u0543\3\2"+ 21377 "\2\2\u0547\u0544\3\2\2\2\u0547\u0545\3\2\2\2\u0547\u0546\3\2\2\2\u0548"+ 21378 "\u054b\3\2\2\2\u0549\u0547\3\2\2\2\u0549\u054a\3\2\2\2\u054a\u054c\3\2"+ 21379 "\2\2\u054b\u0549\3\2\2\2\u054c\u054d\5X-\2\u054d[\3\2\2\2\u054e\u054f"+ 21380 "\7\7\2\2\u054f\u0556\7J\2\2\u0550\u0555\5\n\6\2\u0551\u0555\7\b\2\2\u0552"+ 21381 "\u0555\7\3\2\2\u0553\u0555\7\6\2\2\u0554\u0550\3\2\2\2\u0554\u0551\3\2"+ 21382 "\2\2\u0554\u0552\3\2\2\2\u0554\u0553\3\2\2\2\u0555\u0558\3\2\2\2\u0556"+ 21383 "\u0554\3\2\2\2\u0556\u0557\3\2\2\2\u0557\u0559\3\2\2\2\u0558\u0556\3\2"+ 21384 "\2\2\u0559\u055a\79\2\2\u055a]\3\2\2\2\u055b\u055c\7\7\2\2\u055c\u055d"+ 21385 "\7;\2\2\u055d\u0561\7J\2\2\u055e\u0560\t\2\2\2\u055f\u055e\3\2\2\2\u0560"+ 21386 "\u0563\3\2\2\2\u0561\u055f\3\2\2\2\u0561\u0562\3\2\2\2\u0562\u0564\3\2"+ 21387 "\2\2\u0563\u0561\3\2\2\2\u0564\u0565\79\2\2\u0565_\3\2\2\2\u0566\u0597"+ 21388 "\5\\/\2\u0567\u0596\5\f\7\2\u0568\u0596\5h\65\2\u0569\u0596\5\22\n\2\u056a"+ 21389 "\u0596\5\30\r\2\u056b\u0596\5\36\20\2\u056c\u0596\5$\23\2\u056d\u0596"+ 21390 "\5*\26\2\u056e\u0596\5\60\31\2\u056f\u0596\5\66\34\2\u0570\u0596\5<\37"+ 21391 "\2\u0571\u0596\5B\"\2\u0572\u0596\5H%\2\u0573\u0596\5N(\2\u0574\u0596"+ 21392 "\5T+\2\u0575\u0596\5Z.\2\u0576\u0596\5f\64\2\u0577\u0596\5\u00a6T\2\u0578"+ 21393 "\u0596\5\u00acW\2\u0579\u0596\5\u00b2Z\2\u057a\u0596\5\u00b8]\2\u057b"+ 21394 "\u0596\5\u00be`\2\u057c\u0596\5\16\b\2\u057d\u0596\5\24\13\2\u057e\u0596"+ 21395 "\5\32\16\2\u057f\u0596\5 \21\2\u0580\u0596\5&\24\2\u0581\u0596\5,\27\2"+ 21396 "\u0582\u0596\5\62\32\2\u0583\u0596\58\35\2\u0584\u0596\5> \2\u0585\u0596"+ 21397 "\5D#\2\u0586\u0596\5J&\2\u0587\u0596\5P)\2\u0588\u0596\5V,\2\u0589\u0596"+ 21398 "\5b\62\2\u058a\u0596\5\u00a2R\2\u058b\u0596\5\u00a8U\2\u058c\u0596\5\u00ae"+ 21399 "X\2\u058d\u0596\5\u00b4[\2\u058e\u0596\5\u00ba^\2\u058f\u0590\6\61\22"+ 21400 "\2\u0590\u0596\7\3\2\2\u0591\u0596\5\u0094K\2\u0592\u0596\7\b\2\2\u0593"+ 21401 "\u0596\5\u0096L\2\u0594\u0596\5\u0092J\2\u0595\u0567\3\2\2\2\u0595\u0568"+ 21402 "\3\2\2\2\u0595\u0569\3\2\2\2\u0595\u056a\3\2\2\2\u0595\u056b\3\2\2\2\u0595"+ 21403 "\u056c\3\2\2\2\u0595\u056d\3\2\2\2\u0595\u056e\3\2\2\2\u0595\u056f\3\2"+ 21404 "\2\2\u0595\u0570\3\2\2\2\u0595\u0571\3\2\2\2\u0595\u0572\3\2\2\2\u0595"+ 21405 "\u0573\3\2\2\2\u0595\u0574\3\2\2\2\u0595\u0575\3\2\2\2\u0595\u0576\3\2"+ 21406 "\2\2\u0595\u0577\3\2\2\2\u0595\u0578\3\2\2\2\u0595\u0579\3\2\2\2\u0595"+ 21407 "\u057a\3\2\2\2\u0595\u057b\3\2\2\2\u0595\u057c\3\2\2\2\u0595\u057d\3\2"+ 21408 "\2\2\u0595\u057e\3\2\2\2\u0595\u057f\3\2\2\2\u0595\u0580\3\2\2\2\u0595"+ 21409 "\u0581\3\2\2\2\u0595\u0582\3\2\2\2\u0595\u0583\3\2\2\2\u0595\u0584\3\2"+ 21410 "\2\2\u0595\u0585\3\2\2\2\u0595\u0586\3\2\2\2\u0595\u0587\3\2\2\2\u0595"+ 21411 "\u0588\3\2\2\2\u0595\u0589\3\2\2\2\u0595\u058a\3\2\2\2\u0595\u058b\3\2"+ 21412 "\2\2\u0595\u058c\3\2\2\2\u0595\u058d\3\2\2\2\u0595\u058e\3\2\2\2\u0595"+ 21413 "\u058f\3\2\2\2\u0595\u0591\3\2\2\2\u0595\u0592\3\2\2\2\u0595\u0593\3\2"+ 21414 "\2\2\u0595\u0594\3\2\2\2\u0596\u0599\3\2\2\2\u0597\u0595\3\2\2\2\u0597"+ 21415 "\u0598\3\2\2\2\u0598\u059a\3\2\2\2\u0599\u0597\3\2\2\2\u059a\u059b\5^"+ 21416 "\60\2\u059ba\3\2\2\2\u059c\u059d\7\7\2\2\u059d\u05a4\7K\2\2\u059e\u05a3"+ 21417 "\5\n\6\2\u059f\u05a3\7\b\2\2\u05a0\u05a3\7\3\2\2\u05a1\u05a3\7\6\2\2\u05a2"+ 21418 "\u059e\3\2\2\2\u05a2\u059f\3\2\2\2\u05a2\u05a0\3\2\2\2\u05a2\u05a1\3\2"+ 21419 "\2\2\u05a3\u05a6\3\2\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a5\3\2\2\2\u05a5"+ 21420 "\u05a7\3\2\2\2\u05a6\u05a4\3\2\2\2\u05a7\u05a8\79\2\2\u05a8c\3\2\2\2\u05a9"+ 21421 "\u05aa\7\7\2\2\u05aa\u05ab\7;\2\2\u05ab\u05af\7K\2\2\u05ac\u05ae\t\2\2"+ 21422 "\2\u05ad\u05ac\3\2\2\2\u05ae\u05b1\3\2\2\2\u05af\u05ad\3\2\2\2\u05af\u05b0"+ 21423 "\3\2\2\2\u05b0\u05b2\3\2\2\2\u05b1\u05af\3\2\2\2\u05b2\u05b3\79\2\2\u05b3"+ 21424 "e\3\2\2\2\u05b4\u05e5\5b\62\2\u05b5\u05e4\5\f\7\2\u05b6\u05e4\5h\65\2"+ 21425 "\u05b7\u05e4\5\22\n\2\u05b8\u05e4\5\30\r\2\u05b9\u05e4\5\36\20\2\u05ba"+ 21426 "\u05e4\5$\23\2\u05bb\u05e4\5*\26\2\u05bc\u05e4\5\60\31\2\u05bd\u05e4\5"+ 21427 "\66\34\2\u05be\u05e4\5<\37\2\u05bf\u05e4\5B\"\2\u05c0\u05e4\5H%\2\u05c1"+ 21428 "\u05e4\5N(\2\u05c2\u05e4\5T+\2\u05c3\u05e4\5Z.\2\u05c4\u05e4\5`\61\2\u05c5"+ 21429 "\u05e4\5\u00a6T\2\u05c6\u05e4\5\u00acW\2\u05c7\u05e4\5\u00b2Z\2\u05c8"+ 21430 "\u05e4\5\u00b8]\2\u05c9\u05e4\5\u00be`\2\u05ca\u05e4\5\16\b\2\u05cb\u05e4"+ 21431 "\5\24\13\2\u05cc\u05e4\5\32\16\2\u05cd\u05e4\5 \21\2\u05ce\u05e4\5&\24"+ 21432 "\2\u05cf\u05e4\5,\27\2\u05d0\u05e4\5\62\32\2\u05d1\u05e4\58\35\2\u05d2"+ 21433 "\u05e4\5> \2\u05d3\u05e4\5D#\2\u05d4\u05e4\5J&\2\u05d5\u05e4\5P)\2\u05d6"+ 21434 "\u05e4\5V,\2\u05d7\u05e4\5\\/\2\u05d8\u05e4\5\u00a2R\2\u05d9\u05e4\5\u00a8"+ 21435 "U\2\u05da\u05e4\5\u00aeX\2\u05db\u05e4\5\u00b4[\2\u05dc\u05e4\5\u00ba"+ 21436 "^\2\u05dd\u05de\6\64\23\2\u05de\u05e4\7\3\2\2\u05df\u05e4\5\u0094K\2\u05e0"+ 21437 "\u05e4\7\b\2\2\u05e1\u05e4\5\u0096L\2\u05e2\u05e4\5\u0092J\2\u05e3\u05b5"+ 21438 "\3\2\2\2\u05e3\u05b6\3\2\2\2\u05e3\u05b7\3\2\2\2\u05e3\u05b8\3\2\2\2\u05e3"+ 21439 "\u05b9\3\2\2\2\u05e3\u05ba\3\2\2\2\u05e3\u05bb\3\2\2\2\u05e3\u05bc\3\2"+ 21440 "\2\2\u05e3\u05bd\3\2\2\2\u05e3\u05be\3\2\2\2\u05e3\u05bf\3\2\2\2\u05e3"+ 21441 "\u05c0\3\2\2\2\u05e3\u05c1\3\2\2\2\u05e3\u05c2\3\2\2\2\u05e3\u05c3\3\2"+ 21442 "\2\2\u05e3\u05c4\3\2\2\2\u05e3\u05c5\3\2\2\2\u05e3\u05c6\3\2\2\2\u05e3"+ 21443 "\u05c7\3\2\2\2\u05e3\u05c8\3\2\2\2\u05e3\u05c9\3\2\2\2\u05e3\u05ca\3\2"+ 21444 "\2\2\u05e3\u05cb\3\2\2\2\u05e3\u05cc\3\2\2\2\u05e3\u05cd\3\2\2\2\u05e3"+ 21445 "\u05ce\3\2\2\2\u05e3\u05cf\3\2\2\2\u05e3\u05d0\3\2\2\2\u05e3\u05d1\3\2"+ 21446 "\2\2\u05e3\u05d2\3\2\2\2\u05e3\u05d3\3\2\2\2\u05e3\u05d4\3\2\2\2\u05e3"+ 21447 "\u05d5\3\2\2\2\u05e3\u05d6\3\2\2\2\u05e3\u05d7\3\2\2\2\u05e3\u05d8\3\2"+ 21448 "\2\2\u05e3\u05d9\3\2\2\2\u05e3\u05da\3\2\2\2\u05e3\u05db\3\2\2\2\u05e3"+ 21449 "\u05dc\3\2\2\2\u05e3\u05dd\3\2\2\2\u05e3\u05df\3\2\2\2\u05e3\u05e0\3\2"+ 21450 "\2\2\u05e3\u05e1\3\2\2\2\u05e3\u05e2\3\2\2\2\u05e4\u05e7\3\2\2\2\u05e5"+ 21451 "\u05e3\3\2\2\2\u05e5\u05e6\3\2\2\2\u05e6\u05e8\3\2\2\2\u05e7\u05e5\3\2"+ 21452 "\2\2\u05e8\u05e9\5d\63\2\u05e9g\3\2\2\2\u05ea\u05ff\5j\66\2\u05eb\u05ff"+ 21453 "\5l\67\2\u05ec\u05ff\5n8\2\u05ed\u05ff\5p9\2\u05ee\u05ff\5r:\2\u05ef\u05ff"+ 21454 "\5t;\2\u05f0\u05ff\5v<\2\u05f1\u05ff\5x=\2\u05f2\u05ff\5z>\2\u05f3\u05ff"+ 21455 "\5|?\2\u05f4\u05ff\5~@\2\u05f5\u05ff\5\u0080A\2\u05f6\u05ff\5\u0082B\2"+ 21456 "\u05f7\u05ff\5\u0084C\2\u05f8\u05ff\5\u0098M\2\u05f9\u05ff\5\u009aN\2"+ 21457 "\u05fa\u05ff\5\u009cO\2\u05fb\u05ff\5\u009eP\2\u05fc\u05ff\5\u00a0Q\2"+ 21458 "\u05fd\u05ff\5\u0086D\2\u05fe\u05ea\3\2\2\2\u05fe\u05eb\3\2\2\2\u05fe"+ 21459 "\u05ec\3\2\2\2\u05fe\u05ed\3\2\2\2\u05fe\u05ee\3\2\2\2\u05fe\u05ef\3\2"+ 21460 "\2\2\u05fe\u05f0\3\2\2\2\u05fe\u05f1\3\2\2\2\u05fe\u05f2\3\2\2\2\u05fe"+ 21461 "\u05f3\3\2\2\2\u05fe\u05f4\3\2\2\2\u05fe\u05f5\3\2\2\2\u05fe\u05f6\3\2"+ 21462 "\2\2\u05fe\u05f7\3\2\2\2\u05fe\u05f8\3\2\2\2\u05fe\u05f9\3\2\2\2\u05fe"+ 21463 "\u05fa\3\2\2\2\u05fe\u05fb\3\2\2\2\u05fe\u05fc\3\2\2\2\u05fe\u05fd\3\2"+ 21464 "\2\2\u05ffi\3\2\2\2\u0600\u0601\7\7\2\2\u0601\u0608\t\3\2\2\u0602\u0607"+ 21465 "\5\n\6\2\u0603\u0607\7\b\2\2\u0604\u0607\7\3\2\2\u0605\u0607\7\6\2\2\u0606"+ 21466 "\u0602\3\2\2\2\u0606\u0603\3\2\2\2\u0606\u0604\3\2\2\2\u0606\u0605\3\2"+ 21467 "\2\2\u0607\u060a\3\2\2\2\u0608\u0606\3\2\2\2\u0608\u0609\3\2\2\2\u0609"+ 21468 "\u060b\3\2\2\2\u060a\u0608\3\2\2\2\u060b\u060c\7:\2\2\u060ck\3\2\2\2\u060d"+ 21469 "\u060e\7\7\2\2\u060e\u0615\7L\2\2\u060f\u0614\5\n\6\2\u0610\u0614\7\b"+ 21470 "\2\2\u0611\u0614\7\3\2\2\u0612\u0614\7\6\2\2\u0613\u060f\3\2\2\2\u0613"+ 21471 "\u0610\3\2\2\2\u0613\u0611\3\2\2\2\u0613\u0612\3\2\2\2\u0614\u0617\3\2"+ 21472 "\2\2\u0615\u0613\3\2\2\2\u0615\u0616\3\2\2\2\u0616\u0618\3\2\2\2\u0617"+ 21473 "\u0615\3\2\2\2\u0618\u0619\t\4\2\2\u0619m\3\2\2\2\u061a\u061b\7\7\2\2"+ 21474 "\u061b\u0622\7M\2\2\u061c\u0621\5\n\6\2\u061d\u0621\7\b\2\2\u061e\u0621"+ 21475 "\7\3\2\2\u061f\u0621\7\6\2\2\u0620\u061c\3\2\2\2\u0620\u061d\3\2\2\2\u0620"+ 21476 "\u061e\3\2\2\2\u0620\u061f\3\2\2\2\u0621\u0624\3\2\2\2\u0622\u0620\3\2"+ 21477 "\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2\2\2\u0624\u0622\3\2\2\2\u0625"+ 21478 "\u0626\t\4\2\2\u0626o\3\2\2\2\u0627\u0628\7\7\2\2\u0628\u062f\7N\2\2\u0629"+ 21479 "\u062e\5\n\6\2\u062a\u062e\7\b\2\2\u062b\u062e\7\3\2\2\u062c\u062e\7\6"+ 21480 "\2\2\u062d\u0629\3\2\2\2\u062d\u062a\3\2\2\2\u062d\u062b\3\2\2\2\u062d"+ 21481 "\u062c\3\2\2\2\u062e\u0631\3\2\2\2\u062f\u062d\3\2\2\2\u062f\u0630\3\2"+ 21482 "\2\2\u0630\u0632\3\2\2\2\u0631\u062f\3\2\2\2\u0632\u0633\t\4\2\2\u0633"+ 21483 "q\3\2\2\2\u0634\u0635\7\7\2\2\u0635\u063c\7O\2\2\u0636\u063b\5\n\6\2\u0637"+ 21484 "\u063b\7\b\2\2\u0638\u063b\7\3\2\2\u0639\u063b\7\6\2\2\u063a\u0636\3\2"+ 21485 "\2\2\u063a\u0637\3\2\2\2\u063a\u0638\3\2\2\2\u063a\u0639\3\2\2\2\u063b"+ 21486 "\u063e\3\2\2\2\u063c\u063a\3\2\2\2\u063c\u063d\3\2\2\2\u063d\u063f\3\2"+ 21487 "\2\2\u063e\u063c\3\2\2\2\u063f\u0640\t\4\2\2\u0640s\3\2\2\2\u0641\u0642"+ 21488 "\7\7\2\2\u0642\u0649\7P\2\2\u0643\u0648\5\n\6\2\u0644\u0648\7\b\2\2\u0645"+ 21489 "\u0648\7\3\2\2\u0646\u0648\7\6\2\2\u0647\u0643\3\2\2\2\u0647\u0644\3\2"+ 21490 "\2\2\u0647\u0645\3\2\2\2\u0647\u0646\3\2\2\2\u0648\u064b\3\2\2\2\u0649"+ 21491 "\u0647\3\2\2\2\u0649\u064a\3\2\2\2\u064a\u064c\3\2\2\2\u064b\u0649\3\2"+ 21492 "\2\2\u064c\u064d\t\4\2\2\u064du\3\2\2\2\u064e\u064f\7\7\2\2\u064f\u0656"+ 21493 "\7Q\2\2\u0650\u0655\5\n\6\2\u0651\u0655\7\b\2\2\u0652\u0655\7\3\2\2\u0653"+ 21494 "\u0655\7\6\2\2\u0654\u0650\3\2\2\2\u0654\u0651\3\2\2\2\u0654\u0652\3\2"+ 21495 "\2\2\u0654\u0653\3\2\2\2\u0655\u0658\3\2\2\2\u0656\u0654\3\2\2\2\u0656"+ 21496 "\u0657\3\2\2\2\u0657\u0659\3\2\2\2\u0658\u0656\3\2\2\2\u0659\u065a\t\4"+ 21497 "\2\2\u065aw\3\2\2\2\u065b\u065c\7\7\2\2\u065c\u0663\7R\2\2\u065d\u0662"+ 21498 "\5\n\6\2\u065e\u0662\7\b\2\2\u065f\u0662\7\3\2\2\u0660\u0662\7\6\2\2\u0661"+ 21499 "\u065d\3\2\2\2\u0661\u065e\3\2\2\2\u0661\u065f\3\2\2\2\u0661\u0660\3\2"+ 21500 "\2\2\u0662\u0665\3\2\2\2\u0663\u0661\3\2\2\2\u0663\u0664\3\2\2\2\u0664"+ 21501 "\u0666\3\2\2\2\u0665\u0663\3\2\2\2\u0666\u0667\t\4\2\2\u0667y\3\2\2\2"+ 21502 "\u0668\u0669\7\7\2\2\u0669\u0670\7S\2\2\u066a\u066f\5\n\6\2\u066b\u066f"+ 21503 "\7\b\2\2\u066c\u066f\7\3\2\2\u066d\u066f\7\6\2\2\u066e\u066a\3\2\2\2\u066e"+ 21504 "\u066b\3\2\2\2\u066e\u066c\3\2\2\2\u066e\u066d\3\2\2\2\u066f\u0672\3\2"+ 21505 "\2\2\u0670\u066e\3\2\2\2\u0670\u0671\3\2\2\2\u0671\u0673\3\2\2\2\u0672"+ 21506 "\u0670\3\2\2\2\u0673\u0674\t\4\2\2\u0674{\3\2\2\2\u0675\u0676\7\7\2\2"+ 21507 "\u0676\u067d\7T\2\2\u0677\u067c\5\n\6\2\u0678\u067c\7\b\2\2\u0679\u067c"+ 21508 "\7\3\2\2\u067a\u067c\7\6\2\2\u067b\u0677\3\2\2\2\u067b\u0678\3\2\2\2\u067b"+ 21509 "\u0679\3\2\2\2\u067b\u067a\3\2\2\2\u067c\u067f\3\2\2\2\u067d\u067b\3\2"+ 21510 "\2\2\u067d\u067e\3\2\2\2\u067e\u0680\3\2\2\2\u067f\u067d\3\2\2\2\u0680"+ 21511 "\u0681\t\4\2\2\u0681}\3\2\2\2\u0682\u0683\7\7\2\2\u0683\u068a\7U\2\2\u0684"+ 21512 "\u0689\5\n\6\2\u0685\u0689\7\b\2\2\u0686\u0689\7\3\2\2\u0687\u0689\7\6"+ 21513 "\2\2\u0688\u0684\3\2\2\2\u0688\u0685\3\2\2\2\u0688\u0686\3\2\2\2\u0688"+ 21514 "\u0687\3\2\2\2\u0689\u068c\3\2\2\2\u068a\u0688\3\2\2\2\u068a\u068b\3\2"+ 21515 "\2\2\u068b\u068d\3\2\2\2\u068c\u068a\3\2\2\2\u068d\u068e\t\4\2\2\u068e"+ 21516 "\177\3\2\2\2\u068f\u0690\7\7\2\2\u0690\u0697\7V\2\2\u0691\u0696\5\n\6"+ 21517 "\2\u0692\u0696\7\b\2\2\u0693\u0696\7\3\2\2\u0694\u0696\7\6\2\2\u0695\u0691"+ 21518 "\3\2\2\2\u0695\u0692\3\2\2\2\u0695\u0693\3\2\2\2\u0695\u0694\3\2\2\2\u0696"+ 21519 "\u0699\3\2\2\2\u0697\u0695\3\2\2\2\u0697\u0698\3\2\2\2\u0698\u069a\3\2"+ 21520 "\2\2\u0699\u0697\3\2\2\2\u069a\u069b\t\4\2\2\u069b\u0081\3\2\2\2\u069c"+ 21521 "\u069d\7\7\2\2\u069d\u06a4\7W\2\2\u069e\u06a3\5\n\6\2\u069f\u06a3\7\b"+ 21522 "\2\2\u06a0\u06a3\7\3\2\2\u06a1\u06a3\7\6\2\2\u06a2\u069e\3\2\2\2\u06a2"+ 21523 "\u069f\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a2\u06a1\3\2\2\2\u06a3\u06a6\3\2"+ 21524 "\2\2\u06a4\u06a2\3\2\2\2\u06a4\u06a5\3\2\2\2\u06a5\u06a7\3\2\2\2\u06a6"+ 21525 "\u06a4\3\2\2\2\u06a7\u06a8\t\4\2\2\u06a8\u0083\3\2\2\2\u06a9\u06aa\7\7"+ 21526 "\2\2\u06aa\u06b1\7X\2\2\u06ab\u06b0\5\n\6\2\u06ac\u06b0\7\b\2\2\u06ad"+ 21527 "\u06b0\7\3\2\2\u06ae\u06b0\7\6\2\2\u06af\u06ab\3\2\2\2\u06af\u06ac\3\2"+ 21528 "\2\2\u06af\u06ad\3\2\2\2\u06af\u06ae\3\2\2\2\u06b0\u06b3\3\2\2\2\u06b1"+ 21529 "\u06af\3\2\2\2\u06b1\u06b2\3\2\2\2\u06b2\u06b4\3\2\2\2\u06b3\u06b1\3\2"+ 21530 "\2\2\u06b4\u06b5\t\4\2\2\u06b5\u0085\3\2\2\2\u06b6\u06b7\7\7\2\2\u06b7"+ 21531 "\u06b8\7;\2\2\u06b8\u06b9\5\u0088E\2\u06b9\u06ba\79\2\2\u06ba\u06bb\b"+ 21532 "D\1\2\u06bb\u0087\3\2\2\2\u06bc\u06bd\t\5\2\2\u06bd\u0089\3\2\2\2\u06be"+ 21533 "\u06bf\6F\24\2\u06bf\u06c6\7\3\2\2\u06c0\u06c6\5\u0094K\2\u06c1\u06c6"+ 21534 "\7\b\2\2\u06c2\u06c6\5\u0096L\2\u06c3\u06c6\5\u0092J\2\u06c4\u06c6\5\4"+ 21535 "\3\2\u06c5\u06be\3\2\2\2\u06c5\u06c0\3\2\2\2\u06c5\u06c1\3\2\2\2\u06c5"+ 21536 "\u06c2\3\2\2\2\u06c5\u06c3\3\2\2\2\u06c5\u06c4\3\2\2\2\u06c6\u06c7\3\2"+ 21537 "\2\2\u06c7\u06c5\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u008b\3\2\2\2\u06c9"+ 21538 "\u06cf\7\36\2\2\u06ca\u06cb\7 \2\2\u06cb\u06cd\7#\2\2\u06cc\u06ce\5\u008e"+ 21539 "H\2\u06cd\u06cc\3\2\2\2\u06cd\u06ce\3\2\2\2\u06ce\u06d0\3\2\2\2\u06cf"+ 21540 "\u06ca\3\2\2\2\u06cf\u06d0\3\2\2\2\u06d0\u06d7\3\2\2\2\u06d1\u06d2\7 "+ 21541 "\2\2\u06d2\u06d4\7#\2\2\u06d3\u06d5\5\u008eH\2\u06d4\u06d3\3\2\2\2\u06d4"+ 21542 "\u06d5\3\2\2\2\u06d5\u06d7\3\2\2\2\u06d6\u06c9\3\2\2\2\u06d6\u06d1\3\2"+ 21543 "\2\2\u06d7\u008d\3\2\2\2\u06d8\u06dc\7$\2\2\u06d9\u06db\t\6\2\2\u06da"+ 21544 "\u06d9\3\2\2\2\u06db\u06de\3\2\2\2\u06dc\u06da\3\2\2\2\u06dc\u06dd\3\2"+ 21545 "\2\2\u06dd\u06df\3\2\2\2\u06de\u06dc\3\2\2\2\u06df\u06e0\7%\2\2\u06e0"+ 21546 "\u008f\3\2\2\2\u06e1\u06e3\7\t\2\2\u06e2\u06e4\t\7\2\2\u06e3\u06e2\3\2"+ 21547 "\2\2\u06e4\u06e5\3\2\2\2\u06e5\u06e3\3\2\2\2\u06e5\u06e6\3\2\2\2\u06e6"+ 21548 "\u06e7\3\2\2\2\u06e7\u07a5\5\u008aF\2\u06e8\u06ec\7\n\2\2\u06e9\u06eb"+ 21549 "\t\7\2\2\u06ea\u06e9\3\2\2\2\u06eb\u06ee\3\2\2\2\u06ec\u06ea\3\2\2\2\u06ec"+ 21550 "\u06ed\3\2\2\2\u06ed\u06f1\3\2\2\2\u06ee\u06ec\3\2\2\2\u06ef\u06f0\t\7"+ 21551 "\2\2\u06f0\u06f2\5\u008aF\2\u06f1\u06ef\3\2\2\2\u06f1\u06f2\3\2\2\2\u06f2"+ 21552 "\u07a5\3\2\2\2\u06f3\u06f8\7\13\2\2\u06f4\u06f9\7\6\2\2\u06f5\u06f9\7"+ 21553 "\b\2\2\u06f6\u06f7\6I\25\2\u06f7\u06f9\7\3\2\2\u06f8\u06f4\3\2\2\2\u06f8"+ 21554 "\u06f5\3\2\2\2\u06f8\u06f6\3\2\2\2\u06f9\u06fa\3\2\2\2\u06fa\u06f8\3\2"+ 21555 "\2\2\u06fa\u06fb\3\2\2\2\u06fb\u06fc\3\2\2\2\u06fc\u0700\7-\2\2\u06fd"+ 21556 "\u06ff\t\7\2\2\u06fe\u06fd\3\2\2\2\u06ff\u0702\3\2\2\2\u0700\u06fe\3\2"+ 21557 "\2\2\u0700\u0701\3\2\2\2\u0701\u0705\3\2\2\2\u0702\u0700\3\2\2\2\u0703"+ 21558 "\u0704\t\7\2\2\u0704\u0706\5\u008aF\2\u0705\u0703\3\2\2\2\u0705\u0706"+ 21559 "\3\2\2\2\u0706\u07a5\3\2\2\2\u0707\u070c\7\f\2\2\u0708\u070d\7\6\2\2\u0709"+ 21560 "\u070d\7\b\2\2\u070a\u070b\6I\26\2\u070b\u070d\7\3\2\2\u070c\u0708\3\2"+ 21561 "\2\2\u070c\u0709\3\2\2\2\u070c\u070a\3\2\2\2\u070d\u070e\3\2\2\2\u070e"+ 21562 "\u070c\3\2\2\2\u070e\u070f\3\2\2\2\u070f\u0710\3\2\2\2\u0710\u0714\7\33"+ 21563 "\2\2\u0711\u0713\t\7\2\2\u0712\u0711\3\2\2\2\u0713\u0716\3\2\2\2\u0714"+ 21564 "\u0712\3\2\2\2\u0714\u0715\3\2\2\2\u0715\u0719\3\2\2\2\u0716\u0714\3\2"+ 21565 "\2\2\u0717\u0718\t\7\2\2\u0718\u071a\5\u008aF\2\u0719\u0717\3\2\2\2\u0719"+ 21566 "\u071a\3\2\2\2\u071a\u07a5\3\2\2\2\u071b\u071d\7\r\2\2\u071c\u071e\t\7"+ 21567 "\2\2\u071d\u071c\3\2\2\2\u071e\u071f\3\2\2\2\u071f\u071d\3\2\2\2\u071f"+ 21568 "\u0720\3\2\2\2\u0720\u0721\3\2\2\2\u0721\u07a5\5\u008aF\2\u0722\u0727"+ 21569 "\7\16\2\2\u0723\u0728\7\6\2\2\u0724\u0728\7\b\2\2\u0725\u0726\6I\27\2"+ 21570 "\u0726\u0728\7\3\2\2\u0727\u0723\3\2\2\2\u0727\u0724\3\2\2\2\u0727\u0725"+ 21571 "\3\2\2\2\u0728\u0729\3\2\2\2\u0729\u0727\3\2\2\2\u0729\u072a\3\2\2\2\u072a"+ 21572 "\u072e\3\2\2\2\u072b\u072f\5\u008cG\2\u072c\u072f\7\35\2\2\u072d\u072f"+ 21573 "\5\4\3\2\u072e\u072b\3\2\2\2\u072e\u072c\3\2\2\2\u072e\u072d\3\2\2\2\u072f"+ 21574 "\u0733\3\2\2\2\u0730\u0732\t\7\2\2\u0731\u0730\3\2\2\2\u0732\u0735\3\2"+ 21575 "\2\2\u0733\u0731\3\2\2\2\u0733\u0734\3\2\2\2\u0734\u0738\3\2\2\2\u0735"+ 21576 "\u0733\3\2\2\2\u0736\u0737\t\7\2\2\u0737\u0739\5\u008aF\2\u0738\u0736"+ 21577 "\3\2\2\2\u0738\u0739\3\2\2\2\u0739\u07a5\3\2\2\2\u073a\u073e\7\17\2\2"+ 21578 "\u073b\u073d\t\7\2\2\u073c\u073b\3\2\2\2\u073d\u0740\3\2\2\2\u073e\u073c"+ 21579 "\3\2\2\2\u073e\u073f\3\2\2\2\u073f\u0745\3\2\2\2\u0740\u073e\3\2\2\2\u0741"+ 21580 "\u0742\t\7\2\2\u0742\u0746\5\u008aF\2\u0743\u0746\7\30\2\2\u0744\u0746"+ 21581 "\7\31\2\2\u0745\u0741\3\2\2\2\u0745\u0743\3\2\2\2\u0745\u0744\3\2\2\2"+ 21582 "\u0745\u0746\3\2\2\2\u0746\u074a\3\2\2\2\u0747\u0749\t\7\2\2\u0748\u0747"+ 21583 "\3\2\2\2\u0749\u074c\3\2\2\2\u074a\u0748\3\2\2\2\u074a\u074b\3\2\2\2\u074b"+ 21584 "\u07a5\3\2\2\2\u074c\u074a\3\2\2\2\u074d\u0751\7\21\2\2\u074e\u0750\t"+ 21585 "\7\2\2\u074f\u074e\3\2\2\2\u0750\u0753\3\2\2\2\u0751\u074f\3\2\2\2\u0751"+ 21586 "\u0752\3\2\2\2\u0752\u0756\3\2\2\2\u0753\u0751\3\2\2\2\u0754\u0755\t\7"+ 21587 "\2\2\u0755\u0757\5\u008aF\2\u0756\u0754\3\2\2\2\u0756\u0757\3\2\2\2\u0757"+ 21588 "\u07a5\3\2\2\2\u0758\u075c\7\20\2\2\u0759\u075b\t\7\2\2\u075a\u0759\3"+ 21589 "\2\2\2\u075b\u075e\3\2\2\2\u075c\u075a\3\2\2\2\u075c\u075d\3\2\2\2\u075d"+ 21590 "\u0761\3\2\2\2\u075e\u075c\3\2\2\2\u075f\u0760\t\7\2\2\u0760\u0762\7)"+ 21591 "\2\2\u0761\u075f\3\2\2\2\u0761\u0762\3\2\2\2\u0762\u0766\3\2\2"; 21592 private static final String _serializedATNSegment1 = 21593 "\2\u0763\u0765\t\7\2\2\u0764\u0763\3\2\2\2\u0765\u0768\3\2\2\2\u0766\u0764"+ 21594 "\3\2\2\2\u0766\u0767\3\2\2\2\u0767\u076b\3\2\2\2\u0768\u0766\3\2\2\2\u0769"+ 21595 "\u076a\t\7\2\2\u076a\u076c\7+\2\2\u076b\u0769\3\2\2\2\u076b\u076c\3\2"+ 21596 "\2\2\u076c\u0770\3\2\2\2\u076d\u076f\t\7\2\2\u076e\u076d\3\2\2\2\u076f"+ 21597 "\u0772\3\2\2\2\u0770\u076e\3\2\2\2\u0770\u0771\3\2\2\2\u0771\u0775\3\2"+ 21598 "\2\2\u0772\u0770\3\2\2\2\u0773\u0774\t\7\2\2\u0774\u0776\5\u008aF\2\u0775"+ 21599 "\u0773\3\2\2\2\u0775\u0776\3\2\2\2\u0776\u07a5\3\2\2\2\u0777\u0779\7\22"+ 21600 "\2\2\u0778\u077a\t\7\2\2\u0779\u0778\3\2\2\2\u077a\u077b\3\2\2\2\u077b"+ 21601 "\u0779\3\2\2\2\u077b\u077c\3\2\2\2\u077c\u077d\3\2\2\2\u077d\u07a5\5\u008a"+ 21602 "F\2\u077e\u0783\7\23\2\2\u077f\u0784\7\6\2\2\u0780\u0784\7\b\2\2\u0781"+ 21603 "\u0782\6I\30\2\u0782\u0784\7\3\2\2\u0783\u077f\3\2\2\2\u0783\u0780\3\2"+ 21604 "\2\2\u0783\u0781\3\2\2\2\u0784\u0785\3\2\2\2\u0785\u0783\3\2\2\2\u0785"+ 21605 "\u0786\3\2\2\2\u0786\u0787\3\2\2\2\u0787\u078b\7-\2\2\u0788\u078a\t\7"+ 21606 "\2\2\u0789\u0788\3\2\2\2\u078a\u078d\3\2\2\2\u078b\u0789\3\2\2\2\u078b"+ 21607 "\u078c\3\2\2\2\u078c\u0790\3\2\2\2\u078d\u078b\3\2\2\2\u078e\u078f\t\7"+ 21608 "\2\2\u078f\u0791\5\u008aF\2\u0790\u078e\3\2\2\2\u0790\u0791\3\2\2\2\u0791"+ 21609 "\u07a5\3\2\2\2\u0792\u0794\7\24\2\2\u0793\u0795\t\7\2\2\u0794\u0793\3"+ 21610 "\2\2\2\u0795\u0796\3\2\2\2\u0796\u0794\3\2\2\2\u0796\u0797\3\2\2\2\u0797"+ 21611 "\u0798\3\2\2\2\u0798\u07a5\5\u008aF\2\u0799\u079d\7\27\2\2\u079a\u079c"+ 21612 "\t\7\2\2\u079b\u079a\3\2\2\2\u079c\u079f\3\2\2\2\u079d\u079b\3\2\2\2\u079d"+ 21613 "\u079e\3\2\2\2\u079e\u07a2\3\2\2\2\u079f\u079d\3\2\2\2\u07a0\u07a1\t\7"+ 21614 "\2\2\u07a1\u07a3\5\u008aF\2\u07a2\u07a0\3\2\2\2\u07a2\u07a3\3\2\2\2\u07a3"+ 21615 "\u07a5\3\2\2\2\u07a4\u06e1\3\2\2\2\u07a4\u06e8\3\2\2\2\u07a4\u06f3\3\2"+ 21616 "\2\2\u07a4\u0707\3\2\2\2\u07a4\u071b\3\2\2\2\u07a4\u0722\3\2\2\2\u07a4"+ 21617 "\u073a\3\2\2\2\u07a4\u074d\3\2\2\2\u07a4\u0758\3\2\2\2\u07a4\u0777\3\2"+ 21618 "\2\2\u07a4\u077e\3\2\2\2\u07a4\u0792\3\2\2\2\u07a4\u0799\3\2\2\2\u07a5"+ 21619 "\u0091\3\2\2\2\u07a6\u0801\7\25\2\2\u07a7\u07ae\7/\2\2\u07a8\u07ad\7\6"+ 21620 "\2\2\u07a9\u07ad\7\b\2\2\u07aa\u07ad\7\3\2\2\u07ab\u07ad\5\u0096L\2\u07ac"+ 21621 "\u07a8\3\2\2\2\u07ac\u07a9\3\2\2\2\u07ac\u07aa\3\2\2\2\u07ac\u07ab\3\2"+ 21622 "\2\2\u07ad\u07b0\3\2\2\2\u07ae\u07ac\3\2\2\2\u07ae\u07af\3\2\2\2\u07af"+ 21623 "\u0802\3\2\2\2\u07b0\u07ae\3\2\2\2\u07b1\u07b5\7\60\2\2\u07b2\u07b4\t"+ 21624 "\2\2\2\u07b3\u07b2\3\2\2\2\u07b4\u07b7\3\2\2\2\u07b5\u07b3\3\2\2\2\u07b5"+ 21625 "\u07b6\3\2\2\2\u07b6\u0802\3\2\2\2\u07b7\u07b5\3\2\2\2\u07b8\u07bc\7\61"+ 21626 "\2\2\u07b9\u07bb\t\2\2\2\u07ba\u07b9\3\2\2\2\u07bb\u07be\3\2\2\2\u07bc"+ 21627 "\u07ba\3\2\2\2\u07bc\u07bd\3\2\2\2\u07bd\u0802\3\2\2\2\u07be\u07bc\3\2"+ 21628 "\2\2\u07bf\u07c1\7\62\2\2\u07c0\u07c2\t\2\2\2\u07c1\u07c0\3\2\2\2\u07c2"+ 21629 "\u07c3\3\2\2\2\u07c3\u07c1\3\2\2\2\u07c3\u07c4\3\2\2\2\u07c4\u07c5\3\2"+ 21630 "\2\2\u07c5\u07c9\5\u008cG\2\u07c6\u07c8\t\7\2\2\u07c7\u07c6\3\2\2\2\u07c8"+ 21631 "\u07cb\3\2\2\2\u07c9\u07c7\3\2\2\2\u07c9\u07ca\3\2\2\2\u07ca\u07ce\3\2"+ 21632 "\2\2\u07cb\u07c9\3\2\2\2\u07cc\u07cd\t\7\2\2\u07cd\u07cf\5\u008aF\2\u07ce"+ 21633 "\u07cc\3\2\2\2\u07ce\u07cf\3\2\2\2\u07cf\u0802\3\2\2\2\u07d0\u07d2\7\63"+ 21634 "\2\2\u07d1\u07d3\t\2\2\2\u07d2\u07d1\3\2\2\2\u07d3\u07d4\3\2\2\2\u07d4"+ 21635 "\u07d2\3\2\2\2\u07d4\u07d5\3\2\2\2\u07d5\u07d6\3\2\2\2\u07d6\u07da\5\u008c"+ 21636 "G\2\u07d7\u07d9\t\7\2\2\u07d8\u07d7\3\2\2\2\u07d9\u07dc\3\2\2\2\u07da"+ 21637 "\u07d8\3\2\2\2\u07da\u07db\3\2\2\2\u07db\u07df\3\2\2\2\u07dc\u07da\3\2"+ 21638 "\2\2\u07dd\u07de\t\7\2\2\u07de\u07e0\5\u008aF\2\u07df\u07dd\3\2\2\2\u07df"+ 21639 "\u07e0\3\2\2\2\u07e0\u0802\3\2\2\2\u07e1\u07e8\7\64\2\2\u07e2\u07e7\7"+ 21640 "\6\2\2\u07e3\u07e7\7\b\2\2\u07e4\u07e7\7\3\2\2\u07e5\u07e7\5\u0096L\2"+ 21641 "\u07e6\u07e2\3\2\2\2\u07e6\u07e3\3\2\2\2\u07e6\u07e4\3\2\2\2\u07e6\u07e5"+ 21642 "\3\2\2\2\u07e7\u07ea\3\2\2\2\u07e8\u07e6\3\2\2\2\u07e8\u07e9\3\2\2\2\u07e9"+ 21643 "\u0802\3\2\2\2\u07ea\u07e8\3\2\2\2\u07eb\u07ef\7\65\2\2\u07ec\u07ee\t"+ 21644 "\2\2\2\u07ed\u07ec\3\2\2\2\u07ee\u07f1\3\2\2\2\u07ef\u07ed\3\2\2\2\u07ef"+ 21645 "\u07f0\3\2\2\2\u07f0\u07f4\3\2\2\2\u07f1\u07ef\3\2\2\2\u07f2\u07f3\t\7"+ 21646 "\2\2\u07f3\u07f5\5\u008cG\2\u07f4\u07f2\3\2\2\2\u07f4\u07f5\3\2\2\2\u07f5"+ 21647 "\u0802\3\2\2\2\u07f6\u07fa\7\27\2\2\u07f7\u07f9\t\2\2\2\u07f8\u07f7\3"+ 21648 "\2\2\2\u07f9\u07fc\3\2\2\2\u07fa\u07f8\3\2\2\2\u07fa\u07fb\3\2\2\2\u07fb"+ 21649 "\u07ff\3\2\2\2\u07fc\u07fa\3\2\2\2\u07fd\u07fe\t\7\2\2\u07fe\u0800\5\u008a"+ 21650 "F\2\u07ff\u07fd\3\2\2\2\u07ff\u0800\3\2\2\2\u0800\u0802\3\2\2\2\u0801"+ 21651 "\u07a7\3\2\2\2\u0801\u07b1\3\2\2\2\u0801\u07b8\3\2\2\2\u0801\u07bf\3\2"+ 21652 "\2\2\u0801\u07d0\3\2\2\2\u0801\u07e1\3\2\2\2\u0801\u07eb\3\2\2\2\u0801"+ 21653 "\u07f6\3\2\2\2\u0802\u0803\3\2\2\2\u0803\u0804\7\26\2\2\u0804\u0093\3"+ 21654 "\2\2\2\u0805\u080b\7\4\2\2\u0806\u080a\5\u0096L\2\u0807\u080a\7\b\2\2"+ 21655 "\u0808\u080a\7\3\2\2\u0809\u0806\3\2\2\2\u0809\u0807\3\2\2\2\u0809\u0808"+ 21656 "\3\2\2\2\u080a\u080d\3\2\2\2\u080b\u0809\3\2\2\2\u080b\u080c\3\2\2\2\u080c"+ 21657 "\u080e\3\2\2\2\u080d\u080b\3\2\2\2\u080e\u080f\7]\2\2\u080f\u0095\3\2"+ 21658 "\2\2\u0810\u0811\t\b\2\2\u0811\u0813\bL\1\2\u0812\u0810\3\2\2\2\u0813"+ 21659 "\u0814\3\2\2\2\u0814\u0812\3\2\2\2\u0814\u0815\3\2\2\2\u0815\u0097\3\2"+ 21660 "\2\2\u0816\u0817\7\7\2\2\u0817\u081e\7Y\2\2\u0818\u081d\5\n\6\2\u0819"+ 21661 "\u081d\7\b\2\2\u081a\u081d\7\3\2\2\u081b\u081d\7\6\2\2\u081c\u0818\3\2"+ 21662 "\2\2\u081c\u0819\3\2\2\2\u081c\u081a\3\2\2\2\u081c\u081b\3\2\2\2\u081d"+ 21663 "\u0820\3\2\2\2\u081e\u081c\3\2\2\2\u081e\u081f\3\2\2\2\u081f\u0821\3\2"+ 21664 "\2\2\u0820\u081e\3\2\2\2\u0821\u0822\t\4\2\2\u0822\u0099\3\2\2\2\u0823"+ 21665 "\u0824\7\7\2\2\u0824\u082b\7Z\2\2\u0825\u082a\5\n\6\2\u0826\u082a\7\b"+ 21666 "\2\2\u0827\u082a\7\3\2\2\u0828\u082a\7\6\2\2\u0829\u0825\3\2\2\2\u0829"+ 21667 "\u0826\3\2\2\2\u0829\u0827\3\2\2\2\u0829\u0828\3\2\2\2\u082a\u082d\3\2"+ 21668 "\2\2\u082b\u0829\3\2\2\2\u082b\u082c\3\2\2\2\u082c\u082e\3\2\2\2\u082d"+ 21669 "\u082b\3\2\2\2\u082e\u082f\t\4\2\2\u082f\u009b\3\2\2\2\u0830\u0831\7\7"+ 21670 "\2\2\u0831\u0838\7^\2\2\u0832\u0837\5\n\6\2\u0833\u0837\7\b\2\2\u0834"+ 21671 "\u0837\7\3\2\2\u0835\u0837\7\6\2\2\u0836\u0832\3\2\2\2\u0836\u0833\3\2"+ 21672 "\2\2\u0836\u0834\3\2\2\2\u0836\u0835\3\2\2\2\u0837\u083a\3\2\2\2\u0838"+ 21673 "\u0836\3\2\2\2\u0838\u0839\3\2\2\2\u0839\u083b\3\2\2\2\u083a\u0838\3\2"+ 21674 "\2\2\u083b\u083c\t\4\2\2\u083c\u009d\3\2\2\2\u083d\u083e\7\7\2\2\u083e"+ 21675 "\u0845\7_\2\2\u083f\u0844\5\n\6\2\u0840\u0844\7\b\2\2\u0841\u0844\7\3"+ 21676 "\2\2\u0842\u0844\7\6\2\2\u0843\u083f\3\2\2\2\u0843\u0840\3\2\2\2\u0843"+ 21677 "\u0841\3\2\2\2\u0843\u0842\3\2\2\2\u0844\u0847\3\2\2\2\u0845\u0843\3\2"+ 21678 "\2\2\u0845\u0846\3\2\2\2\u0846\u0848\3\2\2\2\u0847\u0845\3\2\2\2\u0848"+ 21679 "\u0849\t\4\2\2\u0849\u009f\3\2\2\2\u084a\u084b\7\7\2\2\u084b\u0852\7`"+ 21680 "\2\2\u084c\u0851\5\n\6\2\u084d\u0851\7\b\2\2\u084e\u0851\7\3\2\2\u084f"+ 21681 "\u0851\7\6\2\2\u0850\u084c\3\2\2\2\u0850\u084d\3\2\2\2\u0850\u084e\3\2"+ 21682 "\2\2\u0850\u084f\3\2\2\2\u0851\u0854\3\2\2\2\u0852\u0850\3\2\2\2\u0852"+ 21683 "\u0853\3\2\2\2\u0853\u0855\3\2\2\2\u0854\u0852\3\2\2\2\u0855\u0856\t\4"+ 21684 "\2\2\u0856\u00a1\3\2\2\2\u0857\u0858\7\7\2\2\u0858\u085f\7a\2\2\u0859"+ 21685 "\u085e\5\n\6\2\u085a\u085e\7\b\2\2\u085b\u085e\7\3\2\2\u085c\u085e\7\6"+ 21686 "\2\2\u085d\u0859\3\2\2\2\u085d\u085a\3\2\2\2\u085d\u085b\3\2\2\2\u085d"+ 21687 "\u085c\3\2\2\2\u085e\u0861\3\2\2\2\u085f\u085d\3\2\2\2\u085f\u0860\3\2"+ 21688 "\2\2\u0860\u0862\3\2\2\2\u0861\u085f\3\2\2\2\u0862\u0863\79\2\2\u0863"+ 21689 "\u00a3\3\2\2\2\u0864\u0865\7\7\2\2\u0865\u0866\7;\2\2\u0866\u086a\7a\2"+ 21690 "\2\u0867\u0869\t\2\2\2\u0868\u0867\3\2\2\2\u0869\u086c\3\2\2\2\u086a\u0868"+ 21691 "\3\2\2\2\u086a\u086b\3\2\2\2\u086b\u086d\3\2\2\2\u086c\u086a\3\2\2\2\u086d"+ 21692 "\u086e\79\2\2\u086e\u00a5\3\2\2\2\u086f\u0896\5\u00a2R\2\u0870\u0895\5"+ 21693 "\f\7\2\u0871\u0895\5h\65\2\u0872\u0895\5\22\n\2\u0873\u0895\5\30\r\2\u0874"+ 21694 "\u0895\5\36\20\2\u0875\u0895\5$\23\2\u0876\u0895\5*\26\2\u0877\u0895\5"+ 21695 "\60\31\2\u0878\u0895\5\66\34\2\u0879\u0895\5<\37\2\u087a\u0895\5B\"\2"+ 21696 "\u087b\u0895\5H%\2\u087c\u0895\5N(\2\u087d\u0895\5T+\2\u087e\u0895\5Z"+ 21697 ".\2\u087f\u0895\5`\61\2\u0880\u0895\5\16\b\2\u0881\u0895\5\24\13\2\u0882"+ 21698 "\u0895\5\32\16\2\u0883\u0895\5 \21\2\u0884\u0895\5&\24\2\u0885\u0895\5"+ 21699 ",\27\2\u0886\u0895\5\62\32\2\u0887\u0895\58\35\2\u0888\u0895\5> \2\u0889"+ 21700 "\u0895\5D#\2\u088a\u0895\5J&\2\u088b\u0895\5P)\2\u088c\u0895\5V,\2\u088d"+ 21701 "\u0895\5\\/\2\u088e\u088f\6T\31\2\u088f\u0895\7\3\2\2\u0890\u0895\5\u0094"+ 21702 "K\2\u0891\u0895\7\b\2\2\u0892\u0895\5\u0096L\2\u0893\u0895\5\u0092J\2"+ 21703 "\u0894\u0870\3\2\2\2\u0894\u0871\3\2\2\2\u0894\u0872\3\2\2\2\u0894\u0873"+ 21704 "\3\2\2\2\u0894\u0874\3\2\2\2\u0894\u0875\3\2\2\2\u0894\u0876\3\2\2\2\u0894"+ 21705 "\u0877\3\2\2\2\u0894\u0878\3\2\2\2\u0894\u0879\3\2\2\2\u0894\u087a\3\2"+ 21706 "\2\2\u0894\u087b\3\2\2\2\u0894\u087c\3\2\2\2\u0894\u087d\3\2\2\2\u0894"+ 21707 "\u087e\3\2\2\2\u0894\u087f\3\2\2\2\u0894\u0880\3\2\2\2\u0894\u0881\3\2"+ 21708 "\2\2\u0894\u0882\3\2\2\2\u0894\u0883\3\2\2\2\u0894\u0884\3\2\2\2\u0894"+ 21709 "\u0885\3\2\2\2\u0894\u0886\3\2\2\2\u0894\u0887\3\2\2\2\u0894\u0888\3\2"+ 21710 "\2\2\u0894\u0889\3\2\2\2\u0894\u088a\3\2\2\2\u0894\u088b\3\2\2\2\u0894"+ 21711 "\u088c\3\2\2\2\u0894\u088d\3\2\2\2\u0894\u088e\3\2\2\2\u0894\u0890\3\2"+ 21712 "\2\2\u0894\u0891\3\2\2\2\u0894\u0892\3\2\2\2\u0894\u0893\3\2\2\2\u0895"+ 21713 "\u0898\3\2\2\2\u0896\u0894\3\2\2\2\u0896\u0897\3\2\2\2\u0897\u0899\3\2"+ 21714 "\2\2\u0898\u0896\3\2\2\2\u0899\u089a\5\u00a4S\2\u089a\u00a7\3\2\2\2\u089b"+ 21715 "\u089c\7\7\2\2\u089c\u08a3\7b\2\2\u089d\u08a2\5\n\6\2\u089e\u08a2\7\b"+ 21716 "\2\2\u089f\u08a2\7\3\2\2\u08a0\u08a2\7\6\2\2\u08a1\u089d\3\2\2\2\u08a1"+ 21717 "\u089e\3\2\2\2\u08a1\u089f\3\2\2\2\u08a1\u08a0\3\2\2\2\u08a2\u08a5\3\2"+ 21718 "\2\2\u08a3\u08a1\3\2\2\2\u08a3\u08a4\3\2\2\2\u08a4\u08a6\3\2\2\2\u08a5"+ 21719 "\u08a3\3\2\2\2\u08a6\u08a7\79\2\2\u08a7\u00a9\3\2\2\2\u08a8\u08a9\7\7"+ 21720 "\2\2\u08a9\u08aa\7;\2\2\u08aa\u08ae\7b\2\2\u08ab\u08ad\t\2\2\2\u08ac\u08ab"+ 21721 "\3\2\2\2\u08ad\u08b0\3\2\2\2\u08ae\u08ac\3\2\2\2\u08ae\u08af\3\2\2\2\u08af"+ 21722 "\u08b1\3\2\2\2\u08b0\u08ae\3\2\2\2\u08b1\u08b2\79\2\2\u08b2\u00ab\3\2"+ 21723 "\2\2\u08b3\u08da\5\u00a8U\2\u08b4\u08d9\5\f\7\2\u08b5\u08d9\5h\65\2\u08b6"+ 21724 "\u08d9\5\22\n\2\u08b7\u08d9\5\30\r\2\u08b8\u08d9\5\36\20\2\u08b9\u08d9"+ 21725 "\5$\23\2\u08ba\u08d9\5*\26\2\u08bb\u08d9\5\60\31\2\u08bc\u08d9\5\66\34"+ 21726 "\2\u08bd\u08d9\5<\37\2\u08be\u08d9\5B\"\2\u08bf\u08d9\5H%\2\u08c0\u08d9"+ 21727 "\5N(\2\u08c1\u08d9\5T+\2\u08c2\u08d9\5Z.\2\u08c3\u08d9\5`\61\2\u08c4\u08d9"+ 21728 "\5\16\b\2\u08c5\u08d9\5\24\13\2\u08c6\u08d9\5\32\16\2\u08c7\u08d9\5 \21"+ 21729 "\2\u08c8\u08d9\5&\24\2\u08c9\u08d9\5,\27\2\u08ca\u08d9\5\62\32\2\u08cb"+ 21730 "\u08d9\58\35\2\u08cc\u08d9\5> \2\u08cd\u08d9\5D#\2\u08ce\u08d9\5J&\2\u08cf"+ 21731 "\u08d9\5P)\2\u08d0\u08d9\5V,\2\u08d1\u08d9\5\\/\2\u08d2\u08d3\6W\32\2"+ 21732 "\u08d3\u08d9\7\3\2\2\u08d4\u08d9\5\u0094K\2\u08d5\u08d9\7\b\2\2\u08d6"+ 21733 "\u08d9\5\u0096L\2\u08d7\u08d9\5\u0092J\2\u08d8\u08b4\3\2\2\2\u08d8\u08b5"+ 21734 "\3\2\2\2\u08d8\u08b6\3\2\2\2\u08d8\u08b7\3\2\2\2\u08d8\u08b8\3\2\2\2\u08d8"+ 21735 "\u08b9\3\2\2\2\u08d8\u08ba\3\2\2\2\u08d8\u08bb\3\2\2\2\u08d8\u08bc\3\2"+ 21736 "\2\2\u08d8\u08bd\3\2\2\2\u08d8\u08be\3\2\2\2\u08d8\u08bf\3\2\2\2\u08d8"+ 21737 "\u08c0\3\2\2\2\u08d8\u08c1\3\2\2\2\u08d8\u08c2\3\2\2\2\u08d8\u08c3\3\2"+ 21738 "\2\2\u08d8\u08c4\3\2\2\2\u08d8\u08c5\3\2\2\2\u08d8\u08c6\3\2\2\2\u08d8"+ 21739 "\u08c7\3\2\2\2\u08d8\u08c8\3\2\2\2\u08d8\u08c9\3\2\2\2\u08d8\u08ca\3\2"+ 21740 "\2\2\u08d8\u08cb\3\2\2\2\u08d8\u08cc\3\2\2\2\u08d8\u08cd\3\2\2\2\u08d8"+ 21741 "\u08ce\3\2\2\2\u08d8\u08cf\3\2\2\2\u08d8\u08d0\3\2\2\2\u08d8\u08d1\3\2"+ 21742 "\2\2\u08d8\u08d2\3\2\2\2\u08d8\u08d4\3\2\2\2\u08d8\u08d5\3\2\2\2\u08d8"+ 21743 "\u08d6\3\2\2\2\u08d8\u08d7\3\2\2\2\u08d9\u08dc\3\2\2\2\u08da\u08d8\3\2"+ 21744 "\2\2\u08da\u08db\3\2\2\2\u08db\u08dd\3\2\2\2\u08dc\u08da\3\2\2\2\u08dd"+ 21745 "\u08de\5\u00aaV\2\u08de\u00ad\3\2\2\2\u08df\u08e0\7\7\2\2\u08e0\u08e7"+ 21746 "\7c\2\2\u08e1\u08e6\5\n\6\2\u08e2\u08e6\7\b\2\2\u08e3\u08e6\7\3\2\2\u08e4"+ 21747 "\u08e6\7\6\2\2\u08e5\u08e1\3\2\2\2\u08e5\u08e2\3\2\2\2\u08e5\u08e3\3\2"+ 21748 "\2\2\u08e5\u08e4\3\2\2\2\u08e6\u08e9\3\2\2\2\u08e7\u08e5\3\2\2\2\u08e7"+ 21749 "\u08e8\3\2\2\2\u08e8\u08ea\3\2\2\2\u08e9\u08e7\3\2\2\2\u08ea\u08eb\79"+ 21750 "\2\2\u08eb\u00af\3\2\2\2\u08ec\u08ed\7\7\2\2\u08ed\u08ee\7;\2\2\u08ee"+ 21751 "\u08f2\7c\2\2\u08ef\u08f1\t\2\2\2\u08f0\u08ef\3\2\2\2\u08f1\u08f4\3\2"+ 21752 "\2\2\u08f2\u08f0\3\2\2\2\u08f2\u08f3\3\2\2\2\u08f3\u08f5\3\2\2\2\u08f4"+ 21753 "\u08f2\3\2\2\2\u08f5\u08f6\79\2\2\u08f6\u00b1\3\2\2\2\u08f7\u091e\5\u00ae"+ 21754 "X\2\u08f8\u091d\5\f\7\2\u08f9\u091d\5h\65\2\u08fa\u091d\5\22\n\2\u08fb"+ 21755 "\u091d\5\30\r\2\u08fc\u091d\5\36\20\2\u08fd\u091d\5$\23\2\u08fe\u091d"+ 21756 "\5*\26\2\u08ff\u091d\5\60\31\2\u0900\u091d\5\66\34\2\u0901\u091d\5<\37"+ 21757 "\2\u0902\u091d\5B\"\2\u0903\u091d\5H%\2\u0904\u091d\5N(\2\u0905\u091d"+ 21758 "\5T+\2\u0906\u091d\5Z.\2\u0907\u091d\5`\61\2\u0908\u091d\5\16\b\2\u0909"+ 21759 "\u091d\5\24\13\2\u090a\u091d\5\32\16\2\u090b\u091d\5 \21\2\u090c\u091d"+ 21760 "\5&\24\2\u090d\u091d\5,\27\2\u090e\u091d\5\62\32\2\u090f\u091d\58\35\2"+ 21761 "\u0910\u091d\5> \2\u0911\u091d\5D#\2\u0912\u091d\5J&\2\u0913\u091d\5P"+ 21762 ")\2\u0914\u091d\5V,\2\u0915\u091d\5\\/\2\u0916\u0917\6Z\33\2\u0917\u091d"+ 21763 "\7\3\2\2\u0918\u091d\5\u0094K\2\u0919\u091d\7\b\2\2\u091a\u091d\5\u0096"+ 21764 "L\2\u091b\u091d\5\u0092J\2\u091c\u08f8\3\2\2\2\u091c\u08f9\3\2\2\2\u091c"+ 21765 "\u08fa\3\2\2\2\u091c\u08fb\3\2\2\2\u091c\u08fc\3\2\2\2\u091c\u08fd\3\2"+ 21766 "\2\2\u091c\u08fe\3\2\2\2\u091c\u08ff\3\2\2\2\u091c\u0900\3\2\2\2\u091c"+ 21767 "\u0901\3\2\2\2\u091c\u0902\3\2\2\2\u091c\u0903\3\2\2\2\u091c\u0904\3\2"+ 21768 "\2\2\u091c\u0905\3\2\2\2\u091c\u0906\3\2\2\2\u091c\u0907\3\2\2\2\u091c"+ 21769 "\u0908\3\2\2\2\u091c\u0909\3\2\2\2\u091c\u090a\3\2\2\2\u091c\u090b\3\2"+ 21770 "\2\2\u091c\u090c\3\2\2\2\u091c\u090d\3\2\2\2\u091c\u090e\3\2\2\2\u091c"+ 21771 "\u090f\3\2\2\2\u091c\u0910\3\2\2\2\u091c\u0911\3\2\2\2\u091c\u0912\3\2"+ 21772 "\2\2\u091c\u0913\3\2\2\2\u091c\u0914\3\2\2\2\u091c\u0915\3\2\2\2\u091c"+ 21773 "\u0916\3\2\2\2\u091c\u0918\3\2\2\2\u091c\u0919\3\2\2\2\u091c\u091a\3\2"+ 21774 "\2\2\u091c\u091b\3\2\2\2\u091d\u0920\3\2\2\2\u091e\u091c\3\2\2\2\u091e"+ 21775 "\u091f\3\2\2\2\u091f\u0921\3\2\2\2\u0920\u091e\3\2\2\2\u0921\u0922\5\u00b0"+ 21776 "Y\2\u0922\u00b3\3\2\2\2\u0923\u0924\7\7\2\2\u0924\u092b\7d\2\2\u0925\u092a"+ 21777 "\5\n\6\2\u0926\u092a\7\b\2\2\u0927\u092a\7\3\2\2\u0928\u092a\7\6\2\2\u0929"+ 21778 "\u0925\3\2\2\2\u0929\u0926\3\2\2\2\u0929\u0927\3\2\2\2\u0929\u0928\3\2"+ 21779 "\2\2\u092a\u092d\3\2\2\2\u092b\u0929\3\2\2\2\u092b\u092c\3\2\2\2\u092c"+ 21780 "\u092e\3\2\2\2\u092d\u092b\3\2\2\2\u092e\u092f\79\2\2\u092f\u00b5\3\2"+ 21781 "\2\2\u0930\u0931\7\7\2\2\u0931\u0932\7;\2\2\u0932\u0936\7d\2\2\u0933\u0935"+ 21782 "\t\2\2\2\u0934\u0933\3\2\2\2\u0935\u0938\3\2\2\2\u0936\u0934\3\2\2\2\u0936"+ 21783 "\u0937\3\2\2\2\u0937\u0939\3\2\2\2\u0938\u0936\3\2\2\2\u0939\u093a\79"+ 21784 "\2\2\u093a\u00b7\3\2\2\2\u093b\u0962\5\u00b4[\2\u093c\u0961\5\f\7\2\u093d"+ 21785 "\u0961\5h\65\2\u093e\u0961\5\22\n\2\u093f\u0961\5\30\r\2\u0940\u0961\5"+ 21786 "\36\20\2\u0941\u0961\5$\23\2\u0942\u0961\5*\26\2\u0943\u0961\5\60\31\2"+ 21787 "\u0944\u0961\5\66\34\2\u0945\u0961\5<\37\2\u0946\u0961\5B\"\2\u0947\u0961"+ 21788 "\5H%\2\u0948\u0961\5N(\2\u0949\u0961\5T+\2\u094a\u0961\5Z.\2\u094b\u0961"+ 21789 "\5`\61\2\u094c\u0961\5\16\b\2\u094d\u0961\5\24\13\2\u094e\u0961\5\32\16"+ 21790 "\2\u094f\u0961\5 \21\2\u0950\u0961\5&\24\2\u0951\u0961\5,\27\2\u0952\u0961"+ 21791 "\5\62\32\2\u0953\u0961\58\35\2\u0954\u0961\5> \2\u0955\u0961\5D#\2\u0956"+ 21792 "\u0961\5J&\2\u0957\u0961\5P)\2\u0958\u0961\5V,\2\u0959\u0961\5\\/\2\u095a"+ 21793 "\u095b\6]\34\2\u095b\u0961\7\3\2\2\u095c\u0961\5\u0094K\2\u095d\u0961"+ 21794 "\7\b\2\2\u095e\u0961\5\u0096L\2\u095f\u0961\5\u0092J\2\u0960\u093c\3\2"+ 21795 "\2\2\u0960\u093d\3\2\2\2\u0960\u093e\3\2\2\2\u0960\u093f\3\2\2\2\u0960"+ 21796 "\u0940\3\2\2\2\u0960\u0941\3\2\2\2\u0960\u0942\3\2\2\2\u0960\u0943\3\2"+ 21797 "\2\2\u0960\u0944\3\2\2\2\u0960\u0945\3\2\2\2\u0960\u0946\3\2\2\2\u0960"+ 21798 "\u0947\3\2\2\2\u0960\u0948\3\2\2\2\u0960\u0949\3\2\2\2\u0960\u094a\3\2"+ 21799 "\2\2\u0960\u094b\3\2\2\2\u0960\u094c\3\2\2\2\u0960\u094d\3\2\2\2\u0960"+ 21800 "\u094e\3\2\2\2\u0960\u094f\3\2\2\2\u0960\u0950\3\2\2\2\u0960\u0951\3\2"+ 21801 "\2\2\u0960\u0952\3\2\2\2\u0960\u0953\3\2\2\2\u0960\u0954\3\2\2\2\u0960"+ 21802 "\u0955\3\2\2\2\u0960\u0956\3\2\2\2\u0960\u0957\3\2\2\2\u0960\u0958\3\2"+ 21803 "\2\2\u0960\u0959\3\2\2\2\u0960\u095a\3\2\2\2\u0960\u095c\3\2\2\2\u0960"+ 21804 "\u095d\3\2\2\2\u0960\u095e\3\2\2\2\u0960\u095f\3\2\2\2\u0961\u0964\3\2"+ 21805 "\2\2\u0962\u0960\3\2\2\2\u0962\u0963\3\2\2\2\u0963\u0965\3\2\2\2\u0964"+ 21806 "\u0962\3\2\2\2\u0965\u0966\5\u00b6\\\2\u0966\u00b9\3\2\2\2\u0967\u0968"+ 21807 "\7\7\2\2\u0968\u096f\7e\2\2\u0969\u096e\5\n\6\2\u096a\u096e\7\b\2\2\u096b"+ 21808 "\u096e\7\3\2\2\u096c\u096e\7\6\2\2\u096d\u0969\3\2\2\2\u096d\u096a\3\2"+ 21809 "\2\2\u096d\u096b\3\2\2\2\u096d\u096c\3\2\2\2\u096e\u0971\3\2\2\2\u096f"+ 21810 "\u096d\3\2\2\2\u096f\u0970\3\2\2\2\u0970\u0972\3\2\2\2\u0971\u096f\3\2"+ 21811 "\2\2\u0972\u0973\79\2\2\u0973\u00bb\3\2\2\2\u0974\u0975\7\7\2\2\u0975"+ 21812 "\u0976\7;\2\2\u0976\u097a\7e\2\2\u0977\u0979\t\2\2\2\u0978\u0977\3\2\2"+ 21813 "\2\u0979\u097c\3\2\2\2\u097a\u0978\3\2\2\2\u097a\u097b\3\2\2\2\u097b\u097d"+ 21814 "\3\2\2\2\u097c\u097a\3\2\2\2\u097d\u097e\79\2\2\u097e\u00bd\3\2\2\2\u097f"+ 21815 "\u09a6\5\u00ba^\2\u0980\u09a5\5\f\7\2\u0981\u09a5\5h\65\2\u0982\u09a5"+ 21816 "\5\22\n\2\u0983\u09a5\5\30\r\2\u0984\u09a5\5\36\20\2\u0985\u09a5\5$\23"+ 21817 "\2\u0986\u09a5\5*\26\2\u0987\u09a5\5\60\31\2\u0988\u09a5\5\66\34\2\u0989"+ 21818 "\u09a5\5<\37\2\u098a\u09a5\5B\"\2\u098b\u09a5\5H%\2\u098c\u09a5\5N(\2"+ 21819 "\u098d\u09a5\5T+\2\u098e\u09a5\5Z.\2\u098f\u09a5\5`\61\2\u0990\u09a5\5"+ 21820 "\16\b\2\u0991\u09a5\5\24\13\2\u0992\u09a5\5\32\16\2\u0993\u09a5\5 \21"+ 21821 "\2\u0994\u09a5\5&\24\2\u0995\u09a5\5,\27\2\u0996\u09a5\5\62\32\2\u0997"+ 21822 "\u09a5\58\35\2\u0998\u09a5\5> \2\u0999\u09a5\5D#\2\u099a\u09a5\5J&\2\u099b"+ 21823 "\u09a5\5P)\2\u099c\u09a5\5V,\2\u099d\u09a5\5\\/\2\u099e\u099f\6`\35\2"+ 21824 "\u099f\u09a5\7\3\2\2\u09a0\u09a5\5\u0094K\2\u09a1\u09a5\7\b\2\2\u09a2"+ 21825 "\u09a5\5\u0096L\2\u09a3\u09a5\5\u0092J\2\u09a4\u0980\3\2\2\2\u09a4\u0981"+ 21826 "\3\2\2\2\u09a4\u0982\3\2\2\2\u09a4\u0983\3\2\2\2\u09a4\u0984\3\2\2\2\u09a4"+ 21827 "\u0985\3\2\2\2\u09a4\u0986\3\2\2\2\u09a4\u0987\3\2\2\2\u09a4\u0988\3\2"+ 21828 "\2\2\u09a4\u0989\3\2\2\2\u09a4\u098a\3\2\2\2\u09a4\u098b\3\2\2\2\u09a4"+ 21829 "\u098c\3\2\2\2\u09a4\u098d\3\2\2\2\u09a4\u098e\3\2\2\2\u09a4\u098f\3\2"+ 21830 "\2\2\u09a4\u0990\3\2\2\2\u09a4\u0991\3\2\2\2\u09a4\u0992\3\2\2\2\u09a4"+ 21831 "\u0993\3\2\2\2\u09a4\u0994\3\2\2\2\u09a4\u0995\3\2\2\2\u09a4\u0996\3\2"+ 21832 "\2\2\u09a4\u0997\3\2\2\2\u09a4\u0998\3\2\2\2\u09a4\u0999\3\2\2\2\u09a4"+ 21833 "\u099a\3\2\2\2\u09a4\u099b\3\2\2\2\u09a4\u099c\3\2\2\2\u09a4\u099d\3\2"+ 21834 "\2\2\u09a4\u099e\3\2\2\2\u09a4\u09a0\3\2\2\2\u09a4\u09a1\3\2\2\2\u09a4"+ 21835 "\u09a2\3\2\2\2\u09a4\u09a3\3\2\2\2\u09a5\u09a8\3\2\2\2\u09a6\u09a4\3\2"+ 21836 "\2\2\u09a6\u09a7\3\2\2\2\u09a7\u09a9\3\2\2\2\u09a8\u09a6\3\2\2\2\u09a9"+ 21837 "\u09aa\5\u00bc_\2\u09aa\u00bf\3\2\2\2\u00db\u00c7\u00c9\u00cd\u00d2\u00d8"+ 21838 "\u011b\u0123\u0125\u0130\u0139\u0140\u0146\u0150\u0152\u015e\u0160\u016b"+ 21839 "\u019f\u01a1\u01ac\u01ae\u01b9\u01ed\u01ef\u01fa\u01fc\u0207\u023b\u023d"+ 21840 "\u0248\u024a\u0255\u0289\u028b\u0296\u0298\u02a3\u02d7\u02d9\u02e4\u02e6"+ 21841 "\u02f1\u0325\u0327\u0332\u0334\u033f\u0373\u0375\u0380\u0382\u038d\u03c1"+ 21842 "\u03c3\u03ce\u03d0\u03db\u040f\u0411\u041c\u041e\u0429\u045d\u045f\u046a"+ 21843 "\u046c\u0477\u04ab\u04ad\u04b8\u04ba\u04c5\u04f9\u04fb\u0506\u0508\u0513"+ 21844 "\u0547\u0549\u0554\u0556\u0561\u0595\u0597\u05a2\u05a4\u05af\u05e3\u05e5"+ 21845 "\u05fe\u0606\u0608\u0613\u0615\u0620\u0622\u062d\u062f\u063a\u063c\u0647"+ 21846 "\u0649\u0654\u0656\u0661\u0663\u066e\u0670\u067b\u067d\u0688\u068a\u0695"+ 21847 "\u0697\u06a2\u06a4\u06af\u06b1\u06c5\u06c7\u06cd\u06cf\u06d4\u06d6\u06dc"+ 21848 "\u06e5\u06ec\u06f1\u06f8\u06fa\u0700\u0705\u070c\u070e\u0714\u0719\u071f"+ 21849 "\u0727\u0729\u072e\u0733\u0738\u073e\u0745\u074a\u0751\u0756\u075c\u0761"+ 21850 "\u0766\u076b\u0770\u0775\u077b\u0783\u0785\u078b\u0790\u0796\u079d\u07a2"+ 21851 "\u07a4\u07ac\u07ae\u07b5\u07bc\u07c3\u07c9\u07ce\u07d4\u07da\u07df\u07e6"+ 21852 "\u07e8\u07ef\u07f4\u07fa\u07ff\u0801\u0809\u080b\u0814\u081c\u081e\u0829"+ 21853 "\u082b\u0836\u0838\u0843\u0845\u0850\u0852\u085d\u085f\u086a\u0894\u0896"+ 21854 "\u08a1\u08a3\u08ae\u08d8\u08da\u08e5\u08e7\u08f2\u091c\u091e\u0929\u092b"+ 21855 "\u0936\u0960\u0962\u096d\u096f\u097a\u09a4\u09a6"; 21856 public static final String _serializedATN = Utils.join( 21857 new String[] { 21858 _serializedATNSegment0, 21859 _serializedATNSegment1 21860 }, 21861 "" 21862 ); 21863 public static final ATN _ATN = 21864 new ATNDeserializer().deserialize(_serializedATN.toCharArray()); 21865 static { 21866 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; 21867 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { 21868 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); 21869 } 21870 } 21871}