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, CDATA=3, WS=4, START=5, NEWLINE=6, 021 AUTHOR_LITERAL=7, DEPRECATED_LITERAL=8, EXCEPTION_LITERAL=9, PARAM_LITERAL=10, 022 RETURN_LITERAL=11, SEE_LITERAL=12, SERIAL_LITERAL=13, SERIAL_FIELD_LITERAL=14, 023 SERIAL_DATA_LITERAL=15, SINCE_LITERAL=16, THROWS_LITERAL=17, VERSION_LITERAL=18, 024 JAVADOC_INLINE_TAG_START=19, JAVADOC_INLINE_TAG_END=20, CUSTOM_NAME=21, 025 LITERAL_INCLUDE=22, LITERAL_EXCLUDE=23, CHAR=24, PARAMETER_NAME=25, Char1=26, 026 STRING=27, PACKAGE_CLASS=28, DOT=29, HASH=30, CLASS=31, Char2=32, MEMBER=33, 027 LEFT_BRACE=34, RIGHT_BRACE=35, ARGUMENT=36, COMMA=37, Char20=38, FIELD_NAME=39, 028 Char3=40, FIELD_TYPE=41, Char4=42, CLASS_NAME=43, Char5=44, CODE_LITERAL=45, 029 DOC_ROOT_LITERAL=46, INHERIT_DOC_LITERAL=47, LINK_LITERAL=48, LINKPLAIN_LITERAL=49, 030 LITERAL_LITERAL=50, VALUE_LITERAL=51, Char7=52, Char8=53, Char10=54, END=55, 031 SLASH_END=56, SLASH=57, EQUALS=58, P_HTML_TAG_NAME=59, LI_HTML_TAG_NAME=60, 032 TR_HTML_TAG_NAME=61, TD_HTML_TAG_NAME=62, TH_HTML_TAG_NAME=63, BODY_HTML_TAG_NAME=64, 033 COLGROUP_HTML_TAG_NAME=65, DD_HTML_TAG_NAME=66, DT_HTML_TAG_NAME=67, HEAD_HTML_TAG_NAME=68, 034 HTML_HTML_TAG_NAME=69, OPTION_HTML_TAG_NAME=70, TBODY_HTML_TAG_NAME=71, 035 TFOOT_HTML_TAG_NAME=72, THEAD_HTML_TAG_NAME=73, AREA_HTML_TAG_NAME=74, 036 BASE_HTML_TAG_NAME=75, BASEFONT_HTML_TAG_NAME=76, BR_HTML_TAG_NAME=77, 037 COL_HTML_TAG_NAME=78, FRAME_HTML_TAG_NAME=79, HR_HTML_TAG_NAME=80, IMG_HTML_TAG_NAME=81, 038 INPUT_HTML_TAG_NAME=82, ISINDEX_HTML_TAG_NAME=83, LINK_HTML_TAG_NAME=84, 039 META_HTML_TAG_NAME=85, PARAM_HTML_TAG_NAME=86, EMBED_HTML_TAG_NAME=87, 040 KEYGEN_HTML_TAG_NAME=88, ATTR_VALUE=89, Char12=90, HTML_COMMENT_END=91, 041 SOURCE_HTML_TAG_NAME=92, TRACK_HTML_TAG_NAME=93, WBR_HTML_TAG_NAME=94, 042 OPTGROUP_HTML_TAG_NAME=95, RB_HTML_TAG_NAME=96, RT_HTML_TAG_NAME=97, RTC_HTML_TAG_NAME=98, 043 RP_HTML_TAG_NAME=99, HTML_TAG_NAME=100, Char11=101; 044 public static final int 045 RULE_javadoc = 0, RULE_htmlElement = 1, RULE_htmlElementStart = 2, RULE_htmlElementEnd = 3, 046 RULE_attribute = 4, RULE_htmlTag = 5, RULE_pTagStart = 6, RULE_pTagEnd = 7, 047 RULE_paragraph = 8, RULE_liTagStart = 9, RULE_liTagEnd = 10, RULE_li = 11, 048 RULE_trTagStart = 12, RULE_trTagEnd = 13, RULE_tr = 14, RULE_tdTagStart = 15, 049 RULE_tdTagEnd = 16, RULE_td = 17, RULE_thTagStart = 18, RULE_thTagEnd = 19, 050 RULE_th = 20, RULE_bodyTagStart = 21, RULE_bodyTagEnd = 22, RULE_body = 23, 051 RULE_colgroupTagStart = 24, RULE_colgroupTagEnd = 25, RULE_colgroup = 26, 052 RULE_ddTagStart = 27, RULE_ddTagEnd = 28, RULE_dd = 29, RULE_dtTagStart = 30, 053 RULE_dtTagEnd = 31, RULE_dt = 32, RULE_headTagStart = 33, RULE_headTagEnd = 34, 054 RULE_head = 35, RULE_htmlTagStart = 36, RULE_htmlTagEnd = 37, RULE_html = 38, 055 RULE_optionTagStart = 39, RULE_optionTagEnd = 40, RULE_option = 41, RULE_tbodyTagStart = 42, 056 RULE_tbodyTagEnd = 43, RULE_tbody = 44, RULE_tfootTagStart = 45, RULE_tfootTagEnd = 46, 057 RULE_tfoot = 47, RULE_theadTagStart = 48, RULE_theadTagEnd = 49, RULE_thead = 50, 058 RULE_singletonElement = 51, RULE_emptyTag = 52, RULE_areaTag = 53, RULE_baseTag = 54, 059 RULE_basefontTag = 55, RULE_brTag = 56, RULE_colTag = 57, RULE_frameTag = 58, 060 RULE_hrTag = 59, RULE_imgTag = 60, RULE_inputTag = 61, RULE_isindexTag = 62, 061 RULE_linkTag = 63, RULE_metaTag = 64, RULE_paramTag = 65, RULE_wrongSingletonTag = 66, 062 RULE_singletonTagName = 67, RULE_description = 68, RULE_reference = 69, 063 RULE_parameters = 70, RULE_javadocTag = 71, RULE_javadocInlineTag = 72, 064 RULE_htmlComment = 73, RULE_text = 74, RULE_embedTag = 75, RULE_keygenTag = 76, 065 RULE_sourceTag = 77, RULE_trackTag = 78, RULE_wbrTag = 79, RULE_optgroupTagStart = 80, 066 RULE_optgroupTagEnd = 81, RULE_optgroup = 82, RULE_rbTagStart = 83, RULE_rbTagEnd = 84, 067 RULE_rb = 85, RULE_rtTagStart = 86, RULE_rtTagEnd = 87, RULE_rt = 88, 068 RULE_rtcTagStart = 89, RULE_rtcTagEnd = 90, RULE_rtc = 91, RULE_rpTagStart = 92, 069 RULE_rpTagEnd = 93, RULE_rp = 94; 070 private static String[] makeRuleNames() { 071 return new String[] { 072 "javadoc", "htmlElement", "htmlElementStart", "htmlElementEnd", "attribute", 073 "htmlTag", "pTagStart", "pTagEnd", "paragraph", "liTagStart", "liTagEnd", 074 "li", "trTagStart", "trTagEnd", "tr", "tdTagStart", "tdTagEnd", "td", 075 "thTagStart", "thTagEnd", "th", "bodyTagStart", "bodyTagEnd", "body", 076 "colgroupTagStart", "colgroupTagEnd", "colgroup", "ddTagStart", "ddTagEnd", 077 "dd", "dtTagStart", "dtTagEnd", "dt", "headTagStart", "headTagEnd", "head", 078 "htmlTagStart", "htmlTagEnd", "html", "optionTagStart", "optionTagEnd", 079 "option", "tbodyTagStart", "tbodyTagEnd", "tbody", "tfootTagStart", "tfootTagEnd", 080 "tfoot", "theadTagStart", "theadTagEnd", "thead", "singletonElement", 081 "emptyTag", "areaTag", "baseTag", "basefontTag", "brTag", "colTag", "frameTag", 082 "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", "paramTag", 083 "wrongSingletonTag", "singletonTagName", "description", "reference", 084 "parameters", "javadocTag", "javadocInlineTag", "htmlComment", "text", 085 "embedTag", "keygenTag", "sourceTag", "trackTag", "wbrTag", "optgroupTagStart", 086 "optgroupTagEnd", "optgroup", "rbTagStart", "rbTagEnd", "rb", "rtTagStart", 087 "rtTagEnd", "rt", "rtcTagStart", "rtcTagEnd", "rtc", "rpTagStart", "rpTagEnd", 088 "rp" 089 }; 090 } 091 public static final String[] ruleNames = makeRuleNames(); 092 093 private static String[] makeLiteralNames() { 094 return new String[] { 095 null, null, null, null, null, null, null, "'@author'", "'@deprecated'", 096 null, null, "'@return'", null, "'@serial'", null, "'@serialData'", "'@since'", 097 null, "'@version'", null, null, null, "'include'", "'exclude'", null, 098 null, null, null, null, "'.'", null, null, null, null, "'('", "')'", 099 null, "','", null, null, null, null, null, null, null, null, "'@docRoot'", 100 "'@inheritDoc'", "'@link'", "'@linkplain'", null, "'@value'", null, null, 101 null, null, null, "'/'", "'='", null, null, null, null, null, null, null, 102 null, null, 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, "'-->'" 105 }; 106 } 107 private static final String[] _LITERAL_NAMES = makeLiteralNames(); 108 private static String[] makeSymbolicNames() { 109 return new String[] { 110 null, "LEADING_ASTERISK", "HTML_COMMENT_START", "CDATA", "WS", "START", 111 "NEWLINE", "AUTHOR_LITERAL", "DEPRECATED_LITERAL", "EXCEPTION_LITERAL", 112 "PARAM_LITERAL", "RETURN_LITERAL", "SEE_LITERAL", "SERIAL_LITERAL", "SERIAL_FIELD_LITERAL", 113 "SERIAL_DATA_LITERAL", "SINCE_LITERAL", "THROWS_LITERAL", "VERSION_LITERAL", 114 "JAVADOC_INLINE_TAG_START", "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", 115 "LITERAL_INCLUDE", "LITERAL_EXCLUDE", "CHAR", "PARAMETER_NAME", "Char1", 116 "STRING", "PACKAGE_CLASS", "DOT", "HASH", "CLASS", "Char2", "MEMBER", 117 "LEFT_BRACE", "RIGHT_BRACE", "ARGUMENT", "COMMA", "Char20", "FIELD_NAME", 118 "Char3", "FIELD_TYPE", "Char4", "CLASS_NAME", "Char5", "CODE_LITERAL", 119 "DOC_ROOT_LITERAL", "INHERIT_DOC_LITERAL", "LINK_LITERAL", "LINKPLAIN_LITERAL", 120 "LITERAL_LITERAL", "VALUE_LITERAL", "Char7", "Char8", "Char10", "END", 121 "SLASH_END", "SLASH", "EQUALS", "P_HTML_TAG_NAME", "LI_HTML_TAG_NAME", 122 "TR_HTML_TAG_NAME", "TD_HTML_TAG_NAME", "TH_HTML_TAG_NAME", "BODY_HTML_TAG_NAME", 123 "COLGROUP_HTML_TAG_NAME", "DD_HTML_TAG_NAME", "DT_HTML_TAG_NAME", "HEAD_HTML_TAG_NAME", 124 "HTML_HTML_TAG_NAME", "OPTION_HTML_TAG_NAME", "TBODY_HTML_TAG_NAME", 125 "TFOOT_HTML_TAG_NAME", "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", "BASE_HTML_TAG_NAME", 126 "BASEFONT_HTML_TAG_NAME", "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", "FRAME_HTML_TAG_NAME", 127 "HR_HTML_TAG_NAME", "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", "ISINDEX_HTML_TAG_NAME", 128 "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", "EMBED_HTML_TAG_NAME", 129 "KEYGEN_HTML_TAG_NAME", "ATTR_VALUE", "Char12", "HTML_COMMENT_END", "SOURCE_HTML_TAG_NAME", 130 "TRACK_HTML_TAG_NAME", "WBR_HTML_TAG_NAME", "OPTGROUP_HTML_TAG_NAME", 131 "RB_HTML_TAG_NAME", "RT_HTML_TAG_NAME", "RTC_HTML_TAG_NAME", "RP_HTML_TAG_NAME", 132 "HTML_TAG_NAME", "Char11" 133 }; 134 } 135 private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); 136 public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); 137 138 /** 139 * @deprecated Use {@link #VOCABULARY} instead. 140 */ 141 @Deprecated 142 public static final String[] tokenNames; 143 static { 144 tokenNames = new String[_SYMBOLIC_NAMES.length]; 145 for (int i = 0; i < tokenNames.length; i++) { 146 tokenNames[i] = VOCABULARY.getLiteralName(i); 147 if (tokenNames[i] == null) { 148 tokenNames[i] = VOCABULARY.getSymbolicName(i); 149 } 150 151 if (tokenNames[i] == null) { 152 tokenNames[i] = "<INVALID>"; 153 } 154 } 155 } 156 157 @Override 158 @Deprecated 159 public String[] getTokenNames() { 160 return tokenNames; 161 } 162 163 @Override 164 165 public Vocabulary getVocabulary() { 166 return VOCABULARY; 167 } 168 169 @Override 170 public String getGrammarFileName() { return "JavadocParser.g4"; } 171 172 @Override 173 public String[] getRuleNames() { return ruleNames; } 174 175 @Override 176 public String getSerializedATN() { return _serializedATN; } 177 178 @Override 179 public ATN getATN() { return _ATN; } 180 181 182 boolean isNextJavadocTag() { 183 int token1 = _input.LA(2); 184 int token2 = _input.LA(3); 185 return isJavadocTag(token1) 186 || (token1 == WS && isJavadocTag(token2)); 187 } 188 189 boolean isJavadocTag(int type) { 190 switch(type) { 191 case AUTHOR_LITERAL: 192 case DEPRECATED_LITERAL: 193 case EXCEPTION_LITERAL: 194 case PARAM_LITERAL: 195 case RETURN_LITERAL: 196 case SEE_LITERAL: 197 case SERIAL_LITERAL: 198 case SERIAL_FIELD_LITERAL: 199 case SERIAL_DATA_LITERAL: 200 case SINCE_LITERAL: 201 case THROWS_LITERAL: 202 case VERSION_LITERAL: 203 case CUSTOM_NAME: 204 return true; 205 default: 206 return false; 207 } 208 } 209 210 boolean isSameTagNames(ParserRuleContext htmlTagStart, ParserRuleContext htmlTagEnd) { 211 String startTag = htmlTagStart.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 212 String endTag = htmlTagEnd.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 213 return startTag.equals(endTag); 214 } 215 216 public ParserRuleContext nonTightTagStartContext; 217 218 public JavadocParser(TokenStream input) { 219 super(input); 220 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); 221 } 222 223 public static class JavadocContext extends ParserRuleContext { 224 public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); } 225 public List<HtmlElementContext> htmlElement() { 226 return getRuleContexts(HtmlElementContext.class); 227 } 228 public HtmlElementContext htmlElement(int i) { 229 return getRuleContext(HtmlElementContext.class,i); 230 } 231 public List<HtmlCommentContext> htmlComment() { 232 return getRuleContexts(HtmlCommentContext.class); 233 } 234 public HtmlCommentContext htmlComment(int i) { 235 return getRuleContext(HtmlCommentContext.class,i); 236 } 237 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 238 public TerminalNode CDATA(int i) { 239 return getToken(JavadocParser.CDATA, i); 240 } 241 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 242 public TerminalNode NEWLINE(int i) { 243 return getToken(JavadocParser.NEWLINE, i); 244 } 245 public List<TextContext> text() { 246 return getRuleContexts(TextContext.class); 247 } 248 public TextContext text(int i) { 249 return getRuleContext(TextContext.class,i); 250 } 251 public List<JavadocInlineTagContext> javadocInlineTag() { 252 return getRuleContexts(JavadocInlineTagContext.class); 253 } 254 public JavadocInlineTagContext javadocInlineTag(int i) { 255 return getRuleContext(JavadocInlineTagContext.class,i); 256 } 257 public List<JavadocTagContext> javadocTag() { 258 return getRuleContexts(JavadocTagContext.class); 259 } 260 public JavadocTagContext javadocTag(int i) { 261 return getRuleContext(JavadocTagContext.class,i); 262 } 263 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 264 public TerminalNode LEADING_ASTERISK(int i) { 265 return getToken(JavadocParser.LEADING_ASTERISK, i); 266 } 267 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 268 public TerminalNode WS(int i) { 269 return getToken(JavadocParser.WS, i); 270 } 271 public JavadocContext(ParserRuleContext parent, int invokingState) { 272 super(parent, invokingState); 273 } 274 @Override public int getRuleIndex() { return RULE_javadoc; } 275 } 276 277 public final JavadocContext javadoc() throws RecognitionException { 278 JavadocContext _localctx = new JavadocContext(_ctx, getState()); 279 enterRule(_localctx, 0, RULE_javadoc); 280 int _la; 281 try { 282 int _alt; 283 enterOuterAlt(_localctx, 1); 284 { 285 setState(200); 286 _errHandler.sync(this); 287 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 288 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 289 if ( _alt==1 ) { 290 { 291 setState(198); 292 _errHandler.sync(this); 293 switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { 294 case 1: 295 { 296 setState(190); 297 htmlElement(); 298 } 299 break; 300 case 2: 301 { 302 { 303 setState(191); 304 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 305 setState(192); 306 match(LEADING_ASTERISK); 307 } 308 } 309 break; 310 case 3: 311 { 312 setState(193); 313 htmlComment(); 314 } 315 break; 316 case 4: 317 { 318 setState(194); 319 match(CDATA); 320 } 321 break; 322 case 5: 323 { 324 setState(195); 325 match(NEWLINE); 326 } 327 break; 328 case 6: 329 { 330 setState(196); 331 text(); 332 } 333 break; 334 case 7: 335 { 336 setState(197); 337 javadocInlineTag(); 338 } 339 break; 340 } 341 } 342 } 343 setState(202); 344 _errHandler.sync(this); 345 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 346 } 347 setState(215); 348 _errHandler.sync(this); 349 _la = _input.LA(1); 350 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)) { 351 { 352 { 353 setState(204); 354 _errHandler.sync(this); 355 _la = _input.LA(1); 356 if (_la==LEADING_ASTERISK) { 357 { 358 setState(203); 359 match(LEADING_ASTERISK); 360 } 361 } 362 363 setState(209); 364 _errHandler.sync(this); 365 _la = _input.LA(1); 366 while (_la==WS) { 367 { 368 { 369 setState(206); 370 match(WS); 371 } 372 } 373 setState(211); 374 _errHandler.sync(this); 375 _la = _input.LA(1); 376 } 377 setState(212); 378 javadocTag(); 379 } 380 } 381 setState(217); 382 _errHandler.sync(this); 383 _la = _input.LA(1); 384 } 385 setState(218); 386 match(EOF); 387 } 388 } 389 catch (RecognitionException re) { 390 _localctx.exception = re; 391 _errHandler.reportError(this, re); 392 _errHandler.recover(this, re); 393 } 394 finally { 395 exitRule(); 396 } 397 return _localctx; 398 } 399 400 public static class HtmlElementContext extends ParserRuleContext { 401 public HtmlTagContext htmlTag() { 402 return getRuleContext(HtmlTagContext.class,0); 403 } 404 public SingletonElementContext singletonElement() { 405 return getRuleContext(SingletonElementContext.class,0); 406 } 407 public ParagraphContext paragraph() { 408 return getRuleContext(ParagraphContext.class,0); 409 } 410 public LiContext li() { 411 return getRuleContext(LiContext.class,0); 412 } 413 public TrContext tr() { 414 return getRuleContext(TrContext.class,0); 415 } 416 public TdContext td() { 417 return getRuleContext(TdContext.class,0); 418 } 419 public ThContext th() { 420 return getRuleContext(ThContext.class,0); 421 } 422 public BodyContext body() { 423 return getRuleContext(BodyContext.class,0); 424 } 425 public ColgroupContext colgroup() { 426 return getRuleContext(ColgroupContext.class,0); 427 } 428 public DdContext dd() { 429 return getRuleContext(DdContext.class,0); 430 } 431 public DtContext dt() { 432 return getRuleContext(DtContext.class,0); 433 } 434 public HeadContext head() { 435 return getRuleContext(HeadContext.class,0); 436 } 437 public HtmlContext html() { 438 return getRuleContext(HtmlContext.class,0); 439 } 440 public OptionContext option() { 441 return getRuleContext(OptionContext.class,0); 442 } 443 public TbodyContext tbody() { 444 return getRuleContext(TbodyContext.class,0); 445 } 446 public TheadContext thead() { 447 return getRuleContext(TheadContext.class,0); 448 } 449 public TfootContext tfoot() { 450 return getRuleContext(TfootContext.class,0); 451 } 452 public OptgroupContext optgroup() { 453 return getRuleContext(OptgroupContext.class,0); 454 } 455 public RbContext rb() { 456 return getRuleContext(RbContext.class,0); 457 } 458 public RtContext rt() { 459 return getRuleContext(RtContext.class,0); 460 } 461 public RtcContext rtc() { 462 return getRuleContext(RtcContext.class,0); 463 } 464 public RpContext rp() { 465 return getRuleContext(RpContext.class,0); 466 } 467 public PTagStartContext pTagStart() { 468 return getRuleContext(PTagStartContext.class,0); 469 } 470 public LiTagStartContext liTagStart() { 471 return getRuleContext(LiTagStartContext.class,0); 472 } 473 public TrTagStartContext trTagStart() { 474 return getRuleContext(TrTagStartContext.class,0); 475 } 476 public TdTagStartContext tdTagStart() { 477 return getRuleContext(TdTagStartContext.class,0); 478 } 479 public ThTagStartContext thTagStart() { 480 return getRuleContext(ThTagStartContext.class,0); 481 } 482 public BodyTagStartContext bodyTagStart() { 483 return getRuleContext(BodyTagStartContext.class,0); 484 } 485 public ColgroupTagStartContext colgroupTagStart() { 486 return getRuleContext(ColgroupTagStartContext.class,0); 487 } 488 public DdTagStartContext ddTagStart() { 489 return getRuleContext(DdTagStartContext.class,0); 490 } 491 public DtTagStartContext dtTagStart() { 492 return getRuleContext(DtTagStartContext.class,0); 493 } 494 public HeadTagStartContext headTagStart() { 495 return getRuleContext(HeadTagStartContext.class,0); 496 } 497 public HtmlTagStartContext htmlTagStart() { 498 return getRuleContext(HtmlTagStartContext.class,0); 499 } 500 public OptionTagStartContext optionTagStart() { 501 return getRuleContext(OptionTagStartContext.class,0); 502 } 503 public TbodyTagStartContext tbodyTagStart() { 504 return getRuleContext(TbodyTagStartContext.class,0); 505 } 506 public TheadTagStartContext theadTagStart() { 507 return getRuleContext(TheadTagStartContext.class,0); 508 } 509 public TfootTagStartContext tfootTagStart() { 510 return getRuleContext(TfootTagStartContext.class,0); 511 } 512 public OptgroupTagStartContext optgroupTagStart() { 513 return getRuleContext(OptgroupTagStartContext.class,0); 514 } 515 public RbTagStartContext rbTagStart() { 516 return getRuleContext(RbTagStartContext.class,0); 517 } 518 public RtTagStartContext rtTagStart() { 519 return getRuleContext(RtTagStartContext.class,0); 520 } 521 public RtcTagStartContext rtcTagStart() { 522 return getRuleContext(RtcTagStartContext.class,0); 523 } 524 public RpTagStartContext rpTagStart() { 525 return getRuleContext(RpTagStartContext.class,0); 526 } 527 public PTagEndContext pTagEnd() { 528 return getRuleContext(PTagEndContext.class,0); 529 } 530 public LiTagEndContext liTagEnd() { 531 return getRuleContext(LiTagEndContext.class,0); 532 } 533 public TrTagEndContext trTagEnd() { 534 return getRuleContext(TrTagEndContext.class,0); 535 } 536 public TdTagEndContext tdTagEnd() { 537 return getRuleContext(TdTagEndContext.class,0); 538 } 539 public ThTagEndContext thTagEnd() { 540 return getRuleContext(ThTagEndContext.class,0); 541 } 542 public BodyTagEndContext bodyTagEnd() { 543 return getRuleContext(BodyTagEndContext.class,0); 544 } 545 public ColgroupTagEndContext colgroupTagEnd() { 546 return getRuleContext(ColgroupTagEndContext.class,0); 547 } 548 public DdTagEndContext ddTagEnd() { 549 return getRuleContext(DdTagEndContext.class,0); 550 } 551 public DtTagEndContext dtTagEnd() { 552 return getRuleContext(DtTagEndContext.class,0); 553 } 554 public HeadTagEndContext headTagEnd() { 555 return getRuleContext(HeadTagEndContext.class,0); 556 } 557 public HtmlTagEndContext htmlTagEnd() { 558 return getRuleContext(HtmlTagEndContext.class,0); 559 } 560 public OptionTagEndContext optionTagEnd() { 561 return getRuleContext(OptionTagEndContext.class,0); 562 } 563 public TbodyTagEndContext tbodyTagEnd() { 564 return getRuleContext(TbodyTagEndContext.class,0); 565 } 566 public TheadTagEndContext theadTagEnd() { 567 return getRuleContext(TheadTagEndContext.class,0); 568 } 569 public TfootTagEndContext tfootTagEnd() { 570 return getRuleContext(TfootTagEndContext.class,0); 571 } 572 public OptgroupTagEndContext optgroupTagEnd() { 573 return getRuleContext(OptgroupTagEndContext.class,0); 574 } 575 public RbTagEndContext rbTagEnd() { 576 return getRuleContext(RbTagEndContext.class,0); 577 } 578 public RtTagEndContext rtTagEnd() { 579 return getRuleContext(RtTagEndContext.class,0); 580 } 581 public RtcTagEndContext rtcTagEnd() { 582 return getRuleContext(RtcTagEndContext.class,0); 583 } 584 public RpTagEndContext rpTagEnd() { 585 return getRuleContext(RpTagEndContext.class,0); 586 } 587 public HtmlElementContext(ParserRuleContext parent, int invokingState) { 588 super(parent, invokingState); 589 } 590 @Override public int getRuleIndex() { return RULE_htmlElement; } 591 } 592 593 public final HtmlElementContext htmlElement() throws RecognitionException { 594 HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState()); 595 enterRule(_localctx, 2, RULE_htmlElement); 596 try { 597 setState(282); 598 _errHandler.sync(this); 599 switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { 600 case 1: 601 enterOuterAlt(_localctx, 1); 602 { 603 setState(220); 604 htmlTag(); 605 } 606 break; 607 case 2: 608 enterOuterAlt(_localctx, 2); 609 { 610 setState(221); 611 singletonElement(); 612 } 613 break; 614 case 3: 615 enterOuterAlt(_localctx, 3); 616 { 617 setState(222); 618 paragraph(); 619 } 620 break; 621 case 4: 622 enterOuterAlt(_localctx, 4); 623 { 624 setState(223); 625 li(); 626 } 627 break; 628 case 5: 629 enterOuterAlt(_localctx, 5); 630 { 631 setState(224); 632 tr(); 633 } 634 break; 635 case 6: 636 enterOuterAlt(_localctx, 6); 637 { 638 setState(225); 639 td(); 640 } 641 break; 642 case 7: 643 enterOuterAlt(_localctx, 7); 644 { 645 setState(226); 646 th(); 647 } 648 break; 649 case 8: 650 enterOuterAlt(_localctx, 8); 651 { 652 setState(227); 653 body(); 654 } 655 break; 656 case 9: 657 enterOuterAlt(_localctx, 9); 658 { 659 setState(228); 660 colgroup(); 661 } 662 break; 663 case 10: 664 enterOuterAlt(_localctx, 10); 665 { 666 setState(229); 667 dd(); 668 } 669 break; 670 case 11: 671 enterOuterAlt(_localctx, 11); 672 { 673 setState(230); 674 dt(); 675 } 676 break; 677 case 12: 678 enterOuterAlt(_localctx, 12); 679 { 680 setState(231); 681 head(); 682 } 683 break; 684 case 13: 685 enterOuterAlt(_localctx, 13); 686 { 687 setState(232); 688 html(); 689 } 690 break; 691 case 14: 692 enterOuterAlt(_localctx, 14); 693 { 694 setState(233); 695 option(); 696 } 697 break; 698 case 15: 699 enterOuterAlt(_localctx, 15); 700 { 701 setState(234); 702 tbody(); 703 } 704 break; 705 case 16: 706 enterOuterAlt(_localctx, 16); 707 { 708 setState(235); 709 thead(); 710 } 711 break; 712 case 17: 713 enterOuterAlt(_localctx, 17); 714 { 715 setState(236); 716 tfoot(); 717 } 718 break; 719 case 18: 720 enterOuterAlt(_localctx, 18); 721 { 722 setState(237); 723 optgroup(); 724 } 725 break; 726 case 19: 727 enterOuterAlt(_localctx, 19); 728 { 729 setState(238); 730 rb(); 731 } 732 break; 733 case 20: 734 enterOuterAlt(_localctx, 20); 735 { 736 setState(239); 737 rt(); 738 } 739 break; 740 case 21: 741 enterOuterAlt(_localctx, 21); 742 { 743 setState(240); 744 rtc(); 745 } 746 break; 747 case 22: 748 enterOuterAlt(_localctx, 22); 749 { 750 setState(241); 751 rp(); 752 } 753 break; 754 case 23: 755 enterOuterAlt(_localctx, 23); 756 { 757 setState(242); 758 pTagStart(true); 759 } 760 break; 761 case 24: 762 enterOuterAlt(_localctx, 24); 763 { 764 setState(243); 765 liTagStart(true); 766 } 767 break; 768 case 25: 769 enterOuterAlt(_localctx, 25); 770 { 771 setState(244); 772 trTagStart(true); 773 } 774 break; 775 case 26: 776 enterOuterAlt(_localctx, 26); 777 { 778 setState(245); 779 tdTagStart(true); 780 } 781 break; 782 case 27: 783 enterOuterAlt(_localctx, 27); 784 { 785 setState(246); 786 thTagStart(true); 787 } 788 break; 789 case 28: 790 enterOuterAlt(_localctx, 28); 791 { 792 setState(247); 793 bodyTagStart(true); 794 } 795 break; 796 case 29: 797 enterOuterAlt(_localctx, 29); 798 { 799 setState(248); 800 colgroupTagStart(true); 801 } 802 break; 803 case 30: 804 enterOuterAlt(_localctx, 30); 805 { 806 setState(249); 807 ddTagStart(true); 808 } 809 break; 810 case 31: 811 enterOuterAlt(_localctx, 31); 812 { 813 setState(250); 814 dtTagStart(true); 815 } 816 break; 817 case 32: 818 enterOuterAlt(_localctx, 32); 819 { 820 setState(251); 821 headTagStart(true); 822 } 823 break; 824 case 33: 825 enterOuterAlt(_localctx, 33); 826 { 827 setState(252); 828 htmlTagStart(true); 829 } 830 break; 831 case 34: 832 enterOuterAlt(_localctx, 34); 833 { 834 setState(253); 835 optionTagStart(true); 836 } 837 break; 838 case 35: 839 enterOuterAlt(_localctx, 35); 840 { 841 setState(254); 842 tbodyTagStart(true); 843 } 844 break; 845 case 36: 846 enterOuterAlt(_localctx, 36); 847 { 848 setState(255); 849 theadTagStart(true); 850 } 851 break; 852 case 37: 853 enterOuterAlt(_localctx, 37); 854 { 855 setState(256); 856 tfootTagStart(true); 857 } 858 break; 859 case 38: 860 enterOuterAlt(_localctx, 38); 861 { 862 setState(257); 863 optgroupTagStart(true); 864 } 865 break; 866 case 39: 867 enterOuterAlt(_localctx, 39); 868 { 869 setState(258); 870 rbTagStart(true); 871 } 872 break; 873 case 40: 874 enterOuterAlt(_localctx, 40); 875 { 876 setState(259); 877 rtTagStart(true); 878 } 879 break; 880 case 41: 881 enterOuterAlt(_localctx, 41); 882 { 883 setState(260); 884 rtcTagStart(true); 885 } 886 break; 887 case 42: 888 enterOuterAlt(_localctx, 42); 889 { 890 setState(261); 891 rpTagStart(true); 892 } 893 break; 894 case 43: 895 enterOuterAlt(_localctx, 43); 896 { 897 setState(262); 898 pTagEnd(); 899 } 900 break; 901 case 44: 902 enterOuterAlt(_localctx, 44); 903 { 904 setState(263); 905 liTagEnd(); 906 } 907 break; 908 case 45: 909 enterOuterAlt(_localctx, 45); 910 { 911 setState(264); 912 trTagEnd(); 913 } 914 break; 915 case 46: 916 enterOuterAlt(_localctx, 46); 917 { 918 setState(265); 919 tdTagEnd(); 920 } 921 break; 922 case 47: 923 enterOuterAlt(_localctx, 47); 924 { 925 setState(266); 926 thTagEnd(); 927 } 928 break; 929 case 48: 930 enterOuterAlt(_localctx, 48); 931 { 932 setState(267); 933 bodyTagEnd(); 934 } 935 break; 936 case 49: 937 enterOuterAlt(_localctx, 49); 938 { 939 setState(268); 940 colgroupTagEnd(); 941 } 942 break; 943 case 50: 944 enterOuterAlt(_localctx, 50); 945 { 946 setState(269); 947 ddTagEnd(); 948 } 949 break; 950 case 51: 951 enterOuterAlt(_localctx, 51); 952 { 953 setState(270); 954 dtTagEnd(); 955 } 956 break; 957 case 52: 958 enterOuterAlt(_localctx, 52); 959 { 960 setState(271); 961 headTagEnd(); 962 } 963 break; 964 case 53: 965 enterOuterAlt(_localctx, 53); 966 { 967 setState(272); 968 htmlTagEnd(); 969 } 970 break; 971 case 54: 972 enterOuterAlt(_localctx, 54); 973 { 974 setState(273); 975 optionTagEnd(); 976 } 977 break; 978 case 55: 979 enterOuterAlt(_localctx, 55); 980 { 981 setState(274); 982 tbodyTagEnd(); 983 } 984 break; 985 case 56: 986 enterOuterAlt(_localctx, 56); 987 { 988 setState(275); 989 theadTagEnd(); 990 } 991 break; 992 case 57: 993 enterOuterAlt(_localctx, 57); 994 { 995 setState(276); 996 tfootTagEnd(); 997 } 998 break; 999 case 58: 1000 enterOuterAlt(_localctx, 58); 1001 { 1002 setState(277); 1003 optgroupTagEnd(); 1004 } 1005 break; 1006 case 59: 1007 enterOuterAlt(_localctx, 59); 1008 { 1009 setState(278); 1010 rbTagEnd(); 1011 } 1012 break; 1013 case 60: 1014 enterOuterAlt(_localctx, 60); 1015 { 1016 setState(279); 1017 rtTagEnd(); 1018 } 1019 break; 1020 case 61: 1021 enterOuterAlt(_localctx, 61); 1022 { 1023 setState(280); 1024 rtcTagEnd(); 1025 } 1026 break; 1027 case 62: 1028 enterOuterAlt(_localctx, 62); 1029 { 1030 setState(281); 1031 rpTagEnd(); 1032 } 1033 break; 1034 } 1035 } 1036 catch (RecognitionException re) { 1037 _localctx.exception = re; 1038 _errHandler.reportError(this, re); 1039 _errHandler.recover(this, re); 1040 } 1041 finally { 1042 exitRule(); 1043 } 1044 return _localctx; 1045 } 1046 1047 public static class HtmlElementStartContext extends ParserRuleContext { 1048 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 1049 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 1050 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 1051 public List<AttributeContext> attribute() { 1052 return getRuleContexts(AttributeContext.class); 1053 } 1054 public AttributeContext attribute(int i) { 1055 return getRuleContext(AttributeContext.class,i); 1056 } 1057 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1058 public TerminalNode NEWLINE(int i) { 1059 return getToken(JavadocParser.NEWLINE, i); 1060 } 1061 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1062 public TerminalNode LEADING_ASTERISK(int i) { 1063 return getToken(JavadocParser.LEADING_ASTERISK, i); 1064 } 1065 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1066 public TerminalNode WS(int i) { 1067 return getToken(JavadocParser.WS, i); 1068 } 1069 public HtmlElementStartContext(ParserRuleContext parent, int invokingState) { 1070 super(parent, invokingState); 1071 } 1072 @Override public int getRuleIndex() { return RULE_htmlElementStart; } 1073 } 1074 1075 public final HtmlElementStartContext htmlElementStart() throws RecognitionException { 1076 HtmlElementStartContext _localctx = new HtmlElementStartContext(_ctx, getState()); 1077 enterRule(_localctx, 4, RULE_htmlElementStart); 1078 int _la; 1079 try { 1080 enterOuterAlt(_localctx, 1); 1081 { 1082 setState(284); 1083 match(START); 1084 setState(285); 1085 match(HTML_TAG_NAME); 1086 setState(292); 1087 _errHandler.sync(this); 1088 _la = _input.LA(1); 1089 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 1090 { 1091 setState(290); 1092 _errHandler.sync(this); 1093 switch (_input.LA(1)) { 1094 case HTML_TAG_NAME: 1095 { 1096 setState(286); 1097 attribute(); 1098 } 1099 break; 1100 case NEWLINE: 1101 { 1102 setState(287); 1103 match(NEWLINE); 1104 } 1105 break; 1106 case LEADING_ASTERISK: 1107 { 1108 setState(288); 1109 match(LEADING_ASTERISK); 1110 } 1111 break; 1112 case WS: 1113 { 1114 setState(289); 1115 match(WS); 1116 } 1117 break; 1118 default: 1119 throw new NoViableAltException(this); 1120 } 1121 } 1122 setState(294); 1123 _errHandler.sync(this); 1124 _la = _input.LA(1); 1125 } 1126 setState(295); 1127 match(END); 1128 } 1129 } 1130 catch (RecognitionException re) { 1131 _localctx.exception = re; 1132 _errHandler.reportError(this, re); 1133 _errHandler.recover(this, re); 1134 } 1135 finally { 1136 exitRule(); 1137 } 1138 return _localctx; 1139 } 1140 1141 public static class HtmlElementEndContext extends ParserRuleContext { 1142 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 1143 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1144 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 1145 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 1146 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1147 public TerminalNode NEWLINE(int i) { 1148 return getToken(JavadocParser.NEWLINE, i); 1149 } 1150 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1151 public TerminalNode LEADING_ASTERISK(int i) { 1152 return getToken(JavadocParser.LEADING_ASTERISK, i); 1153 } 1154 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1155 public TerminalNode WS(int i) { 1156 return getToken(JavadocParser.WS, i); 1157 } 1158 public HtmlElementEndContext(ParserRuleContext parent, int invokingState) { 1159 super(parent, invokingState); 1160 } 1161 @Override public int getRuleIndex() { return RULE_htmlElementEnd; } 1162 } 1163 1164 public final HtmlElementEndContext htmlElementEnd() throws RecognitionException { 1165 HtmlElementEndContext _localctx = new HtmlElementEndContext(_ctx, getState()); 1166 enterRule(_localctx, 6, RULE_htmlElementEnd); 1167 int _la; 1168 try { 1169 enterOuterAlt(_localctx, 1); 1170 { 1171 setState(297); 1172 match(START); 1173 setState(298); 1174 match(SLASH); 1175 setState(299); 1176 match(HTML_TAG_NAME); 1177 setState(303); 1178 _errHandler.sync(this); 1179 _la = _input.LA(1); 1180 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1181 { 1182 { 1183 setState(300); 1184 _la = _input.LA(1); 1185 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1186 _errHandler.recoverInline(this); 1187 } 1188 else { 1189 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1190 _errHandler.reportMatch(this); 1191 consume(); 1192 } 1193 } 1194 } 1195 setState(305); 1196 _errHandler.sync(this); 1197 _la = _input.LA(1); 1198 } 1199 setState(306); 1200 match(END); 1201 } 1202 } 1203 catch (RecognitionException re) { 1204 _localctx.exception = re; 1205 _errHandler.reportError(this, re); 1206 _errHandler.recover(this, re); 1207 } 1208 finally { 1209 exitRule(); 1210 } 1211 return _localctx; 1212 } 1213 1214 public static class AttributeContext extends ParserRuleContext { 1215 public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); } 1216 public TerminalNode HTML_TAG_NAME(int i) { 1217 return getToken(JavadocParser.HTML_TAG_NAME, i); 1218 } 1219 public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); } 1220 public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); } 1221 public TextContext text() { 1222 return getRuleContext(TextContext.class,0); 1223 } 1224 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1225 public TerminalNode NEWLINE(int i) { 1226 return getToken(JavadocParser.NEWLINE, i); 1227 } 1228 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1229 public TerminalNode LEADING_ASTERISK(int i) { 1230 return getToken(JavadocParser.LEADING_ASTERISK, i); 1231 } 1232 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1233 public TerminalNode WS(int i) { 1234 return getToken(JavadocParser.WS, i); 1235 } 1236 public AttributeContext(ParserRuleContext parent, int invokingState) { 1237 super(parent, invokingState); 1238 } 1239 @Override public int getRuleIndex() { return RULE_attribute; } 1240 } 1241 1242 public final AttributeContext attribute() throws RecognitionException { 1243 AttributeContext _localctx = new AttributeContext(_ctx, getState()); 1244 enterRule(_localctx, 8, RULE_attribute); 1245 int _la; 1246 try { 1247 int _alt; 1248 enterOuterAlt(_localctx, 1); 1249 { 1250 setState(308); 1251 match(HTML_TAG_NAME); 1252 setState(312); 1253 _errHandler.sync(this); 1254 _la = _input.LA(1); 1255 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1256 { 1257 { 1258 setState(309); 1259 _la = _input.LA(1); 1260 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1261 _errHandler.recoverInline(this); 1262 } 1263 else { 1264 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1265 _errHandler.reportMatch(this); 1266 consume(); 1267 } 1268 } 1269 } 1270 setState(314); 1271 _errHandler.sync(this); 1272 _la = _input.LA(1); 1273 } 1274 setState(315); 1275 match(EQUALS); 1276 setState(319); 1277 _errHandler.sync(this); 1278 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1279 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1280 if ( _alt==1 ) { 1281 { 1282 { 1283 setState(316); 1284 _la = _input.LA(1); 1285 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1286 _errHandler.recoverInline(this); 1287 } 1288 else { 1289 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1290 _errHandler.reportMatch(this); 1291 consume(); 1292 } 1293 } 1294 } 1295 } 1296 setState(321); 1297 _errHandler.sync(this); 1298 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1299 } 1300 setState(325); 1301 _errHandler.sync(this); 1302 switch (_input.LA(1)) { 1303 case ATTR_VALUE: 1304 { 1305 setState(322); 1306 match(ATTR_VALUE); 1307 } 1308 break; 1309 case WS: 1310 case CHAR: 1311 { 1312 setState(323); 1313 text(); 1314 } 1315 break; 1316 case HTML_TAG_NAME: 1317 { 1318 setState(324); 1319 match(HTML_TAG_NAME); 1320 } 1321 break; 1322 default: 1323 throw new NoViableAltException(this); 1324 } 1325 } 1326 } 1327 catch (RecognitionException re) { 1328 _localctx.exception = re; 1329 _errHandler.reportError(this, re); 1330 _errHandler.recover(this, re); 1331 } 1332 finally { 1333 exitRule(); 1334 } 1335 return _localctx; 1336 } 1337 1338 public static class HtmlTagContext extends ParserRuleContext { 1339 public HtmlElementStartContext htmlElementStart; 1340 public HtmlElementEndContext htmlElementEnd; 1341 public HtmlElementStartContext htmlElementStart() { 1342 return getRuleContext(HtmlElementStartContext.class,0); 1343 } 1344 public HtmlElementEndContext htmlElementEnd() { 1345 return getRuleContext(HtmlElementEndContext.class,0); 1346 } 1347 public List<HtmlElementContext> htmlElement() { 1348 return getRuleContexts(HtmlElementContext.class); 1349 } 1350 public HtmlElementContext htmlElement(int i) { 1351 return getRuleContext(HtmlElementContext.class,i); 1352 } 1353 public List<HtmlCommentContext> htmlComment() { 1354 return getRuleContexts(HtmlCommentContext.class); 1355 } 1356 public HtmlCommentContext htmlComment(int i) { 1357 return getRuleContext(HtmlCommentContext.class,i); 1358 } 1359 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1360 public TerminalNode CDATA(int i) { 1361 return getToken(JavadocParser.CDATA, i); 1362 } 1363 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1364 public TerminalNode NEWLINE(int i) { 1365 return getToken(JavadocParser.NEWLINE, i); 1366 } 1367 public List<TextContext> text() { 1368 return getRuleContexts(TextContext.class); 1369 } 1370 public TextContext text(int i) { 1371 return getRuleContext(TextContext.class,i); 1372 } 1373 public List<JavadocInlineTagContext> javadocInlineTag() { 1374 return getRuleContexts(JavadocInlineTagContext.class); 1375 } 1376 public JavadocInlineTagContext javadocInlineTag(int i) { 1377 return getRuleContext(JavadocInlineTagContext.class,i); 1378 } 1379 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1380 public TerminalNode LEADING_ASTERISK(int i) { 1381 return getToken(JavadocParser.LEADING_ASTERISK, i); 1382 } 1383 public HtmlTagContext(ParserRuleContext parent, int invokingState) { 1384 super(parent, invokingState); 1385 } 1386 @Override public int getRuleIndex() { return RULE_htmlTag; } 1387 } 1388 1389 public final HtmlTagContext htmlTag() throws RecognitionException { 1390 HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState()); 1391 enterRule(_localctx, 10, RULE_htmlTag); 1392 try { 1393 int _alt; 1394 enterOuterAlt(_localctx, 1); 1395 { 1396 setState(327); 1397 ((HtmlTagContext)_localctx).htmlElementStart = htmlElementStart(); 1398 setState(338); 1399 _errHandler.sync(this); 1400 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1401 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1402 if ( _alt==1 ) { 1403 { 1404 setState(336); 1405 _errHandler.sync(this); 1406 switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { 1407 case 1: 1408 { 1409 setState(328); 1410 htmlElement(); 1411 } 1412 break; 1413 case 2: 1414 { 1415 { 1416 setState(329); 1417 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1418 setState(330); 1419 match(LEADING_ASTERISK); 1420 } 1421 } 1422 break; 1423 case 3: 1424 { 1425 setState(331); 1426 htmlComment(); 1427 } 1428 break; 1429 case 4: 1430 { 1431 setState(332); 1432 match(CDATA); 1433 } 1434 break; 1435 case 5: 1436 { 1437 setState(333); 1438 match(NEWLINE); 1439 } 1440 break; 1441 case 6: 1442 { 1443 setState(334); 1444 text(); 1445 } 1446 break; 1447 case 7: 1448 { 1449 setState(335); 1450 javadocInlineTag(); 1451 } 1452 break; 1453 } 1454 } 1455 } 1456 setState(340); 1457 _errHandler.sync(this); 1458 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1459 } 1460 setState(341); 1461 ((HtmlTagContext)_localctx).htmlElementEnd = htmlElementEnd(); 1462 setState(342); 1463 if (!(isSameTagNames(((HtmlTagContext)_localctx).htmlElementStart, ((HtmlTagContext)_localctx).htmlElementEnd))) throw new FailedPredicateException(this, "isSameTagNames($htmlElementStart.ctx, $htmlElementEnd.ctx)"); 1464 } 1465 } 1466 catch (RecognitionException re) { 1467 _localctx.exception = re; 1468 _errHandler.reportError(this, re); 1469 _errHandler.recover(this, re); 1470 } 1471 finally { 1472 exitRule(); 1473 } 1474 return _localctx; 1475 } 1476 1477 public static class PTagStartContext extends ParserRuleContext { 1478 public boolean isNonTight; 1479 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 1480 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1481 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 1482 public List<AttributeContext> attribute() { 1483 return getRuleContexts(AttributeContext.class); 1484 } 1485 public AttributeContext attribute(int i) { 1486 return getRuleContext(AttributeContext.class,i); 1487 } 1488 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1489 public TerminalNode NEWLINE(int i) { 1490 return getToken(JavadocParser.NEWLINE, i); 1491 } 1492 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1493 public TerminalNode LEADING_ASTERISK(int i) { 1494 return getToken(JavadocParser.LEADING_ASTERISK, i); 1495 } 1496 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1497 public TerminalNode WS(int i) { 1498 return getToken(JavadocParser.WS, i); 1499 } 1500 public PTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 1501 public PTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 1502 super(parent, invokingState); 1503 this.isNonTight = isNonTight; 1504 } 1505 @Override public int getRuleIndex() { return RULE_pTagStart; } 1506 } 1507 1508 public final PTagStartContext pTagStart(boolean isNonTight) throws RecognitionException { 1509 PTagStartContext _localctx = new PTagStartContext(_ctx, getState(), isNonTight); 1510 enterRule(_localctx, 12, RULE_pTagStart); 1511 int _la; 1512 try { 1513 enterOuterAlt(_localctx, 1); 1514 { 1515 setState(344); 1516 match(START); 1517 setState(345); 1518 match(P_HTML_TAG_NAME); 1519 setState(352); 1520 _errHandler.sync(this); 1521 _la = _input.LA(1); 1522 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 1523 { 1524 setState(350); 1525 _errHandler.sync(this); 1526 switch (_input.LA(1)) { 1527 case HTML_TAG_NAME: 1528 { 1529 setState(346); 1530 attribute(); 1531 } 1532 break; 1533 case NEWLINE: 1534 { 1535 setState(347); 1536 match(NEWLINE); 1537 } 1538 break; 1539 case LEADING_ASTERISK: 1540 { 1541 setState(348); 1542 match(LEADING_ASTERISK); 1543 } 1544 break; 1545 case WS: 1546 { 1547 setState(349); 1548 match(WS); 1549 } 1550 break; 1551 default: 1552 throw new NoViableAltException(this); 1553 } 1554 } 1555 setState(354); 1556 _errHandler.sync(this); 1557 _la = _input.LA(1); 1558 } 1559 setState(355); 1560 match(END); 1561 } 1562 _ctx.stop = _input.LT(-1); 1563 1564 if (isNonTight && nonTightTagStartContext == null) { 1565 nonTightTagStartContext = _localctx; 1566 } 1567 1568 } 1569 catch (RecognitionException re) { 1570 _localctx.exception = re; 1571 _errHandler.reportError(this, re); 1572 _errHandler.recover(this, re); 1573 } 1574 finally { 1575 exitRule(); 1576 } 1577 return _localctx; 1578 } 1579 1580 public static class PTagEndContext extends ParserRuleContext { 1581 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 1582 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1583 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1584 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 1585 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1586 public TerminalNode NEWLINE(int i) { 1587 return getToken(JavadocParser.NEWLINE, i); 1588 } 1589 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1590 public TerminalNode LEADING_ASTERISK(int i) { 1591 return getToken(JavadocParser.LEADING_ASTERISK, i); 1592 } 1593 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1594 public TerminalNode WS(int i) { 1595 return getToken(JavadocParser.WS, i); 1596 } 1597 public PTagEndContext(ParserRuleContext parent, int invokingState) { 1598 super(parent, invokingState); 1599 } 1600 @Override public int getRuleIndex() { return RULE_pTagEnd; } 1601 } 1602 1603 public final PTagEndContext pTagEnd() throws RecognitionException { 1604 PTagEndContext _localctx = new PTagEndContext(_ctx, getState()); 1605 enterRule(_localctx, 14, RULE_pTagEnd); 1606 int _la; 1607 try { 1608 enterOuterAlt(_localctx, 1); 1609 { 1610 setState(357); 1611 match(START); 1612 setState(358); 1613 match(SLASH); 1614 setState(359); 1615 match(P_HTML_TAG_NAME); 1616 setState(363); 1617 _errHandler.sync(this); 1618 _la = _input.LA(1); 1619 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1620 { 1621 { 1622 setState(360); 1623 _la = _input.LA(1); 1624 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1625 _errHandler.recoverInline(this); 1626 } 1627 else { 1628 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1629 _errHandler.reportMatch(this); 1630 consume(); 1631 } 1632 } 1633 } 1634 setState(365); 1635 _errHandler.sync(this); 1636 _la = _input.LA(1); 1637 } 1638 setState(366); 1639 match(END); 1640 } 1641 } 1642 catch (RecognitionException re) { 1643 _localctx.exception = re; 1644 _errHandler.reportError(this, re); 1645 _errHandler.recover(this, re); 1646 } 1647 finally { 1648 exitRule(); 1649 } 1650 return _localctx; 1651 } 1652 1653 public static class ParagraphContext extends ParserRuleContext { 1654 public PTagStartContext pTagStart() { 1655 return getRuleContext(PTagStartContext.class,0); 1656 } 1657 public PTagEndContext pTagEnd() { 1658 return getRuleContext(PTagEndContext.class,0); 1659 } 1660 public List<HtmlTagContext> htmlTag() { 1661 return getRuleContexts(HtmlTagContext.class); 1662 } 1663 public HtmlTagContext htmlTag(int i) { 1664 return getRuleContext(HtmlTagContext.class,i); 1665 } 1666 public List<SingletonElementContext> singletonElement() { 1667 return getRuleContexts(SingletonElementContext.class); 1668 } 1669 public SingletonElementContext singletonElement(int i) { 1670 return getRuleContext(SingletonElementContext.class,i); 1671 } 1672 public List<LiContext> li() { 1673 return getRuleContexts(LiContext.class); 1674 } 1675 public LiContext li(int i) { 1676 return getRuleContext(LiContext.class,i); 1677 } 1678 public List<TrContext> tr() { 1679 return getRuleContexts(TrContext.class); 1680 } 1681 public TrContext tr(int i) { 1682 return getRuleContext(TrContext.class,i); 1683 } 1684 public List<TdContext> td() { 1685 return getRuleContexts(TdContext.class); 1686 } 1687 public TdContext td(int i) { 1688 return getRuleContext(TdContext.class,i); 1689 } 1690 public List<ThContext> th() { 1691 return getRuleContexts(ThContext.class); 1692 } 1693 public ThContext th(int i) { 1694 return getRuleContext(ThContext.class,i); 1695 } 1696 public List<BodyContext> body() { 1697 return getRuleContexts(BodyContext.class); 1698 } 1699 public BodyContext body(int i) { 1700 return getRuleContext(BodyContext.class,i); 1701 } 1702 public List<ColgroupContext> colgroup() { 1703 return getRuleContexts(ColgroupContext.class); 1704 } 1705 public ColgroupContext colgroup(int i) { 1706 return getRuleContext(ColgroupContext.class,i); 1707 } 1708 public List<DdContext> dd() { 1709 return getRuleContexts(DdContext.class); 1710 } 1711 public DdContext dd(int i) { 1712 return getRuleContext(DdContext.class,i); 1713 } 1714 public List<DtContext> dt() { 1715 return getRuleContexts(DtContext.class); 1716 } 1717 public DtContext dt(int i) { 1718 return getRuleContext(DtContext.class,i); 1719 } 1720 public List<HeadContext> head() { 1721 return getRuleContexts(HeadContext.class); 1722 } 1723 public HeadContext head(int i) { 1724 return getRuleContext(HeadContext.class,i); 1725 } 1726 public List<HtmlContext> html() { 1727 return getRuleContexts(HtmlContext.class); 1728 } 1729 public HtmlContext html(int i) { 1730 return getRuleContext(HtmlContext.class,i); 1731 } 1732 public List<OptionContext> option() { 1733 return getRuleContexts(OptionContext.class); 1734 } 1735 public OptionContext option(int i) { 1736 return getRuleContext(OptionContext.class,i); 1737 } 1738 public List<TbodyContext> tbody() { 1739 return getRuleContexts(TbodyContext.class); 1740 } 1741 public TbodyContext tbody(int i) { 1742 return getRuleContext(TbodyContext.class,i); 1743 } 1744 public List<TheadContext> thead() { 1745 return getRuleContexts(TheadContext.class); 1746 } 1747 public TheadContext thead(int i) { 1748 return getRuleContext(TheadContext.class,i); 1749 } 1750 public List<TfootContext> tfoot() { 1751 return getRuleContexts(TfootContext.class); 1752 } 1753 public TfootContext tfoot(int i) { 1754 return getRuleContext(TfootContext.class,i); 1755 } 1756 public List<OptgroupContext> optgroup() { 1757 return getRuleContexts(OptgroupContext.class); 1758 } 1759 public OptgroupContext optgroup(int i) { 1760 return getRuleContext(OptgroupContext.class,i); 1761 } 1762 public List<RbContext> rb() { 1763 return getRuleContexts(RbContext.class); 1764 } 1765 public RbContext rb(int i) { 1766 return getRuleContext(RbContext.class,i); 1767 } 1768 public List<RtContext> rt() { 1769 return getRuleContexts(RtContext.class); 1770 } 1771 public RtContext rt(int i) { 1772 return getRuleContext(RtContext.class,i); 1773 } 1774 public List<RtcContext> rtc() { 1775 return getRuleContexts(RtcContext.class); 1776 } 1777 public RtcContext rtc(int i) { 1778 return getRuleContext(RtcContext.class,i); 1779 } 1780 public List<RpContext> rp() { 1781 return getRuleContexts(RpContext.class); 1782 } 1783 public RpContext rp(int i) { 1784 return getRuleContext(RpContext.class,i); 1785 } 1786 public List<LiTagStartContext> liTagStart() { 1787 return getRuleContexts(LiTagStartContext.class); 1788 } 1789 public LiTagStartContext liTagStart(int i) { 1790 return getRuleContext(LiTagStartContext.class,i); 1791 } 1792 public List<TrTagStartContext> trTagStart() { 1793 return getRuleContexts(TrTagStartContext.class); 1794 } 1795 public TrTagStartContext trTagStart(int i) { 1796 return getRuleContext(TrTagStartContext.class,i); 1797 } 1798 public List<TdTagStartContext> tdTagStart() { 1799 return getRuleContexts(TdTagStartContext.class); 1800 } 1801 public TdTagStartContext tdTagStart(int i) { 1802 return getRuleContext(TdTagStartContext.class,i); 1803 } 1804 public List<ThTagStartContext> thTagStart() { 1805 return getRuleContexts(ThTagStartContext.class); 1806 } 1807 public ThTagStartContext thTagStart(int i) { 1808 return getRuleContext(ThTagStartContext.class,i); 1809 } 1810 public List<BodyTagStartContext> bodyTagStart() { 1811 return getRuleContexts(BodyTagStartContext.class); 1812 } 1813 public BodyTagStartContext bodyTagStart(int i) { 1814 return getRuleContext(BodyTagStartContext.class,i); 1815 } 1816 public List<ColgroupTagStartContext> colgroupTagStart() { 1817 return getRuleContexts(ColgroupTagStartContext.class); 1818 } 1819 public ColgroupTagStartContext colgroupTagStart(int i) { 1820 return getRuleContext(ColgroupTagStartContext.class,i); 1821 } 1822 public List<DdTagStartContext> ddTagStart() { 1823 return getRuleContexts(DdTagStartContext.class); 1824 } 1825 public DdTagStartContext ddTagStart(int i) { 1826 return getRuleContext(DdTagStartContext.class,i); 1827 } 1828 public List<DtTagStartContext> dtTagStart() { 1829 return getRuleContexts(DtTagStartContext.class); 1830 } 1831 public DtTagStartContext dtTagStart(int i) { 1832 return getRuleContext(DtTagStartContext.class,i); 1833 } 1834 public List<HeadTagStartContext> headTagStart() { 1835 return getRuleContexts(HeadTagStartContext.class); 1836 } 1837 public HeadTagStartContext headTagStart(int i) { 1838 return getRuleContext(HeadTagStartContext.class,i); 1839 } 1840 public List<HtmlTagStartContext> htmlTagStart() { 1841 return getRuleContexts(HtmlTagStartContext.class); 1842 } 1843 public HtmlTagStartContext htmlTagStart(int i) { 1844 return getRuleContext(HtmlTagStartContext.class,i); 1845 } 1846 public List<OptionTagStartContext> optionTagStart() { 1847 return getRuleContexts(OptionTagStartContext.class); 1848 } 1849 public OptionTagStartContext optionTagStart(int i) { 1850 return getRuleContext(OptionTagStartContext.class,i); 1851 } 1852 public List<TbodyTagStartContext> tbodyTagStart() { 1853 return getRuleContexts(TbodyTagStartContext.class); 1854 } 1855 public TbodyTagStartContext tbodyTagStart(int i) { 1856 return getRuleContext(TbodyTagStartContext.class,i); 1857 } 1858 public List<TheadTagStartContext> theadTagStart() { 1859 return getRuleContexts(TheadTagStartContext.class); 1860 } 1861 public TheadTagStartContext theadTagStart(int i) { 1862 return getRuleContext(TheadTagStartContext.class,i); 1863 } 1864 public List<TfootTagStartContext> tfootTagStart() { 1865 return getRuleContexts(TfootTagStartContext.class); 1866 } 1867 public TfootTagStartContext tfootTagStart(int i) { 1868 return getRuleContext(TfootTagStartContext.class,i); 1869 } 1870 public List<OptgroupTagStartContext> optgroupTagStart() { 1871 return getRuleContexts(OptgroupTagStartContext.class); 1872 } 1873 public OptgroupTagStartContext optgroupTagStart(int i) { 1874 return getRuleContext(OptgroupTagStartContext.class,i); 1875 } 1876 public List<RbTagStartContext> rbTagStart() { 1877 return getRuleContexts(RbTagStartContext.class); 1878 } 1879 public RbTagStartContext rbTagStart(int i) { 1880 return getRuleContext(RbTagStartContext.class,i); 1881 } 1882 public List<RtTagStartContext> rtTagStart() { 1883 return getRuleContexts(RtTagStartContext.class); 1884 } 1885 public RtTagStartContext rtTagStart(int i) { 1886 return getRuleContext(RtTagStartContext.class,i); 1887 } 1888 public List<RtcTagStartContext> rtcTagStart() { 1889 return getRuleContexts(RtcTagStartContext.class); 1890 } 1891 public RtcTagStartContext rtcTagStart(int i) { 1892 return getRuleContext(RtcTagStartContext.class,i); 1893 } 1894 public List<RpTagStartContext> rpTagStart() { 1895 return getRuleContexts(RpTagStartContext.class); 1896 } 1897 public RpTagStartContext rpTagStart(int i) { 1898 return getRuleContext(RpTagStartContext.class,i); 1899 } 1900 public List<HtmlCommentContext> htmlComment() { 1901 return getRuleContexts(HtmlCommentContext.class); 1902 } 1903 public HtmlCommentContext htmlComment(int i) { 1904 return getRuleContext(HtmlCommentContext.class,i); 1905 } 1906 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1907 public TerminalNode CDATA(int i) { 1908 return getToken(JavadocParser.CDATA, i); 1909 } 1910 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1911 public TerminalNode NEWLINE(int i) { 1912 return getToken(JavadocParser.NEWLINE, i); 1913 } 1914 public List<TextContext> text() { 1915 return getRuleContexts(TextContext.class); 1916 } 1917 public TextContext text(int i) { 1918 return getRuleContext(TextContext.class,i); 1919 } 1920 public List<JavadocInlineTagContext> javadocInlineTag() { 1921 return getRuleContexts(JavadocInlineTagContext.class); 1922 } 1923 public JavadocInlineTagContext javadocInlineTag(int i) { 1924 return getRuleContext(JavadocInlineTagContext.class,i); 1925 } 1926 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1927 public TerminalNode LEADING_ASTERISK(int i) { 1928 return getToken(JavadocParser.LEADING_ASTERISK, i); 1929 } 1930 public ParagraphContext(ParserRuleContext parent, int invokingState) { 1931 super(parent, invokingState); 1932 } 1933 @Override public int getRuleIndex() { return RULE_paragraph; } 1934 } 1935 1936 public final ParagraphContext paragraph() throws RecognitionException { 1937 ParagraphContext _localctx = new ParagraphContext(_ctx, getState()); 1938 enterRule(_localctx, 16, RULE_paragraph); 1939 try { 1940 int _alt; 1941 enterOuterAlt(_localctx, 1); 1942 { 1943 setState(368); 1944 pTagStart(false); 1945 setState(418); 1946 _errHandler.sync(this); 1947 _alt = getInterpreter().adaptivePredict(_input,18,_ctx); 1948 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1949 if ( _alt==1 ) { 1950 { 1951 setState(416); 1952 _errHandler.sync(this); 1953 switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { 1954 case 1: 1955 { 1956 setState(369); 1957 htmlTag(); 1958 } 1959 break; 1960 case 2: 1961 { 1962 setState(370); 1963 singletonElement(); 1964 } 1965 break; 1966 case 3: 1967 { 1968 setState(371); 1969 li(); 1970 } 1971 break; 1972 case 4: 1973 { 1974 setState(372); 1975 tr(); 1976 } 1977 break; 1978 case 5: 1979 { 1980 setState(373); 1981 td(); 1982 } 1983 break; 1984 case 6: 1985 { 1986 setState(374); 1987 th(); 1988 } 1989 break; 1990 case 7: 1991 { 1992 setState(375); 1993 body(); 1994 } 1995 break; 1996 case 8: 1997 { 1998 setState(376); 1999 colgroup(); 2000 } 2001 break; 2002 case 9: 2003 { 2004 setState(377); 2005 dd(); 2006 } 2007 break; 2008 case 10: 2009 { 2010 setState(378); 2011 dt(); 2012 } 2013 break; 2014 case 11: 2015 { 2016 setState(379); 2017 head(); 2018 } 2019 break; 2020 case 12: 2021 { 2022 setState(380); 2023 html(); 2024 } 2025 break; 2026 case 13: 2027 { 2028 setState(381); 2029 option(); 2030 } 2031 break; 2032 case 14: 2033 { 2034 setState(382); 2035 tbody(); 2036 } 2037 break; 2038 case 15: 2039 { 2040 setState(383); 2041 thead(); 2042 } 2043 break; 2044 case 16: 2045 { 2046 setState(384); 2047 tfoot(); 2048 } 2049 break; 2050 case 17: 2051 { 2052 setState(385); 2053 optgroup(); 2054 } 2055 break; 2056 case 18: 2057 { 2058 setState(386); 2059 rb(); 2060 } 2061 break; 2062 case 19: 2063 { 2064 setState(387); 2065 rt(); 2066 } 2067 break; 2068 case 20: 2069 { 2070 setState(388); 2071 rtc(); 2072 } 2073 break; 2074 case 21: 2075 { 2076 setState(389); 2077 rp(); 2078 } 2079 break; 2080 case 22: 2081 { 2082 setState(390); 2083 liTagStart(true); 2084 } 2085 break; 2086 case 23: 2087 { 2088 setState(391); 2089 trTagStart(true); 2090 } 2091 break; 2092 case 24: 2093 { 2094 setState(392); 2095 tdTagStart(true); 2096 } 2097 break; 2098 case 25: 2099 { 2100 setState(393); 2101 thTagStart(true); 2102 } 2103 break; 2104 case 26: 2105 { 2106 setState(394); 2107 bodyTagStart(true); 2108 } 2109 break; 2110 case 27: 2111 { 2112 setState(395); 2113 colgroupTagStart(true); 2114 } 2115 break; 2116 case 28: 2117 { 2118 setState(396); 2119 ddTagStart(true); 2120 } 2121 break; 2122 case 29: 2123 { 2124 setState(397); 2125 dtTagStart(true); 2126 } 2127 break; 2128 case 30: 2129 { 2130 setState(398); 2131 headTagStart(true); 2132 } 2133 break; 2134 case 31: 2135 { 2136 setState(399); 2137 htmlTagStart(true); 2138 } 2139 break; 2140 case 32: 2141 { 2142 setState(400); 2143 optionTagStart(true); 2144 } 2145 break; 2146 case 33: 2147 { 2148 setState(401); 2149 tbodyTagStart(true); 2150 } 2151 break; 2152 case 34: 2153 { 2154 setState(402); 2155 theadTagStart(true); 2156 } 2157 break; 2158 case 35: 2159 { 2160 setState(403); 2161 tfootTagStart(true); 2162 } 2163 break; 2164 case 36: 2165 { 2166 setState(404); 2167 optgroupTagStart(true); 2168 } 2169 break; 2170 case 37: 2171 { 2172 setState(405); 2173 rbTagStart(true); 2174 } 2175 break; 2176 case 38: 2177 { 2178 setState(406); 2179 rtTagStart(true); 2180 } 2181 break; 2182 case 39: 2183 { 2184 setState(407); 2185 rtcTagStart(true); 2186 } 2187 break; 2188 case 40: 2189 { 2190 setState(408); 2191 rpTagStart(true); 2192 } 2193 break; 2194 case 41: 2195 { 2196 { 2197 setState(409); 2198 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2199 setState(410); 2200 match(LEADING_ASTERISK); 2201 } 2202 } 2203 break; 2204 case 42: 2205 { 2206 setState(411); 2207 htmlComment(); 2208 } 2209 break; 2210 case 43: 2211 { 2212 setState(412); 2213 match(CDATA); 2214 } 2215 break; 2216 case 44: 2217 { 2218 setState(413); 2219 match(NEWLINE); 2220 } 2221 break; 2222 case 45: 2223 { 2224 setState(414); 2225 text(); 2226 } 2227 break; 2228 case 46: 2229 { 2230 setState(415); 2231 javadocInlineTag(); 2232 } 2233 break; 2234 } 2235 } 2236 } 2237 setState(420); 2238 _errHandler.sync(this); 2239 _alt = getInterpreter().adaptivePredict(_input,18,_ctx); 2240 } 2241 setState(421); 2242 pTagEnd(); 2243 } 2244 } 2245 catch (RecognitionException re) { 2246 _localctx.exception = re; 2247 _errHandler.reportError(this, re); 2248 _errHandler.recover(this, re); 2249 } 2250 finally { 2251 exitRule(); 2252 } 2253 return _localctx; 2254 } 2255 2256 public static class LiTagStartContext extends ParserRuleContext { 2257 public boolean isNonTight; 2258 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 2259 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2260 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 2261 public List<AttributeContext> attribute() { 2262 return getRuleContexts(AttributeContext.class); 2263 } 2264 public AttributeContext attribute(int i) { 2265 return getRuleContext(AttributeContext.class,i); 2266 } 2267 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2268 public TerminalNode NEWLINE(int i) { 2269 return getToken(JavadocParser.NEWLINE, i); 2270 } 2271 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2272 public TerminalNode LEADING_ASTERISK(int i) { 2273 return getToken(JavadocParser.LEADING_ASTERISK, i); 2274 } 2275 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2276 public TerminalNode WS(int i) { 2277 return getToken(JavadocParser.WS, i); 2278 } 2279 public LiTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 2280 public LiTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 2281 super(parent, invokingState); 2282 this.isNonTight = isNonTight; 2283 } 2284 @Override public int getRuleIndex() { return RULE_liTagStart; } 2285 } 2286 2287 public final LiTagStartContext liTagStart(boolean isNonTight) throws RecognitionException { 2288 LiTagStartContext _localctx = new LiTagStartContext(_ctx, getState(), isNonTight); 2289 enterRule(_localctx, 18, RULE_liTagStart); 2290 int _la; 2291 try { 2292 enterOuterAlt(_localctx, 1); 2293 { 2294 setState(423); 2295 match(START); 2296 setState(424); 2297 match(LI_HTML_TAG_NAME); 2298 setState(431); 2299 _errHandler.sync(this); 2300 _la = _input.LA(1); 2301 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2302 { 2303 setState(429); 2304 _errHandler.sync(this); 2305 switch (_input.LA(1)) { 2306 case HTML_TAG_NAME: 2307 { 2308 setState(425); 2309 attribute(); 2310 } 2311 break; 2312 case NEWLINE: 2313 { 2314 setState(426); 2315 match(NEWLINE); 2316 } 2317 break; 2318 case LEADING_ASTERISK: 2319 { 2320 setState(427); 2321 match(LEADING_ASTERISK); 2322 } 2323 break; 2324 case WS: 2325 { 2326 setState(428); 2327 match(WS); 2328 } 2329 break; 2330 default: 2331 throw new NoViableAltException(this); 2332 } 2333 } 2334 setState(433); 2335 _errHandler.sync(this); 2336 _la = _input.LA(1); 2337 } 2338 setState(434); 2339 match(END); 2340 } 2341 _ctx.stop = _input.LT(-1); 2342 2343 if (isNonTight && nonTightTagStartContext == null) { 2344 nonTightTagStartContext = _localctx; 2345 } 2346 2347 } 2348 catch (RecognitionException re) { 2349 _localctx.exception = re; 2350 _errHandler.reportError(this, re); 2351 _errHandler.recover(this, re); 2352 } 2353 finally { 2354 exitRule(); 2355 } 2356 return _localctx; 2357 } 2358 2359 public static class LiTagEndContext extends ParserRuleContext { 2360 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 2361 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2362 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2363 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 2364 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2365 public TerminalNode NEWLINE(int i) { 2366 return getToken(JavadocParser.NEWLINE, i); 2367 } 2368 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2369 public TerminalNode LEADING_ASTERISK(int i) { 2370 return getToken(JavadocParser.LEADING_ASTERISK, i); 2371 } 2372 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2373 public TerminalNode WS(int i) { 2374 return getToken(JavadocParser.WS, i); 2375 } 2376 public LiTagEndContext(ParserRuleContext parent, int invokingState) { 2377 super(parent, invokingState); 2378 } 2379 @Override public int getRuleIndex() { return RULE_liTagEnd; } 2380 } 2381 2382 public final LiTagEndContext liTagEnd() throws RecognitionException { 2383 LiTagEndContext _localctx = new LiTagEndContext(_ctx, getState()); 2384 enterRule(_localctx, 20, RULE_liTagEnd); 2385 int _la; 2386 try { 2387 enterOuterAlt(_localctx, 1); 2388 { 2389 setState(436); 2390 match(START); 2391 setState(437); 2392 match(SLASH); 2393 setState(438); 2394 match(LI_HTML_TAG_NAME); 2395 setState(442); 2396 _errHandler.sync(this); 2397 _la = _input.LA(1); 2398 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2399 { 2400 { 2401 setState(439); 2402 _la = _input.LA(1); 2403 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2404 _errHandler.recoverInline(this); 2405 } 2406 else { 2407 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 2408 _errHandler.reportMatch(this); 2409 consume(); 2410 } 2411 } 2412 } 2413 setState(444); 2414 _errHandler.sync(this); 2415 _la = _input.LA(1); 2416 } 2417 setState(445); 2418 match(END); 2419 } 2420 } 2421 catch (RecognitionException re) { 2422 _localctx.exception = re; 2423 _errHandler.reportError(this, re); 2424 _errHandler.recover(this, re); 2425 } 2426 finally { 2427 exitRule(); 2428 } 2429 return _localctx; 2430 } 2431 2432 public static class LiContext extends ParserRuleContext { 2433 public LiTagStartContext liTagStart() { 2434 return getRuleContext(LiTagStartContext.class,0); 2435 } 2436 public LiTagEndContext liTagEnd() { 2437 return getRuleContext(LiTagEndContext.class,0); 2438 } 2439 public List<HtmlTagContext> htmlTag() { 2440 return getRuleContexts(HtmlTagContext.class); 2441 } 2442 public HtmlTagContext htmlTag(int i) { 2443 return getRuleContext(HtmlTagContext.class,i); 2444 } 2445 public List<SingletonElementContext> singletonElement() { 2446 return getRuleContexts(SingletonElementContext.class); 2447 } 2448 public SingletonElementContext singletonElement(int i) { 2449 return getRuleContext(SingletonElementContext.class,i); 2450 } 2451 public List<ParagraphContext> paragraph() { 2452 return getRuleContexts(ParagraphContext.class); 2453 } 2454 public ParagraphContext paragraph(int i) { 2455 return getRuleContext(ParagraphContext.class,i); 2456 } 2457 public List<TrContext> tr() { 2458 return getRuleContexts(TrContext.class); 2459 } 2460 public TrContext tr(int i) { 2461 return getRuleContext(TrContext.class,i); 2462 } 2463 public List<TdContext> td() { 2464 return getRuleContexts(TdContext.class); 2465 } 2466 public TdContext td(int i) { 2467 return getRuleContext(TdContext.class,i); 2468 } 2469 public List<ThContext> th() { 2470 return getRuleContexts(ThContext.class); 2471 } 2472 public ThContext th(int i) { 2473 return getRuleContext(ThContext.class,i); 2474 } 2475 public List<BodyContext> body() { 2476 return getRuleContexts(BodyContext.class); 2477 } 2478 public BodyContext body(int i) { 2479 return getRuleContext(BodyContext.class,i); 2480 } 2481 public List<ColgroupContext> colgroup() { 2482 return getRuleContexts(ColgroupContext.class); 2483 } 2484 public ColgroupContext colgroup(int i) { 2485 return getRuleContext(ColgroupContext.class,i); 2486 } 2487 public List<DdContext> dd() { 2488 return getRuleContexts(DdContext.class); 2489 } 2490 public DdContext dd(int i) { 2491 return getRuleContext(DdContext.class,i); 2492 } 2493 public List<DtContext> dt() { 2494 return getRuleContexts(DtContext.class); 2495 } 2496 public DtContext dt(int i) { 2497 return getRuleContext(DtContext.class,i); 2498 } 2499 public List<HeadContext> head() { 2500 return getRuleContexts(HeadContext.class); 2501 } 2502 public HeadContext head(int i) { 2503 return getRuleContext(HeadContext.class,i); 2504 } 2505 public List<HtmlContext> html() { 2506 return getRuleContexts(HtmlContext.class); 2507 } 2508 public HtmlContext html(int i) { 2509 return getRuleContext(HtmlContext.class,i); 2510 } 2511 public List<OptionContext> option() { 2512 return getRuleContexts(OptionContext.class); 2513 } 2514 public OptionContext option(int i) { 2515 return getRuleContext(OptionContext.class,i); 2516 } 2517 public List<TbodyContext> tbody() { 2518 return getRuleContexts(TbodyContext.class); 2519 } 2520 public TbodyContext tbody(int i) { 2521 return getRuleContext(TbodyContext.class,i); 2522 } 2523 public List<TheadContext> thead() { 2524 return getRuleContexts(TheadContext.class); 2525 } 2526 public TheadContext thead(int i) { 2527 return getRuleContext(TheadContext.class,i); 2528 } 2529 public List<TfootContext> tfoot() { 2530 return getRuleContexts(TfootContext.class); 2531 } 2532 public TfootContext tfoot(int i) { 2533 return getRuleContext(TfootContext.class,i); 2534 } 2535 public List<OptgroupContext> optgroup() { 2536 return getRuleContexts(OptgroupContext.class); 2537 } 2538 public OptgroupContext optgroup(int i) { 2539 return getRuleContext(OptgroupContext.class,i); 2540 } 2541 public List<RbContext> rb() { 2542 return getRuleContexts(RbContext.class); 2543 } 2544 public RbContext rb(int i) { 2545 return getRuleContext(RbContext.class,i); 2546 } 2547 public List<RtContext> rt() { 2548 return getRuleContexts(RtContext.class); 2549 } 2550 public RtContext rt(int i) { 2551 return getRuleContext(RtContext.class,i); 2552 } 2553 public List<RtcContext> rtc() { 2554 return getRuleContexts(RtcContext.class); 2555 } 2556 public RtcContext rtc(int i) { 2557 return getRuleContext(RtcContext.class,i); 2558 } 2559 public List<RpContext> rp() { 2560 return getRuleContexts(RpContext.class); 2561 } 2562 public RpContext rp(int i) { 2563 return getRuleContext(RpContext.class,i); 2564 } 2565 public List<PTagStartContext> pTagStart() { 2566 return getRuleContexts(PTagStartContext.class); 2567 } 2568 public PTagStartContext pTagStart(int i) { 2569 return getRuleContext(PTagStartContext.class,i); 2570 } 2571 public List<TrTagStartContext> trTagStart() { 2572 return getRuleContexts(TrTagStartContext.class); 2573 } 2574 public TrTagStartContext trTagStart(int i) { 2575 return getRuleContext(TrTagStartContext.class,i); 2576 } 2577 public List<TdTagStartContext> tdTagStart() { 2578 return getRuleContexts(TdTagStartContext.class); 2579 } 2580 public TdTagStartContext tdTagStart(int i) { 2581 return getRuleContext(TdTagStartContext.class,i); 2582 } 2583 public List<ThTagStartContext> thTagStart() { 2584 return getRuleContexts(ThTagStartContext.class); 2585 } 2586 public ThTagStartContext thTagStart(int i) { 2587 return getRuleContext(ThTagStartContext.class,i); 2588 } 2589 public List<BodyTagStartContext> bodyTagStart() { 2590 return getRuleContexts(BodyTagStartContext.class); 2591 } 2592 public BodyTagStartContext bodyTagStart(int i) { 2593 return getRuleContext(BodyTagStartContext.class,i); 2594 } 2595 public List<ColgroupTagStartContext> colgroupTagStart() { 2596 return getRuleContexts(ColgroupTagStartContext.class); 2597 } 2598 public ColgroupTagStartContext colgroupTagStart(int i) { 2599 return getRuleContext(ColgroupTagStartContext.class,i); 2600 } 2601 public List<DdTagStartContext> ddTagStart() { 2602 return getRuleContexts(DdTagStartContext.class); 2603 } 2604 public DdTagStartContext ddTagStart(int i) { 2605 return getRuleContext(DdTagStartContext.class,i); 2606 } 2607 public List<DtTagStartContext> dtTagStart() { 2608 return getRuleContexts(DtTagStartContext.class); 2609 } 2610 public DtTagStartContext dtTagStart(int i) { 2611 return getRuleContext(DtTagStartContext.class,i); 2612 } 2613 public List<HeadTagStartContext> headTagStart() { 2614 return getRuleContexts(HeadTagStartContext.class); 2615 } 2616 public HeadTagStartContext headTagStart(int i) { 2617 return getRuleContext(HeadTagStartContext.class,i); 2618 } 2619 public List<HtmlTagStartContext> htmlTagStart() { 2620 return getRuleContexts(HtmlTagStartContext.class); 2621 } 2622 public HtmlTagStartContext htmlTagStart(int i) { 2623 return getRuleContext(HtmlTagStartContext.class,i); 2624 } 2625 public List<OptionTagStartContext> optionTagStart() { 2626 return getRuleContexts(OptionTagStartContext.class); 2627 } 2628 public OptionTagStartContext optionTagStart(int i) { 2629 return getRuleContext(OptionTagStartContext.class,i); 2630 } 2631 public List<TbodyTagStartContext> tbodyTagStart() { 2632 return getRuleContexts(TbodyTagStartContext.class); 2633 } 2634 public TbodyTagStartContext tbodyTagStart(int i) { 2635 return getRuleContext(TbodyTagStartContext.class,i); 2636 } 2637 public List<TheadTagStartContext> theadTagStart() { 2638 return getRuleContexts(TheadTagStartContext.class); 2639 } 2640 public TheadTagStartContext theadTagStart(int i) { 2641 return getRuleContext(TheadTagStartContext.class,i); 2642 } 2643 public List<TfootTagStartContext> tfootTagStart() { 2644 return getRuleContexts(TfootTagStartContext.class); 2645 } 2646 public TfootTagStartContext tfootTagStart(int i) { 2647 return getRuleContext(TfootTagStartContext.class,i); 2648 } 2649 public List<OptgroupTagStartContext> optgroupTagStart() { 2650 return getRuleContexts(OptgroupTagStartContext.class); 2651 } 2652 public OptgroupTagStartContext optgroupTagStart(int i) { 2653 return getRuleContext(OptgroupTagStartContext.class,i); 2654 } 2655 public List<RbTagStartContext> rbTagStart() { 2656 return getRuleContexts(RbTagStartContext.class); 2657 } 2658 public RbTagStartContext rbTagStart(int i) { 2659 return getRuleContext(RbTagStartContext.class,i); 2660 } 2661 public List<RtTagStartContext> rtTagStart() { 2662 return getRuleContexts(RtTagStartContext.class); 2663 } 2664 public RtTagStartContext rtTagStart(int i) { 2665 return getRuleContext(RtTagStartContext.class,i); 2666 } 2667 public List<RtcTagStartContext> rtcTagStart() { 2668 return getRuleContexts(RtcTagStartContext.class); 2669 } 2670 public RtcTagStartContext rtcTagStart(int i) { 2671 return getRuleContext(RtcTagStartContext.class,i); 2672 } 2673 public List<RpTagStartContext> rpTagStart() { 2674 return getRuleContexts(RpTagStartContext.class); 2675 } 2676 public RpTagStartContext rpTagStart(int i) { 2677 return getRuleContext(RpTagStartContext.class,i); 2678 } 2679 public List<HtmlCommentContext> htmlComment() { 2680 return getRuleContexts(HtmlCommentContext.class); 2681 } 2682 public HtmlCommentContext htmlComment(int i) { 2683 return getRuleContext(HtmlCommentContext.class,i); 2684 } 2685 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 2686 public TerminalNode CDATA(int i) { 2687 return getToken(JavadocParser.CDATA, i); 2688 } 2689 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2690 public TerminalNode NEWLINE(int i) { 2691 return getToken(JavadocParser.NEWLINE, i); 2692 } 2693 public List<TextContext> text() { 2694 return getRuleContexts(TextContext.class); 2695 } 2696 public TextContext text(int i) { 2697 return getRuleContext(TextContext.class,i); 2698 } 2699 public List<JavadocInlineTagContext> javadocInlineTag() { 2700 return getRuleContexts(JavadocInlineTagContext.class); 2701 } 2702 public JavadocInlineTagContext javadocInlineTag(int i) { 2703 return getRuleContext(JavadocInlineTagContext.class,i); 2704 } 2705 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2706 public TerminalNode LEADING_ASTERISK(int i) { 2707 return getToken(JavadocParser.LEADING_ASTERISK, i); 2708 } 2709 public LiContext(ParserRuleContext parent, int invokingState) { 2710 super(parent, invokingState); 2711 } 2712 @Override public int getRuleIndex() { return RULE_li; } 2713 } 2714 2715 public final LiContext li() throws RecognitionException { 2716 LiContext _localctx = new LiContext(_ctx, getState()); 2717 enterRule(_localctx, 22, RULE_li); 2718 try { 2719 int _alt; 2720 enterOuterAlt(_localctx, 1); 2721 { 2722 setState(447); 2723 liTagStart(false); 2724 setState(497); 2725 _errHandler.sync(this); 2726 _alt = getInterpreter().adaptivePredict(_input,23,_ctx); 2727 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 2728 if ( _alt==1 ) { 2729 { 2730 setState(495); 2731 _errHandler.sync(this); 2732 switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) { 2733 case 1: 2734 { 2735 setState(448); 2736 htmlTag(); 2737 } 2738 break; 2739 case 2: 2740 { 2741 setState(449); 2742 singletonElement(); 2743 } 2744 break; 2745 case 3: 2746 { 2747 setState(450); 2748 paragraph(); 2749 } 2750 break; 2751 case 4: 2752 { 2753 setState(451); 2754 tr(); 2755 } 2756 break; 2757 case 5: 2758 { 2759 setState(452); 2760 td(); 2761 } 2762 break; 2763 case 6: 2764 { 2765 setState(453); 2766 th(); 2767 } 2768 break; 2769 case 7: 2770 { 2771 setState(454); 2772 body(); 2773 } 2774 break; 2775 case 8: 2776 { 2777 setState(455); 2778 colgroup(); 2779 } 2780 break; 2781 case 9: 2782 { 2783 setState(456); 2784 dd(); 2785 } 2786 break; 2787 case 10: 2788 { 2789 setState(457); 2790 dt(); 2791 } 2792 break; 2793 case 11: 2794 { 2795 setState(458); 2796 head(); 2797 } 2798 break; 2799 case 12: 2800 { 2801 setState(459); 2802 html(); 2803 } 2804 break; 2805 case 13: 2806 { 2807 setState(460); 2808 option(); 2809 } 2810 break; 2811 case 14: 2812 { 2813 setState(461); 2814 tbody(); 2815 } 2816 break; 2817 case 15: 2818 { 2819 setState(462); 2820 thead(); 2821 } 2822 break; 2823 case 16: 2824 { 2825 setState(463); 2826 tfoot(); 2827 } 2828 break; 2829 case 17: 2830 { 2831 setState(464); 2832 optgroup(); 2833 } 2834 break; 2835 case 18: 2836 { 2837 setState(465); 2838 rb(); 2839 } 2840 break; 2841 case 19: 2842 { 2843 setState(466); 2844 rt(); 2845 } 2846 break; 2847 case 20: 2848 { 2849 setState(467); 2850 rtc(); 2851 } 2852 break; 2853 case 21: 2854 { 2855 setState(468); 2856 rp(); 2857 } 2858 break; 2859 case 22: 2860 { 2861 setState(469); 2862 pTagStart(true); 2863 } 2864 break; 2865 case 23: 2866 { 2867 setState(470); 2868 trTagStart(true); 2869 } 2870 break; 2871 case 24: 2872 { 2873 setState(471); 2874 tdTagStart(true); 2875 } 2876 break; 2877 case 25: 2878 { 2879 setState(472); 2880 thTagStart(true); 2881 } 2882 break; 2883 case 26: 2884 { 2885 setState(473); 2886 bodyTagStart(true); 2887 } 2888 break; 2889 case 27: 2890 { 2891 setState(474); 2892 colgroupTagStart(true); 2893 } 2894 break; 2895 case 28: 2896 { 2897 setState(475); 2898 ddTagStart(true); 2899 } 2900 break; 2901 case 29: 2902 { 2903 setState(476); 2904 dtTagStart(true); 2905 } 2906 break; 2907 case 30: 2908 { 2909 setState(477); 2910 headTagStart(true); 2911 } 2912 break; 2913 case 31: 2914 { 2915 setState(478); 2916 htmlTagStart(true); 2917 } 2918 break; 2919 case 32: 2920 { 2921 setState(479); 2922 optionTagStart(true); 2923 } 2924 break; 2925 case 33: 2926 { 2927 setState(480); 2928 tbodyTagStart(true); 2929 } 2930 break; 2931 case 34: 2932 { 2933 setState(481); 2934 theadTagStart(true); 2935 } 2936 break; 2937 case 35: 2938 { 2939 setState(482); 2940 tfootTagStart(true); 2941 } 2942 break; 2943 case 36: 2944 { 2945 setState(483); 2946 optgroupTagStart(true); 2947 } 2948 break; 2949 case 37: 2950 { 2951 setState(484); 2952 rbTagStart(true); 2953 } 2954 break; 2955 case 38: 2956 { 2957 setState(485); 2958 rtTagStart(true); 2959 } 2960 break; 2961 case 39: 2962 { 2963 setState(486); 2964 rtcTagStart(true); 2965 } 2966 break; 2967 case 40: 2968 { 2969 setState(487); 2970 rpTagStart(true); 2971 } 2972 break; 2973 case 41: 2974 { 2975 { 2976 setState(488); 2977 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2978 setState(489); 2979 match(LEADING_ASTERISK); 2980 } 2981 } 2982 break; 2983 case 42: 2984 { 2985 setState(490); 2986 htmlComment(); 2987 } 2988 break; 2989 case 43: 2990 { 2991 setState(491); 2992 match(CDATA); 2993 } 2994 break; 2995 case 44: 2996 { 2997 setState(492); 2998 match(NEWLINE); 2999 } 3000 break; 3001 case 45: 3002 { 3003 setState(493); 3004 text(); 3005 } 3006 break; 3007 case 46: 3008 { 3009 setState(494); 3010 javadocInlineTag(); 3011 } 3012 break; 3013 } 3014 } 3015 } 3016 setState(499); 3017 _errHandler.sync(this); 3018 _alt = getInterpreter().adaptivePredict(_input,23,_ctx); 3019 } 3020 setState(500); 3021 liTagEnd(); 3022 } 3023 } 3024 catch (RecognitionException re) { 3025 _localctx.exception = re; 3026 _errHandler.reportError(this, re); 3027 _errHandler.recover(this, re); 3028 } 3029 finally { 3030 exitRule(); 3031 } 3032 return _localctx; 3033 } 3034 3035 public static class TrTagStartContext extends ParserRuleContext { 3036 public boolean isNonTight; 3037 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 3038 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 3039 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 3040 public List<AttributeContext> attribute() { 3041 return getRuleContexts(AttributeContext.class); 3042 } 3043 public AttributeContext attribute(int i) { 3044 return getRuleContext(AttributeContext.class,i); 3045 } 3046 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3047 public TerminalNode NEWLINE(int i) { 3048 return getToken(JavadocParser.NEWLINE, i); 3049 } 3050 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3051 public TerminalNode LEADING_ASTERISK(int i) { 3052 return getToken(JavadocParser.LEADING_ASTERISK, i); 3053 } 3054 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3055 public TerminalNode WS(int i) { 3056 return getToken(JavadocParser.WS, i); 3057 } 3058 public TrTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 3059 public TrTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 3060 super(parent, invokingState); 3061 this.isNonTight = isNonTight; 3062 } 3063 @Override public int getRuleIndex() { return RULE_trTagStart; } 3064 } 3065 3066 public final TrTagStartContext trTagStart(boolean isNonTight) throws RecognitionException { 3067 TrTagStartContext _localctx = new TrTagStartContext(_ctx, getState(), isNonTight); 3068 enterRule(_localctx, 24, RULE_trTagStart); 3069 int _la; 3070 try { 3071 enterOuterAlt(_localctx, 1); 3072 { 3073 setState(502); 3074 match(START); 3075 setState(503); 3076 match(TR_HTML_TAG_NAME); 3077 setState(510); 3078 _errHandler.sync(this); 3079 _la = _input.LA(1); 3080 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 3081 { 3082 setState(508); 3083 _errHandler.sync(this); 3084 switch (_input.LA(1)) { 3085 case HTML_TAG_NAME: 3086 { 3087 setState(504); 3088 attribute(); 3089 } 3090 break; 3091 case NEWLINE: 3092 { 3093 setState(505); 3094 match(NEWLINE); 3095 } 3096 break; 3097 case LEADING_ASTERISK: 3098 { 3099 setState(506); 3100 match(LEADING_ASTERISK); 3101 } 3102 break; 3103 case WS: 3104 { 3105 setState(507); 3106 match(WS); 3107 } 3108 break; 3109 default: 3110 throw new NoViableAltException(this); 3111 } 3112 } 3113 setState(512); 3114 _errHandler.sync(this); 3115 _la = _input.LA(1); 3116 } 3117 setState(513); 3118 match(END); 3119 } 3120 _ctx.stop = _input.LT(-1); 3121 3122 if (isNonTight && nonTightTagStartContext == null) { 3123 nonTightTagStartContext = _localctx; 3124 } 3125 3126 } 3127 catch (RecognitionException re) { 3128 _localctx.exception = re; 3129 _errHandler.reportError(this, re); 3130 _errHandler.recover(this, re); 3131 } 3132 finally { 3133 exitRule(); 3134 } 3135 return _localctx; 3136 } 3137 3138 public static class TrTagEndContext extends ParserRuleContext { 3139 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 3140 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 3141 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 3142 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 3143 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3144 public TerminalNode NEWLINE(int i) { 3145 return getToken(JavadocParser.NEWLINE, i); 3146 } 3147 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3148 public TerminalNode LEADING_ASTERISK(int i) { 3149 return getToken(JavadocParser.LEADING_ASTERISK, i); 3150 } 3151 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3152 public TerminalNode WS(int i) { 3153 return getToken(JavadocParser.WS, i); 3154 } 3155 public TrTagEndContext(ParserRuleContext parent, int invokingState) { 3156 super(parent, invokingState); 3157 } 3158 @Override public int getRuleIndex() { return RULE_trTagEnd; } 3159 } 3160 3161 public final TrTagEndContext trTagEnd() throws RecognitionException { 3162 TrTagEndContext _localctx = new TrTagEndContext(_ctx, getState()); 3163 enterRule(_localctx, 26, RULE_trTagEnd); 3164 int _la; 3165 try { 3166 enterOuterAlt(_localctx, 1); 3167 { 3168 setState(515); 3169 match(START); 3170 setState(516); 3171 match(SLASH); 3172 setState(517); 3173 match(TR_HTML_TAG_NAME); 3174 setState(521); 3175 _errHandler.sync(this); 3176 _la = _input.LA(1); 3177 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 3178 { 3179 { 3180 setState(518); 3181 _la = _input.LA(1); 3182 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 3183 _errHandler.recoverInline(this); 3184 } 3185 else { 3186 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3187 _errHandler.reportMatch(this); 3188 consume(); 3189 } 3190 } 3191 } 3192 setState(523); 3193 _errHandler.sync(this); 3194 _la = _input.LA(1); 3195 } 3196 setState(524); 3197 match(END); 3198 } 3199 } 3200 catch (RecognitionException re) { 3201 _localctx.exception = re; 3202 _errHandler.reportError(this, re); 3203 _errHandler.recover(this, re); 3204 } 3205 finally { 3206 exitRule(); 3207 } 3208 return _localctx; 3209 } 3210 3211 public static class TrContext extends ParserRuleContext { 3212 public TrTagStartContext trTagStart() { 3213 return getRuleContext(TrTagStartContext.class,0); 3214 } 3215 public TrTagEndContext trTagEnd() { 3216 return getRuleContext(TrTagEndContext.class,0); 3217 } 3218 public List<HtmlTagContext> htmlTag() { 3219 return getRuleContexts(HtmlTagContext.class); 3220 } 3221 public HtmlTagContext htmlTag(int i) { 3222 return getRuleContext(HtmlTagContext.class,i); 3223 } 3224 public List<SingletonElementContext> singletonElement() { 3225 return getRuleContexts(SingletonElementContext.class); 3226 } 3227 public SingletonElementContext singletonElement(int i) { 3228 return getRuleContext(SingletonElementContext.class,i); 3229 } 3230 public List<ParagraphContext> paragraph() { 3231 return getRuleContexts(ParagraphContext.class); 3232 } 3233 public ParagraphContext paragraph(int i) { 3234 return getRuleContext(ParagraphContext.class,i); 3235 } 3236 public List<LiContext> li() { 3237 return getRuleContexts(LiContext.class); 3238 } 3239 public LiContext li(int i) { 3240 return getRuleContext(LiContext.class,i); 3241 } 3242 public List<TdContext> td() { 3243 return getRuleContexts(TdContext.class); 3244 } 3245 public TdContext td(int i) { 3246 return getRuleContext(TdContext.class,i); 3247 } 3248 public List<ThContext> th() { 3249 return getRuleContexts(ThContext.class); 3250 } 3251 public ThContext th(int i) { 3252 return getRuleContext(ThContext.class,i); 3253 } 3254 public List<BodyContext> body() { 3255 return getRuleContexts(BodyContext.class); 3256 } 3257 public BodyContext body(int i) { 3258 return getRuleContext(BodyContext.class,i); 3259 } 3260 public List<ColgroupContext> colgroup() { 3261 return getRuleContexts(ColgroupContext.class); 3262 } 3263 public ColgroupContext colgroup(int i) { 3264 return getRuleContext(ColgroupContext.class,i); 3265 } 3266 public List<DdContext> dd() { 3267 return getRuleContexts(DdContext.class); 3268 } 3269 public DdContext dd(int i) { 3270 return getRuleContext(DdContext.class,i); 3271 } 3272 public List<DtContext> dt() { 3273 return getRuleContexts(DtContext.class); 3274 } 3275 public DtContext dt(int i) { 3276 return getRuleContext(DtContext.class,i); 3277 } 3278 public List<HeadContext> head() { 3279 return getRuleContexts(HeadContext.class); 3280 } 3281 public HeadContext head(int i) { 3282 return getRuleContext(HeadContext.class,i); 3283 } 3284 public List<HtmlContext> html() { 3285 return getRuleContexts(HtmlContext.class); 3286 } 3287 public HtmlContext html(int i) { 3288 return getRuleContext(HtmlContext.class,i); 3289 } 3290 public List<OptionContext> option() { 3291 return getRuleContexts(OptionContext.class); 3292 } 3293 public OptionContext option(int i) { 3294 return getRuleContext(OptionContext.class,i); 3295 } 3296 public List<TbodyContext> tbody() { 3297 return getRuleContexts(TbodyContext.class); 3298 } 3299 public TbodyContext tbody(int i) { 3300 return getRuleContext(TbodyContext.class,i); 3301 } 3302 public List<TheadContext> thead() { 3303 return getRuleContexts(TheadContext.class); 3304 } 3305 public TheadContext thead(int i) { 3306 return getRuleContext(TheadContext.class,i); 3307 } 3308 public List<TfootContext> tfoot() { 3309 return getRuleContexts(TfootContext.class); 3310 } 3311 public TfootContext tfoot(int i) { 3312 return getRuleContext(TfootContext.class,i); 3313 } 3314 public List<OptgroupContext> optgroup() { 3315 return getRuleContexts(OptgroupContext.class); 3316 } 3317 public OptgroupContext optgroup(int i) { 3318 return getRuleContext(OptgroupContext.class,i); 3319 } 3320 public List<RbContext> rb() { 3321 return getRuleContexts(RbContext.class); 3322 } 3323 public RbContext rb(int i) { 3324 return getRuleContext(RbContext.class,i); 3325 } 3326 public List<RtContext> rt() { 3327 return getRuleContexts(RtContext.class); 3328 } 3329 public RtContext rt(int i) { 3330 return getRuleContext(RtContext.class,i); 3331 } 3332 public List<RtcContext> rtc() { 3333 return getRuleContexts(RtcContext.class); 3334 } 3335 public RtcContext rtc(int i) { 3336 return getRuleContext(RtcContext.class,i); 3337 } 3338 public List<RpContext> rp() { 3339 return getRuleContexts(RpContext.class); 3340 } 3341 public RpContext rp(int i) { 3342 return getRuleContext(RpContext.class,i); 3343 } 3344 public List<PTagStartContext> pTagStart() { 3345 return getRuleContexts(PTagStartContext.class); 3346 } 3347 public PTagStartContext pTagStart(int i) { 3348 return getRuleContext(PTagStartContext.class,i); 3349 } 3350 public List<LiTagStartContext> liTagStart() { 3351 return getRuleContexts(LiTagStartContext.class); 3352 } 3353 public LiTagStartContext liTagStart(int i) { 3354 return getRuleContext(LiTagStartContext.class,i); 3355 } 3356 public List<TdTagStartContext> tdTagStart() { 3357 return getRuleContexts(TdTagStartContext.class); 3358 } 3359 public TdTagStartContext tdTagStart(int i) { 3360 return getRuleContext(TdTagStartContext.class,i); 3361 } 3362 public List<ThTagStartContext> thTagStart() { 3363 return getRuleContexts(ThTagStartContext.class); 3364 } 3365 public ThTagStartContext thTagStart(int i) { 3366 return getRuleContext(ThTagStartContext.class,i); 3367 } 3368 public List<BodyTagStartContext> bodyTagStart() { 3369 return getRuleContexts(BodyTagStartContext.class); 3370 } 3371 public BodyTagStartContext bodyTagStart(int i) { 3372 return getRuleContext(BodyTagStartContext.class,i); 3373 } 3374 public List<ColgroupTagStartContext> colgroupTagStart() { 3375 return getRuleContexts(ColgroupTagStartContext.class); 3376 } 3377 public ColgroupTagStartContext colgroupTagStart(int i) { 3378 return getRuleContext(ColgroupTagStartContext.class,i); 3379 } 3380 public List<DdTagStartContext> ddTagStart() { 3381 return getRuleContexts(DdTagStartContext.class); 3382 } 3383 public DdTagStartContext ddTagStart(int i) { 3384 return getRuleContext(DdTagStartContext.class,i); 3385 } 3386 public List<DtTagStartContext> dtTagStart() { 3387 return getRuleContexts(DtTagStartContext.class); 3388 } 3389 public DtTagStartContext dtTagStart(int i) { 3390 return getRuleContext(DtTagStartContext.class,i); 3391 } 3392 public List<HeadTagStartContext> headTagStart() { 3393 return getRuleContexts(HeadTagStartContext.class); 3394 } 3395 public HeadTagStartContext headTagStart(int i) { 3396 return getRuleContext(HeadTagStartContext.class,i); 3397 } 3398 public List<HtmlTagStartContext> htmlTagStart() { 3399 return getRuleContexts(HtmlTagStartContext.class); 3400 } 3401 public HtmlTagStartContext htmlTagStart(int i) { 3402 return getRuleContext(HtmlTagStartContext.class,i); 3403 } 3404 public List<OptionTagStartContext> optionTagStart() { 3405 return getRuleContexts(OptionTagStartContext.class); 3406 } 3407 public OptionTagStartContext optionTagStart(int i) { 3408 return getRuleContext(OptionTagStartContext.class,i); 3409 } 3410 public List<TbodyTagStartContext> tbodyTagStart() { 3411 return getRuleContexts(TbodyTagStartContext.class); 3412 } 3413 public TbodyTagStartContext tbodyTagStart(int i) { 3414 return getRuleContext(TbodyTagStartContext.class,i); 3415 } 3416 public List<TheadTagStartContext> theadTagStart() { 3417 return getRuleContexts(TheadTagStartContext.class); 3418 } 3419 public TheadTagStartContext theadTagStart(int i) { 3420 return getRuleContext(TheadTagStartContext.class,i); 3421 } 3422 public List<TfootTagStartContext> tfootTagStart() { 3423 return getRuleContexts(TfootTagStartContext.class); 3424 } 3425 public TfootTagStartContext tfootTagStart(int i) { 3426 return getRuleContext(TfootTagStartContext.class,i); 3427 } 3428 public List<OptgroupTagStartContext> optgroupTagStart() { 3429 return getRuleContexts(OptgroupTagStartContext.class); 3430 } 3431 public OptgroupTagStartContext optgroupTagStart(int i) { 3432 return getRuleContext(OptgroupTagStartContext.class,i); 3433 } 3434 public List<RbTagStartContext> rbTagStart() { 3435 return getRuleContexts(RbTagStartContext.class); 3436 } 3437 public RbTagStartContext rbTagStart(int i) { 3438 return getRuleContext(RbTagStartContext.class,i); 3439 } 3440 public List<RtTagStartContext> rtTagStart() { 3441 return getRuleContexts(RtTagStartContext.class); 3442 } 3443 public RtTagStartContext rtTagStart(int i) { 3444 return getRuleContext(RtTagStartContext.class,i); 3445 } 3446 public List<RtcTagStartContext> rtcTagStart() { 3447 return getRuleContexts(RtcTagStartContext.class); 3448 } 3449 public RtcTagStartContext rtcTagStart(int i) { 3450 return getRuleContext(RtcTagStartContext.class,i); 3451 } 3452 public List<RpTagStartContext> rpTagStart() { 3453 return getRuleContexts(RpTagStartContext.class); 3454 } 3455 public RpTagStartContext rpTagStart(int i) { 3456 return getRuleContext(RpTagStartContext.class,i); 3457 } 3458 public List<HtmlCommentContext> htmlComment() { 3459 return getRuleContexts(HtmlCommentContext.class); 3460 } 3461 public HtmlCommentContext htmlComment(int i) { 3462 return getRuleContext(HtmlCommentContext.class,i); 3463 } 3464 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3465 public TerminalNode CDATA(int i) { 3466 return getToken(JavadocParser.CDATA, i); 3467 } 3468 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3469 public TerminalNode NEWLINE(int i) { 3470 return getToken(JavadocParser.NEWLINE, i); 3471 } 3472 public List<TextContext> text() { 3473 return getRuleContexts(TextContext.class); 3474 } 3475 public TextContext text(int i) { 3476 return getRuleContext(TextContext.class,i); 3477 } 3478 public List<JavadocInlineTagContext> javadocInlineTag() { 3479 return getRuleContexts(JavadocInlineTagContext.class); 3480 } 3481 public JavadocInlineTagContext javadocInlineTag(int i) { 3482 return getRuleContext(JavadocInlineTagContext.class,i); 3483 } 3484 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3485 public TerminalNode LEADING_ASTERISK(int i) { 3486 return getToken(JavadocParser.LEADING_ASTERISK, i); 3487 } 3488 public TrContext(ParserRuleContext parent, int invokingState) { 3489 super(parent, invokingState); 3490 } 3491 @Override public int getRuleIndex() { return RULE_tr; } 3492 } 3493 3494 public final TrContext tr() throws RecognitionException { 3495 TrContext _localctx = new TrContext(_ctx, getState()); 3496 enterRule(_localctx, 28, RULE_tr); 3497 try { 3498 int _alt; 3499 enterOuterAlt(_localctx, 1); 3500 { 3501 setState(526); 3502 trTagStart(false); 3503 setState(576); 3504 _errHandler.sync(this); 3505 _alt = getInterpreter().adaptivePredict(_input,28,_ctx); 3506 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3507 if ( _alt==1 ) { 3508 { 3509 setState(574); 3510 _errHandler.sync(this); 3511 switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) { 3512 case 1: 3513 { 3514 setState(527); 3515 htmlTag(); 3516 } 3517 break; 3518 case 2: 3519 { 3520 setState(528); 3521 singletonElement(); 3522 } 3523 break; 3524 case 3: 3525 { 3526 setState(529); 3527 paragraph(); 3528 } 3529 break; 3530 case 4: 3531 { 3532 setState(530); 3533 li(); 3534 } 3535 break; 3536 case 5: 3537 { 3538 setState(531); 3539 td(); 3540 } 3541 break; 3542 case 6: 3543 { 3544 setState(532); 3545 th(); 3546 } 3547 break; 3548 case 7: 3549 { 3550 setState(533); 3551 body(); 3552 } 3553 break; 3554 case 8: 3555 { 3556 setState(534); 3557 colgroup(); 3558 } 3559 break; 3560 case 9: 3561 { 3562 setState(535); 3563 dd(); 3564 } 3565 break; 3566 case 10: 3567 { 3568 setState(536); 3569 dt(); 3570 } 3571 break; 3572 case 11: 3573 { 3574 setState(537); 3575 head(); 3576 } 3577 break; 3578 case 12: 3579 { 3580 setState(538); 3581 html(); 3582 } 3583 break; 3584 case 13: 3585 { 3586 setState(539); 3587 option(); 3588 } 3589 break; 3590 case 14: 3591 { 3592 setState(540); 3593 tbody(); 3594 } 3595 break; 3596 case 15: 3597 { 3598 setState(541); 3599 thead(); 3600 } 3601 break; 3602 case 16: 3603 { 3604 setState(542); 3605 tfoot(); 3606 } 3607 break; 3608 case 17: 3609 { 3610 setState(543); 3611 optgroup(); 3612 } 3613 break; 3614 case 18: 3615 { 3616 setState(544); 3617 rb(); 3618 } 3619 break; 3620 case 19: 3621 { 3622 setState(545); 3623 rt(); 3624 } 3625 break; 3626 case 20: 3627 { 3628 setState(546); 3629 rtc(); 3630 } 3631 break; 3632 case 21: 3633 { 3634 setState(547); 3635 rp(); 3636 } 3637 break; 3638 case 22: 3639 { 3640 setState(548); 3641 pTagStart(true); 3642 } 3643 break; 3644 case 23: 3645 { 3646 setState(549); 3647 liTagStart(true); 3648 } 3649 break; 3650 case 24: 3651 { 3652 setState(550); 3653 tdTagStart(true); 3654 } 3655 break; 3656 case 25: 3657 { 3658 setState(551); 3659 thTagStart(true); 3660 } 3661 break; 3662 case 26: 3663 { 3664 setState(552); 3665 bodyTagStart(true); 3666 } 3667 break; 3668 case 27: 3669 { 3670 setState(553); 3671 colgroupTagStart(true); 3672 } 3673 break; 3674 case 28: 3675 { 3676 setState(554); 3677 ddTagStart(true); 3678 } 3679 break; 3680 case 29: 3681 { 3682 setState(555); 3683 dtTagStart(true); 3684 } 3685 break; 3686 case 30: 3687 { 3688 setState(556); 3689 headTagStart(true); 3690 } 3691 break; 3692 case 31: 3693 { 3694 setState(557); 3695 htmlTagStart(true); 3696 } 3697 break; 3698 case 32: 3699 { 3700 setState(558); 3701 optionTagStart(true); 3702 } 3703 break; 3704 case 33: 3705 { 3706 setState(559); 3707 tbodyTagStart(true); 3708 } 3709 break; 3710 case 34: 3711 { 3712 setState(560); 3713 theadTagStart(true); 3714 } 3715 break; 3716 case 35: 3717 { 3718 setState(561); 3719 tfootTagStart(true); 3720 } 3721 break; 3722 case 36: 3723 { 3724 setState(562); 3725 optgroupTagStart(true); 3726 } 3727 break; 3728 case 37: 3729 { 3730 setState(563); 3731 rbTagStart(true); 3732 } 3733 break; 3734 case 38: 3735 { 3736 setState(564); 3737 rtTagStart(true); 3738 } 3739 break; 3740 case 39: 3741 { 3742 setState(565); 3743 rtcTagStart(true); 3744 } 3745 break; 3746 case 40: 3747 { 3748 setState(566); 3749 rpTagStart(true); 3750 } 3751 break; 3752 case 41: 3753 { 3754 { 3755 setState(567); 3756 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 3757 setState(568); 3758 match(LEADING_ASTERISK); 3759 } 3760 } 3761 break; 3762 case 42: 3763 { 3764 setState(569); 3765 htmlComment(); 3766 } 3767 break; 3768 case 43: 3769 { 3770 setState(570); 3771 match(CDATA); 3772 } 3773 break; 3774 case 44: 3775 { 3776 setState(571); 3777 match(NEWLINE); 3778 } 3779 break; 3780 case 45: 3781 { 3782 setState(572); 3783 text(); 3784 } 3785 break; 3786 case 46: 3787 { 3788 setState(573); 3789 javadocInlineTag(); 3790 } 3791 break; 3792 } 3793 } 3794 } 3795 setState(578); 3796 _errHandler.sync(this); 3797 _alt = getInterpreter().adaptivePredict(_input,28,_ctx); 3798 } 3799 setState(579); 3800 trTagEnd(); 3801 } 3802 } 3803 catch (RecognitionException re) { 3804 _localctx.exception = re; 3805 _errHandler.reportError(this, re); 3806 _errHandler.recover(this, re); 3807 } 3808 finally { 3809 exitRule(); 3810 } 3811 return _localctx; 3812 } 3813 3814 public static class TdTagStartContext extends ParserRuleContext { 3815 public boolean isNonTight; 3816 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 3817 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3818 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 3819 public List<AttributeContext> attribute() { 3820 return getRuleContexts(AttributeContext.class); 3821 } 3822 public AttributeContext attribute(int i) { 3823 return getRuleContext(AttributeContext.class,i); 3824 } 3825 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3826 public TerminalNode NEWLINE(int i) { 3827 return getToken(JavadocParser.NEWLINE, i); 3828 } 3829 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3830 public TerminalNode LEADING_ASTERISK(int i) { 3831 return getToken(JavadocParser.LEADING_ASTERISK, i); 3832 } 3833 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3834 public TerminalNode WS(int i) { 3835 return getToken(JavadocParser.WS, i); 3836 } 3837 public TdTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 3838 public TdTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 3839 super(parent, invokingState); 3840 this.isNonTight = isNonTight; 3841 } 3842 @Override public int getRuleIndex() { return RULE_tdTagStart; } 3843 } 3844 3845 public final TdTagStartContext tdTagStart(boolean isNonTight) throws RecognitionException { 3846 TdTagStartContext _localctx = new TdTagStartContext(_ctx, getState(), isNonTight); 3847 enterRule(_localctx, 30, RULE_tdTagStart); 3848 int _la; 3849 try { 3850 enterOuterAlt(_localctx, 1); 3851 { 3852 setState(581); 3853 match(START); 3854 setState(582); 3855 match(TD_HTML_TAG_NAME); 3856 setState(589); 3857 _errHandler.sync(this); 3858 _la = _input.LA(1); 3859 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 3860 { 3861 setState(587); 3862 _errHandler.sync(this); 3863 switch (_input.LA(1)) { 3864 case HTML_TAG_NAME: 3865 { 3866 setState(583); 3867 attribute(); 3868 } 3869 break; 3870 case NEWLINE: 3871 { 3872 setState(584); 3873 match(NEWLINE); 3874 } 3875 break; 3876 case LEADING_ASTERISK: 3877 { 3878 setState(585); 3879 match(LEADING_ASTERISK); 3880 } 3881 break; 3882 case WS: 3883 { 3884 setState(586); 3885 match(WS); 3886 } 3887 break; 3888 default: 3889 throw new NoViableAltException(this); 3890 } 3891 } 3892 setState(591); 3893 _errHandler.sync(this); 3894 _la = _input.LA(1); 3895 } 3896 setState(592); 3897 match(END); 3898 } 3899 _ctx.stop = _input.LT(-1); 3900 3901 if (isNonTight && nonTightTagStartContext == null) { 3902 nonTightTagStartContext = _localctx; 3903 } 3904 3905 } 3906 catch (RecognitionException re) { 3907 _localctx.exception = re; 3908 _errHandler.reportError(this, re); 3909 _errHandler.recover(this, re); 3910 } 3911 finally { 3912 exitRule(); 3913 } 3914 return _localctx; 3915 } 3916 3917 public static class TdTagEndContext extends ParserRuleContext { 3918 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 3919 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 3920 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3921 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 3922 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3923 public TerminalNode NEWLINE(int i) { 3924 return getToken(JavadocParser.NEWLINE, i); 3925 } 3926 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3927 public TerminalNode LEADING_ASTERISK(int i) { 3928 return getToken(JavadocParser.LEADING_ASTERISK, i); 3929 } 3930 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3931 public TerminalNode WS(int i) { 3932 return getToken(JavadocParser.WS, i); 3933 } 3934 public TdTagEndContext(ParserRuleContext parent, int invokingState) { 3935 super(parent, invokingState); 3936 } 3937 @Override public int getRuleIndex() { return RULE_tdTagEnd; } 3938 } 3939 3940 public final TdTagEndContext tdTagEnd() throws RecognitionException { 3941 TdTagEndContext _localctx = new TdTagEndContext(_ctx, getState()); 3942 enterRule(_localctx, 32, RULE_tdTagEnd); 3943 int _la; 3944 try { 3945 enterOuterAlt(_localctx, 1); 3946 { 3947 setState(594); 3948 match(START); 3949 setState(595); 3950 match(SLASH); 3951 setState(596); 3952 match(TD_HTML_TAG_NAME); 3953 setState(600); 3954 _errHandler.sync(this); 3955 _la = _input.LA(1); 3956 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 3957 { 3958 { 3959 setState(597); 3960 _la = _input.LA(1); 3961 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 3962 _errHandler.recoverInline(this); 3963 } 3964 else { 3965 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3966 _errHandler.reportMatch(this); 3967 consume(); 3968 } 3969 } 3970 } 3971 setState(602); 3972 _errHandler.sync(this); 3973 _la = _input.LA(1); 3974 } 3975 setState(603); 3976 match(END); 3977 } 3978 } 3979 catch (RecognitionException re) { 3980 _localctx.exception = re; 3981 _errHandler.reportError(this, re); 3982 _errHandler.recover(this, re); 3983 } 3984 finally { 3985 exitRule(); 3986 } 3987 return _localctx; 3988 } 3989 3990 public static class TdContext extends ParserRuleContext { 3991 public List<TdTagStartContext> tdTagStart() { 3992 return getRuleContexts(TdTagStartContext.class); 3993 } 3994 public TdTagStartContext tdTagStart(int i) { 3995 return getRuleContext(TdTagStartContext.class,i); 3996 } 3997 public TdTagEndContext tdTagEnd() { 3998 return getRuleContext(TdTagEndContext.class,0); 3999 } 4000 public List<HtmlTagContext> htmlTag() { 4001 return getRuleContexts(HtmlTagContext.class); 4002 } 4003 public HtmlTagContext htmlTag(int i) { 4004 return getRuleContext(HtmlTagContext.class,i); 4005 } 4006 public List<SingletonElementContext> singletonElement() { 4007 return getRuleContexts(SingletonElementContext.class); 4008 } 4009 public SingletonElementContext singletonElement(int i) { 4010 return getRuleContext(SingletonElementContext.class,i); 4011 } 4012 public List<ParagraphContext> paragraph() { 4013 return getRuleContexts(ParagraphContext.class); 4014 } 4015 public ParagraphContext paragraph(int i) { 4016 return getRuleContext(ParagraphContext.class,i); 4017 } 4018 public List<LiContext> li() { 4019 return getRuleContexts(LiContext.class); 4020 } 4021 public LiContext li(int i) { 4022 return getRuleContext(LiContext.class,i); 4023 } 4024 public List<TrContext> tr() { 4025 return getRuleContexts(TrContext.class); 4026 } 4027 public TrContext tr(int i) { 4028 return getRuleContext(TrContext.class,i); 4029 } 4030 public List<ThContext> th() { 4031 return getRuleContexts(ThContext.class); 4032 } 4033 public ThContext th(int i) { 4034 return getRuleContext(ThContext.class,i); 4035 } 4036 public List<BodyContext> body() { 4037 return getRuleContexts(BodyContext.class); 4038 } 4039 public BodyContext body(int i) { 4040 return getRuleContext(BodyContext.class,i); 4041 } 4042 public List<ColgroupContext> colgroup() { 4043 return getRuleContexts(ColgroupContext.class); 4044 } 4045 public ColgroupContext colgroup(int i) { 4046 return getRuleContext(ColgroupContext.class,i); 4047 } 4048 public List<DdContext> dd() { 4049 return getRuleContexts(DdContext.class); 4050 } 4051 public DdContext dd(int i) { 4052 return getRuleContext(DdContext.class,i); 4053 } 4054 public List<DtContext> dt() { 4055 return getRuleContexts(DtContext.class); 4056 } 4057 public DtContext dt(int i) { 4058 return getRuleContext(DtContext.class,i); 4059 } 4060 public List<HeadContext> head() { 4061 return getRuleContexts(HeadContext.class); 4062 } 4063 public HeadContext head(int i) { 4064 return getRuleContext(HeadContext.class,i); 4065 } 4066 public List<HtmlContext> html() { 4067 return getRuleContexts(HtmlContext.class); 4068 } 4069 public HtmlContext html(int i) { 4070 return getRuleContext(HtmlContext.class,i); 4071 } 4072 public List<OptionContext> option() { 4073 return getRuleContexts(OptionContext.class); 4074 } 4075 public OptionContext option(int i) { 4076 return getRuleContext(OptionContext.class,i); 4077 } 4078 public List<TbodyContext> tbody() { 4079 return getRuleContexts(TbodyContext.class); 4080 } 4081 public TbodyContext tbody(int i) { 4082 return getRuleContext(TbodyContext.class,i); 4083 } 4084 public List<TheadContext> thead() { 4085 return getRuleContexts(TheadContext.class); 4086 } 4087 public TheadContext thead(int i) { 4088 return getRuleContext(TheadContext.class,i); 4089 } 4090 public List<TfootContext> tfoot() { 4091 return getRuleContexts(TfootContext.class); 4092 } 4093 public TfootContext tfoot(int i) { 4094 return getRuleContext(TfootContext.class,i); 4095 } 4096 public List<OptgroupContext> optgroup() { 4097 return getRuleContexts(OptgroupContext.class); 4098 } 4099 public OptgroupContext optgroup(int i) { 4100 return getRuleContext(OptgroupContext.class,i); 4101 } 4102 public List<RbContext> rb() { 4103 return getRuleContexts(RbContext.class); 4104 } 4105 public RbContext rb(int i) { 4106 return getRuleContext(RbContext.class,i); 4107 } 4108 public List<RtContext> rt() { 4109 return getRuleContexts(RtContext.class); 4110 } 4111 public RtContext rt(int i) { 4112 return getRuleContext(RtContext.class,i); 4113 } 4114 public List<RtcContext> rtc() { 4115 return getRuleContexts(RtcContext.class); 4116 } 4117 public RtcContext rtc(int i) { 4118 return getRuleContext(RtcContext.class,i); 4119 } 4120 public List<RpContext> rp() { 4121 return getRuleContexts(RpContext.class); 4122 } 4123 public RpContext rp(int i) { 4124 return getRuleContext(RpContext.class,i); 4125 } 4126 public List<PTagStartContext> pTagStart() { 4127 return getRuleContexts(PTagStartContext.class); 4128 } 4129 public PTagStartContext pTagStart(int i) { 4130 return getRuleContext(PTagStartContext.class,i); 4131 } 4132 public List<LiTagStartContext> liTagStart() { 4133 return getRuleContexts(LiTagStartContext.class); 4134 } 4135 public LiTagStartContext liTagStart(int i) { 4136 return getRuleContext(LiTagStartContext.class,i); 4137 } 4138 public List<ThTagStartContext> thTagStart() { 4139 return getRuleContexts(ThTagStartContext.class); 4140 } 4141 public ThTagStartContext thTagStart(int i) { 4142 return getRuleContext(ThTagStartContext.class,i); 4143 } 4144 public List<BodyTagStartContext> bodyTagStart() { 4145 return getRuleContexts(BodyTagStartContext.class); 4146 } 4147 public BodyTagStartContext bodyTagStart(int i) { 4148 return getRuleContext(BodyTagStartContext.class,i); 4149 } 4150 public List<ColgroupTagStartContext> colgroupTagStart() { 4151 return getRuleContexts(ColgroupTagStartContext.class); 4152 } 4153 public ColgroupTagStartContext colgroupTagStart(int i) { 4154 return getRuleContext(ColgroupTagStartContext.class,i); 4155 } 4156 public List<DdTagStartContext> ddTagStart() { 4157 return getRuleContexts(DdTagStartContext.class); 4158 } 4159 public DdTagStartContext ddTagStart(int i) { 4160 return getRuleContext(DdTagStartContext.class,i); 4161 } 4162 public List<DtTagStartContext> dtTagStart() { 4163 return getRuleContexts(DtTagStartContext.class); 4164 } 4165 public DtTagStartContext dtTagStart(int i) { 4166 return getRuleContext(DtTagStartContext.class,i); 4167 } 4168 public List<HeadTagStartContext> headTagStart() { 4169 return getRuleContexts(HeadTagStartContext.class); 4170 } 4171 public HeadTagStartContext headTagStart(int i) { 4172 return getRuleContext(HeadTagStartContext.class,i); 4173 } 4174 public List<HtmlTagStartContext> htmlTagStart() { 4175 return getRuleContexts(HtmlTagStartContext.class); 4176 } 4177 public HtmlTagStartContext htmlTagStart(int i) { 4178 return getRuleContext(HtmlTagStartContext.class,i); 4179 } 4180 public List<OptionTagStartContext> optionTagStart() { 4181 return getRuleContexts(OptionTagStartContext.class); 4182 } 4183 public OptionTagStartContext optionTagStart(int i) { 4184 return getRuleContext(OptionTagStartContext.class,i); 4185 } 4186 public List<TbodyTagStartContext> tbodyTagStart() { 4187 return getRuleContexts(TbodyTagStartContext.class); 4188 } 4189 public TbodyTagStartContext tbodyTagStart(int i) { 4190 return getRuleContext(TbodyTagStartContext.class,i); 4191 } 4192 public List<TheadTagStartContext> theadTagStart() { 4193 return getRuleContexts(TheadTagStartContext.class); 4194 } 4195 public TheadTagStartContext theadTagStart(int i) { 4196 return getRuleContext(TheadTagStartContext.class,i); 4197 } 4198 public List<TfootTagStartContext> tfootTagStart() { 4199 return getRuleContexts(TfootTagStartContext.class); 4200 } 4201 public TfootTagStartContext tfootTagStart(int i) { 4202 return getRuleContext(TfootTagStartContext.class,i); 4203 } 4204 public List<OptgroupTagStartContext> optgroupTagStart() { 4205 return getRuleContexts(OptgroupTagStartContext.class); 4206 } 4207 public OptgroupTagStartContext optgroupTagStart(int i) { 4208 return getRuleContext(OptgroupTagStartContext.class,i); 4209 } 4210 public List<RbTagStartContext> rbTagStart() { 4211 return getRuleContexts(RbTagStartContext.class); 4212 } 4213 public RbTagStartContext rbTagStart(int i) { 4214 return getRuleContext(RbTagStartContext.class,i); 4215 } 4216 public List<RtTagStartContext> rtTagStart() { 4217 return getRuleContexts(RtTagStartContext.class); 4218 } 4219 public RtTagStartContext rtTagStart(int i) { 4220 return getRuleContext(RtTagStartContext.class,i); 4221 } 4222 public List<RtcTagStartContext> rtcTagStart() { 4223 return getRuleContexts(RtcTagStartContext.class); 4224 } 4225 public RtcTagStartContext rtcTagStart(int i) { 4226 return getRuleContext(RtcTagStartContext.class,i); 4227 } 4228 public List<RpTagStartContext> rpTagStart() { 4229 return getRuleContexts(RpTagStartContext.class); 4230 } 4231 public RpTagStartContext rpTagStart(int i) { 4232 return getRuleContext(RpTagStartContext.class,i); 4233 } 4234 public List<HtmlCommentContext> htmlComment() { 4235 return getRuleContexts(HtmlCommentContext.class); 4236 } 4237 public HtmlCommentContext htmlComment(int i) { 4238 return getRuleContext(HtmlCommentContext.class,i); 4239 } 4240 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 4241 public TerminalNode CDATA(int i) { 4242 return getToken(JavadocParser.CDATA, i); 4243 } 4244 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4245 public TerminalNode NEWLINE(int i) { 4246 return getToken(JavadocParser.NEWLINE, i); 4247 } 4248 public List<TextContext> text() { 4249 return getRuleContexts(TextContext.class); 4250 } 4251 public TextContext text(int i) { 4252 return getRuleContext(TextContext.class,i); 4253 } 4254 public List<JavadocInlineTagContext> javadocInlineTag() { 4255 return getRuleContexts(JavadocInlineTagContext.class); 4256 } 4257 public JavadocInlineTagContext javadocInlineTag(int i) { 4258 return getRuleContext(JavadocInlineTagContext.class,i); 4259 } 4260 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4261 public TerminalNode LEADING_ASTERISK(int i) { 4262 return getToken(JavadocParser.LEADING_ASTERISK, i); 4263 } 4264 public TdContext(ParserRuleContext parent, int invokingState) { 4265 super(parent, invokingState); 4266 } 4267 @Override public int getRuleIndex() { return RULE_td; } 4268 } 4269 4270 public final TdContext td() throws RecognitionException { 4271 TdContext _localctx = new TdContext(_ctx, getState()); 4272 enterRule(_localctx, 34, RULE_td); 4273 try { 4274 int _alt; 4275 enterOuterAlt(_localctx, 1); 4276 { 4277 setState(605); 4278 tdTagStart(false); 4279 setState(655); 4280 _errHandler.sync(this); 4281 _alt = getInterpreter().adaptivePredict(_input,33,_ctx); 4282 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 4283 if ( _alt==1 ) { 4284 { 4285 setState(653); 4286 _errHandler.sync(this); 4287 switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) { 4288 case 1: 4289 { 4290 setState(606); 4291 htmlTag(); 4292 } 4293 break; 4294 case 2: 4295 { 4296 setState(607); 4297 singletonElement(); 4298 } 4299 break; 4300 case 3: 4301 { 4302 setState(608); 4303 paragraph(); 4304 } 4305 break; 4306 case 4: 4307 { 4308 setState(609); 4309 li(); 4310 } 4311 break; 4312 case 5: 4313 { 4314 setState(610); 4315 tr(); 4316 } 4317 break; 4318 case 6: 4319 { 4320 setState(611); 4321 th(); 4322 } 4323 break; 4324 case 7: 4325 { 4326 setState(612); 4327 body(); 4328 } 4329 break; 4330 case 8: 4331 { 4332 setState(613); 4333 colgroup(); 4334 } 4335 break; 4336 case 9: 4337 { 4338 setState(614); 4339 dd(); 4340 } 4341 break; 4342 case 10: 4343 { 4344 setState(615); 4345 dt(); 4346 } 4347 break; 4348 case 11: 4349 { 4350 setState(616); 4351 head(); 4352 } 4353 break; 4354 case 12: 4355 { 4356 setState(617); 4357 html(); 4358 } 4359 break; 4360 case 13: 4361 { 4362 setState(618); 4363 option(); 4364 } 4365 break; 4366 case 14: 4367 { 4368 setState(619); 4369 tbody(); 4370 } 4371 break; 4372 case 15: 4373 { 4374 setState(620); 4375 thead(); 4376 } 4377 break; 4378 case 16: 4379 { 4380 setState(621); 4381 tfoot(); 4382 } 4383 break; 4384 case 17: 4385 { 4386 setState(622); 4387 optgroup(); 4388 } 4389 break; 4390 case 18: 4391 { 4392 setState(623); 4393 rb(); 4394 } 4395 break; 4396 case 19: 4397 { 4398 setState(624); 4399 rt(); 4400 } 4401 break; 4402 case 20: 4403 { 4404 setState(625); 4405 rtc(); 4406 } 4407 break; 4408 case 21: 4409 { 4410 setState(626); 4411 rp(); 4412 } 4413 break; 4414 case 22: 4415 { 4416 setState(627); 4417 pTagStart(true); 4418 } 4419 break; 4420 case 23: 4421 { 4422 setState(628); 4423 liTagStart(true); 4424 } 4425 break; 4426 case 24: 4427 { 4428 setState(629); 4429 tdTagStart(true); 4430 } 4431 break; 4432 case 25: 4433 { 4434 setState(630); 4435 thTagStart(true); 4436 } 4437 break; 4438 case 26: 4439 { 4440 setState(631); 4441 bodyTagStart(true); 4442 } 4443 break; 4444 case 27: 4445 { 4446 setState(632); 4447 colgroupTagStart(true); 4448 } 4449 break; 4450 case 28: 4451 { 4452 setState(633); 4453 ddTagStart(true); 4454 } 4455 break; 4456 case 29: 4457 { 4458 setState(634); 4459 dtTagStart(true); 4460 } 4461 break; 4462 case 30: 4463 { 4464 setState(635); 4465 headTagStart(true); 4466 } 4467 break; 4468 case 31: 4469 { 4470 setState(636); 4471 htmlTagStart(true); 4472 } 4473 break; 4474 case 32: 4475 { 4476 setState(637); 4477 optionTagStart(true); 4478 } 4479 break; 4480 case 33: 4481 { 4482 setState(638); 4483 tbodyTagStart(true); 4484 } 4485 break; 4486 case 34: 4487 { 4488 setState(639); 4489 theadTagStart(true); 4490 } 4491 break; 4492 case 35: 4493 { 4494 setState(640); 4495 tfootTagStart(true); 4496 } 4497 break; 4498 case 36: 4499 { 4500 setState(641); 4501 optgroupTagStart(true); 4502 } 4503 break; 4504 case 37: 4505 { 4506 setState(642); 4507 rbTagStart(true); 4508 } 4509 break; 4510 case 38: 4511 { 4512 setState(643); 4513 rtTagStart(true); 4514 } 4515 break; 4516 case 39: 4517 { 4518 setState(644); 4519 rtcTagStart(true); 4520 } 4521 break; 4522 case 40: 4523 { 4524 setState(645); 4525 rpTagStart(true); 4526 } 4527 break; 4528 case 41: 4529 { 4530 { 4531 setState(646); 4532 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4533 setState(647); 4534 match(LEADING_ASTERISK); 4535 } 4536 } 4537 break; 4538 case 42: 4539 { 4540 setState(648); 4541 htmlComment(); 4542 } 4543 break; 4544 case 43: 4545 { 4546 setState(649); 4547 match(CDATA); 4548 } 4549 break; 4550 case 44: 4551 { 4552 setState(650); 4553 match(NEWLINE); 4554 } 4555 break; 4556 case 45: 4557 { 4558 setState(651); 4559 text(); 4560 } 4561 break; 4562 case 46: 4563 { 4564 setState(652); 4565 javadocInlineTag(); 4566 } 4567 break; 4568 } 4569 } 4570 } 4571 setState(657); 4572 _errHandler.sync(this); 4573 _alt = getInterpreter().adaptivePredict(_input,33,_ctx); 4574 } 4575 setState(658); 4576 tdTagEnd(); 4577 } 4578 } 4579 catch (RecognitionException re) { 4580 _localctx.exception = re; 4581 _errHandler.reportError(this, re); 4582 _errHandler.recover(this, re); 4583 } 4584 finally { 4585 exitRule(); 4586 } 4587 return _localctx; 4588 } 4589 4590 public static class ThTagStartContext extends ParserRuleContext { 4591 public boolean isNonTight; 4592 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 4593 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4594 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 4595 public List<AttributeContext> attribute() { 4596 return getRuleContexts(AttributeContext.class); 4597 } 4598 public AttributeContext attribute(int i) { 4599 return getRuleContext(AttributeContext.class,i); 4600 } 4601 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4602 public TerminalNode NEWLINE(int i) { 4603 return getToken(JavadocParser.NEWLINE, i); 4604 } 4605 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4606 public TerminalNode LEADING_ASTERISK(int i) { 4607 return getToken(JavadocParser.LEADING_ASTERISK, i); 4608 } 4609 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4610 public TerminalNode WS(int i) { 4611 return getToken(JavadocParser.WS, i); 4612 } 4613 public ThTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 4614 public ThTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 4615 super(parent, invokingState); 4616 this.isNonTight = isNonTight; 4617 } 4618 @Override public int getRuleIndex() { return RULE_thTagStart; } 4619 } 4620 4621 public final ThTagStartContext thTagStart(boolean isNonTight) throws RecognitionException { 4622 ThTagStartContext _localctx = new ThTagStartContext(_ctx, getState(), isNonTight); 4623 enterRule(_localctx, 36, RULE_thTagStart); 4624 int _la; 4625 try { 4626 enterOuterAlt(_localctx, 1); 4627 { 4628 setState(660); 4629 match(START); 4630 setState(661); 4631 match(TH_HTML_TAG_NAME); 4632 setState(668); 4633 _errHandler.sync(this); 4634 _la = _input.LA(1); 4635 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4636 { 4637 setState(666); 4638 _errHandler.sync(this); 4639 switch (_input.LA(1)) { 4640 case HTML_TAG_NAME: 4641 { 4642 setState(662); 4643 attribute(); 4644 } 4645 break; 4646 case NEWLINE: 4647 { 4648 setState(663); 4649 match(NEWLINE); 4650 } 4651 break; 4652 case LEADING_ASTERISK: 4653 { 4654 setState(664); 4655 match(LEADING_ASTERISK); 4656 } 4657 break; 4658 case WS: 4659 { 4660 setState(665); 4661 match(WS); 4662 } 4663 break; 4664 default: 4665 throw new NoViableAltException(this); 4666 } 4667 } 4668 setState(670); 4669 _errHandler.sync(this); 4670 _la = _input.LA(1); 4671 } 4672 setState(671); 4673 match(END); 4674 } 4675 _ctx.stop = _input.LT(-1); 4676 4677 if (isNonTight && nonTightTagStartContext == null) { 4678 nonTightTagStartContext = _localctx; 4679 } 4680 4681 } 4682 catch (RecognitionException re) { 4683 _localctx.exception = re; 4684 _errHandler.reportError(this, re); 4685 _errHandler.recover(this, re); 4686 } 4687 finally { 4688 exitRule(); 4689 } 4690 return _localctx; 4691 } 4692 4693 public static class ThTagEndContext extends ParserRuleContext { 4694 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 4695 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4696 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4697 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 4698 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4699 public TerminalNode NEWLINE(int i) { 4700 return getToken(JavadocParser.NEWLINE, i); 4701 } 4702 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4703 public TerminalNode LEADING_ASTERISK(int i) { 4704 return getToken(JavadocParser.LEADING_ASTERISK, i); 4705 } 4706 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4707 public TerminalNode WS(int i) { 4708 return getToken(JavadocParser.WS, i); 4709 } 4710 public ThTagEndContext(ParserRuleContext parent, int invokingState) { 4711 super(parent, invokingState); 4712 } 4713 @Override public int getRuleIndex() { return RULE_thTagEnd; } 4714 } 4715 4716 public final ThTagEndContext thTagEnd() throws RecognitionException { 4717 ThTagEndContext _localctx = new ThTagEndContext(_ctx, getState()); 4718 enterRule(_localctx, 38, RULE_thTagEnd); 4719 int _la; 4720 try { 4721 enterOuterAlt(_localctx, 1); 4722 { 4723 setState(673); 4724 match(START); 4725 setState(674); 4726 match(SLASH); 4727 setState(675); 4728 match(TH_HTML_TAG_NAME); 4729 setState(679); 4730 _errHandler.sync(this); 4731 _la = _input.LA(1); 4732 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 4733 { 4734 { 4735 setState(676); 4736 _la = _input.LA(1); 4737 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 4738 _errHandler.recoverInline(this); 4739 } 4740 else { 4741 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 4742 _errHandler.reportMatch(this); 4743 consume(); 4744 } 4745 } 4746 } 4747 setState(681); 4748 _errHandler.sync(this); 4749 _la = _input.LA(1); 4750 } 4751 setState(682); 4752 match(END); 4753 } 4754 } 4755 catch (RecognitionException re) { 4756 _localctx.exception = re; 4757 _errHandler.reportError(this, re); 4758 _errHandler.recover(this, re); 4759 } 4760 finally { 4761 exitRule(); 4762 } 4763 return _localctx; 4764 } 4765 4766 public static class ThContext extends ParserRuleContext { 4767 public ThTagStartContext thTagStart() { 4768 return getRuleContext(ThTagStartContext.class,0); 4769 } 4770 public ThTagEndContext thTagEnd() { 4771 return getRuleContext(ThTagEndContext.class,0); 4772 } 4773 public List<HtmlTagContext> htmlTag() { 4774 return getRuleContexts(HtmlTagContext.class); 4775 } 4776 public HtmlTagContext htmlTag(int i) { 4777 return getRuleContext(HtmlTagContext.class,i); 4778 } 4779 public List<SingletonElementContext> singletonElement() { 4780 return getRuleContexts(SingletonElementContext.class); 4781 } 4782 public SingletonElementContext singletonElement(int i) { 4783 return getRuleContext(SingletonElementContext.class,i); 4784 } 4785 public List<ParagraphContext> paragraph() { 4786 return getRuleContexts(ParagraphContext.class); 4787 } 4788 public ParagraphContext paragraph(int i) { 4789 return getRuleContext(ParagraphContext.class,i); 4790 } 4791 public List<LiContext> li() { 4792 return getRuleContexts(LiContext.class); 4793 } 4794 public LiContext li(int i) { 4795 return getRuleContext(LiContext.class,i); 4796 } 4797 public List<TrContext> tr() { 4798 return getRuleContexts(TrContext.class); 4799 } 4800 public TrContext tr(int i) { 4801 return getRuleContext(TrContext.class,i); 4802 } 4803 public List<TdContext> td() { 4804 return getRuleContexts(TdContext.class); 4805 } 4806 public TdContext td(int i) { 4807 return getRuleContext(TdContext.class,i); 4808 } 4809 public List<BodyContext> body() { 4810 return getRuleContexts(BodyContext.class); 4811 } 4812 public BodyContext body(int i) { 4813 return getRuleContext(BodyContext.class,i); 4814 } 4815 public List<ColgroupContext> colgroup() { 4816 return getRuleContexts(ColgroupContext.class); 4817 } 4818 public ColgroupContext colgroup(int i) { 4819 return getRuleContext(ColgroupContext.class,i); 4820 } 4821 public List<DdContext> dd() { 4822 return getRuleContexts(DdContext.class); 4823 } 4824 public DdContext dd(int i) { 4825 return getRuleContext(DdContext.class,i); 4826 } 4827 public List<DtContext> dt() { 4828 return getRuleContexts(DtContext.class); 4829 } 4830 public DtContext dt(int i) { 4831 return getRuleContext(DtContext.class,i); 4832 } 4833 public List<HeadContext> head() { 4834 return getRuleContexts(HeadContext.class); 4835 } 4836 public HeadContext head(int i) { 4837 return getRuleContext(HeadContext.class,i); 4838 } 4839 public List<HtmlContext> html() { 4840 return getRuleContexts(HtmlContext.class); 4841 } 4842 public HtmlContext html(int i) { 4843 return getRuleContext(HtmlContext.class,i); 4844 } 4845 public List<OptionContext> option() { 4846 return getRuleContexts(OptionContext.class); 4847 } 4848 public OptionContext option(int i) { 4849 return getRuleContext(OptionContext.class,i); 4850 } 4851 public List<TbodyContext> tbody() { 4852 return getRuleContexts(TbodyContext.class); 4853 } 4854 public TbodyContext tbody(int i) { 4855 return getRuleContext(TbodyContext.class,i); 4856 } 4857 public List<TheadContext> thead() { 4858 return getRuleContexts(TheadContext.class); 4859 } 4860 public TheadContext thead(int i) { 4861 return getRuleContext(TheadContext.class,i); 4862 } 4863 public List<TfootContext> tfoot() { 4864 return getRuleContexts(TfootContext.class); 4865 } 4866 public TfootContext tfoot(int i) { 4867 return getRuleContext(TfootContext.class,i); 4868 } 4869 public List<OptgroupContext> optgroup() { 4870 return getRuleContexts(OptgroupContext.class); 4871 } 4872 public OptgroupContext optgroup(int i) { 4873 return getRuleContext(OptgroupContext.class,i); 4874 } 4875 public List<RbContext> rb() { 4876 return getRuleContexts(RbContext.class); 4877 } 4878 public RbContext rb(int i) { 4879 return getRuleContext(RbContext.class,i); 4880 } 4881 public List<RtContext> rt() { 4882 return getRuleContexts(RtContext.class); 4883 } 4884 public RtContext rt(int i) { 4885 return getRuleContext(RtContext.class,i); 4886 } 4887 public List<RtcContext> rtc() { 4888 return getRuleContexts(RtcContext.class); 4889 } 4890 public RtcContext rtc(int i) { 4891 return getRuleContext(RtcContext.class,i); 4892 } 4893 public List<RpContext> rp() { 4894 return getRuleContexts(RpContext.class); 4895 } 4896 public RpContext rp(int i) { 4897 return getRuleContext(RpContext.class,i); 4898 } 4899 public List<PTagStartContext> pTagStart() { 4900 return getRuleContexts(PTagStartContext.class); 4901 } 4902 public PTagStartContext pTagStart(int i) { 4903 return getRuleContext(PTagStartContext.class,i); 4904 } 4905 public List<LiTagStartContext> liTagStart() { 4906 return getRuleContexts(LiTagStartContext.class); 4907 } 4908 public LiTagStartContext liTagStart(int i) { 4909 return getRuleContext(LiTagStartContext.class,i); 4910 } 4911 public List<TrTagStartContext> trTagStart() { 4912 return getRuleContexts(TrTagStartContext.class); 4913 } 4914 public TrTagStartContext trTagStart(int i) { 4915 return getRuleContext(TrTagStartContext.class,i); 4916 } 4917 public List<TdTagStartContext> tdTagStart() { 4918 return getRuleContexts(TdTagStartContext.class); 4919 } 4920 public TdTagStartContext tdTagStart(int i) { 4921 return getRuleContext(TdTagStartContext.class,i); 4922 } 4923 public List<BodyTagStartContext> bodyTagStart() { 4924 return getRuleContexts(BodyTagStartContext.class); 4925 } 4926 public BodyTagStartContext bodyTagStart(int i) { 4927 return getRuleContext(BodyTagStartContext.class,i); 4928 } 4929 public List<ColgroupTagStartContext> colgroupTagStart() { 4930 return getRuleContexts(ColgroupTagStartContext.class); 4931 } 4932 public ColgroupTagStartContext colgroupTagStart(int i) { 4933 return getRuleContext(ColgroupTagStartContext.class,i); 4934 } 4935 public List<DdTagStartContext> ddTagStart() { 4936 return getRuleContexts(DdTagStartContext.class); 4937 } 4938 public DdTagStartContext ddTagStart(int i) { 4939 return getRuleContext(DdTagStartContext.class,i); 4940 } 4941 public List<DtTagStartContext> dtTagStart() { 4942 return getRuleContexts(DtTagStartContext.class); 4943 } 4944 public DtTagStartContext dtTagStart(int i) { 4945 return getRuleContext(DtTagStartContext.class,i); 4946 } 4947 public List<HeadTagStartContext> headTagStart() { 4948 return getRuleContexts(HeadTagStartContext.class); 4949 } 4950 public HeadTagStartContext headTagStart(int i) { 4951 return getRuleContext(HeadTagStartContext.class,i); 4952 } 4953 public List<HtmlTagStartContext> htmlTagStart() { 4954 return getRuleContexts(HtmlTagStartContext.class); 4955 } 4956 public HtmlTagStartContext htmlTagStart(int i) { 4957 return getRuleContext(HtmlTagStartContext.class,i); 4958 } 4959 public List<OptionTagStartContext> optionTagStart() { 4960 return getRuleContexts(OptionTagStartContext.class); 4961 } 4962 public OptionTagStartContext optionTagStart(int i) { 4963 return getRuleContext(OptionTagStartContext.class,i); 4964 } 4965 public List<TbodyTagStartContext> tbodyTagStart() { 4966 return getRuleContexts(TbodyTagStartContext.class); 4967 } 4968 public TbodyTagStartContext tbodyTagStart(int i) { 4969 return getRuleContext(TbodyTagStartContext.class,i); 4970 } 4971 public List<TheadTagStartContext> theadTagStart() { 4972 return getRuleContexts(TheadTagStartContext.class); 4973 } 4974 public TheadTagStartContext theadTagStart(int i) { 4975 return getRuleContext(TheadTagStartContext.class,i); 4976 } 4977 public List<TfootTagStartContext> tfootTagStart() { 4978 return getRuleContexts(TfootTagStartContext.class); 4979 } 4980 public TfootTagStartContext tfootTagStart(int i) { 4981 return getRuleContext(TfootTagStartContext.class,i); 4982 } 4983 public List<OptgroupTagStartContext> optgroupTagStart() { 4984 return getRuleContexts(OptgroupTagStartContext.class); 4985 } 4986 public OptgroupTagStartContext optgroupTagStart(int i) { 4987 return getRuleContext(OptgroupTagStartContext.class,i); 4988 } 4989 public List<RbTagStartContext> rbTagStart() { 4990 return getRuleContexts(RbTagStartContext.class); 4991 } 4992 public RbTagStartContext rbTagStart(int i) { 4993 return getRuleContext(RbTagStartContext.class,i); 4994 } 4995 public List<RtTagStartContext> rtTagStart() { 4996 return getRuleContexts(RtTagStartContext.class); 4997 } 4998 public RtTagStartContext rtTagStart(int i) { 4999 return getRuleContext(RtTagStartContext.class,i); 5000 } 5001 public List<RtcTagStartContext> rtcTagStart() { 5002 return getRuleContexts(RtcTagStartContext.class); 5003 } 5004 public RtcTagStartContext rtcTagStart(int i) { 5005 return getRuleContext(RtcTagStartContext.class,i); 5006 } 5007 public List<RpTagStartContext> rpTagStart() { 5008 return getRuleContexts(RpTagStartContext.class); 5009 } 5010 public RpTagStartContext rpTagStart(int i) { 5011 return getRuleContext(RpTagStartContext.class,i); 5012 } 5013 public List<HtmlCommentContext> htmlComment() { 5014 return getRuleContexts(HtmlCommentContext.class); 5015 } 5016 public HtmlCommentContext htmlComment(int i) { 5017 return getRuleContext(HtmlCommentContext.class,i); 5018 } 5019 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5020 public TerminalNode CDATA(int i) { 5021 return getToken(JavadocParser.CDATA, i); 5022 } 5023 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5024 public TerminalNode NEWLINE(int i) { 5025 return getToken(JavadocParser.NEWLINE, i); 5026 } 5027 public List<TextContext> text() { 5028 return getRuleContexts(TextContext.class); 5029 } 5030 public TextContext text(int i) { 5031 return getRuleContext(TextContext.class,i); 5032 } 5033 public List<JavadocInlineTagContext> javadocInlineTag() { 5034 return getRuleContexts(JavadocInlineTagContext.class); 5035 } 5036 public JavadocInlineTagContext javadocInlineTag(int i) { 5037 return getRuleContext(JavadocInlineTagContext.class,i); 5038 } 5039 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5040 public TerminalNode LEADING_ASTERISK(int i) { 5041 return getToken(JavadocParser.LEADING_ASTERISK, i); 5042 } 5043 public ThContext(ParserRuleContext parent, int invokingState) { 5044 super(parent, invokingState); 5045 } 5046 @Override public int getRuleIndex() { return RULE_th; } 5047 } 5048 5049 public final ThContext th() throws RecognitionException { 5050 ThContext _localctx = new ThContext(_ctx, getState()); 5051 enterRule(_localctx, 40, RULE_th); 5052 try { 5053 int _alt; 5054 enterOuterAlt(_localctx, 1); 5055 { 5056 setState(684); 5057 thTagStart(false); 5058 setState(734); 5059 _errHandler.sync(this); 5060 _alt = getInterpreter().adaptivePredict(_input,38,_ctx); 5061 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5062 if ( _alt==1 ) { 5063 { 5064 setState(732); 5065 _errHandler.sync(this); 5066 switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) { 5067 case 1: 5068 { 5069 setState(685); 5070 htmlTag(); 5071 } 5072 break; 5073 case 2: 5074 { 5075 setState(686); 5076 singletonElement(); 5077 } 5078 break; 5079 case 3: 5080 { 5081 setState(687); 5082 paragraph(); 5083 } 5084 break; 5085 case 4: 5086 { 5087 setState(688); 5088 li(); 5089 } 5090 break; 5091 case 5: 5092 { 5093 setState(689); 5094 tr(); 5095 } 5096 break; 5097 case 6: 5098 { 5099 setState(690); 5100 td(); 5101 } 5102 break; 5103 case 7: 5104 { 5105 setState(691); 5106 body(); 5107 } 5108 break; 5109 case 8: 5110 { 5111 setState(692); 5112 colgroup(); 5113 } 5114 break; 5115 case 9: 5116 { 5117 setState(693); 5118 dd(); 5119 } 5120 break; 5121 case 10: 5122 { 5123 setState(694); 5124 dt(); 5125 } 5126 break; 5127 case 11: 5128 { 5129 setState(695); 5130 head(); 5131 } 5132 break; 5133 case 12: 5134 { 5135 setState(696); 5136 html(); 5137 } 5138 break; 5139 case 13: 5140 { 5141 setState(697); 5142 option(); 5143 } 5144 break; 5145 case 14: 5146 { 5147 setState(698); 5148 tbody(); 5149 } 5150 break; 5151 case 15: 5152 { 5153 setState(699); 5154 thead(); 5155 } 5156 break; 5157 case 16: 5158 { 5159 setState(700); 5160 tfoot(); 5161 } 5162 break; 5163 case 17: 5164 { 5165 setState(701); 5166 optgroup(); 5167 } 5168 break; 5169 case 18: 5170 { 5171 setState(702); 5172 rb(); 5173 } 5174 break; 5175 case 19: 5176 { 5177 setState(703); 5178 rt(); 5179 } 5180 break; 5181 case 20: 5182 { 5183 setState(704); 5184 rtc(); 5185 } 5186 break; 5187 case 21: 5188 { 5189 setState(705); 5190 rp(); 5191 } 5192 break; 5193 case 22: 5194 { 5195 setState(706); 5196 pTagStart(true); 5197 } 5198 break; 5199 case 23: 5200 { 5201 setState(707); 5202 liTagStart(true); 5203 } 5204 break; 5205 case 24: 5206 { 5207 setState(708); 5208 trTagStart(true); 5209 } 5210 break; 5211 case 25: 5212 { 5213 setState(709); 5214 tdTagStart(true); 5215 } 5216 break; 5217 case 26: 5218 { 5219 setState(710); 5220 bodyTagStart(true); 5221 } 5222 break; 5223 case 27: 5224 { 5225 setState(711); 5226 colgroupTagStart(true); 5227 } 5228 break; 5229 case 28: 5230 { 5231 setState(712); 5232 ddTagStart(true); 5233 } 5234 break; 5235 case 29: 5236 { 5237 setState(713); 5238 dtTagStart(true); 5239 } 5240 break; 5241 case 30: 5242 { 5243 setState(714); 5244 headTagStart(true); 5245 } 5246 break; 5247 case 31: 5248 { 5249 setState(715); 5250 htmlTagStart(true); 5251 } 5252 break; 5253 case 32: 5254 { 5255 setState(716); 5256 optionTagStart(true); 5257 } 5258 break; 5259 case 33: 5260 { 5261 setState(717); 5262 tbodyTagStart(true); 5263 } 5264 break; 5265 case 34: 5266 { 5267 setState(718); 5268 theadTagStart(true); 5269 } 5270 break; 5271 case 35: 5272 { 5273 setState(719); 5274 tfootTagStart(true); 5275 } 5276 break; 5277 case 36: 5278 { 5279 setState(720); 5280 optgroupTagStart(true); 5281 } 5282 break; 5283 case 37: 5284 { 5285 setState(721); 5286 rbTagStart(true); 5287 } 5288 break; 5289 case 38: 5290 { 5291 setState(722); 5292 rtTagStart(true); 5293 } 5294 break; 5295 case 39: 5296 { 5297 setState(723); 5298 rtcTagStart(true); 5299 } 5300 break; 5301 case 40: 5302 { 5303 setState(724); 5304 rpTagStart(true); 5305 } 5306 break; 5307 case 41: 5308 { 5309 { 5310 setState(725); 5311 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 5312 setState(726); 5313 match(LEADING_ASTERISK); 5314 } 5315 } 5316 break; 5317 case 42: 5318 { 5319 setState(727); 5320 htmlComment(); 5321 } 5322 break; 5323 case 43: 5324 { 5325 setState(728); 5326 match(CDATA); 5327 } 5328 break; 5329 case 44: 5330 { 5331 setState(729); 5332 match(NEWLINE); 5333 } 5334 break; 5335 case 45: 5336 { 5337 setState(730); 5338 text(); 5339 } 5340 break; 5341 case 46: 5342 { 5343 setState(731); 5344 javadocInlineTag(); 5345 } 5346 break; 5347 } 5348 } 5349 } 5350 setState(736); 5351 _errHandler.sync(this); 5352 _alt = getInterpreter().adaptivePredict(_input,38,_ctx); 5353 } 5354 setState(737); 5355 thTagEnd(); 5356 } 5357 } 5358 catch (RecognitionException re) { 5359 _localctx.exception = re; 5360 _errHandler.reportError(this, re); 5361 _errHandler.recover(this, re); 5362 } 5363 finally { 5364 exitRule(); 5365 } 5366 return _localctx; 5367 } 5368 5369 public static class BodyTagStartContext extends ParserRuleContext { 5370 public boolean isNonTight; 5371 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 5372 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 5373 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 5374 public List<AttributeContext> attribute() { 5375 return getRuleContexts(AttributeContext.class); 5376 } 5377 public AttributeContext attribute(int i) { 5378 return getRuleContext(AttributeContext.class,i); 5379 } 5380 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5381 public TerminalNode NEWLINE(int i) { 5382 return getToken(JavadocParser.NEWLINE, i); 5383 } 5384 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5385 public TerminalNode LEADING_ASTERISK(int i) { 5386 return getToken(JavadocParser.LEADING_ASTERISK, i); 5387 } 5388 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5389 public TerminalNode WS(int i) { 5390 return getToken(JavadocParser.WS, i); 5391 } 5392 public BodyTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 5393 public BodyTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 5394 super(parent, invokingState); 5395 this.isNonTight = isNonTight; 5396 } 5397 @Override public int getRuleIndex() { return RULE_bodyTagStart; } 5398 } 5399 5400 public final BodyTagStartContext bodyTagStart(boolean isNonTight) throws RecognitionException { 5401 BodyTagStartContext _localctx = new BodyTagStartContext(_ctx, getState(), isNonTight); 5402 enterRule(_localctx, 42, RULE_bodyTagStart); 5403 int _la; 5404 try { 5405 enterOuterAlt(_localctx, 1); 5406 { 5407 setState(739); 5408 match(START); 5409 setState(740); 5410 match(BODY_HTML_TAG_NAME); 5411 setState(747); 5412 _errHandler.sync(this); 5413 _la = _input.LA(1); 5414 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 5415 { 5416 setState(745); 5417 _errHandler.sync(this); 5418 switch (_input.LA(1)) { 5419 case HTML_TAG_NAME: 5420 { 5421 setState(741); 5422 attribute(); 5423 } 5424 break; 5425 case NEWLINE: 5426 { 5427 setState(742); 5428 match(NEWLINE); 5429 } 5430 break; 5431 case LEADING_ASTERISK: 5432 { 5433 setState(743); 5434 match(LEADING_ASTERISK); 5435 } 5436 break; 5437 case WS: 5438 { 5439 setState(744); 5440 match(WS); 5441 } 5442 break; 5443 default: 5444 throw new NoViableAltException(this); 5445 } 5446 } 5447 setState(749); 5448 _errHandler.sync(this); 5449 _la = _input.LA(1); 5450 } 5451 setState(750); 5452 match(END); 5453 } 5454 _ctx.stop = _input.LT(-1); 5455 5456 if (isNonTight && nonTightTagStartContext == null) { 5457 nonTightTagStartContext = _localctx; 5458 } 5459 5460 } 5461 catch (RecognitionException re) { 5462 _localctx.exception = re; 5463 _errHandler.reportError(this, re); 5464 _errHandler.recover(this, re); 5465 } 5466 finally { 5467 exitRule(); 5468 } 5469 return _localctx; 5470 } 5471 5472 public static class BodyTagEndContext extends ParserRuleContext { 5473 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 5474 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 5475 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 5476 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 5477 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5478 public TerminalNode NEWLINE(int i) { 5479 return getToken(JavadocParser.NEWLINE, i); 5480 } 5481 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5482 public TerminalNode LEADING_ASTERISK(int i) { 5483 return getToken(JavadocParser.LEADING_ASTERISK, i); 5484 } 5485 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5486 public TerminalNode WS(int i) { 5487 return getToken(JavadocParser.WS, i); 5488 } 5489 public BodyTagEndContext(ParserRuleContext parent, int invokingState) { 5490 super(parent, invokingState); 5491 } 5492 @Override public int getRuleIndex() { return RULE_bodyTagEnd; } 5493 } 5494 5495 public final BodyTagEndContext bodyTagEnd() throws RecognitionException { 5496 BodyTagEndContext _localctx = new BodyTagEndContext(_ctx, getState()); 5497 enterRule(_localctx, 44, RULE_bodyTagEnd); 5498 int _la; 5499 try { 5500 enterOuterAlt(_localctx, 1); 5501 { 5502 setState(752); 5503 match(START); 5504 setState(753); 5505 match(SLASH); 5506 setState(754); 5507 match(BODY_HTML_TAG_NAME); 5508 setState(758); 5509 _errHandler.sync(this); 5510 _la = _input.LA(1); 5511 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5512 { 5513 { 5514 setState(755); 5515 _la = _input.LA(1); 5516 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5517 _errHandler.recoverInline(this); 5518 } 5519 else { 5520 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 5521 _errHandler.reportMatch(this); 5522 consume(); 5523 } 5524 } 5525 } 5526 setState(760); 5527 _errHandler.sync(this); 5528 _la = _input.LA(1); 5529 } 5530 setState(761); 5531 match(END); 5532 } 5533 } 5534 catch (RecognitionException re) { 5535 _localctx.exception = re; 5536 _errHandler.reportError(this, re); 5537 _errHandler.recover(this, re); 5538 } 5539 finally { 5540 exitRule(); 5541 } 5542 return _localctx; 5543 } 5544 5545 public static class BodyContext extends ParserRuleContext { 5546 public BodyTagStartContext bodyTagStart() { 5547 return getRuleContext(BodyTagStartContext.class,0); 5548 } 5549 public BodyTagEndContext bodyTagEnd() { 5550 return getRuleContext(BodyTagEndContext.class,0); 5551 } 5552 public List<HtmlTagContext> htmlTag() { 5553 return getRuleContexts(HtmlTagContext.class); 5554 } 5555 public HtmlTagContext htmlTag(int i) { 5556 return getRuleContext(HtmlTagContext.class,i); 5557 } 5558 public List<SingletonElementContext> singletonElement() { 5559 return getRuleContexts(SingletonElementContext.class); 5560 } 5561 public SingletonElementContext singletonElement(int i) { 5562 return getRuleContext(SingletonElementContext.class,i); 5563 } 5564 public List<ParagraphContext> paragraph() { 5565 return getRuleContexts(ParagraphContext.class); 5566 } 5567 public ParagraphContext paragraph(int i) { 5568 return getRuleContext(ParagraphContext.class,i); 5569 } 5570 public List<LiContext> li() { 5571 return getRuleContexts(LiContext.class); 5572 } 5573 public LiContext li(int i) { 5574 return getRuleContext(LiContext.class,i); 5575 } 5576 public List<TrContext> tr() { 5577 return getRuleContexts(TrContext.class); 5578 } 5579 public TrContext tr(int i) { 5580 return getRuleContext(TrContext.class,i); 5581 } 5582 public List<TdContext> td() { 5583 return getRuleContexts(TdContext.class); 5584 } 5585 public TdContext td(int i) { 5586 return getRuleContext(TdContext.class,i); 5587 } 5588 public List<ThContext> th() { 5589 return getRuleContexts(ThContext.class); 5590 } 5591 public ThContext th(int i) { 5592 return getRuleContext(ThContext.class,i); 5593 } 5594 public List<ColgroupContext> colgroup() { 5595 return getRuleContexts(ColgroupContext.class); 5596 } 5597 public ColgroupContext colgroup(int i) { 5598 return getRuleContext(ColgroupContext.class,i); 5599 } 5600 public List<DdContext> dd() { 5601 return getRuleContexts(DdContext.class); 5602 } 5603 public DdContext dd(int i) { 5604 return getRuleContext(DdContext.class,i); 5605 } 5606 public List<DtContext> dt() { 5607 return getRuleContexts(DtContext.class); 5608 } 5609 public DtContext dt(int i) { 5610 return getRuleContext(DtContext.class,i); 5611 } 5612 public List<HeadContext> head() { 5613 return getRuleContexts(HeadContext.class); 5614 } 5615 public HeadContext head(int i) { 5616 return getRuleContext(HeadContext.class,i); 5617 } 5618 public List<HtmlContext> html() { 5619 return getRuleContexts(HtmlContext.class); 5620 } 5621 public HtmlContext html(int i) { 5622 return getRuleContext(HtmlContext.class,i); 5623 } 5624 public List<OptionContext> option() { 5625 return getRuleContexts(OptionContext.class); 5626 } 5627 public OptionContext option(int i) { 5628 return getRuleContext(OptionContext.class,i); 5629 } 5630 public List<TbodyContext> tbody() { 5631 return getRuleContexts(TbodyContext.class); 5632 } 5633 public TbodyContext tbody(int i) { 5634 return getRuleContext(TbodyContext.class,i); 5635 } 5636 public List<TheadContext> thead() { 5637 return getRuleContexts(TheadContext.class); 5638 } 5639 public TheadContext thead(int i) { 5640 return getRuleContext(TheadContext.class,i); 5641 } 5642 public List<TfootContext> tfoot() { 5643 return getRuleContexts(TfootContext.class); 5644 } 5645 public TfootContext tfoot(int i) { 5646 return getRuleContext(TfootContext.class,i); 5647 } 5648 public List<OptgroupContext> optgroup() { 5649 return getRuleContexts(OptgroupContext.class); 5650 } 5651 public OptgroupContext optgroup(int i) { 5652 return getRuleContext(OptgroupContext.class,i); 5653 } 5654 public List<RbContext> rb() { 5655 return getRuleContexts(RbContext.class); 5656 } 5657 public RbContext rb(int i) { 5658 return getRuleContext(RbContext.class,i); 5659 } 5660 public List<RtContext> rt() { 5661 return getRuleContexts(RtContext.class); 5662 } 5663 public RtContext rt(int i) { 5664 return getRuleContext(RtContext.class,i); 5665 } 5666 public List<RtcContext> rtc() { 5667 return getRuleContexts(RtcContext.class); 5668 } 5669 public RtcContext rtc(int i) { 5670 return getRuleContext(RtcContext.class,i); 5671 } 5672 public List<RpContext> rp() { 5673 return getRuleContexts(RpContext.class); 5674 } 5675 public RpContext rp(int i) { 5676 return getRuleContext(RpContext.class,i); 5677 } 5678 public List<PTagStartContext> pTagStart() { 5679 return getRuleContexts(PTagStartContext.class); 5680 } 5681 public PTagStartContext pTagStart(int i) { 5682 return getRuleContext(PTagStartContext.class,i); 5683 } 5684 public List<LiTagStartContext> liTagStart() { 5685 return getRuleContexts(LiTagStartContext.class); 5686 } 5687 public LiTagStartContext liTagStart(int i) { 5688 return getRuleContext(LiTagStartContext.class,i); 5689 } 5690 public List<TrTagStartContext> trTagStart() { 5691 return getRuleContexts(TrTagStartContext.class); 5692 } 5693 public TrTagStartContext trTagStart(int i) { 5694 return getRuleContext(TrTagStartContext.class,i); 5695 } 5696 public List<TdTagStartContext> tdTagStart() { 5697 return getRuleContexts(TdTagStartContext.class); 5698 } 5699 public TdTagStartContext tdTagStart(int i) { 5700 return getRuleContext(TdTagStartContext.class,i); 5701 } 5702 public List<ThTagStartContext> thTagStart() { 5703 return getRuleContexts(ThTagStartContext.class); 5704 } 5705 public ThTagStartContext thTagStart(int i) { 5706 return getRuleContext(ThTagStartContext.class,i); 5707 } 5708 public List<ColgroupTagStartContext> colgroupTagStart() { 5709 return getRuleContexts(ColgroupTagStartContext.class); 5710 } 5711 public ColgroupTagStartContext colgroupTagStart(int i) { 5712 return getRuleContext(ColgroupTagStartContext.class,i); 5713 } 5714 public List<DdTagStartContext> ddTagStart() { 5715 return getRuleContexts(DdTagStartContext.class); 5716 } 5717 public DdTagStartContext ddTagStart(int i) { 5718 return getRuleContext(DdTagStartContext.class,i); 5719 } 5720 public List<DtTagStartContext> dtTagStart() { 5721 return getRuleContexts(DtTagStartContext.class); 5722 } 5723 public DtTagStartContext dtTagStart(int i) { 5724 return getRuleContext(DtTagStartContext.class,i); 5725 } 5726 public List<HeadTagStartContext> headTagStart() { 5727 return getRuleContexts(HeadTagStartContext.class); 5728 } 5729 public HeadTagStartContext headTagStart(int i) { 5730 return getRuleContext(HeadTagStartContext.class,i); 5731 } 5732 public List<HtmlTagStartContext> htmlTagStart() { 5733 return getRuleContexts(HtmlTagStartContext.class); 5734 } 5735 public HtmlTagStartContext htmlTagStart(int i) { 5736 return getRuleContext(HtmlTagStartContext.class,i); 5737 } 5738 public List<OptionTagStartContext> optionTagStart() { 5739 return getRuleContexts(OptionTagStartContext.class); 5740 } 5741 public OptionTagStartContext optionTagStart(int i) { 5742 return getRuleContext(OptionTagStartContext.class,i); 5743 } 5744 public List<TbodyTagStartContext> tbodyTagStart() { 5745 return getRuleContexts(TbodyTagStartContext.class); 5746 } 5747 public TbodyTagStartContext tbodyTagStart(int i) { 5748 return getRuleContext(TbodyTagStartContext.class,i); 5749 } 5750 public List<TheadTagStartContext> theadTagStart() { 5751 return getRuleContexts(TheadTagStartContext.class); 5752 } 5753 public TheadTagStartContext theadTagStart(int i) { 5754 return getRuleContext(TheadTagStartContext.class,i); 5755 } 5756 public List<TfootTagStartContext> tfootTagStart() { 5757 return getRuleContexts(TfootTagStartContext.class); 5758 } 5759 public TfootTagStartContext tfootTagStart(int i) { 5760 return getRuleContext(TfootTagStartContext.class,i); 5761 } 5762 public List<OptgroupTagStartContext> optgroupTagStart() { 5763 return getRuleContexts(OptgroupTagStartContext.class); 5764 } 5765 public OptgroupTagStartContext optgroupTagStart(int i) { 5766 return getRuleContext(OptgroupTagStartContext.class,i); 5767 } 5768 public List<RbTagStartContext> rbTagStart() { 5769 return getRuleContexts(RbTagStartContext.class); 5770 } 5771 public RbTagStartContext rbTagStart(int i) { 5772 return getRuleContext(RbTagStartContext.class,i); 5773 } 5774 public List<RtTagStartContext> rtTagStart() { 5775 return getRuleContexts(RtTagStartContext.class); 5776 } 5777 public RtTagStartContext rtTagStart(int i) { 5778 return getRuleContext(RtTagStartContext.class,i); 5779 } 5780 public List<RtcTagStartContext> rtcTagStart() { 5781 return getRuleContexts(RtcTagStartContext.class); 5782 } 5783 public RtcTagStartContext rtcTagStart(int i) { 5784 return getRuleContext(RtcTagStartContext.class,i); 5785 } 5786 public List<RpTagStartContext> rpTagStart() { 5787 return getRuleContexts(RpTagStartContext.class); 5788 } 5789 public RpTagStartContext rpTagStart(int i) { 5790 return getRuleContext(RpTagStartContext.class,i); 5791 } 5792 public List<HtmlCommentContext> htmlComment() { 5793 return getRuleContexts(HtmlCommentContext.class); 5794 } 5795 public HtmlCommentContext htmlComment(int i) { 5796 return getRuleContext(HtmlCommentContext.class,i); 5797 } 5798 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5799 public TerminalNode CDATA(int i) { 5800 return getToken(JavadocParser.CDATA, i); 5801 } 5802 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5803 public TerminalNode NEWLINE(int i) { 5804 return getToken(JavadocParser.NEWLINE, i); 5805 } 5806 public List<TextContext> text() { 5807 return getRuleContexts(TextContext.class); 5808 } 5809 public TextContext text(int i) { 5810 return getRuleContext(TextContext.class,i); 5811 } 5812 public List<JavadocInlineTagContext> javadocInlineTag() { 5813 return getRuleContexts(JavadocInlineTagContext.class); 5814 } 5815 public JavadocInlineTagContext javadocInlineTag(int i) { 5816 return getRuleContext(JavadocInlineTagContext.class,i); 5817 } 5818 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5819 public TerminalNode LEADING_ASTERISK(int i) { 5820 return getToken(JavadocParser.LEADING_ASTERISK, i); 5821 } 5822 public BodyContext(ParserRuleContext parent, int invokingState) { 5823 super(parent, invokingState); 5824 } 5825 @Override public int getRuleIndex() { return RULE_body; } 5826 } 5827 5828 public final BodyContext body() throws RecognitionException { 5829 BodyContext _localctx = new BodyContext(_ctx, getState()); 5830 enterRule(_localctx, 46, RULE_body); 5831 try { 5832 int _alt; 5833 enterOuterAlt(_localctx, 1); 5834 { 5835 setState(763); 5836 bodyTagStart(false); 5837 setState(813); 5838 _errHandler.sync(this); 5839 _alt = getInterpreter().adaptivePredict(_input,43,_ctx); 5840 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5841 if ( _alt==1 ) { 5842 { 5843 setState(811); 5844 _errHandler.sync(this); 5845 switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) { 5846 case 1: 5847 { 5848 setState(764); 5849 htmlTag(); 5850 } 5851 break; 5852 case 2: 5853 { 5854 setState(765); 5855 singletonElement(); 5856 } 5857 break; 5858 case 3: 5859 { 5860 setState(766); 5861 paragraph(); 5862 } 5863 break; 5864 case 4: 5865 { 5866 setState(767); 5867 li(); 5868 } 5869 break; 5870 case 5: 5871 { 5872 setState(768); 5873 tr(); 5874 } 5875 break; 5876 case 6: 5877 { 5878 setState(769); 5879 td(); 5880 } 5881 break; 5882 case 7: 5883 { 5884 setState(770); 5885 th(); 5886 } 5887 break; 5888 case 8: 5889 { 5890 setState(771); 5891 colgroup(); 5892 } 5893 break; 5894 case 9: 5895 { 5896 setState(772); 5897 dd(); 5898 } 5899 break; 5900 case 10: 5901 { 5902 setState(773); 5903 dt(); 5904 } 5905 break; 5906 case 11: 5907 { 5908 setState(774); 5909 head(); 5910 } 5911 break; 5912 case 12: 5913 { 5914 setState(775); 5915 html(); 5916 } 5917 break; 5918 case 13: 5919 { 5920 setState(776); 5921 option(); 5922 } 5923 break; 5924 case 14: 5925 { 5926 setState(777); 5927 tbody(); 5928 } 5929 break; 5930 case 15: 5931 { 5932 setState(778); 5933 thead(); 5934 } 5935 break; 5936 case 16: 5937 { 5938 setState(779); 5939 tfoot(); 5940 } 5941 break; 5942 case 17: 5943 { 5944 setState(780); 5945 optgroup(); 5946 } 5947 break; 5948 case 18: 5949 { 5950 setState(781); 5951 rb(); 5952 } 5953 break; 5954 case 19: 5955 { 5956 setState(782); 5957 rt(); 5958 } 5959 break; 5960 case 20: 5961 { 5962 setState(783); 5963 rtc(); 5964 } 5965 break; 5966 case 21: 5967 { 5968 setState(784); 5969 rp(); 5970 } 5971 break; 5972 case 22: 5973 { 5974 setState(785); 5975 pTagStart(true); 5976 } 5977 break; 5978 case 23: 5979 { 5980 setState(786); 5981 liTagStart(true); 5982 } 5983 break; 5984 case 24: 5985 { 5986 setState(787); 5987 trTagStart(true); 5988 } 5989 break; 5990 case 25: 5991 { 5992 setState(788); 5993 tdTagStart(true); 5994 } 5995 break; 5996 case 26: 5997 { 5998 setState(789); 5999 thTagStart(true); 6000 } 6001 break; 6002 case 27: 6003 { 6004 setState(790); 6005 colgroupTagStart(true); 6006 } 6007 break; 6008 case 28: 6009 { 6010 setState(791); 6011 ddTagStart(true); 6012 } 6013 break; 6014 case 29: 6015 { 6016 setState(792); 6017 dtTagStart(true); 6018 } 6019 break; 6020 case 30: 6021 { 6022 setState(793); 6023 headTagStart(true); 6024 } 6025 break; 6026 case 31: 6027 { 6028 setState(794); 6029 htmlTagStart(true); 6030 } 6031 break; 6032 case 32: 6033 { 6034 setState(795); 6035 optionTagStart(true); 6036 } 6037 break; 6038 case 33: 6039 { 6040 setState(796); 6041 tbodyTagStart(true); 6042 } 6043 break; 6044 case 34: 6045 { 6046 setState(797); 6047 theadTagStart(true); 6048 } 6049 break; 6050 case 35: 6051 { 6052 setState(798); 6053 tfootTagStart(true); 6054 } 6055 break; 6056 case 36: 6057 { 6058 setState(799); 6059 optgroupTagStart(true); 6060 } 6061 break; 6062 case 37: 6063 { 6064 setState(800); 6065 rbTagStart(true); 6066 } 6067 break; 6068 case 38: 6069 { 6070 setState(801); 6071 rtTagStart(true); 6072 } 6073 break; 6074 case 39: 6075 { 6076 setState(802); 6077 rtcTagStart(true); 6078 } 6079 break; 6080 case 40: 6081 { 6082 setState(803); 6083 rpTagStart(true); 6084 } 6085 break; 6086 case 41: 6087 { 6088 { 6089 setState(804); 6090 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6091 setState(805); 6092 match(LEADING_ASTERISK); 6093 } 6094 } 6095 break; 6096 case 42: 6097 { 6098 setState(806); 6099 htmlComment(); 6100 } 6101 break; 6102 case 43: 6103 { 6104 setState(807); 6105 match(CDATA); 6106 } 6107 break; 6108 case 44: 6109 { 6110 setState(808); 6111 match(NEWLINE); 6112 } 6113 break; 6114 case 45: 6115 { 6116 setState(809); 6117 text(); 6118 } 6119 break; 6120 case 46: 6121 { 6122 setState(810); 6123 javadocInlineTag(); 6124 } 6125 break; 6126 } 6127 } 6128 } 6129 setState(815); 6130 _errHandler.sync(this); 6131 _alt = getInterpreter().adaptivePredict(_input,43,_ctx); 6132 } 6133 setState(816); 6134 bodyTagEnd(); 6135 } 6136 } 6137 catch (RecognitionException re) { 6138 _localctx.exception = re; 6139 _errHandler.reportError(this, re); 6140 _errHandler.recover(this, re); 6141 } 6142 finally { 6143 exitRule(); 6144 } 6145 return _localctx; 6146 } 6147 6148 public static class ColgroupTagStartContext extends ParserRuleContext { 6149 public boolean isNonTight; 6150 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 6151 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 6152 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 6153 public List<AttributeContext> attribute() { 6154 return getRuleContexts(AttributeContext.class); 6155 } 6156 public AttributeContext attribute(int i) { 6157 return getRuleContext(AttributeContext.class,i); 6158 } 6159 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6160 public TerminalNode NEWLINE(int i) { 6161 return getToken(JavadocParser.NEWLINE, i); 6162 } 6163 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6164 public TerminalNode LEADING_ASTERISK(int i) { 6165 return getToken(JavadocParser.LEADING_ASTERISK, i); 6166 } 6167 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6168 public TerminalNode WS(int i) { 6169 return getToken(JavadocParser.WS, i); 6170 } 6171 public ColgroupTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 6172 public ColgroupTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 6173 super(parent, invokingState); 6174 this.isNonTight = isNonTight; 6175 } 6176 @Override public int getRuleIndex() { return RULE_colgroupTagStart; } 6177 } 6178 6179 public final ColgroupTagStartContext colgroupTagStart(boolean isNonTight) throws RecognitionException { 6180 ColgroupTagStartContext _localctx = new ColgroupTagStartContext(_ctx, getState(), isNonTight); 6181 enterRule(_localctx, 48, RULE_colgroupTagStart); 6182 int _la; 6183 try { 6184 enterOuterAlt(_localctx, 1); 6185 { 6186 setState(818); 6187 match(START); 6188 setState(819); 6189 match(COLGROUP_HTML_TAG_NAME); 6190 setState(826); 6191 _errHandler.sync(this); 6192 _la = _input.LA(1); 6193 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6194 { 6195 setState(824); 6196 _errHandler.sync(this); 6197 switch (_input.LA(1)) { 6198 case HTML_TAG_NAME: 6199 { 6200 setState(820); 6201 attribute(); 6202 } 6203 break; 6204 case NEWLINE: 6205 { 6206 setState(821); 6207 match(NEWLINE); 6208 } 6209 break; 6210 case LEADING_ASTERISK: 6211 { 6212 setState(822); 6213 match(LEADING_ASTERISK); 6214 } 6215 break; 6216 case WS: 6217 { 6218 setState(823); 6219 match(WS); 6220 } 6221 break; 6222 default: 6223 throw new NoViableAltException(this); 6224 } 6225 } 6226 setState(828); 6227 _errHandler.sync(this); 6228 _la = _input.LA(1); 6229 } 6230 setState(829); 6231 match(END); 6232 } 6233 _ctx.stop = _input.LT(-1); 6234 6235 if (isNonTight && nonTightTagStartContext == null) { 6236 nonTightTagStartContext = _localctx; 6237 } 6238 6239 } 6240 catch (RecognitionException re) { 6241 _localctx.exception = re; 6242 _errHandler.reportError(this, re); 6243 _errHandler.recover(this, re); 6244 } 6245 finally { 6246 exitRule(); 6247 } 6248 return _localctx; 6249 } 6250 6251 public static class ColgroupTagEndContext extends ParserRuleContext { 6252 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 6253 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 6254 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 6255 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 6256 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6257 public TerminalNode NEWLINE(int i) { 6258 return getToken(JavadocParser.NEWLINE, i); 6259 } 6260 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6261 public TerminalNode LEADING_ASTERISK(int i) { 6262 return getToken(JavadocParser.LEADING_ASTERISK, i); 6263 } 6264 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6265 public TerminalNode WS(int i) { 6266 return getToken(JavadocParser.WS, i); 6267 } 6268 public ColgroupTagEndContext(ParserRuleContext parent, int invokingState) { 6269 super(parent, invokingState); 6270 } 6271 @Override public int getRuleIndex() { return RULE_colgroupTagEnd; } 6272 } 6273 6274 public final ColgroupTagEndContext colgroupTagEnd() throws RecognitionException { 6275 ColgroupTagEndContext _localctx = new ColgroupTagEndContext(_ctx, getState()); 6276 enterRule(_localctx, 50, RULE_colgroupTagEnd); 6277 int _la; 6278 try { 6279 enterOuterAlt(_localctx, 1); 6280 { 6281 setState(831); 6282 match(START); 6283 setState(832); 6284 match(SLASH); 6285 setState(833); 6286 match(COLGROUP_HTML_TAG_NAME); 6287 setState(837); 6288 _errHandler.sync(this); 6289 _la = _input.LA(1); 6290 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 6291 { 6292 { 6293 setState(834); 6294 _la = _input.LA(1); 6295 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 6296 _errHandler.recoverInline(this); 6297 } 6298 else { 6299 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 6300 _errHandler.reportMatch(this); 6301 consume(); 6302 } 6303 } 6304 } 6305 setState(839); 6306 _errHandler.sync(this); 6307 _la = _input.LA(1); 6308 } 6309 setState(840); 6310 match(END); 6311 } 6312 } 6313 catch (RecognitionException re) { 6314 _localctx.exception = re; 6315 _errHandler.reportError(this, re); 6316 _errHandler.recover(this, re); 6317 } 6318 finally { 6319 exitRule(); 6320 } 6321 return _localctx; 6322 } 6323 6324 public static class ColgroupContext extends ParserRuleContext { 6325 public ColgroupTagStartContext colgroupTagStart() { 6326 return getRuleContext(ColgroupTagStartContext.class,0); 6327 } 6328 public ColgroupTagEndContext colgroupTagEnd() { 6329 return getRuleContext(ColgroupTagEndContext.class,0); 6330 } 6331 public List<HtmlTagContext> htmlTag() { 6332 return getRuleContexts(HtmlTagContext.class); 6333 } 6334 public HtmlTagContext htmlTag(int i) { 6335 return getRuleContext(HtmlTagContext.class,i); 6336 } 6337 public List<SingletonElementContext> singletonElement() { 6338 return getRuleContexts(SingletonElementContext.class); 6339 } 6340 public SingletonElementContext singletonElement(int i) { 6341 return getRuleContext(SingletonElementContext.class,i); 6342 } 6343 public List<ParagraphContext> paragraph() { 6344 return getRuleContexts(ParagraphContext.class); 6345 } 6346 public ParagraphContext paragraph(int i) { 6347 return getRuleContext(ParagraphContext.class,i); 6348 } 6349 public List<LiContext> li() { 6350 return getRuleContexts(LiContext.class); 6351 } 6352 public LiContext li(int i) { 6353 return getRuleContext(LiContext.class,i); 6354 } 6355 public List<TrContext> tr() { 6356 return getRuleContexts(TrContext.class); 6357 } 6358 public TrContext tr(int i) { 6359 return getRuleContext(TrContext.class,i); 6360 } 6361 public List<TdContext> td() { 6362 return getRuleContexts(TdContext.class); 6363 } 6364 public TdContext td(int i) { 6365 return getRuleContext(TdContext.class,i); 6366 } 6367 public List<ThContext> th() { 6368 return getRuleContexts(ThContext.class); 6369 } 6370 public ThContext th(int i) { 6371 return getRuleContext(ThContext.class,i); 6372 } 6373 public List<BodyContext> body() { 6374 return getRuleContexts(BodyContext.class); 6375 } 6376 public BodyContext body(int i) { 6377 return getRuleContext(BodyContext.class,i); 6378 } 6379 public List<DdContext> dd() { 6380 return getRuleContexts(DdContext.class); 6381 } 6382 public DdContext dd(int i) { 6383 return getRuleContext(DdContext.class,i); 6384 } 6385 public List<DtContext> dt() { 6386 return getRuleContexts(DtContext.class); 6387 } 6388 public DtContext dt(int i) { 6389 return getRuleContext(DtContext.class,i); 6390 } 6391 public List<HeadContext> head() { 6392 return getRuleContexts(HeadContext.class); 6393 } 6394 public HeadContext head(int i) { 6395 return getRuleContext(HeadContext.class,i); 6396 } 6397 public List<HtmlContext> html() { 6398 return getRuleContexts(HtmlContext.class); 6399 } 6400 public HtmlContext html(int i) { 6401 return getRuleContext(HtmlContext.class,i); 6402 } 6403 public List<OptionContext> option() { 6404 return getRuleContexts(OptionContext.class); 6405 } 6406 public OptionContext option(int i) { 6407 return getRuleContext(OptionContext.class,i); 6408 } 6409 public List<TbodyContext> tbody() { 6410 return getRuleContexts(TbodyContext.class); 6411 } 6412 public TbodyContext tbody(int i) { 6413 return getRuleContext(TbodyContext.class,i); 6414 } 6415 public List<TheadContext> thead() { 6416 return getRuleContexts(TheadContext.class); 6417 } 6418 public TheadContext thead(int i) { 6419 return getRuleContext(TheadContext.class,i); 6420 } 6421 public List<TfootContext> tfoot() { 6422 return getRuleContexts(TfootContext.class); 6423 } 6424 public TfootContext tfoot(int i) { 6425 return getRuleContext(TfootContext.class,i); 6426 } 6427 public List<OptgroupContext> optgroup() { 6428 return getRuleContexts(OptgroupContext.class); 6429 } 6430 public OptgroupContext optgroup(int i) { 6431 return getRuleContext(OptgroupContext.class,i); 6432 } 6433 public List<RbContext> rb() { 6434 return getRuleContexts(RbContext.class); 6435 } 6436 public RbContext rb(int i) { 6437 return getRuleContext(RbContext.class,i); 6438 } 6439 public List<RtContext> rt() { 6440 return getRuleContexts(RtContext.class); 6441 } 6442 public RtContext rt(int i) { 6443 return getRuleContext(RtContext.class,i); 6444 } 6445 public List<RtcContext> rtc() { 6446 return getRuleContexts(RtcContext.class); 6447 } 6448 public RtcContext rtc(int i) { 6449 return getRuleContext(RtcContext.class,i); 6450 } 6451 public List<RpContext> rp() { 6452 return getRuleContexts(RpContext.class); 6453 } 6454 public RpContext rp(int i) { 6455 return getRuleContext(RpContext.class,i); 6456 } 6457 public List<PTagStartContext> pTagStart() { 6458 return getRuleContexts(PTagStartContext.class); 6459 } 6460 public PTagStartContext pTagStart(int i) { 6461 return getRuleContext(PTagStartContext.class,i); 6462 } 6463 public List<LiTagStartContext> liTagStart() { 6464 return getRuleContexts(LiTagStartContext.class); 6465 } 6466 public LiTagStartContext liTagStart(int i) { 6467 return getRuleContext(LiTagStartContext.class,i); 6468 } 6469 public List<TrTagStartContext> trTagStart() { 6470 return getRuleContexts(TrTagStartContext.class); 6471 } 6472 public TrTagStartContext trTagStart(int i) { 6473 return getRuleContext(TrTagStartContext.class,i); 6474 } 6475 public List<TdTagStartContext> tdTagStart() { 6476 return getRuleContexts(TdTagStartContext.class); 6477 } 6478 public TdTagStartContext tdTagStart(int i) { 6479 return getRuleContext(TdTagStartContext.class,i); 6480 } 6481 public List<ThTagStartContext> thTagStart() { 6482 return getRuleContexts(ThTagStartContext.class); 6483 } 6484 public ThTagStartContext thTagStart(int i) { 6485 return getRuleContext(ThTagStartContext.class,i); 6486 } 6487 public List<BodyTagStartContext> bodyTagStart() { 6488 return getRuleContexts(BodyTagStartContext.class); 6489 } 6490 public BodyTagStartContext bodyTagStart(int i) { 6491 return getRuleContext(BodyTagStartContext.class,i); 6492 } 6493 public List<DdTagStartContext> ddTagStart() { 6494 return getRuleContexts(DdTagStartContext.class); 6495 } 6496 public DdTagStartContext ddTagStart(int i) { 6497 return getRuleContext(DdTagStartContext.class,i); 6498 } 6499 public List<DtTagStartContext> dtTagStart() { 6500 return getRuleContexts(DtTagStartContext.class); 6501 } 6502 public DtTagStartContext dtTagStart(int i) { 6503 return getRuleContext(DtTagStartContext.class,i); 6504 } 6505 public List<HeadTagStartContext> headTagStart() { 6506 return getRuleContexts(HeadTagStartContext.class); 6507 } 6508 public HeadTagStartContext headTagStart(int i) { 6509 return getRuleContext(HeadTagStartContext.class,i); 6510 } 6511 public List<HtmlTagStartContext> htmlTagStart() { 6512 return getRuleContexts(HtmlTagStartContext.class); 6513 } 6514 public HtmlTagStartContext htmlTagStart(int i) { 6515 return getRuleContext(HtmlTagStartContext.class,i); 6516 } 6517 public List<OptionTagStartContext> optionTagStart() { 6518 return getRuleContexts(OptionTagStartContext.class); 6519 } 6520 public OptionTagStartContext optionTagStart(int i) { 6521 return getRuleContext(OptionTagStartContext.class,i); 6522 } 6523 public List<TbodyTagStartContext> tbodyTagStart() { 6524 return getRuleContexts(TbodyTagStartContext.class); 6525 } 6526 public TbodyTagStartContext tbodyTagStart(int i) { 6527 return getRuleContext(TbodyTagStartContext.class,i); 6528 } 6529 public List<TheadTagStartContext> theadTagStart() { 6530 return getRuleContexts(TheadTagStartContext.class); 6531 } 6532 public TheadTagStartContext theadTagStart(int i) { 6533 return getRuleContext(TheadTagStartContext.class,i); 6534 } 6535 public List<TfootTagStartContext> tfootTagStart() { 6536 return getRuleContexts(TfootTagStartContext.class); 6537 } 6538 public TfootTagStartContext tfootTagStart(int i) { 6539 return getRuleContext(TfootTagStartContext.class,i); 6540 } 6541 public List<OptgroupTagStartContext> optgroupTagStart() { 6542 return getRuleContexts(OptgroupTagStartContext.class); 6543 } 6544 public OptgroupTagStartContext optgroupTagStart(int i) { 6545 return getRuleContext(OptgroupTagStartContext.class,i); 6546 } 6547 public List<RbTagStartContext> rbTagStart() { 6548 return getRuleContexts(RbTagStartContext.class); 6549 } 6550 public RbTagStartContext rbTagStart(int i) { 6551 return getRuleContext(RbTagStartContext.class,i); 6552 } 6553 public List<RtTagStartContext> rtTagStart() { 6554 return getRuleContexts(RtTagStartContext.class); 6555 } 6556 public RtTagStartContext rtTagStart(int i) { 6557 return getRuleContext(RtTagStartContext.class,i); 6558 } 6559 public List<RtcTagStartContext> rtcTagStart() { 6560 return getRuleContexts(RtcTagStartContext.class); 6561 } 6562 public RtcTagStartContext rtcTagStart(int i) { 6563 return getRuleContext(RtcTagStartContext.class,i); 6564 } 6565 public List<RpTagStartContext> rpTagStart() { 6566 return getRuleContexts(RpTagStartContext.class); 6567 } 6568 public RpTagStartContext rpTagStart(int i) { 6569 return getRuleContext(RpTagStartContext.class,i); 6570 } 6571 public List<HtmlCommentContext> htmlComment() { 6572 return getRuleContexts(HtmlCommentContext.class); 6573 } 6574 public HtmlCommentContext htmlComment(int i) { 6575 return getRuleContext(HtmlCommentContext.class,i); 6576 } 6577 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 6578 public TerminalNode CDATA(int i) { 6579 return getToken(JavadocParser.CDATA, i); 6580 } 6581 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6582 public TerminalNode NEWLINE(int i) { 6583 return getToken(JavadocParser.NEWLINE, i); 6584 } 6585 public List<TextContext> text() { 6586 return getRuleContexts(TextContext.class); 6587 } 6588 public TextContext text(int i) { 6589 return getRuleContext(TextContext.class,i); 6590 } 6591 public List<JavadocInlineTagContext> javadocInlineTag() { 6592 return getRuleContexts(JavadocInlineTagContext.class); 6593 } 6594 public JavadocInlineTagContext javadocInlineTag(int i) { 6595 return getRuleContext(JavadocInlineTagContext.class,i); 6596 } 6597 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6598 public TerminalNode LEADING_ASTERISK(int i) { 6599 return getToken(JavadocParser.LEADING_ASTERISK, i); 6600 } 6601 public ColgroupContext(ParserRuleContext parent, int invokingState) { 6602 super(parent, invokingState); 6603 } 6604 @Override public int getRuleIndex() { return RULE_colgroup; } 6605 } 6606 6607 public final ColgroupContext colgroup() throws RecognitionException { 6608 ColgroupContext _localctx = new ColgroupContext(_ctx, getState()); 6609 enterRule(_localctx, 52, RULE_colgroup); 6610 try { 6611 int _alt; 6612 enterOuterAlt(_localctx, 1); 6613 { 6614 setState(842); 6615 colgroupTagStart(false); 6616 setState(892); 6617 _errHandler.sync(this); 6618 _alt = getInterpreter().adaptivePredict(_input,48,_ctx); 6619 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6620 if ( _alt==1 ) { 6621 { 6622 setState(890); 6623 _errHandler.sync(this); 6624 switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) { 6625 case 1: 6626 { 6627 setState(843); 6628 htmlTag(); 6629 } 6630 break; 6631 case 2: 6632 { 6633 setState(844); 6634 singletonElement(); 6635 } 6636 break; 6637 case 3: 6638 { 6639 setState(845); 6640 paragraph(); 6641 } 6642 break; 6643 case 4: 6644 { 6645 setState(846); 6646 li(); 6647 } 6648 break; 6649 case 5: 6650 { 6651 setState(847); 6652 tr(); 6653 } 6654 break; 6655 case 6: 6656 { 6657 setState(848); 6658 td(); 6659 } 6660 break; 6661 case 7: 6662 { 6663 setState(849); 6664 th(); 6665 } 6666 break; 6667 case 8: 6668 { 6669 setState(850); 6670 body(); 6671 } 6672 break; 6673 case 9: 6674 { 6675 setState(851); 6676 dd(); 6677 } 6678 break; 6679 case 10: 6680 { 6681 setState(852); 6682 dt(); 6683 } 6684 break; 6685 case 11: 6686 { 6687 setState(853); 6688 head(); 6689 } 6690 break; 6691 case 12: 6692 { 6693 setState(854); 6694 html(); 6695 } 6696 break; 6697 case 13: 6698 { 6699 setState(855); 6700 option(); 6701 } 6702 break; 6703 case 14: 6704 { 6705 setState(856); 6706 tbody(); 6707 } 6708 break; 6709 case 15: 6710 { 6711 setState(857); 6712 thead(); 6713 } 6714 break; 6715 case 16: 6716 { 6717 setState(858); 6718 tfoot(); 6719 } 6720 break; 6721 case 17: 6722 { 6723 setState(859); 6724 optgroup(); 6725 } 6726 break; 6727 case 18: 6728 { 6729 setState(860); 6730 rb(); 6731 } 6732 break; 6733 case 19: 6734 { 6735 setState(861); 6736 rt(); 6737 } 6738 break; 6739 case 20: 6740 { 6741 setState(862); 6742 rtc(); 6743 } 6744 break; 6745 case 21: 6746 { 6747 setState(863); 6748 rp(); 6749 } 6750 break; 6751 case 22: 6752 { 6753 setState(864); 6754 pTagStart(true); 6755 } 6756 break; 6757 case 23: 6758 { 6759 setState(865); 6760 liTagStart(true); 6761 } 6762 break; 6763 case 24: 6764 { 6765 setState(866); 6766 trTagStart(true); 6767 } 6768 break; 6769 case 25: 6770 { 6771 setState(867); 6772 tdTagStart(true); 6773 } 6774 break; 6775 case 26: 6776 { 6777 setState(868); 6778 thTagStart(true); 6779 } 6780 break; 6781 case 27: 6782 { 6783 setState(869); 6784 bodyTagStart(true); 6785 } 6786 break; 6787 case 28: 6788 { 6789 setState(870); 6790 ddTagStart(true); 6791 } 6792 break; 6793 case 29: 6794 { 6795 setState(871); 6796 dtTagStart(true); 6797 } 6798 break; 6799 case 30: 6800 { 6801 setState(872); 6802 headTagStart(true); 6803 } 6804 break; 6805 case 31: 6806 { 6807 setState(873); 6808 htmlTagStart(true); 6809 } 6810 break; 6811 case 32: 6812 { 6813 setState(874); 6814 optionTagStart(true); 6815 } 6816 break; 6817 case 33: 6818 { 6819 setState(875); 6820 tbodyTagStart(true); 6821 } 6822 break; 6823 case 34: 6824 { 6825 setState(876); 6826 theadTagStart(true); 6827 } 6828 break; 6829 case 35: 6830 { 6831 setState(877); 6832 tfootTagStart(true); 6833 } 6834 break; 6835 case 36: 6836 { 6837 setState(878); 6838 optgroupTagStart(true); 6839 } 6840 break; 6841 case 37: 6842 { 6843 setState(879); 6844 rbTagStart(true); 6845 } 6846 break; 6847 case 38: 6848 { 6849 setState(880); 6850 rtTagStart(true); 6851 } 6852 break; 6853 case 39: 6854 { 6855 setState(881); 6856 rtcTagStart(true); 6857 } 6858 break; 6859 case 40: 6860 { 6861 setState(882); 6862 rpTagStart(true); 6863 } 6864 break; 6865 case 41: 6866 { 6867 { 6868 setState(883); 6869 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6870 setState(884); 6871 match(LEADING_ASTERISK); 6872 } 6873 } 6874 break; 6875 case 42: 6876 { 6877 setState(885); 6878 htmlComment(); 6879 } 6880 break; 6881 case 43: 6882 { 6883 setState(886); 6884 match(CDATA); 6885 } 6886 break; 6887 case 44: 6888 { 6889 setState(887); 6890 match(NEWLINE); 6891 } 6892 break; 6893 case 45: 6894 { 6895 setState(888); 6896 text(); 6897 } 6898 break; 6899 case 46: 6900 { 6901 setState(889); 6902 javadocInlineTag(); 6903 } 6904 break; 6905 } 6906 } 6907 } 6908 setState(894); 6909 _errHandler.sync(this); 6910 _alt = getInterpreter().adaptivePredict(_input,48,_ctx); 6911 } 6912 setState(895); 6913 colgroupTagEnd(); 6914 } 6915 } 6916 catch (RecognitionException re) { 6917 _localctx.exception = re; 6918 _errHandler.reportError(this, re); 6919 _errHandler.recover(this, re); 6920 } 6921 finally { 6922 exitRule(); 6923 } 6924 return _localctx; 6925 } 6926 6927 public static class DdTagStartContext extends ParserRuleContext { 6928 public boolean isNonTight; 6929 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 6930 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6931 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 6932 public List<AttributeContext> attribute() { 6933 return getRuleContexts(AttributeContext.class); 6934 } 6935 public AttributeContext attribute(int i) { 6936 return getRuleContext(AttributeContext.class,i); 6937 } 6938 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6939 public TerminalNode NEWLINE(int i) { 6940 return getToken(JavadocParser.NEWLINE, i); 6941 } 6942 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6943 public TerminalNode LEADING_ASTERISK(int i) { 6944 return getToken(JavadocParser.LEADING_ASTERISK, i); 6945 } 6946 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6947 public TerminalNode WS(int i) { 6948 return getToken(JavadocParser.WS, i); 6949 } 6950 public DdTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 6951 public DdTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 6952 super(parent, invokingState); 6953 this.isNonTight = isNonTight; 6954 } 6955 @Override public int getRuleIndex() { return RULE_ddTagStart; } 6956 } 6957 6958 public final DdTagStartContext ddTagStart(boolean isNonTight) throws RecognitionException { 6959 DdTagStartContext _localctx = new DdTagStartContext(_ctx, getState(), isNonTight); 6960 enterRule(_localctx, 54, RULE_ddTagStart); 6961 int _la; 6962 try { 6963 enterOuterAlt(_localctx, 1); 6964 { 6965 setState(897); 6966 match(START); 6967 setState(898); 6968 match(DD_HTML_TAG_NAME); 6969 setState(905); 6970 _errHandler.sync(this); 6971 _la = _input.LA(1); 6972 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6973 { 6974 setState(903); 6975 _errHandler.sync(this); 6976 switch (_input.LA(1)) { 6977 case HTML_TAG_NAME: 6978 { 6979 setState(899); 6980 attribute(); 6981 } 6982 break; 6983 case NEWLINE: 6984 { 6985 setState(900); 6986 match(NEWLINE); 6987 } 6988 break; 6989 case LEADING_ASTERISK: 6990 { 6991 setState(901); 6992 match(LEADING_ASTERISK); 6993 } 6994 break; 6995 case WS: 6996 { 6997 setState(902); 6998 match(WS); 6999 } 7000 break; 7001 default: 7002 throw new NoViableAltException(this); 7003 } 7004 } 7005 setState(907); 7006 _errHandler.sync(this); 7007 _la = _input.LA(1); 7008 } 7009 setState(908); 7010 match(END); 7011 } 7012 _ctx.stop = _input.LT(-1); 7013 7014 if (isNonTight && nonTightTagStartContext == null) { 7015 nonTightTagStartContext = _localctx; 7016 } 7017 7018 } 7019 catch (RecognitionException re) { 7020 _localctx.exception = re; 7021 _errHandler.reportError(this, re); 7022 _errHandler.recover(this, re); 7023 } 7024 finally { 7025 exitRule(); 7026 } 7027 return _localctx; 7028 } 7029 7030 public static class DdTagEndContext extends ParserRuleContext { 7031 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 7032 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7033 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 7034 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 7035 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7036 public TerminalNode NEWLINE(int i) { 7037 return getToken(JavadocParser.NEWLINE, i); 7038 } 7039 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7040 public TerminalNode LEADING_ASTERISK(int i) { 7041 return getToken(JavadocParser.LEADING_ASTERISK, i); 7042 } 7043 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7044 public TerminalNode WS(int i) { 7045 return getToken(JavadocParser.WS, i); 7046 } 7047 public DdTagEndContext(ParserRuleContext parent, int invokingState) { 7048 super(parent, invokingState); 7049 } 7050 @Override public int getRuleIndex() { return RULE_ddTagEnd; } 7051 } 7052 7053 public final DdTagEndContext ddTagEnd() throws RecognitionException { 7054 DdTagEndContext _localctx = new DdTagEndContext(_ctx, getState()); 7055 enterRule(_localctx, 56, RULE_ddTagEnd); 7056 int _la; 7057 try { 7058 enterOuterAlt(_localctx, 1); 7059 { 7060 setState(910); 7061 match(START); 7062 setState(911); 7063 match(SLASH); 7064 setState(912); 7065 match(DD_HTML_TAG_NAME); 7066 setState(916); 7067 _errHandler.sync(this); 7068 _la = _input.LA(1); 7069 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7070 { 7071 { 7072 setState(913); 7073 _la = _input.LA(1); 7074 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7075 _errHandler.recoverInline(this); 7076 } 7077 else { 7078 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 7079 _errHandler.reportMatch(this); 7080 consume(); 7081 } 7082 } 7083 } 7084 setState(918); 7085 _errHandler.sync(this); 7086 _la = _input.LA(1); 7087 } 7088 setState(919); 7089 match(END); 7090 } 7091 } 7092 catch (RecognitionException re) { 7093 _localctx.exception = re; 7094 _errHandler.reportError(this, re); 7095 _errHandler.recover(this, re); 7096 } 7097 finally { 7098 exitRule(); 7099 } 7100 return _localctx; 7101 } 7102 7103 public static class DdContext extends ParserRuleContext { 7104 public DdTagStartContext ddTagStart() { 7105 return getRuleContext(DdTagStartContext.class,0); 7106 } 7107 public DdTagEndContext ddTagEnd() { 7108 return getRuleContext(DdTagEndContext.class,0); 7109 } 7110 public List<HtmlTagContext> htmlTag() { 7111 return getRuleContexts(HtmlTagContext.class); 7112 } 7113 public HtmlTagContext htmlTag(int i) { 7114 return getRuleContext(HtmlTagContext.class,i); 7115 } 7116 public List<SingletonElementContext> singletonElement() { 7117 return getRuleContexts(SingletonElementContext.class); 7118 } 7119 public SingletonElementContext singletonElement(int i) { 7120 return getRuleContext(SingletonElementContext.class,i); 7121 } 7122 public List<ParagraphContext> paragraph() { 7123 return getRuleContexts(ParagraphContext.class); 7124 } 7125 public ParagraphContext paragraph(int i) { 7126 return getRuleContext(ParagraphContext.class,i); 7127 } 7128 public List<LiContext> li() { 7129 return getRuleContexts(LiContext.class); 7130 } 7131 public LiContext li(int i) { 7132 return getRuleContext(LiContext.class,i); 7133 } 7134 public List<TrContext> tr() { 7135 return getRuleContexts(TrContext.class); 7136 } 7137 public TrContext tr(int i) { 7138 return getRuleContext(TrContext.class,i); 7139 } 7140 public List<TdContext> td() { 7141 return getRuleContexts(TdContext.class); 7142 } 7143 public TdContext td(int i) { 7144 return getRuleContext(TdContext.class,i); 7145 } 7146 public List<ThContext> th() { 7147 return getRuleContexts(ThContext.class); 7148 } 7149 public ThContext th(int i) { 7150 return getRuleContext(ThContext.class,i); 7151 } 7152 public List<BodyContext> body() { 7153 return getRuleContexts(BodyContext.class); 7154 } 7155 public BodyContext body(int i) { 7156 return getRuleContext(BodyContext.class,i); 7157 } 7158 public List<ColgroupContext> colgroup() { 7159 return getRuleContexts(ColgroupContext.class); 7160 } 7161 public ColgroupContext colgroup(int i) { 7162 return getRuleContext(ColgroupContext.class,i); 7163 } 7164 public List<DtContext> dt() { 7165 return getRuleContexts(DtContext.class); 7166 } 7167 public DtContext dt(int i) { 7168 return getRuleContext(DtContext.class,i); 7169 } 7170 public List<HeadContext> head() { 7171 return getRuleContexts(HeadContext.class); 7172 } 7173 public HeadContext head(int i) { 7174 return getRuleContext(HeadContext.class,i); 7175 } 7176 public List<HtmlContext> html() { 7177 return getRuleContexts(HtmlContext.class); 7178 } 7179 public HtmlContext html(int i) { 7180 return getRuleContext(HtmlContext.class,i); 7181 } 7182 public List<OptionContext> option() { 7183 return getRuleContexts(OptionContext.class); 7184 } 7185 public OptionContext option(int i) { 7186 return getRuleContext(OptionContext.class,i); 7187 } 7188 public List<TbodyContext> tbody() { 7189 return getRuleContexts(TbodyContext.class); 7190 } 7191 public TbodyContext tbody(int i) { 7192 return getRuleContext(TbodyContext.class,i); 7193 } 7194 public List<TheadContext> thead() { 7195 return getRuleContexts(TheadContext.class); 7196 } 7197 public TheadContext thead(int i) { 7198 return getRuleContext(TheadContext.class,i); 7199 } 7200 public List<TfootContext> tfoot() { 7201 return getRuleContexts(TfootContext.class); 7202 } 7203 public TfootContext tfoot(int i) { 7204 return getRuleContext(TfootContext.class,i); 7205 } 7206 public List<OptgroupContext> optgroup() { 7207 return getRuleContexts(OptgroupContext.class); 7208 } 7209 public OptgroupContext optgroup(int i) { 7210 return getRuleContext(OptgroupContext.class,i); 7211 } 7212 public List<RbContext> rb() { 7213 return getRuleContexts(RbContext.class); 7214 } 7215 public RbContext rb(int i) { 7216 return getRuleContext(RbContext.class,i); 7217 } 7218 public List<RtContext> rt() { 7219 return getRuleContexts(RtContext.class); 7220 } 7221 public RtContext rt(int i) { 7222 return getRuleContext(RtContext.class,i); 7223 } 7224 public List<RtcContext> rtc() { 7225 return getRuleContexts(RtcContext.class); 7226 } 7227 public RtcContext rtc(int i) { 7228 return getRuleContext(RtcContext.class,i); 7229 } 7230 public List<RpContext> rp() { 7231 return getRuleContexts(RpContext.class); 7232 } 7233 public RpContext rp(int i) { 7234 return getRuleContext(RpContext.class,i); 7235 } 7236 public List<PTagStartContext> pTagStart() { 7237 return getRuleContexts(PTagStartContext.class); 7238 } 7239 public PTagStartContext pTagStart(int i) { 7240 return getRuleContext(PTagStartContext.class,i); 7241 } 7242 public List<LiTagStartContext> liTagStart() { 7243 return getRuleContexts(LiTagStartContext.class); 7244 } 7245 public LiTagStartContext liTagStart(int i) { 7246 return getRuleContext(LiTagStartContext.class,i); 7247 } 7248 public List<TrTagStartContext> trTagStart() { 7249 return getRuleContexts(TrTagStartContext.class); 7250 } 7251 public TrTagStartContext trTagStart(int i) { 7252 return getRuleContext(TrTagStartContext.class,i); 7253 } 7254 public List<TdTagStartContext> tdTagStart() { 7255 return getRuleContexts(TdTagStartContext.class); 7256 } 7257 public TdTagStartContext tdTagStart(int i) { 7258 return getRuleContext(TdTagStartContext.class,i); 7259 } 7260 public List<ThTagStartContext> thTagStart() { 7261 return getRuleContexts(ThTagStartContext.class); 7262 } 7263 public ThTagStartContext thTagStart(int i) { 7264 return getRuleContext(ThTagStartContext.class,i); 7265 } 7266 public List<BodyTagStartContext> bodyTagStart() { 7267 return getRuleContexts(BodyTagStartContext.class); 7268 } 7269 public BodyTagStartContext bodyTagStart(int i) { 7270 return getRuleContext(BodyTagStartContext.class,i); 7271 } 7272 public List<ColgroupTagStartContext> colgroupTagStart() { 7273 return getRuleContexts(ColgroupTagStartContext.class); 7274 } 7275 public ColgroupTagStartContext colgroupTagStart(int i) { 7276 return getRuleContext(ColgroupTagStartContext.class,i); 7277 } 7278 public List<DtTagStartContext> dtTagStart() { 7279 return getRuleContexts(DtTagStartContext.class); 7280 } 7281 public DtTagStartContext dtTagStart(int i) { 7282 return getRuleContext(DtTagStartContext.class,i); 7283 } 7284 public List<HeadTagStartContext> headTagStart() { 7285 return getRuleContexts(HeadTagStartContext.class); 7286 } 7287 public HeadTagStartContext headTagStart(int i) { 7288 return getRuleContext(HeadTagStartContext.class,i); 7289 } 7290 public List<HtmlTagStartContext> htmlTagStart() { 7291 return getRuleContexts(HtmlTagStartContext.class); 7292 } 7293 public HtmlTagStartContext htmlTagStart(int i) { 7294 return getRuleContext(HtmlTagStartContext.class,i); 7295 } 7296 public List<OptionTagStartContext> optionTagStart() { 7297 return getRuleContexts(OptionTagStartContext.class); 7298 } 7299 public OptionTagStartContext optionTagStart(int i) { 7300 return getRuleContext(OptionTagStartContext.class,i); 7301 } 7302 public List<TbodyTagStartContext> tbodyTagStart() { 7303 return getRuleContexts(TbodyTagStartContext.class); 7304 } 7305 public TbodyTagStartContext tbodyTagStart(int i) { 7306 return getRuleContext(TbodyTagStartContext.class,i); 7307 } 7308 public List<TheadTagStartContext> theadTagStart() { 7309 return getRuleContexts(TheadTagStartContext.class); 7310 } 7311 public TheadTagStartContext theadTagStart(int i) { 7312 return getRuleContext(TheadTagStartContext.class,i); 7313 } 7314 public List<TfootTagStartContext> tfootTagStart() { 7315 return getRuleContexts(TfootTagStartContext.class); 7316 } 7317 public TfootTagStartContext tfootTagStart(int i) { 7318 return getRuleContext(TfootTagStartContext.class,i); 7319 } 7320 public List<OptgroupTagStartContext> optgroupTagStart() { 7321 return getRuleContexts(OptgroupTagStartContext.class); 7322 } 7323 public OptgroupTagStartContext optgroupTagStart(int i) { 7324 return getRuleContext(OptgroupTagStartContext.class,i); 7325 } 7326 public List<RbTagStartContext> rbTagStart() { 7327 return getRuleContexts(RbTagStartContext.class); 7328 } 7329 public RbTagStartContext rbTagStart(int i) { 7330 return getRuleContext(RbTagStartContext.class,i); 7331 } 7332 public List<RtTagStartContext> rtTagStart() { 7333 return getRuleContexts(RtTagStartContext.class); 7334 } 7335 public RtTagStartContext rtTagStart(int i) { 7336 return getRuleContext(RtTagStartContext.class,i); 7337 } 7338 public List<RtcTagStartContext> rtcTagStart() { 7339 return getRuleContexts(RtcTagStartContext.class); 7340 } 7341 public RtcTagStartContext rtcTagStart(int i) { 7342 return getRuleContext(RtcTagStartContext.class,i); 7343 } 7344 public List<RpTagStartContext> rpTagStart() { 7345 return getRuleContexts(RpTagStartContext.class); 7346 } 7347 public RpTagStartContext rpTagStart(int i) { 7348 return getRuleContext(RpTagStartContext.class,i); 7349 } 7350 public List<HtmlCommentContext> htmlComment() { 7351 return getRuleContexts(HtmlCommentContext.class); 7352 } 7353 public HtmlCommentContext htmlComment(int i) { 7354 return getRuleContext(HtmlCommentContext.class,i); 7355 } 7356 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 7357 public TerminalNode CDATA(int i) { 7358 return getToken(JavadocParser.CDATA, i); 7359 } 7360 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7361 public TerminalNode NEWLINE(int i) { 7362 return getToken(JavadocParser.NEWLINE, i); 7363 } 7364 public List<TextContext> text() { 7365 return getRuleContexts(TextContext.class); 7366 } 7367 public TextContext text(int i) { 7368 return getRuleContext(TextContext.class,i); 7369 } 7370 public List<JavadocInlineTagContext> javadocInlineTag() { 7371 return getRuleContexts(JavadocInlineTagContext.class); 7372 } 7373 public JavadocInlineTagContext javadocInlineTag(int i) { 7374 return getRuleContext(JavadocInlineTagContext.class,i); 7375 } 7376 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7377 public TerminalNode LEADING_ASTERISK(int i) { 7378 return getToken(JavadocParser.LEADING_ASTERISK, i); 7379 } 7380 public DdContext(ParserRuleContext parent, int invokingState) { 7381 super(parent, invokingState); 7382 } 7383 @Override public int getRuleIndex() { return RULE_dd; } 7384 } 7385 7386 public final DdContext dd() throws RecognitionException { 7387 DdContext _localctx = new DdContext(_ctx, getState()); 7388 enterRule(_localctx, 58, RULE_dd); 7389 try { 7390 int _alt; 7391 enterOuterAlt(_localctx, 1); 7392 { 7393 setState(921); 7394 ddTagStart(false); 7395 setState(971); 7396 _errHandler.sync(this); 7397 _alt = getInterpreter().adaptivePredict(_input,53,_ctx); 7398 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 7399 if ( _alt==1 ) { 7400 { 7401 setState(969); 7402 _errHandler.sync(this); 7403 switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) { 7404 case 1: 7405 { 7406 setState(922); 7407 htmlTag(); 7408 } 7409 break; 7410 case 2: 7411 { 7412 setState(923); 7413 singletonElement(); 7414 } 7415 break; 7416 case 3: 7417 { 7418 setState(924); 7419 paragraph(); 7420 } 7421 break; 7422 case 4: 7423 { 7424 setState(925); 7425 li(); 7426 } 7427 break; 7428 case 5: 7429 { 7430 setState(926); 7431 tr(); 7432 } 7433 break; 7434 case 6: 7435 { 7436 setState(927); 7437 td(); 7438 } 7439 break; 7440 case 7: 7441 { 7442 setState(928); 7443 th(); 7444 } 7445 break; 7446 case 8: 7447 { 7448 setState(929); 7449 body(); 7450 } 7451 break; 7452 case 9: 7453 { 7454 setState(930); 7455 colgroup(); 7456 } 7457 break; 7458 case 10: 7459 { 7460 setState(931); 7461 dt(); 7462 } 7463 break; 7464 case 11: 7465 { 7466 setState(932); 7467 head(); 7468 } 7469 break; 7470 case 12: 7471 { 7472 setState(933); 7473 html(); 7474 } 7475 break; 7476 case 13: 7477 { 7478 setState(934); 7479 option(); 7480 } 7481 break; 7482 case 14: 7483 { 7484 setState(935); 7485 tbody(); 7486 } 7487 break; 7488 case 15: 7489 { 7490 setState(936); 7491 thead(); 7492 } 7493 break; 7494 case 16: 7495 { 7496 setState(937); 7497 tfoot(); 7498 } 7499 break; 7500 case 17: 7501 { 7502 setState(938); 7503 optgroup(); 7504 } 7505 break; 7506 case 18: 7507 { 7508 setState(939); 7509 rb(); 7510 } 7511 break; 7512 case 19: 7513 { 7514 setState(940); 7515 rt(); 7516 } 7517 break; 7518 case 20: 7519 { 7520 setState(941); 7521 rtc(); 7522 } 7523 break; 7524 case 21: 7525 { 7526 setState(942); 7527 rp(); 7528 } 7529 break; 7530 case 22: 7531 { 7532 setState(943); 7533 pTagStart(true); 7534 } 7535 break; 7536 case 23: 7537 { 7538 setState(944); 7539 liTagStart(true); 7540 } 7541 break; 7542 case 24: 7543 { 7544 setState(945); 7545 trTagStart(true); 7546 } 7547 break; 7548 case 25: 7549 { 7550 setState(946); 7551 tdTagStart(true); 7552 } 7553 break; 7554 case 26: 7555 { 7556 setState(947); 7557 thTagStart(true); 7558 } 7559 break; 7560 case 27: 7561 { 7562 setState(948); 7563 bodyTagStart(true); 7564 } 7565 break; 7566 case 28: 7567 { 7568 setState(949); 7569 colgroupTagStart(true); 7570 } 7571 break; 7572 case 29: 7573 { 7574 setState(950); 7575 dtTagStart(true); 7576 } 7577 break; 7578 case 30: 7579 { 7580 setState(951); 7581 headTagStart(true); 7582 } 7583 break; 7584 case 31: 7585 { 7586 setState(952); 7587 htmlTagStart(true); 7588 } 7589 break; 7590 case 32: 7591 { 7592 setState(953); 7593 optionTagStart(true); 7594 } 7595 break; 7596 case 33: 7597 { 7598 setState(954); 7599 tbodyTagStart(true); 7600 } 7601 break; 7602 case 34: 7603 { 7604 setState(955); 7605 theadTagStart(true); 7606 } 7607 break; 7608 case 35: 7609 { 7610 setState(956); 7611 tfootTagStart(true); 7612 } 7613 break; 7614 case 36: 7615 { 7616 setState(957); 7617 optgroupTagStart(true); 7618 } 7619 break; 7620 case 37: 7621 { 7622 setState(958); 7623 rbTagStart(true); 7624 } 7625 break; 7626 case 38: 7627 { 7628 setState(959); 7629 rtTagStart(true); 7630 } 7631 break; 7632 case 39: 7633 { 7634 setState(960); 7635 rtcTagStart(true); 7636 } 7637 break; 7638 case 40: 7639 { 7640 setState(961); 7641 rpTagStart(true); 7642 } 7643 break; 7644 case 41: 7645 { 7646 { 7647 setState(962); 7648 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 7649 setState(963); 7650 match(LEADING_ASTERISK); 7651 } 7652 } 7653 break; 7654 case 42: 7655 { 7656 setState(964); 7657 htmlComment(); 7658 } 7659 break; 7660 case 43: 7661 { 7662 setState(965); 7663 match(CDATA); 7664 } 7665 break; 7666 case 44: 7667 { 7668 setState(966); 7669 match(NEWLINE); 7670 } 7671 break; 7672 case 45: 7673 { 7674 setState(967); 7675 text(); 7676 } 7677 break; 7678 case 46: 7679 { 7680 setState(968); 7681 javadocInlineTag(); 7682 } 7683 break; 7684 } 7685 } 7686 } 7687 setState(973); 7688 _errHandler.sync(this); 7689 _alt = getInterpreter().adaptivePredict(_input,53,_ctx); 7690 } 7691 setState(974); 7692 ddTagEnd(); 7693 } 7694 } 7695 catch (RecognitionException re) { 7696 _localctx.exception = re; 7697 _errHandler.reportError(this, re); 7698 _errHandler.recover(this, re); 7699 } 7700 finally { 7701 exitRule(); 7702 } 7703 return _localctx; 7704 } 7705 7706 public static class DtTagStartContext extends ParserRuleContext { 7707 public boolean isNonTight; 7708 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 7709 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 7710 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 7711 public List<AttributeContext> attribute() { 7712 return getRuleContexts(AttributeContext.class); 7713 } 7714 public AttributeContext attribute(int i) { 7715 return getRuleContext(AttributeContext.class,i); 7716 } 7717 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7718 public TerminalNode NEWLINE(int i) { 7719 return getToken(JavadocParser.NEWLINE, i); 7720 } 7721 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7722 public TerminalNode LEADING_ASTERISK(int i) { 7723 return getToken(JavadocParser.LEADING_ASTERISK, i); 7724 } 7725 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7726 public TerminalNode WS(int i) { 7727 return getToken(JavadocParser.WS, i); 7728 } 7729 public DtTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 7730 public DtTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 7731 super(parent, invokingState); 7732 this.isNonTight = isNonTight; 7733 } 7734 @Override public int getRuleIndex() { return RULE_dtTagStart; } 7735 } 7736 7737 public final DtTagStartContext dtTagStart(boolean isNonTight) throws RecognitionException { 7738 DtTagStartContext _localctx = new DtTagStartContext(_ctx, getState(), isNonTight); 7739 enterRule(_localctx, 60, RULE_dtTagStart); 7740 int _la; 7741 try { 7742 enterOuterAlt(_localctx, 1); 7743 { 7744 setState(976); 7745 match(START); 7746 setState(977); 7747 match(DT_HTML_TAG_NAME); 7748 setState(984); 7749 _errHandler.sync(this); 7750 _la = _input.LA(1); 7751 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 7752 { 7753 setState(982); 7754 _errHandler.sync(this); 7755 switch (_input.LA(1)) { 7756 case HTML_TAG_NAME: 7757 { 7758 setState(978); 7759 attribute(); 7760 } 7761 break; 7762 case NEWLINE: 7763 { 7764 setState(979); 7765 match(NEWLINE); 7766 } 7767 break; 7768 case LEADING_ASTERISK: 7769 { 7770 setState(980); 7771 match(LEADING_ASTERISK); 7772 } 7773 break; 7774 case WS: 7775 { 7776 setState(981); 7777 match(WS); 7778 } 7779 break; 7780 default: 7781 throw new NoViableAltException(this); 7782 } 7783 } 7784 setState(986); 7785 _errHandler.sync(this); 7786 _la = _input.LA(1); 7787 } 7788 setState(987); 7789 match(END); 7790 } 7791 _ctx.stop = _input.LT(-1); 7792 7793 if (isNonTight && nonTightTagStartContext == null) { 7794 nonTightTagStartContext = _localctx; 7795 } 7796 7797 } 7798 catch (RecognitionException re) { 7799 _localctx.exception = re; 7800 _errHandler.reportError(this, re); 7801 _errHandler.recover(this, re); 7802 } 7803 finally { 7804 exitRule(); 7805 } 7806 return _localctx; 7807 } 7808 7809 public static class DtTagEndContext extends ParserRuleContext { 7810 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 7811 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7812 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 7813 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 7814 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7815 public TerminalNode NEWLINE(int i) { 7816 return getToken(JavadocParser.NEWLINE, i); 7817 } 7818 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7819 public TerminalNode LEADING_ASTERISK(int i) { 7820 return getToken(JavadocParser.LEADING_ASTERISK, i); 7821 } 7822 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7823 public TerminalNode WS(int i) { 7824 return getToken(JavadocParser.WS, i); 7825 } 7826 public DtTagEndContext(ParserRuleContext parent, int invokingState) { 7827 super(parent, invokingState); 7828 } 7829 @Override public int getRuleIndex() { return RULE_dtTagEnd; } 7830 } 7831 7832 public final DtTagEndContext dtTagEnd() throws RecognitionException { 7833 DtTagEndContext _localctx = new DtTagEndContext(_ctx, getState()); 7834 enterRule(_localctx, 62, RULE_dtTagEnd); 7835 int _la; 7836 try { 7837 enterOuterAlt(_localctx, 1); 7838 { 7839 setState(989); 7840 match(START); 7841 setState(990); 7842 match(SLASH); 7843 setState(991); 7844 match(DT_HTML_TAG_NAME); 7845 setState(995); 7846 _errHandler.sync(this); 7847 _la = _input.LA(1); 7848 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7849 { 7850 { 7851 setState(992); 7852 _la = _input.LA(1); 7853 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7854 _errHandler.recoverInline(this); 7855 } 7856 else { 7857 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 7858 _errHandler.reportMatch(this); 7859 consume(); 7860 } 7861 } 7862 } 7863 setState(997); 7864 _errHandler.sync(this); 7865 _la = _input.LA(1); 7866 } 7867 setState(998); 7868 match(END); 7869 } 7870 } 7871 catch (RecognitionException re) { 7872 _localctx.exception = re; 7873 _errHandler.reportError(this, re); 7874 _errHandler.recover(this, re); 7875 } 7876 finally { 7877 exitRule(); 7878 } 7879 return _localctx; 7880 } 7881 7882 public static class DtContext extends ParserRuleContext { 7883 public DtTagStartContext dtTagStart() { 7884 return getRuleContext(DtTagStartContext.class,0); 7885 } 7886 public DtTagEndContext dtTagEnd() { 7887 return getRuleContext(DtTagEndContext.class,0); 7888 } 7889 public List<HtmlTagContext> htmlTag() { 7890 return getRuleContexts(HtmlTagContext.class); 7891 } 7892 public HtmlTagContext htmlTag(int i) { 7893 return getRuleContext(HtmlTagContext.class,i); 7894 } 7895 public List<SingletonElementContext> singletonElement() { 7896 return getRuleContexts(SingletonElementContext.class); 7897 } 7898 public SingletonElementContext singletonElement(int i) { 7899 return getRuleContext(SingletonElementContext.class,i); 7900 } 7901 public List<ParagraphContext> paragraph() { 7902 return getRuleContexts(ParagraphContext.class); 7903 } 7904 public ParagraphContext paragraph(int i) { 7905 return getRuleContext(ParagraphContext.class,i); 7906 } 7907 public List<LiContext> li() { 7908 return getRuleContexts(LiContext.class); 7909 } 7910 public LiContext li(int i) { 7911 return getRuleContext(LiContext.class,i); 7912 } 7913 public List<TrContext> tr() { 7914 return getRuleContexts(TrContext.class); 7915 } 7916 public TrContext tr(int i) { 7917 return getRuleContext(TrContext.class,i); 7918 } 7919 public List<TdContext> td() { 7920 return getRuleContexts(TdContext.class); 7921 } 7922 public TdContext td(int i) { 7923 return getRuleContext(TdContext.class,i); 7924 } 7925 public List<ThContext> th() { 7926 return getRuleContexts(ThContext.class); 7927 } 7928 public ThContext th(int i) { 7929 return getRuleContext(ThContext.class,i); 7930 } 7931 public List<BodyContext> body() { 7932 return getRuleContexts(BodyContext.class); 7933 } 7934 public BodyContext body(int i) { 7935 return getRuleContext(BodyContext.class,i); 7936 } 7937 public List<ColgroupContext> colgroup() { 7938 return getRuleContexts(ColgroupContext.class); 7939 } 7940 public ColgroupContext colgroup(int i) { 7941 return getRuleContext(ColgroupContext.class,i); 7942 } 7943 public List<DdContext> dd() { 7944 return getRuleContexts(DdContext.class); 7945 } 7946 public DdContext dd(int i) { 7947 return getRuleContext(DdContext.class,i); 7948 } 7949 public List<HeadContext> head() { 7950 return getRuleContexts(HeadContext.class); 7951 } 7952 public HeadContext head(int i) { 7953 return getRuleContext(HeadContext.class,i); 7954 } 7955 public List<HtmlContext> html() { 7956 return getRuleContexts(HtmlContext.class); 7957 } 7958 public HtmlContext html(int i) { 7959 return getRuleContext(HtmlContext.class,i); 7960 } 7961 public List<OptionContext> option() { 7962 return getRuleContexts(OptionContext.class); 7963 } 7964 public OptionContext option(int i) { 7965 return getRuleContext(OptionContext.class,i); 7966 } 7967 public List<TbodyContext> tbody() { 7968 return getRuleContexts(TbodyContext.class); 7969 } 7970 public TbodyContext tbody(int i) { 7971 return getRuleContext(TbodyContext.class,i); 7972 } 7973 public List<TheadContext> thead() { 7974 return getRuleContexts(TheadContext.class); 7975 } 7976 public TheadContext thead(int i) { 7977 return getRuleContext(TheadContext.class,i); 7978 } 7979 public List<TfootContext> tfoot() { 7980 return getRuleContexts(TfootContext.class); 7981 } 7982 public TfootContext tfoot(int i) { 7983 return getRuleContext(TfootContext.class,i); 7984 } 7985 public List<OptgroupContext> optgroup() { 7986 return getRuleContexts(OptgroupContext.class); 7987 } 7988 public OptgroupContext optgroup(int i) { 7989 return getRuleContext(OptgroupContext.class,i); 7990 } 7991 public List<RbContext> rb() { 7992 return getRuleContexts(RbContext.class); 7993 } 7994 public RbContext rb(int i) { 7995 return getRuleContext(RbContext.class,i); 7996 } 7997 public List<RtContext> rt() { 7998 return getRuleContexts(RtContext.class); 7999 } 8000 public RtContext rt(int i) { 8001 return getRuleContext(RtContext.class,i); 8002 } 8003 public List<RtcContext> rtc() { 8004 return getRuleContexts(RtcContext.class); 8005 } 8006 public RtcContext rtc(int i) { 8007 return getRuleContext(RtcContext.class,i); 8008 } 8009 public List<RpContext> rp() { 8010 return getRuleContexts(RpContext.class); 8011 } 8012 public RpContext rp(int i) { 8013 return getRuleContext(RpContext.class,i); 8014 } 8015 public List<PTagStartContext> pTagStart() { 8016 return getRuleContexts(PTagStartContext.class); 8017 } 8018 public PTagStartContext pTagStart(int i) { 8019 return getRuleContext(PTagStartContext.class,i); 8020 } 8021 public List<LiTagStartContext> liTagStart() { 8022 return getRuleContexts(LiTagStartContext.class); 8023 } 8024 public LiTagStartContext liTagStart(int i) { 8025 return getRuleContext(LiTagStartContext.class,i); 8026 } 8027 public List<TrTagStartContext> trTagStart() { 8028 return getRuleContexts(TrTagStartContext.class); 8029 } 8030 public TrTagStartContext trTagStart(int i) { 8031 return getRuleContext(TrTagStartContext.class,i); 8032 } 8033 public List<TdTagStartContext> tdTagStart() { 8034 return getRuleContexts(TdTagStartContext.class); 8035 } 8036 public TdTagStartContext tdTagStart(int i) { 8037 return getRuleContext(TdTagStartContext.class,i); 8038 } 8039 public List<ThTagStartContext> thTagStart() { 8040 return getRuleContexts(ThTagStartContext.class); 8041 } 8042 public ThTagStartContext thTagStart(int i) { 8043 return getRuleContext(ThTagStartContext.class,i); 8044 } 8045 public List<BodyTagStartContext> bodyTagStart() { 8046 return getRuleContexts(BodyTagStartContext.class); 8047 } 8048 public BodyTagStartContext bodyTagStart(int i) { 8049 return getRuleContext(BodyTagStartContext.class,i); 8050 } 8051 public List<ColgroupTagStartContext> colgroupTagStart() { 8052 return getRuleContexts(ColgroupTagStartContext.class); 8053 } 8054 public ColgroupTagStartContext colgroupTagStart(int i) { 8055 return getRuleContext(ColgroupTagStartContext.class,i); 8056 } 8057 public List<DdTagStartContext> ddTagStart() { 8058 return getRuleContexts(DdTagStartContext.class); 8059 } 8060 public DdTagStartContext ddTagStart(int i) { 8061 return getRuleContext(DdTagStartContext.class,i); 8062 } 8063 public List<HeadTagStartContext> headTagStart() { 8064 return getRuleContexts(HeadTagStartContext.class); 8065 } 8066 public HeadTagStartContext headTagStart(int i) { 8067 return getRuleContext(HeadTagStartContext.class,i); 8068 } 8069 public List<HtmlTagStartContext> htmlTagStart() { 8070 return getRuleContexts(HtmlTagStartContext.class); 8071 } 8072 public HtmlTagStartContext htmlTagStart(int i) { 8073 return getRuleContext(HtmlTagStartContext.class,i); 8074 } 8075 public List<OptionTagStartContext> optionTagStart() { 8076 return getRuleContexts(OptionTagStartContext.class); 8077 } 8078 public OptionTagStartContext optionTagStart(int i) { 8079 return getRuleContext(OptionTagStartContext.class,i); 8080 } 8081 public List<TbodyTagStartContext> tbodyTagStart() { 8082 return getRuleContexts(TbodyTagStartContext.class); 8083 } 8084 public TbodyTagStartContext tbodyTagStart(int i) { 8085 return getRuleContext(TbodyTagStartContext.class,i); 8086 } 8087 public List<TheadTagStartContext> theadTagStart() { 8088 return getRuleContexts(TheadTagStartContext.class); 8089 } 8090 public TheadTagStartContext theadTagStart(int i) { 8091 return getRuleContext(TheadTagStartContext.class,i); 8092 } 8093 public List<TfootTagStartContext> tfootTagStart() { 8094 return getRuleContexts(TfootTagStartContext.class); 8095 } 8096 public TfootTagStartContext tfootTagStart(int i) { 8097 return getRuleContext(TfootTagStartContext.class,i); 8098 } 8099 public List<OptgroupTagStartContext> optgroupTagStart() { 8100 return getRuleContexts(OptgroupTagStartContext.class); 8101 } 8102 public OptgroupTagStartContext optgroupTagStart(int i) { 8103 return getRuleContext(OptgroupTagStartContext.class,i); 8104 } 8105 public List<RbTagStartContext> rbTagStart() { 8106 return getRuleContexts(RbTagStartContext.class); 8107 } 8108 public RbTagStartContext rbTagStart(int i) { 8109 return getRuleContext(RbTagStartContext.class,i); 8110 } 8111 public List<RtTagStartContext> rtTagStart() { 8112 return getRuleContexts(RtTagStartContext.class); 8113 } 8114 public RtTagStartContext rtTagStart(int i) { 8115 return getRuleContext(RtTagStartContext.class,i); 8116 } 8117 public List<RtcTagStartContext> rtcTagStart() { 8118 return getRuleContexts(RtcTagStartContext.class); 8119 } 8120 public RtcTagStartContext rtcTagStart(int i) { 8121 return getRuleContext(RtcTagStartContext.class,i); 8122 } 8123 public List<RpTagStartContext> rpTagStart() { 8124 return getRuleContexts(RpTagStartContext.class); 8125 } 8126 public RpTagStartContext rpTagStart(int i) { 8127 return getRuleContext(RpTagStartContext.class,i); 8128 } 8129 public List<HtmlCommentContext> htmlComment() { 8130 return getRuleContexts(HtmlCommentContext.class); 8131 } 8132 public HtmlCommentContext htmlComment(int i) { 8133 return getRuleContext(HtmlCommentContext.class,i); 8134 } 8135 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 8136 public TerminalNode CDATA(int i) { 8137 return getToken(JavadocParser.CDATA, i); 8138 } 8139 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8140 public TerminalNode NEWLINE(int i) { 8141 return getToken(JavadocParser.NEWLINE, i); 8142 } 8143 public List<TextContext> text() { 8144 return getRuleContexts(TextContext.class); 8145 } 8146 public TextContext text(int i) { 8147 return getRuleContext(TextContext.class,i); 8148 } 8149 public List<JavadocInlineTagContext> javadocInlineTag() { 8150 return getRuleContexts(JavadocInlineTagContext.class); 8151 } 8152 public JavadocInlineTagContext javadocInlineTag(int i) { 8153 return getRuleContext(JavadocInlineTagContext.class,i); 8154 } 8155 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8156 public TerminalNode LEADING_ASTERISK(int i) { 8157 return getToken(JavadocParser.LEADING_ASTERISK, i); 8158 } 8159 public DtContext(ParserRuleContext parent, int invokingState) { 8160 super(parent, invokingState); 8161 } 8162 @Override public int getRuleIndex() { return RULE_dt; } 8163 } 8164 8165 public final DtContext dt() throws RecognitionException { 8166 DtContext _localctx = new DtContext(_ctx, getState()); 8167 enterRule(_localctx, 64, RULE_dt); 8168 try { 8169 int _alt; 8170 enterOuterAlt(_localctx, 1); 8171 { 8172 setState(1000); 8173 dtTagStart(false); 8174 setState(1050); 8175 _errHandler.sync(this); 8176 _alt = getInterpreter().adaptivePredict(_input,58,_ctx); 8177 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8178 if ( _alt==1 ) { 8179 { 8180 setState(1048); 8181 _errHandler.sync(this); 8182 switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) { 8183 case 1: 8184 { 8185 setState(1001); 8186 htmlTag(); 8187 } 8188 break; 8189 case 2: 8190 { 8191 setState(1002); 8192 singletonElement(); 8193 } 8194 break; 8195 case 3: 8196 { 8197 setState(1003); 8198 paragraph(); 8199 } 8200 break; 8201 case 4: 8202 { 8203 setState(1004); 8204 li(); 8205 } 8206 break; 8207 case 5: 8208 { 8209 setState(1005); 8210 tr(); 8211 } 8212 break; 8213 case 6: 8214 { 8215 setState(1006); 8216 td(); 8217 } 8218 break; 8219 case 7: 8220 { 8221 setState(1007); 8222 th(); 8223 } 8224 break; 8225 case 8: 8226 { 8227 setState(1008); 8228 body(); 8229 } 8230 break; 8231 case 9: 8232 { 8233 setState(1009); 8234 colgroup(); 8235 } 8236 break; 8237 case 10: 8238 { 8239 setState(1010); 8240 dd(); 8241 } 8242 break; 8243 case 11: 8244 { 8245 setState(1011); 8246 head(); 8247 } 8248 break; 8249 case 12: 8250 { 8251 setState(1012); 8252 html(); 8253 } 8254 break; 8255 case 13: 8256 { 8257 setState(1013); 8258 option(); 8259 } 8260 break; 8261 case 14: 8262 { 8263 setState(1014); 8264 tbody(); 8265 } 8266 break; 8267 case 15: 8268 { 8269 setState(1015); 8270 thead(); 8271 } 8272 break; 8273 case 16: 8274 { 8275 setState(1016); 8276 tfoot(); 8277 } 8278 break; 8279 case 17: 8280 { 8281 setState(1017); 8282 optgroup(); 8283 } 8284 break; 8285 case 18: 8286 { 8287 setState(1018); 8288 rb(); 8289 } 8290 break; 8291 case 19: 8292 { 8293 setState(1019); 8294 rt(); 8295 } 8296 break; 8297 case 20: 8298 { 8299 setState(1020); 8300 rtc(); 8301 } 8302 break; 8303 case 21: 8304 { 8305 setState(1021); 8306 rp(); 8307 } 8308 break; 8309 case 22: 8310 { 8311 setState(1022); 8312 pTagStart(true); 8313 } 8314 break; 8315 case 23: 8316 { 8317 setState(1023); 8318 liTagStart(true); 8319 } 8320 break; 8321 case 24: 8322 { 8323 setState(1024); 8324 trTagStart(true); 8325 } 8326 break; 8327 case 25: 8328 { 8329 setState(1025); 8330 tdTagStart(true); 8331 } 8332 break; 8333 case 26: 8334 { 8335 setState(1026); 8336 thTagStart(true); 8337 } 8338 break; 8339 case 27: 8340 { 8341 setState(1027); 8342 bodyTagStart(true); 8343 } 8344 break; 8345 case 28: 8346 { 8347 setState(1028); 8348 colgroupTagStart(true); 8349 } 8350 break; 8351 case 29: 8352 { 8353 setState(1029); 8354 ddTagStart(true); 8355 } 8356 break; 8357 case 30: 8358 { 8359 setState(1030); 8360 headTagStart(true); 8361 } 8362 break; 8363 case 31: 8364 { 8365 setState(1031); 8366 htmlTagStart(true); 8367 } 8368 break; 8369 case 32: 8370 { 8371 setState(1032); 8372 optionTagStart(true); 8373 } 8374 break; 8375 case 33: 8376 { 8377 setState(1033); 8378 tbodyTagStart(true); 8379 } 8380 break; 8381 case 34: 8382 { 8383 setState(1034); 8384 theadTagStart(true); 8385 } 8386 break; 8387 case 35: 8388 { 8389 setState(1035); 8390 tfootTagStart(true); 8391 } 8392 break; 8393 case 36: 8394 { 8395 setState(1036); 8396 optgroupTagStart(true); 8397 } 8398 break; 8399 case 37: 8400 { 8401 setState(1037); 8402 rbTagStart(true); 8403 } 8404 break; 8405 case 38: 8406 { 8407 setState(1038); 8408 rtTagStart(true); 8409 } 8410 break; 8411 case 39: 8412 { 8413 setState(1039); 8414 rtcTagStart(true); 8415 } 8416 break; 8417 case 40: 8418 { 8419 setState(1040); 8420 rpTagStart(true); 8421 } 8422 break; 8423 case 41: 8424 { 8425 { 8426 setState(1041); 8427 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8428 setState(1042); 8429 match(LEADING_ASTERISK); 8430 } 8431 } 8432 break; 8433 case 42: 8434 { 8435 setState(1043); 8436 htmlComment(); 8437 } 8438 break; 8439 case 43: 8440 { 8441 setState(1044); 8442 match(CDATA); 8443 } 8444 break; 8445 case 44: 8446 { 8447 setState(1045); 8448 match(NEWLINE); 8449 } 8450 break; 8451 case 45: 8452 { 8453 setState(1046); 8454 text(); 8455 } 8456 break; 8457 case 46: 8458 { 8459 setState(1047); 8460 javadocInlineTag(); 8461 } 8462 break; 8463 } 8464 } 8465 } 8466 setState(1052); 8467 _errHandler.sync(this); 8468 _alt = getInterpreter().adaptivePredict(_input,58,_ctx); 8469 } 8470 setState(1053); 8471 dtTagEnd(); 8472 } 8473 } 8474 catch (RecognitionException re) { 8475 _localctx.exception = re; 8476 _errHandler.reportError(this, re); 8477 _errHandler.recover(this, re); 8478 } 8479 finally { 8480 exitRule(); 8481 } 8482 return _localctx; 8483 } 8484 8485 public static class HeadTagStartContext extends ParserRuleContext { 8486 public boolean isNonTight; 8487 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 8488 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 8489 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 8490 public List<AttributeContext> attribute() { 8491 return getRuleContexts(AttributeContext.class); 8492 } 8493 public AttributeContext attribute(int i) { 8494 return getRuleContext(AttributeContext.class,i); 8495 } 8496 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8497 public TerminalNode NEWLINE(int i) { 8498 return getToken(JavadocParser.NEWLINE, i); 8499 } 8500 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8501 public TerminalNode LEADING_ASTERISK(int i) { 8502 return getToken(JavadocParser.LEADING_ASTERISK, i); 8503 } 8504 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8505 public TerminalNode WS(int i) { 8506 return getToken(JavadocParser.WS, i); 8507 } 8508 public HeadTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 8509 public HeadTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 8510 super(parent, invokingState); 8511 this.isNonTight = isNonTight; 8512 } 8513 @Override public int getRuleIndex() { return RULE_headTagStart; } 8514 } 8515 8516 public final HeadTagStartContext headTagStart(boolean isNonTight) throws RecognitionException { 8517 HeadTagStartContext _localctx = new HeadTagStartContext(_ctx, getState(), isNonTight); 8518 enterRule(_localctx, 66, RULE_headTagStart); 8519 int _la; 8520 try { 8521 enterOuterAlt(_localctx, 1); 8522 { 8523 setState(1055); 8524 match(START); 8525 setState(1056); 8526 match(HEAD_HTML_TAG_NAME); 8527 setState(1063); 8528 _errHandler.sync(this); 8529 _la = _input.LA(1); 8530 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 8531 { 8532 setState(1061); 8533 _errHandler.sync(this); 8534 switch (_input.LA(1)) { 8535 case HTML_TAG_NAME: 8536 { 8537 setState(1057); 8538 attribute(); 8539 } 8540 break; 8541 case NEWLINE: 8542 { 8543 setState(1058); 8544 match(NEWLINE); 8545 } 8546 break; 8547 case LEADING_ASTERISK: 8548 { 8549 setState(1059); 8550 match(LEADING_ASTERISK); 8551 } 8552 break; 8553 case WS: 8554 { 8555 setState(1060); 8556 match(WS); 8557 } 8558 break; 8559 default: 8560 throw new NoViableAltException(this); 8561 } 8562 } 8563 setState(1065); 8564 _errHandler.sync(this); 8565 _la = _input.LA(1); 8566 } 8567 setState(1066); 8568 match(END); 8569 } 8570 _ctx.stop = _input.LT(-1); 8571 8572 if (isNonTight && nonTightTagStartContext == null) { 8573 nonTightTagStartContext = _localctx; 8574 } 8575 8576 } 8577 catch (RecognitionException re) { 8578 _localctx.exception = re; 8579 _errHandler.reportError(this, re); 8580 _errHandler.recover(this, re); 8581 } 8582 finally { 8583 exitRule(); 8584 } 8585 return _localctx; 8586 } 8587 8588 public static class HeadTagEndContext extends ParserRuleContext { 8589 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 8590 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 8591 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 8592 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 8593 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8594 public TerminalNode NEWLINE(int i) { 8595 return getToken(JavadocParser.NEWLINE, i); 8596 } 8597 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8598 public TerminalNode LEADING_ASTERISK(int i) { 8599 return getToken(JavadocParser.LEADING_ASTERISK, i); 8600 } 8601 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8602 public TerminalNode WS(int i) { 8603 return getToken(JavadocParser.WS, i); 8604 } 8605 public HeadTagEndContext(ParserRuleContext parent, int invokingState) { 8606 super(parent, invokingState); 8607 } 8608 @Override public int getRuleIndex() { return RULE_headTagEnd; } 8609 } 8610 8611 public final HeadTagEndContext headTagEnd() throws RecognitionException { 8612 HeadTagEndContext _localctx = new HeadTagEndContext(_ctx, getState()); 8613 enterRule(_localctx, 68, RULE_headTagEnd); 8614 int _la; 8615 try { 8616 enterOuterAlt(_localctx, 1); 8617 { 8618 setState(1068); 8619 match(START); 8620 setState(1069); 8621 match(SLASH); 8622 setState(1070); 8623 match(HEAD_HTML_TAG_NAME); 8624 setState(1074); 8625 _errHandler.sync(this); 8626 _la = _input.LA(1); 8627 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 8628 { 8629 { 8630 setState(1071); 8631 _la = _input.LA(1); 8632 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 8633 _errHandler.recoverInline(this); 8634 } 8635 else { 8636 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 8637 _errHandler.reportMatch(this); 8638 consume(); 8639 } 8640 } 8641 } 8642 setState(1076); 8643 _errHandler.sync(this); 8644 _la = _input.LA(1); 8645 } 8646 setState(1077); 8647 match(END); 8648 } 8649 } 8650 catch (RecognitionException re) { 8651 _localctx.exception = re; 8652 _errHandler.reportError(this, re); 8653 _errHandler.recover(this, re); 8654 } 8655 finally { 8656 exitRule(); 8657 } 8658 return _localctx; 8659 } 8660 8661 public static class HeadContext extends ParserRuleContext { 8662 public HeadTagStartContext headTagStart() { 8663 return getRuleContext(HeadTagStartContext.class,0); 8664 } 8665 public HeadTagEndContext headTagEnd() { 8666 return getRuleContext(HeadTagEndContext.class,0); 8667 } 8668 public List<HtmlTagContext> htmlTag() { 8669 return getRuleContexts(HtmlTagContext.class); 8670 } 8671 public HtmlTagContext htmlTag(int i) { 8672 return getRuleContext(HtmlTagContext.class,i); 8673 } 8674 public List<SingletonElementContext> singletonElement() { 8675 return getRuleContexts(SingletonElementContext.class); 8676 } 8677 public SingletonElementContext singletonElement(int i) { 8678 return getRuleContext(SingletonElementContext.class,i); 8679 } 8680 public List<ParagraphContext> paragraph() { 8681 return getRuleContexts(ParagraphContext.class); 8682 } 8683 public ParagraphContext paragraph(int i) { 8684 return getRuleContext(ParagraphContext.class,i); 8685 } 8686 public List<LiContext> li() { 8687 return getRuleContexts(LiContext.class); 8688 } 8689 public LiContext li(int i) { 8690 return getRuleContext(LiContext.class,i); 8691 } 8692 public List<TrContext> tr() { 8693 return getRuleContexts(TrContext.class); 8694 } 8695 public TrContext tr(int i) { 8696 return getRuleContext(TrContext.class,i); 8697 } 8698 public List<TdContext> td() { 8699 return getRuleContexts(TdContext.class); 8700 } 8701 public TdContext td(int i) { 8702 return getRuleContext(TdContext.class,i); 8703 } 8704 public List<ThContext> th() { 8705 return getRuleContexts(ThContext.class); 8706 } 8707 public ThContext th(int i) { 8708 return getRuleContext(ThContext.class,i); 8709 } 8710 public List<BodyContext> body() { 8711 return getRuleContexts(BodyContext.class); 8712 } 8713 public BodyContext body(int i) { 8714 return getRuleContext(BodyContext.class,i); 8715 } 8716 public List<ColgroupContext> colgroup() { 8717 return getRuleContexts(ColgroupContext.class); 8718 } 8719 public ColgroupContext colgroup(int i) { 8720 return getRuleContext(ColgroupContext.class,i); 8721 } 8722 public List<DdContext> dd() { 8723 return getRuleContexts(DdContext.class); 8724 } 8725 public DdContext dd(int i) { 8726 return getRuleContext(DdContext.class,i); 8727 } 8728 public List<DtContext> dt() { 8729 return getRuleContexts(DtContext.class); 8730 } 8731 public DtContext dt(int i) { 8732 return getRuleContext(DtContext.class,i); 8733 } 8734 public List<HtmlContext> html() { 8735 return getRuleContexts(HtmlContext.class); 8736 } 8737 public HtmlContext html(int i) { 8738 return getRuleContext(HtmlContext.class,i); 8739 } 8740 public List<OptionContext> option() { 8741 return getRuleContexts(OptionContext.class); 8742 } 8743 public OptionContext option(int i) { 8744 return getRuleContext(OptionContext.class,i); 8745 } 8746 public List<TbodyContext> tbody() { 8747 return getRuleContexts(TbodyContext.class); 8748 } 8749 public TbodyContext tbody(int i) { 8750 return getRuleContext(TbodyContext.class,i); 8751 } 8752 public List<TheadContext> thead() { 8753 return getRuleContexts(TheadContext.class); 8754 } 8755 public TheadContext thead(int i) { 8756 return getRuleContext(TheadContext.class,i); 8757 } 8758 public List<TfootContext> tfoot() { 8759 return getRuleContexts(TfootContext.class); 8760 } 8761 public TfootContext tfoot(int i) { 8762 return getRuleContext(TfootContext.class,i); 8763 } 8764 public List<OptgroupContext> optgroup() { 8765 return getRuleContexts(OptgroupContext.class); 8766 } 8767 public OptgroupContext optgroup(int i) { 8768 return getRuleContext(OptgroupContext.class,i); 8769 } 8770 public List<RbContext> rb() { 8771 return getRuleContexts(RbContext.class); 8772 } 8773 public RbContext rb(int i) { 8774 return getRuleContext(RbContext.class,i); 8775 } 8776 public List<RtContext> rt() { 8777 return getRuleContexts(RtContext.class); 8778 } 8779 public RtContext rt(int i) { 8780 return getRuleContext(RtContext.class,i); 8781 } 8782 public List<RtcContext> rtc() { 8783 return getRuleContexts(RtcContext.class); 8784 } 8785 public RtcContext rtc(int i) { 8786 return getRuleContext(RtcContext.class,i); 8787 } 8788 public List<RpContext> rp() { 8789 return getRuleContexts(RpContext.class); 8790 } 8791 public RpContext rp(int i) { 8792 return getRuleContext(RpContext.class,i); 8793 } 8794 public List<PTagStartContext> pTagStart() { 8795 return getRuleContexts(PTagStartContext.class); 8796 } 8797 public PTagStartContext pTagStart(int i) { 8798 return getRuleContext(PTagStartContext.class,i); 8799 } 8800 public List<LiTagStartContext> liTagStart() { 8801 return getRuleContexts(LiTagStartContext.class); 8802 } 8803 public LiTagStartContext liTagStart(int i) { 8804 return getRuleContext(LiTagStartContext.class,i); 8805 } 8806 public List<TrTagStartContext> trTagStart() { 8807 return getRuleContexts(TrTagStartContext.class); 8808 } 8809 public TrTagStartContext trTagStart(int i) { 8810 return getRuleContext(TrTagStartContext.class,i); 8811 } 8812 public List<TdTagStartContext> tdTagStart() { 8813 return getRuleContexts(TdTagStartContext.class); 8814 } 8815 public TdTagStartContext tdTagStart(int i) { 8816 return getRuleContext(TdTagStartContext.class,i); 8817 } 8818 public List<ThTagStartContext> thTagStart() { 8819 return getRuleContexts(ThTagStartContext.class); 8820 } 8821 public ThTagStartContext thTagStart(int i) { 8822 return getRuleContext(ThTagStartContext.class,i); 8823 } 8824 public List<BodyTagStartContext> bodyTagStart() { 8825 return getRuleContexts(BodyTagStartContext.class); 8826 } 8827 public BodyTagStartContext bodyTagStart(int i) { 8828 return getRuleContext(BodyTagStartContext.class,i); 8829 } 8830 public List<ColgroupTagStartContext> colgroupTagStart() { 8831 return getRuleContexts(ColgroupTagStartContext.class); 8832 } 8833 public ColgroupTagStartContext colgroupTagStart(int i) { 8834 return getRuleContext(ColgroupTagStartContext.class,i); 8835 } 8836 public List<DdTagStartContext> ddTagStart() { 8837 return getRuleContexts(DdTagStartContext.class); 8838 } 8839 public DdTagStartContext ddTagStart(int i) { 8840 return getRuleContext(DdTagStartContext.class,i); 8841 } 8842 public List<DtTagStartContext> dtTagStart() { 8843 return getRuleContexts(DtTagStartContext.class); 8844 } 8845 public DtTagStartContext dtTagStart(int i) { 8846 return getRuleContext(DtTagStartContext.class,i); 8847 } 8848 public List<HtmlTagStartContext> htmlTagStart() { 8849 return getRuleContexts(HtmlTagStartContext.class); 8850 } 8851 public HtmlTagStartContext htmlTagStart(int i) { 8852 return getRuleContext(HtmlTagStartContext.class,i); 8853 } 8854 public List<OptionTagStartContext> optionTagStart() { 8855 return getRuleContexts(OptionTagStartContext.class); 8856 } 8857 public OptionTagStartContext optionTagStart(int i) { 8858 return getRuleContext(OptionTagStartContext.class,i); 8859 } 8860 public List<TbodyTagStartContext> tbodyTagStart() { 8861 return getRuleContexts(TbodyTagStartContext.class); 8862 } 8863 public TbodyTagStartContext tbodyTagStart(int i) { 8864 return getRuleContext(TbodyTagStartContext.class,i); 8865 } 8866 public List<TheadTagStartContext> theadTagStart() { 8867 return getRuleContexts(TheadTagStartContext.class); 8868 } 8869 public TheadTagStartContext theadTagStart(int i) { 8870 return getRuleContext(TheadTagStartContext.class,i); 8871 } 8872 public List<TfootTagStartContext> tfootTagStart() { 8873 return getRuleContexts(TfootTagStartContext.class); 8874 } 8875 public TfootTagStartContext tfootTagStart(int i) { 8876 return getRuleContext(TfootTagStartContext.class,i); 8877 } 8878 public List<OptgroupTagStartContext> optgroupTagStart() { 8879 return getRuleContexts(OptgroupTagStartContext.class); 8880 } 8881 public OptgroupTagStartContext optgroupTagStart(int i) { 8882 return getRuleContext(OptgroupTagStartContext.class,i); 8883 } 8884 public List<RbTagStartContext> rbTagStart() { 8885 return getRuleContexts(RbTagStartContext.class); 8886 } 8887 public RbTagStartContext rbTagStart(int i) { 8888 return getRuleContext(RbTagStartContext.class,i); 8889 } 8890 public List<RtTagStartContext> rtTagStart() { 8891 return getRuleContexts(RtTagStartContext.class); 8892 } 8893 public RtTagStartContext rtTagStart(int i) { 8894 return getRuleContext(RtTagStartContext.class,i); 8895 } 8896 public List<RtcTagStartContext> rtcTagStart() { 8897 return getRuleContexts(RtcTagStartContext.class); 8898 } 8899 public RtcTagStartContext rtcTagStart(int i) { 8900 return getRuleContext(RtcTagStartContext.class,i); 8901 } 8902 public List<RpTagStartContext> rpTagStart() { 8903 return getRuleContexts(RpTagStartContext.class); 8904 } 8905 public RpTagStartContext rpTagStart(int i) { 8906 return getRuleContext(RpTagStartContext.class,i); 8907 } 8908 public List<HtmlCommentContext> htmlComment() { 8909 return getRuleContexts(HtmlCommentContext.class); 8910 } 8911 public HtmlCommentContext htmlComment(int i) { 8912 return getRuleContext(HtmlCommentContext.class,i); 8913 } 8914 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 8915 public TerminalNode CDATA(int i) { 8916 return getToken(JavadocParser.CDATA, i); 8917 } 8918 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8919 public TerminalNode NEWLINE(int i) { 8920 return getToken(JavadocParser.NEWLINE, i); 8921 } 8922 public List<TextContext> text() { 8923 return getRuleContexts(TextContext.class); 8924 } 8925 public TextContext text(int i) { 8926 return getRuleContext(TextContext.class,i); 8927 } 8928 public List<JavadocInlineTagContext> javadocInlineTag() { 8929 return getRuleContexts(JavadocInlineTagContext.class); 8930 } 8931 public JavadocInlineTagContext javadocInlineTag(int i) { 8932 return getRuleContext(JavadocInlineTagContext.class,i); 8933 } 8934 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8935 public TerminalNode LEADING_ASTERISK(int i) { 8936 return getToken(JavadocParser.LEADING_ASTERISK, i); 8937 } 8938 public HeadContext(ParserRuleContext parent, int invokingState) { 8939 super(parent, invokingState); 8940 } 8941 @Override public int getRuleIndex() { return RULE_head; } 8942 } 8943 8944 public final HeadContext head() throws RecognitionException { 8945 HeadContext _localctx = new HeadContext(_ctx, getState()); 8946 enterRule(_localctx, 70, RULE_head); 8947 try { 8948 int _alt; 8949 enterOuterAlt(_localctx, 1); 8950 { 8951 setState(1079); 8952 headTagStart(false); 8953 setState(1129); 8954 _errHandler.sync(this); 8955 _alt = getInterpreter().adaptivePredict(_input,63,_ctx); 8956 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8957 if ( _alt==1 ) { 8958 { 8959 setState(1127); 8960 _errHandler.sync(this); 8961 switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) { 8962 case 1: 8963 { 8964 setState(1080); 8965 htmlTag(); 8966 } 8967 break; 8968 case 2: 8969 { 8970 setState(1081); 8971 singletonElement(); 8972 } 8973 break; 8974 case 3: 8975 { 8976 setState(1082); 8977 paragraph(); 8978 } 8979 break; 8980 case 4: 8981 { 8982 setState(1083); 8983 li(); 8984 } 8985 break; 8986 case 5: 8987 { 8988 setState(1084); 8989 tr(); 8990 } 8991 break; 8992 case 6: 8993 { 8994 setState(1085); 8995 td(); 8996 } 8997 break; 8998 case 7: 8999 { 9000 setState(1086); 9001 th(); 9002 } 9003 break; 9004 case 8: 9005 { 9006 setState(1087); 9007 body(); 9008 } 9009 break; 9010 case 9: 9011 { 9012 setState(1088); 9013 colgroup(); 9014 } 9015 break; 9016 case 10: 9017 { 9018 setState(1089); 9019 dd(); 9020 } 9021 break; 9022 case 11: 9023 { 9024 setState(1090); 9025 dt(); 9026 } 9027 break; 9028 case 12: 9029 { 9030 setState(1091); 9031 html(); 9032 } 9033 break; 9034 case 13: 9035 { 9036 setState(1092); 9037 option(); 9038 } 9039 break; 9040 case 14: 9041 { 9042 setState(1093); 9043 tbody(); 9044 } 9045 break; 9046 case 15: 9047 { 9048 setState(1094); 9049 thead(); 9050 } 9051 break; 9052 case 16: 9053 { 9054 setState(1095); 9055 tfoot(); 9056 } 9057 break; 9058 case 17: 9059 { 9060 setState(1096); 9061 optgroup(); 9062 } 9063 break; 9064 case 18: 9065 { 9066 setState(1097); 9067 rb(); 9068 } 9069 break; 9070 case 19: 9071 { 9072 setState(1098); 9073 rt(); 9074 } 9075 break; 9076 case 20: 9077 { 9078 setState(1099); 9079 rtc(); 9080 } 9081 break; 9082 case 21: 9083 { 9084 setState(1100); 9085 rp(); 9086 } 9087 break; 9088 case 22: 9089 { 9090 setState(1101); 9091 pTagStart(true); 9092 } 9093 break; 9094 case 23: 9095 { 9096 setState(1102); 9097 liTagStart(true); 9098 } 9099 break; 9100 case 24: 9101 { 9102 setState(1103); 9103 trTagStart(true); 9104 } 9105 break; 9106 case 25: 9107 { 9108 setState(1104); 9109 tdTagStart(true); 9110 } 9111 break; 9112 case 26: 9113 { 9114 setState(1105); 9115 thTagStart(true); 9116 } 9117 break; 9118 case 27: 9119 { 9120 setState(1106); 9121 bodyTagStart(true); 9122 } 9123 break; 9124 case 28: 9125 { 9126 setState(1107); 9127 colgroupTagStart(true); 9128 } 9129 break; 9130 case 29: 9131 { 9132 setState(1108); 9133 ddTagStart(true); 9134 } 9135 break; 9136 case 30: 9137 { 9138 setState(1109); 9139 dtTagStart(true); 9140 } 9141 break; 9142 case 31: 9143 { 9144 setState(1110); 9145 htmlTagStart(true); 9146 } 9147 break; 9148 case 32: 9149 { 9150 setState(1111); 9151 optionTagStart(true); 9152 } 9153 break; 9154 case 33: 9155 { 9156 setState(1112); 9157 tbodyTagStart(true); 9158 } 9159 break; 9160 case 34: 9161 { 9162 setState(1113); 9163 theadTagStart(true); 9164 } 9165 break; 9166 case 35: 9167 { 9168 setState(1114); 9169 tfootTagStart(true); 9170 } 9171 break; 9172 case 36: 9173 { 9174 setState(1115); 9175 optgroupTagStart(true); 9176 } 9177 break; 9178 case 37: 9179 { 9180 setState(1116); 9181 rbTagStart(true); 9182 } 9183 break; 9184 case 38: 9185 { 9186 setState(1117); 9187 rtTagStart(true); 9188 } 9189 break; 9190 case 39: 9191 { 9192 setState(1118); 9193 rtcTagStart(true); 9194 } 9195 break; 9196 case 40: 9197 { 9198 setState(1119); 9199 rpTagStart(true); 9200 } 9201 break; 9202 case 41: 9203 { 9204 { 9205 setState(1120); 9206 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 9207 setState(1121); 9208 match(LEADING_ASTERISK); 9209 } 9210 } 9211 break; 9212 case 42: 9213 { 9214 setState(1122); 9215 htmlComment(); 9216 } 9217 break; 9218 case 43: 9219 { 9220 setState(1123); 9221 match(CDATA); 9222 } 9223 break; 9224 case 44: 9225 { 9226 setState(1124); 9227 match(NEWLINE); 9228 } 9229 break; 9230 case 45: 9231 { 9232 setState(1125); 9233 text(); 9234 } 9235 break; 9236 case 46: 9237 { 9238 setState(1126); 9239 javadocInlineTag(); 9240 } 9241 break; 9242 } 9243 } 9244 } 9245 setState(1131); 9246 _errHandler.sync(this); 9247 _alt = getInterpreter().adaptivePredict(_input,63,_ctx); 9248 } 9249 setState(1132); 9250 headTagEnd(); 9251 } 9252 } 9253 catch (RecognitionException re) { 9254 _localctx.exception = re; 9255 _errHandler.reportError(this, re); 9256 _errHandler.recover(this, re); 9257 } 9258 finally { 9259 exitRule(); 9260 } 9261 return _localctx; 9262 } 9263 9264 public static class HtmlTagStartContext extends ParserRuleContext { 9265 public boolean isNonTight; 9266 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 9267 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 9268 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 9269 public List<AttributeContext> attribute() { 9270 return getRuleContexts(AttributeContext.class); 9271 } 9272 public AttributeContext attribute(int i) { 9273 return getRuleContext(AttributeContext.class,i); 9274 } 9275 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9276 public TerminalNode NEWLINE(int i) { 9277 return getToken(JavadocParser.NEWLINE, i); 9278 } 9279 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9280 public TerminalNode LEADING_ASTERISK(int i) { 9281 return getToken(JavadocParser.LEADING_ASTERISK, i); 9282 } 9283 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9284 public TerminalNode WS(int i) { 9285 return getToken(JavadocParser.WS, i); 9286 } 9287 public HtmlTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 9288 public HtmlTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 9289 super(parent, invokingState); 9290 this.isNonTight = isNonTight; 9291 } 9292 @Override public int getRuleIndex() { return RULE_htmlTagStart; } 9293 } 9294 9295 public final HtmlTagStartContext htmlTagStart(boolean isNonTight) throws RecognitionException { 9296 HtmlTagStartContext _localctx = new HtmlTagStartContext(_ctx, getState(), isNonTight); 9297 enterRule(_localctx, 72, RULE_htmlTagStart); 9298 int _la; 9299 try { 9300 enterOuterAlt(_localctx, 1); 9301 { 9302 setState(1134); 9303 match(START); 9304 setState(1135); 9305 match(HTML_HTML_TAG_NAME); 9306 setState(1142); 9307 _errHandler.sync(this); 9308 _la = _input.LA(1); 9309 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9310 { 9311 setState(1140); 9312 _errHandler.sync(this); 9313 switch (_input.LA(1)) { 9314 case HTML_TAG_NAME: 9315 { 9316 setState(1136); 9317 attribute(); 9318 } 9319 break; 9320 case NEWLINE: 9321 { 9322 setState(1137); 9323 match(NEWLINE); 9324 } 9325 break; 9326 case LEADING_ASTERISK: 9327 { 9328 setState(1138); 9329 match(LEADING_ASTERISK); 9330 } 9331 break; 9332 case WS: 9333 { 9334 setState(1139); 9335 match(WS); 9336 } 9337 break; 9338 default: 9339 throw new NoViableAltException(this); 9340 } 9341 } 9342 setState(1144); 9343 _errHandler.sync(this); 9344 _la = _input.LA(1); 9345 } 9346 setState(1145); 9347 match(END); 9348 } 9349 _ctx.stop = _input.LT(-1); 9350 9351 if (isNonTight && nonTightTagStartContext == null) { 9352 nonTightTagStartContext = _localctx; 9353 } 9354 9355 } 9356 catch (RecognitionException re) { 9357 _localctx.exception = re; 9358 _errHandler.reportError(this, re); 9359 _errHandler.recover(this, re); 9360 } 9361 finally { 9362 exitRule(); 9363 } 9364 return _localctx; 9365 } 9366 9367 public static class HtmlTagEndContext extends ParserRuleContext { 9368 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 9369 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9370 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 9371 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 9372 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9373 public TerminalNode NEWLINE(int i) { 9374 return getToken(JavadocParser.NEWLINE, i); 9375 } 9376 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9377 public TerminalNode LEADING_ASTERISK(int i) { 9378 return getToken(JavadocParser.LEADING_ASTERISK, i); 9379 } 9380 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9381 public TerminalNode WS(int i) { 9382 return getToken(JavadocParser.WS, i); 9383 } 9384 public HtmlTagEndContext(ParserRuleContext parent, int invokingState) { 9385 super(parent, invokingState); 9386 } 9387 @Override public int getRuleIndex() { return RULE_htmlTagEnd; } 9388 } 9389 9390 public final HtmlTagEndContext htmlTagEnd() throws RecognitionException { 9391 HtmlTagEndContext _localctx = new HtmlTagEndContext(_ctx, getState()); 9392 enterRule(_localctx, 74, RULE_htmlTagEnd); 9393 int _la; 9394 try { 9395 enterOuterAlt(_localctx, 1); 9396 { 9397 setState(1147); 9398 match(START); 9399 setState(1148); 9400 match(SLASH); 9401 setState(1149); 9402 match(HTML_HTML_TAG_NAME); 9403 setState(1153); 9404 _errHandler.sync(this); 9405 _la = _input.LA(1); 9406 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9407 { 9408 { 9409 setState(1150); 9410 _la = _input.LA(1); 9411 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9412 _errHandler.recoverInline(this); 9413 } 9414 else { 9415 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 9416 _errHandler.reportMatch(this); 9417 consume(); 9418 } 9419 } 9420 } 9421 setState(1155); 9422 _errHandler.sync(this); 9423 _la = _input.LA(1); 9424 } 9425 setState(1156); 9426 match(END); 9427 } 9428 } 9429 catch (RecognitionException re) { 9430 _localctx.exception = re; 9431 _errHandler.reportError(this, re); 9432 _errHandler.recover(this, re); 9433 } 9434 finally { 9435 exitRule(); 9436 } 9437 return _localctx; 9438 } 9439 9440 public static class HtmlContext extends ParserRuleContext { 9441 public HtmlTagStartContext htmlTagStart() { 9442 return getRuleContext(HtmlTagStartContext.class,0); 9443 } 9444 public HtmlTagEndContext htmlTagEnd() { 9445 return getRuleContext(HtmlTagEndContext.class,0); 9446 } 9447 public List<HtmlTagContext> htmlTag() { 9448 return getRuleContexts(HtmlTagContext.class); 9449 } 9450 public HtmlTagContext htmlTag(int i) { 9451 return getRuleContext(HtmlTagContext.class,i); 9452 } 9453 public List<SingletonElementContext> singletonElement() { 9454 return getRuleContexts(SingletonElementContext.class); 9455 } 9456 public SingletonElementContext singletonElement(int i) { 9457 return getRuleContext(SingletonElementContext.class,i); 9458 } 9459 public List<ParagraphContext> paragraph() { 9460 return getRuleContexts(ParagraphContext.class); 9461 } 9462 public ParagraphContext paragraph(int i) { 9463 return getRuleContext(ParagraphContext.class,i); 9464 } 9465 public List<LiContext> li() { 9466 return getRuleContexts(LiContext.class); 9467 } 9468 public LiContext li(int i) { 9469 return getRuleContext(LiContext.class,i); 9470 } 9471 public List<TrContext> tr() { 9472 return getRuleContexts(TrContext.class); 9473 } 9474 public TrContext tr(int i) { 9475 return getRuleContext(TrContext.class,i); 9476 } 9477 public List<TdContext> td() { 9478 return getRuleContexts(TdContext.class); 9479 } 9480 public TdContext td(int i) { 9481 return getRuleContext(TdContext.class,i); 9482 } 9483 public List<ThContext> th() { 9484 return getRuleContexts(ThContext.class); 9485 } 9486 public ThContext th(int i) { 9487 return getRuleContext(ThContext.class,i); 9488 } 9489 public List<BodyContext> body() { 9490 return getRuleContexts(BodyContext.class); 9491 } 9492 public BodyContext body(int i) { 9493 return getRuleContext(BodyContext.class,i); 9494 } 9495 public List<ColgroupContext> colgroup() { 9496 return getRuleContexts(ColgroupContext.class); 9497 } 9498 public ColgroupContext colgroup(int i) { 9499 return getRuleContext(ColgroupContext.class,i); 9500 } 9501 public List<DdContext> dd() { 9502 return getRuleContexts(DdContext.class); 9503 } 9504 public DdContext dd(int i) { 9505 return getRuleContext(DdContext.class,i); 9506 } 9507 public List<DtContext> dt() { 9508 return getRuleContexts(DtContext.class); 9509 } 9510 public DtContext dt(int i) { 9511 return getRuleContext(DtContext.class,i); 9512 } 9513 public List<HeadContext> head() { 9514 return getRuleContexts(HeadContext.class); 9515 } 9516 public HeadContext head(int i) { 9517 return getRuleContext(HeadContext.class,i); 9518 } 9519 public List<OptionContext> option() { 9520 return getRuleContexts(OptionContext.class); 9521 } 9522 public OptionContext option(int i) { 9523 return getRuleContext(OptionContext.class,i); 9524 } 9525 public List<TbodyContext> tbody() { 9526 return getRuleContexts(TbodyContext.class); 9527 } 9528 public TbodyContext tbody(int i) { 9529 return getRuleContext(TbodyContext.class,i); 9530 } 9531 public List<TheadContext> thead() { 9532 return getRuleContexts(TheadContext.class); 9533 } 9534 public TheadContext thead(int i) { 9535 return getRuleContext(TheadContext.class,i); 9536 } 9537 public List<TfootContext> tfoot() { 9538 return getRuleContexts(TfootContext.class); 9539 } 9540 public TfootContext tfoot(int i) { 9541 return getRuleContext(TfootContext.class,i); 9542 } 9543 public List<OptgroupContext> optgroup() { 9544 return getRuleContexts(OptgroupContext.class); 9545 } 9546 public OptgroupContext optgroup(int i) { 9547 return getRuleContext(OptgroupContext.class,i); 9548 } 9549 public List<RbContext> rb() { 9550 return getRuleContexts(RbContext.class); 9551 } 9552 public RbContext rb(int i) { 9553 return getRuleContext(RbContext.class,i); 9554 } 9555 public List<RtContext> rt() { 9556 return getRuleContexts(RtContext.class); 9557 } 9558 public RtContext rt(int i) { 9559 return getRuleContext(RtContext.class,i); 9560 } 9561 public List<RtcContext> rtc() { 9562 return getRuleContexts(RtcContext.class); 9563 } 9564 public RtcContext rtc(int i) { 9565 return getRuleContext(RtcContext.class,i); 9566 } 9567 public List<RpContext> rp() { 9568 return getRuleContexts(RpContext.class); 9569 } 9570 public RpContext rp(int i) { 9571 return getRuleContext(RpContext.class,i); 9572 } 9573 public List<PTagStartContext> pTagStart() { 9574 return getRuleContexts(PTagStartContext.class); 9575 } 9576 public PTagStartContext pTagStart(int i) { 9577 return getRuleContext(PTagStartContext.class,i); 9578 } 9579 public List<LiTagStartContext> liTagStart() { 9580 return getRuleContexts(LiTagStartContext.class); 9581 } 9582 public LiTagStartContext liTagStart(int i) { 9583 return getRuleContext(LiTagStartContext.class,i); 9584 } 9585 public List<TrTagStartContext> trTagStart() { 9586 return getRuleContexts(TrTagStartContext.class); 9587 } 9588 public TrTagStartContext trTagStart(int i) { 9589 return getRuleContext(TrTagStartContext.class,i); 9590 } 9591 public List<TdTagStartContext> tdTagStart() { 9592 return getRuleContexts(TdTagStartContext.class); 9593 } 9594 public TdTagStartContext tdTagStart(int i) { 9595 return getRuleContext(TdTagStartContext.class,i); 9596 } 9597 public List<ThTagStartContext> thTagStart() { 9598 return getRuleContexts(ThTagStartContext.class); 9599 } 9600 public ThTagStartContext thTagStart(int i) { 9601 return getRuleContext(ThTagStartContext.class,i); 9602 } 9603 public List<BodyTagStartContext> bodyTagStart() { 9604 return getRuleContexts(BodyTagStartContext.class); 9605 } 9606 public BodyTagStartContext bodyTagStart(int i) { 9607 return getRuleContext(BodyTagStartContext.class,i); 9608 } 9609 public List<ColgroupTagStartContext> colgroupTagStart() { 9610 return getRuleContexts(ColgroupTagStartContext.class); 9611 } 9612 public ColgroupTagStartContext colgroupTagStart(int i) { 9613 return getRuleContext(ColgroupTagStartContext.class,i); 9614 } 9615 public List<DdTagStartContext> ddTagStart() { 9616 return getRuleContexts(DdTagStartContext.class); 9617 } 9618 public DdTagStartContext ddTagStart(int i) { 9619 return getRuleContext(DdTagStartContext.class,i); 9620 } 9621 public List<DtTagStartContext> dtTagStart() { 9622 return getRuleContexts(DtTagStartContext.class); 9623 } 9624 public DtTagStartContext dtTagStart(int i) { 9625 return getRuleContext(DtTagStartContext.class,i); 9626 } 9627 public List<HeadTagStartContext> headTagStart() { 9628 return getRuleContexts(HeadTagStartContext.class); 9629 } 9630 public HeadTagStartContext headTagStart(int i) { 9631 return getRuleContext(HeadTagStartContext.class,i); 9632 } 9633 public List<OptionTagStartContext> optionTagStart() { 9634 return getRuleContexts(OptionTagStartContext.class); 9635 } 9636 public OptionTagStartContext optionTagStart(int i) { 9637 return getRuleContext(OptionTagStartContext.class,i); 9638 } 9639 public List<TbodyTagStartContext> tbodyTagStart() { 9640 return getRuleContexts(TbodyTagStartContext.class); 9641 } 9642 public TbodyTagStartContext tbodyTagStart(int i) { 9643 return getRuleContext(TbodyTagStartContext.class,i); 9644 } 9645 public List<TheadTagStartContext> theadTagStart() { 9646 return getRuleContexts(TheadTagStartContext.class); 9647 } 9648 public TheadTagStartContext theadTagStart(int i) { 9649 return getRuleContext(TheadTagStartContext.class,i); 9650 } 9651 public List<TfootTagStartContext> tfootTagStart() { 9652 return getRuleContexts(TfootTagStartContext.class); 9653 } 9654 public TfootTagStartContext tfootTagStart(int i) { 9655 return getRuleContext(TfootTagStartContext.class,i); 9656 } 9657 public List<OptgroupTagStartContext> optgroupTagStart() { 9658 return getRuleContexts(OptgroupTagStartContext.class); 9659 } 9660 public OptgroupTagStartContext optgroupTagStart(int i) { 9661 return getRuleContext(OptgroupTagStartContext.class,i); 9662 } 9663 public List<RbTagStartContext> rbTagStart() { 9664 return getRuleContexts(RbTagStartContext.class); 9665 } 9666 public RbTagStartContext rbTagStart(int i) { 9667 return getRuleContext(RbTagStartContext.class,i); 9668 } 9669 public List<RtTagStartContext> rtTagStart() { 9670 return getRuleContexts(RtTagStartContext.class); 9671 } 9672 public RtTagStartContext rtTagStart(int i) { 9673 return getRuleContext(RtTagStartContext.class,i); 9674 } 9675 public List<RtcTagStartContext> rtcTagStart() { 9676 return getRuleContexts(RtcTagStartContext.class); 9677 } 9678 public RtcTagStartContext rtcTagStart(int i) { 9679 return getRuleContext(RtcTagStartContext.class,i); 9680 } 9681 public List<RpTagStartContext> rpTagStart() { 9682 return getRuleContexts(RpTagStartContext.class); 9683 } 9684 public RpTagStartContext rpTagStart(int i) { 9685 return getRuleContext(RpTagStartContext.class,i); 9686 } 9687 public List<HtmlCommentContext> htmlComment() { 9688 return getRuleContexts(HtmlCommentContext.class); 9689 } 9690 public HtmlCommentContext htmlComment(int i) { 9691 return getRuleContext(HtmlCommentContext.class,i); 9692 } 9693 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 9694 public TerminalNode CDATA(int i) { 9695 return getToken(JavadocParser.CDATA, i); 9696 } 9697 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9698 public TerminalNode NEWLINE(int i) { 9699 return getToken(JavadocParser.NEWLINE, i); 9700 } 9701 public List<TextContext> text() { 9702 return getRuleContexts(TextContext.class); 9703 } 9704 public TextContext text(int i) { 9705 return getRuleContext(TextContext.class,i); 9706 } 9707 public List<JavadocInlineTagContext> javadocInlineTag() { 9708 return getRuleContexts(JavadocInlineTagContext.class); 9709 } 9710 public JavadocInlineTagContext javadocInlineTag(int i) { 9711 return getRuleContext(JavadocInlineTagContext.class,i); 9712 } 9713 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9714 public TerminalNode LEADING_ASTERISK(int i) { 9715 return getToken(JavadocParser.LEADING_ASTERISK, i); 9716 } 9717 public HtmlContext(ParserRuleContext parent, int invokingState) { 9718 super(parent, invokingState); 9719 } 9720 @Override public int getRuleIndex() { return RULE_html; } 9721 } 9722 9723 public final HtmlContext html() throws RecognitionException { 9724 HtmlContext _localctx = new HtmlContext(_ctx, getState()); 9725 enterRule(_localctx, 76, RULE_html); 9726 try { 9727 int _alt; 9728 enterOuterAlt(_localctx, 1); 9729 { 9730 setState(1158); 9731 htmlTagStart(false); 9732 setState(1208); 9733 _errHandler.sync(this); 9734 _alt = getInterpreter().adaptivePredict(_input,68,_ctx); 9735 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 9736 if ( _alt==1 ) { 9737 { 9738 setState(1206); 9739 _errHandler.sync(this); 9740 switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) { 9741 case 1: 9742 { 9743 setState(1159); 9744 htmlTag(); 9745 } 9746 break; 9747 case 2: 9748 { 9749 setState(1160); 9750 singletonElement(); 9751 } 9752 break; 9753 case 3: 9754 { 9755 setState(1161); 9756 paragraph(); 9757 } 9758 break; 9759 case 4: 9760 { 9761 setState(1162); 9762 li(); 9763 } 9764 break; 9765 case 5: 9766 { 9767 setState(1163); 9768 tr(); 9769 } 9770 break; 9771 case 6: 9772 { 9773 setState(1164); 9774 td(); 9775 } 9776 break; 9777 case 7: 9778 { 9779 setState(1165); 9780 th(); 9781 } 9782 break; 9783 case 8: 9784 { 9785 setState(1166); 9786 body(); 9787 } 9788 break; 9789 case 9: 9790 { 9791 setState(1167); 9792 colgroup(); 9793 } 9794 break; 9795 case 10: 9796 { 9797 setState(1168); 9798 dd(); 9799 } 9800 break; 9801 case 11: 9802 { 9803 setState(1169); 9804 dt(); 9805 } 9806 break; 9807 case 12: 9808 { 9809 setState(1170); 9810 head(); 9811 } 9812 break; 9813 case 13: 9814 { 9815 setState(1171); 9816 option(); 9817 } 9818 break; 9819 case 14: 9820 { 9821 setState(1172); 9822 tbody(); 9823 } 9824 break; 9825 case 15: 9826 { 9827 setState(1173); 9828 thead(); 9829 } 9830 break; 9831 case 16: 9832 { 9833 setState(1174); 9834 tfoot(); 9835 } 9836 break; 9837 case 17: 9838 { 9839 setState(1175); 9840 optgroup(); 9841 } 9842 break; 9843 case 18: 9844 { 9845 setState(1176); 9846 rb(); 9847 } 9848 break; 9849 case 19: 9850 { 9851 setState(1177); 9852 rt(); 9853 } 9854 break; 9855 case 20: 9856 { 9857 setState(1178); 9858 rtc(); 9859 } 9860 break; 9861 case 21: 9862 { 9863 setState(1179); 9864 rp(); 9865 } 9866 break; 9867 case 22: 9868 { 9869 setState(1180); 9870 pTagStart(true); 9871 } 9872 break; 9873 case 23: 9874 { 9875 setState(1181); 9876 liTagStart(true); 9877 } 9878 break; 9879 case 24: 9880 { 9881 setState(1182); 9882 trTagStart(true); 9883 } 9884 break; 9885 case 25: 9886 { 9887 setState(1183); 9888 tdTagStart(true); 9889 } 9890 break; 9891 case 26: 9892 { 9893 setState(1184); 9894 thTagStart(true); 9895 } 9896 break; 9897 case 27: 9898 { 9899 setState(1185); 9900 bodyTagStart(true); 9901 } 9902 break; 9903 case 28: 9904 { 9905 setState(1186); 9906 colgroupTagStart(true); 9907 } 9908 break; 9909 case 29: 9910 { 9911 setState(1187); 9912 ddTagStart(true); 9913 } 9914 break; 9915 case 30: 9916 { 9917 setState(1188); 9918 dtTagStart(true); 9919 } 9920 break; 9921 case 31: 9922 { 9923 setState(1189); 9924 headTagStart(true); 9925 } 9926 break; 9927 case 32: 9928 { 9929 setState(1190); 9930 optionTagStart(true); 9931 } 9932 break; 9933 case 33: 9934 { 9935 setState(1191); 9936 tbodyTagStart(true); 9937 } 9938 break; 9939 case 34: 9940 { 9941 setState(1192); 9942 theadTagStart(true); 9943 } 9944 break; 9945 case 35: 9946 { 9947 setState(1193); 9948 tfootTagStart(true); 9949 } 9950 break; 9951 case 36: 9952 { 9953 setState(1194); 9954 optgroupTagStart(true); 9955 } 9956 break; 9957 case 37: 9958 { 9959 setState(1195); 9960 rbTagStart(true); 9961 } 9962 break; 9963 case 38: 9964 { 9965 setState(1196); 9966 rtTagStart(true); 9967 } 9968 break; 9969 case 39: 9970 { 9971 setState(1197); 9972 rtcTagStart(true); 9973 } 9974 break; 9975 case 40: 9976 { 9977 setState(1198); 9978 rpTagStart(true); 9979 } 9980 break; 9981 case 41: 9982 { 9983 { 9984 setState(1199); 9985 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 9986 setState(1200); 9987 match(LEADING_ASTERISK); 9988 } 9989 } 9990 break; 9991 case 42: 9992 { 9993 setState(1201); 9994 htmlComment(); 9995 } 9996 break; 9997 case 43: 9998 { 9999 setState(1202); 10000 match(CDATA); 10001 } 10002 break; 10003 case 44: 10004 { 10005 setState(1203); 10006 match(NEWLINE); 10007 } 10008 break; 10009 case 45: 10010 { 10011 setState(1204); 10012 text(); 10013 } 10014 break; 10015 case 46: 10016 { 10017 setState(1205); 10018 javadocInlineTag(); 10019 } 10020 break; 10021 } 10022 } 10023 } 10024 setState(1210); 10025 _errHandler.sync(this); 10026 _alt = getInterpreter().adaptivePredict(_input,68,_ctx); 10027 } 10028 setState(1211); 10029 htmlTagEnd(); 10030 } 10031 } 10032 catch (RecognitionException re) { 10033 _localctx.exception = re; 10034 _errHandler.reportError(this, re); 10035 _errHandler.recover(this, re); 10036 } 10037 finally { 10038 exitRule(); 10039 } 10040 return _localctx; 10041 } 10042 10043 public static class OptionTagStartContext extends ParserRuleContext { 10044 public boolean isNonTight; 10045 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 10046 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 10047 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 10048 public List<AttributeContext> attribute() { 10049 return getRuleContexts(AttributeContext.class); 10050 } 10051 public AttributeContext attribute(int i) { 10052 return getRuleContext(AttributeContext.class,i); 10053 } 10054 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10055 public TerminalNode NEWLINE(int i) { 10056 return getToken(JavadocParser.NEWLINE, i); 10057 } 10058 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10059 public TerminalNode LEADING_ASTERISK(int i) { 10060 return getToken(JavadocParser.LEADING_ASTERISK, i); 10061 } 10062 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10063 public TerminalNode WS(int i) { 10064 return getToken(JavadocParser.WS, i); 10065 } 10066 public OptionTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 10067 public OptionTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 10068 super(parent, invokingState); 10069 this.isNonTight = isNonTight; 10070 } 10071 @Override public int getRuleIndex() { return RULE_optionTagStart; } 10072 } 10073 10074 public final OptionTagStartContext optionTagStart(boolean isNonTight) throws RecognitionException { 10075 OptionTagStartContext _localctx = new OptionTagStartContext(_ctx, getState(), isNonTight); 10076 enterRule(_localctx, 78, RULE_optionTagStart); 10077 int _la; 10078 try { 10079 enterOuterAlt(_localctx, 1); 10080 { 10081 setState(1213); 10082 match(START); 10083 setState(1214); 10084 match(OPTION_HTML_TAG_NAME); 10085 setState(1221); 10086 _errHandler.sync(this); 10087 _la = _input.LA(1); 10088 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 10089 { 10090 setState(1219); 10091 _errHandler.sync(this); 10092 switch (_input.LA(1)) { 10093 case HTML_TAG_NAME: 10094 { 10095 setState(1215); 10096 attribute(); 10097 } 10098 break; 10099 case NEWLINE: 10100 { 10101 setState(1216); 10102 match(NEWLINE); 10103 } 10104 break; 10105 case LEADING_ASTERISK: 10106 { 10107 setState(1217); 10108 match(LEADING_ASTERISK); 10109 } 10110 break; 10111 case WS: 10112 { 10113 setState(1218); 10114 match(WS); 10115 } 10116 break; 10117 default: 10118 throw new NoViableAltException(this); 10119 } 10120 } 10121 setState(1223); 10122 _errHandler.sync(this); 10123 _la = _input.LA(1); 10124 } 10125 setState(1224); 10126 match(END); 10127 } 10128 _ctx.stop = _input.LT(-1); 10129 10130 if (isNonTight && nonTightTagStartContext == null) { 10131 nonTightTagStartContext = _localctx; 10132 } 10133 10134 } 10135 catch (RecognitionException re) { 10136 _localctx.exception = re; 10137 _errHandler.reportError(this, re); 10138 _errHandler.recover(this, re); 10139 } 10140 finally { 10141 exitRule(); 10142 } 10143 return _localctx; 10144 } 10145 10146 public static class OptionTagEndContext extends ParserRuleContext { 10147 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 10148 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 10149 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 10150 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 10151 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10152 public TerminalNode NEWLINE(int i) { 10153 return getToken(JavadocParser.NEWLINE, i); 10154 } 10155 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10156 public TerminalNode LEADING_ASTERISK(int i) { 10157 return getToken(JavadocParser.LEADING_ASTERISK, i); 10158 } 10159 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10160 public TerminalNode WS(int i) { 10161 return getToken(JavadocParser.WS, i); 10162 } 10163 public OptionTagEndContext(ParserRuleContext parent, int invokingState) { 10164 super(parent, invokingState); 10165 } 10166 @Override public int getRuleIndex() { return RULE_optionTagEnd; } 10167 } 10168 10169 public final OptionTagEndContext optionTagEnd() throws RecognitionException { 10170 OptionTagEndContext _localctx = new OptionTagEndContext(_ctx, getState()); 10171 enterRule(_localctx, 80, RULE_optionTagEnd); 10172 int _la; 10173 try { 10174 enterOuterAlt(_localctx, 1); 10175 { 10176 setState(1226); 10177 match(START); 10178 setState(1227); 10179 match(SLASH); 10180 setState(1228); 10181 match(OPTION_HTML_TAG_NAME); 10182 setState(1232); 10183 _errHandler.sync(this); 10184 _la = _input.LA(1); 10185 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 10186 { 10187 { 10188 setState(1229); 10189 _la = _input.LA(1); 10190 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 10191 _errHandler.recoverInline(this); 10192 } 10193 else { 10194 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 10195 _errHandler.reportMatch(this); 10196 consume(); 10197 } 10198 } 10199 } 10200 setState(1234); 10201 _errHandler.sync(this); 10202 _la = _input.LA(1); 10203 } 10204 setState(1235); 10205 match(END); 10206 } 10207 } 10208 catch (RecognitionException re) { 10209 _localctx.exception = re; 10210 _errHandler.reportError(this, re); 10211 _errHandler.recover(this, re); 10212 } 10213 finally { 10214 exitRule(); 10215 } 10216 return _localctx; 10217 } 10218 10219 public static class OptionContext extends ParserRuleContext { 10220 public OptionTagStartContext optionTagStart() { 10221 return getRuleContext(OptionTagStartContext.class,0); 10222 } 10223 public OptionTagEndContext optionTagEnd() { 10224 return getRuleContext(OptionTagEndContext.class,0); 10225 } 10226 public List<HtmlTagContext> htmlTag() { 10227 return getRuleContexts(HtmlTagContext.class); 10228 } 10229 public HtmlTagContext htmlTag(int i) { 10230 return getRuleContext(HtmlTagContext.class,i); 10231 } 10232 public List<SingletonElementContext> singletonElement() { 10233 return getRuleContexts(SingletonElementContext.class); 10234 } 10235 public SingletonElementContext singletonElement(int i) { 10236 return getRuleContext(SingletonElementContext.class,i); 10237 } 10238 public List<ParagraphContext> paragraph() { 10239 return getRuleContexts(ParagraphContext.class); 10240 } 10241 public ParagraphContext paragraph(int i) { 10242 return getRuleContext(ParagraphContext.class,i); 10243 } 10244 public List<LiContext> li() { 10245 return getRuleContexts(LiContext.class); 10246 } 10247 public LiContext li(int i) { 10248 return getRuleContext(LiContext.class,i); 10249 } 10250 public List<TrContext> tr() { 10251 return getRuleContexts(TrContext.class); 10252 } 10253 public TrContext tr(int i) { 10254 return getRuleContext(TrContext.class,i); 10255 } 10256 public List<TdContext> td() { 10257 return getRuleContexts(TdContext.class); 10258 } 10259 public TdContext td(int i) { 10260 return getRuleContext(TdContext.class,i); 10261 } 10262 public List<ThContext> th() { 10263 return getRuleContexts(ThContext.class); 10264 } 10265 public ThContext th(int i) { 10266 return getRuleContext(ThContext.class,i); 10267 } 10268 public List<BodyContext> body() { 10269 return getRuleContexts(BodyContext.class); 10270 } 10271 public BodyContext body(int i) { 10272 return getRuleContext(BodyContext.class,i); 10273 } 10274 public List<ColgroupContext> colgroup() { 10275 return getRuleContexts(ColgroupContext.class); 10276 } 10277 public ColgroupContext colgroup(int i) { 10278 return getRuleContext(ColgroupContext.class,i); 10279 } 10280 public List<DdContext> dd() { 10281 return getRuleContexts(DdContext.class); 10282 } 10283 public DdContext dd(int i) { 10284 return getRuleContext(DdContext.class,i); 10285 } 10286 public List<DtContext> dt() { 10287 return getRuleContexts(DtContext.class); 10288 } 10289 public DtContext dt(int i) { 10290 return getRuleContext(DtContext.class,i); 10291 } 10292 public List<HeadContext> head() { 10293 return getRuleContexts(HeadContext.class); 10294 } 10295 public HeadContext head(int i) { 10296 return getRuleContext(HeadContext.class,i); 10297 } 10298 public List<HtmlContext> html() { 10299 return getRuleContexts(HtmlContext.class); 10300 } 10301 public HtmlContext html(int i) { 10302 return getRuleContext(HtmlContext.class,i); 10303 } 10304 public List<TbodyContext> tbody() { 10305 return getRuleContexts(TbodyContext.class); 10306 } 10307 public TbodyContext tbody(int i) { 10308 return getRuleContext(TbodyContext.class,i); 10309 } 10310 public List<TheadContext> thead() { 10311 return getRuleContexts(TheadContext.class); 10312 } 10313 public TheadContext thead(int i) { 10314 return getRuleContext(TheadContext.class,i); 10315 } 10316 public List<TfootContext> tfoot() { 10317 return getRuleContexts(TfootContext.class); 10318 } 10319 public TfootContext tfoot(int i) { 10320 return getRuleContext(TfootContext.class,i); 10321 } 10322 public List<OptgroupContext> optgroup() { 10323 return getRuleContexts(OptgroupContext.class); 10324 } 10325 public OptgroupContext optgroup(int i) { 10326 return getRuleContext(OptgroupContext.class,i); 10327 } 10328 public List<RbContext> rb() { 10329 return getRuleContexts(RbContext.class); 10330 } 10331 public RbContext rb(int i) { 10332 return getRuleContext(RbContext.class,i); 10333 } 10334 public List<RtContext> rt() { 10335 return getRuleContexts(RtContext.class); 10336 } 10337 public RtContext rt(int i) { 10338 return getRuleContext(RtContext.class,i); 10339 } 10340 public List<RtcContext> rtc() { 10341 return getRuleContexts(RtcContext.class); 10342 } 10343 public RtcContext rtc(int i) { 10344 return getRuleContext(RtcContext.class,i); 10345 } 10346 public List<RpContext> rp() { 10347 return getRuleContexts(RpContext.class); 10348 } 10349 public RpContext rp(int i) { 10350 return getRuleContext(RpContext.class,i); 10351 } 10352 public List<PTagStartContext> pTagStart() { 10353 return getRuleContexts(PTagStartContext.class); 10354 } 10355 public PTagStartContext pTagStart(int i) { 10356 return getRuleContext(PTagStartContext.class,i); 10357 } 10358 public List<LiTagStartContext> liTagStart() { 10359 return getRuleContexts(LiTagStartContext.class); 10360 } 10361 public LiTagStartContext liTagStart(int i) { 10362 return getRuleContext(LiTagStartContext.class,i); 10363 } 10364 public List<TrTagStartContext> trTagStart() { 10365 return getRuleContexts(TrTagStartContext.class); 10366 } 10367 public TrTagStartContext trTagStart(int i) { 10368 return getRuleContext(TrTagStartContext.class,i); 10369 } 10370 public List<TdTagStartContext> tdTagStart() { 10371 return getRuleContexts(TdTagStartContext.class); 10372 } 10373 public TdTagStartContext tdTagStart(int i) { 10374 return getRuleContext(TdTagStartContext.class,i); 10375 } 10376 public List<ThTagStartContext> thTagStart() { 10377 return getRuleContexts(ThTagStartContext.class); 10378 } 10379 public ThTagStartContext thTagStart(int i) { 10380 return getRuleContext(ThTagStartContext.class,i); 10381 } 10382 public List<BodyTagStartContext> bodyTagStart() { 10383 return getRuleContexts(BodyTagStartContext.class); 10384 } 10385 public BodyTagStartContext bodyTagStart(int i) { 10386 return getRuleContext(BodyTagStartContext.class,i); 10387 } 10388 public List<ColgroupTagStartContext> colgroupTagStart() { 10389 return getRuleContexts(ColgroupTagStartContext.class); 10390 } 10391 public ColgroupTagStartContext colgroupTagStart(int i) { 10392 return getRuleContext(ColgroupTagStartContext.class,i); 10393 } 10394 public List<DdTagStartContext> ddTagStart() { 10395 return getRuleContexts(DdTagStartContext.class); 10396 } 10397 public DdTagStartContext ddTagStart(int i) { 10398 return getRuleContext(DdTagStartContext.class,i); 10399 } 10400 public List<DtTagStartContext> dtTagStart() { 10401 return getRuleContexts(DtTagStartContext.class); 10402 } 10403 public DtTagStartContext dtTagStart(int i) { 10404 return getRuleContext(DtTagStartContext.class,i); 10405 } 10406 public List<HeadTagStartContext> headTagStart() { 10407 return getRuleContexts(HeadTagStartContext.class); 10408 } 10409 public HeadTagStartContext headTagStart(int i) { 10410 return getRuleContext(HeadTagStartContext.class,i); 10411 } 10412 public List<HtmlTagStartContext> htmlTagStart() { 10413 return getRuleContexts(HtmlTagStartContext.class); 10414 } 10415 public HtmlTagStartContext htmlTagStart(int i) { 10416 return getRuleContext(HtmlTagStartContext.class,i); 10417 } 10418 public List<TbodyTagStartContext> tbodyTagStart() { 10419 return getRuleContexts(TbodyTagStartContext.class); 10420 } 10421 public TbodyTagStartContext tbodyTagStart(int i) { 10422 return getRuleContext(TbodyTagStartContext.class,i); 10423 } 10424 public List<TheadTagStartContext> theadTagStart() { 10425 return getRuleContexts(TheadTagStartContext.class); 10426 } 10427 public TheadTagStartContext theadTagStart(int i) { 10428 return getRuleContext(TheadTagStartContext.class,i); 10429 } 10430 public List<TfootTagStartContext> tfootTagStart() { 10431 return getRuleContexts(TfootTagStartContext.class); 10432 } 10433 public TfootTagStartContext tfootTagStart(int i) { 10434 return getRuleContext(TfootTagStartContext.class,i); 10435 } 10436 public List<OptgroupTagStartContext> optgroupTagStart() { 10437 return getRuleContexts(OptgroupTagStartContext.class); 10438 } 10439 public OptgroupTagStartContext optgroupTagStart(int i) { 10440 return getRuleContext(OptgroupTagStartContext.class,i); 10441 } 10442 public List<RbTagStartContext> rbTagStart() { 10443 return getRuleContexts(RbTagStartContext.class); 10444 } 10445 public RbTagStartContext rbTagStart(int i) { 10446 return getRuleContext(RbTagStartContext.class,i); 10447 } 10448 public List<RtTagStartContext> rtTagStart() { 10449 return getRuleContexts(RtTagStartContext.class); 10450 } 10451 public RtTagStartContext rtTagStart(int i) { 10452 return getRuleContext(RtTagStartContext.class,i); 10453 } 10454 public List<RtcTagStartContext> rtcTagStart() { 10455 return getRuleContexts(RtcTagStartContext.class); 10456 } 10457 public RtcTagStartContext rtcTagStart(int i) { 10458 return getRuleContext(RtcTagStartContext.class,i); 10459 } 10460 public List<RpTagStartContext> rpTagStart() { 10461 return getRuleContexts(RpTagStartContext.class); 10462 } 10463 public RpTagStartContext rpTagStart(int i) { 10464 return getRuleContext(RpTagStartContext.class,i); 10465 } 10466 public List<HtmlCommentContext> htmlComment() { 10467 return getRuleContexts(HtmlCommentContext.class); 10468 } 10469 public HtmlCommentContext htmlComment(int i) { 10470 return getRuleContext(HtmlCommentContext.class,i); 10471 } 10472 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10473 public TerminalNode CDATA(int i) { 10474 return getToken(JavadocParser.CDATA, i); 10475 } 10476 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10477 public TerminalNode NEWLINE(int i) { 10478 return getToken(JavadocParser.NEWLINE, i); 10479 } 10480 public List<TextContext> text() { 10481 return getRuleContexts(TextContext.class); 10482 } 10483 public TextContext text(int i) { 10484 return getRuleContext(TextContext.class,i); 10485 } 10486 public List<JavadocInlineTagContext> javadocInlineTag() { 10487 return getRuleContexts(JavadocInlineTagContext.class); 10488 } 10489 public JavadocInlineTagContext javadocInlineTag(int i) { 10490 return getRuleContext(JavadocInlineTagContext.class,i); 10491 } 10492 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10493 public TerminalNode LEADING_ASTERISK(int i) { 10494 return getToken(JavadocParser.LEADING_ASTERISK, i); 10495 } 10496 public OptionContext(ParserRuleContext parent, int invokingState) { 10497 super(parent, invokingState); 10498 } 10499 @Override public int getRuleIndex() { return RULE_option; } 10500 } 10501 10502 public final OptionContext option() throws RecognitionException { 10503 OptionContext _localctx = new OptionContext(_ctx, getState()); 10504 enterRule(_localctx, 82, RULE_option); 10505 try { 10506 int _alt; 10507 enterOuterAlt(_localctx, 1); 10508 { 10509 setState(1237); 10510 optionTagStart(false); 10511 setState(1287); 10512 _errHandler.sync(this); 10513 _alt = getInterpreter().adaptivePredict(_input,73,_ctx); 10514 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10515 if ( _alt==1 ) { 10516 { 10517 setState(1285); 10518 _errHandler.sync(this); 10519 switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) { 10520 case 1: 10521 { 10522 setState(1238); 10523 htmlTag(); 10524 } 10525 break; 10526 case 2: 10527 { 10528 setState(1239); 10529 singletonElement(); 10530 } 10531 break; 10532 case 3: 10533 { 10534 setState(1240); 10535 paragraph(); 10536 } 10537 break; 10538 case 4: 10539 { 10540 setState(1241); 10541 li(); 10542 } 10543 break; 10544 case 5: 10545 { 10546 setState(1242); 10547 tr(); 10548 } 10549 break; 10550 case 6: 10551 { 10552 setState(1243); 10553 td(); 10554 } 10555 break; 10556 case 7: 10557 { 10558 setState(1244); 10559 th(); 10560 } 10561 break; 10562 case 8: 10563 { 10564 setState(1245); 10565 body(); 10566 } 10567 break; 10568 case 9: 10569 { 10570 setState(1246); 10571 colgroup(); 10572 } 10573 break; 10574 case 10: 10575 { 10576 setState(1247); 10577 dd(); 10578 } 10579 break; 10580 case 11: 10581 { 10582 setState(1248); 10583 dt(); 10584 } 10585 break; 10586 case 12: 10587 { 10588 setState(1249); 10589 head(); 10590 } 10591 break; 10592 case 13: 10593 { 10594 setState(1250); 10595 html(); 10596 } 10597 break; 10598 case 14: 10599 { 10600 setState(1251); 10601 tbody(); 10602 } 10603 break; 10604 case 15: 10605 { 10606 setState(1252); 10607 thead(); 10608 } 10609 break; 10610 case 16: 10611 { 10612 setState(1253); 10613 tfoot(); 10614 } 10615 break; 10616 case 17: 10617 { 10618 setState(1254); 10619 optgroup(); 10620 } 10621 break; 10622 case 18: 10623 { 10624 setState(1255); 10625 rb(); 10626 } 10627 break; 10628 case 19: 10629 { 10630 setState(1256); 10631 rt(); 10632 } 10633 break; 10634 case 20: 10635 { 10636 setState(1257); 10637 rtc(); 10638 } 10639 break; 10640 case 21: 10641 { 10642 setState(1258); 10643 rp(); 10644 } 10645 break; 10646 case 22: 10647 { 10648 setState(1259); 10649 pTagStart(true); 10650 } 10651 break; 10652 case 23: 10653 { 10654 setState(1260); 10655 liTagStart(true); 10656 } 10657 break; 10658 case 24: 10659 { 10660 setState(1261); 10661 trTagStart(true); 10662 } 10663 break; 10664 case 25: 10665 { 10666 setState(1262); 10667 tdTagStart(true); 10668 } 10669 break; 10670 case 26: 10671 { 10672 setState(1263); 10673 thTagStart(true); 10674 } 10675 break; 10676 case 27: 10677 { 10678 setState(1264); 10679 bodyTagStart(true); 10680 } 10681 break; 10682 case 28: 10683 { 10684 setState(1265); 10685 colgroupTagStart(true); 10686 } 10687 break; 10688 case 29: 10689 { 10690 setState(1266); 10691 ddTagStart(true); 10692 } 10693 break; 10694 case 30: 10695 { 10696 setState(1267); 10697 dtTagStart(true); 10698 } 10699 break; 10700 case 31: 10701 { 10702 setState(1268); 10703 headTagStart(true); 10704 } 10705 break; 10706 case 32: 10707 { 10708 setState(1269); 10709 htmlTagStart(true); 10710 } 10711 break; 10712 case 33: 10713 { 10714 setState(1270); 10715 tbodyTagStart(true); 10716 } 10717 break; 10718 case 34: 10719 { 10720 setState(1271); 10721 theadTagStart(true); 10722 } 10723 break; 10724 case 35: 10725 { 10726 setState(1272); 10727 tfootTagStart(true); 10728 } 10729 break; 10730 case 36: 10731 { 10732 setState(1273); 10733 optgroupTagStart(true); 10734 } 10735 break; 10736 case 37: 10737 { 10738 setState(1274); 10739 rbTagStart(true); 10740 } 10741 break; 10742 case 38: 10743 { 10744 setState(1275); 10745 rtTagStart(true); 10746 } 10747 break; 10748 case 39: 10749 { 10750 setState(1276); 10751 rtcTagStart(true); 10752 } 10753 break; 10754 case 40: 10755 { 10756 setState(1277); 10757 rpTagStart(true); 10758 } 10759 break; 10760 case 41: 10761 { 10762 { 10763 setState(1278); 10764 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 10765 setState(1279); 10766 match(LEADING_ASTERISK); 10767 } 10768 } 10769 break; 10770 case 42: 10771 { 10772 setState(1280); 10773 htmlComment(); 10774 } 10775 break; 10776 case 43: 10777 { 10778 setState(1281); 10779 match(CDATA); 10780 } 10781 break; 10782 case 44: 10783 { 10784 setState(1282); 10785 match(NEWLINE); 10786 } 10787 break; 10788 case 45: 10789 { 10790 setState(1283); 10791 text(); 10792 } 10793 break; 10794 case 46: 10795 { 10796 setState(1284); 10797 javadocInlineTag(); 10798 } 10799 break; 10800 } 10801 } 10802 } 10803 setState(1289); 10804 _errHandler.sync(this); 10805 _alt = getInterpreter().adaptivePredict(_input,73,_ctx); 10806 } 10807 setState(1290); 10808 optionTagEnd(); 10809 } 10810 } 10811 catch (RecognitionException re) { 10812 _localctx.exception = re; 10813 _errHandler.reportError(this, re); 10814 _errHandler.recover(this, re); 10815 } 10816 finally { 10817 exitRule(); 10818 } 10819 return _localctx; 10820 } 10821 10822 public static class TbodyTagStartContext extends ParserRuleContext { 10823 public boolean isNonTight; 10824 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 10825 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 10826 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 10827 public List<AttributeContext> attribute() { 10828 return getRuleContexts(AttributeContext.class); 10829 } 10830 public AttributeContext attribute(int i) { 10831 return getRuleContext(AttributeContext.class,i); 10832 } 10833 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10834 public TerminalNode NEWLINE(int i) { 10835 return getToken(JavadocParser.NEWLINE, i); 10836 } 10837 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10838 public TerminalNode LEADING_ASTERISK(int i) { 10839 return getToken(JavadocParser.LEADING_ASTERISK, i); 10840 } 10841 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10842 public TerminalNode WS(int i) { 10843 return getToken(JavadocParser.WS, i); 10844 } 10845 public TbodyTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 10846 public TbodyTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 10847 super(parent, invokingState); 10848 this.isNonTight = isNonTight; 10849 } 10850 @Override public int getRuleIndex() { return RULE_tbodyTagStart; } 10851 } 10852 10853 public final TbodyTagStartContext tbodyTagStart(boolean isNonTight) throws RecognitionException { 10854 TbodyTagStartContext _localctx = new TbodyTagStartContext(_ctx, getState(), isNonTight); 10855 enterRule(_localctx, 84, RULE_tbodyTagStart); 10856 int _la; 10857 try { 10858 enterOuterAlt(_localctx, 1); 10859 { 10860 setState(1292); 10861 match(START); 10862 setState(1293); 10863 match(TBODY_HTML_TAG_NAME); 10864 setState(1300); 10865 _errHandler.sync(this); 10866 _la = _input.LA(1); 10867 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 10868 { 10869 setState(1298); 10870 _errHandler.sync(this); 10871 switch (_input.LA(1)) { 10872 case HTML_TAG_NAME: 10873 { 10874 setState(1294); 10875 attribute(); 10876 } 10877 break; 10878 case NEWLINE: 10879 { 10880 setState(1295); 10881 match(NEWLINE); 10882 } 10883 break; 10884 case LEADING_ASTERISK: 10885 { 10886 setState(1296); 10887 match(LEADING_ASTERISK); 10888 } 10889 break; 10890 case WS: 10891 { 10892 setState(1297); 10893 match(WS); 10894 } 10895 break; 10896 default: 10897 throw new NoViableAltException(this); 10898 } 10899 } 10900 setState(1302); 10901 _errHandler.sync(this); 10902 _la = _input.LA(1); 10903 } 10904 setState(1303); 10905 match(END); 10906 } 10907 _ctx.stop = _input.LT(-1); 10908 10909 if (isNonTight && nonTightTagStartContext == null) { 10910 nonTightTagStartContext = _localctx; 10911 } 10912 10913 } 10914 catch (RecognitionException re) { 10915 _localctx.exception = re; 10916 _errHandler.reportError(this, re); 10917 _errHandler.recover(this, re); 10918 } 10919 finally { 10920 exitRule(); 10921 } 10922 return _localctx; 10923 } 10924 10925 public static class TbodyTagEndContext extends ParserRuleContext { 10926 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 10927 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 10928 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 10929 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 10930 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10931 public TerminalNode NEWLINE(int i) { 10932 return getToken(JavadocParser.NEWLINE, i); 10933 } 10934 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10935 public TerminalNode LEADING_ASTERISK(int i) { 10936 return getToken(JavadocParser.LEADING_ASTERISK, i); 10937 } 10938 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10939 public TerminalNode WS(int i) { 10940 return getToken(JavadocParser.WS, i); 10941 } 10942 public TbodyTagEndContext(ParserRuleContext parent, int invokingState) { 10943 super(parent, invokingState); 10944 } 10945 @Override public int getRuleIndex() { return RULE_tbodyTagEnd; } 10946 } 10947 10948 public final TbodyTagEndContext tbodyTagEnd() throws RecognitionException { 10949 TbodyTagEndContext _localctx = new TbodyTagEndContext(_ctx, getState()); 10950 enterRule(_localctx, 86, RULE_tbodyTagEnd); 10951 int _la; 10952 try { 10953 enterOuterAlt(_localctx, 1); 10954 { 10955 setState(1305); 10956 match(START); 10957 setState(1306); 10958 match(SLASH); 10959 setState(1307); 10960 match(TBODY_HTML_TAG_NAME); 10961 setState(1311); 10962 _errHandler.sync(this); 10963 _la = _input.LA(1); 10964 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 10965 { 10966 { 10967 setState(1308); 10968 _la = _input.LA(1); 10969 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 10970 _errHandler.recoverInline(this); 10971 } 10972 else { 10973 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 10974 _errHandler.reportMatch(this); 10975 consume(); 10976 } 10977 } 10978 } 10979 setState(1313); 10980 _errHandler.sync(this); 10981 _la = _input.LA(1); 10982 } 10983 setState(1314); 10984 match(END); 10985 } 10986 } 10987 catch (RecognitionException re) { 10988 _localctx.exception = re; 10989 _errHandler.reportError(this, re); 10990 _errHandler.recover(this, re); 10991 } 10992 finally { 10993 exitRule(); 10994 } 10995 return _localctx; 10996 } 10997 10998 public static class TbodyContext extends ParserRuleContext { 10999 public TbodyTagStartContext tbodyTagStart() { 11000 return getRuleContext(TbodyTagStartContext.class,0); 11001 } 11002 public TbodyTagEndContext tbodyTagEnd() { 11003 return getRuleContext(TbodyTagEndContext.class,0); 11004 } 11005 public List<HtmlTagContext> htmlTag() { 11006 return getRuleContexts(HtmlTagContext.class); 11007 } 11008 public HtmlTagContext htmlTag(int i) { 11009 return getRuleContext(HtmlTagContext.class,i); 11010 } 11011 public List<SingletonElementContext> singletonElement() { 11012 return getRuleContexts(SingletonElementContext.class); 11013 } 11014 public SingletonElementContext singletonElement(int i) { 11015 return getRuleContext(SingletonElementContext.class,i); 11016 } 11017 public List<ParagraphContext> paragraph() { 11018 return getRuleContexts(ParagraphContext.class); 11019 } 11020 public ParagraphContext paragraph(int i) { 11021 return getRuleContext(ParagraphContext.class,i); 11022 } 11023 public List<LiContext> li() { 11024 return getRuleContexts(LiContext.class); 11025 } 11026 public LiContext li(int i) { 11027 return getRuleContext(LiContext.class,i); 11028 } 11029 public List<TrContext> tr() { 11030 return getRuleContexts(TrContext.class); 11031 } 11032 public TrContext tr(int i) { 11033 return getRuleContext(TrContext.class,i); 11034 } 11035 public List<TdContext> td() { 11036 return getRuleContexts(TdContext.class); 11037 } 11038 public TdContext td(int i) { 11039 return getRuleContext(TdContext.class,i); 11040 } 11041 public List<ThContext> th() { 11042 return getRuleContexts(ThContext.class); 11043 } 11044 public ThContext th(int i) { 11045 return getRuleContext(ThContext.class,i); 11046 } 11047 public List<BodyContext> body() { 11048 return getRuleContexts(BodyContext.class); 11049 } 11050 public BodyContext body(int i) { 11051 return getRuleContext(BodyContext.class,i); 11052 } 11053 public List<ColgroupContext> colgroup() { 11054 return getRuleContexts(ColgroupContext.class); 11055 } 11056 public ColgroupContext colgroup(int i) { 11057 return getRuleContext(ColgroupContext.class,i); 11058 } 11059 public List<DdContext> dd() { 11060 return getRuleContexts(DdContext.class); 11061 } 11062 public DdContext dd(int i) { 11063 return getRuleContext(DdContext.class,i); 11064 } 11065 public List<DtContext> dt() { 11066 return getRuleContexts(DtContext.class); 11067 } 11068 public DtContext dt(int i) { 11069 return getRuleContext(DtContext.class,i); 11070 } 11071 public List<HeadContext> head() { 11072 return getRuleContexts(HeadContext.class); 11073 } 11074 public HeadContext head(int i) { 11075 return getRuleContext(HeadContext.class,i); 11076 } 11077 public List<HtmlContext> html() { 11078 return getRuleContexts(HtmlContext.class); 11079 } 11080 public HtmlContext html(int i) { 11081 return getRuleContext(HtmlContext.class,i); 11082 } 11083 public List<OptionContext> option() { 11084 return getRuleContexts(OptionContext.class); 11085 } 11086 public OptionContext option(int i) { 11087 return getRuleContext(OptionContext.class,i); 11088 } 11089 public List<TheadContext> thead() { 11090 return getRuleContexts(TheadContext.class); 11091 } 11092 public TheadContext thead(int i) { 11093 return getRuleContext(TheadContext.class,i); 11094 } 11095 public List<TfootContext> tfoot() { 11096 return getRuleContexts(TfootContext.class); 11097 } 11098 public TfootContext tfoot(int i) { 11099 return getRuleContext(TfootContext.class,i); 11100 } 11101 public List<OptgroupContext> optgroup() { 11102 return getRuleContexts(OptgroupContext.class); 11103 } 11104 public OptgroupContext optgroup(int i) { 11105 return getRuleContext(OptgroupContext.class,i); 11106 } 11107 public List<RbContext> rb() { 11108 return getRuleContexts(RbContext.class); 11109 } 11110 public RbContext rb(int i) { 11111 return getRuleContext(RbContext.class,i); 11112 } 11113 public List<RtContext> rt() { 11114 return getRuleContexts(RtContext.class); 11115 } 11116 public RtContext rt(int i) { 11117 return getRuleContext(RtContext.class,i); 11118 } 11119 public List<RtcContext> rtc() { 11120 return getRuleContexts(RtcContext.class); 11121 } 11122 public RtcContext rtc(int i) { 11123 return getRuleContext(RtcContext.class,i); 11124 } 11125 public List<RpContext> rp() { 11126 return getRuleContexts(RpContext.class); 11127 } 11128 public RpContext rp(int i) { 11129 return getRuleContext(RpContext.class,i); 11130 } 11131 public List<PTagStartContext> pTagStart() { 11132 return getRuleContexts(PTagStartContext.class); 11133 } 11134 public PTagStartContext pTagStart(int i) { 11135 return getRuleContext(PTagStartContext.class,i); 11136 } 11137 public List<LiTagStartContext> liTagStart() { 11138 return getRuleContexts(LiTagStartContext.class); 11139 } 11140 public LiTagStartContext liTagStart(int i) { 11141 return getRuleContext(LiTagStartContext.class,i); 11142 } 11143 public List<TrTagStartContext> trTagStart() { 11144 return getRuleContexts(TrTagStartContext.class); 11145 } 11146 public TrTagStartContext trTagStart(int i) { 11147 return getRuleContext(TrTagStartContext.class,i); 11148 } 11149 public List<TdTagStartContext> tdTagStart() { 11150 return getRuleContexts(TdTagStartContext.class); 11151 } 11152 public TdTagStartContext tdTagStart(int i) { 11153 return getRuleContext(TdTagStartContext.class,i); 11154 } 11155 public List<ThTagStartContext> thTagStart() { 11156 return getRuleContexts(ThTagStartContext.class); 11157 } 11158 public ThTagStartContext thTagStart(int i) { 11159 return getRuleContext(ThTagStartContext.class,i); 11160 } 11161 public List<BodyTagStartContext> bodyTagStart() { 11162 return getRuleContexts(BodyTagStartContext.class); 11163 } 11164 public BodyTagStartContext bodyTagStart(int i) { 11165 return getRuleContext(BodyTagStartContext.class,i); 11166 } 11167 public List<ColgroupTagStartContext> colgroupTagStart() { 11168 return getRuleContexts(ColgroupTagStartContext.class); 11169 } 11170 public ColgroupTagStartContext colgroupTagStart(int i) { 11171 return getRuleContext(ColgroupTagStartContext.class,i); 11172 } 11173 public List<DdTagStartContext> ddTagStart() { 11174 return getRuleContexts(DdTagStartContext.class); 11175 } 11176 public DdTagStartContext ddTagStart(int i) { 11177 return getRuleContext(DdTagStartContext.class,i); 11178 } 11179 public List<DtTagStartContext> dtTagStart() { 11180 return getRuleContexts(DtTagStartContext.class); 11181 } 11182 public DtTagStartContext dtTagStart(int i) { 11183 return getRuleContext(DtTagStartContext.class,i); 11184 } 11185 public List<HeadTagStartContext> headTagStart() { 11186 return getRuleContexts(HeadTagStartContext.class); 11187 } 11188 public HeadTagStartContext headTagStart(int i) { 11189 return getRuleContext(HeadTagStartContext.class,i); 11190 } 11191 public List<HtmlTagStartContext> htmlTagStart() { 11192 return getRuleContexts(HtmlTagStartContext.class); 11193 } 11194 public HtmlTagStartContext htmlTagStart(int i) { 11195 return getRuleContext(HtmlTagStartContext.class,i); 11196 } 11197 public List<OptionTagStartContext> optionTagStart() { 11198 return getRuleContexts(OptionTagStartContext.class); 11199 } 11200 public OptionTagStartContext optionTagStart(int i) { 11201 return getRuleContext(OptionTagStartContext.class,i); 11202 } 11203 public List<TheadTagStartContext> theadTagStart() { 11204 return getRuleContexts(TheadTagStartContext.class); 11205 } 11206 public TheadTagStartContext theadTagStart(int i) { 11207 return getRuleContext(TheadTagStartContext.class,i); 11208 } 11209 public List<TfootTagStartContext> tfootTagStart() { 11210 return getRuleContexts(TfootTagStartContext.class); 11211 } 11212 public TfootTagStartContext tfootTagStart(int i) { 11213 return getRuleContext(TfootTagStartContext.class,i); 11214 } 11215 public List<OptgroupTagStartContext> optgroupTagStart() { 11216 return getRuleContexts(OptgroupTagStartContext.class); 11217 } 11218 public OptgroupTagStartContext optgroupTagStart(int i) { 11219 return getRuleContext(OptgroupTagStartContext.class,i); 11220 } 11221 public List<RbTagStartContext> rbTagStart() { 11222 return getRuleContexts(RbTagStartContext.class); 11223 } 11224 public RbTagStartContext rbTagStart(int i) { 11225 return getRuleContext(RbTagStartContext.class,i); 11226 } 11227 public List<RtTagStartContext> rtTagStart() { 11228 return getRuleContexts(RtTagStartContext.class); 11229 } 11230 public RtTagStartContext rtTagStart(int i) { 11231 return getRuleContext(RtTagStartContext.class,i); 11232 } 11233 public List<RtcTagStartContext> rtcTagStart() { 11234 return getRuleContexts(RtcTagStartContext.class); 11235 } 11236 public RtcTagStartContext rtcTagStart(int i) { 11237 return getRuleContext(RtcTagStartContext.class,i); 11238 } 11239 public List<RpTagStartContext> rpTagStart() { 11240 return getRuleContexts(RpTagStartContext.class); 11241 } 11242 public RpTagStartContext rpTagStart(int i) { 11243 return getRuleContext(RpTagStartContext.class,i); 11244 } 11245 public List<HtmlCommentContext> htmlComment() { 11246 return getRuleContexts(HtmlCommentContext.class); 11247 } 11248 public HtmlCommentContext htmlComment(int i) { 11249 return getRuleContext(HtmlCommentContext.class,i); 11250 } 11251 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 11252 public TerminalNode CDATA(int i) { 11253 return getToken(JavadocParser.CDATA, i); 11254 } 11255 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11256 public TerminalNode NEWLINE(int i) { 11257 return getToken(JavadocParser.NEWLINE, i); 11258 } 11259 public List<TextContext> text() { 11260 return getRuleContexts(TextContext.class); 11261 } 11262 public TextContext text(int i) { 11263 return getRuleContext(TextContext.class,i); 11264 } 11265 public List<JavadocInlineTagContext> javadocInlineTag() { 11266 return getRuleContexts(JavadocInlineTagContext.class); 11267 } 11268 public JavadocInlineTagContext javadocInlineTag(int i) { 11269 return getRuleContext(JavadocInlineTagContext.class,i); 11270 } 11271 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11272 public TerminalNode LEADING_ASTERISK(int i) { 11273 return getToken(JavadocParser.LEADING_ASTERISK, i); 11274 } 11275 public TbodyContext(ParserRuleContext parent, int invokingState) { 11276 super(parent, invokingState); 11277 } 11278 @Override public int getRuleIndex() { return RULE_tbody; } 11279 } 11280 11281 public final TbodyContext tbody() throws RecognitionException { 11282 TbodyContext _localctx = new TbodyContext(_ctx, getState()); 11283 enterRule(_localctx, 88, RULE_tbody); 11284 try { 11285 int _alt; 11286 enterOuterAlt(_localctx, 1); 11287 { 11288 setState(1316); 11289 tbodyTagStart(false); 11290 setState(1366); 11291 _errHandler.sync(this); 11292 _alt = getInterpreter().adaptivePredict(_input,78,_ctx); 11293 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 11294 if ( _alt==1 ) { 11295 { 11296 setState(1364); 11297 _errHandler.sync(this); 11298 switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) { 11299 case 1: 11300 { 11301 setState(1317); 11302 htmlTag(); 11303 } 11304 break; 11305 case 2: 11306 { 11307 setState(1318); 11308 singletonElement(); 11309 } 11310 break; 11311 case 3: 11312 { 11313 setState(1319); 11314 paragraph(); 11315 } 11316 break; 11317 case 4: 11318 { 11319 setState(1320); 11320 li(); 11321 } 11322 break; 11323 case 5: 11324 { 11325 setState(1321); 11326 tr(); 11327 } 11328 break; 11329 case 6: 11330 { 11331 setState(1322); 11332 td(); 11333 } 11334 break; 11335 case 7: 11336 { 11337 setState(1323); 11338 th(); 11339 } 11340 break; 11341 case 8: 11342 { 11343 setState(1324); 11344 body(); 11345 } 11346 break; 11347 case 9: 11348 { 11349 setState(1325); 11350 colgroup(); 11351 } 11352 break; 11353 case 10: 11354 { 11355 setState(1326); 11356 dd(); 11357 } 11358 break; 11359 case 11: 11360 { 11361 setState(1327); 11362 dt(); 11363 } 11364 break; 11365 case 12: 11366 { 11367 setState(1328); 11368 head(); 11369 } 11370 break; 11371 case 13: 11372 { 11373 setState(1329); 11374 html(); 11375 } 11376 break; 11377 case 14: 11378 { 11379 setState(1330); 11380 option(); 11381 } 11382 break; 11383 case 15: 11384 { 11385 setState(1331); 11386 thead(); 11387 } 11388 break; 11389 case 16: 11390 { 11391 setState(1332); 11392 tfoot(); 11393 } 11394 break; 11395 case 17: 11396 { 11397 setState(1333); 11398 optgroup(); 11399 } 11400 break; 11401 case 18: 11402 { 11403 setState(1334); 11404 rb(); 11405 } 11406 break; 11407 case 19: 11408 { 11409 setState(1335); 11410 rt(); 11411 } 11412 break; 11413 case 20: 11414 { 11415 setState(1336); 11416 rtc(); 11417 } 11418 break; 11419 case 21: 11420 { 11421 setState(1337); 11422 rp(); 11423 } 11424 break; 11425 case 22: 11426 { 11427 setState(1338); 11428 pTagStart(true); 11429 } 11430 break; 11431 case 23: 11432 { 11433 setState(1339); 11434 liTagStart(true); 11435 } 11436 break; 11437 case 24: 11438 { 11439 setState(1340); 11440 trTagStart(true); 11441 } 11442 break; 11443 case 25: 11444 { 11445 setState(1341); 11446 tdTagStart(true); 11447 } 11448 break; 11449 case 26: 11450 { 11451 setState(1342); 11452 thTagStart(true); 11453 } 11454 break; 11455 case 27: 11456 { 11457 setState(1343); 11458 bodyTagStart(true); 11459 } 11460 break; 11461 case 28: 11462 { 11463 setState(1344); 11464 colgroupTagStart(true); 11465 } 11466 break; 11467 case 29: 11468 { 11469 setState(1345); 11470 ddTagStart(true); 11471 } 11472 break; 11473 case 30: 11474 { 11475 setState(1346); 11476 dtTagStart(true); 11477 } 11478 break; 11479 case 31: 11480 { 11481 setState(1347); 11482 headTagStart(true); 11483 } 11484 break; 11485 case 32: 11486 { 11487 setState(1348); 11488 htmlTagStart(true); 11489 } 11490 break; 11491 case 33: 11492 { 11493 setState(1349); 11494 optionTagStart(true); 11495 } 11496 break; 11497 case 34: 11498 { 11499 setState(1350); 11500 theadTagStart(true); 11501 } 11502 break; 11503 case 35: 11504 { 11505 setState(1351); 11506 tfootTagStart(true); 11507 } 11508 break; 11509 case 36: 11510 { 11511 setState(1352); 11512 optgroupTagStart(true); 11513 } 11514 break; 11515 case 37: 11516 { 11517 setState(1353); 11518 rbTagStart(true); 11519 } 11520 break; 11521 case 38: 11522 { 11523 setState(1354); 11524 rtTagStart(true); 11525 } 11526 break; 11527 case 39: 11528 { 11529 setState(1355); 11530 rtcTagStart(true); 11531 } 11532 break; 11533 case 40: 11534 { 11535 setState(1356); 11536 rpTagStart(true); 11537 } 11538 break; 11539 case 41: 11540 { 11541 { 11542 setState(1357); 11543 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 11544 setState(1358); 11545 match(LEADING_ASTERISK); 11546 } 11547 } 11548 break; 11549 case 42: 11550 { 11551 setState(1359); 11552 htmlComment(); 11553 } 11554 break; 11555 case 43: 11556 { 11557 setState(1360); 11558 match(CDATA); 11559 } 11560 break; 11561 case 44: 11562 { 11563 setState(1361); 11564 match(NEWLINE); 11565 } 11566 break; 11567 case 45: 11568 { 11569 setState(1362); 11570 text(); 11571 } 11572 break; 11573 case 46: 11574 { 11575 setState(1363); 11576 javadocInlineTag(); 11577 } 11578 break; 11579 } 11580 } 11581 } 11582 setState(1368); 11583 _errHandler.sync(this); 11584 _alt = getInterpreter().adaptivePredict(_input,78,_ctx); 11585 } 11586 setState(1369); 11587 tbodyTagEnd(); 11588 } 11589 } 11590 catch (RecognitionException re) { 11591 _localctx.exception = re; 11592 _errHandler.reportError(this, re); 11593 _errHandler.recover(this, re); 11594 } 11595 finally { 11596 exitRule(); 11597 } 11598 return _localctx; 11599 } 11600 11601 public static class TfootTagStartContext extends ParserRuleContext { 11602 public boolean isNonTight; 11603 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 11604 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 11605 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 11606 public List<AttributeContext> attribute() { 11607 return getRuleContexts(AttributeContext.class); 11608 } 11609 public AttributeContext attribute(int i) { 11610 return getRuleContext(AttributeContext.class,i); 11611 } 11612 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11613 public TerminalNode NEWLINE(int i) { 11614 return getToken(JavadocParser.NEWLINE, i); 11615 } 11616 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11617 public TerminalNode LEADING_ASTERISK(int i) { 11618 return getToken(JavadocParser.LEADING_ASTERISK, i); 11619 } 11620 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11621 public TerminalNode WS(int i) { 11622 return getToken(JavadocParser.WS, i); 11623 } 11624 public TfootTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 11625 public TfootTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 11626 super(parent, invokingState); 11627 this.isNonTight = isNonTight; 11628 } 11629 @Override public int getRuleIndex() { return RULE_tfootTagStart; } 11630 } 11631 11632 public final TfootTagStartContext tfootTagStart(boolean isNonTight) throws RecognitionException { 11633 TfootTagStartContext _localctx = new TfootTagStartContext(_ctx, getState(), isNonTight); 11634 enterRule(_localctx, 90, RULE_tfootTagStart); 11635 int _la; 11636 try { 11637 enterOuterAlt(_localctx, 1); 11638 { 11639 setState(1371); 11640 match(START); 11641 setState(1372); 11642 match(TFOOT_HTML_TAG_NAME); 11643 setState(1379); 11644 _errHandler.sync(this); 11645 _la = _input.LA(1); 11646 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11647 { 11648 setState(1377); 11649 _errHandler.sync(this); 11650 switch (_input.LA(1)) { 11651 case HTML_TAG_NAME: 11652 { 11653 setState(1373); 11654 attribute(); 11655 } 11656 break; 11657 case NEWLINE: 11658 { 11659 setState(1374); 11660 match(NEWLINE); 11661 } 11662 break; 11663 case LEADING_ASTERISK: 11664 { 11665 setState(1375); 11666 match(LEADING_ASTERISK); 11667 } 11668 break; 11669 case WS: 11670 { 11671 setState(1376); 11672 match(WS); 11673 } 11674 break; 11675 default: 11676 throw new NoViableAltException(this); 11677 } 11678 } 11679 setState(1381); 11680 _errHandler.sync(this); 11681 _la = _input.LA(1); 11682 } 11683 setState(1382); 11684 match(END); 11685 } 11686 _ctx.stop = _input.LT(-1); 11687 11688 if (isNonTight && nonTightTagStartContext == null) { 11689 nonTightTagStartContext = _localctx; 11690 } 11691 11692 } 11693 catch (RecognitionException re) { 11694 _localctx.exception = re; 11695 _errHandler.reportError(this, re); 11696 _errHandler.recover(this, re); 11697 } 11698 finally { 11699 exitRule(); 11700 } 11701 return _localctx; 11702 } 11703 11704 public static class TfootTagEndContext extends ParserRuleContext { 11705 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 11706 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 11707 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 11708 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 11709 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11710 public TerminalNode NEWLINE(int i) { 11711 return getToken(JavadocParser.NEWLINE, i); 11712 } 11713 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11714 public TerminalNode LEADING_ASTERISK(int i) { 11715 return getToken(JavadocParser.LEADING_ASTERISK, i); 11716 } 11717 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11718 public TerminalNode WS(int i) { 11719 return getToken(JavadocParser.WS, i); 11720 } 11721 public TfootTagEndContext(ParserRuleContext parent, int invokingState) { 11722 super(parent, invokingState); 11723 } 11724 @Override public int getRuleIndex() { return RULE_tfootTagEnd; } 11725 } 11726 11727 public final TfootTagEndContext tfootTagEnd() throws RecognitionException { 11728 TfootTagEndContext _localctx = new TfootTagEndContext(_ctx, getState()); 11729 enterRule(_localctx, 92, RULE_tfootTagEnd); 11730 int _la; 11731 try { 11732 enterOuterAlt(_localctx, 1); 11733 { 11734 setState(1384); 11735 match(START); 11736 setState(1385); 11737 match(SLASH); 11738 setState(1386); 11739 match(TFOOT_HTML_TAG_NAME); 11740 setState(1390); 11741 _errHandler.sync(this); 11742 _la = _input.LA(1); 11743 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 11744 { 11745 { 11746 setState(1387); 11747 _la = _input.LA(1); 11748 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 11749 _errHandler.recoverInline(this); 11750 } 11751 else { 11752 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 11753 _errHandler.reportMatch(this); 11754 consume(); 11755 } 11756 } 11757 } 11758 setState(1392); 11759 _errHandler.sync(this); 11760 _la = _input.LA(1); 11761 } 11762 setState(1393); 11763 match(END); 11764 } 11765 } 11766 catch (RecognitionException re) { 11767 _localctx.exception = re; 11768 _errHandler.reportError(this, re); 11769 _errHandler.recover(this, re); 11770 } 11771 finally { 11772 exitRule(); 11773 } 11774 return _localctx; 11775 } 11776 11777 public static class TfootContext extends ParserRuleContext { 11778 public TfootTagStartContext tfootTagStart() { 11779 return getRuleContext(TfootTagStartContext.class,0); 11780 } 11781 public TfootTagEndContext tfootTagEnd() { 11782 return getRuleContext(TfootTagEndContext.class,0); 11783 } 11784 public List<HtmlTagContext> htmlTag() { 11785 return getRuleContexts(HtmlTagContext.class); 11786 } 11787 public HtmlTagContext htmlTag(int i) { 11788 return getRuleContext(HtmlTagContext.class,i); 11789 } 11790 public List<SingletonElementContext> singletonElement() { 11791 return getRuleContexts(SingletonElementContext.class); 11792 } 11793 public SingletonElementContext singletonElement(int i) { 11794 return getRuleContext(SingletonElementContext.class,i); 11795 } 11796 public List<ParagraphContext> paragraph() { 11797 return getRuleContexts(ParagraphContext.class); 11798 } 11799 public ParagraphContext paragraph(int i) { 11800 return getRuleContext(ParagraphContext.class,i); 11801 } 11802 public List<LiContext> li() { 11803 return getRuleContexts(LiContext.class); 11804 } 11805 public LiContext li(int i) { 11806 return getRuleContext(LiContext.class,i); 11807 } 11808 public List<TrContext> tr() { 11809 return getRuleContexts(TrContext.class); 11810 } 11811 public TrContext tr(int i) { 11812 return getRuleContext(TrContext.class,i); 11813 } 11814 public List<TdContext> td() { 11815 return getRuleContexts(TdContext.class); 11816 } 11817 public TdContext td(int i) { 11818 return getRuleContext(TdContext.class,i); 11819 } 11820 public List<ThContext> th() { 11821 return getRuleContexts(ThContext.class); 11822 } 11823 public ThContext th(int i) { 11824 return getRuleContext(ThContext.class,i); 11825 } 11826 public List<BodyContext> body() { 11827 return getRuleContexts(BodyContext.class); 11828 } 11829 public BodyContext body(int i) { 11830 return getRuleContext(BodyContext.class,i); 11831 } 11832 public List<ColgroupContext> colgroup() { 11833 return getRuleContexts(ColgroupContext.class); 11834 } 11835 public ColgroupContext colgroup(int i) { 11836 return getRuleContext(ColgroupContext.class,i); 11837 } 11838 public List<DdContext> dd() { 11839 return getRuleContexts(DdContext.class); 11840 } 11841 public DdContext dd(int i) { 11842 return getRuleContext(DdContext.class,i); 11843 } 11844 public List<DtContext> dt() { 11845 return getRuleContexts(DtContext.class); 11846 } 11847 public DtContext dt(int i) { 11848 return getRuleContext(DtContext.class,i); 11849 } 11850 public List<HeadContext> head() { 11851 return getRuleContexts(HeadContext.class); 11852 } 11853 public HeadContext head(int i) { 11854 return getRuleContext(HeadContext.class,i); 11855 } 11856 public List<HtmlContext> html() { 11857 return getRuleContexts(HtmlContext.class); 11858 } 11859 public HtmlContext html(int i) { 11860 return getRuleContext(HtmlContext.class,i); 11861 } 11862 public List<OptionContext> option() { 11863 return getRuleContexts(OptionContext.class); 11864 } 11865 public OptionContext option(int i) { 11866 return getRuleContext(OptionContext.class,i); 11867 } 11868 public List<TbodyContext> tbody() { 11869 return getRuleContexts(TbodyContext.class); 11870 } 11871 public TbodyContext tbody(int i) { 11872 return getRuleContext(TbodyContext.class,i); 11873 } 11874 public List<TheadContext> thead() { 11875 return getRuleContexts(TheadContext.class); 11876 } 11877 public TheadContext thead(int i) { 11878 return getRuleContext(TheadContext.class,i); 11879 } 11880 public List<OptgroupContext> optgroup() { 11881 return getRuleContexts(OptgroupContext.class); 11882 } 11883 public OptgroupContext optgroup(int i) { 11884 return getRuleContext(OptgroupContext.class,i); 11885 } 11886 public List<RbContext> rb() { 11887 return getRuleContexts(RbContext.class); 11888 } 11889 public RbContext rb(int i) { 11890 return getRuleContext(RbContext.class,i); 11891 } 11892 public List<RtContext> rt() { 11893 return getRuleContexts(RtContext.class); 11894 } 11895 public RtContext rt(int i) { 11896 return getRuleContext(RtContext.class,i); 11897 } 11898 public List<RtcContext> rtc() { 11899 return getRuleContexts(RtcContext.class); 11900 } 11901 public RtcContext rtc(int i) { 11902 return getRuleContext(RtcContext.class,i); 11903 } 11904 public List<RpContext> rp() { 11905 return getRuleContexts(RpContext.class); 11906 } 11907 public RpContext rp(int i) { 11908 return getRuleContext(RpContext.class,i); 11909 } 11910 public List<PTagStartContext> pTagStart() { 11911 return getRuleContexts(PTagStartContext.class); 11912 } 11913 public PTagStartContext pTagStart(int i) { 11914 return getRuleContext(PTagStartContext.class,i); 11915 } 11916 public List<LiTagStartContext> liTagStart() { 11917 return getRuleContexts(LiTagStartContext.class); 11918 } 11919 public LiTagStartContext liTagStart(int i) { 11920 return getRuleContext(LiTagStartContext.class,i); 11921 } 11922 public List<TrTagStartContext> trTagStart() { 11923 return getRuleContexts(TrTagStartContext.class); 11924 } 11925 public TrTagStartContext trTagStart(int i) { 11926 return getRuleContext(TrTagStartContext.class,i); 11927 } 11928 public List<TdTagStartContext> tdTagStart() { 11929 return getRuleContexts(TdTagStartContext.class); 11930 } 11931 public TdTagStartContext tdTagStart(int i) { 11932 return getRuleContext(TdTagStartContext.class,i); 11933 } 11934 public List<ThTagStartContext> thTagStart() { 11935 return getRuleContexts(ThTagStartContext.class); 11936 } 11937 public ThTagStartContext thTagStart(int i) { 11938 return getRuleContext(ThTagStartContext.class,i); 11939 } 11940 public List<BodyTagStartContext> bodyTagStart() { 11941 return getRuleContexts(BodyTagStartContext.class); 11942 } 11943 public BodyTagStartContext bodyTagStart(int i) { 11944 return getRuleContext(BodyTagStartContext.class,i); 11945 } 11946 public List<ColgroupTagStartContext> colgroupTagStart() { 11947 return getRuleContexts(ColgroupTagStartContext.class); 11948 } 11949 public ColgroupTagStartContext colgroupTagStart(int i) { 11950 return getRuleContext(ColgroupTagStartContext.class,i); 11951 } 11952 public List<DdTagStartContext> ddTagStart() { 11953 return getRuleContexts(DdTagStartContext.class); 11954 } 11955 public DdTagStartContext ddTagStart(int i) { 11956 return getRuleContext(DdTagStartContext.class,i); 11957 } 11958 public List<DtTagStartContext> dtTagStart() { 11959 return getRuleContexts(DtTagStartContext.class); 11960 } 11961 public DtTagStartContext dtTagStart(int i) { 11962 return getRuleContext(DtTagStartContext.class,i); 11963 } 11964 public List<HeadTagStartContext> headTagStart() { 11965 return getRuleContexts(HeadTagStartContext.class); 11966 } 11967 public HeadTagStartContext headTagStart(int i) { 11968 return getRuleContext(HeadTagStartContext.class,i); 11969 } 11970 public List<HtmlTagStartContext> htmlTagStart() { 11971 return getRuleContexts(HtmlTagStartContext.class); 11972 } 11973 public HtmlTagStartContext htmlTagStart(int i) { 11974 return getRuleContext(HtmlTagStartContext.class,i); 11975 } 11976 public List<OptionTagStartContext> optionTagStart() { 11977 return getRuleContexts(OptionTagStartContext.class); 11978 } 11979 public OptionTagStartContext optionTagStart(int i) { 11980 return getRuleContext(OptionTagStartContext.class,i); 11981 } 11982 public List<TbodyTagStartContext> tbodyTagStart() { 11983 return getRuleContexts(TbodyTagStartContext.class); 11984 } 11985 public TbodyTagStartContext tbodyTagStart(int i) { 11986 return getRuleContext(TbodyTagStartContext.class,i); 11987 } 11988 public List<TheadTagStartContext> theadTagStart() { 11989 return getRuleContexts(TheadTagStartContext.class); 11990 } 11991 public TheadTagStartContext theadTagStart(int i) { 11992 return getRuleContext(TheadTagStartContext.class,i); 11993 } 11994 public List<OptgroupTagStartContext> optgroupTagStart() { 11995 return getRuleContexts(OptgroupTagStartContext.class); 11996 } 11997 public OptgroupTagStartContext optgroupTagStart(int i) { 11998 return getRuleContext(OptgroupTagStartContext.class,i); 11999 } 12000 public List<RbTagStartContext> rbTagStart() { 12001 return getRuleContexts(RbTagStartContext.class); 12002 } 12003 public RbTagStartContext rbTagStart(int i) { 12004 return getRuleContext(RbTagStartContext.class,i); 12005 } 12006 public List<RtTagStartContext> rtTagStart() { 12007 return getRuleContexts(RtTagStartContext.class); 12008 } 12009 public RtTagStartContext rtTagStart(int i) { 12010 return getRuleContext(RtTagStartContext.class,i); 12011 } 12012 public List<RtcTagStartContext> rtcTagStart() { 12013 return getRuleContexts(RtcTagStartContext.class); 12014 } 12015 public RtcTagStartContext rtcTagStart(int i) { 12016 return getRuleContext(RtcTagStartContext.class,i); 12017 } 12018 public List<RpTagStartContext> rpTagStart() { 12019 return getRuleContexts(RpTagStartContext.class); 12020 } 12021 public RpTagStartContext rpTagStart(int i) { 12022 return getRuleContext(RpTagStartContext.class,i); 12023 } 12024 public List<HtmlCommentContext> htmlComment() { 12025 return getRuleContexts(HtmlCommentContext.class); 12026 } 12027 public HtmlCommentContext htmlComment(int i) { 12028 return getRuleContext(HtmlCommentContext.class,i); 12029 } 12030 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 12031 public TerminalNode CDATA(int i) { 12032 return getToken(JavadocParser.CDATA, i); 12033 } 12034 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12035 public TerminalNode NEWLINE(int i) { 12036 return getToken(JavadocParser.NEWLINE, i); 12037 } 12038 public List<TextContext> text() { 12039 return getRuleContexts(TextContext.class); 12040 } 12041 public TextContext text(int i) { 12042 return getRuleContext(TextContext.class,i); 12043 } 12044 public List<JavadocInlineTagContext> javadocInlineTag() { 12045 return getRuleContexts(JavadocInlineTagContext.class); 12046 } 12047 public JavadocInlineTagContext javadocInlineTag(int i) { 12048 return getRuleContext(JavadocInlineTagContext.class,i); 12049 } 12050 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12051 public TerminalNode LEADING_ASTERISK(int i) { 12052 return getToken(JavadocParser.LEADING_ASTERISK, i); 12053 } 12054 public TfootContext(ParserRuleContext parent, int invokingState) { 12055 super(parent, invokingState); 12056 } 12057 @Override public int getRuleIndex() { return RULE_tfoot; } 12058 } 12059 12060 public final TfootContext tfoot() throws RecognitionException { 12061 TfootContext _localctx = new TfootContext(_ctx, getState()); 12062 enterRule(_localctx, 94, RULE_tfoot); 12063 try { 12064 int _alt; 12065 enterOuterAlt(_localctx, 1); 12066 { 12067 setState(1395); 12068 tfootTagStart(false); 12069 setState(1445); 12070 _errHandler.sync(this); 12071 _alt = getInterpreter().adaptivePredict(_input,83,_ctx); 12072 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 12073 if ( _alt==1 ) { 12074 { 12075 setState(1443); 12076 _errHandler.sync(this); 12077 switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) { 12078 case 1: 12079 { 12080 setState(1396); 12081 htmlTag(); 12082 } 12083 break; 12084 case 2: 12085 { 12086 setState(1397); 12087 singletonElement(); 12088 } 12089 break; 12090 case 3: 12091 { 12092 setState(1398); 12093 paragraph(); 12094 } 12095 break; 12096 case 4: 12097 { 12098 setState(1399); 12099 li(); 12100 } 12101 break; 12102 case 5: 12103 { 12104 setState(1400); 12105 tr(); 12106 } 12107 break; 12108 case 6: 12109 { 12110 setState(1401); 12111 td(); 12112 } 12113 break; 12114 case 7: 12115 { 12116 setState(1402); 12117 th(); 12118 } 12119 break; 12120 case 8: 12121 { 12122 setState(1403); 12123 body(); 12124 } 12125 break; 12126 case 9: 12127 { 12128 setState(1404); 12129 colgroup(); 12130 } 12131 break; 12132 case 10: 12133 { 12134 setState(1405); 12135 dd(); 12136 } 12137 break; 12138 case 11: 12139 { 12140 setState(1406); 12141 dt(); 12142 } 12143 break; 12144 case 12: 12145 { 12146 setState(1407); 12147 head(); 12148 } 12149 break; 12150 case 13: 12151 { 12152 setState(1408); 12153 html(); 12154 } 12155 break; 12156 case 14: 12157 { 12158 setState(1409); 12159 option(); 12160 } 12161 break; 12162 case 15: 12163 { 12164 setState(1410); 12165 tbody(); 12166 } 12167 break; 12168 case 16: 12169 { 12170 setState(1411); 12171 thead(); 12172 } 12173 break; 12174 case 17: 12175 { 12176 setState(1412); 12177 optgroup(); 12178 } 12179 break; 12180 case 18: 12181 { 12182 setState(1413); 12183 rb(); 12184 } 12185 break; 12186 case 19: 12187 { 12188 setState(1414); 12189 rt(); 12190 } 12191 break; 12192 case 20: 12193 { 12194 setState(1415); 12195 rtc(); 12196 } 12197 break; 12198 case 21: 12199 { 12200 setState(1416); 12201 rp(); 12202 } 12203 break; 12204 case 22: 12205 { 12206 setState(1417); 12207 pTagStart(true); 12208 } 12209 break; 12210 case 23: 12211 { 12212 setState(1418); 12213 liTagStart(true); 12214 } 12215 break; 12216 case 24: 12217 { 12218 setState(1419); 12219 trTagStart(true); 12220 } 12221 break; 12222 case 25: 12223 { 12224 setState(1420); 12225 tdTagStart(true); 12226 } 12227 break; 12228 case 26: 12229 { 12230 setState(1421); 12231 thTagStart(true); 12232 } 12233 break; 12234 case 27: 12235 { 12236 setState(1422); 12237 bodyTagStart(true); 12238 } 12239 break; 12240 case 28: 12241 { 12242 setState(1423); 12243 colgroupTagStart(true); 12244 } 12245 break; 12246 case 29: 12247 { 12248 setState(1424); 12249 ddTagStart(true); 12250 } 12251 break; 12252 case 30: 12253 { 12254 setState(1425); 12255 dtTagStart(true); 12256 } 12257 break; 12258 case 31: 12259 { 12260 setState(1426); 12261 headTagStart(true); 12262 } 12263 break; 12264 case 32: 12265 { 12266 setState(1427); 12267 htmlTagStart(true); 12268 } 12269 break; 12270 case 33: 12271 { 12272 setState(1428); 12273 optionTagStart(true); 12274 } 12275 break; 12276 case 34: 12277 { 12278 setState(1429); 12279 tbodyTagStart(true); 12280 } 12281 break; 12282 case 35: 12283 { 12284 setState(1430); 12285 theadTagStart(true); 12286 } 12287 break; 12288 case 36: 12289 { 12290 setState(1431); 12291 optgroupTagStart(true); 12292 } 12293 break; 12294 case 37: 12295 { 12296 setState(1432); 12297 rbTagStart(true); 12298 } 12299 break; 12300 case 38: 12301 { 12302 setState(1433); 12303 rtTagStart(true); 12304 } 12305 break; 12306 case 39: 12307 { 12308 setState(1434); 12309 rtcTagStart(true); 12310 } 12311 break; 12312 case 40: 12313 { 12314 setState(1435); 12315 rpTagStart(true); 12316 } 12317 break; 12318 case 41: 12319 { 12320 { 12321 setState(1436); 12322 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 12323 setState(1437); 12324 match(LEADING_ASTERISK); 12325 } 12326 } 12327 break; 12328 case 42: 12329 { 12330 setState(1438); 12331 htmlComment(); 12332 } 12333 break; 12334 case 43: 12335 { 12336 setState(1439); 12337 match(CDATA); 12338 } 12339 break; 12340 case 44: 12341 { 12342 setState(1440); 12343 match(NEWLINE); 12344 } 12345 break; 12346 case 45: 12347 { 12348 setState(1441); 12349 text(); 12350 } 12351 break; 12352 case 46: 12353 { 12354 setState(1442); 12355 javadocInlineTag(); 12356 } 12357 break; 12358 } 12359 } 12360 } 12361 setState(1447); 12362 _errHandler.sync(this); 12363 _alt = getInterpreter().adaptivePredict(_input,83,_ctx); 12364 } 12365 setState(1448); 12366 tfootTagEnd(); 12367 } 12368 } 12369 catch (RecognitionException re) { 12370 _localctx.exception = re; 12371 _errHandler.reportError(this, re); 12372 _errHandler.recover(this, re); 12373 } 12374 finally { 12375 exitRule(); 12376 } 12377 return _localctx; 12378 } 12379 12380 public static class TheadTagStartContext extends ParserRuleContext { 12381 public boolean isNonTight; 12382 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 12383 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 12384 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 12385 public List<AttributeContext> attribute() { 12386 return getRuleContexts(AttributeContext.class); 12387 } 12388 public AttributeContext attribute(int i) { 12389 return getRuleContext(AttributeContext.class,i); 12390 } 12391 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12392 public TerminalNode NEWLINE(int i) { 12393 return getToken(JavadocParser.NEWLINE, i); 12394 } 12395 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12396 public TerminalNode LEADING_ASTERISK(int i) { 12397 return getToken(JavadocParser.LEADING_ASTERISK, i); 12398 } 12399 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12400 public TerminalNode WS(int i) { 12401 return getToken(JavadocParser.WS, i); 12402 } 12403 public TheadTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 12404 public TheadTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 12405 super(parent, invokingState); 12406 this.isNonTight = isNonTight; 12407 } 12408 @Override public int getRuleIndex() { return RULE_theadTagStart; } 12409 } 12410 12411 public final TheadTagStartContext theadTagStart(boolean isNonTight) throws RecognitionException { 12412 TheadTagStartContext _localctx = new TheadTagStartContext(_ctx, getState(), isNonTight); 12413 enterRule(_localctx, 96, RULE_theadTagStart); 12414 int _la; 12415 try { 12416 enterOuterAlt(_localctx, 1); 12417 { 12418 setState(1450); 12419 match(START); 12420 setState(1451); 12421 match(THEAD_HTML_TAG_NAME); 12422 setState(1458); 12423 _errHandler.sync(this); 12424 _la = _input.LA(1); 12425 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12426 { 12427 setState(1456); 12428 _errHandler.sync(this); 12429 switch (_input.LA(1)) { 12430 case HTML_TAG_NAME: 12431 { 12432 setState(1452); 12433 attribute(); 12434 } 12435 break; 12436 case NEWLINE: 12437 { 12438 setState(1453); 12439 match(NEWLINE); 12440 } 12441 break; 12442 case LEADING_ASTERISK: 12443 { 12444 setState(1454); 12445 match(LEADING_ASTERISK); 12446 } 12447 break; 12448 case WS: 12449 { 12450 setState(1455); 12451 match(WS); 12452 } 12453 break; 12454 default: 12455 throw new NoViableAltException(this); 12456 } 12457 } 12458 setState(1460); 12459 _errHandler.sync(this); 12460 _la = _input.LA(1); 12461 } 12462 setState(1461); 12463 match(END); 12464 } 12465 _ctx.stop = _input.LT(-1); 12466 12467 if (isNonTight && nonTightTagStartContext == null) { 12468 nonTightTagStartContext = _localctx; 12469 } 12470 12471 } 12472 catch (RecognitionException re) { 12473 _localctx.exception = re; 12474 _errHandler.reportError(this, re); 12475 _errHandler.recover(this, re); 12476 } 12477 finally { 12478 exitRule(); 12479 } 12480 return _localctx; 12481 } 12482 12483 public static class TheadTagEndContext extends ParserRuleContext { 12484 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 12485 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 12486 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 12487 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 12488 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12489 public TerminalNode NEWLINE(int i) { 12490 return getToken(JavadocParser.NEWLINE, i); 12491 } 12492 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12493 public TerminalNode LEADING_ASTERISK(int i) { 12494 return getToken(JavadocParser.LEADING_ASTERISK, i); 12495 } 12496 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12497 public TerminalNode WS(int i) { 12498 return getToken(JavadocParser.WS, i); 12499 } 12500 public TheadTagEndContext(ParserRuleContext parent, int invokingState) { 12501 super(parent, invokingState); 12502 } 12503 @Override public int getRuleIndex() { return RULE_theadTagEnd; } 12504 } 12505 12506 public final TheadTagEndContext theadTagEnd() throws RecognitionException { 12507 TheadTagEndContext _localctx = new TheadTagEndContext(_ctx, getState()); 12508 enterRule(_localctx, 98, RULE_theadTagEnd); 12509 int _la; 12510 try { 12511 enterOuterAlt(_localctx, 1); 12512 { 12513 setState(1463); 12514 match(START); 12515 setState(1464); 12516 match(SLASH); 12517 setState(1465); 12518 match(THEAD_HTML_TAG_NAME); 12519 setState(1469); 12520 _errHandler.sync(this); 12521 _la = _input.LA(1); 12522 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 12523 { 12524 { 12525 setState(1466); 12526 _la = _input.LA(1); 12527 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 12528 _errHandler.recoverInline(this); 12529 } 12530 else { 12531 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12532 _errHandler.reportMatch(this); 12533 consume(); 12534 } 12535 } 12536 } 12537 setState(1471); 12538 _errHandler.sync(this); 12539 _la = _input.LA(1); 12540 } 12541 setState(1472); 12542 match(END); 12543 } 12544 } 12545 catch (RecognitionException re) { 12546 _localctx.exception = re; 12547 _errHandler.reportError(this, re); 12548 _errHandler.recover(this, re); 12549 } 12550 finally { 12551 exitRule(); 12552 } 12553 return _localctx; 12554 } 12555 12556 public static class TheadContext extends ParserRuleContext { 12557 public TheadTagStartContext theadTagStart() { 12558 return getRuleContext(TheadTagStartContext.class,0); 12559 } 12560 public TheadTagEndContext theadTagEnd() { 12561 return getRuleContext(TheadTagEndContext.class,0); 12562 } 12563 public List<HtmlTagContext> htmlTag() { 12564 return getRuleContexts(HtmlTagContext.class); 12565 } 12566 public HtmlTagContext htmlTag(int i) { 12567 return getRuleContext(HtmlTagContext.class,i); 12568 } 12569 public List<SingletonElementContext> singletonElement() { 12570 return getRuleContexts(SingletonElementContext.class); 12571 } 12572 public SingletonElementContext singletonElement(int i) { 12573 return getRuleContext(SingletonElementContext.class,i); 12574 } 12575 public List<ParagraphContext> paragraph() { 12576 return getRuleContexts(ParagraphContext.class); 12577 } 12578 public ParagraphContext paragraph(int i) { 12579 return getRuleContext(ParagraphContext.class,i); 12580 } 12581 public List<LiContext> li() { 12582 return getRuleContexts(LiContext.class); 12583 } 12584 public LiContext li(int i) { 12585 return getRuleContext(LiContext.class,i); 12586 } 12587 public List<TrContext> tr() { 12588 return getRuleContexts(TrContext.class); 12589 } 12590 public TrContext tr(int i) { 12591 return getRuleContext(TrContext.class,i); 12592 } 12593 public List<TdContext> td() { 12594 return getRuleContexts(TdContext.class); 12595 } 12596 public TdContext td(int i) { 12597 return getRuleContext(TdContext.class,i); 12598 } 12599 public List<ThContext> th() { 12600 return getRuleContexts(ThContext.class); 12601 } 12602 public ThContext th(int i) { 12603 return getRuleContext(ThContext.class,i); 12604 } 12605 public List<BodyContext> body() { 12606 return getRuleContexts(BodyContext.class); 12607 } 12608 public BodyContext body(int i) { 12609 return getRuleContext(BodyContext.class,i); 12610 } 12611 public List<ColgroupContext> colgroup() { 12612 return getRuleContexts(ColgroupContext.class); 12613 } 12614 public ColgroupContext colgroup(int i) { 12615 return getRuleContext(ColgroupContext.class,i); 12616 } 12617 public List<DdContext> dd() { 12618 return getRuleContexts(DdContext.class); 12619 } 12620 public DdContext dd(int i) { 12621 return getRuleContext(DdContext.class,i); 12622 } 12623 public List<DtContext> dt() { 12624 return getRuleContexts(DtContext.class); 12625 } 12626 public DtContext dt(int i) { 12627 return getRuleContext(DtContext.class,i); 12628 } 12629 public List<HeadContext> head() { 12630 return getRuleContexts(HeadContext.class); 12631 } 12632 public HeadContext head(int i) { 12633 return getRuleContext(HeadContext.class,i); 12634 } 12635 public List<HtmlContext> html() { 12636 return getRuleContexts(HtmlContext.class); 12637 } 12638 public HtmlContext html(int i) { 12639 return getRuleContext(HtmlContext.class,i); 12640 } 12641 public List<OptionContext> option() { 12642 return getRuleContexts(OptionContext.class); 12643 } 12644 public OptionContext option(int i) { 12645 return getRuleContext(OptionContext.class,i); 12646 } 12647 public List<TbodyContext> tbody() { 12648 return getRuleContexts(TbodyContext.class); 12649 } 12650 public TbodyContext tbody(int i) { 12651 return getRuleContext(TbodyContext.class,i); 12652 } 12653 public List<TfootContext> tfoot() { 12654 return getRuleContexts(TfootContext.class); 12655 } 12656 public TfootContext tfoot(int i) { 12657 return getRuleContext(TfootContext.class,i); 12658 } 12659 public List<OptgroupContext> optgroup() { 12660 return getRuleContexts(OptgroupContext.class); 12661 } 12662 public OptgroupContext optgroup(int i) { 12663 return getRuleContext(OptgroupContext.class,i); 12664 } 12665 public List<RbContext> rb() { 12666 return getRuleContexts(RbContext.class); 12667 } 12668 public RbContext rb(int i) { 12669 return getRuleContext(RbContext.class,i); 12670 } 12671 public List<RtContext> rt() { 12672 return getRuleContexts(RtContext.class); 12673 } 12674 public RtContext rt(int i) { 12675 return getRuleContext(RtContext.class,i); 12676 } 12677 public List<RtcContext> rtc() { 12678 return getRuleContexts(RtcContext.class); 12679 } 12680 public RtcContext rtc(int i) { 12681 return getRuleContext(RtcContext.class,i); 12682 } 12683 public List<RpContext> rp() { 12684 return getRuleContexts(RpContext.class); 12685 } 12686 public RpContext rp(int i) { 12687 return getRuleContext(RpContext.class,i); 12688 } 12689 public List<PTagStartContext> pTagStart() { 12690 return getRuleContexts(PTagStartContext.class); 12691 } 12692 public PTagStartContext pTagStart(int i) { 12693 return getRuleContext(PTagStartContext.class,i); 12694 } 12695 public List<LiTagStartContext> liTagStart() { 12696 return getRuleContexts(LiTagStartContext.class); 12697 } 12698 public LiTagStartContext liTagStart(int i) { 12699 return getRuleContext(LiTagStartContext.class,i); 12700 } 12701 public List<TrTagStartContext> trTagStart() { 12702 return getRuleContexts(TrTagStartContext.class); 12703 } 12704 public TrTagStartContext trTagStart(int i) { 12705 return getRuleContext(TrTagStartContext.class,i); 12706 } 12707 public List<TdTagStartContext> tdTagStart() { 12708 return getRuleContexts(TdTagStartContext.class); 12709 } 12710 public TdTagStartContext tdTagStart(int i) { 12711 return getRuleContext(TdTagStartContext.class,i); 12712 } 12713 public List<ThTagStartContext> thTagStart() { 12714 return getRuleContexts(ThTagStartContext.class); 12715 } 12716 public ThTagStartContext thTagStart(int i) { 12717 return getRuleContext(ThTagStartContext.class,i); 12718 } 12719 public List<BodyTagStartContext> bodyTagStart() { 12720 return getRuleContexts(BodyTagStartContext.class); 12721 } 12722 public BodyTagStartContext bodyTagStart(int i) { 12723 return getRuleContext(BodyTagStartContext.class,i); 12724 } 12725 public List<ColgroupTagStartContext> colgroupTagStart() { 12726 return getRuleContexts(ColgroupTagStartContext.class); 12727 } 12728 public ColgroupTagStartContext colgroupTagStart(int i) { 12729 return getRuleContext(ColgroupTagStartContext.class,i); 12730 } 12731 public List<DdTagStartContext> ddTagStart() { 12732 return getRuleContexts(DdTagStartContext.class); 12733 } 12734 public DdTagStartContext ddTagStart(int i) { 12735 return getRuleContext(DdTagStartContext.class,i); 12736 } 12737 public List<DtTagStartContext> dtTagStart() { 12738 return getRuleContexts(DtTagStartContext.class); 12739 } 12740 public DtTagStartContext dtTagStart(int i) { 12741 return getRuleContext(DtTagStartContext.class,i); 12742 } 12743 public List<HeadTagStartContext> headTagStart() { 12744 return getRuleContexts(HeadTagStartContext.class); 12745 } 12746 public HeadTagStartContext headTagStart(int i) { 12747 return getRuleContext(HeadTagStartContext.class,i); 12748 } 12749 public List<HtmlTagStartContext> htmlTagStart() { 12750 return getRuleContexts(HtmlTagStartContext.class); 12751 } 12752 public HtmlTagStartContext htmlTagStart(int i) { 12753 return getRuleContext(HtmlTagStartContext.class,i); 12754 } 12755 public List<OptionTagStartContext> optionTagStart() { 12756 return getRuleContexts(OptionTagStartContext.class); 12757 } 12758 public OptionTagStartContext optionTagStart(int i) { 12759 return getRuleContext(OptionTagStartContext.class,i); 12760 } 12761 public List<TbodyTagStartContext> tbodyTagStart() { 12762 return getRuleContexts(TbodyTagStartContext.class); 12763 } 12764 public TbodyTagStartContext tbodyTagStart(int i) { 12765 return getRuleContext(TbodyTagStartContext.class,i); 12766 } 12767 public List<TfootTagStartContext> tfootTagStart() { 12768 return getRuleContexts(TfootTagStartContext.class); 12769 } 12770 public TfootTagStartContext tfootTagStart(int i) { 12771 return getRuleContext(TfootTagStartContext.class,i); 12772 } 12773 public List<OptgroupTagStartContext> optgroupTagStart() { 12774 return getRuleContexts(OptgroupTagStartContext.class); 12775 } 12776 public OptgroupTagStartContext optgroupTagStart(int i) { 12777 return getRuleContext(OptgroupTagStartContext.class,i); 12778 } 12779 public List<RbTagStartContext> rbTagStart() { 12780 return getRuleContexts(RbTagStartContext.class); 12781 } 12782 public RbTagStartContext rbTagStart(int i) { 12783 return getRuleContext(RbTagStartContext.class,i); 12784 } 12785 public List<RtTagStartContext> rtTagStart() { 12786 return getRuleContexts(RtTagStartContext.class); 12787 } 12788 public RtTagStartContext rtTagStart(int i) { 12789 return getRuleContext(RtTagStartContext.class,i); 12790 } 12791 public List<RtcTagStartContext> rtcTagStart() { 12792 return getRuleContexts(RtcTagStartContext.class); 12793 } 12794 public RtcTagStartContext rtcTagStart(int i) { 12795 return getRuleContext(RtcTagStartContext.class,i); 12796 } 12797 public List<RpTagStartContext> rpTagStart() { 12798 return getRuleContexts(RpTagStartContext.class); 12799 } 12800 public RpTagStartContext rpTagStart(int i) { 12801 return getRuleContext(RpTagStartContext.class,i); 12802 } 12803 public List<HtmlCommentContext> htmlComment() { 12804 return getRuleContexts(HtmlCommentContext.class); 12805 } 12806 public HtmlCommentContext htmlComment(int i) { 12807 return getRuleContext(HtmlCommentContext.class,i); 12808 } 12809 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 12810 public TerminalNode CDATA(int i) { 12811 return getToken(JavadocParser.CDATA, i); 12812 } 12813 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12814 public TerminalNode NEWLINE(int i) { 12815 return getToken(JavadocParser.NEWLINE, i); 12816 } 12817 public List<TextContext> text() { 12818 return getRuleContexts(TextContext.class); 12819 } 12820 public TextContext text(int i) { 12821 return getRuleContext(TextContext.class,i); 12822 } 12823 public List<JavadocInlineTagContext> javadocInlineTag() { 12824 return getRuleContexts(JavadocInlineTagContext.class); 12825 } 12826 public JavadocInlineTagContext javadocInlineTag(int i) { 12827 return getRuleContext(JavadocInlineTagContext.class,i); 12828 } 12829 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12830 public TerminalNode LEADING_ASTERISK(int i) { 12831 return getToken(JavadocParser.LEADING_ASTERISK, i); 12832 } 12833 public TheadContext(ParserRuleContext parent, int invokingState) { 12834 super(parent, invokingState); 12835 } 12836 @Override public int getRuleIndex() { return RULE_thead; } 12837 } 12838 12839 public final TheadContext thead() throws RecognitionException { 12840 TheadContext _localctx = new TheadContext(_ctx, getState()); 12841 enterRule(_localctx, 100, RULE_thead); 12842 try { 12843 int _alt; 12844 enterOuterAlt(_localctx, 1); 12845 { 12846 setState(1474); 12847 theadTagStart(false); 12848 setState(1524); 12849 _errHandler.sync(this); 12850 _alt = getInterpreter().adaptivePredict(_input,88,_ctx); 12851 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 12852 if ( _alt==1 ) { 12853 { 12854 setState(1522); 12855 _errHandler.sync(this); 12856 switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) { 12857 case 1: 12858 { 12859 setState(1475); 12860 htmlTag(); 12861 } 12862 break; 12863 case 2: 12864 { 12865 setState(1476); 12866 singletonElement(); 12867 } 12868 break; 12869 case 3: 12870 { 12871 setState(1477); 12872 paragraph(); 12873 } 12874 break; 12875 case 4: 12876 { 12877 setState(1478); 12878 li(); 12879 } 12880 break; 12881 case 5: 12882 { 12883 setState(1479); 12884 tr(); 12885 } 12886 break; 12887 case 6: 12888 { 12889 setState(1480); 12890 td(); 12891 } 12892 break; 12893 case 7: 12894 { 12895 setState(1481); 12896 th(); 12897 } 12898 break; 12899 case 8: 12900 { 12901 setState(1482); 12902 body(); 12903 } 12904 break; 12905 case 9: 12906 { 12907 setState(1483); 12908 colgroup(); 12909 } 12910 break; 12911 case 10: 12912 { 12913 setState(1484); 12914 dd(); 12915 } 12916 break; 12917 case 11: 12918 { 12919 setState(1485); 12920 dt(); 12921 } 12922 break; 12923 case 12: 12924 { 12925 setState(1486); 12926 head(); 12927 } 12928 break; 12929 case 13: 12930 { 12931 setState(1487); 12932 html(); 12933 } 12934 break; 12935 case 14: 12936 { 12937 setState(1488); 12938 option(); 12939 } 12940 break; 12941 case 15: 12942 { 12943 setState(1489); 12944 tbody(); 12945 } 12946 break; 12947 case 16: 12948 { 12949 setState(1490); 12950 tfoot(); 12951 } 12952 break; 12953 case 17: 12954 { 12955 setState(1491); 12956 optgroup(); 12957 } 12958 break; 12959 case 18: 12960 { 12961 setState(1492); 12962 rb(); 12963 } 12964 break; 12965 case 19: 12966 { 12967 setState(1493); 12968 rt(); 12969 } 12970 break; 12971 case 20: 12972 { 12973 setState(1494); 12974 rtc(); 12975 } 12976 break; 12977 case 21: 12978 { 12979 setState(1495); 12980 rp(); 12981 } 12982 break; 12983 case 22: 12984 { 12985 setState(1496); 12986 pTagStart(true); 12987 } 12988 break; 12989 case 23: 12990 { 12991 setState(1497); 12992 liTagStart(true); 12993 } 12994 break; 12995 case 24: 12996 { 12997 setState(1498); 12998 trTagStart(true); 12999 } 13000 break; 13001 case 25: 13002 { 13003 setState(1499); 13004 tdTagStart(true); 13005 } 13006 break; 13007 case 26: 13008 { 13009 setState(1500); 13010 thTagStart(true); 13011 } 13012 break; 13013 case 27: 13014 { 13015 setState(1501); 13016 bodyTagStart(true); 13017 } 13018 break; 13019 case 28: 13020 { 13021 setState(1502); 13022 colgroupTagStart(true); 13023 } 13024 break; 13025 case 29: 13026 { 13027 setState(1503); 13028 ddTagStart(true); 13029 } 13030 break; 13031 case 30: 13032 { 13033 setState(1504); 13034 dtTagStart(true); 13035 } 13036 break; 13037 case 31: 13038 { 13039 setState(1505); 13040 headTagStart(true); 13041 } 13042 break; 13043 case 32: 13044 { 13045 setState(1506); 13046 htmlTagStart(true); 13047 } 13048 break; 13049 case 33: 13050 { 13051 setState(1507); 13052 optionTagStart(true); 13053 } 13054 break; 13055 case 34: 13056 { 13057 setState(1508); 13058 tbodyTagStart(true); 13059 } 13060 break; 13061 case 35: 13062 { 13063 setState(1509); 13064 tfootTagStart(true); 13065 } 13066 break; 13067 case 36: 13068 { 13069 setState(1510); 13070 optgroupTagStart(true); 13071 } 13072 break; 13073 case 37: 13074 { 13075 setState(1511); 13076 rbTagStart(true); 13077 } 13078 break; 13079 case 38: 13080 { 13081 setState(1512); 13082 rtTagStart(true); 13083 } 13084 break; 13085 case 39: 13086 { 13087 setState(1513); 13088 rtcTagStart(true); 13089 } 13090 break; 13091 case 40: 13092 { 13093 setState(1514); 13094 rpTagStart(true); 13095 } 13096 break; 13097 case 41: 13098 { 13099 { 13100 setState(1515); 13101 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 13102 setState(1516); 13103 match(LEADING_ASTERISK); 13104 } 13105 } 13106 break; 13107 case 42: 13108 { 13109 setState(1517); 13110 htmlComment(); 13111 } 13112 break; 13113 case 43: 13114 { 13115 setState(1518); 13116 match(CDATA); 13117 } 13118 break; 13119 case 44: 13120 { 13121 setState(1519); 13122 match(NEWLINE); 13123 } 13124 break; 13125 case 45: 13126 { 13127 setState(1520); 13128 text(); 13129 } 13130 break; 13131 case 46: 13132 { 13133 setState(1521); 13134 javadocInlineTag(); 13135 } 13136 break; 13137 } 13138 } 13139 } 13140 setState(1526); 13141 _errHandler.sync(this); 13142 _alt = getInterpreter().adaptivePredict(_input,88,_ctx); 13143 } 13144 setState(1527); 13145 theadTagEnd(); 13146 } 13147 } 13148 catch (RecognitionException re) { 13149 _localctx.exception = re; 13150 _errHandler.reportError(this, re); 13151 _errHandler.recover(this, re); 13152 } 13153 finally { 13154 exitRule(); 13155 } 13156 return _localctx; 13157 } 13158 13159 public static class SingletonElementContext extends ParserRuleContext { 13160 public EmptyTagContext emptyTag() { 13161 return getRuleContext(EmptyTagContext.class,0); 13162 } 13163 public AreaTagContext areaTag() { 13164 return getRuleContext(AreaTagContext.class,0); 13165 } 13166 public BaseTagContext baseTag() { 13167 return getRuleContext(BaseTagContext.class,0); 13168 } 13169 public BasefontTagContext basefontTag() { 13170 return getRuleContext(BasefontTagContext.class,0); 13171 } 13172 public BrTagContext brTag() { 13173 return getRuleContext(BrTagContext.class,0); 13174 } 13175 public ColTagContext colTag() { 13176 return getRuleContext(ColTagContext.class,0); 13177 } 13178 public FrameTagContext frameTag() { 13179 return getRuleContext(FrameTagContext.class,0); 13180 } 13181 public HrTagContext hrTag() { 13182 return getRuleContext(HrTagContext.class,0); 13183 } 13184 public ImgTagContext imgTag() { 13185 return getRuleContext(ImgTagContext.class,0); 13186 } 13187 public InputTagContext inputTag() { 13188 return getRuleContext(InputTagContext.class,0); 13189 } 13190 public IsindexTagContext isindexTag() { 13191 return getRuleContext(IsindexTagContext.class,0); 13192 } 13193 public LinkTagContext linkTag() { 13194 return getRuleContext(LinkTagContext.class,0); 13195 } 13196 public MetaTagContext metaTag() { 13197 return getRuleContext(MetaTagContext.class,0); 13198 } 13199 public ParamTagContext paramTag() { 13200 return getRuleContext(ParamTagContext.class,0); 13201 } 13202 public EmbedTagContext embedTag() { 13203 return getRuleContext(EmbedTagContext.class,0); 13204 } 13205 public KeygenTagContext keygenTag() { 13206 return getRuleContext(KeygenTagContext.class,0); 13207 } 13208 public SourceTagContext sourceTag() { 13209 return getRuleContext(SourceTagContext.class,0); 13210 } 13211 public TrackTagContext trackTag() { 13212 return getRuleContext(TrackTagContext.class,0); 13213 } 13214 public WbrTagContext wbrTag() { 13215 return getRuleContext(WbrTagContext.class,0); 13216 } 13217 public WrongSingletonTagContext wrongSingletonTag() { 13218 return getRuleContext(WrongSingletonTagContext.class,0); 13219 } 13220 public SingletonElementContext(ParserRuleContext parent, int invokingState) { 13221 super(parent, invokingState); 13222 } 13223 @Override public int getRuleIndex() { return RULE_singletonElement; } 13224 } 13225 13226 public final SingletonElementContext singletonElement() throws RecognitionException { 13227 SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState()); 13228 enterRule(_localctx, 102, RULE_singletonElement); 13229 try { 13230 setState(1549); 13231 _errHandler.sync(this); 13232 switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) { 13233 case 1: 13234 enterOuterAlt(_localctx, 1); 13235 { 13236 setState(1529); 13237 emptyTag(); 13238 } 13239 break; 13240 case 2: 13241 enterOuterAlt(_localctx, 2); 13242 { 13243 setState(1530); 13244 areaTag(); 13245 } 13246 break; 13247 case 3: 13248 enterOuterAlt(_localctx, 3); 13249 { 13250 setState(1531); 13251 baseTag(); 13252 } 13253 break; 13254 case 4: 13255 enterOuterAlt(_localctx, 4); 13256 { 13257 setState(1532); 13258 basefontTag(); 13259 } 13260 break; 13261 case 5: 13262 enterOuterAlt(_localctx, 5); 13263 { 13264 setState(1533); 13265 brTag(); 13266 } 13267 break; 13268 case 6: 13269 enterOuterAlt(_localctx, 6); 13270 { 13271 setState(1534); 13272 colTag(); 13273 } 13274 break; 13275 case 7: 13276 enterOuterAlt(_localctx, 7); 13277 { 13278 setState(1535); 13279 frameTag(); 13280 } 13281 break; 13282 case 8: 13283 enterOuterAlt(_localctx, 8); 13284 { 13285 setState(1536); 13286 hrTag(); 13287 } 13288 break; 13289 case 9: 13290 enterOuterAlt(_localctx, 9); 13291 { 13292 setState(1537); 13293 imgTag(); 13294 } 13295 break; 13296 case 10: 13297 enterOuterAlt(_localctx, 10); 13298 { 13299 setState(1538); 13300 inputTag(); 13301 } 13302 break; 13303 case 11: 13304 enterOuterAlt(_localctx, 11); 13305 { 13306 setState(1539); 13307 isindexTag(); 13308 } 13309 break; 13310 case 12: 13311 enterOuterAlt(_localctx, 12); 13312 { 13313 setState(1540); 13314 linkTag(); 13315 } 13316 break; 13317 case 13: 13318 enterOuterAlt(_localctx, 13); 13319 { 13320 setState(1541); 13321 metaTag(); 13322 } 13323 break; 13324 case 14: 13325 enterOuterAlt(_localctx, 14); 13326 { 13327 setState(1542); 13328 paramTag(); 13329 } 13330 break; 13331 case 15: 13332 enterOuterAlt(_localctx, 15); 13333 { 13334 setState(1543); 13335 embedTag(); 13336 } 13337 break; 13338 case 16: 13339 enterOuterAlt(_localctx, 16); 13340 { 13341 setState(1544); 13342 keygenTag(); 13343 } 13344 break; 13345 case 17: 13346 enterOuterAlt(_localctx, 17); 13347 { 13348 setState(1545); 13349 sourceTag(); 13350 } 13351 break; 13352 case 18: 13353 enterOuterAlt(_localctx, 18); 13354 { 13355 setState(1546); 13356 trackTag(); 13357 } 13358 break; 13359 case 19: 13360 enterOuterAlt(_localctx, 19); 13361 { 13362 setState(1547); 13363 wbrTag(); 13364 } 13365 break; 13366 case 20: 13367 enterOuterAlt(_localctx, 20); 13368 { 13369 setState(1548); 13370 wrongSingletonTag(); 13371 } 13372 break; 13373 } 13374 } 13375 catch (RecognitionException re) { 13376 _localctx.exception = re; 13377 _errHandler.reportError(this, re); 13378 _errHandler.recover(this, re); 13379 } 13380 finally { 13381 exitRule(); 13382 } 13383 return _localctx; 13384 } 13385 13386 public static class EmptyTagContext extends ParserRuleContext { 13387 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13388 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13389 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 13390 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 13391 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 13392 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 13393 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 13394 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 13395 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 13396 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 13397 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 13398 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 13399 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 13400 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 13401 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 13402 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 13403 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 13404 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 13405 public List<AttributeContext> attribute() { 13406 return getRuleContexts(AttributeContext.class); 13407 } 13408 public AttributeContext attribute(int i) { 13409 return getRuleContext(AttributeContext.class,i); 13410 } 13411 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13412 public TerminalNode NEWLINE(int i) { 13413 return getToken(JavadocParser.NEWLINE, i); 13414 } 13415 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13416 public TerminalNode LEADING_ASTERISK(int i) { 13417 return getToken(JavadocParser.LEADING_ASTERISK, i); 13418 } 13419 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13420 public TerminalNode WS(int i) { 13421 return getToken(JavadocParser.WS, i); 13422 } 13423 public EmptyTagContext(ParserRuleContext parent, int invokingState) { 13424 super(parent, invokingState); 13425 } 13426 @Override public int getRuleIndex() { return RULE_emptyTag; } 13427 } 13428 13429 public final EmptyTagContext emptyTag() throws RecognitionException { 13430 EmptyTagContext _localctx = new EmptyTagContext(_ctx, getState()); 13431 enterRule(_localctx, 104, RULE_emptyTag); 13432 int _la; 13433 try { 13434 enterOuterAlt(_localctx, 1); 13435 { 13436 setState(1551); 13437 match(START); 13438 setState(1552); 13439 _la = _input.LA(1); 13440 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)) ) { 13441 _errHandler.recoverInline(this); 13442 } 13443 else { 13444 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13445 _errHandler.reportMatch(this); 13446 consume(); 13447 } 13448 setState(1559); 13449 _errHandler.sync(this); 13450 _la = _input.LA(1); 13451 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13452 { 13453 setState(1557); 13454 _errHandler.sync(this); 13455 switch (_input.LA(1)) { 13456 case HTML_TAG_NAME: 13457 { 13458 setState(1553); 13459 attribute(); 13460 } 13461 break; 13462 case NEWLINE: 13463 { 13464 setState(1554); 13465 match(NEWLINE); 13466 } 13467 break; 13468 case LEADING_ASTERISK: 13469 { 13470 setState(1555); 13471 match(LEADING_ASTERISK); 13472 } 13473 break; 13474 case WS: 13475 { 13476 setState(1556); 13477 match(WS); 13478 } 13479 break; 13480 default: 13481 throw new NoViableAltException(this); 13482 } 13483 } 13484 setState(1561); 13485 _errHandler.sync(this); 13486 _la = _input.LA(1); 13487 } 13488 setState(1562); 13489 match(SLASH_END); 13490 } 13491 } 13492 catch (RecognitionException re) { 13493 _localctx.exception = re; 13494 _errHandler.reportError(this, re); 13495 _errHandler.recover(this, re); 13496 } 13497 finally { 13498 exitRule(); 13499 } 13500 return _localctx; 13501 } 13502 13503 public static class AreaTagContext extends ParserRuleContext { 13504 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13505 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 13506 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13507 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 13508 public List<AttributeContext> attribute() { 13509 return getRuleContexts(AttributeContext.class); 13510 } 13511 public AttributeContext attribute(int i) { 13512 return getRuleContext(AttributeContext.class,i); 13513 } 13514 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13515 public TerminalNode NEWLINE(int i) { 13516 return getToken(JavadocParser.NEWLINE, i); 13517 } 13518 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13519 public TerminalNode LEADING_ASTERISK(int i) { 13520 return getToken(JavadocParser.LEADING_ASTERISK, i); 13521 } 13522 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13523 public TerminalNode WS(int i) { 13524 return getToken(JavadocParser.WS, i); 13525 } 13526 public AreaTagContext(ParserRuleContext parent, int invokingState) { 13527 super(parent, invokingState); 13528 } 13529 @Override public int getRuleIndex() { return RULE_areaTag; } 13530 } 13531 13532 public final AreaTagContext areaTag() throws RecognitionException { 13533 AreaTagContext _localctx = new AreaTagContext(_ctx, getState()); 13534 enterRule(_localctx, 106, RULE_areaTag); 13535 int _la; 13536 try { 13537 enterOuterAlt(_localctx, 1); 13538 { 13539 setState(1564); 13540 match(START); 13541 setState(1565); 13542 match(AREA_HTML_TAG_NAME); 13543 setState(1572); 13544 _errHandler.sync(this); 13545 _la = _input.LA(1); 13546 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13547 { 13548 setState(1570); 13549 _errHandler.sync(this); 13550 switch (_input.LA(1)) { 13551 case HTML_TAG_NAME: 13552 { 13553 setState(1566); 13554 attribute(); 13555 } 13556 break; 13557 case NEWLINE: 13558 { 13559 setState(1567); 13560 match(NEWLINE); 13561 } 13562 break; 13563 case LEADING_ASTERISK: 13564 { 13565 setState(1568); 13566 match(LEADING_ASTERISK); 13567 } 13568 break; 13569 case WS: 13570 { 13571 setState(1569); 13572 match(WS); 13573 } 13574 break; 13575 default: 13576 throw new NoViableAltException(this); 13577 } 13578 } 13579 setState(1574); 13580 _errHandler.sync(this); 13581 _la = _input.LA(1); 13582 } 13583 setState(1575); 13584 _la = _input.LA(1); 13585 if ( !(_la==END || _la==SLASH_END) ) { 13586 _errHandler.recoverInline(this); 13587 } 13588 else { 13589 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13590 _errHandler.reportMatch(this); 13591 consume(); 13592 } 13593 } 13594 } 13595 catch (RecognitionException re) { 13596 _localctx.exception = re; 13597 _errHandler.reportError(this, re); 13598 _errHandler.recover(this, re); 13599 } 13600 finally { 13601 exitRule(); 13602 } 13603 return _localctx; 13604 } 13605 13606 public static class BaseTagContext extends ParserRuleContext { 13607 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13608 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 13609 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13610 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 13611 public List<AttributeContext> attribute() { 13612 return getRuleContexts(AttributeContext.class); 13613 } 13614 public AttributeContext attribute(int i) { 13615 return getRuleContext(AttributeContext.class,i); 13616 } 13617 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13618 public TerminalNode NEWLINE(int i) { 13619 return getToken(JavadocParser.NEWLINE, i); 13620 } 13621 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13622 public TerminalNode LEADING_ASTERISK(int i) { 13623 return getToken(JavadocParser.LEADING_ASTERISK, i); 13624 } 13625 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13626 public TerminalNode WS(int i) { 13627 return getToken(JavadocParser.WS, i); 13628 } 13629 public BaseTagContext(ParserRuleContext parent, int invokingState) { 13630 super(parent, invokingState); 13631 } 13632 @Override public int getRuleIndex() { return RULE_baseTag; } 13633 } 13634 13635 public final BaseTagContext baseTag() throws RecognitionException { 13636 BaseTagContext _localctx = new BaseTagContext(_ctx, getState()); 13637 enterRule(_localctx, 108, RULE_baseTag); 13638 int _la; 13639 try { 13640 enterOuterAlt(_localctx, 1); 13641 { 13642 setState(1577); 13643 match(START); 13644 setState(1578); 13645 match(BASE_HTML_TAG_NAME); 13646 setState(1585); 13647 _errHandler.sync(this); 13648 _la = _input.LA(1); 13649 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13650 { 13651 setState(1583); 13652 _errHandler.sync(this); 13653 switch (_input.LA(1)) { 13654 case HTML_TAG_NAME: 13655 { 13656 setState(1579); 13657 attribute(); 13658 } 13659 break; 13660 case NEWLINE: 13661 { 13662 setState(1580); 13663 match(NEWLINE); 13664 } 13665 break; 13666 case LEADING_ASTERISK: 13667 { 13668 setState(1581); 13669 match(LEADING_ASTERISK); 13670 } 13671 break; 13672 case WS: 13673 { 13674 setState(1582); 13675 match(WS); 13676 } 13677 break; 13678 default: 13679 throw new NoViableAltException(this); 13680 } 13681 } 13682 setState(1587); 13683 _errHandler.sync(this); 13684 _la = _input.LA(1); 13685 } 13686 setState(1588); 13687 _la = _input.LA(1); 13688 if ( !(_la==END || _la==SLASH_END) ) { 13689 _errHandler.recoverInline(this); 13690 } 13691 else { 13692 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13693 _errHandler.reportMatch(this); 13694 consume(); 13695 } 13696 } 13697 } 13698 catch (RecognitionException re) { 13699 _localctx.exception = re; 13700 _errHandler.reportError(this, re); 13701 _errHandler.recover(this, re); 13702 } 13703 finally { 13704 exitRule(); 13705 } 13706 return _localctx; 13707 } 13708 13709 public static class BasefontTagContext extends ParserRuleContext { 13710 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13711 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 13712 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13713 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 13714 public List<AttributeContext> attribute() { 13715 return getRuleContexts(AttributeContext.class); 13716 } 13717 public AttributeContext attribute(int i) { 13718 return getRuleContext(AttributeContext.class,i); 13719 } 13720 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13721 public TerminalNode NEWLINE(int i) { 13722 return getToken(JavadocParser.NEWLINE, i); 13723 } 13724 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13725 public TerminalNode LEADING_ASTERISK(int i) { 13726 return getToken(JavadocParser.LEADING_ASTERISK, i); 13727 } 13728 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13729 public TerminalNode WS(int i) { 13730 return getToken(JavadocParser.WS, i); 13731 } 13732 public BasefontTagContext(ParserRuleContext parent, int invokingState) { 13733 super(parent, invokingState); 13734 } 13735 @Override public int getRuleIndex() { return RULE_basefontTag; } 13736 } 13737 13738 public final BasefontTagContext basefontTag() throws RecognitionException { 13739 BasefontTagContext _localctx = new BasefontTagContext(_ctx, getState()); 13740 enterRule(_localctx, 110, RULE_basefontTag); 13741 int _la; 13742 try { 13743 enterOuterAlt(_localctx, 1); 13744 { 13745 setState(1590); 13746 match(START); 13747 setState(1591); 13748 match(BASEFONT_HTML_TAG_NAME); 13749 setState(1598); 13750 _errHandler.sync(this); 13751 _la = _input.LA(1); 13752 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13753 { 13754 setState(1596); 13755 _errHandler.sync(this); 13756 switch (_input.LA(1)) { 13757 case HTML_TAG_NAME: 13758 { 13759 setState(1592); 13760 attribute(); 13761 } 13762 break; 13763 case NEWLINE: 13764 { 13765 setState(1593); 13766 match(NEWLINE); 13767 } 13768 break; 13769 case LEADING_ASTERISK: 13770 { 13771 setState(1594); 13772 match(LEADING_ASTERISK); 13773 } 13774 break; 13775 case WS: 13776 { 13777 setState(1595); 13778 match(WS); 13779 } 13780 break; 13781 default: 13782 throw new NoViableAltException(this); 13783 } 13784 } 13785 setState(1600); 13786 _errHandler.sync(this); 13787 _la = _input.LA(1); 13788 } 13789 setState(1601); 13790 _la = _input.LA(1); 13791 if ( !(_la==END || _la==SLASH_END) ) { 13792 _errHandler.recoverInline(this); 13793 } 13794 else { 13795 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13796 _errHandler.reportMatch(this); 13797 consume(); 13798 } 13799 } 13800 } 13801 catch (RecognitionException re) { 13802 _localctx.exception = re; 13803 _errHandler.reportError(this, re); 13804 _errHandler.recover(this, re); 13805 } 13806 finally { 13807 exitRule(); 13808 } 13809 return _localctx; 13810 } 13811 13812 public static class BrTagContext extends ParserRuleContext { 13813 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13814 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 13815 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13816 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 13817 public List<AttributeContext> attribute() { 13818 return getRuleContexts(AttributeContext.class); 13819 } 13820 public AttributeContext attribute(int i) { 13821 return getRuleContext(AttributeContext.class,i); 13822 } 13823 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13824 public TerminalNode NEWLINE(int i) { 13825 return getToken(JavadocParser.NEWLINE, i); 13826 } 13827 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13828 public TerminalNode LEADING_ASTERISK(int i) { 13829 return getToken(JavadocParser.LEADING_ASTERISK, i); 13830 } 13831 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13832 public TerminalNode WS(int i) { 13833 return getToken(JavadocParser.WS, i); 13834 } 13835 public BrTagContext(ParserRuleContext parent, int invokingState) { 13836 super(parent, invokingState); 13837 } 13838 @Override public int getRuleIndex() { return RULE_brTag; } 13839 } 13840 13841 public final BrTagContext brTag() throws RecognitionException { 13842 BrTagContext _localctx = new BrTagContext(_ctx, getState()); 13843 enterRule(_localctx, 112, RULE_brTag); 13844 int _la; 13845 try { 13846 enterOuterAlt(_localctx, 1); 13847 { 13848 setState(1603); 13849 match(START); 13850 setState(1604); 13851 match(BR_HTML_TAG_NAME); 13852 setState(1611); 13853 _errHandler.sync(this); 13854 _la = _input.LA(1); 13855 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13856 { 13857 setState(1609); 13858 _errHandler.sync(this); 13859 switch (_input.LA(1)) { 13860 case HTML_TAG_NAME: 13861 { 13862 setState(1605); 13863 attribute(); 13864 } 13865 break; 13866 case NEWLINE: 13867 { 13868 setState(1606); 13869 match(NEWLINE); 13870 } 13871 break; 13872 case LEADING_ASTERISK: 13873 { 13874 setState(1607); 13875 match(LEADING_ASTERISK); 13876 } 13877 break; 13878 case WS: 13879 { 13880 setState(1608); 13881 match(WS); 13882 } 13883 break; 13884 default: 13885 throw new NoViableAltException(this); 13886 } 13887 } 13888 setState(1613); 13889 _errHandler.sync(this); 13890 _la = _input.LA(1); 13891 } 13892 setState(1614); 13893 _la = _input.LA(1); 13894 if ( !(_la==END || _la==SLASH_END) ) { 13895 _errHandler.recoverInline(this); 13896 } 13897 else { 13898 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13899 _errHandler.reportMatch(this); 13900 consume(); 13901 } 13902 } 13903 } 13904 catch (RecognitionException re) { 13905 _localctx.exception = re; 13906 _errHandler.reportError(this, re); 13907 _errHandler.recover(this, re); 13908 } 13909 finally { 13910 exitRule(); 13911 } 13912 return _localctx; 13913 } 13914 13915 public static class ColTagContext extends ParserRuleContext { 13916 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13917 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 13918 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13919 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 13920 public List<AttributeContext> attribute() { 13921 return getRuleContexts(AttributeContext.class); 13922 } 13923 public AttributeContext attribute(int i) { 13924 return getRuleContext(AttributeContext.class,i); 13925 } 13926 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13927 public TerminalNode NEWLINE(int i) { 13928 return getToken(JavadocParser.NEWLINE, i); 13929 } 13930 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13931 public TerminalNode LEADING_ASTERISK(int i) { 13932 return getToken(JavadocParser.LEADING_ASTERISK, i); 13933 } 13934 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13935 public TerminalNode WS(int i) { 13936 return getToken(JavadocParser.WS, i); 13937 } 13938 public ColTagContext(ParserRuleContext parent, int invokingState) { 13939 super(parent, invokingState); 13940 } 13941 @Override public int getRuleIndex() { return RULE_colTag; } 13942 } 13943 13944 public final ColTagContext colTag() throws RecognitionException { 13945 ColTagContext _localctx = new ColTagContext(_ctx, getState()); 13946 enterRule(_localctx, 114, RULE_colTag); 13947 int _la; 13948 try { 13949 enterOuterAlt(_localctx, 1); 13950 { 13951 setState(1616); 13952 match(START); 13953 setState(1617); 13954 match(COL_HTML_TAG_NAME); 13955 setState(1624); 13956 _errHandler.sync(this); 13957 _la = _input.LA(1); 13958 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13959 { 13960 setState(1622); 13961 _errHandler.sync(this); 13962 switch (_input.LA(1)) { 13963 case HTML_TAG_NAME: 13964 { 13965 setState(1618); 13966 attribute(); 13967 } 13968 break; 13969 case NEWLINE: 13970 { 13971 setState(1619); 13972 match(NEWLINE); 13973 } 13974 break; 13975 case LEADING_ASTERISK: 13976 { 13977 setState(1620); 13978 match(LEADING_ASTERISK); 13979 } 13980 break; 13981 case WS: 13982 { 13983 setState(1621); 13984 match(WS); 13985 } 13986 break; 13987 default: 13988 throw new NoViableAltException(this); 13989 } 13990 } 13991 setState(1626); 13992 _errHandler.sync(this); 13993 _la = _input.LA(1); 13994 } 13995 setState(1627); 13996 _la = _input.LA(1); 13997 if ( !(_la==END || _la==SLASH_END) ) { 13998 _errHandler.recoverInline(this); 13999 } 14000 else { 14001 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14002 _errHandler.reportMatch(this); 14003 consume(); 14004 } 14005 } 14006 } 14007 catch (RecognitionException re) { 14008 _localctx.exception = re; 14009 _errHandler.reportError(this, re); 14010 _errHandler.recover(this, re); 14011 } 14012 finally { 14013 exitRule(); 14014 } 14015 return _localctx; 14016 } 14017 14018 public static class FrameTagContext extends ParserRuleContext { 14019 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14020 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 14021 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14022 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14023 public List<AttributeContext> attribute() { 14024 return getRuleContexts(AttributeContext.class); 14025 } 14026 public AttributeContext attribute(int i) { 14027 return getRuleContext(AttributeContext.class,i); 14028 } 14029 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14030 public TerminalNode NEWLINE(int i) { 14031 return getToken(JavadocParser.NEWLINE, i); 14032 } 14033 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14034 public TerminalNode LEADING_ASTERISK(int i) { 14035 return getToken(JavadocParser.LEADING_ASTERISK, i); 14036 } 14037 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14038 public TerminalNode WS(int i) { 14039 return getToken(JavadocParser.WS, i); 14040 } 14041 public FrameTagContext(ParserRuleContext parent, int invokingState) { 14042 super(parent, invokingState); 14043 } 14044 @Override public int getRuleIndex() { return RULE_frameTag; } 14045 } 14046 14047 public final FrameTagContext frameTag() throws RecognitionException { 14048 FrameTagContext _localctx = new FrameTagContext(_ctx, getState()); 14049 enterRule(_localctx, 116, RULE_frameTag); 14050 int _la; 14051 try { 14052 enterOuterAlt(_localctx, 1); 14053 { 14054 setState(1629); 14055 match(START); 14056 setState(1630); 14057 match(FRAME_HTML_TAG_NAME); 14058 setState(1637); 14059 _errHandler.sync(this); 14060 _la = _input.LA(1); 14061 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14062 { 14063 setState(1635); 14064 _errHandler.sync(this); 14065 switch (_input.LA(1)) { 14066 case HTML_TAG_NAME: 14067 { 14068 setState(1631); 14069 attribute(); 14070 } 14071 break; 14072 case NEWLINE: 14073 { 14074 setState(1632); 14075 match(NEWLINE); 14076 } 14077 break; 14078 case LEADING_ASTERISK: 14079 { 14080 setState(1633); 14081 match(LEADING_ASTERISK); 14082 } 14083 break; 14084 case WS: 14085 { 14086 setState(1634); 14087 match(WS); 14088 } 14089 break; 14090 default: 14091 throw new NoViableAltException(this); 14092 } 14093 } 14094 setState(1639); 14095 _errHandler.sync(this); 14096 _la = _input.LA(1); 14097 } 14098 setState(1640); 14099 _la = _input.LA(1); 14100 if ( !(_la==END || _la==SLASH_END) ) { 14101 _errHandler.recoverInline(this); 14102 } 14103 else { 14104 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14105 _errHandler.reportMatch(this); 14106 consume(); 14107 } 14108 } 14109 } 14110 catch (RecognitionException re) { 14111 _localctx.exception = re; 14112 _errHandler.reportError(this, re); 14113 _errHandler.recover(this, re); 14114 } 14115 finally { 14116 exitRule(); 14117 } 14118 return _localctx; 14119 } 14120 14121 public static class HrTagContext extends ParserRuleContext { 14122 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14123 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 14124 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14125 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14126 public List<AttributeContext> attribute() { 14127 return getRuleContexts(AttributeContext.class); 14128 } 14129 public AttributeContext attribute(int i) { 14130 return getRuleContext(AttributeContext.class,i); 14131 } 14132 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14133 public TerminalNode NEWLINE(int i) { 14134 return getToken(JavadocParser.NEWLINE, i); 14135 } 14136 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14137 public TerminalNode LEADING_ASTERISK(int i) { 14138 return getToken(JavadocParser.LEADING_ASTERISK, i); 14139 } 14140 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14141 public TerminalNode WS(int i) { 14142 return getToken(JavadocParser.WS, i); 14143 } 14144 public HrTagContext(ParserRuleContext parent, int invokingState) { 14145 super(parent, invokingState); 14146 } 14147 @Override public int getRuleIndex() { return RULE_hrTag; } 14148 } 14149 14150 public final HrTagContext hrTag() throws RecognitionException { 14151 HrTagContext _localctx = new HrTagContext(_ctx, getState()); 14152 enterRule(_localctx, 118, RULE_hrTag); 14153 int _la; 14154 try { 14155 enterOuterAlt(_localctx, 1); 14156 { 14157 setState(1642); 14158 match(START); 14159 setState(1643); 14160 match(HR_HTML_TAG_NAME); 14161 setState(1650); 14162 _errHandler.sync(this); 14163 _la = _input.LA(1); 14164 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14165 { 14166 setState(1648); 14167 _errHandler.sync(this); 14168 switch (_input.LA(1)) { 14169 case HTML_TAG_NAME: 14170 { 14171 setState(1644); 14172 attribute(); 14173 } 14174 break; 14175 case NEWLINE: 14176 { 14177 setState(1645); 14178 match(NEWLINE); 14179 } 14180 break; 14181 case LEADING_ASTERISK: 14182 { 14183 setState(1646); 14184 match(LEADING_ASTERISK); 14185 } 14186 break; 14187 case WS: 14188 { 14189 setState(1647); 14190 match(WS); 14191 } 14192 break; 14193 default: 14194 throw new NoViableAltException(this); 14195 } 14196 } 14197 setState(1652); 14198 _errHandler.sync(this); 14199 _la = _input.LA(1); 14200 } 14201 setState(1653); 14202 _la = _input.LA(1); 14203 if ( !(_la==END || _la==SLASH_END) ) { 14204 _errHandler.recoverInline(this); 14205 } 14206 else { 14207 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14208 _errHandler.reportMatch(this); 14209 consume(); 14210 } 14211 } 14212 } 14213 catch (RecognitionException re) { 14214 _localctx.exception = re; 14215 _errHandler.reportError(this, re); 14216 _errHandler.recover(this, re); 14217 } 14218 finally { 14219 exitRule(); 14220 } 14221 return _localctx; 14222 } 14223 14224 public static class ImgTagContext extends ParserRuleContext { 14225 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14226 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 14227 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14228 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14229 public List<AttributeContext> attribute() { 14230 return getRuleContexts(AttributeContext.class); 14231 } 14232 public AttributeContext attribute(int i) { 14233 return getRuleContext(AttributeContext.class,i); 14234 } 14235 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14236 public TerminalNode NEWLINE(int i) { 14237 return getToken(JavadocParser.NEWLINE, i); 14238 } 14239 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14240 public TerminalNode LEADING_ASTERISK(int i) { 14241 return getToken(JavadocParser.LEADING_ASTERISK, i); 14242 } 14243 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14244 public TerminalNode WS(int i) { 14245 return getToken(JavadocParser.WS, i); 14246 } 14247 public ImgTagContext(ParserRuleContext parent, int invokingState) { 14248 super(parent, invokingState); 14249 } 14250 @Override public int getRuleIndex() { return RULE_imgTag; } 14251 } 14252 14253 public final ImgTagContext imgTag() throws RecognitionException { 14254 ImgTagContext _localctx = new ImgTagContext(_ctx, getState()); 14255 enterRule(_localctx, 120, RULE_imgTag); 14256 int _la; 14257 try { 14258 enterOuterAlt(_localctx, 1); 14259 { 14260 setState(1655); 14261 match(START); 14262 setState(1656); 14263 match(IMG_HTML_TAG_NAME); 14264 setState(1663); 14265 _errHandler.sync(this); 14266 _la = _input.LA(1); 14267 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14268 { 14269 setState(1661); 14270 _errHandler.sync(this); 14271 switch (_input.LA(1)) { 14272 case HTML_TAG_NAME: 14273 { 14274 setState(1657); 14275 attribute(); 14276 } 14277 break; 14278 case NEWLINE: 14279 { 14280 setState(1658); 14281 match(NEWLINE); 14282 } 14283 break; 14284 case LEADING_ASTERISK: 14285 { 14286 setState(1659); 14287 match(LEADING_ASTERISK); 14288 } 14289 break; 14290 case WS: 14291 { 14292 setState(1660); 14293 match(WS); 14294 } 14295 break; 14296 default: 14297 throw new NoViableAltException(this); 14298 } 14299 } 14300 setState(1665); 14301 _errHandler.sync(this); 14302 _la = _input.LA(1); 14303 } 14304 setState(1666); 14305 _la = _input.LA(1); 14306 if ( !(_la==END || _la==SLASH_END) ) { 14307 _errHandler.recoverInline(this); 14308 } 14309 else { 14310 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14311 _errHandler.reportMatch(this); 14312 consume(); 14313 } 14314 } 14315 } 14316 catch (RecognitionException re) { 14317 _localctx.exception = re; 14318 _errHandler.reportError(this, re); 14319 _errHandler.recover(this, re); 14320 } 14321 finally { 14322 exitRule(); 14323 } 14324 return _localctx; 14325 } 14326 14327 public static class InputTagContext extends ParserRuleContext { 14328 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14329 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 14330 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14331 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14332 public List<AttributeContext> attribute() { 14333 return getRuleContexts(AttributeContext.class); 14334 } 14335 public AttributeContext attribute(int i) { 14336 return getRuleContext(AttributeContext.class,i); 14337 } 14338 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14339 public TerminalNode NEWLINE(int i) { 14340 return getToken(JavadocParser.NEWLINE, i); 14341 } 14342 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14343 public TerminalNode LEADING_ASTERISK(int i) { 14344 return getToken(JavadocParser.LEADING_ASTERISK, i); 14345 } 14346 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14347 public TerminalNode WS(int i) { 14348 return getToken(JavadocParser.WS, i); 14349 } 14350 public InputTagContext(ParserRuleContext parent, int invokingState) { 14351 super(parent, invokingState); 14352 } 14353 @Override public int getRuleIndex() { return RULE_inputTag; } 14354 } 14355 14356 public final InputTagContext inputTag() throws RecognitionException { 14357 InputTagContext _localctx = new InputTagContext(_ctx, getState()); 14358 enterRule(_localctx, 122, RULE_inputTag); 14359 int _la; 14360 try { 14361 enterOuterAlt(_localctx, 1); 14362 { 14363 setState(1668); 14364 match(START); 14365 setState(1669); 14366 match(INPUT_HTML_TAG_NAME); 14367 setState(1676); 14368 _errHandler.sync(this); 14369 _la = _input.LA(1); 14370 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14371 { 14372 setState(1674); 14373 _errHandler.sync(this); 14374 switch (_input.LA(1)) { 14375 case HTML_TAG_NAME: 14376 { 14377 setState(1670); 14378 attribute(); 14379 } 14380 break; 14381 case NEWLINE: 14382 { 14383 setState(1671); 14384 match(NEWLINE); 14385 } 14386 break; 14387 case LEADING_ASTERISK: 14388 { 14389 setState(1672); 14390 match(LEADING_ASTERISK); 14391 } 14392 break; 14393 case WS: 14394 { 14395 setState(1673); 14396 match(WS); 14397 } 14398 break; 14399 default: 14400 throw new NoViableAltException(this); 14401 } 14402 } 14403 setState(1678); 14404 _errHandler.sync(this); 14405 _la = _input.LA(1); 14406 } 14407 setState(1679); 14408 _la = _input.LA(1); 14409 if ( !(_la==END || _la==SLASH_END) ) { 14410 _errHandler.recoverInline(this); 14411 } 14412 else { 14413 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14414 _errHandler.reportMatch(this); 14415 consume(); 14416 } 14417 } 14418 } 14419 catch (RecognitionException re) { 14420 _localctx.exception = re; 14421 _errHandler.reportError(this, re); 14422 _errHandler.recover(this, re); 14423 } 14424 finally { 14425 exitRule(); 14426 } 14427 return _localctx; 14428 } 14429 14430 public static class IsindexTagContext extends ParserRuleContext { 14431 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14432 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 14433 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14434 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14435 public List<AttributeContext> attribute() { 14436 return getRuleContexts(AttributeContext.class); 14437 } 14438 public AttributeContext attribute(int i) { 14439 return getRuleContext(AttributeContext.class,i); 14440 } 14441 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14442 public TerminalNode NEWLINE(int i) { 14443 return getToken(JavadocParser.NEWLINE, i); 14444 } 14445 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14446 public TerminalNode LEADING_ASTERISK(int i) { 14447 return getToken(JavadocParser.LEADING_ASTERISK, i); 14448 } 14449 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14450 public TerminalNode WS(int i) { 14451 return getToken(JavadocParser.WS, i); 14452 } 14453 public IsindexTagContext(ParserRuleContext parent, int invokingState) { 14454 super(parent, invokingState); 14455 } 14456 @Override public int getRuleIndex() { return RULE_isindexTag; } 14457 } 14458 14459 public final IsindexTagContext isindexTag() throws RecognitionException { 14460 IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState()); 14461 enterRule(_localctx, 124, RULE_isindexTag); 14462 int _la; 14463 try { 14464 enterOuterAlt(_localctx, 1); 14465 { 14466 setState(1681); 14467 match(START); 14468 setState(1682); 14469 match(ISINDEX_HTML_TAG_NAME); 14470 setState(1689); 14471 _errHandler.sync(this); 14472 _la = _input.LA(1); 14473 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14474 { 14475 setState(1687); 14476 _errHandler.sync(this); 14477 switch (_input.LA(1)) { 14478 case HTML_TAG_NAME: 14479 { 14480 setState(1683); 14481 attribute(); 14482 } 14483 break; 14484 case NEWLINE: 14485 { 14486 setState(1684); 14487 match(NEWLINE); 14488 } 14489 break; 14490 case LEADING_ASTERISK: 14491 { 14492 setState(1685); 14493 match(LEADING_ASTERISK); 14494 } 14495 break; 14496 case WS: 14497 { 14498 setState(1686); 14499 match(WS); 14500 } 14501 break; 14502 default: 14503 throw new NoViableAltException(this); 14504 } 14505 } 14506 setState(1691); 14507 _errHandler.sync(this); 14508 _la = _input.LA(1); 14509 } 14510 setState(1692); 14511 _la = _input.LA(1); 14512 if ( !(_la==END || _la==SLASH_END) ) { 14513 _errHandler.recoverInline(this); 14514 } 14515 else { 14516 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14517 _errHandler.reportMatch(this); 14518 consume(); 14519 } 14520 } 14521 } 14522 catch (RecognitionException re) { 14523 _localctx.exception = re; 14524 _errHandler.reportError(this, re); 14525 _errHandler.recover(this, re); 14526 } 14527 finally { 14528 exitRule(); 14529 } 14530 return _localctx; 14531 } 14532 14533 public static class LinkTagContext extends ParserRuleContext { 14534 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14535 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 14536 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14537 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14538 public List<AttributeContext> attribute() { 14539 return getRuleContexts(AttributeContext.class); 14540 } 14541 public AttributeContext attribute(int i) { 14542 return getRuleContext(AttributeContext.class,i); 14543 } 14544 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14545 public TerminalNode NEWLINE(int i) { 14546 return getToken(JavadocParser.NEWLINE, i); 14547 } 14548 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14549 public TerminalNode LEADING_ASTERISK(int i) { 14550 return getToken(JavadocParser.LEADING_ASTERISK, i); 14551 } 14552 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14553 public TerminalNode WS(int i) { 14554 return getToken(JavadocParser.WS, i); 14555 } 14556 public LinkTagContext(ParserRuleContext parent, int invokingState) { 14557 super(parent, invokingState); 14558 } 14559 @Override public int getRuleIndex() { return RULE_linkTag; } 14560 } 14561 14562 public final LinkTagContext linkTag() throws RecognitionException { 14563 LinkTagContext _localctx = new LinkTagContext(_ctx, getState()); 14564 enterRule(_localctx, 126, RULE_linkTag); 14565 int _la; 14566 try { 14567 enterOuterAlt(_localctx, 1); 14568 { 14569 setState(1694); 14570 match(START); 14571 setState(1695); 14572 match(LINK_HTML_TAG_NAME); 14573 setState(1702); 14574 _errHandler.sync(this); 14575 _la = _input.LA(1); 14576 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14577 { 14578 setState(1700); 14579 _errHandler.sync(this); 14580 switch (_input.LA(1)) { 14581 case HTML_TAG_NAME: 14582 { 14583 setState(1696); 14584 attribute(); 14585 } 14586 break; 14587 case NEWLINE: 14588 { 14589 setState(1697); 14590 match(NEWLINE); 14591 } 14592 break; 14593 case LEADING_ASTERISK: 14594 { 14595 setState(1698); 14596 match(LEADING_ASTERISK); 14597 } 14598 break; 14599 case WS: 14600 { 14601 setState(1699); 14602 match(WS); 14603 } 14604 break; 14605 default: 14606 throw new NoViableAltException(this); 14607 } 14608 } 14609 setState(1704); 14610 _errHandler.sync(this); 14611 _la = _input.LA(1); 14612 } 14613 setState(1705); 14614 _la = _input.LA(1); 14615 if ( !(_la==END || _la==SLASH_END) ) { 14616 _errHandler.recoverInline(this); 14617 } 14618 else { 14619 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14620 _errHandler.reportMatch(this); 14621 consume(); 14622 } 14623 } 14624 } 14625 catch (RecognitionException re) { 14626 _localctx.exception = re; 14627 _errHandler.reportError(this, re); 14628 _errHandler.recover(this, re); 14629 } 14630 finally { 14631 exitRule(); 14632 } 14633 return _localctx; 14634 } 14635 14636 public static class MetaTagContext extends ParserRuleContext { 14637 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14638 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 14639 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14640 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14641 public List<AttributeContext> attribute() { 14642 return getRuleContexts(AttributeContext.class); 14643 } 14644 public AttributeContext attribute(int i) { 14645 return getRuleContext(AttributeContext.class,i); 14646 } 14647 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14648 public TerminalNode NEWLINE(int i) { 14649 return getToken(JavadocParser.NEWLINE, i); 14650 } 14651 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14652 public TerminalNode LEADING_ASTERISK(int i) { 14653 return getToken(JavadocParser.LEADING_ASTERISK, i); 14654 } 14655 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14656 public TerminalNode WS(int i) { 14657 return getToken(JavadocParser.WS, i); 14658 } 14659 public MetaTagContext(ParserRuleContext parent, int invokingState) { 14660 super(parent, invokingState); 14661 } 14662 @Override public int getRuleIndex() { return RULE_metaTag; } 14663 } 14664 14665 public final MetaTagContext metaTag() throws RecognitionException { 14666 MetaTagContext _localctx = new MetaTagContext(_ctx, getState()); 14667 enterRule(_localctx, 128, RULE_metaTag); 14668 int _la; 14669 try { 14670 enterOuterAlt(_localctx, 1); 14671 { 14672 setState(1707); 14673 match(START); 14674 setState(1708); 14675 match(META_HTML_TAG_NAME); 14676 setState(1715); 14677 _errHandler.sync(this); 14678 _la = _input.LA(1); 14679 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14680 { 14681 setState(1713); 14682 _errHandler.sync(this); 14683 switch (_input.LA(1)) { 14684 case HTML_TAG_NAME: 14685 { 14686 setState(1709); 14687 attribute(); 14688 } 14689 break; 14690 case NEWLINE: 14691 { 14692 setState(1710); 14693 match(NEWLINE); 14694 } 14695 break; 14696 case LEADING_ASTERISK: 14697 { 14698 setState(1711); 14699 match(LEADING_ASTERISK); 14700 } 14701 break; 14702 case WS: 14703 { 14704 setState(1712); 14705 match(WS); 14706 } 14707 break; 14708 default: 14709 throw new NoViableAltException(this); 14710 } 14711 } 14712 setState(1717); 14713 _errHandler.sync(this); 14714 _la = _input.LA(1); 14715 } 14716 setState(1718); 14717 _la = _input.LA(1); 14718 if ( !(_la==END || _la==SLASH_END) ) { 14719 _errHandler.recoverInline(this); 14720 } 14721 else { 14722 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14723 _errHandler.reportMatch(this); 14724 consume(); 14725 } 14726 } 14727 } 14728 catch (RecognitionException re) { 14729 _localctx.exception = re; 14730 _errHandler.reportError(this, re); 14731 _errHandler.recover(this, re); 14732 } 14733 finally { 14734 exitRule(); 14735 } 14736 return _localctx; 14737 } 14738 14739 public static class ParamTagContext extends ParserRuleContext { 14740 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14741 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 14742 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14743 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14744 public List<AttributeContext> attribute() { 14745 return getRuleContexts(AttributeContext.class); 14746 } 14747 public AttributeContext attribute(int i) { 14748 return getRuleContext(AttributeContext.class,i); 14749 } 14750 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14751 public TerminalNode NEWLINE(int i) { 14752 return getToken(JavadocParser.NEWLINE, i); 14753 } 14754 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14755 public TerminalNode LEADING_ASTERISK(int i) { 14756 return getToken(JavadocParser.LEADING_ASTERISK, i); 14757 } 14758 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14759 public TerminalNode WS(int i) { 14760 return getToken(JavadocParser.WS, i); 14761 } 14762 public ParamTagContext(ParserRuleContext parent, int invokingState) { 14763 super(parent, invokingState); 14764 } 14765 @Override public int getRuleIndex() { return RULE_paramTag; } 14766 } 14767 14768 public final ParamTagContext paramTag() throws RecognitionException { 14769 ParamTagContext _localctx = new ParamTagContext(_ctx, getState()); 14770 enterRule(_localctx, 130, RULE_paramTag); 14771 int _la; 14772 try { 14773 enterOuterAlt(_localctx, 1); 14774 { 14775 setState(1720); 14776 match(START); 14777 setState(1721); 14778 match(PARAM_HTML_TAG_NAME); 14779 setState(1728); 14780 _errHandler.sync(this); 14781 _la = _input.LA(1); 14782 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14783 { 14784 setState(1726); 14785 _errHandler.sync(this); 14786 switch (_input.LA(1)) { 14787 case HTML_TAG_NAME: 14788 { 14789 setState(1722); 14790 attribute(); 14791 } 14792 break; 14793 case NEWLINE: 14794 { 14795 setState(1723); 14796 match(NEWLINE); 14797 } 14798 break; 14799 case LEADING_ASTERISK: 14800 { 14801 setState(1724); 14802 match(LEADING_ASTERISK); 14803 } 14804 break; 14805 case WS: 14806 { 14807 setState(1725); 14808 match(WS); 14809 } 14810 break; 14811 default: 14812 throw new NoViableAltException(this); 14813 } 14814 } 14815 setState(1730); 14816 _errHandler.sync(this); 14817 _la = _input.LA(1); 14818 } 14819 setState(1731); 14820 _la = _input.LA(1); 14821 if ( !(_la==END || _la==SLASH_END) ) { 14822 _errHandler.recoverInline(this); 14823 } 14824 else { 14825 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14826 _errHandler.reportMatch(this); 14827 consume(); 14828 } 14829 } 14830 } 14831 catch (RecognitionException re) { 14832 _localctx.exception = re; 14833 _errHandler.reportError(this, re); 14834 _errHandler.recover(this, re); 14835 } 14836 finally { 14837 exitRule(); 14838 } 14839 return _localctx; 14840 } 14841 14842 public static class WrongSingletonTagContext extends ParserRuleContext { 14843 public SingletonTagNameContext singletonTagName; 14844 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14845 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 14846 public SingletonTagNameContext singletonTagName() { 14847 return getRuleContext(SingletonTagNameContext.class,0); 14848 } 14849 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14850 public WrongSingletonTagContext(ParserRuleContext parent, int invokingState) { 14851 super(parent, invokingState); 14852 } 14853 @Override public int getRuleIndex() { return RULE_wrongSingletonTag; } 14854 } 14855 14856 public final WrongSingletonTagContext wrongSingletonTag() throws RecognitionException { 14857 WrongSingletonTagContext _localctx = new WrongSingletonTagContext(_ctx, getState()); 14858 enterRule(_localctx, 132, RULE_wrongSingletonTag); 14859 try { 14860 enterOuterAlt(_localctx, 1); 14861 { 14862 setState(1733); 14863 match(START); 14864 setState(1734); 14865 match(SLASH); 14866 setState(1735); 14867 ((WrongSingletonTagContext)_localctx).singletonTagName = singletonTagName(); 14868 setState(1736); 14869 match(END); 14870 notifyErrorListeners((((WrongSingletonTagContext)_localctx).singletonTagName!=null?(((WrongSingletonTagContext)_localctx).singletonTagName.start):null), 14871 "javadoc.wrong.singleton.html.tag", null); 14872 } 14873 } 14874 catch (RecognitionException re) { 14875 _localctx.exception = re; 14876 _errHandler.reportError(this, re); 14877 _errHandler.recover(this, re); 14878 } 14879 finally { 14880 exitRule(); 14881 } 14882 return _localctx; 14883 } 14884 14885 public static class SingletonTagNameContext extends ParserRuleContext { 14886 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 14887 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 14888 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 14889 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 14890 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 14891 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 14892 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 14893 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 14894 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 14895 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 14896 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 14897 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 14898 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 14899 public TerminalNode EMBED_HTML_TAG_NAME() { return getToken(JavadocParser.EMBED_HTML_TAG_NAME, 0); } 14900 public TerminalNode KEYGEN_HTML_TAG_NAME() { return getToken(JavadocParser.KEYGEN_HTML_TAG_NAME, 0); } 14901 public TerminalNode SOURCE_HTML_TAG_NAME() { return getToken(JavadocParser.SOURCE_HTML_TAG_NAME, 0); } 14902 public TerminalNode TRACK_HTML_TAG_NAME() { return getToken(JavadocParser.TRACK_HTML_TAG_NAME, 0); } 14903 public TerminalNode WBR_HTML_TAG_NAME() { return getToken(JavadocParser.WBR_HTML_TAG_NAME, 0); } 14904 public SingletonTagNameContext(ParserRuleContext parent, int invokingState) { 14905 super(parent, invokingState); 14906 } 14907 @Override public int getRuleIndex() { return RULE_singletonTagName; } 14908 } 14909 14910 public final SingletonTagNameContext singletonTagName() throws RecognitionException { 14911 SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState()); 14912 enterRule(_localctx, 134, RULE_singletonTagName); 14913 int _la; 14914 try { 14915 enterOuterAlt(_localctx, 1); 14916 { 14917 setState(1739); 14918 _la = _input.LA(1); 14919 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)) ) { 14920 _errHandler.recoverInline(this); 14921 } 14922 else { 14923 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14924 _errHandler.reportMatch(this); 14925 consume(); 14926 } 14927 } 14928 } 14929 catch (RecognitionException re) { 14930 _localctx.exception = re; 14931 _errHandler.reportError(this, re); 14932 _errHandler.recover(this, re); 14933 } 14934 finally { 14935 exitRule(); 14936 } 14937 return _localctx; 14938 } 14939 14940 public static class DescriptionContext extends ParserRuleContext { 14941 public List<HtmlCommentContext> htmlComment() { 14942 return getRuleContexts(HtmlCommentContext.class); 14943 } 14944 public HtmlCommentContext htmlComment(int i) { 14945 return getRuleContext(HtmlCommentContext.class,i); 14946 } 14947 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 14948 public TerminalNode CDATA(int i) { 14949 return getToken(JavadocParser.CDATA, i); 14950 } 14951 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14952 public TerminalNode NEWLINE(int i) { 14953 return getToken(JavadocParser.NEWLINE, i); 14954 } 14955 public List<TextContext> text() { 14956 return getRuleContexts(TextContext.class); 14957 } 14958 public TextContext text(int i) { 14959 return getRuleContext(TextContext.class,i); 14960 } 14961 public List<JavadocInlineTagContext> javadocInlineTag() { 14962 return getRuleContexts(JavadocInlineTagContext.class); 14963 } 14964 public JavadocInlineTagContext javadocInlineTag(int i) { 14965 return getRuleContext(JavadocInlineTagContext.class,i); 14966 } 14967 public List<HtmlElementContext> htmlElement() { 14968 return getRuleContexts(HtmlElementContext.class); 14969 } 14970 public HtmlElementContext htmlElement(int i) { 14971 return getRuleContext(HtmlElementContext.class,i); 14972 } 14973 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14974 public TerminalNode LEADING_ASTERISK(int i) { 14975 return getToken(JavadocParser.LEADING_ASTERISK, i); 14976 } 14977 public DescriptionContext(ParserRuleContext parent, int invokingState) { 14978 super(parent, invokingState); 14979 } 14980 @Override public int getRuleIndex() { return RULE_description; } 14981 } 14982 14983 public final DescriptionContext description() throws RecognitionException { 14984 DescriptionContext _localctx = new DescriptionContext(_ctx, getState()); 14985 enterRule(_localctx, 136, RULE_description); 14986 try { 14987 int _alt; 14988 enterOuterAlt(_localctx, 1); 14989 { 14990 setState(1749); 14991 _errHandler.sync(this); 14992 _alt = 1; 14993 do { 14994 switch (_alt) { 14995 case 1: 14996 { 14997 setState(1749); 14998 _errHandler.sync(this); 14999 switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) { 15000 case 1: 15001 { 15002 { 15003 setState(1741); 15004 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 15005 setState(1742); 15006 match(LEADING_ASTERISK); 15007 } 15008 } 15009 break; 15010 case 2: 15011 { 15012 setState(1743); 15013 htmlComment(); 15014 } 15015 break; 15016 case 3: 15017 { 15018 setState(1744); 15019 match(CDATA); 15020 } 15021 break; 15022 case 4: 15023 { 15024 setState(1745); 15025 match(NEWLINE); 15026 } 15027 break; 15028 case 5: 15029 { 15030 setState(1746); 15031 text(); 15032 } 15033 break; 15034 case 6: 15035 { 15036 setState(1747); 15037 javadocInlineTag(); 15038 } 15039 break; 15040 case 7: 15041 { 15042 setState(1748); 15043 htmlElement(); 15044 } 15045 break; 15046 } 15047 } 15048 break; 15049 default: 15050 throw new NoViableAltException(this); 15051 } 15052 setState(1751); 15053 _errHandler.sync(this); 15054 _alt = getInterpreter().adaptivePredict(_input,119,_ctx); 15055 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15056 } 15057 } 15058 catch (RecognitionException re) { 15059 _localctx.exception = re; 15060 _errHandler.reportError(this, re); 15061 _errHandler.recover(this, re); 15062 } 15063 finally { 15064 exitRule(); 15065 } 15066 return _localctx; 15067 } 15068 15069 public static class ReferenceContext extends ParserRuleContext { 15070 public TerminalNode PACKAGE_CLASS() { return getToken(JavadocParser.PACKAGE_CLASS, 0); } 15071 public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); } 15072 public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); } 15073 public ParametersContext parameters() { 15074 return getRuleContext(ParametersContext.class,0); 15075 } 15076 public ReferenceContext(ParserRuleContext parent, int invokingState) { 15077 super(parent, invokingState); 15078 } 15079 @Override public int getRuleIndex() { return RULE_reference; } 15080 } 15081 15082 public final ReferenceContext reference() throws RecognitionException { 15083 ReferenceContext _localctx = new ReferenceContext(_ctx, getState()); 15084 enterRule(_localctx, 138, RULE_reference); 15085 int _la; 15086 try { 15087 setState(1766); 15088 _errHandler.sync(this); 15089 switch (_input.LA(1)) { 15090 case PACKAGE_CLASS: 15091 enterOuterAlt(_localctx, 1); 15092 { 15093 setState(1753); 15094 match(PACKAGE_CLASS); 15095 setState(1759); 15096 _errHandler.sync(this); 15097 _la = _input.LA(1); 15098 if (_la==HASH) { 15099 { 15100 setState(1754); 15101 match(HASH); 15102 setState(1755); 15103 match(MEMBER); 15104 setState(1757); 15105 _errHandler.sync(this); 15106 _la = _input.LA(1); 15107 if (_la==LEFT_BRACE) { 15108 { 15109 setState(1756); 15110 parameters(); 15111 } 15112 } 15113 15114 } 15115 } 15116 15117 } 15118 break; 15119 case HASH: 15120 enterOuterAlt(_localctx, 2); 15121 { 15122 setState(1761); 15123 match(HASH); 15124 setState(1762); 15125 match(MEMBER); 15126 setState(1764); 15127 _errHandler.sync(this); 15128 _la = _input.LA(1); 15129 if (_la==LEFT_BRACE) { 15130 { 15131 setState(1763); 15132 parameters(); 15133 } 15134 } 15135 15136 } 15137 break; 15138 default: 15139 throw new NoViableAltException(this); 15140 } 15141 } 15142 catch (RecognitionException re) { 15143 _localctx.exception = re; 15144 _errHandler.reportError(this, re); 15145 _errHandler.recover(this, re); 15146 } 15147 finally { 15148 exitRule(); 15149 } 15150 return _localctx; 15151 } 15152 15153 public static class ParametersContext extends ParserRuleContext { 15154 public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); } 15155 public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); } 15156 public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); } 15157 public TerminalNode ARGUMENT(int i) { 15158 return getToken(JavadocParser.ARGUMENT, i); 15159 } 15160 public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); } 15161 public TerminalNode COMMA(int i) { 15162 return getToken(JavadocParser.COMMA, i); 15163 } 15164 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15165 public TerminalNode WS(int i) { 15166 return getToken(JavadocParser.WS, i); 15167 } 15168 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15169 public TerminalNode NEWLINE(int i) { 15170 return getToken(JavadocParser.NEWLINE, i); 15171 } 15172 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15173 public TerminalNode LEADING_ASTERISK(int i) { 15174 return getToken(JavadocParser.LEADING_ASTERISK, i); 15175 } 15176 public ParametersContext(ParserRuleContext parent, int invokingState) { 15177 super(parent, invokingState); 15178 } 15179 @Override public int getRuleIndex() { return RULE_parameters; } 15180 } 15181 15182 public final ParametersContext parameters() throws RecognitionException { 15183 ParametersContext _localctx = new ParametersContext(_ctx, getState()); 15184 enterRule(_localctx, 140, RULE_parameters); 15185 int _la; 15186 try { 15187 enterOuterAlt(_localctx, 1); 15188 { 15189 setState(1768); 15190 match(LEFT_BRACE); 15191 setState(1772); 15192 _errHandler.sync(this); 15193 _la = _input.LA(1); 15194 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) { 15195 { 15196 { 15197 setState(1769); 15198 _la = _input.LA(1); 15199 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) { 15200 _errHandler.recoverInline(this); 15201 } 15202 else { 15203 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15204 _errHandler.reportMatch(this); 15205 consume(); 15206 } 15207 } 15208 } 15209 setState(1774); 15210 _errHandler.sync(this); 15211 _la = _input.LA(1); 15212 } 15213 setState(1775); 15214 match(RIGHT_BRACE); 15215 } 15216 } 15217 catch (RecognitionException re) { 15218 _localctx.exception = re; 15219 _errHandler.reportError(this, re); 15220 _errHandler.recover(this, re); 15221 } 15222 finally { 15223 exitRule(); 15224 } 15225 return _localctx; 15226 } 15227 15228 public static class JavadocTagContext extends ParserRuleContext { 15229 public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); } 15230 public DescriptionContext description() { 15231 return getRuleContext(DescriptionContext.class,0); 15232 } 15233 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15234 public TerminalNode WS(int i) { 15235 return getToken(JavadocParser.WS, i); 15236 } 15237 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15238 public TerminalNode NEWLINE(int i) { 15239 return getToken(JavadocParser.NEWLINE, i); 15240 } 15241 public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); } 15242 public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); } 15243 public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); } 15244 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15245 public TerminalNode LEADING_ASTERISK(int i) { 15246 return getToken(JavadocParser.LEADING_ASTERISK, i); 15247 } 15248 public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); } 15249 public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); } 15250 public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); } 15251 public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); } 15252 public ReferenceContext reference() { 15253 return getRuleContext(ReferenceContext.class,0); 15254 } 15255 public TerminalNode STRING() { return getToken(JavadocParser.STRING, 0); } 15256 public HtmlElementContext htmlElement() { 15257 return getRuleContext(HtmlElementContext.class,0); 15258 } 15259 public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); } 15260 public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); } 15261 public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); } 15262 public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); } 15263 public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); } 15264 public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); } 15265 public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); } 15266 public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); } 15267 public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); } 15268 public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); } 15269 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 15270 public JavadocTagContext(ParserRuleContext parent, int invokingState) { 15271 super(parent, invokingState); 15272 } 15273 @Override public int getRuleIndex() { return RULE_javadocTag; } 15274 } 15275 15276 public final JavadocTagContext javadocTag() throws RecognitionException { 15277 JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState()); 15278 enterRule(_localctx, 142, RULE_javadocTag); 15279 int _la; 15280 try { 15281 int _alt; 15282 setState(1972); 15283 _errHandler.sync(this); 15284 switch (_input.LA(1)) { 15285 case AUTHOR_LITERAL: 15286 enterOuterAlt(_localctx, 1); 15287 { 15288 setState(1777); 15289 match(AUTHOR_LITERAL); 15290 setState(1779); 15291 _errHandler.sync(this); 15292 _alt = 1; 15293 do { 15294 switch (_alt) { 15295 case 1: 15296 { 15297 { 15298 setState(1778); 15299 _la = _input.LA(1); 15300 if ( !(_la==WS || _la==NEWLINE) ) { 15301 _errHandler.recoverInline(this); 15302 } 15303 else { 15304 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15305 _errHandler.reportMatch(this); 15306 consume(); 15307 } 15308 } 15309 } 15310 break; 15311 default: 15312 throw new NoViableAltException(this); 15313 } 15314 setState(1781); 15315 _errHandler.sync(this); 15316 _alt = getInterpreter().adaptivePredict(_input,125,_ctx); 15317 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15318 setState(1783); 15319 description(); 15320 } 15321 break; 15322 case DEPRECATED_LITERAL: 15323 enterOuterAlt(_localctx, 2); 15324 { 15325 setState(1784); 15326 match(DEPRECATED_LITERAL); 15327 setState(1788); 15328 _errHandler.sync(this); 15329 _alt = getInterpreter().adaptivePredict(_input,126,_ctx); 15330 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15331 if ( _alt==1 ) { 15332 { 15333 { 15334 setState(1785); 15335 _la = _input.LA(1); 15336 if ( !(_la==WS || _la==NEWLINE) ) { 15337 _errHandler.recoverInline(this); 15338 } 15339 else { 15340 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15341 _errHandler.reportMatch(this); 15342 consume(); 15343 } 15344 } 15345 } 15346 } 15347 setState(1790); 15348 _errHandler.sync(this); 15349 _alt = getInterpreter().adaptivePredict(_input,126,_ctx); 15350 } 15351 setState(1793); 15352 _errHandler.sync(this); 15353 switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) { 15354 case 1: 15355 { 15356 setState(1791); 15357 _la = _input.LA(1); 15358 if ( !(_la==WS || _la==NEWLINE) ) { 15359 _errHandler.recoverInline(this); 15360 } 15361 else { 15362 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15363 _errHandler.reportMatch(this); 15364 consume(); 15365 } 15366 setState(1792); 15367 description(); 15368 } 15369 break; 15370 } 15371 } 15372 break; 15373 case EXCEPTION_LITERAL: 15374 enterOuterAlt(_localctx, 3); 15375 { 15376 setState(1795); 15377 match(EXCEPTION_LITERAL); 15378 setState(1800); 15379 _errHandler.sync(this); 15380 _alt = 1; 15381 do { 15382 switch (_alt) { 15383 case 1: 15384 { 15385 setState(1800); 15386 _errHandler.sync(this); 15387 switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { 15388 case 1: 15389 { 15390 setState(1796); 15391 match(WS); 15392 } 15393 break; 15394 case 2: 15395 { 15396 setState(1797); 15397 match(NEWLINE); 15398 } 15399 break; 15400 case 3: 15401 { 15402 setState(1798); 15403 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 15404 setState(1799); 15405 match(LEADING_ASTERISK); 15406 } 15407 break; 15408 } 15409 } 15410 break; 15411 default: 15412 throw new NoViableAltException(this); 15413 } 15414 setState(1802); 15415 _errHandler.sync(this); 15416 _alt = getInterpreter().adaptivePredict(_input,129,_ctx); 15417 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15418 setState(1804); 15419 match(CLASS_NAME); 15420 setState(1808); 15421 _errHandler.sync(this); 15422 _alt = getInterpreter().adaptivePredict(_input,130,_ctx); 15423 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15424 if ( _alt==1 ) { 15425 { 15426 { 15427 setState(1805); 15428 _la = _input.LA(1); 15429 if ( !(_la==WS || _la==NEWLINE) ) { 15430 _errHandler.recoverInline(this); 15431 } 15432 else { 15433 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15434 _errHandler.reportMatch(this); 15435 consume(); 15436 } 15437 } 15438 } 15439 } 15440 setState(1810); 15441 _errHandler.sync(this); 15442 _alt = getInterpreter().adaptivePredict(_input,130,_ctx); 15443 } 15444 setState(1813); 15445 _errHandler.sync(this); 15446 switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { 15447 case 1: 15448 { 15449 setState(1811); 15450 _la = _input.LA(1); 15451 if ( !(_la==WS || _la==NEWLINE) ) { 15452 _errHandler.recoverInline(this); 15453 } 15454 else { 15455 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15456 _errHandler.reportMatch(this); 15457 consume(); 15458 } 15459 setState(1812); 15460 description(); 15461 } 15462 break; 15463 } 15464 } 15465 break; 15466 case PARAM_LITERAL: 15467 enterOuterAlt(_localctx, 4); 15468 { 15469 setState(1815); 15470 match(PARAM_LITERAL); 15471 setState(1820); 15472 _errHandler.sync(this); 15473 _alt = 1; 15474 do { 15475 switch (_alt) { 15476 case 1: 15477 { 15478 setState(1820); 15479 _errHandler.sync(this); 15480 switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { 15481 case 1: 15482 { 15483 setState(1816); 15484 match(WS); 15485 } 15486 break; 15487 case 2: 15488 { 15489 setState(1817); 15490 match(NEWLINE); 15491 } 15492 break; 15493 case 3: 15494 { 15495 setState(1818); 15496 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 15497 setState(1819); 15498 match(LEADING_ASTERISK); 15499 } 15500 break; 15501 } 15502 } 15503 break; 15504 default: 15505 throw new NoViableAltException(this); 15506 } 15507 setState(1822); 15508 _errHandler.sync(this); 15509 _alt = getInterpreter().adaptivePredict(_input,133,_ctx); 15510 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15511 setState(1824); 15512 match(PARAMETER_NAME); 15513 setState(1828); 15514 _errHandler.sync(this); 15515 _alt = getInterpreter().adaptivePredict(_input,134,_ctx); 15516 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15517 if ( _alt==1 ) { 15518 { 15519 { 15520 setState(1825); 15521 _la = _input.LA(1); 15522 if ( !(_la==WS || _la==NEWLINE) ) { 15523 _errHandler.recoverInline(this); 15524 } 15525 else { 15526 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15527 _errHandler.reportMatch(this); 15528 consume(); 15529 } 15530 } 15531 } 15532 } 15533 setState(1830); 15534 _errHandler.sync(this); 15535 _alt = getInterpreter().adaptivePredict(_input,134,_ctx); 15536 } 15537 setState(1833); 15538 _errHandler.sync(this); 15539 switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) { 15540 case 1: 15541 { 15542 setState(1831); 15543 _la = _input.LA(1); 15544 if ( !(_la==WS || _la==NEWLINE) ) { 15545 _errHandler.recoverInline(this); 15546 } 15547 else { 15548 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15549 _errHandler.reportMatch(this); 15550 consume(); 15551 } 15552 setState(1832); 15553 description(); 15554 } 15555 break; 15556 } 15557 } 15558 break; 15559 case RETURN_LITERAL: 15560 enterOuterAlt(_localctx, 5); 15561 { 15562 setState(1835); 15563 match(RETURN_LITERAL); 15564 setState(1837); 15565 _errHandler.sync(this); 15566 _alt = 1; 15567 do { 15568 switch (_alt) { 15569 case 1: 15570 { 15571 { 15572 setState(1836); 15573 _la = _input.LA(1); 15574 if ( !(_la==WS || _la==NEWLINE) ) { 15575 _errHandler.recoverInline(this); 15576 } 15577 else { 15578 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15579 _errHandler.reportMatch(this); 15580 consume(); 15581 } 15582 } 15583 } 15584 break; 15585 default: 15586 throw new NoViableAltException(this); 15587 } 15588 setState(1839); 15589 _errHandler.sync(this); 15590 _alt = getInterpreter().adaptivePredict(_input,136,_ctx); 15591 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15592 setState(1841); 15593 description(); 15594 } 15595 break; 15596 case SEE_LITERAL: 15597 enterOuterAlt(_localctx, 6); 15598 { 15599 setState(1842); 15600 match(SEE_LITERAL); 15601 setState(1847); 15602 _errHandler.sync(this); 15603 _alt = 1; 15604 do { 15605 switch (_alt) { 15606 case 1: 15607 { 15608 setState(1847); 15609 _errHandler.sync(this); 15610 switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) { 15611 case 1: 15612 { 15613 setState(1843); 15614 match(WS); 15615 } 15616 break; 15617 case 2: 15618 { 15619 setState(1844); 15620 match(NEWLINE); 15621 } 15622 break; 15623 case 3: 15624 { 15625 setState(1845); 15626 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 15627 setState(1846); 15628 match(LEADING_ASTERISK); 15629 } 15630 break; 15631 } 15632 } 15633 break; 15634 default: 15635 throw new NoViableAltException(this); 15636 } 15637 setState(1849); 15638 _errHandler.sync(this); 15639 _alt = getInterpreter().adaptivePredict(_input,138,_ctx); 15640 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15641 setState(1854); 15642 _errHandler.sync(this); 15643 switch (_input.LA(1)) { 15644 case PACKAGE_CLASS: 15645 case HASH: 15646 { 15647 setState(1851); 15648 reference(); 15649 } 15650 break; 15651 case STRING: 15652 { 15653 setState(1852); 15654 match(STRING); 15655 } 15656 break; 15657 case START: 15658 { 15659 setState(1853); 15660 htmlElement(); 15661 } 15662 break; 15663 default: 15664 throw new NoViableAltException(this); 15665 } 15666 setState(1859); 15667 _errHandler.sync(this); 15668 _alt = getInterpreter().adaptivePredict(_input,140,_ctx); 15669 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15670 if ( _alt==1 ) { 15671 { 15672 { 15673 setState(1856); 15674 _la = _input.LA(1); 15675 if ( !(_la==WS || _la==NEWLINE) ) { 15676 _errHandler.recoverInline(this); 15677 } 15678 else { 15679 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15680 _errHandler.reportMatch(this); 15681 consume(); 15682 } 15683 } 15684 } 15685 } 15686 setState(1861); 15687 _errHandler.sync(this); 15688 _alt = getInterpreter().adaptivePredict(_input,140,_ctx); 15689 } 15690 setState(1864); 15691 _errHandler.sync(this); 15692 switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) { 15693 case 1: 15694 { 15695 setState(1862); 15696 _la = _input.LA(1); 15697 if ( !(_la==WS || _la==NEWLINE) ) { 15698 _errHandler.recoverInline(this); 15699 } 15700 else { 15701 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15702 _errHandler.reportMatch(this); 15703 consume(); 15704 } 15705 setState(1863); 15706 description(); 15707 } 15708 break; 15709 } 15710 } 15711 break; 15712 case SERIAL_LITERAL: 15713 enterOuterAlt(_localctx, 7); 15714 { 15715 setState(1866); 15716 match(SERIAL_LITERAL); 15717 setState(1870); 15718 _errHandler.sync(this); 15719 _alt = getInterpreter().adaptivePredict(_input,142,_ctx); 15720 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15721 if ( _alt==1 ) { 15722 { 15723 { 15724 setState(1867); 15725 _la = _input.LA(1); 15726 if ( !(_la==WS || _la==NEWLINE) ) { 15727 _errHandler.recoverInline(this); 15728 } 15729 else { 15730 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15731 _errHandler.reportMatch(this); 15732 consume(); 15733 } 15734 } 15735 } 15736 } 15737 setState(1872); 15738 _errHandler.sync(this); 15739 _alt = getInterpreter().adaptivePredict(_input,142,_ctx); 15740 } 15741 setState(1877); 15742 _errHandler.sync(this); 15743 switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) { 15744 case 1: 15745 { 15746 setState(1873); 15747 _la = _input.LA(1); 15748 if ( !(_la==WS || _la==NEWLINE) ) { 15749 _errHandler.recoverInline(this); 15750 } 15751 else { 15752 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15753 _errHandler.reportMatch(this); 15754 consume(); 15755 } 15756 setState(1874); 15757 description(); 15758 } 15759 break; 15760 case 2: 15761 { 15762 setState(1875); 15763 match(LITERAL_INCLUDE); 15764 } 15765 break; 15766 case 3: 15767 { 15768 setState(1876); 15769 match(LITERAL_EXCLUDE); 15770 } 15771 break; 15772 } 15773 setState(1882); 15774 _errHandler.sync(this); 15775 _alt = getInterpreter().adaptivePredict(_input,144,_ctx); 15776 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15777 if ( _alt==1 ) { 15778 { 15779 { 15780 setState(1879); 15781 _la = _input.LA(1); 15782 if ( !(_la==WS || _la==NEWLINE) ) { 15783 _errHandler.recoverInline(this); 15784 } 15785 else { 15786 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15787 _errHandler.reportMatch(this); 15788 consume(); 15789 } 15790 } 15791 } 15792 } 15793 setState(1884); 15794 _errHandler.sync(this); 15795 _alt = getInterpreter().adaptivePredict(_input,144,_ctx); 15796 } 15797 } 15798 break; 15799 case SERIAL_DATA_LITERAL: 15800 enterOuterAlt(_localctx, 8); 15801 { 15802 setState(1885); 15803 match(SERIAL_DATA_LITERAL); 15804 setState(1889); 15805 _errHandler.sync(this); 15806 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 15807 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15808 if ( _alt==1 ) { 15809 { 15810 { 15811 setState(1886); 15812 _la = _input.LA(1); 15813 if ( !(_la==WS || _la==NEWLINE) ) { 15814 _errHandler.recoverInline(this); 15815 } 15816 else { 15817 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15818 _errHandler.reportMatch(this); 15819 consume(); 15820 } 15821 } 15822 } 15823 } 15824 setState(1891); 15825 _errHandler.sync(this); 15826 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 15827 } 15828 setState(1894); 15829 _errHandler.sync(this); 15830 switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { 15831 case 1: 15832 { 15833 setState(1892); 15834 _la = _input.LA(1); 15835 if ( !(_la==WS || _la==NEWLINE) ) { 15836 _errHandler.recoverInline(this); 15837 } 15838 else { 15839 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15840 _errHandler.reportMatch(this); 15841 consume(); 15842 } 15843 setState(1893); 15844 description(); 15845 } 15846 break; 15847 } 15848 } 15849 break; 15850 case SERIAL_FIELD_LITERAL: 15851 enterOuterAlt(_localctx, 9); 15852 { 15853 setState(1896); 15854 match(SERIAL_FIELD_LITERAL); 15855 setState(1900); 15856 _errHandler.sync(this); 15857 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 15858 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15859 if ( _alt==1 ) { 15860 { 15861 { 15862 setState(1897); 15863 _la = _input.LA(1); 15864 if ( !(_la==WS || _la==NEWLINE) ) { 15865 _errHandler.recoverInline(this); 15866 } 15867 else { 15868 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15869 _errHandler.reportMatch(this); 15870 consume(); 15871 } 15872 } 15873 } 15874 } 15875 setState(1902); 15876 _errHandler.sync(this); 15877 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 15878 } 15879 setState(1905); 15880 _errHandler.sync(this); 15881 switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { 15882 case 1: 15883 { 15884 setState(1903); 15885 _la = _input.LA(1); 15886 if ( !(_la==WS || _la==NEWLINE) ) { 15887 _errHandler.recoverInline(this); 15888 } 15889 else { 15890 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15891 _errHandler.reportMatch(this); 15892 consume(); 15893 } 15894 setState(1904); 15895 match(FIELD_NAME); 15896 } 15897 break; 15898 } 15899 setState(1910); 15900 _errHandler.sync(this); 15901 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 15902 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15903 if ( _alt==1 ) { 15904 { 15905 { 15906 setState(1907); 15907 _la = _input.LA(1); 15908 if ( !(_la==WS || _la==NEWLINE) ) { 15909 _errHandler.recoverInline(this); 15910 } 15911 else { 15912 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15913 _errHandler.reportMatch(this); 15914 consume(); 15915 } 15916 } 15917 } 15918 } 15919 setState(1912); 15920 _errHandler.sync(this); 15921 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 15922 } 15923 setState(1915); 15924 _errHandler.sync(this); 15925 switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { 15926 case 1: 15927 { 15928 setState(1913); 15929 _la = _input.LA(1); 15930 if ( !(_la==WS || _la==NEWLINE) ) { 15931 _errHandler.recoverInline(this); 15932 } 15933 else { 15934 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15935 _errHandler.reportMatch(this); 15936 consume(); 15937 } 15938 setState(1914); 15939 match(FIELD_TYPE); 15940 } 15941 break; 15942 } 15943 setState(1920); 15944 _errHandler.sync(this); 15945 _alt = getInterpreter().adaptivePredict(_input,151,_ctx); 15946 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15947 if ( _alt==1 ) { 15948 { 15949 { 15950 setState(1917); 15951 _la = _input.LA(1); 15952 if ( !(_la==WS || _la==NEWLINE) ) { 15953 _errHandler.recoverInline(this); 15954 } 15955 else { 15956 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15957 _errHandler.reportMatch(this); 15958 consume(); 15959 } 15960 } 15961 } 15962 } 15963 setState(1922); 15964 _errHandler.sync(this); 15965 _alt = getInterpreter().adaptivePredict(_input,151,_ctx); 15966 } 15967 setState(1925); 15968 _errHandler.sync(this); 15969 switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) { 15970 case 1: 15971 { 15972 setState(1923); 15973 _la = _input.LA(1); 15974 if ( !(_la==WS || _la==NEWLINE) ) { 15975 _errHandler.recoverInline(this); 15976 } 15977 else { 15978 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15979 _errHandler.reportMatch(this); 15980 consume(); 15981 } 15982 setState(1924); 15983 description(); 15984 } 15985 break; 15986 } 15987 } 15988 break; 15989 case SINCE_LITERAL: 15990 enterOuterAlt(_localctx, 10); 15991 { 15992 setState(1927); 15993 match(SINCE_LITERAL); 15994 setState(1929); 15995 _errHandler.sync(this); 15996 _alt = 1; 15997 do { 15998 switch (_alt) { 15999 case 1: 16000 { 16001 { 16002 setState(1928); 16003 _la = _input.LA(1); 16004 if ( !(_la==WS || _la==NEWLINE) ) { 16005 _errHandler.recoverInline(this); 16006 } 16007 else { 16008 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16009 _errHandler.reportMatch(this); 16010 consume(); 16011 } 16012 } 16013 } 16014 break; 16015 default: 16016 throw new NoViableAltException(this); 16017 } 16018 setState(1931); 16019 _errHandler.sync(this); 16020 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 16021 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 16022 setState(1933); 16023 description(); 16024 } 16025 break; 16026 case THROWS_LITERAL: 16027 enterOuterAlt(_localctx, 11); 16028 { 16029 setState(1934); 16030 match(THROWS_LITERAL); 16031 setState(1939); 16032 _errHandler.sync(this); 16033 _alt = 1; 16034 do { 16035 switch (_alt) { 16036 case 1: 16037 { 16038 setState(1939); 16039 _errHandler.sync(this); 16040 switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) { 16041 case 1: 16042 { 16043 setState(1935); 16044 match(WS); 16045 } 16046 break; 16047 case 2: 16048 { 16049 setState(1936); 16050 match(NEWLINE); 16051 } 16052 break; 16053 case 3: 16054 { 16055 setState(1937); 16056 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 16057 setState(1938); 16058 match(LEADING_ASTERISK); 16059 } 16060 break; 16061 } 16062 } 16063 break; 16064 default: 16065 throw new NoViableAltException(this); 16066 } 16067 setState(1941); 16068 _errHandler.sync(this); 16069 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 16070 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 16071 setState(1943); 16072 match(CLASS_NAME); 16073 setState(1947); 16074 _errHandler.sync(this); 16075 _alt = getInterpreter().adaptivePredict(_input,156,_ctx); 16076 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 16077 if ( _alt==1 ) { 16078 { 16079 { 16080 setState(1944); 16081 _la = _input.LA(1); 16082 if ( !(_la==WS || _la==NEWLINE) ) { 16083 _errHandler.recoverInline(this); 16084 } 16085 else { 16086 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16087 _errHandler.reportMatch(this); 16088 consume(); 16089 } 16090 } 16091 } 16092 } 16093 setState(1949); 16094 _errHandler.sync(this); 16095 _alt = getInterpreter().adaptivePredict(_input,156,_ctx); 16096 } 16097 setState(1952); 16098 _errHandler.sync(this); 16099 switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { 16100 case 1: 16101 { 16102 setState(1950); 16103 _la = _input.LA(1); 16104 if ( !(_la==WS || _la==NEWLINE) ) { 16105 _errHandler.recoverInline(this); 16106 } 16107 else { 16108 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16109 _errHandler.reportMatch(this); 16110 consume(); 16111 } 16112 setState(1951); 16113 description(); 16114 } 16115 break; 16116 } 16117 } 16118 break; 16119 case VERSION_LITERAL: 16120 enterOuterAlt(_localctx, 12); 16121 { 16122 setState(1954); 16123 match(VERSION_LITERAL); 16124 setState(1956); 16125 _errHandler.sync(this); 16126 _alt = 1; 16127 do { 16128 switch (_alt) { 16129 case 1: 16130 { 16131 { 16132 setState(1955); 16133 _la = _input.LA(1); 16134 if ( !(_la==WS || _la==NEWLINE) ) { 16135 _errHandler.recoverInline(this); 16136 } 16137 else { 16138 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16139 _errHandler.reportMatch(this); 16140 consume(); 16141 } 16142 } 16143 } 16144 break; 16145 default: 16146 throw new NoViableAltException(this); 16147 } 16148 setState(1958); 16149 _errHandler.sync(this); 16150 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 16151 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 16152 setState(1960); 16153 description(); 16154 } 16155 break; 16156 case CUSTOM_NAME: 16157 enterOuterAlt(_localctx, 13); 16158 { 16159 setState(1961); 16160 match(CUSTOM_NAME); 16161 setState(1965); 16162 _errHandler.sync(this); 16163 _alt = getInterpreter().adaptivePredict(_input,159,_ctx); 16164 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 16165 if ( _alt==1 ) { 16166 { 16167 { 16168 setState(1962); 16169 _la = _input.LA(1); 16170 if ( !(_la==WS || _la==NEWLINE) ) { 16171 _errHandler.recoverInline(this); 16172 } 16173 else { 16174 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16175 _errHandler.reportMatch(this); 16176 consume(); 16177 } 16178 } 16179 } 16180 } 16181 setState(1967); 16182 _errHandler.sync(this); 16183 _alt = getInterpreter().adaptivePredict(_input,159,_ctx); 16184 } 16185 setState(1970); 16186 _errHandler.sync(this); 16187 switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) { 16188 case 1: 16189 { 16190 setState(1968); 16191 _la = _input.LA(1); 16192 if ( !(_la==WS || _la==NEWLINE) ) { 16193 _errHandler.recoverInline(this); 16194 } 16195 else { 16196 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16197 _errHandler.reportMatch(this); 16198 consume(); 16199 } 16200 setState(1969); 16201 description(); 16202 } 16203 break; 16204 } 16205 } 16206 break; 16207 default: 16208 throw new NoViableAltException(this); 16209 } 16210 } 16211 catch (RecognitionException re) { 16212 _localctx.exception = re; 16213 _errHandler.reportError(this, re); 16214 _errHandler.recover(this, re); 16215 } 16216 finally { 16217 exitRule(); 16218 } 16219 return _localctx; 16220 } 16221 16222 public static class JavadocInlineTagContext extends ParserRuleContext { 16223 public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); } 16224 public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); } 16225 public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); } 16226 public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); } 16227 public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); } 16228 public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); } 16229 public ReferenceContext reference() { 16230 return getRuleContext(ReferenceContext.class,0); 16231 } 16232 public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); } 16233 public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); } 16234 public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); } 16235 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 16236 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 16237 public TerminalNode WS(int i) { 16238 return getToken(JavadocParser.WS, i); 16239 } 16240 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 16241 public TerminalNode NEWLINE(int i) { 16242 return getToken(JavadocParser.NEWLINE, i); 16243 } 16244 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 16245 public TerminalNode LEADING_ASTERISK(int i) { 16246 return getToken(JavadocParser.LEADING_ASTERISK, i); 16247 } 16248 public List<TextContext> text() { 16249 return getRuleContexts(TextContext.class); 16250 } 16251 public TextContext text(int i) { 16252 return getRuleContext(TextContext.class,i); 16253 } 16254 public DescriptionContext description() { 16255 return getRuleContext(DescriptionContext.class,0); 16256 } 16257 public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) { 16258 super(parent, invokingState); 16259 } 16260 @Override public int getRuleIndex() { return RULE_javadocInlineTag; } 16261 } 16262 16263 public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException { 16264 JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState()); 16265 enterRule(_localctx, 144, RULE_javadocInlineTag); 16266 int _la; 16267 try { 16268 int _alt; 16269 enterOuterAlt(_localctx, 1); 16270 { 16271 setState(1974); 16272 match(JAVADOC_INLINE_TAG_START); 16273 setState(2065); 16274 _errHandler.sync(this); 16275 switch (_input.LA(1)) { 16276 case CODE_LITERAL: 16277 { 16278 setState(1975); 16279 match(CODE_LITERAL); 16280 setState(1982); 16281 _errHandler.sync(this); 16282 _la = _input.LA(1); 16283 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 16284 { 16285 setState(1980); 16286 _errHandler.sync(this); 16287 switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) { 16288 case 1: 16289 { 16290 setState(1976); 16291 match(WS); 16292 } 16293 break; 16294 case 2: 16295 { 16296 setState(1977); 16297 match(NEWLINE); 16298 } 16299 break; 16300 case 3: 16301 { 16302 setState(1978); 16303 match(LEADING_ASTERISK); 16304 } 16305 break; 16306 case 4: 16307 { 16308 setState(1979); 16309 text(); 16310 } 16311 break; 16312 } 16313 } 16314 setState(1984); 16315 _errHandler.sync(this); 16316 _la = _input.LA(1); 16317 } 16318 } 16319 break; 16320 case DOC_ROOT_LITERAL: 16321 { 16322 setState(1985); 16323 match(DOC_ROOT_LITERAL); 16324 setState(1989); 16325 _errHandler.sync(this); 16326 _la = _input.LA(1); 16327 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 16328 { 16329 { 16330 setState(1986); 16331 _la = _input.LA(1); 16332 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16333 _errHandler.recoverInline(this); 16334 } 16335 else { 16336 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16337 _errHandler.reportMatch(this); 16338 consume(); 16339 } 16340 } 16341 } 16342 setState(1991); 16343 _errHandler.sync(this); 16344 _la = _input.LA(1); 16345 } 16346 } 16347 break; 16348 case INHERIT_DOC_LITERAL: 16349 { 16350 setState(1992); 16351 match(INHERIT_DOC_LITERAL); 16352 setState(1996); 16353 _errHandler.sync(this); 16354 _la = _input.LA(1); 16355 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 16356 { 16357 { 16358 setState(1993); 16359 _la = _input.LA(1); 16360 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16361 _errHandler.recoverInline(this); 16362 } 16363 else { 16364 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16365 _errHandler.reportMatch(this); 16366 consume(); 16367 } 16368 } 16369 } 16370 setState(1998); 16371 _errHandler.sync(this); 16372 _la = _input.LA(1); 16373 } 16374 } 16375 break; 16376 case LINK_LITERAL: 16377 { 16378 setState(1999); 16379 match(LINK_LITERAL); 16380 setState(2001); 16381 _errHandler.sync(this); 16382 _la = _input.LA(1); 16383 do { 16384 { 16385 { 16386 setState(2000); 16387 _la = _input.LA(1); 16388 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16389 _errHandler.recoverInline(this); 16390 } 16391 else { 16392 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16393 _errHandler.reportMatch(this); 16394 consume(); 16395 } 16396 } 16397 } 16398 setState(2003); 16399 _errHandler.sync(this); 16400 _la = _input.LA(1); 16401 } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) ); 16402 setState(2005); 16403 reference(); 16404 setState(2009); 16405 _errHandler.sync(this); 16406 _alt = getInterpreter().adaptivePredict(_input,167,_ctx); 16407 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 16408 if ( _alt==1 ) { 16409 { 16410 { 16411 setState(2006); 16412 _la = _input.LA(1); 16413 if ( !(_la==WS || _la==NEWLINE) ) { 16414 _errHandler.recoverInline(this); 16415 } 16416 else { 16417 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16418 _errHandler.reportMatch(this); 16419 consume(); 16420 } 16421 } 16422 } 16423 } 16424 setState(2011); 16425 _errHandler.sync(this); 16426 _alt = getInterpreter().adaptivePredict(_input,167,_ctx); 16427 } 16428 setState(2014); 16429 _errHandler.sync(this); 16430 _la = _input.LA(1); 16431 if (_la==WS || _la==NEWLINE) { 16432 { 16433 setState(2012); 16434 _la = _input.LA(1); 16435 if ( !(_la==WS || _la==NEWLINE) ) { 16436 _errHandler.recoverInline(this); 16437 } 16438 else { 16439 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16440 _errHandler.reportMatch(this); 16441 consume(); 16442 } 16443 setState(2013); 16444 description(); 16445 } 16446 } 16447 16448 } 16449 break; 16450 case LINKPLAIN_LITERAL: 16451 { 16452 setState(2016); 16453 match(LINKPLAIN_LITERAL); 16454 setState(2018); 16455 _errHandler.sync(this); 16456 _la = _input.LA(1); 16457 do { 16458 { 16459 { 16460 setState(2017); 16461 _la = _input.LA(1); 16462 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16463 _errHandler.recoverInline(this); 16464 } 16465 else { 16466 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16467 _errHandler.reportMatch(this); 16468 consume(); 16469 } 16470 } 16471 } 16472 setState(2020); 16473 _errHandler.sync(this); 16474 _la = _input.LA(1); 16475 } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) ); 16476 setState(2022); 16477 reference(); 16478 setState(2026); 16479 _errHandler.sync(this); 16480 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 16481 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 16482 if ( _alt==1 ) { 16483 { 16484 { 16485 setState(2023); 16486 _la = _input.LA(1); 16487 if ( !(_la==WS || _la==NEWLINE) ) { 16488 _errHandler.recoverInline(this); 16489 } 16490 else { 16491 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16492 _errHandler.reportMatch(this); 16493 consume(); 16494 } 16495 } 16496 } 16497 } 16498 setState(2028); 16499 _errHandler.sync(this); 16500 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 16501 } 16502 setState(2031); 16503 _errHandler.sync(this); 16504 _la = _input.LA(1); 16505 if (_la==WS || _la==NEWLINE) { 16506 { 16507 setState(2029); 16508 _la = _input.LA(1); 16509 if ( !(_la==WS || _la==NEWLINE) ) { 16510 _errHandler.recoverInline(this); 16511 } 16512 else { 16513 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16514 _errHandler.reportMatch(this); 16515 consume(); 16516 } 16517 setState(2030); 16518 description(); 16519 } 16520 } 16521 16522 } 16523 break; 16524 case LITERAL_LITERAL: 16525 { 16526 setState(2033); 16527 match(LITERAL_LITERAL); 16528 setState(2040); 16529 _errHandler.sync(this); 16530 _la = _input.LA(1); 16531 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 16532 { 16533 setState(2038); 16534 _errHandler.sync(this); 16535 switch ( getInterpreter().adaptivePredict(_input,172,_ctx) ) { 16536 case 1: 16537 { 16538 setState(2034); 16539 match(WS); 16540 } 16541 break; 16542 case 2: 16543 { 16544 setState(2035); 16545 match(NEWLINE); 16546 } 16547 break; 16548 case 3: 16549 { 16550 setState(2036); 16551 match(LEADING_ASTERISK); 16552 } 16553 break; 16554 case 4: 16555 { 16556 setState(2037); 16557 text(); 16558 } 16559 break; 16560 } 16561 } 16562 setState(2042); 16563 _errHandler.sync(this); 16564 _la = _input.LA(1); 16565 } 16566 } 16567 break; 16568 case VALUE_LITERAL: 16569 { 16570 setState(2043); 16571 match(VALUE_LITERAL); 16572 setState(2047); 16573 _errHandler.sync(this); 16574 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 16575 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 16576 if ( _alt==1 ) { 16577 { 16578 { 16579 setState(2044); 16580 _la = _input.LA(1); 16581 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16582 _errHandler.recoverInline(this); 16583 } 16584 else { 16585 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16586 _errHandler.reportMatch(this); 16587 consume(); 16588 } 16589 } 16590 } 16591 } 16592 setState(2049); 16593 _errHandler.sync(this); 16594 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 16595 } 16596 setState(2052); 16597 _errHandler.sync(this); 16598 _la = _input.LA(1); 16599 if (_la==WS || _la==NEWLINE) { 16600 { 16601 setState(2050); 16602 _la = _input.LA(1); 16603 if ( !(_la==WS || _la==NEWLINE) ) { 16604 _errHandler.recoverInline(this); 16605 } 16606 else { 16607 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16608 _errHandler.reportMatch(this); 16609 consume(); 16610 } 16611 setState(2051); 16612 reference(); 16613 } 16614 } 16615 16616 } 16617 break; 16618 case CUSTOM_NAME: 16619 { 16620 setState(2054); 16621 match(CUSTOM_NAME); 16622 setState(2058); 16623 _errHandler.sync(this); 16624 _alt = getInterpreter().adaptivePredict(_input,176,_ctx); 16625 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 16626 if ( _alt==1 ) { 16627 { 16628 { 16629 setState(2055); 16630 _la = _input.LA(1); 16631 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16632 _errHandler.recoverInline(this); 16633 } 16634 else { 16635 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16636 _errHandler.reportMatch(this); 16637 consume(); 16638 } 16639 } 16640 } 16641 } 16642 setState(2060); 16643 _errHandler.sync(this); 16644 _alt = getInterpreter().adaptivePredict(_input,176,_ctx); 16645 } 16646 setState(2063); 16647 _errHandler.sync(this); 16648 _la = _input.LA(1); 16649 if (_la==WS || _la==NEWLINE) { 16650 { 16651 setState(2061); 16652 _la = _input.LA(1); 16653 if ( !(_la==WS || _la==NEWLINE) ) { 16654 _errHandler.recoverInline(this); 16655 } 16656 else { 16657 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16658 _errHandler.reportMatch(this); 16659 consume(); 16660 } 16661 setState(2062); 16662 description(); 16663 } 16664 } 16665 16666 } 16667 break; 16668 default: 16669 throw new NoViableAltException(this); 16670 } 16671 setState(2067); 16672 match(JAVADOC_INLINE_TAG_END); 16673 } 16674 } 16675 catch (RecognitionException re) { 16676 _localctx.exception = re; 16677 _errHandler.reportError(this, re); 16678 _errHandler.recover(this, re); 16679 } 16680 finally { 16681 exitRule(); 16682 } 16683 return _localctx; 16684 } 16685 16686 public static class HtmlCommentContext extends ParserRuleContext { 16687 public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); } 16688 public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); } 16689 public List<TextContext> text() { 16690 return getRuleContexts(TextContext.class); 16691 } 16692 public TextContext text(int i) { 16693 return getRuleContext(TextContext.class,i); 16694 } 16695 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 16696 public TerminalNode NEWLINE(int i) { 16697 return getToken(JavadocParser.NEWLINE, i); 16698 } 16699 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 16700 public TerminalNode LEADING_ASTERISK(int i) { 16701 return getToken(JavadocParser.LEADING_ASTERISK, i); 16702 } 16703 public HtmlCommentContext(ParserRuleContext parent, int invokingState) { 16704 super(parent, invokingState); 16705 } 16706 @Override public int getRuleIndex() { return RULE_htmlComment; } 16707 } 16708 16709 public final HtmlCommentContext htmlComment() throws RecognitionException { 16710 HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState()); 16711 enterRule(_localctx, 146, RULE_htmlComment); 16712 int _la; 16713 try { 16714 enterOuterAlt(_localctx, 1); 16715 { 16716 setState(2069); 16717 match(HTML_COMMENT_START); 16718 setState(2075); 16719 _errHandler.sync(this); 16720 _la = _input.LA(1); 16721 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 16722 { 16723 setState(2073); 16724 _errHandler.sync(this); 16725 switch (_input.LA(1)) { 16726 case WS: 16727 case CHAR: 16728 { 16729 setState(2070); 16730 text(); 16731 } 16732 break; 16733 case NEWLINE: 16734 { 16735 setState(2071); 16736 match(NEWLINE); 16737 } 16738 break; 16739 case LEADING_ASTERISK: 16740 { 16741 setState(2072); 16742 match(LEADING_ASTERISK); 16743 } 16744 break; 16745 default: 16746 throw new NoViableAltException(this); 16747 } 16748 } 16749 setState(2077); 16750 _errHandler.sync(this); 16751 _la = _input.LA(1); 16752 } 16753 setState(2078); 16754 match(HTML_COMMENT_END); 16755 } 16756 } 16757 catch (RecognitionException re) { 16758 _localctx.exception = re; 16759 _errHandler.reportError(this, re); 16760 _errHandler.recover(this, re); 16761 } 16762 finally { 16763 exitRule(); 16764 } 16765 return _localctx; 16766 } 16767 16768 public static class TextContext extends ParserRuleContext { 16769 public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); } 16770 public TerminalNode CHAR(int i) { 16771 return getToken(JavadocParser.CHAR, i); 16772 } 16773 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 16774 public TerminalNode WS(int i) { 16775 return getToken(JavadocParser.WS, i); 16776 } 16777 public TextContext(ParserRuleContext parent, int invokingState) { 16778 super(parent, invokingState); 16779 } 16780 @Override public int getRuleIndex() { return RULE_text; } 16781 } 16782 16783 public final TextContext text() throws RecognitionException { 16784 TextContext _localctx = new TextContext(_ctx, getState()); 16785 enterRule(_localctx, 148, RULE_text); 16786 int _la; 16787 try { 16788 int _alt; 16789 enterOuterAlt(_localctx, 1); 16790 { 16791 setState(2082); 16792 _errHandler.sync(this); 16793 _alt = 1; 16794 do { 16795 switch (_alt) { 16796 case 1: 16797 { 16798 { 16799 setState(2080); 16800 _la = _input.LA(1); 16801 if ( !(_la==WS || _la==CHAR) ) { 16802 _errHandler.recoverInline(this); 16803 } 16804 else { 16805 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16806 _errHandler.reportMatch(this); 16807 consume(); 16808 } 16809 16810 _la = _input.LA(1); 16811 if ((_la != WS) && (_la != CHAR)) return _localctx; 16812 else if (_alt == 1) continue; 16813 16814 } 16815 } 16816 break; 16817 default: 16818 throw new NoViableAltException(this); 16819 } 16820 setState(2084); 16821 _errHandler.sync(this); 16822 _alt = getInterpreter().adaptivePredict(_input,181,_ctx); 16823 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 16824 } 16825 } 16826 catch (RecognitionException re) { 16827 _localctx.exception = re; 16828 _errHandler.reportError(this, re); 16829 _errHandler.recover(this, re); 16830 } 16831 finally { 16832 exitRule(); 16833 } 16834 return _localctx; 16835 } 16836 16837 public static class EmbedTagContext extends ParserRuleContext { 16838 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 16839 public TerminalNode EMBED_HTML_TAG_NAME() { return getToken(JavadocParser.EMBED_HTML_TAG_NAME, 0); } 16840 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 16841 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 16842 public List<AttributeContext> attribute() { 16843 return getRuleContexts(AttributeContext.class); 16844 } 16845 public AttributeContext attribute(int i) { 16846 return getRuleContext(AttributeContext.class,i); 16847 } 16848 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 16849 public TerminalNode NEWLINE(int i) { 16850 return getToken(JavadocParser.NEWLINE, i); 16851 } 16852 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 16853 public TerminalNode LEADING_ASTERISK(int i) { 16854 return getToken(JavadocParser.LEADING_ASTERISK, i); 16855 } 16856 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 16857 public TerminalNode WS(int i) { 16858 return getToken(JavadocParser.WS, i); 16859 } 16860 public EmbedTagContext(ParserRuleContext parent, int invokingState) { 16861 super(parent, invokingState); 16862 } 16863 @Override public int getRuleIndex() { return RULE_embedTag; } 16864 } 16865 16866 public final EmbedTagContext embedTag() throws RecognitionException { 16867 EmbedTagContext _localctx = new EmbedTagContext(_ctx, getState()); 16868 enterRule(_localctx, 150, RULE_embedTag); 16869 int _la; 16870 try { 16871 enterOuterAlt(_localctx, 1); 16872 { 16873 setState(2086); 16874 match(START); 16875 setState(2087); 16876 match(EMBED_HTML_TAG_NAME); 16877 setState(2094); 16878 _errHandler.sync(this); 16879 _la = _input.LA(1); 16880 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 16881 { 16882 setState(2092); 16883 _errHandler.sync(this); 16884 switch (_input.LA(1)) { 16885 case HTML_TAG_NAME: 16886 { 16887 setState(2088); 16888 attribute(); 16889 } 16890 break; 16891 case NEWLINE: 16892 { 16893 setState(2089); 16894 match(NEWLINE); 16895 } 16896 break; 16897 case LEADING_ASTERISK: 16898 { 16899 setState(2090); 16900 match(LEADING_ASTERISK); 16901 } 16902 break; 16903 case WS: 16904 { 16905 setState(2091); 16906 match(WS); 16907 } 16908 break; 16909 default: 16910 throw new NoViableAltException(this); 16911 } 16912 } 16913 setState(2096); 16914 _errHandler.sync(this); 16915 _la = _input.LA(1); 16916 } 16917 setState(2097); 16918 _la = _input.LA(1); 16919 if ( !(_la==END || _la==SLASH_END) ) { 16920 _errHandler.recoverInline(this); 16921 } 16922 else { 16923 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16924 _errHandler.reportMatch(this); 16925 consume(); 16926 } 16927 } 16928 } 16929 catch (RecognitionException re) { 16930 _localctx.exception = re; 16931 _errHandler.reportError(this, re); 16932 _errHandler.recover(this, re); 16933 } 16934 finally { 16935 exitRule(); 16936 } 16937 return _localctx; 16938 } 16939 16940 public static class KeygenTagContext extends ParserRuleContext { 16941 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 16942 public TerminalNode KEYGEN_HTML_TAG_NAME() { return getToken(JavadocParser.KEYGEN_HTML_TAG_NAME, 0); } 16943 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 16944 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 16945 public List<AttributeContext> attribute() { 16946 return getRuleContexts(AttributeContext.class); 16947 } 16948 public AttributeContext attribute(int i) { 16949 return getRuleContext(AttributeContext.class,i); 16950 } 16951 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 16952 public TerminalNode NEWLINE(int i) { 16953 return getToken(JavadocParser.NEWLINE, i); 16954 } 16955 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 16956 public TerminalNode LEADING_ASTERISK(int i) { 16957 return getToken(JavadocParser.LEADING_ASTERISK, i); 16958 } 16959 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 16960 public TerminalNode WS(int i) { 16961 return getToken(JavadocParser.WS, i); 16962 } 16963 public KeygenTagContext(ParserRuleContext parent, int invokingState) { 16964 super(parent, invokingState); 16965 } 16966 @Override public int getRuleIndex() { return RULE_keygenTag; } 16967 } 16968 16969 public final KeygenTagContext keygenTag() throws RecognitionException { 16970 KeygenTagContext _localctx = new KeygenTagContext(_ctx, getState()); 16971 enterRule(_localctx, 152, RULE_keygenTag); 16972 int _la; 16973 try { 16974 enterOuterAlt(_localctx, 1); 16975 { 16976 setState(2099); 16977 match(START); 16978 setState(2100); 16979 match(KEYGEN_HTML_TAG_NAME); 16980 setState(2107); 16981 _errHandler.sync(this); 16982 _la = _input.LA(1); 16983 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 16984 { 16985 setState(2105); 16986 _errHandler.sync(this); 16987 switch (_input.LA(1)) { 16988 case HTML_TAG_NAME: 16989 { 16990 setState(2101); 16991 attribute(); 16992 } 16993 break; 16994 case NEWLINE: 16995 { 16996 setState(2102); 16997 match(NEWLINE); 16998 } 16999 break; 17000 case LEADING_ASTERISK: 17001 { 17002 setState(2103); 17003 match(LEADING_ASTERISK); 17004 } 17005 break; 17006 case WS: 17007 { 17008 setState(2104); 17009 match(WS); 17010 } 17011 break; 17012 default: 17013 throw new NoViableAltException(this); 17014 } 17015 } 17016 setState(2109); 17017 _errHandler.sync(this); 17018 _la = _input.LA(1); 17019 } 17020 setState(2110); 17021 _la = _input.LA(1); 17022 if ( !(_la==END || _la==SLASH_END) ) { 17023 _errHandler.recoverInline(this); 17024 } 17025 else { 17026 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 17027 _errHandler.reportMatch(this); 17028 consume(); 17029 } 17030 } 17031 } 17032 catch (RecognitionException re) { 17033 _localctx.exception = re; 17034 _errHandler.reportError(this, re); 17035 _errHandler.recover(this, re); 17036 } 17037 finally { 17038 exitRule(); 17039 } 17040 return _localctx; 17041 } 17042 17043 public static class SourceTagContext extends ParserRuleContext { 17044 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 17045 public TerminalNode SOURCE_HTML_TAG_NAME() { return getToken(JavadocParser.SOURCE_HTML_TAG_NAME, 0); } 17046 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 17047 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 17048 public List<AttributeContext> attribute() { 17049 return getRuleContexts(AttributeContext.class); 17050 } 17051 public AttributeContext attribute(int i) { 17052 return getRuleContext(AttributeContext.class,i); 17053 } 17054 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17055 public TerminalNode NEWLINE(int i) { 17056 return getToken(JavadocParser.NEWLINE, i); 17057 } 17058 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17059 public TerminalNode LEADING_ASTERISK(int i) { 17060 return getToken(JavadocParser.LEADING_ASTERISK, i); 17061 } 17062 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 17063 public TerminalNode WS(int i) { 17064 return getToken(JavadocParser.WS, i); 17065 } 17066 public SourceTagContext(ParserRuleContext parent, int invokingState) { 17067 super(parent, invokingState); 17068 } 17069 @Override public int getRuleIndex() { return RULE_sourceTag; } 17070 } 17071 17072 public final SourceTagContext sourceTag() throws RecognitionException { 17073 SourceTagContext _localctx = new SourceTagContext(_ctx, getState()); 17074 enterRule(_localctx, 154, RULE_sourceTag); 17075 int _la; 17076 try { 17077 enterOuterAlt(_localctx, 1); 17078 { 17079 setState(2112); 17080 match(START); 17081 setState(2113); 17082 match(SOURCE_HTML_TAG_NAME); 17083 setState(2120); 17084 _errHandler.sync(this); 17085 _la = _input.LA(1); 17086 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 17087 { 17088 setState(2118); 17089 _errHandler.sync(this); 17090 switch (_input.LA(1)) { 17091 case HTML_TAG_NAME: 17092 { 17093 setState(2114); 17094 attribute(); 17095 } 17096 break; 17097 case NEWLINE: 17098 { 17099 setState(2115); 17100 match(NEWLINE); 17101 } 17102 break; 17103 case LEADING_ASTERISK: 17104 { 17105 setState(2116); 17106 match(LEADING_ASTERISK); 17107 } 17108 break; 17109 case WS: 17110 { 17111 setState(2117); 17112 match(WS); 17113 } 17114 break; 17115 default: 17116 throw new NoViableAltException(this); 17117 } 17118 } 17119 setState(2122); 17120 _errHandler.sync(this); 17121 _la = _input.LA(1); 17122 } 17123 setState(2123); 17124 _la = _input.LA(1); 17125 if ( !(_la==END || _la==SLASH_END) ) { 17126 _errHandler.recoverInline(this); 17127 } 17128 else { 17129 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 17130 _errHandler.reportMatch(this); 17131 consume(); 17132 } 17133 } 17134 } 17135 catch (RecognitionException re) { 17136 _localctx.exception = re; 17137 _errHandler.reportError(this, re); 17138 _errHandler.recover(this, re); 17139 } 17140 finally { 17141 exitRule(); 17142 } 17143 return _localctx; 17144 } 17145 17146 public static class TrackTagContext extends ParserRuleContext { 17147 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 17148 public TerminalNode TRACK_HTML_TAG_NAME() { return getToken(JavadocParser.TRACK_HTML_TAG_NAME, 0); } 17149 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 17150 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 17151 public List<AttributeContext> attribute() { 17152 return getRuleContexts(AttributeContext.class); 17153 } 17154 public AttributeContext attribute(int i) { 17155 return getRuleContext(AttributeContext.class,i); 17156 } 17157 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17158 public TerminalNode NEWLINE(int i) { 17159 return getToken(JavadocParser.NEWLINE, i); 17160 } 17161 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17162 public TerminalNode LEADING_ASTERISK(int i) { 17163 return getToken(JavadocParser.LEADING_ASTERISK, i); 17164 } 17165 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 17166 public TerminalNode WS(int i) { 17167 return getToken(JavadocParser.WS, i); 17168 } 17169 public TrackTagContext(ParserRuleContext parent, int invokingState) { 17170 super(parent, invokingState); 17171 } 17172 @Override public int getRuleIndex() { return RULE_trackTag; } 17173 } 17174 17175 public final TrackTagContext trackTag() throws RecognitionException { 17176 TrackTagContext _localctx = new TrackTagContext(_ctx, getState()); 17177 enterRule(_localctx, 156, RULE_trackTag); 17178 int _la; 17179 try { 17180 enterOuterAlt(_localctx, 1); 17181 { 17182 setState(2125); 17183 match(START); 17184 setState(2126); 17185 match(TRACK_HTML_TAG_NAME); 17186 setState(2133); 17187 _errHandler.sync(this); 17188 _la = _input.LA(1); 17189 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 17190 { 17191 setState(2131); 17192 _errHandler.sync(this); 17193 switch (_input.LA(1)) { 17194 case HTML_TAG_NAME: 17195 { 17196 setState(2127); 17197 attribute(); 17198 } 17199 break; 17200 case NEWLINE: 17201 { 17202 setState(2128); 17203 match(NEWLINE); 17204 } 17205 break; 17206 case LEADING_ASTERISK: 17207 { 17208 setState(2129); 17209 match(LEADING_ASTERISK); 17210 } 17211 break; 17212 case WS: 17213 { 17214 setState(2130); 17215 match(WS); 17216 } 17217 break; 17218 default: 17219 throw new NoViableAltException(this); 17220 } 17221 } 17222 setState(2135); 17223 _errHandler.sync(this); 17224 _la = _input.LA(1); 17225 } 17226 setState(2136); 17227 _la = _input.LA(1); 17228 if ( !(_la==END || _la==SLASH_END) ) { 17229 _errHandler.recoverInline(this); 17230 } 17231 else { 17232 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 17233 _errHandler.reportMatch(this); 17234 consume(); 17235 } 17236 } 17237 } 17238 catch (RecognitionException re) { 17239 _localctx.exception = re; 17240 _errHandler.reportError(this, re); 17241 _errHandler.recover(this, re); 17242 } 17243 finally { 17244 exitRule(); 17245 } 17246 return _localctx; 17247 } 17248 17249 public static class WbrTagContext extends ParserRuleContext { 17250 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 17251 public TerminalNode WBR_HTML_TAG_NAME() { return getToken(JavadocParser.WBR_HTML_TAG_NAME, 0); } 17252 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 17253 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 17254 public List<AttributeContext> attribute() { 17255 return getRuleContexts(AttributeContext.class); 17256 } 17257 public AttributeContext attribute(int i) { 17258 return getRuleContext(AttributeContext.class,i); 17259 } 17260 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17261 public TerminalNode NEWLINE(int i) { 17262 return getToken(JavadocParser.NEWLINE, i); 17263 } 17264 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17265 public TerminalNode LEADING_ASTERISK(int i) { 17266 return getToken(JavadocParser.LEADING_ASTERISK, i); 17267 } 17268 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 17269 public TerminalNode WS(int i) { 17270 return getToken(JavadocParser.WS, i); 17271 } 17272 public WbrTagContext(ParserRuleContext parent, int invokingState) { 17273 super(parent, invokingState); 17274 } 17275 @Override public int getRuleIndex() { return RULE_wbrTag; } 17276 } 17277 17278 public final WbrTagContext wbrTag() throws RecognitionException { 17279 WbrTagContext _localctx = new WbrTagContext(_ctx, getState()); 17280 enterRule(_localctx, 158, RULE_wbrTag); 17281 int _la; 17282 try { 17283 enterOuterAlt(_localctx, 1); 17284 { 17285 setState(2138); 17286 match(START); 17287 setState(2139); 17288 match(WBR_HTML_TAG_NAME); 17289 setState(2146); 17290 _errHandler.sync(this); 17291 _la = _input.LA(1); 17292 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 17293 { 17294 setState(2144); 17295 _errHandler.sync(this); 17296 switch (_input.LA(1)) { 17297 case HTML_TAG_NAME: 17298 { 17299 setState(2140); 17300 attribute(); 17301 } 17302 break; 17303 case NEWLINE: 17304 { 17305 setState(2141); 17306 match(NEWLINE); 17307 } 17308 break; 17309 case LEADING_ASTERISK: 17310 { 17311 setState(2142); 17312 match(LEADING_ASTERISK); 17313 } 17314 break; 17315 case WS: 17316 { 17317 setState(2143); 17318 match(WS); 17319 } 17320 break; 17321 default: 17322 throw new NoViableAltException(this); 17323 } 17324 } 17325 setState(2148); 17326 _errHandler.sync(this); 17327 _la = _input.LA(1); 17328 } 17329 setState(2149); 17330 _la = _input.LA(1); 17331 if ( !(_la==END || _la==SLASH_END) ) { 17332 _errHandler.recoverInline(this); 17333 } 17334 else { 17335 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 17336 _errHandler.reportMatch(this); 17337 consume(); 17338 } 17339 } 17340 } 17341 catch (RecognitionException re) { 17342 _localctx.exception = re; 17343 _errHandler.reportError(this, re); 17344 _errHandler.recover(this, re); 17345 } 17346 finally { 17347 exitRule(); 17348 } 17349 return _localctx; 17350 } 17351 17352 public static class OptgroupTagStartContext extends ParserRuleContext { 17353 public boolean isNonTight; 17354 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 17355 public TerminalNode OPTGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.OPTGROUP_HTML_TAG_NAME, 0); } 17356 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 17357 public List<AttributeContext> attribute() { 17358 return getRuleContexts(AttributeContext.class); 17359 } 17360 public AttributeContext attribute(int i) { 17361 return getRuleContext(AttributeContext.class,i); 17362 } 17363 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17364 public TerminalNode NEWLINE(int i) { 17365 return getToken(JavadocParser.NEWLINE, i); 17366 } 17367 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17368 public TerminalNode LEADING_ASTERISK(int i) { 17369 return getToken(JavadocParser.LEADING_ASTERISK, i); 17370 } 17371 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 17372 public TerminalNode WS(int i) { 17373 return getToken(JavadocParser.WS, i); 17374 } 17375 public OptgroupTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 17376 public OptgroupTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 17377 super(parent, invokingState); 17378 this.isNonTight = isNonTight; 17379 } 17380 @Override public int getRuleIndex() { return RULE_optgroupTagStart; } 17381 } 17382 17383 public final OptgroupTagStartContext optgroupTagStart(boolean isNonTight) throws RecognitionException { 17384 OptgroupTagStartContext _localctx = new OptgroupTagStartContext(_ctx, getState(), isNonTight); 17385 enterRule(_localctx, 160, RULE_optgroupTagStart); 17386 int _la; 17387 try { 17388 enterOuterAlt(_localctx, 1); 17389 { 17390 setState(2151); 17391 match(START); 17392 setState(2152); 17393 match(OPTGROUP_HTML_TAG_NAME); 17394 setState(2159); 17395 _errHandler.sync(this); 17396 _la = _input.LA(1); 17397 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 17398 { 17399 setState(2157); 17400 _errHandler.sync(this); 17401 switch (_input.LA(1)) { 17402 case HTML_TAG_NAME: 17403 { 17404 setState(2153); 17405 attribute(); 17406 } 17407 break; 17408 case NEWLINE: 17409 { 17410 setState(2154); 17411 match(NEWLINE); 17412 } 17413 break; 17414 case LEADING_ASTERISK: 17415 { 17416 setState(2155); 17417 match(LEADING_ASTERISK); 17418 } 17419 break; 17420 case WS: 17421 { 17422 setState(2156); 17423 match(WS); 17424 } 17425 break; 17426 default: 17427 throw new NoViableAltException(this); 17428 } 17429 } 17430 setState(2161); 17431 _errHandler.sync(this); 17432 _la = _input.LA(1); 17433 } 17434 setState(2162); 17435 match(END); 17436 } 17437 _ctx.stop = _input.LT(-1); 17438 17439 if (isNonTight && nonTightTagStartContext == null) { 17440 nonTightTagStartContext = _localctx; 17441 } 17442 17443 } 17444 catch (RecognitionException re) { 17445 _localctx.exception = re; 17446 _errHandler.reportError(this, re); 17447 _errHandler.recover(this, re); 17448 } 17449 finally { 17450 exitRule(); 17451 } 17452 return _localctx; 17453 } 17454 17455 public static class OptgroupTagEndContext extends ParserRuleContext { 17456 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 17457 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 17458 public TerminalNode OPTGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.OPTGROUP_HTML_TAG_NAME, 0); } 17459 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 17460 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17461 public TerminalNode NEWLINE(int i) { 17462 return getToken(JavadocParser.NEWLINE, i); 17463 } 17464 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17465 public TerminalNode LEADING_ASTERISK(int i) { 17466 return getToken(JavadocParser.LEADING_ASTERISK, i); 17467 } 17468 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 17469 public TerminalNode WS(int i) { 17470 return getToken(JavadocParser.WS, i); 17471 } 17472 public OptgroupTagEndContext(ParserRuleContext parent, int invokingState) { 17473 super(parent, invokingState); 17474 } 17475 @Override public int getRuleIndex() { return RULE_optgroupTagEnd; } 17476 } 17477 17478 public final OptgroupTagEndContext optgroupTagEnd() throws RecognitionException { 17479 OptgroupTagEndContext _localctx = new OptgroupTagEndContext(_ctx, getState()); 17480 enterRule(_localctx, 162, RULE_optgroupTagEnd); 17481 int _la; 17482 try { 17483 enterOuterAlt(_localctx, 1); 17484 { 17485 setState(2164); 17486 match(START); 17487 setState(2165); 17488 match(SLASH); 17489 setState(2166); 17490 match(OPTGROUP_HTML_TAG_NAME); 17491 setState(2170); 17492 _errHandler.sync(this); 17493 _la = _input.LA(1); 17494 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 17495 { 17496 { 17497 setState(2167); 17498 _la = _input.LA(1); 17499 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 17500 _errHandler.recoverInline(this); 17501 } 17502 else { 17503 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 17504 _errHandler.reportMatch(this); 17505 consume(); 17506 } 17507 } 17508 } 17509 setState(2172); 17510 _errHandler.sync(this); 17511 _la = _input.LA(1); 17512 } 17513 setState(2173); 17514 match(END); 17515 } 17516 } 17517 catch (RecognitionException re) { 17518 _localctx.exception = re; 17519 _errHandler.reportError(this, re); 17520 _errHandler.recover(this, re); 17521 } 17522 finally { 17523 exitRule(); 17524 } 17525 return _localctx; 17526 } 17527 17528 public static class OptgroupContext extends ParserRuleContext { 17529 public OptgroupTagStartContext optgroupTagStart() { 17530 return getRuleContext(OptgroupTagStartContext.class,0); 17531 } 17532 public OptgroupTagEndContext optgroupTagEnd() { 17533 return getRuleContext(OptgroupTagEndContext.class,0); 17534 } 17535 public List<HtmlTagContext> htmlTag() { 17536 return getRuleContexts(HtmlTagContext.class); 17537 } 17538 public HtmlTagContext htmlTag(int i) { 17539 return getRuleContext(HtmlTagContext.class,i); 17540 } 17541 public List<SingletonElementContext> singletonElement() { 17542 return getRuleContexts(SingletonElementContext.class); 17543 } 17544 public SingletonElementContext singletonElement(int i) { 17545 return getRuleContext(SingletonElementContext.class,i); 17546 } 17547 public List<ParagraphContext> paragraph() { 17548 return getRuleContexts(ParagraphContext.class); 17549 } 17550 public ParagraphContext paragraph(int i) { 17551 return getRuleContext(ParagraphContext.class,i); 17552 } 17553 public List<LiContext> li() { 17554 return getRuleContexts(LiContext.class); 17555 } 17556 public LiContext li(int i) { 17557 return getRuleContext(LiContext.class,i); 17558 } 17559 public List<TrContext> tr() { 17560 return getRuleContexts(TrContext.class); 17561 } 17562 public TrContext tr(int i) { 17563 return getRuleContext(TrContext.class,i); 17564 } 17565 public List<TdContext> td() { 17566 return getRuleContexts(TdContext.class); 17567 } 17568 public TdContext td(int i) { 17569 return getRuleContext(TdContext.class,i); 17570 } 17571 public List<ThContext> th() { 17572 return getRuleContexts(ThContext.class); 17573 } 17574 public ThContext th(int i) { 17575 return getRuleContext(ThContext.class,i); 17576 } 17577 public List<BodyContext> body() { 17578 return getRuleContexts(BodyContext.class); 17579 } 17580 public BodyContext body(int i) { 17581 return getRuleContext(BodyContext.class,i); 17582 } 17583 public List<ColgroupContext> colgroup() { 17584 return getRuleContexts(ColgroupContext.class); 17585 } 17586 public ColgroupContext colgroup(int i) { 17587 return getRuleContext(ColgroupContext.class,i); 17588 } 17589 public List<DdContext> dd() { 17590 return getRuleContexts(DdContext.class); 17591 } 17592 public DdContext dd(int i) { 17593 return getRuleContext(DdContext.class,i); 17594 } 17595 public List<DtContext> dt() { 17596 return getRuleContexts(DtContext.class); 17597 } 17598 public DtContext dt(int i) { 17599 return getRuleContext(DtContext.class,i); 17600 } 17601 public List<HeadContext> head() { 17602 return getRuleContexts(HeadContext.class); 17603 } 17604 public HeadContext head(int i) { 17605 return getRuleContext(HeadContext.class,i); 17606 } 17607 public List<HtmlContext> html() { 17608 return getRuleContexts(HtmlContext.class); 17609 } 17610 public HtmlContext html(int i) { 17611 return getRuleContext(HtmlContext.class,i); 17612 } 17613 public List<OptionContext> option() { 17614 return getRuleContexts(OptionContext.class); 17615 } 17616 public OptionContext option(int i) { 17617 return getRuleContext(OptionContext.class,i); 17618 } 17619 public List<TbodyContext> tbody() { 17620 return getRuleContexts(TbodyContext.class); 17621 } 17622 public TbodyContext tbody(int i) { 17623 return getRuleContext(TbodyContext.class,i); 17624 } 17625 public List<TfootContext> tfoot() { 17626 return getRuleContexts(TfootContext.class); 17627 } 17628 public TfootContext tfoot(int i) { 17629 return getRuleContext(TfootContext.class,i); 17630 } 17631 public List<PTagStartContext> pTagStart() { 17632 return getRuleContexts(PTagStartContext.class); 17633 } 17634 public PTagStartContext pTagStart(int i) { 17635 return getRuleContext(PTagStartContext.class,i); 17636 } 17637 public List<LiTagStartContext> liTagStart() { 17638 return getRuleContexts(LiTagStartContext.class); 17639 } 17640 public LiTagStartContext liTagStart(int i) { 17641 return getRuleContext(LiTagStartContext.class,i); 17642 } 17643 public List<TrTagStartContext> trTagStart() { 17644 return getRuleContexts(TrTagStartContext.class); 17645 } 17646 public TrTagStartContext trTagStart(int i) { 17647 return getRuleContext(TrTagStartContext.class,i); 17648 } 17649 public List<TdTagStartContext> tdTagStart() { 17650 return getRuleContexts(TdTagStartContext.class); 17651 } 17652 public TdTagStartContext tdTagStart(int i) { 17653 return getRuleContext(TdTagStartContext.class,i); 17654 } 17655 public List<ThTagStartContext> thTagStart() { 17656 return getRuleContexts(ThTagStartContext.class); 17657 } 17658 public ThTagStartContext thTagStart(int i) { 17659 return getRuleContext(ThTagStartContext.class,i); 17660 } 17661 public List<BodyTagStartContext> bodyTagStart() { 17662 return getRuleContexts(BodyTagStartContext.class); 17663 } 17664 public BodyTagStartContext bodyTagStart(int i) { 17665 return getRuleContext(BodyTagStartContext.class,i); 17666 } 17667 public List<ColgroupTagStartContext> colgroupTagStart() { 17668 return getRuleContexts(ColgroupTagStartContext.class); 17669 } 17670 public ColgroupTagStartContext colgroupTagStart(int i) { 17671 return getRuleContext(ColgroupTagStartContext.class,i); 17672 } 17673 public List<DdTagStartContext> ddTagStart() { 17674 return getRuleContexts(DdTagStartContext.class); 17675 } 17676 public DdTagStartContext ddTagStart(int i) { 17677 return getRuleContext(DdTagStartContext.class,i); 17678 } 17679 public List<DtTagStartContext> dtTagStart() { 17680 return getRuleContexts(DtTagStartContext.class); 17681 } 17682 public DtTagStartContext dtTagStart(int i) { 17683 return getRuleContext(DtTagStartContext.class,i); 17684 } 17685 public List<HeadTagStartContext> headTagStart() { 17686 return getRuleContexts(HeadTagStartContext.class); 17687 } 17688 public HeadTagStartContext headTagStart(int i) { 17689 return getRuleContext(HeadTagStartContext.class,i); 17690 } 17691 public List<HtmlTagStartContext> htmlTagStart() { 17692 return getRuleContexts(HtmlTagStartContext.class); 17693 } 17694 public HtmlTagStartContext htmlTagStart(int i) { 17695 return getRuleContext(HtmlTagStartContext.class,i); 17696 } 17697 public List<OptionTagStartContext> optionTagStart() { 17698 return getRuleContexts(OptionTagStartContext.class); 17699 } 17700 public OptionTagStartContext optionTagStart(int i) { 17701 return getRuleContext(OptionTagStartContext.class,i); 17702 } 17703 public List<TbodyTagStartContext> tbodyTagStart() { 17704 return getRuleContexts(TbodyTagStartContext.class); 17705 } 17706 public TbodyTagStartContext tbodyTagStart(int i) { 17707 return getRuleContext(TbodyTagStartContext.class,i); 17708 } 17709 public List<TfootTagStartContext> tfootTagStart() { 17710 return getRuleContexts(TfootTagStartContext.class); 17711 } 17712 public TfootTagStartContext tfootTagStart(int i) { 17713 return getRuleContext(TfootTagStartContext.class,i); 17714 } 17715 public List<HtmlCommentContext> htmlComment() { 17716 return getRuleContexts(HtmlCommentContext.class); 17717 } 17718 public HtmlCommentContext htmlComment(int i) { 17719 return getRuleContext(HtmlCommentContext.class,i); 17720 } 17721 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 17722 public TerminalNode CDATA(int i) { 17723 return getToken(JavadocParser.CDATA, i); 17724 } 17725 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17726 public TerminalNode NEWLINE(int i) { 17727 return getToken(JavadocParser.NEWLINE, i); 17728 } 17729 public List<TextContext> text() { 17730 return getRuleContexts(TextContext.class); 17731 } 17732 public TextContext text(int i) { 17733 return getRuleContext(TextContext.class,i); 17734 } 17735 public List<JavadocInlineTagContext> javadocInlineTag() { 17736 return getRuleContexts(JavadocInlineTagContext.class); 17737 } 17738 public JavadocInlineTagContext javadocInlineTag(int i) { 17739 return getRuleContext(JavadocInlineTagContext.class,i); 17740 } 17741 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17742 public TerminalNode LEADING_ASTERISK(int i) { 17743 return getToken(JavadocParser.LEADING_ASTERISK, i); 17744 } 17745 public OptgroupContext(ParserRuleContext parent, int invokingState) { 17746 super(parent, invokingState); 17747 } 17748 @Override public int getRuleIndex() { return RULE_optgroup; } 17749 } 17750 17751 public final OptgroupContext optgroup() throws RecognitionException { 17752 OptgroupContext _localctx = new OptgroupContext(_ctx, getState()); 17753 enterRule(_localctx, 164, RULE_optgroup); 17754 try { 17755 int _alt; 17756 enterOuterAlt(_localctx, 1); 17757 { 17758 setState(2175); 17759 optgroupTagStart(false); 17760 setState(2215); 17761 _errHandler.sync(this); 17762 _alt = getInterpreter().adaptivePredict(_input,196,_ctx); 17763 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 17764 if ( _alt==1 ) { 17765 { 17766 setState(2213); 17767 _errHandler.sync(this); 17768 switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) { 17769 case 1: 17770 { 17771 setState(2176); 17772 htmlTag(); 17773 } 17774 break; 17775 case 2: 17776 { 17777 setState(2177); 17778 singletonElement(); 17779 } 17780 break; 17781 case 3: 17782 { 17783 setState(2178); 17784 paragraph(); 17785 } 17786 break; 17787 case 4: 17788 { 17789 setState(2179); 17790 li(); 17791 } 17792 break; 17793 case 5: 17794 { 17795 setState(2180); 17796 tr(); 17797 } 17798 break; 17799 case 6: 17800 { 17801 setState(2181); 17802 td(); 17803 } 17804 break; 17805 case 7: 17806 { 17807 setState(2182); 17808 th(); 17809 } 17810 break; 17811 case 8: 17812 { 17813 setState(2183); 17814 body(); 17815 } 17816 break; 17817 case 9: 17818 { 17819 setState(2184); 17820 colgroup(); 17821 } 17822 break; 17823 case 10: 17824 { 17825 setState(2185); 17826 dd(); 17827 } 17828 break; 17829 case 11: 17830 { 17831 setState(2186); 17832 dt(); 17833 } 17834 break; 17835 case 12: 17836 { 17837 setState(2187); 17838 head(); 17839 } 17840 break; 17841 case 13: 17842 { 17843 setState(2188); 17844 html(); 17845 } 17846 break; 17847 case 14: 17848 { 17849 setState(2189); 17850 option(); 17851 } 17852 break; 17853 case 15: 17854 { 17855 setState(2190); 17856 tbody(); 17857 } 17858 break; 17859 case 16: 17860 { 17861 setState(2191); 17862 tfoot(); 17863 } 17864 break; 17865 case 17: 17866 { 17867 setState(2192); 17868 pTagStart(true); 17869 } 17870 break; 17871 case 18: 17872 { 17873 setState(2193); 17874 liTagStart(true); 17875 } 17876 break; 17877 case 19: 17878 { 17879 setState(2194); 17880 trTagStart(true); 17881 } 17882 break; 17883 case 20: 17884 { 17885 setState(2195); 17886 tdTagStart(true); 17887 } 17888 break; 17889 case 21: 17890 { 17891 setState(2196); 17892 thTagStart(true); 17893 } 17894 break; 17895 case 22: 17896 { 17897 setState(2197); 17898 bodyTagStart(true); 17899 } 17900 break; 17901 case 23: 17902 { 17903 setState(2198); 17904 colgroupTagStart(true); 17905 } 17906 break; 17907 case 24: 17908 { 17909 setState(2199); 17910 ddTagStart(true); 17911 } 17912 break; 17913 case 25: 17914 { 17915 setState(2200); 17916 dtTagStart(true); 17917 } 17918 break; 17919 case 26: 17920 { 17921 setState(2201); 17922 headTagStart(true); 17923 } 17924 break; 17925 case 27: 17926 { 17927 setState(2202); 17928 htmlTagStart(true); 17929 } 17930 break; 17931 case 28: 17932 { 17933 setState(2203); 17934 optionTagStart(true); 17935 } 17936 break; 17937 case 29: 17938 { 17939 setState(2204); 17940 tbodyTagStart(true); 17941 } 17942 break; 17943 case 30: 17944 { 17945 setState(2205); 17946 tfootTagStart(true); 17947 } 17948 break; 17949 case 31: 17950 { 17951 { 17952 setState(2206); 17953 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 17954 setState(2207); 17955 match(LEADING_ASTERISK); 17956 } 17957 } 17958 break; 17959 case 32: 17960 { 17961 setState(2208); 17962 htmlComment(); 17963 } 17964 break; 17965 case 33: 17966 { 17967 setState(2209); 17968 match(CDATA); 17969 } 17970 break; 17971 case 34: 17972 { 17973 setState(2210); 17974 match(NEWLINE); 17975 } 17976 break; 17977 case 35: 17978 { 17979 setState(2211); 17980 text(); 17981 } 17982 break; 17983 case 36: 17984 { 17985 setState(2212); 17986 javadocInlineTag(); 17987 } 17988 break; 17989 } 17990 } 17991 } 17992 setState(2217); 17993 _errHandler.sync(this); 17994 _alt = getInterpreter().adaptivePredict(_input,196,_ctx); 17995 } 17996 setState(2218); 17997 optgroupTagEnd(); 17998 } 17999 } 18000 catch (RecognitionException re) { 18001 _localctx.exception = re; 18002 _errHandler.reportError(this, re); 18003 _errHandler.recover(this, re); 18004 } 18005 finally { 18006 exitRule(); 18007 } 18008 return _localctx; 18009 } 18010 18011 public static class RbTagStartContext extends ParserRuleContext { 18012 public boolean isNonTight; 18013 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 18014 public TerminalNode RB_HTML_TAG_NAME() { return getToken(JavadocParser.RB_HTML_TAG_NAME, 0); } 18015 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 18016 public List<AttributeContext> attribute() { 18017 return getRuleContexts(AttributeContext.class); 18018 } 18019 public AttributeContext attribute(int i) { 18020 return getRuleContext(AttributeContext.class,i); 18021 } 18022 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 18023 public TerminalNode NEWLINE(int i) { 18024 return getToken(JavadocParser.NEWLINE, i); 18025 } 18026 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 18027 public TerminalNode LEADING_ASTERISK(int i) { 18028 return getToken(JavadocParser.LEADING_ASTERISK, i); 18029 } 18030 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 18031 public TerminalNode WS(int i) { 18032 return getToken(JavadocParser.WS, i); 18033 } 18034 public RbTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 18035 public RbTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 18036 super(parent, invokingState); 18037 this.isNonTight = isNonTight; 18038 } 18039 @Override public int getRuleIndex() { return RULE_rbTagStart; } 18040 } 18041 18042 public final RbTagStartContext rbTagStart(boolean isNonTight) throws RecognitionException { 18043 RbTagStartContext _localctx = new RbTagStartContext(_ctx, getState(), isNonTight); 18044 enterRule(_localctx, 166, RULE_rbTagStart); 18045 int _la; 18046 try { 18047 enterOuterAlt(_localctx, 1); 18048 { 18049 setState(2220); 18050 match(START); 18051 setState(2221); 18052 match(RB_HTML_TAG_NAME); 18053 setState(2228); 18054 _errHandler.sync(this); 18055 _la = _input.LA(1); 18056 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 18057 { 18058 setState(2226); 18059 _errHandler.sync(this); 18060 switch (_input.LA(1)) { 18061 case HTML_TAG_NAME: 18062 { 18063 setState(2222); 18064 attribute(); 18065 } 18066 break; 18067 case NEWLINE: 18068 { 18069 setState(2223); 18070 match(NEWLINE); 18071 } 18072 break; 18073 case LEADING_ASTERISK: 18074 { 18075 setState(2224); 18076 match(LEADING_ASTERISK); 18077 } 18078 break; 18079 case WS: 18080 { 18081 setState(2225); 18082 match(WS); 18083 } 18084 break; 18085 default: 18086 throw new NoViableAltException(this); 18087 } 18088 } 18089 setState(2230); 18090 _errHandler.sync(this); 18091 _la = _input.LA(1); 18092 } 18093 setState(2231); 18094 match(END); 18095 } 18096 _ctx.stop = _input.LT(-1); 18097 18098 if (isNonTight && nonTightTagStartContext == null) { 18099 nonTightTagStartContext = _localctx; 18100 } 18101 18102 } 18103 catch (RecognitionException re) { 18104 _localctx.exception = re; 18105 _errHandler.reportError(this, re); 18106 _errHandler.recover(this, re); 18107 } 18108 finally { 18109 exitRule(); 18110 } 18111 return _localctx; 18112 } 18113 18114 public static class RbTagEndContext extends ParserRuleContext { 18115 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 18116 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 18117 public TerminalNode RB_HTML_TAG_NAME() { return getToken(JavadocParser.RB_HTML_TAG_NAME, 0); } 18118 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 18119 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 18120 public TerminalNode NEWLINE(int i) { 18121 return getToken(JavadocParser.NEWLINE, i); 18122 } 18123 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 18124 public TerminalNode LEADING_ASTERISK(int i) { 18125 return getToken(JavadocParser.LEADING_ASTERISK, i); 18126 } 18127 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 18128 public TerminalNode WS(int i) { 18129 return getToken(JavadocParser.WS, i); 18130 } 18131 public RbTagEndContext(ParserRuleContext parent, int invokingState) { 18132 super(parent, invokingState); 18133 } 18134 @Override public int getRuleIndex() { return RULE_rbTagEnd; } 18135 } 18136 18137 public final RbTagEndContext rbTagEnd() throws RecognitionException { 18138 RbTagEndContext _localctx = new RbTagEndContext(_ctx, getState()); 18139 enterRule(_localctx, 168, RULE_rbTagEnd); 18140 int _la; 18141 try { 18142 enterOuterAlt(_localctx, 1); 18143 { 18144 setState(2233); 18145 match(START); 18146 setState(2234); 18147 match(SLASH); 18148 setState(2235); 18149 match(RB_HTML_TAG_NAME); 18150 setState(2239); 18151 _errHandler.sync(this); 18152 _la = _input.LA(1); 18153 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 18154 { 18155 { 18156 setState(2236); 18157 _la = _input.LA(1); 18158 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 18159 _errHandler.recoverInline(this); 18160 } 18161 else { 18162 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 18163 _errHandler.reportMatch(this); 18164 consume(); 18165 } 18166 } 18167 } 18168 setState(2241); 18169 _errHandler.sync(this); 18170 _la = _input.LA(1); 18171 } 18172 setState(2242); 18173 match(END); 18174 } 18175 } 18176 catch (RecognitionException re) { 18177 _localctx.exception = re; 18178 _errHandler.reportError(this, re); 18179 _errHandler.recover(this, re); 18180 } 18181 finally { 18182 exitRule(); 18183 } 18184 return _localctx; 18185 } 18186 18187 public static class RbContext extends ParserRuleContext { 18188 public RbTagStartContext rbTagStart() { 18189 return getRuleContext(RbTagStartContext.class,0); 18190 } 18191 public RbTagEndContext rbTagEnd() { 18192 return getRuleContext(RbTagEndContext.class,0); 18193 } 18194 public List<HtmlTagContext> htmlTag() { 18195 return getRuleContexts(HtmlTagContext.class); 18196 } 18197 public HtmlTagContext htmlTag(int i) { 18198 return getRuleContext(HtmlTagContext.class,i); 18199 } 18200 public List<SingletonElementContext> singletonElement() { 18201 return getRuleContexts(SingletonElementContext.class); 18202 } 18203 public SingletonElementContext singletonElement(int i) { 18204 return getRuleContext(SingletonElementContext.class,i); 18205 } 18206 public List<ParagraphContext> paragraph() { 18207 return getRuleContexts(ParagraphContext.class); 18208 } 18209 public ParagraphContext paragraph(int i) { 18210 return getRuleContext(ParagraphContext.class,i); 18211 } 18212 public List<LiContext> li() { 18213 return getRuleContexts(LiContext.class); 18214 } 18215 public LiContext li(int i) { 18216 return getRuleContext(LiContext.class,i); 18217 } 18218 public List<TrContext> tr() { 18219 return getRuleContexts(TrContext.class); 18220 } 18221 public TrContext tr(int i) { 18222 return getRuleContext(TrContext.class,i); 18223 } 18224 public List<TdContext> td() { 18225 return getRuleContexts(TdContext.class); 18226 } 18227 public TdContext td(int i) { 18228 return getRuleContext(TdContext.class,i); 18229 } 18230 public List<ThContext> th() { 18231 return getRuleContexts(ThContext.class); 18232 } 18233 public ThContext th(int i) { 18234 return getRuleContext(ThContext.class,i); 18235 } 18236 public List<BodyContext> body() { 18237 return getRuleContexts(BodyContext.class); 18238 } 18239 public BodyContext body(int i) { 18240 return getRuleContext(BodyContext.class,i); 18241 } 18242 public List<ColgroupContext> colgroup() { 18243 return getRuleContexts(ColgroupContext.class); 18244 } 18245 public ColgroupContext colgroup(int i) { 18246 return getRuleContext(ColgroupContext.class,i); 18247 } 18248 public List<DdContext> dd() { 18249 return getRuleContexts(DdContext.class); 18250 } 18251 public DdContext dd(int i) { 18252 return getRuleContext(DdContext.class,i); 18253 } 18254 public List<DtContext> dt() { 18255 return getRuleContexts(DtContext.class); 18256 } 18257 public DtContext dt(int i) { 18258 return getRuleContext(DtContext.class,i); 18259 } 18260 public List<HeadContext> head() { 18261 return getRuleContexts(HeadContext.class); 18262 } 18263 public HeadContext head(int i) { 18264 return getRuleContext(HeadContext.class,i); 18265 } 18266 public List<HtmlContext> html() { 18267 return getRuleContexts(HtmlContext.class); 18268 } 18269 public HtmlContext html(int i) { 18270 return getRuleContext(HtmlContext.class,i); 18271 } 18272 public List<OptionContext> option() { 18273 return getRuleContexts(OptionContext.class); 18274 } 18275 public OptionContext option(int i) { 18276 return getRuleContext(OptionContext.class,i); 18277 } 18278 public List<TbodyContext> tbody() { 18279 return getRuleContexts(TbodyContext.class); 18280 } 18281 public TbodyContext tbody(int i) { 18282 return getRuleContext(TbodyContext.class,i); 18283 } 18284 public List<TfootContext> tfoot() { 18285 return getRuleContexts(TfootContext.class); 18286 } 18287 public TfootContext tfoot(int i) { 18288 return getRuleContext(TfootContext.class,i); 18289 } 18290 public List<PTagStartContext> pTagStart() { 18291 return getRuleContexts(PTagStartContext.class); 18292 } 18293 public PTagStartContext pTagStart(int i) { 18294 return getRuleContext(PTagStartContext.class,i); 18295 } 18296 public List<LiTagStartContext> liTagStart() { 18297 return getRuleContexts(LiTagStartContext.class); 18298 } 18299 public LiTagStartContext liTagStart(int i) { 18300 return getRuleContext(LiTagStartContext.class,i); 18301 } 18302 public List<TrTagStartContext> trTagStart() { 18303 return getRuleContexts(TrTagStartContext.class); 18304 } 18305 public TrTagStartContext trTagStart(int i) { 18306 return getRuleContext(TrTagStartContext.class,i); 18307 } 18308 public List<TdTagStartContext> tdTagStart() { 18309 return getRuleContexts(TdTagStartContext.class); 18310 } 18311 public TdTagStartContext tdTagStart(int i) { 18312 return getRuleContext(TdTagStartContext.class,i); 18313 } 18314 public List<ThTagStartContext> thTagStart() { 18315 return getRuleContexts(ThTagStartContext.class); 18316 } 18317 public ThTagStartContext thTagStart(int i) { 18318 return getRuleContext(ThTagStartContext.class,i); 18319 } 18320 public List<BodyTagStartContext> bodyTagStart() { 18321 return getRuleContexts(BodyTagStartContext.class); 18322 } 18323 public BodyTagStartContext bodyTagStart(int i) { 18324 return getRuleContext(BodyTagStartContext.class,i); 18325 } 18326 public List<ColgroupTagStartContext> colgroupTagStart() { 18327 return getRuleContexts(ColgroupTagStartContext.class); 18328 } 18329 public ColgroupTagStartContext colgroupTagStart(int i) { 18330 return getRuleContext(ColgroupTagStartContext.class,i); 18331 } 18332 public List<DdTagStartContext> ddTagStart() { 18333 return getRuleContexts(DdTagStartContext.class); 18334 } 18335 public DdTagStartContext ddTagStart(int i) { 18336 return getRuleContext(DdTagStartContext.class,i); 18337 } 18338 public List<DtTagStartContext> dtTagStart() { 18339 return getRuleContexts(DtTagStartContext.class); 18340 } 18341 public DtTagStartContext dtTagStart(int i) { 18342 return getRuleContext(DtTagStartContext.class,i); 18343 } 18344 public List<HeadTagStartContext> headTagStart() { 18345 return getRuleContexts(HeadTagStartContext.class); 18346 } 18347 public HeadTagStartContext headTagStart(int i) { 18348 return getRuleContext(HeadTagStartContext.class,i); 18349 } 18350 public List<HtmlTagStartContext> htmlTagStart() { 18351 return getRuleContexts(HtmlTagStartContext.class); 18352 } 18353 public HtmlTagStartContext htmlTagStart(int i) { 18354 return getRuleContext(HtmlTagStartContext.class,i); 18355 } 18356 public List<OptionTagStartContext> optionTagStart() { 18357 return getRuleContexts(OptionTagStartContext.class); 18358 } 18359 public OptionTagStartContext optionTagStart(int i) { 18360 return getRuleContext(OptionTagStartContext.class,i); 18361 } 18362 public List<TbodyTagStartContext> tbodyTagStart() { 18363 return getRuleContexts(TbodyTagStartContext.class); 18364 } 18365 public TbodyTagStartContext tbodyTagStart(int i) { 18366 return getRuleContext(TbodyTagStartContext.class,i); 18367 } 18368 public List<TfootTagStartContext> tfootTagStart() { 18369 return getRuleContexts(TfootTagStartContext.class); 18370 } 18371 public TfootTagStartContext tfootTagStart(int i) { 18372 return getRuleContext(TfootTagStartContext.class,i); 18373 } 18374 public List<HtmlCommentContext> htmlComment() { 18375 return getRuleContexts(HtmlCommentContext.class); 18376 } 18377 public HtmlCommentContext htmlComment(int i) { 18378 return getRuleContext(HtmlCommentContext.class,i); 18379 } 18380 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 18381 public TerminalNode CDATA(int i) { 18382 return getToken(JavadocParser.CDATA, i); 18383 } 18384 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 18385 public TerminalNode NEWLINE(int i) { 18386 return getToken(JavadocParser.NEWLINE, i); 18387 } 18388 public List<TextContext> text() { 18389 return getRuleContexts(TextContext.class); 18390 } 18391 public TextContext text(int i) { 18392 return getRuleContext(TextContext.class,i); 18393 } 18394 public List<JavadocInlineTagContext> javadocInlineTag() { 18395 return getRuleContexts(JavadocInlineTagContext.class); 18396 } 18397 public JavadocInlineTagContext javadocInlineTag(int i) { 18398 return getRuleContext(JavadocInlineTagContext.class,i); 18399 } 18400 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 18401 public TerminalNode LEADING_ASTERISK(int i) { 18402 return getToken(JavadocParser.LEADING_ASTERISK, i); 18403 } 18404 public RbContext(ParserRuleContext parent, int invokingState) { 18405 super(parent, invokingState); 18406 } 18407 @Override public int getRuleIndex() { return RULE_rb; } 18408 } 18409 18410 public final RbContext rb() throws RecognitionException { 18411 RbContext _localctx = new RbContext(_ctx, getState()); 18412 enterRule(_localctx, 170, RULE_rb); 18413 try { 18414 int _alt; 18415 enterOuterAlt(_localctx, 1); 18416 { 18417 setState(2244); 18418 rbTagStart(false); 18419 setState(2284); 18420 _errHandler.sync(this); 18421 _alt = getInterpreter().adaptivePredict(_input,201,_ctx); 18422 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 18423 if ( _alt==1 ) { 18424 { 18425 setState(2282); 18426 _errHandler.sync(this); 18427 switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) { 18428 case 1: 18429 { 18430 setState(2245); 18431 htmlTag(); 18432 } 18433 break; 18434 case 2: 18435 { 18436 setState(2246); 18437 singletonElement(); 18438 } 18439 break; 18440 case 3: 18441 { 18442 setState(2247); 18443 paragraph(); 18444 } 18445 break; 18446 case 4: 18447 { 18448 setState(2248); 18449 li(); 18450 } 18451 break; 18452 case 5: 18453 { 18454 setState(2249); 18455 tr(); 18456 } 18457 break; 18458 case 6: 18459 { 18460 setState(2250); 18461 td(); 18462 } 18463 break; 18464 case 7: 18465 { 18466 setState(2251); 18467 th(); 18468 } 18469 break; 18470 case 8: 18471 { 18472 setState(2252); 18473 body(); 18474 } 18475 break; 18476 case 9: 18477 { 18478 setState(2253); 18479 colgroup(); 18480 } 18481 break; 18482 case 10: 18483 { 18484 setState(2254); 18485 dd(); 18486 } 18487 break; 18488 case 11: 18489 { 18490 setState(2255); 18491 dt(); 18492 } 18493 break; 18494 case 12: 18495 { 18496 setState(2256); 18497 head(); 18498 } 18499 break; 18500 case 13: 18501 { 18502 setState(2257); 18503 html(); 18504 } 18505 break; 18506 case 14: 18507 { 18508 setState(2258); 18509 option(); 18510 } 18511 break; 18512 case 15: 18513 { 18514 setState(2259); 18515 tbody(); 18516 } 18517 break; 18518 case 16: 18519 { 18520 setState(2260); 18521 tfoot(); 18522 } 18523 break; 18524 case 17: 18525 { 18526 setState(2261); 18527 pTagStart(true); 18528 } 18529 break; 18530 case 18: 18531 { 18532 setState(2262); 18533 liTagStart(true); 18534 } 18535 break; 18536 case 19: 18537 { 18538 setState(2263); 18539 trTagStart(true); 18540 } 18541 break; 18542 case 20: 18543 { 18544 setState(2264); 18545 tdTagStart(true); 18546 } 18547 break; 18548 case 21: 18549 { 18550 setState(2265); 18551 thTagStart(true); 18552 } 18553 break; 18554 case 22: 18555 { 18556 setState(2266); 18557 bodyTagStart(true); 18558 } 18559 break; 18560 case 23: 18561 { 18562 setState(2267); 18563 colgroupTagStart(true); 18564 } 18565 break; 18566 case 24: 18567 { 18568 setState(2268); 18569 ddTagStart(true); 18570 } 18571 break; 18572 case 25: 18573 { 18574 setState(2269); 18575 dtTagStart(true); 18576 } 18577 break; 18578 case 26: 18579 { 18580 setState(2270); 18581 headTagStart(true); 18582 } 18583 break; 18584 case 27: 18585 { 18586 setState(2271); 18587 htmlTagStart(true); 18588 } 18589 break; 18590 case 28: 18591 { 18592 setState(2272); 18593 optionTagStart(true); 18594 } 18595 break; 18596 case 29: 18597 { 18598 setState(2273); 18599 tbodyTagStart(true); 18600 } 18601 break; 18602 case 30: 18603 { 18604 setState(2274); 18605 tfootTagStart(true); 18606 } 18607 break; 18608 case 31: 18609 { 18610 { 18611 setState(2275); 18612 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 18613 setState(2276); 18614 match(LEADING_ASTERISK); 18615 } 18616 } 18617 break; 18618 case 32: 18619 { 18620 setState(2277); 18621 htmlComment(); 18622 } 18623 break; 18624 case 33: 18625 { 18626 setState(2278); 18627 match(CDATA); 18628 } 18629 break; 18630 case 34: 18631 { 18632 setState(2279); 18633 match(NEWLINE); 18634 } 18635 break; 18636 case 35: 18637 { 18638 setState(2280); 18639 text(); 18640 } 18641 break; 18642 case 36: 18643 { 18644 setState(2281); 18645 javadocInlineTag(); 18646 } 18647 break; 18648 } 18649 } 18650 } 18651 setState(2286); 18652 _errHandler.sync(this); 18653 _alt = getInterpreter().adaptivePredict(_input,201,_ctx); 18654 } 18655 setState(2287); 18656 rbTagEnd(); 18657 } 18658 } 18659 catch (RecognitionException re) { 18660 _localctx.exception = re; 18661 _errHandler.reportError(this, re); 18662 _errHandler.recover(this, re); 18663 } 18664 finally { 18665 exitRule(); 18666 } 18667 return _localctx; 18668 } 18669 18670 public static class RtTagStartContext extends ParserRuleContext { 18671 public boolean isNonTight; 18672 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 18673 public TerminalNode RT_HTML_TAG_NAME() { return getToken(JavadocParser.RT_HTML_TAG_NAME, 0); } 18674 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 18675 public List<AttributeContext> attribute() { 18676 return getRuleContexts(AttributeContext.class); 18677 } 18678 public AttributeContext attribute(int i) { 18679 return getRuleContext(AttributeContext.class,i); 18680 } 18681 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 18682 public TerminalNode NEWLINE(int i) { 18683 return getToken(JavadocParser.NEWLINE, i); 18684 } 18685 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 18686 public TerminalNode LEADING_ASTERISK(int i) { 18687 return getToken(JavadocParser.LEADING_ASTERISK, i); 18688 } 18689 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 18690 public TerminalNode WS(int i) { 18691 return getToken(JavadocParser.WS, i); 18692 } 18693 public RtTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 18694 public RtTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 18695 super(parent, invokingState); 18696 this.isNonTight = isNonTight; 18697 } 18698 @Override public int getRuleIndex() { return RULE_rtTagStart; } 18699 } 18700 18701 public final RtTagStartContext rtTagStart(boolean isNonTight) throws RecognitionException { 18702 RtTagStartContext _localctx = new RtTagStartContext(_ctx, getState(), isNonTight); 18703 enterRule(_localctx, 172, RULE_rtTagStart); 18704 int _la; 18705 try { 18706 enterOuterAlt(_localctx, 1); 18707 { 18708 setState(2289); 18709 match(START); 18710 setState(2290); 18711 match(RT_HTML_TAG_NAME); 18712 setState(2297); 18713 _errHandler.sync(this); 18714 _la = _input.LA(1); 18715 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 18716 { 18717 setState(2295); 18718 _errHandler.sync(this); 18719 switch (_input.LA(1)) { 18720 case HTML_TAG_NAME: 18721 { 18722 setState(2291); 18723 attribute(); 18724 } 18725 break; 18726 case NEWLINE: 18727 { 18728 setState(2292); 18729 match(NEWLINE); 18730 } 18731 break; 18732 case LEADING_ASTERISK: 18733 { 18734 setState(2293); 18735 match(LEADING_ASTERISK); 18736 } 18737 break; 18738 case WS: 18739 { 18740 setState(2294); 18741 match(WS); 18742 } 18743 break; 18744 default: 18745 throw new NoViableAltException(this); 18746 } 18747 } 18748 setState(2299); 18749 _errHandler.sync(this); 18750 _la = _input.LA(1); 18751 } 18752 setState(2300); 18753 match(END); 18754 } 18755 _ctx.stop = _input.LT(-1); 18756 18757 if (isNonTight && nonTightTagStartContext == null) { 18758 nonTightTagStartContext = _localctx; 18759 } 18760 18761 } 18762 catch (RecognitionException re) { 18763 _localctx.exception = re; 18764 _errHandler.reportError(this, re); 18765 _errHandler.recover(this, re); 18766 } 18767 finally { 18768 exitRule(); 18769 } 18770 return _localctx; 18771 } 18772 18773 public static class RtTagEndContext extends ParserRuleContext { 18774 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 18775 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 18776 public TerminalNode RT_HTML_TAG_NAME() { return getToken(JavadocParser.RT_HTML_TAG_NAME, 0); } 18777 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 18778 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 18779 public TerminalNode NEWLINE(int i) { 18780 return getToken(JavadocParser.NEWLINE, i); 18781 } 18782 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 18783 public TerminalNode LEADING_ASTERISK(int i) { 18784 return getToken(JavadocParser.LEADING_ASTERISK, i); 18785 } 18786 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 18787 public TerminalNode WS(int i) { 18788 return getToken(JavadocParser.WS, i); 18789 } 18790 public RtTagEndContext(ParserRuleContext parent, int invokingState) { 18791 super(parent, invokingState); 18792 } 18793 @Override public int getRuleIndex() { return RULE_rtTagEnd; } 18794 } 18795 18796 public final RtTagEndContext rtTagEnd() throws RecognitionException { 18797 RtTagEndContext _localctx = new RtTagEndContext(_ctx, getState()); 18798 enterRule(_localctx, 174, RULE_rtTagEnd); 18799 int _la; 18800 try { 18801 enterOuterAlt(_localctx, 1); 18802 { 18803 setState(2302); 18804 match(START); 18805 setState(2303); 18806 match(SLASH); 18807 setState(2304); 18808 match(RT_HTML_TAG_NAME); 18809 setState(2308); 18810 _errHandler.sync(this); 18811 _la = _input.LA(1); 18812 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 18813 { 18814 { 18815 setState(2305); 18816 _la = _input.LA(1); 18817 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 18818 _errHandler.recoverInline(this); 18819 } 18820 else { 18821 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 18822 _errHandler.reportMatch(this); 18823 consume(); 18824 } 18825 } 18826 } 18827 setState(2310); 18828 _errHandler.sync(this); 18829 _la = _input.LA(1); 18830 } 18831 setState(2311); 18832 match(END); 18833 } 18834 } 18835 catch (RecognitionException re) { 18836 _localctx.exception = re; 18837 _errHandler.reportError(this, re); 18838 _errHandler.recover(this, re); 18839 } 18840 finally { 18841 exitRule(); 18842 } 18843 return _localctx; 18844 } 18845 18846 public static class RtContext extends ParserRuleContext { 18847 public RtTagStartContext rtTagStart() { 18848 return getRuleContext(RtTagStartContext.class,0); 18849 } 18850 public RtTagEndContext rtTagEnd() { 18851 return getRuleContext(RtTagEndContext.class,0); 18852 } 18853 public List<HtmlTagContext> htmlTag() { 18854 return getRuleContexts(HtmlTagContext.class); 18855 } 18856 public HtmlTagContext htmlTag(int i) { 18857 return getRuleContext(HtmlTagContext.class,i); 18858 } 18859 public List<SingletonElementContext> singletonElement() { 18860 return getRuleContexts(SingletonElementContext.class); 18861 } 18862 public SingletonElementContext singletonElement(int i) { 18863 return getRuleContext(SingletonElementContext.class,i); 18864 } 18865 public List<ParagraphContext> paragraph() { 18866 return getRuleContexts(ParagraphContext.class); 18867 } 18868 public ParagraphContext paragraph(int i) { 18869 return getRuleContext(ParagraphContext.class,i); 18870 } 18871 public List<LiContext> li() { 18872 return getRuleContexts(LiContext.class); 18873 } 18874 public LiContext li(int i) { 18875 return getRuleContext(LiContext.class,i); 18876 } 18877 public List<TrContext> tr() { 18878 return getRuleContexts(TrContext.class); 18879 } 18880 public TrContext tr(int i) { 18881 return getRuleContext(TrContext.class,i); 18882 } 18883 public List<TdContext> td() { 18884 return getRuleContexts(TdContext.class); 18885 } 18886 public TdContext td(int i) { 18887 return getRuleContext(TdContext.class,i); 18888 } 18889 public List<ThContext> th() { 18890 return getRuleContexts(ThContext.class); 18891 } 18892 public ThContext th(int i) { 18893 return getRuleContext(ThContext.class,i); 18894 } 18895 public List<BodyContext> body() { 18896 return getRuleContexts(BodyContext.class); 18897 } 18898 public BodyContext body(int i) { 18899 return getRuleContext(BodyContext.class,i); 18900 } 18901 public List<ColgroupContext> colgroup() { 18902 return getRuleContexts(ColgroupContext.class); 18903 } 18904 public ColgroupContext colgroup(int i) { 18905 return getRuleContext(ColgroupContext.class,i); 18906 } 18907 public List<DdContext> dd() { 18908 return getRuleContexts(DdContext.class); 18909 } 18910 public DdContext dd(int i) { 18911 return getRuleContext(DdContext.class,i); 18912 } 18913 public List<DtContext> dt() { 18914 return getRuleContexts(DtContext.class); 18915 } 18916 public DtContext dt(int i) { 18917 return getRuleContext(DtContext.class,i); 18918 } 18919 public List<HeadContext> head() { 18920 return getRuleContexts(HeadContext.class); 18921 } 18922 public HeadContext head(int i) { 18923 return getRuleContext(HeadContext.class,i); 18924 } 18925 public List<HtmlContext> html() { 18926 return getRuleContexts(HtmlContext.class); 18927 } 18928 public HtmlContext html(int i) { 18929 return getRuleContext(HtmlContext.class,i); 18930 } 18931 public List<OptionContext> option() { 18932 return getRuleContexts(OptionContext.class); 18933 } 18934 public OptionContext option(int i) { 18935 return getRuleContext(OptionContext.class,i); 18936 } 18937 public List<TbodyContext> tbody() { 18938 return getRuleContexts(TbodyContext.class); 18939 } 18940 public TbodyContext tbody(int i) { 18941 return getRuleContext(TbodyContext.class,i); 18942 } 18943 public List<TfootContext> tfoot() { 18944 return getRuleContexts(TfootContext.class); 18945 } 18946 public TfootContext tfoot(int i) { 18947 return getRuleContext(TfootContext.class,i); 18948 } 18949 public List<PTagStartContext> pTagStart() { 18950 return getRuleContexts(PTagStartContext.class); 18951 } 18952 public PTagStartContext pTagStart(int i) { 18953 return getRuleContext(PTagStartContext.class,i); 18954 } 18955 public List<LiTagStartContext> liTagStart() { 18956 return getRuleContexts(LiTagStartContext.class); 18957 } 18958 public LiTagStartContext liTagStart(int i) { 18959 return getRuleContext(LiTagStartContext.class,i); 18960 } 18961 public List<TrTagStartContext> trTagStart() { 18962 return getRuleContexts(TrTagStartContext.class); 18963 } 18964 public TrTagStartContext trTagStart(int i) { 18965 return getRuleContext(TrTagStartContext.class,i); 18966 } 18967 public List<TdTagStartContext> tdTagStart() { 18968 return getRuleContexts(TdTagStartContext.class); 18969 } 18970 public TdTagStartContext tdTagStart(int i) { 18971 return getRuleContext(TdTagStartContext.class,i); 18972 } 18973 public List<ThTagStartContext> thTagStart() { 18974 return getRuleContexts(ThTagStartContext.class); 18975 } 18976 public ThTagStartContext thTagStart(int i) { 18977 return getRuleContext(ThTagStartContext.class,i); 18978 } 18979 public List<BodyTagStartContext> bodyTagStart() { 18980 return getRuleContexts(BodyTagStartContext.class); 18981 } 18982 public BodyTagStartContext bodyTagStart(int i) { 18983 return getRuleContext(BodyTagStartContext.class,i); 18984 } 18985 public List<ColgroupTagStartContext> colgroupTagStart() { 18986 return getRuleContexts(ColgroupTagStartContext.class); 18987 } 18988 public ColgroupTagStartContext colgroupTagStart(int i) { 18989 return getRuleContext(ColgroupTagStartContext.class,i); 18990 } 18991 public List<DdTagStartContext> ddTagStart() { 18992 return getRuleContexts(DdTagStartContext.class); 18993 } 18994 public DdTagStartContext ddTagStart(int i) { 18995 return getRuleContext(DdTagStartContext.class,i); 18996 } 18997 public List<DtTagStartContext> dtTagStart() { 18998 return getRuleContexts(DtTagStartContext.class); 18999 } 19000 public DtTagStartContext dtTagStart(int i) { 19001 return getRuleContext(DtTagStartContext.class,i); 19002 } 19003 public List<HeadTagStartContext> headTagStart() { 19004 return getRuleContexts(HeadTagStartContext.class); 19005 } 19006 public HeadTagStartContext headTagStart(int i) { 19007 return getRuleContext(HeadTagStartContext.class,i); 19008 } 19009 public List<HtmlTagStartContext> htmlTagStart() { 19010 return getRuleContexts(HtmlTagStartContext.class); 19011 } 19012 public HtmlTagStartContext htmlTagStart(int i) { 19013 return getRuleContext(HtmlTagStartContext.class,i); 19014 } 19015 public List<OptionTagStartContext> optionTagStart() { 19016 return getRuleContexts(OptionTagStartContext.class); 19017 } 19018 public OptionTagStartContext optionTagStart(int i) { 19019 return getRuleContext(OptionTagStartContext.class,i); 19020 } 19021 public List<TbodyTagStartContext> tbodyTagStart() { 19022 return getRuleContexts(TbodyTagStartContext.class); 19023 } 19024 public TbodyTagStartContext tbodyTagStart(int i) { 19025 return getRuleContext(TbodyTagStartContext.class,i); 19026 } 19027 public List<TfootTagStartContext> tfootTagStart() { 19028 return getRuleContexts(TfootTagStartContext.class); 19029 } 19030 public TfootTagStartContext tfootTagStart(int i) { 19031 return getRuleContext(TfootTagStartContext.class,i); 19032 } 19033 public List<HtmlCommentContext> htmlComment() { 19034 return getRuleContexts(HtmlCommentContext.class); 19035 } 19036 public HtmlCommentContext htmlComment(int i) { 19037 return getRuleContext(HtmlCommentContext.class,i); 19038 } 19039 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 19040 public TerminalNode CDATA(int i) { 19041 return getToken(JavadocParser.CDATA, i); 19042 } 19043 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 19044 public TerminalNode NEWLINE(int i) { 19045 return getToken(JavadocParser.NEWLINE, i); 19046 } 19047 public List<TextContext> text() { 19048 return getRuleContexts(TextContext.class); 19049 } 19050 public TextContext text(int i) { 19051 return getRuleContext(TextContext.class,i); 19052 } 19053 public List<JavadocInlineTagContext> javadocInlineTag() { 19054 return getRuleContexts(JavadocInlineTagContext.class); 19055 } 19056 public JavadocInlineTagContext javadocInlineTag(int i) { 19057 return getRuleContext(JavadocInlineTagContext.class,i); 19058 } 19059 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 19060 public TerminalNode LEADING_ASTERISK(int i) { 19061 return getToken(JavadocParser.LEADING_ASTERISK, i); 19062 } 19063 public RtContext(ParserRuleContext parent, int invokingState) { 19064 super(parent, invokingState); 19065 } 19066 @Override public int getRuleIndex() { return RULE_rt; } 19067 } 19068 19069 public final RtContext rt() throws RecognitionException { 19070 RtContext _localctx = new RtContext(_ctx, getState()); 19071 enterRule(_localctx, 176, RULE_rt); 19072 try { 19073 int _alt; 19074 enterOuterAlt(_localctx, 1); 19075 { 19076 setState(2313); 19077 rtTagStart(false); 19078 setState(2353); 19079 _errHandler.sync(this); 19080 _alt = getInterpreter().adaptivePredict(_input,206,_ctx); 19081 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 19082 if ( _alt==1 ) { 19083 { 19084 setState(2351); 19085 _errHandler.sync(this); 19086 switch ( getInterpreter().adaptivePredict(_input,205,_ctx) ) { 19087 case 1: 19088 { 19089 setState(2314); 19090 htmlTag(); 19091 } 19092 break; 19093 case 2: 19094 { 19095 setState(2315); 19096 singletonElement(); 19097 } 19098 break; 19099 case 3: 19100 { 19101 setState(2316); 19102 paragraph(); 19103 } 19104 break; 19105 case 4: 19106 { 19107 setState(2317); 19108 li(); 19109 } 19110 break; 19111 case 5: 19112 { 19113 setState(2318); 19114 tr(); 19115 } 19116 break; 19117 case 6: 19118 { 19119 setState(2319); 19120 td(); 19121 } 19122 break; 19123 case 7: 19124 { 19125 setState(2320); 19126 th(); 19127 } 19128 break; 19129 case 8: 19130 { 19131 setState(2321); 19132 body(); 19133 } 19134 break; 19135 case 9: 19136 { 19137 setState(2322); 19138 colgroup(); 19139 } 19140 break; 19141 case 10: 19142 { 19143 setState(2323); 19144 dd(); 19145 } 19146 break; 19147 case 11: 19148 { 19149 setState(2324); 19150 dt(); 19151 } 19152 break; 19153 case 12: 19154 { 19155 setState(2325); 19156 head(); 19157 } 19158 break; 19159 case 13: 19160 { 19161 setState(2326); 19162 html(); 19163 } 19164 break; 19165 case 14: 19166 { 19167 setState(2327); 19168 option(); 19169 } 19170 break; 19171 case 15: 19172 { 19173 setState(2328); 19174 tbody(); 19175 } 19176 break; 19177 case 16: 19178 { 19179 setState(2329); 19180 tfoot(); 19181 } 19182 break; 19183 case 17: 19184 { 19185 setState(2330); 19186 pTagStart(true); 19187 } 19188 break; 19189 case 18: 19190 { 19191 setState(2331); 19192 liTagStart(true); 19193 } 19194 break; 19195 case 19: 19196 { 19197 setState(2332); 19198 trTagStart(true); 19199 } 19200 break; 19201 case 20: 19202 { 19203 setState(2333); 19204 tdTagStart(true); 19205 } 19206 break; 19207 case 21: 19208 { 19209 setState(2334); 19210 thTagStart(true); 19211 } 19212 break; 19213 case 22: 19214 { 19215 setState(2335); 19216 bodyTagStart(true); 19217 } 19218 break; 19219 case 23: 19220 { 19221 setState(2336); 19222 colgroupTagStart(true); 19223 } 19224 break; 19225 case 24: 19226 { 19227 setState(2337); 19228 ddTagStart(true); 19229 } 19230 break; 19231 case 25: 19232 { 19233 setState(2338); 19234 dtTagStart(true); 19235 } 19236 break; 19237 case 26: 19238 { 19239 setState(2339); 19240 headTagStart(true); 19241 } 19242 break; 19243 case 27: 19244 { 19245 setState(2340); 19246 htmlTagStart(true); 19247 } 19248 break; 19249 case 28: 19250 { 19251 setState(2341); 19252 optionTagStart(true); 19253 } 19254 break; 19255 case 29: 19256 { 19257 setState(2342); 19258 tbodyTagStart(true); 19259 } 19260 break; 19261 case 30: 19262 { 19263 setState(2343); 19264 tfootTagStart(true); 19265 } 19266 break; 19267 case 31: 19268 { 19269 { 19270 setState(2344); 19271 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 19272 setState(2345); 19273 match(LEADING_ASTERISK); 19274 } 19275 } 19276 break; 19277 case 32: 19278 { 19279 setState(2346); 19280 htmlComment(); 19281 } 19282 break; 19283 case 33: 19284 { 19285 setState(2347); 19286 match(CDATA); 19287 } 19288 break; 19289 case 34: 19290 { 19291 setState(2348); 19292 match(NEWLINE); 19293 } 19294 break; 19295 case 35: 19296 { 19297 setState(2349); 19298 text(); 19299 } 19300 break; 19301 case 36: 19302 { 19303 setState(2350); 19304 javadocInlineTag(); 19305 } 19306 break; 19307 } 19308 } 19309 } 19310 setState(2355); 19311 _errHandler.sync(this); 19312 _alt = getInterpreter().adaptivePredict(_input,206,_ctx); 19313 } 19314 setState(2356); 19315 rtTagEnd(); 19316 } 19317 } 19318 catch (RecognitionException re) { 19319 _localctx.exception = re; 19320 _errHandler.reportError(this, re); 19321 _errHandler.recover(this, re); 19322 } 19323 finally { 19324 exitRule(); 19325 } 19326 return _localctx; 19327 } 19328 19329 public static class RtcTagStartContext extends ParserRuleContext { 19330 public boolean isNonTight; 19331 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 19332 public TerminalNode RTC_HTML_TAG_NAME() { return getToken(JavadocParser.RTC_HTML_TAG_NAME, 0); } 19333 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 19334 public List<AttributeContext> attribute() { 19335 return getRuleContexts(AttributeContext.class); 19336 } 19337 public AttributeContext attribute(int i) { 19338 return getRuleContext(AttributeContext.class,i); 19339 } 19340 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 19341 public TerminalNode NEWLINE(int i) { 19342 return getToken(JavadocParser.NEWLINE, i); 19343 } 19344 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 19345 public TerminalNode LEADING_ASTERISK(int i) { 19346 return getToken(JavadocParser.LEADING_ASTERISK, i); 19347 } 19348 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 19349 public TerminalNode WS(int i) { 19350 return getToken(JavadocParser.WS, i); 19351 } 19352 public RtcTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 19353 public RtcTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 19354 super(parent, invokingState); 19355 this.isNonTight = isNonTight; 19356 } 19357 @Override public int getRuleIndex() { return RULE_rtcTagStart; } 19358 } 19359 19360 public final RtcTagStartContext rtcTagStart(boolean isNonTight) throws RecognitionException { 19361 RtcTagStartContext _localctx = new RtcTagStartContext(_ctx, getState(), isNonTight); 19362 enterRule(_localctx, 178, RULE_rtcTagStart); 19363 int _la; 19364 try { 19365 enterOuterAlt(_localctx, 1); 19366 { 19367 setState(2358); 19368 match(START); 19369 setState(2359); 19370 match(RTC_HTML_TAG_NAME); 19371 setState(2366); 19372 _errHandler.sync(this); 19373 _la = _input.LA(1); 19374 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 19375 { 19376 setState(2364); 19377 _errHandler.sync(this); 19378 switch (_input.LA(1)) { 19379 case HTML_TAG_NAME: 19380 { 19381 setState(2360); 19382 attribute(); 19383 } 19384 break; 19385 case NEWLINE: 19386 { 19387 setState(2361); 19388 match(NEWLINE); 19389 } 19390 break; 19391 case LEADING_ASTERISK: 19392 { 19393 setState(2362); 19394 match(LEADING_ASTERISK); 19395 } 19396 break; 19397 case WS: 19398 { 19399 setState(2363); 19400 match(WS); 19401 } 19402 break; 19403 default: 19404 throw new NoViableAltException(this); 19405 } 19406 } 19407 setState(2368); 19408 _errHandler.sync(this); 19409 _la = _input.LA(1); 19410 } 19411 setState(2369); 19412 match(END); 19413 } 19414 _ctx.stop = _input.LT(-1); 19415 19416 if (isNonTight && nonTightTagStartContext == null) { 19417 nonTightTagStartContext = _localctx; 19418 } 19419 19420 } 19421 catch (RecognitionException re) { 19422 _localctx.exception = re; 19423 _errHandler.reportError(this, re); 19424 _errHandler.recover(this, re); 19425 } 19426 finally { 19427 exitRule(); 19428 } 19429 return _localctx; 19430 } 19431 19432 public static class RtcTagEndContext extends ParserRuleContext { 19433 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 19434 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 19435 public TerminalNode RTC_HTML_TAG_NAME() { return getToken(JavadocParser.RTC_HTML_TAG_NAME, 0); } 19436 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 19437 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 19438 public TerminalNode NEWLINE(int i) { 19439 return getToken(JavadocParser.NEWLINE, i); 19440 } 19441 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 19442 public TerminalNode LEADING_ASTERISK(int i) { 19443 return getToken(JavadocParser.LEADING_ASTERISK, i); 19444 } 19445 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 19446 public TerminalNode WS(int i) { 19447 return getToken(JavadocParser.WS, i); 19448 } 19449 public RtcTagEndContext(ParserRuleContext parent, int invokingState) { 19450 super(parent, invokingState); 19451 } 19452 @Override public int getRuleIndex() { return RULE_rtcTagEnd; } 19453 } 19454 19455 public final RtcTagEndContext rtcTagEnd() throws RecognitionException { 19456 RtcTagEndContext _localctx = new RtcTagEndContext(_ctx, getState()); 19457 enterRule(_localctx, 180, RULE_rtcTagEnd); 19458 int _la; 19459 try { 19460 enterOuterAlt(_localctx, 1); 19461 { 19462 setState(2371); 19463 match(START); 19464 setState(2372); 19465 match(SLASH); 19466 setState(2373); 19467 match(RTC_HTML_TAG_NAME); 19468 setState(2377); 19469 _errHandler.sync(this); 19470 _la = _input.LA(1); 19471 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 19472 { 19473 { 19474 setState(2374); 19475 _la = _input.LA(1); 19476 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 19477 _errHandler.recoverInline(this); 19478 } 19479 else { 19480 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 19481 _errHandler.reportMatch(this); 19482 consume(); 19483 } 19484 } 19485 } 19486 setState(2379); 19487 _errHandler.sync(this); 19488 _la = _input.LA(1); 19489 } 19490 setState(2380); 19491 match(END); 19492 } 19493 } 19494 catch (RecognitionException re) { 19495 _localctx.exception = re; 19496 _errHandler.reportError(this, re); 19497 _errHandler.recover(this, re); 19498 } 19499 finally { 19500 exitRule(); 19501 } 19502 return _localctx; 19503 } 19504 19505 public static class RtcContext extends ParserRuleContext { 19506 public RtcTagStartContext rtcTagStart() { 19507 return getRuleContext(RtcTagStartContext.class,0); 19508 } 19509 public RtcTagEndContext rtcTagEnd() { 19510 return getRuleContext(RtcTagEndContext.class,0); 19511 } 19512 public List<HtmlTagContext> htmlTag() { 19513 return getRuleContexts(HtmlTagContext.class); 19514 } 19515 public HtmlTagContext htmlTag(int i) { 19516 return getRuleContext(HtmlTagContext.class,i); 19517 } 19518 public List<SingletonElementContext> singletonElement() { 19519 return getRuleContexts(SingletonElementContext.class); 19520 } 19521 public SingletonElementContext singletonElement(int i) { 19522 return getRuleContext(SingletonElementContext.class,i); 19523 } 19524 public List<ParagraphContext> paragraph() { 19525 return getRuleContexts(ParagraphContext.class); 19526 } 19527 public ParagraphContext paragraph(int i) { 19528 return getRuleContext(ParagraphContext.class,i); 19529 } 19530 public List<LiContext> li() { 19531 return getRuleContexts(LiContext.class); 19532 } 19533 public LiContext li(int i) { 19534 return getRuleContext(LiContext.class,i); 19535 } 19536 public List<TrContext> tr() { 19537 return getRuleContexts(TrContext.class); 19538 } 19539 public TrContext tr(int i) { 19540 return getRuleContext(TrContext.class,i); 19541 } 19542 public List<TdContext> td() { 19543 return getRuleContexts(TdContext.class); 19544 } 19545 public TdContext td(int i) { 19546 return getRuleContext(TdContext.class,i); 19547 } 19548 public List<ThContext> th() { 19549 return getRuleContexts(ThContext.class); 19550 } 19551 public ThContext th(int i) { 19552 return getRuleContext(ThContext.class,i); 19553 } 19554 public List<BodyContext> body() { 19555 return getRuleContexts(BodyContext.class); 19556 } 19557 public BodyContext body(int i) { 19558 return getRuleContext(BodyContext.class,i); 19559 } 19560 public List<ColgroupContext> colgroup() { 19561 return getRuleContexts(ColgroupContext.class); 19562 } 19563 public ColgroupContext colgroup(int i) { 19564 return getRuleContext(ColgroupContext.class,i); 19565 } 19566 public List<DdContext> dd() { 19567 return getRuleContexts(DdContext.class); 19568 } 19569 public DdContext dd(int i) { 19570 return getRuleContext(DdContext.class,i); 19571 } 19572 public List<DtContext> dt() { 19573 return getRuleContexts(DtContext.class); 19574 } 19575 public DtContext dt(int i) { 19576 return getRuleContext(DtContext.class,i); 19577 } 19578 public List<HeadContext> head() { 19579 return getRuleContexts(HeadContext.class); 19580 } 19581 public HeadContext head(int i) { 19582 return getRuleContext(HeadContext.class,i); 19583 } 19584 public List<HtmlContext> html() { 19585 return getRuleContexts(HtmlContext.class); 19586 } 19587 public HtmlContext html(int i) { 19588 return getRuleContext(HtmlContext.class,i); 19589 } 19590 public List<OptionContext> option() { 19591 return getRuleContexts(OptionContext.class); 19592 } 19593 public OptionContext option(int i) { 19594 return getRuleContext(OptionContext.class,i); 19595 } 19596 public List<TbodyContext> tbody() { 19597 return getRuleContexts(TbodyContext.class); 19598 } 19599 public TbodyContext tbody(int i) { 19600 return getRuleContext(TbodyContext.class,i); 19601 } 19602 public List<TfootContext> tfoot() { 19603 return getRuleContexts(TfootContext.class); 19604 } 19605 public TfootContext tfoot(int i) { 19606 return getRuleContext(TfootContext.class,i); 19607 } 19608 public List<PTagStartContext> pTagStart() { 19609 return getRuleContexts(PTagStartContext.class); 19610 } 19611 public PTagStartContext pTagStart(int i) { 19612 return getRuleContext(PTagStartContext.class,i); 19613 } 19614 public List<LiTagStartContext> liTagStart() { 19615 return getRuleContexts(LiTagStartContext.class); 19616 } 19617 public LiTagStartContext liTagStart(int i) { 19618 return getRuleContext(LiTagStartContext.class,i); 19619 } 19620 public List<TrTagStartContext> trTagStart() { 19621 return getRuleContexts(TrTagStartContext.class); 19622 } 19623 public TrTagStartContext trTagStart(int i) { 19624 return getRuleContext(TrTagStartContext.class,i); 19625 } 19626 public List<TdTagStartContext> tdTagStart() { 19627 return getRuleContexts(TdTagStartContext.class); 19628 } 19629 public TdTagStartContext tdTagStart(int i) { 19630 return getRuleContext(TdTagStartContext.class,i); 19631 } 19632 public List<ThTagStartContext> thTagStart() { 19633 return getRuleContexts(ThTagStartContext.class); 19634 } 19635 public ThTagStartContext thTagStart(int i) { 19636 return getRuleContext(ThTagStartContext.class,i); 19637 } 19638 public List<BodyTagStartContext> bodyTagStart() { 19639 return getRuleContexts(BodyTagStartContext.class); 19640 } 19641 public BodyTagStartContext bodyTagStart(int i) { 19642 return getRuleContext(BodyTagStartContext.class,i); 19643 } 19644 public List<ColgroupTagStartContext> colgroupTagStart() { 19645 return getRuleContexts(ColgroupTagStartContext.class); 19646 } 19647 public ColgroupTagStartContext colgroupTagStart(int i) { 19648 return getRuleContext(ColgroupTagStartContext.class,i); 19649 } 19650 public List<DdTagStartContext> ddTagStart() { 19651 return getRuleContexts(DdTagStartContext.class); 19652 } 19653 public DdTagStartContext ddTagStart(int i) { 19654 return getRuleContext(DdTagStartContext.class,i); 19655 } 19656 public List<DtTagStartContext> dtTagStart() { 19657 return getRuleContexts(DtTagStartContext.class); 19658 } 19659 public DtTagStartContext dtTagStart(int i) { 19660 return getRuleContext(DtTagStartContext.class,i); 19661 } 19662 public List<HeadTagStartContext> headTagStart() { 19663 return getRuleContexts(HeadTagStartContext.class); 19664 } 19665 public HeadTagStartContext headTagStart(int i) { 19666 return getRuleContext(HeadTagStartContext.class,i); 19667 } 19668 public List<HtmlTagStartContext> htmlTagStart() { 19669 return getRuleContexts(HtmlTagStartContext.class); 19670 } 19671 public HtmlTagStartContext htmlTagStart(int i) { 19672 return getRuleContext(HtmlTagStartContext.class,i); 19673 } 19674 public List<OptionTagStartContext> optionTagStart() { 19675 return getRuleContexts(OptionTagStartContext.class); 19676 } 19677 public OptionTagStartContext optionTagStart(int i) { 19678 return getRuleContext(OptionTagStartContext.class,i); 19679 } 19680 public List<TbodyTagStartContext> tbodyTagStart() { 19681 return getRuleContexts(TbodyTagStartContext.class); 19682 } 19683 public TbodyTagStartContext tbodyTagStart(int i) { 19684 return getRuleContext(TbodyTagStartContext.class,i); 19685 } 19686 public List<TfootTagStartContext> tfootTagStart() { 19687 return getRuleContexts(TfootTagStartContext.class); 19688 } 19689 public TfootTagStartContext tfootTagStart(int i) { 19690 return getRuleContext(TfootTagStartContext.class,i); 19691 } 19692 public List<HtmlCommentContext> htmlComment() { 19693 return getRuleContexts(HtmlCommentContext.class); 19694 } 19695 public HtmlCommentContext htmlComment(int i) { 19696 return getRuleContext(HtmlCommentContext.class,i); 19697 } 19698 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 19699 public TerminalNode CDATA(int i) { 19700 return getToken(JavadocParser.CDATA, i); 19701 } 19702 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 19703 public TerminalNode NEWLINE(int i) { 19704 return getToken(JavadocParser.NEWLINE, i); 19705 } 19706 public List<TextContext> text() { 19707 return getRuleContexts(TextContext.class); 19708 } 19709 public TextContext text(int i) { 19710 return getRuleContext(TextContext.class,i); 19711 } 19712 public List<JavadocInlineTagContext> javadocInlineTag() { 19713 return getRuleContexts(JavadocInlineTagContext.class); 19714 } 19715 public JavadocInlineTagContext javadocInlineTag(int i) { 19716 return getRuleContext(JavadocInlineTagContext.class,i); 19717 } 19718 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 19719 public TerminalNode LEADING_ASTERISK(int i) { 19720 return getToken(JavadocParser.LEADING_ASTERISK, i); 19721 } 19722 public RtcContext(ParserRuleContext parent, int invokingState) { 19723 super(parent, invokingState); 19724 } 19725 @Override public int getRuleIndex() { return RULE_rtc; } 19726 } 19727 19728 public final RtcContext rtc() throws RecognitionException { 19729 RtcContext _localctx = new RtcContext(_ctx, getState()); 19730 enterRule(_localctx, 182, RULE_rtc); 19731 try { 19732 int _alt; 19733 enterOuterAlt(_localctx, 1); 19734 { 19735 setState(2382); 19736 rtcTagStart(false); 19737 setState(2422); 19738 _errHandler.sync(this); 19739 _alt = getInterpreter().adaptivePredict(_input,211,_ctx); 19740 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 19741 if ( _alt==1 ) { 19742 { 19743 setState(2420); 19744 _errHandler.sync(this); 19745 switch ( getInterpreter().adaptivePredict(_input,210,_ctx) ) { 19746 case 1: 19747 { 19748 setState(2383); 19749 htmlTag(); 19750 } 19751 break; 19752 case 2: 19753 { 19754 setState(2384); 19755 singletonElement(); 19756 } 19757 break; 19758 case 3: 19759 { 19760 setState(2385); 19761 paragraph(); 19762 } 19763 break; 19764 case 4: 19765 { 19766 setState(2386); 19767 li(); 19768 } 19769 break; 19770 case 5: 19771 { 19772 setState(2387); 19773 tr(); 19774 } 19775 break; 19776 case 6: 19777 { 19778 setState(2388); 19779 td(); 19780 } 19781 break; 19782 case 7: 19783 { 19784 setState(2389); 19785 th(); 19786 } 19787 break; 19788 case 8: 19789 { 19790 setState(2390); 19791 body(); 19792 } 19793 break; 19794 case 9: 19795 { 19796 setState(2391); 19797 colgroup(); 19798 } 19799 break; 19800 case 10: 19801 { 19802 setState(2392); 19803 dd(); 19804 } 19805 break; 19806 case 11: 19807 { 19808 setState(2393); 19809 dt(); 19810 } 19811 break; 19812 case 12: 19813 { 19814 setState(2394); 19815 head(); 19816 } 19817 break; 19818 case 13: 19819 { 19820 setState(2395); 19821 html(); 19822 } 19823 break; 19824 case 14: 19825 { 19826 setState(2396); 19827 option(); 19828 } 19829 break; 19830 case 15: 19831 { 19832 setState(2397); 19833 tbody(); 19834 } 19835 break; 19836 case 16: 19837 { 19838 setState(2398); 19839 tfoot(); 19840 } 19841 break; 19842 case 17: 19843 { 19844 setState(2399); 19845 pTagStart(true); 19846 } 19847 break; 19848 case 18: 19849 { 19850 setState(2400); 19851 liTagStart(true); 19852 } 19853 break; 19854 case 19: 19855 { 19856 setState(2401); 19857 trTagStart(true); 19858 } 19859 break; 19860 case 20: 19861 { 19862 setState(2402); 19863 tdTagStart(true); 19864 } 19865 break; 19866 case 21: 19867 { 19868 setState(2403); 19869 thTagStart(true); 19870 } 19871 break; 19872 case 22: 19873 { 19874 setState(2404); 19875 bodyTagStart(true); 19876 } 19877 break; 19878 case 23: 19879 { 19880 setState(2405); 19881 colgroupTagStart(true); 19882 } 19883 break; 19884 case 24: 19885 { 19886 setState(2406); 19887 ddTagStart(true); 19888 } 19889 break; 19890 case 25: 19891 { 19892 setState(2407); 19893 dtTagStart(true); 19894 } 19895 break; 19896 case 26: 19897 { 19898 setState(2408); 19899 headTagStart(true); 19900 } 19901 break; 19902 case 27: 19903 { 19904 setState(2409); 19905 htmlTagStart(true); 19906 } 19907 break; 19908 case 28: 19909 { 19910 setState(2410); 19911 optionTagStart(true); 19912 } 19913 break; 19914 case 29: 19915 { 19916 setState(2411); 19917 tbodyTagStart(true); 19918 } 19919 break; 19920 case 30: 19921 { 19922 setState(2412); 19923 tfootTagStart(true); 19924 } 19925 break; 19926 case 31: 19927 { 19928 { 19929 setState(2413); 19930 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 19931 setState(2414); 19932 match(LEADING_ASTERISK); 19933 } 19934 } 19935 break; 19936 case 32: 19937 { 19938 setState(2415); 19939 htmlComment(); 19940 } 19941 break; 19942 case 33: 19943 { 19944 setState(2416); 19945 match(CDATA); 19946 } 19947 break; 19948 case 34: 19949 { 19950 setState(2417); 19951 match(NEWLINE); 19952 } 19953 break; 19954 case 35: 19955 { 19956 setState(2418); 19957 text(); 19958 } 19959 break; 19960 case 36: 19961 { 19962 setState(2419); 19963 javadocInlineTag(); 19964 } 19965 break; 19966 } 19967 } 19968 } 19969 setState(2424); 19970 _errHandler.sync(this); 19971 _alt = getInterpreter().adaptivePredict(_input,211,_ctx); 19972 } 19973 setState(2425); 19974 rtcTagEnd(); 19975 } 19976 } 19977 catch (RecognitionException re) { 19978 _localctx.exception = re; 19979 _errHandler.reportError(this, re); 19980 _errHandler.recover(this, re); 19981 } 19982 finally { 19983 exitRule(); 19984 } 19985 return _localctx; 19986 } 19987 19988 public static class RpTagStartContext extends ParserRuleContext { 19989 public boolean isNonTight; 19990 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 19991 public TerminalNode RP_HTML_TAG_NAME() { return getToken(JavadocParser.RP_HTML_TAG_NAME, 0); } 19992 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 19993 public List<AttributeContext> attribute() { 19994 return getRuleContexts(AttributeContext.class); 19995 } 19996 public AttributeContext attribute(int i) { 19997 return getRuleContext(AttributeContext.class,i); 19998 } 19999 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 20000 public TerminalNode NEWLINE(int i) { 20001 return getToken(JavadocParser.NEWLINE, i); 20002 } 20003 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 20004 public TerminalNode LEADING_ASTERISK(int i) { 20005 return getToken(JavadocParser.LEADING_ASTERISK, i); 20006 } 20007 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 20008 public TerminalNode WS(int i) { 20009 return getToken(JavadocParser.WS, i); 20010 } 20011 public RpTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 20012 public RpTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 20013 super(parent, invokingState); 20014 this.isNonTight = isNonTight; 20015 } 20016 @Override public int getRuleIndex() { return RULE_rpTagStart; } 20017 } 20018 20019 public final RpTagStartContext rpTagStart(boolean isNonTight) throws RecognitionException { 20020 RpTagStartContext _localctx = new RpTagStartContext(_ctx, getState(), isNonTight); 20021 enterRule(_localctx, 184, RULE_rpTagStart); 20022 int _la; 20023 try { 20024 enterOuterAlt(_localctx, 1); 20025 { 20026 setState(2427); 20027 match(START); 20028 setState(2428); 20029 match(RP_HTML_TAG_NAME); 20030 setState(2435); 20031 _errHandler.sync(this); 20032 _la = _input.LA(1); 20033 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 20034 { 20035 setState(2433); 20036 _errHandler.sync(this); 20037 switch (_input.LA(1)) { 20038 case HTML_TAG_NAME: 20039 { 20040 setState(2429); 20041 attribute(); 20042 } 20043 break; 20044 case NEWLINE: 20045 { 20046 setState(2430); 20047 match(NEWLINE); 20048 } 20049 break; 20050 case LEADING_ASTERISK: 20051 { 20052 setState(2431); 20053 match(LEADING_ASTERISK); 20054 } 20055 break; 20056 case WS: 20057 { 20058 setState(2432); 20059 match(WS); 20060 } 20061 break; 20062 default: 20063 throw new NoViableAltException(this); 20064 } 20065 } 20066 setState(2437); 20067 _errHandler.sync(this); 20068 _la = _input.LA(1); 20069 } 20070 setState(2438); 20071 match(END); 20072 } 20073 _ctx.stop = _input.LT(-1); 20074 20075 if (isNonTight && nonTightTagStartContext == null) { 20076 nonTightTagStartContext = _localctx; 20077 } 20078 20079 } 20080 catch (RecognitionException re) { 20081 _localctx.exception = re; 20082 _errHandler.reportError(this, re); 20083 _errHandler.recover(this, re); 20084 } 20085 finally { 20086 exitRule(); 20087 } 20088 return _localctx; 20089 } 20090 20091 public static class RpTagEndContext extends ParserRuleContext { 20092 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 20093 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 20094 public TerminalNode RP_HTML_TAG_NAME() { return getToken(JavadocParser.RP_HTML_TAG_NAME, 0); } 20095 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 20096 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 20097 public TerminalNode NEWLINE(int i) { 20098 return getToken(JavadocParser.NEWLINE, i); 20099 } 20100 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 20101 public TerminalNode LEADING_ASTERISK(int i) { 20102 return getToken(JavadocParser.LEADING_ASTERISK, i); 20103 } 20104 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 20105 public TerminalNode WS(int i) { 20106 return getToken(JavadocParser.WS, i); 20107 } 20108 public RpTagEndContext(ParserRuleContext parent, int invokingState) { 20109 super(parent, invokingState); 20110 } 20111 @Override public int getRuleIndex() { return RULE_rpTagEnd; } 20112 } 20113 20114 public final RpTagEndContext rpTagEnd() throws RecognitionException { 20115 RpTagEndContext _localctx = new RpTagEndContext(_ctx, getState()); 20116 enterRule(_localctx, 186, RULE_rpTagEnd); 20117 int _la; 20118 try { 20119 enterOuterAlt(_localctx, 1); 20120 { 20121 setState(2440); 20122 match(START); 20123 setState(2441); 20124 match(SLASH); 20125 setState(2442); 20126 match(RP_HTML_TAG_NAME); 20127 setState(2446); 20128 _errHandler.sync(this); 20129 _la = _input.LA(1); 20130 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 20131 { 20132 { 20133 setState(2443); 20134 _la = _input.LA(1); 20135 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 20136 _errHandler.recoverInline(this); 20137 } 20138 else { 20139 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 20140 _errHandler.reportMatch(this); 20141 consume(); 20142 } 20143 } 20144 } 20145 setState(2448); 20146 _errHandler.sync(this); 20147 _la = _input.LA(1); 20148 } 20149 setState(2449); 20150 match(END); 20151 } 20152 } 20153 catch (RecognitionException re) { 20154 _localctx.exception = re; 20155 _errHandler.reportError(this, re); 20156 _errHandler.recover(this, re); 20157 } 20158 finally { 20159 exitRule(); 20160 } 20161 return _localctx; 20162 } 20163 20164 public static class RpContext extends ParserRuleContext { 20165 public RpTagStartContext rpTagStart() { 20166 return getRuleContext(RpTagStartContext.class,0); 20167 } 20168 public RpTagEndContext rpTagEnd() { 20169 return getRuleContext(RpTagEndContext.class,0); 20170 } 20171 public List<HtmlTagContext> htmlTag() { 20172 return getRuleContexts(HtmlTagContext.class); 20173 } 20174 public HtmlTagContext htmlTag(int i) { 20175 return getRuleContext(HtmlTagContext.class,i); 20176 } 20177 public List<SingletonElementContext> singletonElement() { 20178 return getRuleContexts(SingletonElementContext.class); 20179 } 20180 public SingletonElementContext singletonElement(int i) { 20181 return getRuleContext(SingletonElementContext.class,i); 20182 } 20183 public List<ParagraphContext> paragraph() { 20184 return getRuleContexts(ParagraphContext.class); 20185 } 20186 public ParagraphContext paragraph(int i) { 20187 return getRuleContext(ParagraphContext.class,i); 20188 } 20189 public List<LiContext> li() { 20190 return getRuleContexts(LiContext.class); 20191 } 20192 public LiContext li(int i) { 20193 return getRuleContext(LiContext.class,i); 20194 } 20195 public List<TrContext> tr() { 20196 return getRuleContexts(TrContext.class); 20197 } 20198 public TrContext tr(int i) { 20199 return getRuleContext(TrContext.class,i); 20200 } 20201 public List<TdContext> td() { 20202 return getRuleContexts(TdContext.class); 20203 } 20204 public TdContext td(int i) { 20205 return getRuleContext(TdContext.class,i); 20206 } 20207 public List<ThContext> th() { 20208 return getRuleContexts(ThContext.class); 20209 } 20210 public ThContext th(int i) { 20211 return getRuleContext(ThContext.class,i); 20212 } 20213 public List<BodyContext> body() { 20214 return getRuleContexts(BodyContext.class); 20215 } 20216 public BodyContext body(int i) { 20217 return getRuleContext(BodyContext.class,i); 20218 } 20219 public List<ColgroupContext> colgroup() { 20220 return getRuleContexts(ColgroupContext.class); 20221 } 20222 public ColgroupContext colgroup(int i) { 20223 return getRuleContext(ColgroupContext.class,i); 20224 } 20225 public List<DdContext> dd() { 20226 return getRuleContexts(DdContext.class); 20227 } 20228 public DdContext dd(int i) { 20229 return getRuleContext(DdContext.class,i); 20230 } 20231 public List<DtContext> dt() { 20232 return getRuleContexts(DtContext.class); 20233 } 20234 public DtContext dt(int i) { 20235 return getRuleContext(DtContext.class,i); 20236 } 20237 public List<HeadContext> head() { 20238 return getRuleContexts(HeadContext.class); 20239 } 20240 public HeadContext head(int i) { 20241 return getRuleContext(HeadContext.class,i); 20242 } 20243 public List<HtmlContext> html() { 20244 return getRuleContexts(HtmlContext.class); 20245 } 20246 public HtmlContext html(int i) { 20247 return getRuleContext(HtmlContext.class,i); 20248 } 20249 public List<OptionContext> option() { 20250 return getRuleContexts(OptionContext.class); 20251 } 20252 public OptionContext option(int i) { 20253 return getRuleContext(OptionContext.class,i); 20254 } 20255 public List<TbodyContext> tbody() { 20256 return getRuleContexts(TbodyContext.class); 20257 } 20258 public TbodyContext tbody(int i) { 20259 return getRuleContext(TbodyContext.class,i); 20260 } 20261 public List<TfootContext> tfoot() { 20262 return getRuleContexts(TfootContext.class); 20263 } 20264 public TfootContext tfoot(int i) { 20265 return getRuleContext(TfootContext.class,i); 20266 } 20267 public List<PTagStartContext> pTagStart() { 20268 return getRuleContexts(PTagStartContext.class); 20269 } 20270 public PTagStartContext pTagStart(int i) { 20271 return getRuleContext(PTagStartContext.class,i); 20272 } 20273 public List<LiTagStartContext> liTagStart() { 20274 return getRuleContexts(LiTagStartContext.class); 20275 } 20276 public LiTagStartContext liTagStart(int i) { 20277 return getRuleContext(LiTagStartContext.class,i); 20278 } 20279 public List<TrTagStartContext> trTagStart() { 20280 return getRuleContexts(TrTagStartContext.class); 20281 } 20282 public TrTagStartContext trTagStart(int i) { 20283 return getRuleContext(TrTagStartContext.class,i); 20284 } 20285 public List<TdTagStartContext> tdTagStart() { 20286 return getRuleContexts(TdTagStartContext.class); 20287 } 20288 public TdTagStartContext tdTagStart(int i) { 20289 return getRuleContext(TdTagStartContext.class,i); 20290 } 20291 public List<ThTagStartContext> thTagStart() { 20292 return getRuleContexts(ThTagStartContext.class); 20293 } 20294 public ThTagStartContext thTagStart(int i) { 20295 return getRuleContext(ThTagStartContext.class,i); 20296 } 20297 public List<BodyTagStartContext> bodyTagStart() { 20298 return getRuleContexts(BodyTagStartContext.class); 20299 } 20300 public BodyTagStartContext bodyTagStart(int i) { 20301 return getRuleContext(BodyTagStartContext.class,i); 20302 } 20303 public List<ColgroupTagStartContext> colgroupTagStart() { 20304 return getRuleContexts(ColgroupTagStartContext.class); 20305 } 20306 public ColgroupTagStartContext colgroupTagStart(int i) { 20307 return getRuleContext(ColgroupTagStartContext.class,i); 20308 } 20309 public List<DdTagStartContext> ddTagStart() { 20310 return getRuleContexts(DdTagStartContext.class); 20311 } 20312 public DdTagStartContext ddTagStart(int i) { 20313 return getRuleContext(DdTagStartContext.class,i); 20314 } 20315 public List<DtTagStartContext> dtTagStart() { 20316 return getRuleContexts(DtTagStartContext.class); 20317 } 20318 public DtTagStartContext dtTagStart(int i) { 20319 return getRuleContext(DtTagStartContext.class,i); 20320 } 20321 public List<HeadTagStartContext> headTagStart() { 20322 return getRuleContexts(HeadTagStartContext.class); 20323 } 20324 public HeadTagStartContext headTagStart(int i) { 20325 return getRuleContext(HeadTagStartContext.class,i); 20326 } 20327 public List<HtmlTagStartContext> htmlTagStart() { 20328 return getRuleContexts(HtmlTagStartContext.class); 20329 } 20330 public HtmlTagStartContext htmlTagStart(int i) { 20331 return getRuleContext(HtmlTagStartContext.class,i); 20332 } 20333 public List<OptionTagStartContext> optionTagStart() { 20334 return getRuleContexts(OptionTagStartContext.class); 20335 } 20336 public OptionTagStartContext optionTagStart(int i) { 20337 return getRuleContext(OptionTagStartContext.class,i); 20338 } 20339 public List<TbodyTagStartContext> tbodyTagStart() { 20340 return getRuleContexts(TbodyTagStartContext.class); 20341 } 20342 public TbodyTagStartContext tbodyTagStart(int i) { 20343 return getRuleContext(TbodyTagStartContext.class,i); 20344 } 20345 public List<TfootTagStartContext> tfootTagStart() { 20346 return getRuleContexts(TfootTagStartContext.class); 20347 } 20348 public TfootTagStartContext tfootTagStart(int i) { 20349 return getRuleContext(TfootTagStartContext.class,i); 20350 } 20351 public List<HtmlCommentContext> htmlComment() { 20352 return getRuleContexts(HtmlCommentContext.class); 20353 } 20354 public HtmlCommentContext htmlComment(int i) { 20355 return getRuleContext(HtmlCommentContext.class,i); 20356 } 20357 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 20358 public TerminalNode CDATA(int i) { 20359 return getToken(JavadocParser.CDATA, i); 20360 } 20361 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 20362 public TerminalNode NEWLINE(int i) { 20363 return getToken(JavadocParser.NEWLINE, i); 20364 } 20365 public List<TextContext> text() { 20366 return getRuleContexts(TextContext.class); 20367 } 20368 public TextContext text(int i) { 20369 return getRuleContext(TextContext.class,i); 20370 } 20371 public List<JavadocInlineTagContext> javadocInlineTag() { 20372 return getRuleContexts(JavadocInlineTagContext.class); 20373 } 20374 public JavadocInlineTagContext javadocInlineTag(int i) { 20375 return getRuleContext(JavadocInlineTagContext.class,i); 20376 } 20377 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 20378 public TerminalNode LEADING_ASTERISK(int i) { 20379 return getToken(JavadocParser.LEADING_ASTERISK, i); 20380 } 20381 public RpContext(ParserRuleContext parent, int invokingState) { 20382 super(parent, invokingState); 20383 } 20384 @Override public int getRuleIndex() { return RULE_rp; } 20385 } 20386 20387 public final RpContext rp() throws RecognitionException { 20388 RpContext _localctx = new RpContext(_ctx, getState()); 20389 enterRule(_localctx, 188, RULE_rp); 20390 try { 20391 int _alt; 20392 enterOuterAlt(_localctx, 1); 20393 { 20394 setState(2451); 20395 rpTagStart(false); 20396 setState(2491); 20397 _errHandler.sync(this); 20398 _alt = getInterpreter().adaptivePredict(_input,216,_ctx); 20399 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 20400 if ( _alt==1 ) { 20401 { 20402 setState(2489); 20403 _errHandler.sync(this); 20404 switch ( getInterpreter().adaptivePredict(_input,215,_ctx) ) { 20405 case 1: 20406 { 20407 setState(2452); 20408 htmlTag(); 20409 } 20410 break; 20411 case 2: 20412 { 20413 setState(2453); 20414 singletonElement(); 20415 } 20416 break; 20417 case 3: 20418 { 20419 setState(2454); 20420 paragraph(); 20421 } 20422 break; 20423 case 4: 20424 { 20425 setState(2455); 20426 li(); 20427 } 20428 break; 20429 case 5: 20430 { 20431 setState(2456); 20432 tr(); 20433 } 20434 break; 20435 case 6: 20436 { 20437 setState(2457); 20438 td(); 20439 } 20440 break; 20441 case 7: 20442 { 20443 setState(2458); 20444 th(); 20445 } 20446 break; 20447 case 8: 20448 { 20449 setState(2459); 20450 body(); 20451 } 20452 break; 20453 case 9: 20454 { 20455 setState(2460); 20456 colgroup(); 20457 } 20458 break; 20459 case 10: 20460 { 20461 setState(2461); 20462 dd(); 20463 } 20464 break; 20465 case 11: 20466 { 20467 setState(2462); 20468 dt(); 20469 } 20470 break; 20471 case 12: 20472 { 20473 setState(2463); 20474 head(); 20475 } 20476 break; 20477 case 13: 20478 { 20479 setState(2464); 20480 html(); 20481 } 20482 break; 20483 case 14: 20484 { 20485 setState(2465); 20486 option(); 20487 } 20488 break; 20489 case 15: 20490 { 20491 setState(2466); 20492 tbody(); 20493 } 20494 break; 20495 case 16: 20496 { 20497 setState(2467); 20498 tfoot(); 20499 } 20500 break; 20501 case 17: 20502 { 20503 setState(2468); 20504 pTagStart(true); 20505 } 20506 break; 20507 case 18: 20508 { 20509 setState(2469); 20510 liTagStart(true); 20511 } 20512 break; 20513 case 19: 20514 { 20515 setState(2470); 20516 trTagStart(true); 20517 } 20518 break; 20519 case 20: 20520 { 20521 setState(2471); 20522 tdTagStart(true); 20523 } 20524 break; 20525 case 21: 20526 { 20527 setState(2472); 20528 thTagStart(true); 20529 } 20530 break; 20531 case 22: 20532 { 20533 setState(2473); 20534 bodyTagStart(true); 20535 } 20536 break; 20537 case 23: 20538 { 20539 setState(2474); 20540 colgroupTagStart(true); 20541 } 20542 break; 20543 case 24: 20544 { 20545 setState(2475); 20546 ddTagStart(true); 20547 } 20548 break; 20549 case 25: 20550 { 20551 setState(2476); 20552 dtTagStart(true); 20553 } 20554 break; 20555 case 26: 20556 { 20557 setState(2477); 20558 headTagStart(true); 20559 } 20560 break; 20561 case 27: 20562 { 20563 setState(2478); 20564 htmlTagStart(true); 20565 } 20566 break; 20567 case 28: 20568 { 20569 setState(2479); 20570 optionTagStart(true); 20571 } 20572 break; 20573 case 29: 20574 { 20575 setState(2480); 20576 tbodyTagStart(true); 20577 } 20578 break; 20579 case 30: 20580 { 20581 setState(2481); 20582 tfootTagStart(true); 20583 } 20584 break; 20585 case 31: 20586 { 20587 { 20588 setState(2482); 20589 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 20590 setState(2483); 20591 match(LEADING_ASTERISK); 20592 } 20593 } 20594 break; 20595 case 32: 20596 { 20597 setState(2484); 20598 htmlComment(); 20599 } 20600 break; 20601 case 33: 20602 { 20603 setState(2485); 20604 match(CDATA); 20605 } 20606 break; 20607 case 34: 20608 { 20609 setState(2486); 20610 match(NEWLINE); 20611 } 20612 break; 20613 case 35: 20614 { 20615 setState(2487); 20616 text(); 20617 } 20618 break; 20619 case 36: 20620 { 20621 setState(2488); 20622 javadocInlineTag(); 20623 } 20624 break; 20625 } 20626 } 20627 } 20628 setState(2493); 20629 _errHandler.sync(this); 20630 _alt = getInterpreter().adaptivePredict(_input,216,_ctx); 20631 } 20632 setState(2494); 20633 rpTagEnd(); 20634 } 20635 } 20636 catch (RecognitionException re) { 20637 _localctx.exception = re; 20638 _errHandler.reportError(this, re); 20639 _errHandler.recover(this, re); 20640 } 20641 finally { 20642 exitRule(); 20643 } 20644 return _localctx; 20645 } 20646 20647 public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { 20648 switch (ruleIndex) { 20649 case 0: 20650 return javadoc_sempred((JavadocContext)_localctx, predIndex); 20651 case 5: 20652 return htmlTag_sempred((HtmlTagContext)_localctx, predIndex); 20653 case 8: 20654 return paragraph_sempred((ParagraphContext)_localctx, predIndex); 20655 case 11: 20656 return li_sempred((LiContext)_localctx, predIndex); 20657 case 14: 20658 return tr_sempred((TrContext)_localctx, predIndex); 20659 case 17: 20660 return td_sempred((TdContext)_localctx, predIndex); 20661 case 20: 20662 return th_sempred((ThContext)_localctx, predIndex); 20663 case 23: 20664 return body_sempred((BodyContext)_localctx, predIndex); 20665 case 26: 20666 return colgroup_sempred((ColgroupContext)_localctx, predIndex); 20667 case 29: 20668 return dd_sempred((DdContext)_localctx, predIndex); 20669 case 32: 20670 return dt_sempred((DtContext)_localctx, predIndex); 20671 case 35: 20672 return head_sempred((HeadContext)_localctx, predIndex); 20673 case 38: 20674 return html_sempred((HtmlContext)_localctx, predIndex); 20675 case 41: 20676 return option_sempred((OptionContext)_localctx, predIndex); 20677 case 44: 20678 return tbody_sempred((TbodyContext)_localctx, predIndex); 20679 case 47: 20680 return tfoot_sempred((TfootContext)_localctx, predIndex); 20681 case 50: 20682 return thead_sempred((TheadContext)_localctx, predIndex); 20683 case 68: 20684 return description_sempred((DescriptionContext)_localctx, predIndex); 20685 case 71: 20686 return javadocTag_sempred((JavadocTagContext)_localctx, predIndex); 20687 case 82: 20688 return optgroup_sempred((OptgroupContext)_localctx, predIndex); 20689 case 85: 20690 return rb_sempred((RbContext)_localctx, predIndex); 20691 case 88: 20692 return rt_sempred((RtContext)_localctx, predIndex); 20693 case 91: 20694 return rtc_sempred((RtcContext)_localctx, predIndex); 20695 case 94: 20696 return rp_sempred((RpContext)_localctx, predIndex); 20697 } 20698 return true; 20699 } 20700 private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) { 20701 switch (predIndex) { 20702 case 0: 20703 return !isNextJavadocTag(); 20704 } 20705 return true; 20706 } 20707 private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) { 20708 switch (predIndex) { 20709 case 1: 20710 return !isNextJavadocTag(); 20711 case 2: 20712 return isSameTagNames(((HtmlTagContext)_localctx).htmlElementStart, ((HtmlTagContext)_localctx).htmlElementEnd); 20713 } 20714 return true; 20715 } 20716 private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) { 20717 switch (predIndex) { 20718 case 3: 20719 return !isNextJavadocTag(); 20720 } 20721 return true; 20722 } 20723 private boolean li_sempred(LiContext _localctx, int predIndex) { 20724 switch (predIndex) { 20725 case 4: 20726 return !isNextJavadocTag(); 20727 } 20728 return true; 20729 } 20730 private boolean tr_sempred(TrContext _localctx, int predIndex) { 20731 switch (predIndex) { 20732 case 5: 20733 return !isNextJavadocTag(); 20734 } 20735 return true; 20736 } 20737 private boolean td_sempred(TdContext _localctx, int predIndex) { 20738 switch (predIndex) { 20739 case 6: 20740 return !isNextJavadocTag(); 20741 } 20742 return true; 20743 } 20744 private boolean th_sempred(ThContext _localctx, int predIndex) { 20745 switch (predIndex) { 20746 case 7: 20747 return !isNextJavadocTag(); 20748 } 20749 return true; 20750 } 20751 private boolean body_sempred(BodyContext _localctx, int predIndex) { 20752 switch (predIndex) { 20753 case 8: 20754 return !isNextJavadocTag(); 20755 } 20756 return true; 20757 } 20758 private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) { 20759 switch (predIndex) { 20760 case 9: 20761 return !isNextJavadocTag(); 20762 } 20763 return true; 20764 } 20765 private boolean dd_sempred(DdContext _localctx, int predIndex) { 20766 switch (predIndex) { 20767 case 10: 20768 return !isNextJavadocTag(); 20769 } 20770 return true; 20771 } 20772 private boolean dt_sempred(DtContext _localctx, int predIndex) { 20773 switch (predIndex) { 20774 case 11: 20775 return !isNextJavadocTag(); 20776 } 20777 return true; 20778 } 20779 private boolean head_sempred(HeadContext _localctx, int predIndex) { 20780 switch (predIndex) { 20781 case 12: 20782 return !isNextJavadocTag(); 20783 } 20784 return true; 20785 } 20786 private boolean html_sempred(HtmlContext _localctx, int predIndex) { 20787 switch (predIndex) { 20788 case 13: 20789 return !isNextJavadocTag(); 20790 } 20791 return true; 20792 } 20793 private boolean option_sempred(OptionContext _localctx, int predIndex) { 20794 switch (predIndex) { 20795 case 14: 20796 return !isNextJavadocTag(); 20797 } 20798 return true; 20799 } 20800 private boolean tbody_sempred(TbodyContext _localctx, int predIndex) { 20801 switch (predIndex) { 20802 case 15: 20803 return !isNextJavadocTag(); 20804 } 20805 return true; 20806 } 20807 private boolean tfoot_sempred(TfootContext _localctx, int predIndex) { 20808 switch (predIndex) { 20809 case 16: 20810 return !isNextJavadocTag(); 20811 } 20812 return true; 20813 } 20814 private boolean thead_sempred(TheadContext _localctx, int predIndex) { 20815 switch (predIndex) { 20816 case 17: 20817 return !isNextJavadocTag(); 20818 } 20819 return true; 20820 } 20821 private boolean description_sempred(DescriptionContext _localctx, int predIndex) { 20822 switch (predIndex) { 20823 case 18: 20824 return !isNextJavadocTag(); 20825 } 20826 return true; 20827 } 20828 private boolean javadocTag_sempred(JavadocTagContext _localctx, int predIndex) { 20829 switch (predIndex) { 20830 case 19: 20831 return !isNextJavadocTag(); 20832 case 20: 20833 return !isNextJavadocTag(); 20834 case 21: 20835 return !isNextJavadocTag(); 20836 case 22: 20837 return !isNextJavadocTag(); 20838 } 20839 return true; 20840 } 20841 private boolean optgroup_sempred(OptgroupContext _localctx, int predIndex) { 20842 switch (predIndex) { 20843 case 23: 20844 return !isNextJavadocTag(); 20845 } 20846 return true; 20847 } 20848 private boolean rb_sempred(RbContext _localctx, int predIndex) { 20849 switch (predIndex) { 20850 case 24: 20851 return !isNextJavadocTag(); 20852 } 20853 return true; 20854 } 20855 private boolean rt_sempred(RtContext _localctx, int predIndex) { 20856 switch (predIndex) { 20857 case 25: 20858 return !isNextJavadocTag(); 20859 } 20860 return true; 20861 } 20862 private boolean rtc_sempred(RtcContext _localctx, int predIndex) { 20863 switch (predIndex) { 20864 case 26: 20865 return !isNextJavadocTag(); 20866 } 20867 return true; 20868 } 20869 private boolean rp_sempred(RpContext _localctx, int predIndex) { 20870 switch (predIndex) { 20871 case 27: 20872 return !isNextJavadocTag(); 20873 } 20874 return true; 20875 } 20876 20877 private static final int _serializedATNSegments = 2; 20878 private static final String _serializedATNSegment0 = 20879 "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3g\u09c3\4\2\t\2\4"+ 20880 "\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"+ 20881 "\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"+ 20882 "\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"+ 20883 "\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!"+ 20884 "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ 20885 ",\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"+ 20886 "\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="+ 20887 "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ 20888 "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ 20889 "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+ 20890 "`\t`\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\7\2\u00c9\n\2\f\2\16\2\u00cc\13\2"+ 20891 "\3\2\5\2\u00cf\n\2\3\2\7\2\u00d2\n\2\f\2\16\2\u00d5\13\2\3\2\7\2\u00d8"+ 20892 "\n\2\f\2\16\2\u00db\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"+ 20893 "\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"+ 20894 "\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"+ 20895 "\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"+ 20896 "\5\3\u011d\n\3\3\4\3\4\3\4\3\4\3\4\3\4\7\4\u0125\n\4\f\4\16\4\u0128\13"+ 20897 "\4\3\4\3\4\3\5\3\5\3\5\3\5\7\5\u0130\n\5\f\5\16\5\u0133\13\5\3\5\3\5\3"+ 20898 "\6\3\6\7\6\u0139\n\6\f\6\16\6\u013c\13\6\3\6\3\6\7\6\u0140\n\6\f\6\16"+ 20899 "\6\u0143\13\6\3\6\3\6\3\6\5\6\u0148\n\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3"+ 20900 "\7\3\7\7\7\u0153\n\7\f\7\16\7\u0156\13\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3"+ 20901 "\b\3\b\7\b\u0161\n\b\f\b\16\b\u0164\13\b\3\b\3\b\3\t\3\t\3\t\3\t\7\t\u016c"+ 20902 "\n\t\f\t\16\t\u016f\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"+ 20903 "\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"+ 20904 "\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"+ 20905 "\n\3\n\3\n\3\n\7\n\u01a3\n\n\f\n\16\n\u01a6\13\n\3\n\3\n\3\13\3\13\3\13"+ 20906 "\3\13\3\13\3\13\7\13\u01b0\n\13\f\13\16\13\u01b3\13\13\3\13\3\13\3\f\3"+ 20907 "\f\3\f\3\f\7\f\u01bb\n\f\f\f\16\f\u01be\13\f\3\f\3\f\3\r\3\r\3\r\3\r\3"+ 20908 "\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"+ 20909 "\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"+ 20910 "\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\7\r\u01f2\n\r\f\r\16\r\u01f5\13\r\3"+ 20911 "\r\3\r\3\16\3\16\3\16\3\16\3\16\3\16\7\16\u01ff\n\16\f\16\16\16\u0202"+ 20912 "\13\16\3\16\3\16\3\17\3\17\3\17\3\17\7\17\u020a\n\17\f\17\16\17\u020d"+ 20913 "\13\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20"+ 20914 "\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"+ 20915 "\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"+ 20916 "\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u0241\n\20\f\20\16"+ 20917 "\20\u0244\13\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\21\7\21\u024e\n\21"+ 20918 "\f\21\16\21\u0251\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0259\n\22"+ 20919 "\f\22\16\22\u025c\13\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3"+ 20920 "\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"+ 20921 "\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"+ 20922 "\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\7\23\u0290"+ 20923 "\n\23\f\23\16\23\u0293\13\23\3\23\3\23\3\24\3\24\3\24\3\24\3\24\3\24\7"+ 20924 "\24\u029d\n\24\f\24\16\24\u02a0\13\24\3\24\3\24\3\25\3\25\3\25\3\25\7"+ 20925 "\25\u02a8\n\25\f\25\16\25\u02ab\13\25\3\25\3\25\3\26\3\26\3\26\3\26\3"+ 20926 "\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\3"+ 20927 "\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\3"+ 20928 "\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\3"+ 20929 "\26\3\26\7\26\u02df\n\26\f\26\16\26\u02e2\13\26\3\26\3\26\3\27\3\27\3"+ 20930 "\27\3\27\3\27\3\27\7\27\u02ec\n\27\f\27\16\27\u02ef\13\27\3\27\3\27\3"+ 20931 "\30\3\30\3\30\3\30\7\30\u02f7\n\30\f\30\16\30\u02fa\13\30\3\30\3\30\3"+ 20932 "\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"+ 20933 "\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"+ 20934 "\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"+ 20935 "\31\3\31\3\31\3\31\3\31\3\31\7\31\u032e\n\31\f\31\16\31\u0331\13\31\3"+ 20936 "\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\7\32\u033b\n\32\f\32\16\32\u033e"+ 20937 "\13\32\3\32\3\32\3\33\3\33\3\33\3\33\7\33\u0346\n\33\f\33\16\33\u0349"+ 20938 "\13\33\3\33\3\33\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34"+ 20939 "\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\34"+ 20940 "\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\34"+ 20941 "\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\7\34\u037d\n\34\f\34\16"+ 20942 "\34\u0380\13\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35\3\35\7\35\u038a\n\35"+ 20943 "\f\35\16\35\u038d\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u0395\n\36"+ 20944 "\f\36\16\36\u0398\13\36\3\36\3\36\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3"+ 20945 "\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"+ 20946 "\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"+ 20947 "\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\7\37\u03cc"+ 20948 "\n\37\f\37\16\37\u03cf\13\37\3\37\3\37\3 \3 \3 \3 \3 \3 \7 \u03d9\n \f"+ 20949 " \16 \u03dc\13 \3 \3 \3!\3!\3!\3!\7!\u03e4\n!\f!\16!\u03e7\13!\3!\3!\3"+ 20950 "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+ 20951 "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+ 20952 "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u041b\n\"\f\"\16"+ 20953 "\"\u041e\13\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u0428\n#\f#\16#\u042b\13#\3"+ 20954 "#\3#\3$\3$\3$\3$\7$\u0433\n$\f$\16$\u0436\13$\3$\3$\3%\3%\3%\3%\3%\3%"+ 20955 "\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%"+ 20956 "\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\7%\u046a\n%"+ 20957 "\f%\16%\u046d\13%\3%\3%\3&\3&\3&\3&\3&\3&\7&\u0477\n&\f&\16&\u047a\13"+ 20958 "&\3&\3&\3\'\3\'\3\'\3\'\7\'\u0482\n\'\f\'\16\'\u0485\13\'\3\'\3\'\3(\3"+ 20959 "(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3"+ 20960 "(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3"+ 20961 "(\7(\u04b9\n(\f(\16(\u04bc\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u04c6\n)\f)"+ 20962 "\16)\u04c9\13)\3)\3)\3*\3*\3*\3*\7*\u04d1\n*\f*\16*\u04d4\13*\3*\3*\3"+ 20963 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3"+ 20964 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3"+ 20965 "+\3+\7+\u0508\n+\f+\16+\u050b\13+\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0515\n,"+ 20966 "\f,\16,\u0518\13,\3,\3,\3-\3-\3-\3-\7-\u0520\n-\f-\16-\u0523\13-\3-\3"+ 20967 "-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3"+ 20968 ".\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3"+ 20969 ".\3.\3.\7.\u0557\n.\f.\16.\u055a\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/\u0564"+ 20970 "\n/\f/\16/\u0567\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u056f\n\60\f\60\16"+ 20971 "\60\u0572\13\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61"+ 20972 "\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"+ 20973 "\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"+ 20974 "\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\7\61\u05a6\n\61"+ 20975 "\f\61\16\61\u05a9\13\61\3\61\3\61\3\62\3\62\3\62\3\62\3\62\3\62\7\62\u05b3"+ 20976 "\n\62\f\62\16\62\u05b6\13\62\3\62\3\62\3\63\3\63\3\63\3\63\7\63\u05be"+ 20977 "\n\63\f\63\16\63\u05c1\13\63\3\63\3\63\3\64\3\64\3\64\3\64\3\64\3\64\3"+ 20978 "\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"+ 20979 "\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"+ 20980 "\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\7"+ 20981 "\64\u05f5\n\64\f\64\16\64\u05f8\13\64\3\64\3\64\3\65\3\65\3\65\3\65\3"+ 20982 "\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\3"+ 20983 "\65\3\65\5\65\u0610\n\65\3\66\3\66\3\66\3\66\3\66\3\66\7\66\u0618\n\66"+ 20984 "\f\66\16\66\u061b\13\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67\3\67\7\67\u0625"+ 20985 "\n\67\f\67\16\67\u0628\13\67\3\67\3\67\38\38\38\38\38\38\78\u0632\n8\f"+ 20986 "8\168\u0635\138\38\38\39\39\39\39\39\39\79\u063f\n9\f9\169\u0642\139\3"+ 20987 "9\39\3:\3:\3:\3:\3:\3:\7:\u064c\n:\f:\16:\u064f\13:\3:\3:\3;\3;\3;\3;"+ 20988 "\3;\3;\7;\u0659\n;\f;\16;\u065c\13;\3;\3;\3<\3<\3<\3<\3<\3<\7<\u0666\n"+ 20989 "<\f<\16<\u0669\13<\3<\3<\3=\3=\3=\3=\3=\3=\7=\u0673\n=\f=\16=\u0676\13"+ 20990 "=\3=\3=\3>\3>\3>\3>\3>\3>\7>\u0680\n>\f>\16>\u0683\13>\3>\3>\3?\3?\3?"+ 20991 "\3?\3?\3?\7?\u068d\n?\f?\16?\u0690\13?\3?\3?\3@\3@\3@\3@\3@\3@\7@\u069a"+ 20992 "\n@\f@\16@\u069d\13@\3@\3@\3A\3A\3A\3A\3A\3A\7A\u06a7\nA\fA\16A\u06aa"+ 20993 "\13A\3A\3A\3B\3B\3B\3B\3B\3B\7B\u06b4\nB\fB\16B\u06b7\13B\3B\3B\3C\3C"+ 20994 "\3C\3C\3C\3C\7C\u06c1\nC\fC\16C\u06c4\13C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3"+ 20995 "E\3F\3F\3F\3F\3F\3F\3F\3F\6F\u06d8\nF\rF\16F\u06d9\3G\3G\3G\3G\5G\u06e0"+ 20996 "\nG\5G\u06e2\nG\3G\3G\3G\5G\u06e7\nG\5G\u06e9\nG\3H\3H\7H\u06ed\nH\fH"+ 20997 "\16H\u06f0\13H\3H\3H\3I\3I\6I\u06f6\nI\rI\16I\u06f7\3I\3I\3I\7I\u06fd"+ 20998 "\nI\fI\16I\u0700\13I\3I\3I\5I\u0704\nI\3I\3I\3I\3I\3I\6I\u070b\nI\rI\16"+ 20999 "I\u070c\3I\3I\7I\u0711\nI\fI\16I\u0714\13I\3I\3I\5I\u0718\nI\3I\3I\3I"+ 21000 "\3I\3I\6I\u071f\nI\rI\16I\u0720\3I\3I\7I\u0725\nI\fI\16I\u0728\13I\3I"+ 21001 "\3I\5I\u072c\nI\3I\3I\6I\u0730\nI\rI\16I\u0731\3I\3I\3I\3I\3I\3I\6I\u073a"+ 21002 "\nI\rI\16I\u073b\3I\3I\3I\5I\u0741\nI\3I\7I\u0744\nI\fI\16I\u0747\13I"+ 21003 "\3I\3I\5I\u074b\nI\3I\3I\7I\u074f\nI\fI\16I\u0752\13I\3I\3I\3I\3I\5I\u0758"+ 21004 "\nI\3I\7I\u075b\nI\fI\16I\u075e\13I\3I\3I\7I\u0762\nI\fI\16I\u0765\13"+ 21005 "I\3I\3I\5I\u0769\nI\3I\3I\7I\u076d\nI\fI\16I\u0770\13I\3I\3I\5I\u0774"+ 21006 "\nI\3I\7I\u0777\nI\fI\16I\u077a\13I\3I\3I\5I\u077e\nI\3I\7I\u0781\nI\f"+ 21007 "I\16I\u0784\13I\3I\3I\5I\u0788\nI\3I\3I\6I\u078c\nI\rI\16I\u078d\3I\3"+ 21008 "I\3I\3I\3I\3I\6I\u0796\nI\rI\16I\u0797\3I\3I\7I\u079c\nI\fI\16I\u079f"+ 21009 "\13I\3I\3I\5I\u07a3\nI\3I\3I\6I\u07a7\nI\rI\16I\u07a8\3I\3I\3I\7I\u07ae"+ 21010 "\nI\fI\16I\u07b1\13I\3I\3I\5I\u07b5\nI\5I\u07b7\nI\3J\3J\3J\3J\3J\3J\7"+ 21011 "J\u07bf\nJ\fJ\16J\u07c2\13J\3J\3J\7J\u07c6\nJ\fJ\16J\u07c9\13J\3J\3J\7"+ 21012 "J\u07cd\nJ\fJ\16J\u07d0\13J\3J\3J\6J\u07d4\nJ\rJ\16J\u07d5\3J\3J\7J\u07da"+ 21013 "\nJ\fJ\16J\u07dd\13J\3J\3J\5J\u07e1\nJ\3J\3J\6J\u07e5\nJ\rJ\16J\u07e6"+ 21014 "\3J\3J\7J\u07eb\nJ\fJ\16J\u07ee\13J\3J\3J\5J\u07f2\nJ\3J\3J\3J\3J\3J\7"+ 21015 "J\u07f9\nJ\fJ\16J\u07fc\13J\3J\3J\7J\u0800\nJ\fJ\16J\u0803\13J\3J\3J\5"+ 21016 "J\u0807\nJ\3J\3J\7J\u080b\nJ\fJ\16J\u080e\13J\3J\3J\5J\u0812\nJ\5J\u0814"+ 21017 "\nJ\3J\3J\3K\3K\3K\3K\7K\u081c\nK\fK\16K\u081f\13K\3K\3K\3L\3L\6L\u0825"+ 21018 "\nL\rL\16L\u0826\3M\3M\3M\3M\3M\3M\7M\u082f\nM\fM\16M\u0832\13M\3M\3M"+ 21019 "\3N\3N\3N\3N\3N\3N\7N\u083c\nN\fN\16N\u083f\13N\3N\3N\3O\3O\3O\3O\3O\3"+ 21020 "O\7O\u0849\nO\fO\16O\u084c\13O\3O\3O\3P\3P\3P\3P\3P\3P\7P\u0856\nP\fP"+ 21021 "\16P\u0859\13P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\7Q\u0863\nQ\fQ\16Q\u0866\13Q\3"+ 21022 "Q\3Q\3R\3R\3R\3R\3R\3R\7R\u0870\nR\fR\16R\u0873\13R\3R\3R\3S\3S\3S\3S"+ 21023 "\7S\u087b\nS\fS\16S\u087e\13S\3S\3S\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3"+ 21024 "T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3"+ 21025 "T\3T\3T\3T\7T\u08a8\nT\fT\16T\u08ab\13T\3T\3T\3U\3U\3U\3U\3U\3U\7U\u08b5"+ 21026 "\nU\fU\16U\u08b8\13U\3U\3U\3V\3V\3V\3V\7V\u08c0\nV\fV\16V\u08c3\13V\3"+ 21027 "V\3V\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3"+ 21028 "W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\7W\u08ed\nW\fW\16W\u08f0"+ 21029 "\13W\3W\3W\3X\3X\3X\3X\3X\3X\7X\u08fa\nX\fX\16X\u08fd\13X\3X\3X\3Y\3Y"+ 21030 "\3Y\3Y\7Y\u0905\nY\fY\16Y\u0908\13Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3"+ 21031 "Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3"+ 21032 "Z\3Z\3Z\3Z\3Z\3Z\7Z\u0932\nZ\fZ\16Z\u0935\13Z\3Z\3Z\3[\3[\3[\3[\3[\3["+ 21033 "\7[\u093f\n[\f[\16[\u0942\13[\3[\3[\3\\\3\\\3\\\3\\\7\\\u094a\n\\\f\\"+ 21034 "\16\\\u094d\13\\\3\\\3\\\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]"+ 21035 "\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]"+ 21036 "\7]\u0977\n]\f]\16]\u097a\13]\3]\3]\3^\3^\3^\3^\3^\3^\7^\u0984\n^\f^\16"+ 21037 "^\u0987\13^\3^\3^\3_\3_\3_\3_\7_\u098f\n_\f_\16_\u0992\13_\3_\3_\3`\3"+ 21038 "`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3"+ 21039 "`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\7`\u09bc\n`\f`\16`\u09bf\13`"+ 21040 "\3`\3`\3`\2\2a\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64"+ 21041 "\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088"+ 21042 "\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0"+ 21043 "\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8"+ 21044 "\u00ba\u00bc\u00be\2\t\5\2\3\3\6\6\b\b\4\2=Kff\3\29:\4\2LZ^`\6\2\3\3\6"+ 21045 "\6\b\b&\'\4\2\6\6\b\b\4\2\6\6\32\32\2\u0e45\2\u00ca\3\2\2\2\4\u011c\3"+ 21046 "\2\2\2\6\u011e\3\2\2\2\b\u012b\3\2\2\2\n\u0136\3\2\2\2\f\u0149\3\2\2\2"+ 21047 "\16\u015a\3\2\2\2\20\u0167\3\2\2\2\22\u0172\3\2\2\2\24\u01a9\3\2\2\2\26"+ 21048 "\u01b6\3\2\2\2\30\u01c1\3\2\2\2\32\u01f8\3\2\2\2\34\u0205\3\2\2\2\36\u0210"+ 21049 "\3\2\2\2 \u0247\3\2\2\2\"\u0254\3\2\2\2$\u025f\3\2\2\2&\u0296\3\2\2\2"+ 21050 "(\u02a3\3\2\2\2*\u02ae\3\2\2\2,\u02e5\3\2\2\2.\u02f2\3\2\2\2\60\u02fd"+ 21051 "\3\2\2\2\62\u0334\3\2\2\2\64\u0341\3\2\2\2\66\u034c\3\2\2\28\u0383\3\2"+ 21052 "\2\2:\u0390\3\2\2\2<\u039b\3\2\2\2>\u03d2\3\2\2\2@\u03df\3\2\2\2B\u03ea"+ 21053 "\3\2\2\2D\u0421\3\2\2\2F\u042e\3\2\2\2H\u0439\3\2\2\2J\u0470\3\2\2\2L"+ 21054 "\u047d\3\2\2\2N\u0488\3\2\2\2P\u04bf\3\2\2\2R\u04cc\3\2\2\2T\u04d7\3\2"+ 21055 "\2\2V\u050e\3\2\2\2X\u051b\3\2\2\2Z\u0526\3\2\2\2\\\u055d\3\2\2\2^\u056a"+ 21056 "\3\2\2\2`\u0575\3\2\2\2b\u05ac\3\2\2\2d\u05b9\3\2\2\2f\u05c4\3\2\2\2h"+ 21057 "\u060f\3\2\2\2j\u0611\3\2\2\2l\u061e\3\2\2\2n\u062b\3\2\2\2p\u0638\3\2"+ 21058 "\2\2r\u0645\3\2\2\2t\u0652\3\2\2\2v\u065f\3\2\2\2x\u066c\3\2\2\2z\u0679"+ 21059 "\3\2\2\2|\u0686\3\2\2\2~\u0693\3\2\2\2\u0080\u06a0\3\2\2\2\u0082\u06ad"+ 21060 "\3\2\2\2\u0084\u06ba\3\2\2\2\u0086\u06c7\3\2\2\2\u0088\u06cd\3\2\2\2\u008a"+ 21061 "\u06d7\3\2\2\2\u008c\u06e8\3\2\2\2\u008e\u06ea\3\2\2\2\u0090\u07b6\3\2"+ 21062 "\2\2\u0092\u07b8\3\2\2\2\u0094\u0817\3\2\2\2\u0096\u0824\3\2\2\2\u0098"+ 21063 "\u0828\3\2\2\2\u009a\u0835\3\2\2\2\u009c\u0842\3\2\2\2\u009e\u084f\3\2"+ 21064 "\2\2\u00a0\u085c\3\2\2\2\u00a2\u0869\3\2\2\2\u00a4\u0876\3\2\2\2\u00a6"+ 21065 "\u0881\3\2\2\2\u00a8\u08ae\3\2\2\2\u00aa\u08bb\3\2\2\2\u00ac\u08c6\3\2"+ 21066 "\2\2\u00ae\u08f3\3\2\2\2\u00b0\u0900\3\2\2\2\u00b2\u090b\3\2\2\2\u00b4"+ 21067 "\u0938\3\2\2\2\u00b6\u0945\3\2\2\2\u00b8\u0950\3\2\2\2\u00ba\u097d\3\2"+ 21068 "\2\2\u00bc\u098a\3\2\2\2\u00be\u0995\3\2\2\2\u00c0\u00c9\5\4\3\2\u00c1"+ 21069 "\u00c2\6\2\2\2\u00c2\u00c9\7\3\2\2\u00c3\u00c9\5\u0094K\2\u00c4\u00c9"+ 21070 "\7\5\2\2\u00c5\u00c9\7\b\2\2\u00c6\u00c9\5\u0096L\2\u00c7\u00c9\5\u0092"+ 21071 "J\2\u00c8\u00c0\3\2\2\2\u00c8\u00c1\3\2\2\2\u00c8\u00c3\3\2\2\2\u00c8"+ 21072 "\u00c4\3\2\2\2\u00c8\u00c5\3\2\2\2\u00c8\u00c6\3\2\2\2\u00c8\u00c7\3\2"+ 21073 "\2\2\u00c9\u00cc\3\2\2\2\u00ca\u00c8\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb"+ 21074 "\u00d9\3\2\2\2\u00cc\u00ca\3\2\2\2\u00cd\u00cf\7\3\2\2\u00ce\u00cd\3\2"+ 21075 "\2\2\u00ce\u00cf\3\2\2\2\u00cf\u00d3\3\2\2\2\u00d0\u00d2\7\6\2\2\u00d1"+ 21076 "\u00d0\3\2\2\2\u00d2\u00d5\3\2\2\2\u00d3\u00d1\3\2\2\2\u00d3\u00d4\3\2"+ 21077 "\2\2\u00d4\u00d6\3\2\2\2\u00d5\u00d3\3\2\2\2\u00d6\u00d8\5\u0090I\2\u00d7"+ 21078 "\u00ce\3\2\2\2\u00d8\u00db\3\2\2\2\u00d9\u00d7\3\2\2\2\u00d9\u00da\3\2"+ 21079 "\2\2\u00da\u00dc\3\2\2\2\u00db\u00d9\3\2\2\2\u00dc\u00dd\7\2\2\3\u00dd"+ 21080 "\3\3\2\2\2\u00de\u011d\5\f\7\2\u00df\u011d\5h\65\2\u00e0\u011d\5\22\n"+ 21081 "\2\u00e1\u011d\5\30\r\2\u00e2\u011d\5\36\20\2\u00e3\u011d\5$\23\2\u00e4"+ 21082 "\u011d\5*\26\2\u00e5\u011d\5\60\31\2\u00e6\u011d\5\66\34\2\u00e7\u011d"+ 21083 "\5<\37\2\u00e8\u011d\5B\"\2\u00e9\u011d\5H%\2\u00ea\u011d\5N(\2\u00eb"+ 21084 "\u011d\5T+\2\u00ec\u011d\5Z.\2\u00ed\u011d\5f\64\2\u00ee\u011d\5`\61\2"+ 21085 "\u00ef\u011d\5\u00a6T\2\u00f0\u011d\5\u00acW\2\u00f1\u011d\5\u00b2Z\2"+ 21086 "\u00f2\u011d\5\u00b8]\2\u00f3\u011d\5\u00be`\2\u00f4\u011d\5\16\b\2\u00f5"+ 21087 "\u011d\5\24\13\2\u00f6\u011d\5\32\16\2\u00f7\u011d\5 \21\2\u00f8\u011d"+ 21088 "\5&\24\2\u00f9\u011d\5,\27\2\u00fa\u011d\5\62\32\2\u00fb\u011d\58\35\2"+ 21089 "\u00fc\u011d\5> \2\u00fd\u011d\5D#\2\u00fe\u011d\5J&\2\u00ff\u011d\5P"+ 21090 ")\2\u0100\u011d\5V,\2\u0101\u011d\5b\62\2\u0102\u011d\5\\/\2\u0103\u011d"+ 21091 "\5\u00a2R\2\u0104\u011d\5\u00a8U\2\u0105\u011d\5\u00aeX\2\u0106\u011d"+ 21092 "\5\u00b4[\2\u0107\u011d\5\u00ba^\2\u0108\u011d\5\20\t\2\u0109\u011d\5"+ 21093 "\26\f\2\u010a\u011d\5\34\17\2\u010b\u011d\5\"\22\2\u010c\u011d\5(\25\2"+ 21094 "\u010d\u011d\5.\30\2\u010e\u011d\5\64\33\2\u010f\u011d\5:\36\2\u0110\u011d"+ 21095 "\5@!\2\u0111\u011d\5F$\2\u0112\u011d\5L\'\2\u0113\u011d\5R*\2\u0114\u011d"+ 21096 "\5X-\2\u0115\u011d\5d\63\2\u0116\u011d\5^\60\2\u0117\u011d\5\u00a4S\2"+ 21097 "\u0118\u011d\5\u00aaV\2\u0119\u011d\5\u00b0Y\2\u011a\u011d\5\u00b6\\\2"+ 21098 "\u011b\u011d\5\u00bc_\2\u011c\u00de\3\2\2\2\u011c\u00df\3\2\2\2\u011c"+ 21099 "\u00e0\3\2\2\2\u011c\u00e1\3\2\2\2\u011c\u00e2\3\2\2\2\u011c\u00e3\3\2"+ 21100 "\2\2\u011c\u00e4\3\2\2\2\u011c\u00e5\3\2\2\2\u011c\u00e6\3\2\2\2\u011c"+ 21101 "\u00e7\3\2\2\2\u011c\u00e8\3\2\2\2\u011c\u00e9\3\2\2\2\u011c\u00ea\3\2"+ 21102 "\2\2\u011c\u00eb\3\2\2\2\u011c\u00ec\3\2\2\2\u011c\u00ed\3\2\2\2\u011c"+ 21103 "\u00ee\3\2\2\2\u011c\u00ef\3\2\2\2\u011c\u00f0\3\2\2\2\u011c\u00f1\3\2"+ 21104 "\2\2\u011c\u00f2\3\2\2\2\u011c\u00f3\3\2\2\2\u011c\u00f4\3\2\2\2\u011c"+ 21105 "\u00f5\3\2\2\2\u011c\u00f6\3\2\2\2\u011c\u00f7\3\2\2\2\u011c\u00f8\3\2"+ 21106 "\2\2\u011c\u00f9\3\2\2\2\u011c\u00fa\3\2\2\2\u011c\u00fb\3\2\2\2\u011c"+ 21107 "\u00fc\3\2\2\2\u011c\u00fd\3\2\2\2\u011c\u00fe\3\2\2\2\u011c\u00ff\3\2"+ 21108 "\2\2\u011c\u0100\3\2\2\2\u011c\u0101\3\2\2\2\u011c\u0102\3\2\2\2\u011c"+ 21109 "\u0103\3\2\2\2\u011c\u0104\3\2\2\2\u011c\u0105\3\2\2\2\u011c\u0106\3\2"+ 21110 "\2\2\u011c\u0107\3\2\2\2\u011c\u0108\3\2\2\2\u011c\u0109\3\2\2\2\u011c"+ 21111 "\u010a\3\2\2\2\u011c\u010b\3\2\2\2\u011c\u010c\3\2\2\2\u011c\u010d\3\2"+ 21112 "\2\2\u011c\u010e\3\2\2\2\u011c\u010f\3\2\2\2\u011c\u0110\3\2\2\2\u011c"+ 21113 "\u0111\3\2\2\2\u011c\u0112\3\2\2\2\u011c\u0113\3\2\2\2\u011c\u0114\3\2"+ 21114 "\2\2\u011c\u0115\3\2\2\2\u011c\u0116\3\2\2\2\u011c\u0117\3\2\2\2\u011c"+ 21115 "\u0118\3\2\2\2\u011c\u0119\3\2\2\2\u011c\u011a\3\2\2\2\u011c\u011b\3\2"+ 21116 "\2\2\u011d\5\3\2\2\2\u011e\u011f\7\7\2\2\u011f\u0126\7f\2\2\u0120\u0125"+ 21117 "\5\n\6\2\u0121\u0125\7\b\2\2\u0122\u0125\7\3\2\2\u0123\u0125\7\6\2\2\u0124"+ 21118 "\u0120\3\2\2\2\u0124\u0121\3\2\2\2\u0124\u0122\3\2\2\2\u0124\u0123\3\2"+ 21119 "\2\2\u0125\u0128\3\2\2\2\u0126\u0124\3\2\2\2\u0126\u0127\3\2\2\2\u0127"+ 21120 "\u0129\3\2\2\2\u0128\u0126\3\2\2\2\u0129\u012a\79\2\2\u012a\7\3\2\2\2"+ 21121 "\u012b\u012c\7\7\2\2\u012c\u012d\7;\2\2\u012d\u0131\7f\2\2\u012e\u0130"+ 21122 "\t\2\2\2\u012f\u012e\3\2\2\2\u0130\u0133\3\2\2\2\u0131\u012f\3\2\2\2\u0131"+ 21123 "\u0132\3\2\2\2\u0132\u0134\3\2\2\2\u0133\u0131\3\2\2\2\u0134\u0135\79"+ 21124 "\2\2\u0135\t\3\2\2\2\u0136\u013a\7f\2\2\u0137\u0139\t\2\2\2\u0138\u0137"+ 21125 "\3\2\2\2\u0139\u013c\3\2\2\2\u013a\u0138\3\2\2\2\u013a\u013b\3\2\2\2\u013b"+ 21126 "\u013d\3\2\2\2\u013c\u013a\3\2\2\2\u013d\u0141\7<\2\2\u013e\u0140\t\2"+ 21127 "\2\2\u013f\u013e\3\2\2\2\u0140\u0143\3\2\2\2\u0141\u013f\3\2\2\2\u0141"+ 21128 "\u0142\3\2\2\2\u0142\u0147\3\2\2\2\u0143\u0141\3\2\2\2\u0144\u0148\7["+ 21129 "\2\2\u0145\u0148\5\u0096L\2\u0146\u0148\7f\2\2\u0147\u0144\3\2\2\2\u0147"+ 21130 "\u0145\3\2\2\2\u0147\u0146\3\2\2\2\u0148\13\3\2\2\2\u0149\u0154\5\6\4"+ 21131 "\2\u014a\u0153\5\4\3\2\u014b\u014c\6\7\3\2\u014c\u0153\7\3\2\2\u014d\u0153"+ 21132 "\5\u0094K\2\u014e\u0153\7\5\2\2\u014f\u0153\7\b\2\2\u0150\u0153\5\u0096"+ 21133 "L\2\u0151\u0153\5\u0092J\2\u0152\u014a\3\2\2\2\u0152\u014b\3\2\2\2\u0152"+ 21134 "\u014d\3\2\2\2\u0152\u014e\3\2\2\2\u0152\u014f\3\2\2\2\u0152\u0150\3\2"+ 21135 "\2\2\u0152\u0151\3\2\2\2\u0153\u0156\3\2\2\2\u0154\u0152\3\2\2\2\u0154"+ 21136 "\u0155\3\2\2\2\u0155\u0157\3\2\2\2\u0156\u0154\3\2\2\2\u0157\u0158\5\b"+ 21137 "\5\2\u0158\u0159\6\7\4\3\u0159\r\3\2\2\2\u015a\u015b\7\7\2\2\u015b\u0162"+ 21138 "\7=\2\2\u015c\u0161\5\n\6\2\u015d\u0161\7\b\2\2\u015e\u0161\7\3\2\2\u015f"+ 21139 "\u0161\7\6\2\2\u0160\u015c\3\2\2\2\u0160\u015d\3\2\2\2\u0160\u015e\3\2"+ 21140 "\2\2\u0160\u015f\3\2\2\2\u0161\u0164\3\2\2\2\u0162\u0160\3\2\2\2\u0162"+ 21141 "\u0163\3\2\2\2\u0163\u0165\3\2\2\2\u0164\u0162\3\2\2\2\u0165\u0166\79"+ 21142 "\2\2\u0166\17\3\2\2\2\u0167\u0168\7\7\2\2\u0168\u0169\7;\2\2\u0169\u016d"+ 21143 "\7=\2\2\u016a\u016c\t\2\2\2\u016b\u016a\3\2\2\2\u016c\u016f\3\2\2\2\u016d"+ 21144 "\u016b\3\2\2\2\u016d\u016e\3\2\2\2\u016e\u0170\3\2\2\2\u016f\u016d\3\2"+ 21145 "\2\2\u0170\u0171\79\2\2\u0171\21\3\2\2\2\u0172\u01a4\5\16\b\2\u0173\u01a3"+ 21146 "\5\f\7\2\u0174\u01a3\5h\65\2\u0175\u01a3\5\30\r\2\u0176\u01a3\5\36\20"+ 21147 "\2\u0177\u01a3\5$\23\2\u0178\u01a3\5*\26\2\u0179\u01a3\5\60\31\2\u017a"+ 21148 "\u01a3\5\66\34\2\u017b\u01a3\5<\37\2\u017c\u01a3\5B\"\2\u017d\u01a3\5"+ 21149 "H%\2\u017e\u01a3\5N(\2\u017f\u01a3\5T+\2\u0180\u01a3\5Z.\2\u0181\u01a3"+ 21150 "\5f\64\2\u0182\u01a3\5`\61\2\u0183\u01a3\5\u00a6T\2\u0184\u01a3\5\u00ac"+ 21151 "W\2\u0185\u01a3\5\u00b2Z\2\u0186\u01a3\5\u00b8]\2\u0187\u01a3\5\u00be"+ 21152 "`\2\u0188\u01a3\5\24\13\2\u0189\u01a3\5\32\16\2\u018a\u01a3\5 \21\2\u018b"+ 21153 "\u01a3\5&\24\2\u018c\u01a3\5,\27\2\u018d\u01a3\5\62\32\2\u018e\u01a3\5"+ 21154 "8\35\2\u018f\u01a3\5> \2\u0190\u01a3\5D#\2\u0191\u01a3\5J&\2\u0192\u01a3"+ 21155 "\5P)\2\u0193\u01a3\5V,\2\u0194\u01a3\5b\62\2\u0195\u01a3\5\\/\2\u0196"+ 21156 "\u01a3\5\u00a2R\2\u0197\u01a3\5\u00a8U\2\u0198\u01a3\5\u00aeX\2\u0199"+ 21157 "\u01a3\5\u00b4[\2\u019a\u01a3\5\u00ba^\2\u019b\u019c\6\n\5\2\u019c\u01a3"+ 21158 "\7\3\2\2\u019d\u01a3\5\u0094K\2\u019e\u01a3\7\5\2\2\u019f\u01a3\7\b\2"+ 21159 "\2\u01a0\u01a3\5\u0096L\2\u01a1\u01a3\5\u0092J\2\u01a2\u0173\3\2\2\2\u01a2"+ 21160 "\u0174\3\2\2\2\u01a2\u0175\3\2\2\2\u01a2\u0176\3\2\2\2\u01a2\u0177\3\2"+ 21161 "\2\2\u01a2\u0178\3\2\2\2\u01a2\u0179\3\2\2\2\u01a2\u017a\3\2\2\2\u01a2"+ 21162 "\u017b\3\2\2\2\u01a2\u017c\3\2\2\2\u01a2\u017d\3\2\2\2\u01a2\u017e\3\2"+ 21163 "\2\2\u01a2\u017f\3\2\2\2\u01a2\u0180\3\2\2\2\u01a2\u0181\3\2\2\2\u01a2"+ 21164 "\u0182\3\2\2\2\u01a2\u0183\3\2\2\2\u01a2\u0184\3\2\2\2\u01a2\u0185\3\2"+ 21165 "\2\2\u01a2\u0186\3\2\2\2\u01a2\u0187\3\2\2\2\u01a2\u0188\3\2\2\2\u01a2"+ 21166 "\u0189\3\2\2\2\u01a2\u018a\3\2\2\2\u01a2\u018b\3\2\2\2\u01a2\u018c\3\2"+ 21167 "\2\2\u01a2\u018d\3\2\2\2\u01a2\u018e\3\2\2\2\u01a2\u018f\3\2\2\2\u01a2"+ 21168 "\u0190\3\2\2\2\u01a2\u0191\3\2\2\2\u01a2\u0192\3\2\2\2\u01a2\u0193\3\2"+ 21169 "\2\2\u01a2\u0194\3\2\2\2\u01a2\u0195\3\2\2\2\u01a2\u0196\3\2\2\2\u01a2"+ 21170 "\u0197\3\2\2\2\u01a2\u0198\3\2\2\2\u01a2\u0199\3\2\2\2\u01a2\u019a\3\2"+ 21171 "\2\2\u01a2\u019b\3\2\2\2\u01a2\u019d\3\2\2\2\u01a2\u019e\3\2\2\2\u01a2"+ 21172 "\u019f\3\2\2\2\u01a2\u01a0\3\2\2\2\u01a2\u01a1\3\2\2\2\u01a3\u01a6\3\2"+ 21173 "\2\2\u01a4\u01a2\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5\u01a7\3\2\2\2\u01a6"+ 21174 "\u01a4\3\2\2\2\u01a7\u01a8\5\20\t\2\u01a8\23\3\2\2\2\u01a9\u01aa\7\7\2"+ 21175 "\2\u01aa\u01b1\7>\2\2\u01ab\u01b0\5\n\6\2\u01ac\u01b0\7\b\2\2\u01ad\u01b0"+ 21176 "\7\3\2\2\u01ae\u01b0\7\6\2\2\u01af\u01ab\3\2\2\2\u01af\u01ac\3\2\2\2\u01af"+ 21177 "\u01ad\3\2\2\2\u01af\u01ae\3\2\2\2\u01b0\u01b3\3\2\2\2\u01b1\u01af\3\2"+ 21178 "\2\2\u01b1\u01b2\3\2\2\2\u01b2\u01b4\3\2\2\2\u01b3\u01b1\3\2\2\2\u01b4"+ 21179 "\u01b5\79\2\2\u01b5\25\3\2\2\2\u01b6\u01b7\7\7\2\2\u01b7\u01b8\7;\2\2"+ 21180 "\u01b8\u01bc\7>\2\2\u01b9\u01bb\t\2\2\2\u01ba\u01b9\3\2\2\2\u01bb\u01be"+ 21181 "\3\2\2\2\u01bc\u01ba\3\2\2\2\u01bc\u01bd\3\2\2\2\u01bd\u01bf\3\2\2\2\u01be"+ 21182 "\u01bc\3\2\2\2\u01bf\u01c0\79\2\2\u01c0\27\3\2\2\2\u01c1\u01f3\5\24\13"+ 21183 "\2\u01c2\u01f2\5\f\7\2\u01c3\u01f2\5h\65\2\u01c4\u01f2\5\22\n\2\u01c5"+ 21184 "\u01f2\5\36\20\2\u01c6\u01f2\5$\23\2\u01c7\u01f2\5*\26\2\u01c8\u01f2\5"+ 21185 "\60\31\2\u01c9\u01f2\5\66\34\2\u01ca\u01f2\5<\37\2\u01cb\u01f2\5B\"\2"+ 21186 "\u01cc\u01f2\5H%\2\u01cd\u01f2\5N(\2\u01ce\u01f2\5T+\2\u01cf\u01f2\5Z"+ 21187 ".\2\u01d0\u01f2\5f\64\2\u01d1\u01f2\5`\61\2\u01d2\u01f2\5\u00a6T\2\u01d3"+ 21188 "\u01f2\5\u00acW\2\u01d4\u01f2\5\u00b2Z\2\u01d5\u01f2\5\u00b8]\2\u01d6"+ 21189 "\u01f2\5\u00be`\2\u01d7\u01f2\5\16\b\2\u01d8\u01f2\5\32\16\2\u01d9\u01f2"+ 21190 "\5 \21\2\u01da\u01f2\5&\24\2\u01db\u01f2\5,\27\2\u01dc\u01f2\5\62\32\2"+ 21191 "\u01dd\u01f2\58\35\2\u01de\u01f2\5> \2\u01df\u01f2\5D#\2\u01e0\u01f2\5"+ 21192 "J&\2\u01e1\u01f2\5P)\2\u01e2\u01f2\5V,\2\u01e3\u01f2\5b\62\2\u01e4\u01f2"+ 21193 "\5\\/\2\u01e5\u01f2\5\u00a2R\2\u01e6\u01f2\5\u00a8U\2\u01e7\u01f2\5\u00ae"+ 21194 "X\2\u01e8\u01f2\5\u00b4[\2\u01e9\u01f2\5\u00ba^\2\u01ea\u01eb\6\r\6\2"+ 21195 "\u01eb\u01f2\7\3\2\2\u01ec\u01f2\5\u0094K\2\u01ed\u01f2\7\5\2\2\u01ee"+ 21196 "\u01f2\7\b\2\2\u01ef\u01f2\5\u0096L\2\u01f0\u01f2\5\u0092J\2\u01f1\u01c2"+ 21197 "\3\2\2\2\u01f1\u01c3\3\2\2\2\u01f1\u01c4\3\2\2\2\u01f1\u01c5\3\2\2\2\u01f1"+ 21198 "\u01c6\3\2\2\2\u01f1\u01c7\3\2\2\2\u01f1\u01c8\3\2\2\2\u01f1\u01c9\3\2"+ 21199 "\2\2\u01f1\u01ca\3\2\2\2\u01f1\u01cb\3\2\2\2\u01f1\u01cc\3\2\2\2\u01f1"+ 21200 "\u01cd\3\2\2\2\u01f1\u01ce\3\2\2\2\u01f1\u01cf\3\2\2\2\u01f1\u01d0\3\2"+ 21201 "\2\2\u01f1\u01d1\3\2\2\2\u01f1\u01d2\3\2\2\2\u01f1\u01d3\3\2\2\2\u01f1"+ 21202 "\u01d4\3\2\2\2\u01f1\u01d5\3\2\2\2\u01f1\u01d6\3\2\2\2\u01f1\u01d7\3\2"+ 21203 "\2\2\u01f1\u01d8\3\2\2\2\u01f1\u01d9\3\2\2\2\u01f1\u01da\3\2\2\2\u01f1"+ 21204 "\u01db\3\2\2\2\u01f1\u01dc\3\2\2\2\u01f1\u01dd\3\2\2\2\u01f1\u01de\3\2"+ 21205 "\2\2\u01f1\u01df\3\2\2\2\u01f1\u01e0\3\2\2\2\u01f1\u01e1\3\2\2\2\u01f1"+ 21206 "\u01e2\3\2\2\2\u01f1\u01e3\3\2\2\2\u01f1\u01e4\3\2\2\2\u01f1\u01e5\3\2"+ 21207 "\2\2\u01f1\u01e6\3\2\2\2\u01f1\u01e7\3\2\2\2\u01f1\u01e8\3\2\2\2\u01f1"+ 21208 "\u01e9\3\2\2\2\u01f1\u01ea\3\2\2\2\u01f1\u01ec\3\2\2\2\u01f1\u01ed\3\2"+ 21209 "\2\2\u01f1\u01ee\3\2\2\2\u01f1\u01ef\3\2\2\2\u01f1\u01f0\3\2\2\2\u01f2"+ 21210 "\u01f5\3\2\2\2\u01f3\u01f1\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4\u01f6\3\2"+ 21211 "\2\2\u01f5\u01f3\3\2\2\2\u01f6\u01f7\5\26\f\2\u01f7\31\3\2\2\2\u01f8\u01f9"+ 21212 "\7\7\2\2\u01f9\u0200\7?\2\2\u01fa\u01ff\5\n\6\2\u01fb\u01ff\7\b\2\2\u01fc"+ 21213 "\u01ff\7\3\2\2\u01fd\u01ff\7\6\2\2\u01fe\u01fa\3\2\2\2\u01fe\u01fb\3\2"+ 21214 "\2\2\u01fe\u01fc\3\2\2\2\u01fe\u01fd\3\2\2\2\u01ff\u0202\3\2\2\2\u0200"+ 21215 "\u01fe\3\2\2\2\u0200\u0201\3\2\2\2\u0201\u0203\3\2\2\2\u0202\u0200\3\2"+ 21216 "\2\2\u0203\u0204\79\2\2\u0204\33\3\2\2\2\u0205\u0206\7\7\2\2\u0206\u0207"+ 21217 "\7;\2\2\u0207\u020b\7?\2\2\u0208\u020a\t\2\2\2\u0209\u0208\3\2\2\2\u020a"+ 21218 "\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2\2\2\u020c\u020e\3\2"+ 21219 "\2\2\u020d\u020b\3\2\2\2\u020e\u020f\79\2\2\u020f\35\3\2\2\2\u0210\u0242"+ 21220 "\5\32\16\2\u0211\u0241\5\f\7\2\u0212\u0241\5h\65\2\u0213\u0241\5\22\n"+ 21221 "\2\u0214\u0241\5\30\r\2\u0215\u0241\5$\23\2\u0216\u0241\5*\26\2\u0217"+ 21222 "\u0241\5\60\31\2\u0218\u0241\5\66\34\2\u0219\u0241\5<\37\2\u021a\u0241"+ 21223 "\5B\"\2\u021b\u0241\5H%\2\u021c\u0241\5N(\2\u021d\u0241\5T+\2\u021e\u0241"+ 21224 "\5Z.\2\u021f\u0241\5f\64\2\u0220\u0241\5`\61\2\u0221\u0241\5\u00a6T\2"+ 21225 "\u0222\u0241\5\u00acW\2\u0223\u0241\5\u00b2Z\2\u0224\u0241\5\u00b8]\2"+ 21226 "\u0225\u0241\5\u00be`\2\u0226\u0241\5\16\b\2\u0227\u0241\5\24\13\2\u0228"+ 21227 "\u0241\5 \21\2\u0229\u0241\5&\24\2\u022a\u0241\5,\27\2\u022b\u0241\5\62"+ 21228 "\32\2\u022c\u0241\58\35\2\u022d\u0241\5> \2\u022e\u0241\5D#\2\u022f\u0241"+ 21229 "\5J&\2\u0230\u0241\5P)\2\u0231\u0241\5V,\2\u0232\u0241\5b\62\2\u0233\u0241"+ 21230 "\5\\/\2\u0234\u0241\5\u00a2R\2\u0235\u0241\5\u00a8U\2\u0236\u0241\5\u00ae"+ 21231 "X\2\u0237\u0241\5\u00b4[\2\u0238\u0241\5\u00ba^\2\u0239\u023a\6\20\7\2"+ 21232 "\u023a\u0241\7\3\2\2\u023b\u0241\5\u0094K\2\u023c\u0241\7\5\2\2\u023d"+ 21233 "\u0241\7\b\2\2\u023e\u0241\5\u0096L\2\u023f\u0241\5\u0092J\2\u0240\u0211"+ 21234 "\3\2\2\2\u0240\u0212\3\2\2\2\u0240\u0213\3\2\2\2\u0240\u0214\3\2\2\2\u0240"+ 21235 "\u0215\3\2\2\2\u0240\u0216\3\2\2\2\u0240\u0217\3\2\2\2\u0240\u0218\3\2"+ 21236 "\2\2\u0240\u0219\3\2\2\2\u0240\u021a\3\2\2\2\u0240\u021b\3\2\2\2\u0240"+ 21237 "\u021c\3\2\2\2\u0240\u021d\3\2\2\2\u0240\u021e\3\2\2\2\u0240\u021f\3\2"+ 21238 "\2\2\u0240\u0220\3\2\2\2\u0240\u0221\3\2\2\2\u0240\u0222\3\2\2\2\u0240"+ 21239 "\u0223\3\2\2\2\u0240\u0224\3\2\2\2\u0240\u0225\3\2\2\2\u0240\u0226\3\2"+ 21240 "\2\2\u0240\u0227\3\2\2\2\u0240\u0228\3\2\2\2\u0240\u0229\3\2\2\2\u0240"+ 21241 "\u022a\3\2\2\2\u0240\u022b\3\2\2\2\u0240\u022c\3\2\2\2\u0240\u022d\3\2"+ 21242 "\2\2\u0240\u022e\3\2\2\2\u0240\u022f\3\2\2\2\u0240\u0230\3\2\2\2\u0240"+ 21243 "\u0231\3\2\2\2\u0240\u0232\3\2\2\2\u0240\u0233\3\2\2\2\u0240\u0234\3\2"+ 21244 "\2\2\u0240\u0235\3\2\2\2\u0240\u0236\3\2\2\2\u0240\u0237\3\2\2\2\u0240"+ 21245 "\u0238\3\2\2\2\u0240\u0239\3\2\2\2\u0240\u023b\3\2\2\2\u0240\u023c\3\2"+ 21246 "\2\2\u0240\u023d\3\2\2\2\u0240\u023e\3\2\2\2\u0240\u023f\3\2\2\2\u0241"+ 21247 "\u0244\3\2\2\2\u0242\u0240\3\2\2\2\u0242\u0243\3\2\2\2\u0243\u0245\3\2"+ 21248 "\2\2\u0244\u0242\3\2\2\2\u0245\u0246\5\34\17\2\u0246\37\3\2\2\2\u0247"+ 21249 "\u0248\7\7\2\2\u0248\u024f\7@\2\2\u0249\u024e\5\n\6\2\u024a\u024e\7\b"+ 21250 "\2\2\u024b\u024e\7\3\2\2\u024c\u024e\7\6\2\2\u024d\u0249\3\2\2\2\u024d"+ 21251 "\u024a\3\2\2\2\u024d\u024b\3\2\2\2\u024d\u024c\3\2\2\2\u024e\u0251\3\2"+ 21252 "\2\2\u024f\u024d\3\2\2\2\u024f\u0250\3\2\2\2\u0250\u0252\3\2\2\2\u0251"+ 21253 "\u024f\3\2\2\2\u0252\u0253\79\2\2\u0253!\3\2\2\2\u0254\u0255\7\7\2\2\u0255"+ 21254 "\u0256\7;\2\2\u0256\u025a\7@\2\2\u0257\u0259\t\2\2\2\u0258\u0257\3\2\2"+ 21255 "\2\u0259\u025c\3\2\2\2\u025a\u0258\3\2\2\2\u025a\u025b\3\2\2\2\u025b\u025d"+ 21256 "\3\2\2\2\u025c\u025a\3\2\2\2\u025d\u025e\79\2\2\u025e#\3\2\2\2\u025f\u0291"+ 21257 "\5 \21\2\u0260\u0290\5\f\7\2\u0261\u0290\5h\65\2\u0262\u0290\5\22\n\2"+ 21258 "\u0263\u0290\5\30\r\2\u0264\u0290\5\36\20\2\u0265\u0290\5*\26\2\u0266"+ 21259 "\u0290\5\60\31\2\u0267\u0290\5\66\34\2\u0268\u0290\5<\37\2\u0269\u0290"+ 21260 "\5B\"\2\u026a\u0290\5H%\2\u026b\u0290\5N(\2\u026c\u0290\5T+\2\u026d\u0290"+ 21261 "\5Z.\2\u026e\u0290\5f\64\2\u026f\u0290\5`\61\2\u0270\u0290\5\u00a6T\2"+ 21262 "\u0271\u0290\5\u00acW\2\u0272\u0290\5\u00b2Z\2\u0273\u0290\5\u00b8]\2"+ 21263 "\u0274\u0290\5\u00be`\2\u0275\u0290\5\16\b\2\u0276\u0290\5\24\13\2\u0277"+ 21264 "\u0290\5 \21\2\u0278\u0290\5&\24\2\u0279\u0290\5,\27\2\u027a\u0290\5\62"+ 21265 "\32\2\u027b\u0290\58\35\2\u027c\u0290\5> \2\u027d\u0290\5D#\2\u027e\u0290"+ 21266 "\5J&\2\u027f\u0290\5P)\2\u0280\u0290\5V,\2\u0281\u0290\5b\62\2\u0282\u0290"+ 21267 "\5\\/\2\u0283\u0290\5\u00a2R\2\u0284\u0290\5\u00a8U\2\u0285\u0290\5\u00ae"+ 21268 "X\2\u0286\u0290\5\u00b4[\2\u0287\u0290\5\u00ba^\2\u0288\u0289\6\23\b\2"+ 21269 "\u0289\u0290\7\3\2\2\u028a\u0290\5\u0094K\2\u028b\u0290\7\5\2\2\u028c"+ 21270 "\u0290\7\b\2\2\u028d\u0290\5\u0096L\2\u028e\u0290\5\u0092J\2\u028f\u0260"+ 21271 "\3\2\2\2\u028f\u0261\3\2\2\2\u028f\u0262\3\2\2\2\u028f\u0263\3\2\2\2\u028f"+ 21272 "\u0264\3\2\2\2\u028f\u0265\3\2\2\2\u028f\u0266\3\2\2\2\u028f\u0267\3\2"+ 21273 "\2\2\u028f\u0268\3\2\2\2\u028f\u0269\3\2\2\2\u028f\u026a\3\2\2\2\u028f"+ 21274 "\u026b\3\2\2\2\u028f\u026c\3\2\2\2\u028f\u026d\3\2\2\2\u028f\u026e\3\2"+ 21275 "\2\2\u028f\u026f\3\2\2\2\u028f\u0270\3\2\2\2\u028f\u0271\3\2\2\2\u028f"+ 21276 "\u0272\3\2\2\2\u028f\u0273\3\2\2\2\u028f\u0274\3\2\2\2\u028f\u0275\3\2"+ 21277 "\2\2\u028f\u0276\3\2\2\2\u028f\u0277\3\2\2\2\u028f\u0278\3\2\2\2\u028f"+ 21278 "\u0279\3\2\2\2\u028f\u027a\3\2\2\2\u028f\u027b\3\2\2\2\u028f\u027c\3\2"+ 21279 "\2\2\u028f\u027d\3\2\2\2\u028f\u027e\3\2\2\2\u028f\u027f\3\2\2\2\u028f"+ 21280 "\u0280\3\2\2\2\u028f\u0281\3\2\2\2\u028f\u0282\3\2\2\2\u028f\u0283\3\2"+ 21281 "\2\2\u028f\u0284\3\2\2\2\u028f\u0285\3\2\2\2\u028f\u0286\3\2\2\2\u028f"+ 21282 "\u0287\3\2\2\2\u028f\u0288\3\2\2\2\u028f\u028a\3\2\2\2\u028f\u028b\3\2"+ 21283 "\2\2\u028f\u028c\3\2\2\2\u028f\u028d\3\2\2\2\u028f\u028e\3\2\2\2\u0290"+ 21284 "\u0293\3\2\2\2\u0291\u028f\3\2\2\2\u0291\u0292\3\2\2\2\u0292\u0294\3\2"+ 21285 "\2\2\u0293\u0291\3\2\2\2\u0294\u0295\5\"\22\2\u0295%\3\2\2\2\u0296\u0297"+ 21286 "\7\7\2\2\u0297\u029e\7A\2\2\u0298\u029d\5\n\6\2\u0299\u029d\7\b\2\2\u029a"+ 21287 "\u029d\7\3\2\2\u029b\u029d\7\6\2\2\u029c\u0298\3\2\2\2\u029c\u0299\3\2"+ 21288 "\2\2\u029c\u029a\3\2\2\2\u029c\u029b\3\2\2\2\u029d\u02a0\3\2\2\2\u029e"+ 21289 "\u029c\3\2\2\2\u029e\u029f\3\2\2\2\u029f\u02a1\3\2\2\2\u02a0\u029e\3\2"+ 21290 "\2\2\u02a1\u02a2\79\2\2\u02a2\'\3\2\2\2\u02a3\u02a4\7\7\2\2\u02a4\u02a5"+ 21291 "\7;\2\2\u02a5\u02a9\7A\2\2\u02a6\u02a8\t\2\2\2\u02a7\u02a6\3\2\2\2\u02a8"+ 21292 "\u02ab\3\2\2\2\u02a9\u02a7\3\2\2\2\u02a9\u02aa\3\2\2\2\u02aa\u02ac\3\2"+ 21293 "\2\2\u02ab\u02a9\3\2\2\2\u02ac\u02ad\79\2\2\u02ad)\3\2\2\2\u02ae\u02e0"+ 21294 "\5&\24\2\u02af\u02df\5\f\7\2\u02b0\u02df\5h\65\2\u02b1\u02df\5\22\n\2"+ 21295 "\u02b2\u02df\5\30\r\2\u02b3\u02df\5\36\20\2\u02b4\u02df\5$\23\2\u02b5"+ 21296 "\u02df\5\60\31\2\u02b6\u02df\5\66\34\2\u02b7\u02df\5<\37\2\u02b8\u02df"+ 21297 "\5B\"\2\u02b9\u02df\5H%\2\u02ba\u02df\5N(\2\u02bb\u02df\5T+\2\u02bc\u02df"+ 21298 "\5Z.\2\u02bd\u02df\5f\64\2\u02be\u02df\5`\61\2\u02bf\u02df\5\u00a6T\2"+ 21299 "\u02c0\u02df\5\u00acW\2\u02c1\u02df\5\u00b2Z\2\u02c2\u02df\5\u00b8]\2"+ 21300 "\u02c3\u02df\5\u00be`\2\u02c4\u02df\5\16\b\2\u02c5\u02df\5\24\13\2\u02c6"+ 21301 "\u02df\5\32\16\2\u02c7\u02df\5 \21\2\u02c8\u02df\5,\27\2\u02c9\u02df\5"+ 21302 "\62\32\2\u02ca\u02df\58\35\2\u02cb\u02df\5> \2\u02cc\u02df\5D#\2\u02cd"+ 21303 "\u02df\5J&\2\u02ce\u02df\5P)\2\u02cf\u02df\5V,\2\u02d0\u02df\5b\62\2\u02d1"+ 21304 "\u02df\5\\/\2\u02d2\u02df\5\u00a2R\2\u02d3\u02df\5\u00a8U\2\u02d4\u02df"+ 21305 "\5\u00aeX\2\u02d5\u02df\5\u00b4[\2\u02d6\u02df\5\u00ba^\2\u02d7\u02d8"+ 21306 "\6\26\t\2\u02d8\u02df\7\3\2\2\u02d9\u02df\5\u0094K\2\u02da\u02df\7\5\2"+ 21307 "\2\u02db\u02df\7\b\2\2\u02dc\u02df\5\u0096L\2\u02dd\u02df\5\u0092J\2\u02de"+ 21308 "\u02af\3\2\2\2\u02de\u02b0\3\2\2\2\u02de\u02b1\3\2\2\2\u02de\u02b2\3\2"+ 21309 "\2\2\u02de\u02b3\3\2\2\2\u02de\u02b4\3\2\2\2\u02de\u02b5\3\2\2\2\u02de"+ 21310 "\u02b6\3\2\2\2\u02de\u02b7\3\2\2\2\u02de\u02b8\3\2\2\2\u02de\u02b9\3\2"+ 21311 "\2\2\u02de\u02ba\3\2\2\2\u02de\u02bb\3\2\2\2\u02de\u02bc\3\2\2\2\u02de"+ 21312 "\u02bd\3\2\2\2\u02de\u02be\3\2\2\2\u02de\u02bf\3\2\2\2\u02de\u02c0\3\2"+ 21313 "\2\2\u02de\u02c1\3\2\2\2\u02de\u02c2\3\2\2\2\u02de\u02c3\3\2\2\2\u02de"+ 21314 "\u02c4\3\2\2\2\u02de\u02c5\3\2\2\2\u02de\u02c6\3\2\2\2\u02de\u02c7\3\2"+ 21315 "\2\2\u02de\u02c8\3\2\2\2\u02de\u02c9\3\2\2\2\u02de\u02ca\3\2\2\2\u02de"+ 21316 "\u02cb\3\2\2\2\u02de\u02cc\3\2\2\2\u02de\u02cd\3\2\2\2\u02de\u02ce\3\2"+ 21317 "\2\2\u02de\u02cf\3\2\2\2\u02de\u02d0\3\2\2\2\u02de\u02d1\3\2\2\2\u02de"+ 21318 "\u02d2\3\2\2\2\u02de\u02d3\3\2\2\2\u02de\u02d4\3\2\2\2\u02de\u02d5\3\2"+ 21319 "\2\2\u02de\u02d6\3\2\2\2\u02de\u02d7\3\2\2\2\u02de\u02d9\3\2\2\2\u02de"+ 21320 "\u02da\3\2\2\2\u02de\u02db\3\2\2\2\u02de\u02dc\3\2\2\2\u02de\u02dd\3\2"+ 21321 "\2\2\u02df\u02e2\3\2\2\2\u02e0\u02de\3\2\2\2\u02e0\u02e1\3\2\2\2\u02e1"+ 21322 "\u02e3\3\2\2\2\u02e2\u02e0\3\2\2\2\u02e3\u02e4\5(\25\2\u02e4+\3\2\2\2"+ 21323 "\u02e5\u02e6\7\7\2\2\u02e6\u02ed\7B\2\2\u02e7\u02ec\5\n\6\2\u02e8\u02ec"+ 21324 "\7\b\2\2\u02e9\u02ec\7\3\2\2\u02ea\u02ec\7\6\2\2\u02eb\u02e7\3\2\2\2\u02eb"+ 21325 "\u02e8\3\2\2\2\u02eb\u02e9\3\2\2\2\u02eb\u02ea\3\2\2\2\u02ec\u02ef\3\2"+ 21326 "\2\2\u02ed\u02eb\3\2\2\2\u02ed\u02ee\3\2\2\2\u02ee\u02f0\3\2\2\2\u02ef"+ 21327 "\u02ed\3\2\2\2\u02f0\u02f1\79\2\2\u02f1-\3\2\2\2\u02f2\u02f3\7\7\2\2\u02f3"+ 21328 "\u02f4\7;\2\2\u02f4\u02f8\7B\2\2\u02f5\u02f7\t\2\2\2\u02f6\u02f5\3\2\2"+ 21329 "\2\u02f7\u02fa\3\2\2\2\u02f8\u02f6\3\2\2\2\u02f8\u02f9\3\2\2\2\u02f9\u02fb"+ 21330 "\3\2\2\2\u02fa\u02f8\3\2\2\2\u02fb\u02fc\79\2\2\u02fc/\3\2\2\2\u02fd\u032f"+ 21331 "\5,\27\2\u02fe\u032e\5\f\7\2\u02ff\u032e\5h\65\2\u0300\u032e\5\22\n\2"+ 21332 "\u0301\u032e\5\30\r\2\u0302\u032e\5\36\20\2\u0303\u032e\5$\23\2\u0304"+ 21333 "\u032e\5*\26\2\u0305\u032e\5\66\34\2\u0306\u032e\5<\37\2\u0307\u032e\5"+ 21334 "B\"\2\u0308\u032e\5H%\2\u0309\u032e\5N(\2\u030a\u032e\5T+\2\u030b\u032e"+ 21335 "\5Z.\2\u030c\u032e\5f\64\2\u030d\u032e\5`\61\2\u030e\u032e\5\u00a6T\2"+ 21336 "\u030f\u032e\5\u00acW\2\u0310\u032e\5\u00b2Z\2\u0311\u032e\5\u00b8]\2"+ 21337 "\u0312\u032e\5\u00be`\2\u0313\u032e\5\16\b\2\u0314\u032e\5\24\13\2\u0315"+ 21338 "\u032e\5\32\16\2\u0316\u032e\5 \21\2\u0317\u032e\5&\24\2\u0318\u032e\5"+ 21339 "\62\32\2\u0319\u032e\58\35\2\u031a\u032e\5> \2\u031b\u032e\5D#\2\u031c"+ 21340 "\u032e\5J&\2\u031d\u032e\5P)\2\u031e\u032e\5V,\2\u031f\u032e\5b\62\2\u0320"+ 21341 "\u032e\5\\/\2\u0321\u032e\5\u00a2R\2\u0322\u032e\5\u00a8U\2\u0323\u032e"+ 21342 "\5\u00aeX\2\u0324\u032e\5\u00b4[\2\u0325\u032e\5\u00ba^\2\u0326\u0327"+ 21343 "\6\31\n\2\u0327\u032e\7\3\2\2\u0328\u032e\5\u0094K\2\u0329\u032e\7\5\2"+ 21344 "\2\u032a\u032e\7\b\2\2\u032b\u032e\5\u0096L\2\u032c\u032e\5\u0092J\2\u032d"+ 21345 "\u02fe\3\2\2\2\u032d\u02ff\3\2\2\2\u032d\u0300\3\2\2\2\u032d\u0301\3\2"+ 21346 "\2\2\u032d\u0302\3\2\2\2\u032d\u0303\3\2\2\2\u032d\u0304\3\2\2\2\u032d"+ 21347 "\u0305\3\2\2\2\u032d\u0306\3\2\2\2\u032d\u0307\3\2\2\2\u032d\u0308\3\2"+ 21348 "\2\2\u032d\u0309\3\2\2\2\u032d\u030a\3\2\2\2\u032d\u030b\3\2\2\2\u032d"+ 21349 "\u030c\3\2\2\2\u032d\u030d\3\2\2\2\u032d\u030e\3\2\2\2\u032d\u030f\3\2"+ 21350 "\2\2\u032d\u0310\3\2\2\2\u032d\u0311\3\2\2\2\u032d\u0312\3\2\2\2\u032d"+ 21351 "\u0313\3\2\2\2\u032d\u0314\3\2\2\2\u032d\u0315\3\2\2\2\u032d\u0316\3\2"+ 21352 "\2\2\u032d\u0317\3\2\2\2\u032d\u0318\3\2\2\2\u032d\u0319\3\2\2\2\u032d"+ 21353 "\u031a\3\2\2\2\u032d\u031b\3\2\2\2\u032d\u031c\3\2\2\2\u032d\u031d\3\2"+ 21354 "\2\2\u032d\u031e\3\2\2\2\u032d\u031f\3\2\2\2\u032d\u0320\3\2\2\2\u032d"+ 21355 "\u0321\3\2\2\2\u032d\u0322\3\2\2\2\u032d\u0323\3\2\2\2\u032d\u0324\3\2"+ 21356 "\2\2\u032d\u0325\3\2\2\2\u032d\u0326\3\2\2\2\u032d\u0328\3\2\2\2\u032d"+ 21357 "\u0329\3\2\2\2\u032d\u032a\3\2\2\2\u032d\u032b\3\2\2\2\u032d\u032c\3\2"+ 21358 "\2\2\u032e\u0331\3\2\2\2\u032f\u032d\3\2\2\2\u032f\u0330\3\2\2\2\u0330"+ 21359 "\u0332\3\2\2\2\u0331\u032f\3\2\2\2\u0332\u0333\5.\30\2\u0333\61\3\2\2"+ 21360 "\2\u0334\u0335\7\7\2\2\u0335\u033c\7C\2\2\u0336\u033b\5\n\6\2\u0337\u033b"+ 21361 "\7\b\2\2\u0338\u033b\7\3\2\2\u0339\u033b\7\6\2\2\u033a\u0336\3\2\2\2\u033a"+ 21362 "\u0337\3\2\2\2\u033a\u0338\3\2\2\2\u033a\u0339\3\2\2\2\u033b\u033e\3\2"+ 21363 "\2\2\u033c\u033a\3\2\2\2\u033c\u033d\3\2\2\2\u033d\u033f\3\2\2\2\u033e"+ 21364 "\u033c\3\2\2\2\u033f\u0340\79\2\2\u0340\63\3\2\2\2\u0341\u0342\7\7\2\2"+ 21365 "\u0342\u0343\7;\2\2\u0343\u0347\7C\2\2\u0344\u0346\t\2\2\2\u0345\u0344"+ 21366 "\3\2\2\2\u0346\u0349\3\2\2\2\u0347\u0345\3\2\2\2\u0347\u0348\3\2\2\2\u0348"+ 21367 "\u034a\3\2\2\2\u0349\u0347\3\2\2\2\u034a\u034b\79\2\2\u034b\65\3\2\2\2"+ 21368 "\u034c\u037e\5\62\32\2\u034d\u037d\5\f\7\2\u034e\u037d\5h\65\2\u034f\u037d"+ 21369 "\5\22\n\2\u0350\u037d\5\30\r\2\u0351\u037d\5\36\20\2\u0352\u037d\5$\23"+ 21370 "\2\u0353\u037d\5*\26\2\u0354\u037d\5\60\31\2\u0355\u037d\5<\37\2\u0356"+ 21371 "\u037d\5B\"\2\u0357\u037d\5H%\2\u0358\u037d\5N(\2\u0359\u037d\5T+\2\u035a"+ 21372 "\u037d\5Z.\2\u035b\u037d\5f\64\2\u035c\u037d\5`\61\2\u035d\u037d\5\u00a6"+ 21373 "T\2\u035e\u037d\5\u00acW\2\u035f\u037d\5\u00b2Z\2\u0360\u037d\5\u00b8"+ 21374 "]\2\u0361\u037d\5\u00be`\2\u0362\u037d\5\16\b\2\u0363\u037d\5\24\13\2"+ 21375 "\u0364\u037d\5\32\16\2\u0365\u037d\5 \21\2\u0366\u037d\5&\24\2\u0367\u037d"+ 21376 "\5,\27\2\u0368\u037d\58\35\2\u0369\u037d\5> \2\u036a\u037d\5D#\2\u036b"+ 21377 "\u037d\5J&\2\u036c\u037d\5P)\2\u036d\u037d\5V,\2\u036e\u037d\5b\62\2\u036f"+ 21378 "\u037d\5\\/\2\u0370\u037d\5\u00a2R\2\u0371\u037d\5\u00a8U\2\u0372\u037d"+ 21379 "\5\u00aeX\2\u0373\u037d\5\u00b4[\2\u0374\u037d\5\u00ba^\2\u0375\u0376"+ 21380 "\6\34\13\2\u0376\u037d\7\3\2\2\u0377\u037d\5\u0094K\2\u0378\u037d\7\5"+ 21381 "\2\2\u0379\u037d\7\b\2\2\u037a\u037d\5\u0096L\2\u037b\u037d\5\u0092J\2"+ 21382 "\u037c\u034d\3\2\2\2\u037c\u034e\3\2\2\2\u037c\u034f\3\2\2\2\u037c\u0350"+ 21383 "\3\2\2\2\u037c\u0351\3\2\2\2\u037c\u0352\3\2\2\2\u037c\u0353\3\2\2\2\u037c"+ 21384 "\u0354\3\2\2\2\u037c\u0355\3\2\2\2\u037c\u0356\3\2\2\2\u037c\u0357\3\2"+ 21385 "\2\2\u037c\u0358\3\2\2\2\u037c\u0359\3\2\2\2\u037c\u035a\3\2\2\2\u037c"+ 21386 "\u035b\3\2\2\2\u037c\u035c\3\2\2\2\u037c\u035d\3\2\2\2\u037c\u035e\3\2"+ 21387 "\2\2\u037c\u035f\3\2\2\2\u037c\u0360\3\2\2\2\u037c\u0361\3\2\2\2\u037c"+ 21388 "\u0362\3\2\2\2\u037c\u0363\3\2\2\2\u037c\u0364\3\2\2\2\u037c\u0365\3\2"+ 21389 "\2\2\u037c\u0366\3\2\2\2\u037c\u0367\3\2\2\2\u037c\u0368\3\2\2\2\u037c"+ 21390 "\u0369\3\2\2\2\u037c\u036a\3\2\2\2\u037c\u036b\3\2\2\2\u037c\u036c\3\2"+ 21391 "\2\2\u037c\u036d\3\2\2\2\u037c\u036e\3\2\2\2\u037c\u036f\3\2\2\2\u037c"+ 21392 "\u0370\3\2\2\2\u037c\u0371\3\2\2\2\u037c\u0372\3\2\2\2\u037c\u0373\3\2"+ 21393 "\2\2\u037c\u0374\3\2\2\2\u037c\u0375\3\2\2\2\u037c\u0377\3\2\2\2\u037c"+ 21394 "\u0378\3\2\2\2\u037c\u0379\3\2\2\2\u037c\u037a\3\2\2\2\u037c\u037b\3\2"+ 21395 "\2\2\u037d\u0380\3\2\2\2\u037e\u037c\3\2\2\2\u037e\u037f\3\2\2\2\u037f"+ 21396 "\u0381\3\2\2\2\u0380\u037e\3\2\2\2\u0381\u0382\5\64\33\2\u0382\67\3\2"+ 21397 "\2\2\u0383\u0384\7\7\2\2\u0384\u038b\7D\2\2\u0385\u038a\5\n\6\2\u0386"+ 21398 "\u038a\7\b\2\2\u0387\u038a\7\3\2\2\u0388\u038a\7\6\2\2\u0389\u0385\3\2"+ 21399 "\2\2\u0389\u0386\3\2\2\2\u0389\u0387\3\2\2\2\u0389\u0388\3\2\2\2\u038a"+ 21400 "\u038d\3\2\2\2\u038b\u0389\3\2\2\2\u038b\u038c\3\2\2\2\u038c\u038e\3\2"+ 21401 "\2\2\u038d\u038b\3\2\2\2\u038e\u038f\79\2\2\u038f9\3\2\2\2\u0390\u0391"+ 21402 "\7\7\2\2\u0391\u0392\7;\2\2\u0392\u0396\7D\2\2\u0393\u0395\t\2\2\2\u0394"+ 21403 "\u0393\3\2\2\2\u0395\u0398\3\2\2\2\u0396\u0394\3\2\2\2\u0396\u0397\3\2"+ 21404 "\2\2\u0397\u0399\3\2\2\2\u0398\u0396\3\2\2\2\u0399\u039a\79\2\2\u039a"+ 21405 ";\3\2\2\2\u039b\u03cd\58\35\2\u039c\u03cc\5\f\7\2\u039d\u03cc\5h\65\2"+ 21406 "\u039e\u03cc\5\22\n\2\u039f\u03cc\5\30\r\2\u03a0\u03cc\5\36\20\2\u03a1"+ 21407 "\u03cc\5$\23\2\u03a2\u03cc\5*\26\2\u03a3\u03cc\5\60\31\2\u03a4\u03cc\5"+ 21408 "\66\34\2\u03a5\u03cc\5B\"\2\u03a6\u03cc\5H%\2\u03a7\u03cc\5N(\2\u03a8"+ 21409 "\u03cc\5T+\2\u03a9\u03cc\5Z.\2\u03aa\u03cc\5f\64\2\u03ab\u03cc\5`\61\2"+ 21410 "\u03ac\u03cc\5\u00a6T\2\u03ad\u03cc\5\u00acW\2\u03ae\u03cc\5\u00b2Z\2"+ 21411 "\u03af\u03cc\5\u00b8]\2\u03b0\u03cc\5\u00be`\2\u03b1\u03cc\5\16\b\2\u03b2"+ 21412 "\u03cc\5\24\13\2\u03b3\u03cc\5\32\16\2\u03b4\u03cc\5 \21\2\u03b5\u03cc"+ 21413 "\5&\24\2\u03b6\u03cc\5,\27\2\u03b7\u03cc\5\62\32\2\u03b8\u03cc\5> \2\u03b9"+ 21414 "\u03cc\5D#\2\u03ba\u03cc\5J&\2\u03bb\u03cc\5P)\2\u03bc\u03cc\5V,\2\u03bd"+ 21415 "\u03cc\5b\62\2\u03be\u03cc\5\\/\2\u03bf\u03cc\5\u00a2R\2\u03c0\u03cc\5"+ 21416 "\u00a8U\2\u03c1\u03cc\5\u00aeX\2\u03c2\u03cc\5\u00b4[\2\u03c3\u03cc\5"+ 21417 "\u00ba^\2\u03c4\u03c5\6\37\f\2\u03c5\u03cc\7\3\2\2\u03c6\u03cc\5\u0094"+ 21418 "K\2\u03c7\u03cc\7\5\2\2\u03c8\u03cc\7\b\2\2\u03c9\u03cc\5\u0096L\2\u03ca"+ 21419 "\u03cc\5\u0092J\2\u03cb\u039c\3\2\2\2\u03cb\u039d\3\2\2\2\u03cb\u039e"+ 21420 "\3\2\2\2\u03cb\u039f\3\2\2\2\u03cb\u03a0\3\2\2\2\u03cb\u03a1\3\2\2\2\u03cb"+ 21421 "\u03a2\3\2\2\2\u03cb\u03a3\3\2\2\2\u03cb\u03a4\3\2\2\2\u03cb\u03a5\3\2"+ 21422 "\2\2\u03cb\u03a6\3\2\2\2\u03cb\u03a7\3\2\2\2\u03cb\u03a8\3\2\2\2\u03cb"+ 21423 "\u03a9\3\2\2\2\u03cb\u03aa\3\2\2\2\u03cb\u03ab\3\2\2\2\u03cb\u03ac\3\2"+ 21424 "\2\2\u03cb\u03ad\3\2\2\2\u03cb\u03ae\3\2\2\2\u03cb\u03af\3\2\2\2\u03cb"+ 21425 "\u03b0\3\2\2\2\u03cb\u03b1\3\2\2\2\u03cb\u03b2\3\2\2\2\u03cb\u03b3\3\2"+ 21426 "\2\2\u03cb\u03b4\3\2\2\2\u03cb\u03b5\3\2\2\2\u03cb\u03b6\3\2\2\2\u03cb"+ 21427 "\u03b7\3\2\2\2\u03cb\u03b8\3\2\2\2\u03cb\u03b9\3\2\2\2\u03cb\u03ba\3\2"+ 21428 "\2\2\u03cb\u03bb\3\2\2\2\u03cb\u03bc\3\2\2\2\u03cb\u03bd\3\2\2\2\u03cb"+ 21429 "\u03be\3\2\2\2\u03cb\u03bf\3\2\2\2\u03cb\u03c0\3\2\2\2\u03cb\u03c1\3\2"+ 21430 "\2\2\u03cb\u03c2\3\2\2\2\u03cb\u03c3\3\2\2\2\u03cb\u03c4\3\2\2\2\u03cb"+ 21431 "\u03c6\3\2\2\2\u03cb\u03c7\3\2\2\2\u03cb\u03c8\3\2\2\2\u03cb\u03c9\3\2"+ 21432 "\2\2\u03cb\u03ca\3\2\2\2\u03cc\u03cf\3\2\2\2\u03cd\u03cb\3\2\2\2\u03cd"+ 21433 "\u03ce\3\2\2\2\u03ce\u03d0\3\2\2\2\u03cf\u03cd\3\2\2\2\u03d0\u03d1\5:"+ 21434 "\36\2\u03d1=\3\2\2\2\u03d2\u03d3\7\7\2\2\u03d3\u03da\7E\2\2\u03d4\u03d9"+ 21435 "\5\n\6\2\u03d5\u03d9\7\b\2\2\u03d6\u03d9\7\3\2\2\u03d7\u03d9\7\6\2\2\u03d8"+ 21436 "\u03d4\3\2\2\2\u03d8\u03d5\3\2\2\2\u03d8\u03d6\3\2\2\2\u03d8\u03d7\3\2"+ 21437 "\2\2\u03d9\u03dc\3\2\2\2\u03da\u03d8\3\2\2\2\u03da\u03db\3\2\2\2\u03db"+ 21438 "\u03dd\3\2\2\2\u03dc\u03da\3\2\2\2\u03dd\u03de\79\2\2\u03de?\3\2\2\2\u03df"+ 21439 "\u03e0\7\7\2\2\u03e0\u03e1\7;\2\2\u03e1\u03e5\7E\2\2\u03e2\u03e4\t\2\2"+ 21440 "\2\u03e3\u03e2\3\2\2\2\u03e4\u03e7\3\2\2\2\u03e5\u03e3\3\2\2\2\u03e5\u03e6"+ 21441 "\3\2\2\2\u03e6\u03e8\3\2\2\2\u03e7\u03e5\3\2\2\2\u03e8\u03e9\79\2\2\u03e9"+ 21442 "A\3\2\2\2\u03ea\u041c\5> \2\u03eb\u041b\5\f\7\2\u03ec\u041b\5h\65\2\u03ed"+ 21443 "\u041b\5\22\n\2\u03ee\u041b\5\30\r\2\u03ef\u041b\5\36\20\2\u03f0\u041b"+ 21444 "\5$\23\2\u03f1\u041b\5*\26\2\u03f2\u041b\5\60\31\2\u03f3\u041b\5\66\34"+ 21445 "\2\u03f4\u041b\5<\37\2\u03f5\u041b\5H%\2\u03f6\u041b\5N(\2\u03f7\u041b"+ 21446 "\5T+\2\u03f8\u041b\5Z.\2\u03f9\u041b\5f\64\2\u03fa\u041b\5`\61\2\u03fb"+ 21447 "\u041b\5\u00a6T\2\u03fc\u041b\5\u00acW\2\u03fd\u041b\5\u00b2Z\2\u03fe"+ 21448 "\u041b\5\u00b8]\2\u03ff\u041b\5\u00be`\2\u0400\u041b\5\16\b\2\u0401\u041b"+ 21449 "\5\24\13\2\u0402\u041b\5\32\16\2\u0403\u041b\5 \21\2\u0404\u041b\5&\24"+ 21450 "\2\u0405\u041b\5,\27\2\u0406\u041b\5\62\32\2\u0407\u041b\58\35\2\u0408"+ 21451 "\u041b\5D#\2\u0409\u041b\5J&\2\u040a\u041b\5P)\2\u040b\u041b\5V,\2\u040c"+ 21452 "\u041b\5b\62\2\u040d\u041b\5\\/\2\u040e\u041b\5\u00a2R\2\u040f\u041b\5"+ 21453 "\u00a8U\2\u0410\u041b\5\u00aeX\2\u0411\u041b\5\u00b4[\2\u0412\u041b\5"+ 21454 "\u00ba^\2\u0413\u0414\6\"\r\2\u0414\u041b\7\3\2\2\u0415\u041b\5\u0094"+ 21455 "K\2\u0416\u041b\7\5\2\2\u0417\u041b\7\b\2\2\u0418\u041b\5\u0096L\2\u0419"+ 21456 "\u041b\5\u0092J\2\u041a\u03eb\3\2\2\2\u041a\u03ec\3\2\2\2\u041a\u03ed"+ 21457 "\3\2\2\2\u041a\u03ee\3\2\2\2\u041a\u03ef\3\2\2\2\u041a\u03f0\3\2\2\2\u041a"+ 21458 "\u03f1\3\2\2\2\u041a\u03f2\3\2\2\2\u041a\u03f3\3\2\2\2\u041a\u03f4\3\2"+ 21459 "\2\2\u041a\u03f5\3\2\2\2\u041a\u03f6\3\2\2\2\u041a\u03f7\3\2\2\2\u041a"+ 21460 "\u03f8\3\2\2\2\u041a\u03f9\3\2\2\2\u041a\u03fa\3\2\2\2\u041a\u03fb\3\2"+ 21461 "\2\2\u041a\u03fc\3\2\2\2\u041a\u03fd\3\2\2\2\u041a\u03fe\3\2\2\2\u041a"+ 21462 "\u03ff\3\2\2\2\u041a\u0400\3\2\2\2\u041a\u0401\3\2\2\2\u041a\u0402\3\2"+ 21463 "\2\2\u041a\u0403\3\2\2\2\u041a\u0404\3\2\2\2\u041a\u0405\3\2\2\2\u041a"+ 21464 "\u0406\3\2\2\2\u041a\u0407\3\2\2\2\u041a\u0408\3\2\2\2\u041a\u0409\3\2"+ 21465 "\2\2\u041a\u040a\3\2\2\2\u041a\u040b\3\2\2\2\u041a\u040c\3\2\2\2\u041a"+ 21466 "\u040d\3\2\2\2\u041a\u040e\3\2\2\2\u041a\u040f\3\2\2\2\u041a\u0410\3\2"+ 21467 "\2\2\u041a\u0411\3\2\2\2\u041a\u0412\3\2\2\2\u041a\u0413\3\2\2\2\u041a"+ 21468 "\u0415\3\2\2\2\u041a\u0416\3\2\2\2\u041a\u0417\3\2\2\2\u041a\u0418\3\2"+ 21469 "\2\2\u041a\u0419\3\2\2\2\u041b\u041e\3\2\2\2\u041c\u041a\3\2\2\2\u041c"+ 21470 "\u041d\3\2\2\2\u041d\u041f\3\2\2\2\u041e\u041c\3\2\2\2\u041f\u0420\5@"+ 21471 "!\2\u0420C\3\2\2\2\u0421\u0422\7\7\2\2\u0422\u0429\7F\2\2\u0423\u0428"+ 21472 "\5\n\6\2\u0424\u0428\7\b\2\2\u0425\u0428\7\3\2\2\u0426\u0428\7\6\2\2\u0427"+ 21473 "\u0423\3\2\2\2\u0427\u0424\3\2\2\2\u0427\u0425\3\2\2\2\u0427\u0426\3\2"+ 21474 "\2\2\u0428\u042b\3\2\2\2\u0429\u0427\3\2\2\2\u0429\u042a\3\2\2\2\u042a"+ 21475 "\u042c\3\2\2\2\u042b\u0429\3\2\2\2\u042c\u042d\79\2\2\u042dE\3\2\2\2\u042e"+ 21476 "\u042f\7\7\2\2\u042f\u0430\7;\2\2\u0430\u0434\7F\2\2\u0431\u0433\t\2\2"+ 21477 "\2\u0432\u0431\3\2\2\2\u0433\u0436\3\2\2\2\u0434\u0432\3\2\2\2\u0434\u0435"+ 21478 "\3\2\2\2\u0435\u0437\3\2\2\2\u0436\u0434\3\2\2\2\u0437\u0438\79\2\2\u0438"+ 21479 "G\3\2\2\2\u0439\u046b\5D#\2\u043a\u046a\5\f\7\2\u043b\u046a\5h\65\2\u043c"+ 21480 "\u046a\5\22\n\2\u043d\u046a\5\30\r\2\u043e\u046a\5\36\20\2\u043f\u046a"+ 21481 "\5$\23\2\u0440\u046a\5*\26\2\u0441\u046a\5\60\31\2\u0442\u046a\5\66\34"+ 21482 "\2\u0443\u046a\5<\37\2\u0444\u046a\5B\"\2\u0445\u046a\5N(\2\u0446\u046a"+ 21483 "\5T+\2\u0447\u046a\5Z.\2\u0448\u046a\5f\64\2\u0449\u046a\5`\61\2\u044a"+ 21484 "\u046a\5\u00a6T\2\u044b\u046a\5\u00acW\2\u044c\u046a\5\u00b2Z\2\u044d"+ 21485 "\u046a\5\u00b8]\2\u044e\u046a\5\u00be`\2\u044f\u046a\5\16\b\2\u0450\u046a"+ 21486 "\5\24\13\2\u0451\u046a\5\32\16\2\u0452\u046a\5 \21\2\u0453\u046a\5&\24"+ 21487 "\2\u0454\u046a\5,\27\2\u0455\u046a\5\62\32\2\u0456\u046a\58\35\2\u0457"+ 21488 "\u046a\5> \2\u0458\u046a\5J&\2\u0459\u046a\5P)\2\u045a\u046a\5V,\2\u045b"+ 21489 "\u046a\5b\62\2\u045c\u046a\5\\/\2\u045d\u046a\5\u00a2R\2\u045e\u046a\5"+ 21490 "\u00a8U\2\u045f\u046a\5\u00aeX\2\u0460\u046a\5\u00b4[\2\u0461\u046a\5"+ 21491 "\u00ba^\2\u0462\u0463\6%\16\2\u0463\u046a\7\3\2\2\u0464\u046a\5\u0094"+ 21492 "K\2\u0465\u046a\7\5\2\2\u0466\u046a\7\b\2\2\u0467\u046a\5\u0096L\2\u0468"+ 21493 "\u046a\5\u0092J\2\u0469\u043a\3\2\2\2\u0469\u043b\3\2\2\2\u0469\u043c"+ 21494 "\3\2\2\2\u0469\u043d\3\2\2\2\u0469\u043e\3\2\2\2\u0469\u043f\3\2\2\2\u0469"+ 21495 "\u0440\3\2\2\2\u0469\u0441\3\2\2\2\u0469\u0442\3\2\2\2\u0469\u0443\3\2"+ 21496 "\2\2\u0469\u0444\3\2\2\2\u0469\u0445\3\2\2\2\u0469\u0446\3\2\2\2\u0469"+ 21497 "\u0447\3\2\2\2\u0469\u0448\3\2\2\2\u0469\u0449\3\2\2\2\u0469\u044a\3\2"+ 21498 "\2\2\u0469\u044b\3\2\2\2\u0469\u044c\3\2\2\2\u0469\u044d\3\2\2\2\u0469"+ 21499 "\u044e\3\2\2\2\u0469\u044f\3\2\2\2\u0469\u0450\3\2\2\2\u0469\u0451\3\2"+ 21500 "\2\2\u0469\u0452\3\2\2\2\u0469\u0453\3\2\2\2\u0469\u0454\3\2\2\2\u0469"+ 21501 "\u0455\3\2\2\2\u0469\u0456\3\2\2\2\u0469\u0457\3\2\2\2\u0469\u0458\3\2"+ 21502 "\2\2\u0469\u0459\3\2\2\2\u0469\u045a\3\2\2\2\u0469\u045b\3\2\2\2\u0469"+ 21503 "\u045c\3\2\2\2\u0469\u045d\3\2\2\2\u0469\u045e\3\2\2\2\u0469\u045f\3\2"+ 21504 "\2\2\u0469\u0460\3\2\2\2\u0469\u0461\3\2\2\2\u0469\u0462\3\2\2\2\u0469"+ 21505 "\u0464\3\2\2\2\u0469\u0465\3\2\2\2\u0469\u0466\3\2\2\2\u0469\u0467\3\2"+ 21506 "\2\2\u0469\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b"+ 21507 "\u046c\3\2\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u046f\5F"+ 21508 "$\2\u046fI\3\2\2\2\u0470\u0471\7\7\2\2\u0471\u0478\7G\2\2\u0472\u0477"+ 21509 "\5\n\6\2\u0473\u0477\7\b\2\2\u0474\u0477\7\3\2\2\u0475\u0477\7\6\2\2\u0476"+ 21510 "\u0472\3\2\2\2\u0476\u0473\3\2\2\2\u0476\u0474\3\2\2\2\u0476\u0475\3\2"+ 21511 "\2\2\u0477\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3\2\2\2\u0479"+ 21512 "\u047b\3\2\2\2\u047a\u0478\3\2\2\2\u047b\u047c\79\2\2\u047cK\3\2\2\2\u047d"+ 21513 "\u047e\7\7\2\2\u047e\u047f\7;\2\2\u047f\u0483\7G\2\2\u0480\u0482\t\2\2"+ 21514 "\2\u0481\u0480\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484"+ 21515 "\3\2\2\2\u0484\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0487\79\2\2\u0487"+ 21516 "M\3\2\2\2\u0488\u04ba\5J&\2\u0489\u04b9\5\f\7\2\u048a\u04b9\5h\65\2\u048b"+ 21517 "\u04b9\5\22\n\2\u048c\u04b9\5\30\r\2\u048d\u04b9\5\36\20\2\u048e\u04b9"+ 21518 "\5$\23\2\u048f\u04b9\5*\26\2\u0490\u04b9\5\60\31\2\u0491\u04b9\5\66\34"+ 21519 "\2\u0492\u04b9\5<\37\2\u0493\u04b9\5B\"\2\u0494\u04b9\5H%\2\u0495\u04b9"+ 21520 "\5T+\2\u0496\u04b9\5Z.\2\u0497\u04b9\5f\64\2\u0498\u04b9\5`\61\2\u0499"+ 21521 "\u04b9\5\u00a6T\2\u049a\u04b9\5\u00acW\2\u049b\u04b9\5\u00b2Z\2\u049c"+ 21522 "\u04b9\5\u00b8]\2\u049d\u04b9\5\u00be`\2\u049e\u04b9\5\16\b\2\u049f\u04b9"+ 21523 "\5\24\13\2\u04a0\u04b9\5\32\16\2\u04a1\u04b9\5 \21\2\u04a2\u04b9\5&\24"+ 21524 "\2\u04a3\u04b9\5,\27\2\u04a4\u04b9\5\62\32\2\u04a5\u04b9\58\35\2\u04a6"+ 21525 "\u04b9\5> \2\u04a7\u04b9\5D#\2\u04a8\u04b9\5P)\2\u04a9\u04b9\5V,\2\u04aa"+ 21526 "\u04b9\5b\62\2\u04ab\u04b9\5\\/\2\u04ac\u04b9\5\u00a2R\2\u04ad\u04b9\5"+ 21527 "\u00a8U\2\u04ae\u04b9\5\u00aeX\2\u04af\u04b9\5\u00b4[\2\u04b0\u04b9\5"+ 21528 "\u00ba^\2\u04b1\u04b2\6(\17\2\u04b2\u04b9\7\3\2\2\u04b3\u04b9\5\u0094"+ 21529 "K\2\u04b4\u04b9\7\5\2\2\u04b5\u04b9\7\b\2\2\u04b6\u04b9\5\u0096L\2\u04b7"+ 21530 "\u04b9\5\u0092J\2\u04b8\u0489\3\2\2\2\u04b8\u048a\3\2\2\2\u04b8\u048b"+ 21531 "\3\2\2\2\u04b8\u048c\3\2\2\2\u04b8\u048d\3\2\2\2\u04b8\u048e\3\2\2\2\u04b8"+ 21532 "\u048f\3\2\2\2\u04b8\u0490\3\2\2\2\u04b8\u0491\3\2\2\2\u04b8\u0492\3\2"+ 21533 "\2\2\u04b8\u0493\3\2\2\2\u04b8\u0494\3\2\2\2\u04b8\u0495\3\2\2\2\u04b8"+ 21534 "\u0496\3\2\2\2\u04b8\u0497\3\2\2\2\u04b8\u0498\3\2\2\2\u04b8\u0499\3\2"+ 21535 "\2\2\u04b8\u049a\3\2\2\2\u04b8\u049b\3\2\2\2\u04b8\u049c\3\2\2\2\u04b8"+ 21536 "\u049d\3\2\2\2\u04b8\u049e\3\2\2\2\u04b8\u049f\3\2\2\2\u04b8\u04a0\3\2"+ 21537 "\2\2\u04b8\u04a1\3\2\2\2\u04b8\u04a2\3\2\2\2\u04b8\u04a3\3\2\2\2\u04b8"+ 21538 "\u04a4\3\2\2\2\u04b8\u04a5\3\2\2\2\u04b8\u04a6\3\2\2\2\u04b8\u04a7\3\2"+ 21539 "\2\2\u04b8\u04a8\3\2\2\2\u04b8\u04a9\3\2\2\2\u04b8\u04aa\3\2\2\2\u04b8"+ 21540 "\u04ab\3\2\2\2\u04b8\u04ac\3\2\2\2\u04b8\u04ad\3\2\2\2\u04b8\u04ae\3\2"+ 21541 "\2\2\u04b8\u04af\3\2\2\2\u04b8\u04b0\3\2\2\2\u04b8\u04b1\3\2\2\2\u04b8"+ 21542 "\u04b3\3\2\2\2\u04b8\u04b4\3\2\2\2\u04b8\u04b5\3\2\2\2\u04b8\u04b6\3\2"+ 21543 "\2\2\u04b8\u04b7\3\2\2\2\u04b9\u04bc\3\2\2\2\u04ba\u04b8\3\2\2\2\u04ba"+ 21544 "\u04bb\3\2\2\2\u04bb\u04bd\3\2\2\2\u04bc\u04ba\3\2\2\2\u04bd\u04be\5L"+ 21545 "\'\2\u04beO\3\2\2\2\u04bf\u04c0\7\7\2\2\u04c0\u04c7\7H\2\2\u04c1\u04c6"+ 21546 "\5\n\6\2\u04c2\u04c6\7\b\2\2\u04c3\u04c6\7\3\2\2\u04c4\u04c6\7\6\2\2\u04c5"+ 21547 "\u04c1\3\2\2\2\u04c5\u04c2\3\2\2\2\u04c5\u04c3\3\2\2\2\u04c5\u04c4\3\2"+ 21548 "\2\2\u04c6\u04c9\3\2\2\2\u04c7\u04c5\3\2\2\2\u04c7\u04c8\3\2\2\2\u04c8"+ 21549 "\u04ca\3\2\2\2\u04c9\u04c7\3\2\2\2\u04ca\u04cb\79\2\2\u04cbQ\3\2\2\2\u04cc"+ 21550 "\u04cd\7\7\2\2\u04cd\u04ce\7;\2\2\u04ce\u04d2\7H\2\2\u04cf\u04d1\t\2\2"+ 21551 "\2\u04d0\u04cf\3\2\2\2\u04d1\u04d4\3\2\2\2\u04d2\u04d0\3\2\2\2\u04d2\u04d3"+ 21552 "\3\2\2\2\u04d3\u04d5\3\2\2\2\u04d4\u04d2\3\2\2\2\u04d5\u04d6\79\2\2\u04d6"+ 21553 "S\3\2\2\2\u04d7\u0509\5P)\2\u04d8\u0508\5\f\7\2\u04d9\u0508\5h\65\2\u04da"+ 21554 "\u0508\5\22\n\2\u04db\u0508\5\30\r\2\u04dc\u0508\5\36\20\2\u04dd\u0508"+ 21555 "\5$\23\2\u04de\u0508\5*\26\2\u04df\u0508\5\60\31\2\u04e0\u0508\5\66\34"+ 21556 "\2\u04e1\u0508\5<\37\2\u04e2\u0508\5B\"\2\u04e3\u0508\5H%\2\u04e4\u0508"+ 21557 "\5N(\2\u04e5\u0508\5Z.\2\u04e6\u0508\5f\64\2\u04e7\u0508\5`\61\2\u04e8"+ 21558 "\u0508\5\u00a6T\2\u04e9\u0508\5\u00acW\2\u04ea\u0508\5\u00b2Z\2\u04eb"+ 21559 "\u0508\5\u00b8]\2\u04ec\u0508\5\u00be`\2\u04ed\u0508\5\16\b\2\u04ee\u0508"+ 21560 "\5\24\13\2\u04ef\u0508\5\32\16\2\u04f0\u0508\5 \21\2\u04f1\u0508\5&\24"+ 21561 "\2\u04f2\u0508\5,\27\2\u04f3\u0508\5\62\32\2\u04f4\u0508\58\35\2\u04f5"+ 21562 "\u0508\5> \2\u04f6\u0508\5D#\2\u04f7\u0508\5J&\2\u04f8\u0508\5V,\2\u04f9"+ 21563 "\u0508\5b\62\2\u04fa\u0508\5\\/\2\u04fb\u0508\5\u00a2R\2\u04fc\u0508\5"+ 21564 "\u00a8U\2\u04fd\u0508\5\u00aeX\2\u04fe\u0508\5\u00b4[\2\u04ff\u0508\5"+ 21565 "\u00ba^\2\u0500\u0501\6+\20\2\u0501\u0508\7\3\2\2\u0502\u0508\5\u0094"+ 21566 "K\2\u0503\u0508\7\5\2\2\u0504\u0508\7\b\2\2\u0505\u0508\5\u0096L\2\u0506"+ 21567 "\u0508\5\u0092J\2\u0507\u04d8\3\2\2\2\u0507\u04d9\3\2\2\2\u0507\u04da"+ 21568 "\3\2\2\2\u0507\u04db\3\2\2\2\u0507\u04dc\3\2\2\2\u0507\u04dd\3\2\2\2\u0507"+ 21569 "\u04de\3\2\2\2\u0507\u04df\3\2\2\2\u0507\u04e0\3\2\2\2\u0507\u04e1\3\2"+ 21570 "\2\2\u0507\u04e2\3\2\2\2\u0507\u04e3\3\2\2\2\u0507\u04e4\3\2\2\2\u0507"+ 21571 "\u04e5\3\2\2\2\u0507\u04e6\3\2\2\2\u0507\u04e7\3\2\2\2\u0507\u04e8\3\2"+ 21572 "\2\2\u0507\u04e9\3\2\2\2\u0507\u04ea\3\2\2\2\u0507\u04eb\3\2\2\2\u0507"+ 21573 "\u04ec\3\2\2\2\u0507\u04ed\3\2\2\2\u0507\u04ee\3\2\2\2\u0507\u04ef\3\2"+ 21574 "\2\2\u0507\u04f0\3\2\2\2\u0507\u04f1\3\2\2\2\u0507\u04f2\3\2\2\2\u0507"+ 21575 "\u04f3\3\2\2\2\u0507\u04f4\3\2\2\2\u0507\u04f5\3\2\2\2\u0507\u04f6\3\2"+ 21576 "\2\2\u0507\u04f7\3\2\2\2\u0507\u04f8\3\2\2\2\u0507\u04f9\3\2\2\2\u0507"+ 21577 "\u04fa\3\2\2\2\u0507\u04fb\3\2\2\2\u0507\u04fc\3\2\2\2\u0507\u04fd\3\2"+ 21578 "\2\2\u0507\u04fe\3\2\2\2\u0507\u04ff\3\2\2\2\u0507\u0500\3\2\2\2\u0507"+ 21579 "\u0502\3\2\2\2\u0507\u0503\3\2\2\2\u0507\u0504\3\2\2\2\u0507\u0505\3\2"+ 21580 "\2\2\u0507\u0506\3\2\2\2\u0508\u050b\3\2\2\2\u0509\u0507\3\2\2\2\u0509"+ 21581 "\u050a\3\2\2\2\u050a\u050c\3\2\2\2\u050b\u0509\3\2\2\2\u050c\u050d\5R"+ 21582 "*\2\u050dU\3\2\2\2\u050e\u050f\7\7\2\2\u050f\u0516\7I\2\2\u0510\u0515"+ 21583 "\5\n\6\2\u0511\u0515\7\b\2\2\u0512\u0515\7\3\2\2\u0513\u0515\7\6\2\2\u0514"+ 21584 "\u0510\3\2\2\2\u0514\u0511\3\2\2\2\u0514\u0512\3\2\2\2\u0514\u0513\3\2"+ 21585 "\2\2\u0515\u0518\3\2\2\2\u0516\u0514\3\2\2\2\u0516\u0517\3\2\2\2\u0517"+ 21586 "\u0519\3\2\2\2\u0518\u0516\3\2\2\2\u0519\u051a\79\2\2\u051aW\3\2\2\2\u051b"+ 21587 "\u051c\7\7\2\2\u051c\u051d\7;\2\2\u051d\u0521\7I\2\2\u051e\u0520\t\2\2"+ 21588 "\2\u051f\u051e\3\2\2\2\u0520\u0523\3\2\2\2\u0521\u051f\3\2\2\2\u0521\u0522"+ 21589 "\3\2\2\2\u0522\u0524\3\2\2\2\u0523\u0521\3\2\2\2\u0524\u0525\79\2\2\u0525"+ 21590 "Y\3\2\2\2\u0526\u0558\5V,\2\u0527\u0557\5\f\7\2\u0528\u0557\5h\65\2\u0529"+ 21591 "\u0557\5\22\n\2\u052a\u0557\5\30\r\2\u052b\u0557\5\36\20\2\u052c\u0557"+ 21592 "\5$\23\2\u052d\u0557\5*\26\2\u052e\u0557\5\60\31\2\u052f\u0557\5\66\34"+ 21593 "\2\u0530\u0557\5<\37\2\u0531\u0557\5B\"\2\u0532\u0557\5H%\2\u0533\u0557"+ 21594 "\5N(\2\u0534\u0557\5T+\2\u0535\u0557\5f\64\2\u0536\u0557\5`\61\2\u0537"+ 21595 "\u0557\5\u00a6T\2\u0538\u0557\5\u00acW\2\u0539\u0557\5\u00b2Z\2\u053a"+ 21596 "\u0557\5\u00b8]\2\u053b\u0557\5\u00be`\2\u053c\u0557\5\16\b\2\u053d\u0557"+ 21597 "\5\24\13\2\u053e\u0557\5\32\16\2\u053f\u0557\5 \21\2\u0540\u0557\5&\24"+ 21598 "\2\u0541\u0557\5,\27\2\u0542\u0557\5\62\32\2\u0543\u0557\58\35\2\u0544"+ 21599 "\u0557\5> \2\u0545\u0557\5D#\2\u0546\u0557\5J&\2\u0547\u0557\5P)\2\u0548"+ 21600 "\u0557\5b\62\2\u0549\u0557\5\\/\2\u054a\u0557\5\u00a2R\2\u054b\u0557\5"+ 21601 "\u00a8U\2\u054c\u0557\5\u00aeX\2\u054d\u0557\5\u00b4[\2\u054e\u0557\5"+ 21602 "\u00ba^\2\u054f\u0550\6.\21\2\u0550\u0557\7\3\2\2\u0551\u0557\5\u0094"+ 21603 "K\2\u0552\u0557\7\5\2\2\u0553\u0557\7\b\2\2\u0554\u0557\5\u0096L\2\u0555"+ 21604 "\u0557\5\u0092J\2\u0556\u0527\3\2\2\2\u0556\u0528\3\2\2\2\u0556\u0529"+ 21605 "\3\2\2\2\u0556\u052a\3\2\2\2\u0556\u052b\3\2\2\2\u0556\u052c\3\2\2\2\u0556"+ 21606 "\u052d\3\2\2\2\u0556\u052e\3\2\2\2\u0556\u052f\3\2\2\2\u0556\u0530\3\2"+ 21607 "\2\2\u0556\u0531\3\2\2\2\u0556\u0532\3\2\2\2\u0556\u0533\3\2\2\2\u0556"+ 21608 "\u0534\3\2\2\2\u0556\u0535\3\2\2\2\u0556\u0536\3\2\2\2\u0556\u0537\3\2"+ 21609 "\2\2\u0556\u0538\3\2\2\2\u0556\u0539\3\2\2\2\u0556\u053a\3\2\2\2\u0556"+ 21610 "\u053b\3\2\2\2\u0556\u053c\3\2\2\2\u0556\u053d\3\2\2\2\u0556\u053e\3\2"+ 21611 "\2\2\u0556\u053f\3\2\2\2\u0556\u0540\3\2\2\2\u0556\u0541\3\2\2\2\u0556"+ 21612 "\u0542\3\2\2\2\u0556\u0543\3\2\2\2\u0556\u0544\3\2\2\2\u0556\u0545\3\2"+ 21613 "\2\2\u0556\u0546\3\2\2\2\u0556\u0547\3\2\2\2\u0556\u0548\3\2\2\2\u0556"+ 21614 "\u0549\3\2\2\2\u0556\u054a\3\2\2\2\u0556\u054b\3\2\2\2\u0556\u054c\3\2"+ 21615 "\2\2\u0556\u054d\3\2\2\2\u0556\u054e\3\2\2\2\u0556\u054f\3\2\2\2\u0556"+ 21616 "\u0551\3\2\2\2\u0556\u0552\3\2\2\2\u0556\u0553\3\2\2\2\u0556\u0554\3\2"+ 21617 "\2\2\u0556\u0555\3\2\2\2\u0557\u055a\3\2\2\2\u0558\u0556\3\2\2\2\u0558"+ 21618 "\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\5X"+ 21619 "-\2\u055c[\3\2\2\2\u055d\u055e\7\7\2\2\u055e\u0565\7J\2\2\u055f\u0564"+ 21620 "\5\n\6\2\u0560\u0564\7\b\2\2\u0561\u0564\7\3\2\2\u0562\u0564\7\6\2\2\u0563"+ 21621 "\u055f\3\2\2\2\u0563\u0560\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0562\3\2"+ 21622 "\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0565\u0566\3\2\2\2\u0566"+ 21623 "\u0568\3\2\2\2\u0567\u0565\3\2\2\2\u0568\u0569\79\2\2\u0569]\3\2\2\2\u056a"+ 21624 "\u056b\7\7\2\2\u056b\u056c\7;\2\2\u056c\u0570\7J\2\2\u056d\u056f\t\2\2"+ 21625 "\2\u056e\u056d\3\2\2\2\u056f\u0572\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u0571"+ 21626 "\3\2\2\2\u0571\u0573\3\2\2\2\u0572\u0570\3\2\2\2\u0573\u0574\79\2\2\u0574"+ 21627 "_\3\2\2\2\u0575\u05a7\5\\/\2\u0576\u05a6\5\f\7\2\u0577\u05a6\5h\65\2\u0578"+ 21628 "\u05a6\5\22\n\2\u0579\u05a6\5\30\r\2\u057a\u05a6\5\36\20\2\u057b\u05a6"+ 21629 "\5$\23\2\u057c\u05a6\5*\26\2\u057d\u05a6\5\60\31\2\u057e\u05a6\5\66\34"+ 21630 "\2\u057f\u05a6\5<\37\2\u0580\u05a6\5B\"\2\u0581\u05a6\5H%\2\u0582\u05a6"+ 21631 "\5N(\2\u0583\u05a6\5T+\2\u0584\u05a6\5Z.\2\u0585\u05a6\5f\64\2\u0586\u05a6"+ 21632 "\5\u00a6T\2\u0587\u05a6\5\u00acW\2\u0588\u05a6\5\u00b2Z\2\u0589\u05a6"+ 21633 "\5\u00b8]\2\u058a\u05a6\5\u00be`\2\u058b\u05a6\5\16\b\2\u058c\u05a6\5"+ 21634 "\24\13\2\u058d\u05a6\5\32\16\2\u058e\u05a6\5 \21\2\u058f\u05a6\5&\24\2"+ 21635 "\u0590\u05a6\5,\27\2\u0591\u05a6\5\62\32\2\u0592\u05a6\58\35\2\u0593\u05a6"+ 21636 "\5> \2\u0594\u05a6\5D#\2\u0595\u05a6\5J&\2\u0596\u05a6\5P)\2\u0597\u05a6"+ 21637 "\5V,\2\u0598\u05a6\5b\62\2\u0599\u05a6\5\u00a2R\2\u059a\u05a6\5\u00a8"+ 21638 "U\2\u059b\u05a6\5\u00aeX\2\u059c\u05a6\5\u00b4[\2\u059d\u05a6\5\u00ba"+ 21639 "^\2\u059e\u059f\6\61\22\2\u059f\u05a6\7\3\2\2\u05a0\u05a6\5\u0094K\2\u05a1"+ 21640 "\u05a6\7\5\2\2\u05a2\u05a6\7\b\2\2\u05a3\u05a6\5\u0096L\2\u05a4\u05a6"+ 21641 "\5\u0092J\2\u05a5\u0576\3\2\2\2\u05a5\u0577\3\2\2\2\u05a5\u0578\3\2\2"+ 21642 "\2\u05a5\u0579\3\2\2\2\u05a5\u057a\3\2\2\2\u05a5\u057b\3\2\2\2\u05a5\u057c"+ 21643 "\3\2\2\2\u05a5\u057d\3\2\2\2\u05a5\u057e\3\2\2\2\u05a5\u057f\3\2\2\2\u05a5"+ 21644 "\u0580\3\2\2\2\u05a5\u0581\3\2\2\2\u05a5\u0582\3\2\2\2\u05a5\u0583\3\2"+ 21645 "\2\2\u05a5\u0584\3\2\2\2\u05a5\u0585\3\2\2\2\u05a5\u0586\3\2\2\2\u05a5"+ 21646 "\u0587\3\2\2\2\u05a5\u0588\3\2\2\2\u05a5\u0589\3\2\2\2\u05a5\u058a\3\2"+ 21647 "\2\2\u05a5\u058b\3\2\2\2\u05a5\u058c\3\2\2\2\u05a5\u058d\3\2\2\2\u05a5"+ 21648 "\u058e\3\2\2\2\u05a5\u058f\3\2\2\2\u05a5\u0590\3\2\2\2\u05a5\u0591\3\2"+ 21649 "\2\2\u05a5\u0592\3\2\2\2\u05a5\u0593\3\2\2\2\u05a5\u0594\3\2\2\2\u05a5"+ 21650 "\u0595\3\2\2\2\u05a5\u0596\3\2\2\2\u05a5\u0597\3\2\2\2\u05a5\u0598\3\2"+ 21651 "\2\2\u05a5\u0599\3\2\2\2\u05a5\u059a\3\2\2\2\u05a5\u059b\3\2\2\2\u05a5"+ 21652 "\u059c\3\2\2\2\u05a5\u059d\3\2\2\2\u05a5\u059e\3\2\2\2\u05a5\u05a0\3\2"+ 21653 "\2\2\u05a5\u05a1\3\2\2\2\u05a5\u05a2\3\2\2\2\u05a5\u05a3\3\2\2\2\u05a5"+ 21654 "\u05a4\3\2\2\2\u05a6\u05a9\3\2\2\2\u05a7\u05a5\3\2\2\2\u05a7\u05a8\3\2"+ 21655 "\2\2\u05a8\u05aa\3\2\2\2\u05a9\u05a7\3\2\2\2\u05aa\u05ab\5^\60\2\u05ab"+ 21656 "a\3\2\2\2\u05ac\u05ad\7\7\2\2\u05ad\u05b4\7K\2\2\u05ae\u05b3\5\n\6\2\u05af"+ 21657 "\u05b3\7\b\2\2\u05b0\u05b3\7\3\2\2\u05b1\u05b3\7\6\2\2\u05b2\u05ae\3\2"+ 21658 "\2\2\u05b2\u05af\3\2\2\2\u05b2\u05b0\3\2\2\2\u05b2\u05b1\3\2\2\2\u05b3"+ 21659 "\u05b6\3\2\2\2\u05b4\u05b2\3\2\2\2\u05b4\u05b5\3\2\2\2\u05b5\u05b7\3\2"+ 21660 "\2\2\u05b6\u05b4\3\2\2\2\u05b7\u05b8\79\2\2\u05b8c\3\2\2\2\u05b9\u05ba"+ 21661 "\7\7\2\2\u05ba\u05bb\7;\2\2\u05bb\u05bf\7K\2\2\u05bc\u05be\t\2\2\2\u05bd"+ 21662 "\u05bc\3\2\2\2\u05be\u05c1\3\2\2\2\u05bf\u05bd\3\2\2\2\u05bf\u05c0\3\2"+ 21663 "\2\2\u05c0\u05c2\3\2\2\2\u05c1\u05bf\3\2\2\2\u05c2\u05c3\79\2\2\u05c3"+ 21664 "e\3\2\2\2\u05c4\u05f6\5b\62\2\u05c5\u05f5\5\f\7\2\u05c6\u05f5\5h\65\2"+ 21665 "\u05c7\u05f5\5\22\n\2\u05c8\u05f5\5\30\r\2\u05c9\u05f5\5\36\20\2\u05ca"+ 21666 "\u05f5\5$\23\2\u05cb\u05f5\5*\26\2\u05cc\u05f5\5\60\31\2\u05cd\u05f5\5"+ 21667 "\66\34\2\u05ce\u05f5\5<\37\2\u05cf\u05f5\5B\"\2\u05d0\u05f5\5H%\2\u05d1"+ 21668 "\u05f5\5N(\2\u05d2\u05f5\5T+\2\u05d3\u05f5\5Z.\2\u05d4\u05f5\5`\61\2\u05d5"+ 21669 "\u05f5\5\u00a6T\2\u05d6\u05f5\5\u00acW\2\u05d7\u05f5\5\u00b2Z\2\u05d8"+ 21670 "\u05f5\5\u00b8]\2\u05d9\u05f5\5\u00be`\2\u05da\u05f5\5\16\b\2\u05db\u05f5"+ 21671 "\5\24\13\2\u05dc\u05f5\5\32\16\2\u05dd\u05f5\5 \21\2\u05de\u05f5\5&\24"+ 21672 "\2\u05df\u05f5\5,\27\2\u05e0\u05f5\5\62\32\2\u05e1\u05f5\58\35\2\u05e2"+ 21673 "\u05f5\5> \2\u05e3\u05f5\5D#\2\u05e4\u05f5\5J&\2\u05e5\u05f5\5P)\2\u05e6"+ 21674 "\u05f5\5V,\2\u05e7\u05f5\5\\/\2\u05e8\u05f5\5\u00a2R\2\u05e9\u05f5\5\u00a8"+ 21675 "U\2\u05ea\u05f5\5\u00aeX\2\u05eb\u05f5\5\u00b4[\2\u05ec\u05f5\5\u00ba"+ 21676 "^\2\u05ed\u05ee\6\64\23\2\u05ee\u05f5\7\3\2\2\u05ef\u05f5\5\u0094K\2\u05f0"+ 21677 "\u05f5\7\5\2\2\u05f1\u05f5\7\b\2\2\u05f2\u05f5\5\u0096L\2\u05f3\u05f5"+ 21678 "\5\u0092J\2\u05f4\u05c5\3\2\2\2\u05f4\u05c6\3\2\2\2\u05f4\u05c7\3\2\2"+ 21679 "\2\u05f4\u05c8\3\2\2\2\u05f4\u05c9\3\2\2\2\u05f4\u05ca\3\2\2\2\u05f4\u05cb"+ 21680 "\3\2\2\2\u05f4\u05cc\3\2\2\2\u05f4\u05cd\3\2\2\2\u05f4\u05ce\3\2\2\2\u05f4"+ 21681 "\u05cf\3\2\2\2\u05f4\u05d0\3\2\2\2\u05f4\u05d1\3\2\2\2\u05f4\u05d2\3\2"+ 21682 "\2\2\u05f4\u05d3\3\2\2\2\u05f4\u05d4\3\2\2\2\u05f4\u05d5\3\2\2\2\u05f4"+ 21683 "\u05d6\3\2\2\2\u05f4\u05d7\3\2\2\2\u05f4\u05d8\3\2\2\2\u05f4\u05d9\3\2"+ 21684 "\2\2\u05f4\u05da\3\2\2\2\u05f4\u05db\3\2\2\2\u05f4\u05dc\3\2\2\2\u05f4"+ 21685 "\u05dd\3\2\2\2\u05f4\u05de\3\2\2\2\u05f4\u05df\3\2\2\2\u05f4\u05e0\3\2"+ 21686 "\2\2\u05f4\u05e1\3\2\2\2\u05f4\u05e2\3\2\2\2\u05f4\u05e3\3\2\2\2\u05f4"+ 21687 "\u05e4\3\2\2\2\u05f4\u05e5\3\2\2\2\u05f4\u05e6\3\2\2\2\u05f4\u05e7\3\2"+ 21688 "\2\2\u05f4\u05e8\3\2\2\2\u05f4\u05e9\3\2\2\2\u05f4\u05ea\3\2\2\2\u05f4"+ 21689 "\u05eb\3\2\2\2\u05f4\u05ec\3\2\2\2\u05f4\u05ed\3\2\2\2\u05f4\u05ef\3\2"+ 21690 "\2\2\u05f4\u05f0\3\2\2\2\u05f4\u05f1\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4"+ 21691 "\u05f3\3\2\2\2\u05f5\u05f8\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f6\u05f7\3\2"+ 21692 "\2\2\u05f7\u05f9\3\2\2\2\u05f8\u05f6\3\2\2\2\u05f9\u05fa\5d\63\2\u05fa"+ 21693 "g\3\2\2\2\u05fb\u0610\5j\66\2\u05fc\u0610\5l\67\2\u05fd\u0610\5n8\2\u05fe"+ 21694 "\u0610\5p9\2\u05ff\u0610\5r:\2\u0600\u0610\5t;\2\u0601\u0610\5v<\2\u0602"+ 21695 "\u0610\5x=\2\u0603\u0610\5z>\2\u0604\u0610\5|?\2\u0605\u0610\5~@\2\u0606"+ 21696 "\u0610\5\u0080A\2\u0607\u0610\5\u0082B\2\u0608\u0610\5\u0084C\2\u0609"+ 21697 "\u0610\5\u0098M\2\u060a\u0610\5\u009aN\2\u060b\u0610\5\u009cO\2\u060c"+ 21698 "\u0610\5\u009eP\2\u060d\u0610\5\u00a0Q\2\u060e\u0610\5\u0086D\2\u060f"+ 21699 "\u05fb\3\2\2\2\u060f\u05fc\3\2\2\2\u060f\u05fd\3\2\2\2\u060f\u05fe\3\2"+ 21700 "\2\2\u060f\u05ff\3\2\2\2\u060f\u0600\3\2\2\2\u060f\u0601\3\2\2\2\u060f"+ 21701 "\u0602\3\2\2\2\u060f\u0603\3\2\2\2\u060f\u0604\3\2\2\2\u060f\u0605\3\2"+ 21702 "\2\2\u060f\u0606\3\2\2\2\u060f\u0607\3\2\2\2\u060f\u0608\3\2\2\2\u060f"+ 21703 "\u0609\3\2\2\2\u060f\u060a\3\2\2\2\u060f\u060b\3\2\2\2\u060f\u060c\3\2"+ 21704 "\2\2\u060f\u060d\3\2\2\2\u060f\u060e\3\2\2\2\u0610i\3\2\2\2\u0611\u0612"+ 21705 "\7\7\2\2\u0612\u0619\t\3\2\2\u0613\u0618\5\n\6\2\u0614\u0618\7\b\2\2\u0615"+ 21706 "\u0618\7\3\2\2\u0616\u0618\7\6\2\2\u0617\u0613\3\2\2\2\u0617\u0614\3\2"+ 21707 "\2\2\u0617\u0615\3\2\2\2\u0617\u0616\3\2\2\2\u0618\u061b\3\2\2\2\u0619"+ 21708 "\u0617\3\2\2\2\u0619\u061a\3\2\2\2\u061a\u061c\3\2\2\2\u061b\u0619\3\2"+ 21709 "\2\2\u061c\u061d\7:\2\2\u061dk\3\2\2\2\u061e\u061f\7\7\2\2\u061f\u0626"+ 21710 "\7L\2\2\u0620\u0625\5\n\6\2\u0621\u0625\7\b\2\2\u0622\u0625\7\3\2\2\u0623"+ 21711 "\u0625\7\6\2\2\u0624\u0620\3\2\2\2\u0624\u0621\3\2\2\2\u0624\u0622\3\2"+ 21712 "\2\2\u0624\u0623\3\2\2\2\u0625\u0628\3\2\2\2\u0626\u0624\3\2\2\2\u0626"+ 21713 "\u0627\3\2\2\2\u0627\u0629\3\2\2\2\u0628\u0626\3\2\2\2\u0629\u062a\t\4"+ 21714 "\2\2\u062am\3\2\2\2\u062b\u062c\7\7\2\2\u062c\u0633\7M\2\2\u062d\u0632"+ 21715 "\5\n\6\2\u062e\u0632\7\b\2\2\u062f\u0632\7\3\2\2\u0630\u0632\7\6\2\2\u0631"+ 21716 "\u062d\3\2\2\2\u0631\u062e\3\2\2\2\u0631\u062f\3\2\2\2\u0631\u0630\3\2"+ 21717 "\2\2\u0632\u0635\3\2\2\2\u0633\u0631\3\2\2\2\u0633\u0634\3\2\2\2\u0634"+ 21718 "\u0636\3\2\2\2\u0635\u0633\3\2\2\2\u0636\u0637\t\4\2\2\u0637o\3\2\2\2"+ 21719 "\u0638\u0639\7\7\2\2\u0639\u0640\7N\2\2\u063a\u063f\5\n\6\2\u063b\u063f"+ 21720 "\7\b\2\2\u063c\u063f\7\3\2\2\u063d\u063f\7\6\2\2\u063e\u063a\3\2\2\2\u063e"+ 21721 "\u063b\3\2\2\2\u063e\u063c\3\2\2\2\u063e\u063d\3\2\2\2\u063f\u0642\3\2"+ 21722 "\2\2\u0640\u063e\3\2\2\2\u0640\u0641\3\2\2\2\u0641\u0643\3\2\2\2\u0642"+ 21723 "\u0640\3\2\2\2\u0643\u0644\t\4\2\2\u0644q\3\2\2\2\u0645\u0646\7\7\2\2"+ 21724 "\u0646\u064d\7O\2\2\u0647\u064c\5\n\6\2\u0648\u064c\7\b\2\2\u0649\u064c"+ 21725 "\7\3\2\2\u064a\u064c\7\6\2\2\u064b\u0647\3\2\2\2\u064b\u0648\3\2\2\2\u064b"+ 21726 "\u0649\3\2\2\2\u064b\u064a\3\2\2\2\u064c\u064f\3\2\2\2\u064d\u064b\3\2"+ 21727 "\2\2\u064d\u064e\3\2\2\2\u064e\u0650\3\2\2\2\u064f\u064d\3\2\2\2\u0650"+ 21728 "\u0651\t\4\2\2\u0651s\3\2\2\2\u0652\u0653\7\7\2\2\u0653\u065a\7P\2\2\u0654"+ 21729 "\u0659\5\n\6\2\u0655\u0659\7\b\2\2\u0656\u0659\7\3\2\2\u0657\u0659\7\6"+ 21730 "\2\2\u0658\u0654\3\2\2\2\u0658\u0655\3\2\2\2\u0658\u0656\3\2\2\2\u0658"+ 21731 "\u0657\3\2\2\2\u0659\u065c\3\2\2\2\u065a\u0658\3\2\2\2\u065a\u065b\3\2"+ 21732 "\2\2\u065b\u065d\3\2\2\2\u065c\u065a\3\2\2\2\u065d\u065e\t\4\2\2\u065e"+ 21733 "u\3\2\2\2\u065f\u0660\7\7\2\2\u0660\u0667\7Q\2\2\u0661\u0666\5\n\6\2\u0662"+ 21734 "\u0666\7\b\2\2\u0663\u0666\7\3\2\2\u0664\u0666\7\6\2\2\u0665\u0661\3\2"+ 21735 "\2\2\u0665\u0662\3\2\2\2\u0665\u0663\3\2\2\2\u0665\u0664\3\2\2\2\u0666"+ 21736 "\u0669\3\2\2\2\u0667\u0665\3\2\2\2\u0667\u0668\3\2\2\2\u0668\u066a\3\2"+ 21737 "\2\2\u0669\u0667\3\2\2\2\u066a\u066b\t\4\2\2\u066bw\3\2\2\2\u066c\u066d"+ 21738 "\7\7\2\2\u066d\u0674\7R\2\2\u066e\u0673\5\n\6\2\u066f\u0673\7\b\2\2\u0670"+ 21739 "\u0673\7\3\2\2\u0671\u0673\7\6\2\2\u0672\u066e\3\2\2\2\u0672\u066f\3\2"+ 21740 "\2\2\u0672\u0670\3\2\2\2\u0672\u0671\3\2\2\2\u0673\u0676\3\2\2\2\u0674"+ 21741 "\u0672\3\2\2\2\u0674\u0675\3\2\2\2\u0675\u0677\3\2\2\2\u0676\u0674\3\2"+ 21742 "\2\2\u0677\u0678\t\4\2\2\u0678y\3\2\2\2\u0679\u067a\7\7\2\2\u067a\u0681"+ 21743 "\7S\2\2\u067b\u0680\5\n\6\2\u067c\u0680\7\b\2\2\u067d\u0680\7\3\2\2\u067e"+ 21744 "\u0680\7\6\2\2\u067f\u067b\3\2\2\2\u067f\u067c\3\2\2\2\u067f\u067d\3\2"+ 21745 "\2\2\u067f\u067e\3\2\2\2\u0680\u0683\3\2\2\2\u0681\u067f\3\2\2\2\u0681"+ 21746 "\u0682\3\2\2\2\u0682\u0684\3\2\2\2\u0683\u0681\3\2\2\2\u0684\u0685\t\4"+ 21747 "\2\2\u0685{\3\2\2\2\u0686\u0687\7\7\2\2\u0687\u068e\7T\2\2\u0688\u068d"+ 21748 "\5\n\6\2\u0689\u068d\7\b\2\2\u068a\u068d\7\3\2\2\u068b\u068d\7\6\2\2\u068c"+ 21749 "\u0688\3\2\2\2\u068c\u0689\3\2\2\2\u068c\u068a\3\2\2\2\u068c\u068b\3\2"+ 21750 "\2\2\u068d\u0690\3\2\2\2\u068e\u068c\3\2\2\2\u068e\u068f\3\2\2\2\u068f"+ 21751 "\u0691\3\2\2\2\u0690\u068e\3\2\2\2\u0691\u0692\t\4\2\2\u0692}\3\2\2\2"+ 21752 "\u0693\u0694\7\7\2\2\u0694\u069b\7U\2\2\u0695\u069a\5\n\6\2\u0696\u069a"+ 21753 "\7\b\2\2\u0697\u069a\7\3\2\2\u0698\u069a\7\6\2\2\u0699\u0695\3\2\2\2\u0699"+ 21754 "\u0696\3\2\2\2\u0699\u0697\3\2\2\2\u0699\u0698\3\2\2\2\u069a\u069d\3\2"+ 21755 "\2\2\u069b\u0699\3\2\2\2\u069b\u069c\3\2\2\2\u069c\u069e\3\2\2\2\u069d"+ 21756 "\u069b\3\2\2\2\u069e\u069f\t\4\2\2\u069f\177\3\2\2\2\u06a0\u06a1\7\7\2"+ 21757 "\2\u06a1\u06a8\7V\2\2\u06a2\u06a7\5\n\6\2\u06a3\u06a7\7\b\2\2\u06a4\u06a7"+ 21758 "\7\3\2\2\u06a5\u06a7\7\6\2\2\u06a6\u06a2\3\2\2\2\u06a6\u06a3\3\2\2\2\u06a6"+ 21759 "\u06a4\3\2\2\2\u06a6\u06a5\3\2\2\2\u06a7\u06aa\3\2\2\2\u06a8\u06a6\3\2"+ 21760 "\2\2\u06a8\u06a9\3\2\2\2\u06a9\u06ab\3\2\2\2\u06aa\u06a8\3\2\2\2\u06ab"+ 21761 "\u06ac\t\4\2\2\u06ac\u0081\3\2\2\2\u06ad\u06ae\7\7\2\2\u06ae\u06b5\7W"+ 21762 "\2\2\u06af\u06b4\5\n\6\2\u06b0\u06b4\7\b\2\2\u06b1\u06b4\7\3\2\2\u06b2"+ 21763 "\u06b4\7\6\2\2\u06b3\u06af\3\2\2\2\u06b3\u06b0\3\2\2\2\u06b3\u06b1\3\2"+ 21764 "\2\2\u06b3\u06b2\3\2\2\2\u06b4\u06b7\3\2\2\2\u06b5\u06b3\3\2\2\2\u06b5"+ 21765 "\u06b6\3\2\2\2\u06b6\u06b8\3\2\2\2\u06b7\u06b5\3\2\2\2\u06b8\u06b9\t\4"+ 21766 "\2\2\u06b9\u0083\3\2\2\2\u06ba\u06bb\7\7\2\2\u06bb\u06c2\7X\2\2\u06bc"+ 21767 "\u06c1\5\n\6\2\u06bd\u06c1\7\b\2\2\u06be\u06c1\7\3\2\2\u06bf\u06c1\7\6"+ 21768 "\2\2\u06c0\u06bc\3\2\2\2\u06c0\u06bd\3\2\2\2\u06c0\u06be\3\2\2\2\u06c0"+ 21769 "\u06bf\3\2\2\2\u06c1\u06c4\3\2\2\2\u06c2\u06c0\3\2\2\2\u06c2\u06c3\3\2"+ 21770 "\2\2\u06c3\u06c5\3\2\2\2\u06c4\u06c2\3\2\2\2\u06c5\u06c6\t\4\2\2\u06c6"+ 21771 "\u0085\3\2\2\2\u06c7\u06c8\7\7\2\2\u06c8\u06c9\7;\2\2\u06c9\u06ca\5\u0088"+ 21772 "E\2\u06ca\u06cb\79\2\2\u06cb\u06cc\bD\1\2\u06cc\u0087\3\2\2\2\u06cd\u06ce"+ 21773 "\t\5\2\2\u06ce\u0089\3\2\2\2\u06cf\u06d0\6F\24\2\u06d0\u06d8\7\3\2\2\u06d1"+ 21774 "\u06d8\5\u0094K\2\u06d2\u06d8\7\5\2\2\u06d3\u06d8\7\b\2\2\u06d4\u06d8"+ 21775 "\5\u0096L\2\u06d5\u06d8\5\u0092J\2\u06d6\u06d8\5\4\3\2\u06d7\u06cf\3\2"+ 21776 "\2\2\u06d7\u06d1\3\2\2\2\u06d7\u06d2\3\2\2\2\u06d7\u06d3\3\2\2\2\u06d7"+ 21777 "\u06d4\3\2\2\2\u06d7\u06d5\3\2\2\2\u06d7\u06d6\3\2\2\2\u06d8\u06d9\3\2"+ 21778 "\2\2\u06d9\u06d7\3\2\2\2\u06d9\u06da\3\2\2\2\u06da\u008b\3\2\2\2\u06db"+ 21779 "\u06e1\7\36\2\2\u06dc\u06dd\7 \2\2\u06dd\u06df\7#\2\2\u06de\u06e0\5\u008e"+ 21780 "H\2\u06df\u06de\3\2\2\2\u06df\u06e0\3\2\2\2\u06e0\u06e2\3\2\2\2\u06e1"+ 21781 "\u06dc\3\2\2\2\u06e1\u06e2\3\2\2\2\u06e2\u06e9\3\2\2\2\u06e3\u06e4\7 "+ 21782 "\2\2\u06e4\u06e6\7#\2\2\u06e5\u06e7\5\u008eH\2\u06e6\u06e5\3\2\2\2\u06e6"+ 21783 "\u06e7\3\2\2\2\u06e7\u06e9\3\2\2\2\u06e8\u06db\3\2\2\2\u06e8\u06e3\3\2"+ 21784 "\2\2\u06e9\u008d\3\2\2\2\u06ea\u06ee\7$\2\2\u06eb\u06ed\t\6\2\2\u06ec"+ 21785 "\u06eb\3\2\2\2\u06ed\u06f0\3\2\2\2\u06ee\u06ec\3\2\2\2\u06ee\u06ef\3\2"+ 21786 "\2\2\u06ef\u06f1\3\2\2\2\u06f0\u06ee\3\2\2\2\u06f1\u06f2\7%\2\2\u06f2"+ 21787 "\u008f\3\2\2\2\u06f3\u06f5\7\t\2\2\u06f4\u06f6\t\7\2\2\u06f5\u06f4\3\2"+ 21788 "\2\2\u06f6\u06f7\3\2\2\2\u06f7\u06f5\3\2\2\2\u06f7\u06f8\3\2\2\2\u06f8"+ 21789 "\u06f9\3\2\2\2\u06f9\u07b7\5\u008aF\2\u06fa\u06fe\7\n\2\2\u06fb\u06fd"+ 21790 "\t\7\2\2\u06fc\u06fb\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3\2\2\2\u06fe"+ 21791 "\u06ff\3\2\2\2\u06ff\u0703\3\2\2\2\u0700\u06fe\3\2\2\2\u0701\u0702\t\7"+ 21792 "\2\2\u0702\u0704\5\u008aF\2\u0703\u0701\3\2\2\2\u0703\u0704\3\2\2\2\u0704"+ 21793 "\u07b7\3\2\2\2\u0705\u070a\7\13\2\2\u0706\u070b\7\6\2\2\u0707\u070b\7"+ 21794 "\b\2\2\u0708\u0709\6I\25\2\u0709\u070b\7\3\2\2\u070a\u0706\3\2\2\2\u070a"+ 21795 "\u0707\3\2\2\2\u070a\u0708\3\2\2\2\u070b\u070c\3\2\2\2\u070c\u070a\3\2"+ 21796 "\2\2\u070c\u070d\3\2\2\2\u070d\u070e\3\2\2\2\u070e\u0712\7-\2\2\u070f"+ 21797 "\u0711\t\7\2\2\u0710\u070f\3\2\2\2\u0711\u0714\3\2\2\2\u0712\u0710\3\2"+ 21798 "\2\2\u0712\u0713\3\2\2\2\u0713\u0717\3\2\2\2\u0714\u0712\3\2\2\2\u0715"+ 21799 "\u0716\t\7\2\2\u0716\u0718\5\u008aF\2\u0717\u0715\3\2\2\2\u0717\u0718"+ 21800 "\3\2\2\2\u0718\u07b7\3\2\2\2\u0719\u071e\7\f\2\2\u071a\u071f\7\6\2\2\u071b"+ 21801 "\u071f\7\b\2\2\u071c\u071d\6I\26\2\u071d\u071f\7\3\2\2\u071e\u071a\3\2"+ 21802 "\2\2\u071e\u071b\3\2\2\2\u071e\u071c\3\2\2\2\u071f\u0720\3\2\2\2\u0720"+ 21803 "\u071e\3\2\2\2\u0720\u0721\3\2\2\2\u0721\u0722\3\2\2\2\u0722\u0726\7\33"+ 21804 "\2\2\u0723\u0725\t\7\2\2\u0724\u0723\3\2\2\2\u0725\u0728\3\2\2\2\u0726"+ 21805 "\u0724\3\2\2\2\u0726\u0727\3\2\2\2\u0727\u072b\3\2\2\2\u0728\u0726\3\2"+ 21806 "\2\2\u0729\u072a\t\7\2\2\u072a\u072c\5\u008aF\2\u072b\u0729\3\2\2\2\u072b"+ 21807 "\u072c\3\2\2\2\u072c\u07b7\3\2\2\2\u072d\u072f\7\r\2\2\u072e\u0730\t\7"+ 21808 "\2\2\u072f\u072e\3\2\2\2\u0730\u0731\3\2\2\2\u0731\u072f\3\2\2\2\u0731"+ 21809 "\u0732\3\2\2\2\u0732\u0733\3\2\2\2\u0733\u07b7\5\u008aF\2\u0734\u0739"+ 21810 "\7\16\2\2\u0735\u073a\7\6\2\2\u0736\u073a\7\b\2\2\u0737\u0738\6I\27\2"+ 21811 "\u0738\u073a\7\3\2\2\u0739\u0735\3\2\2\2\u0739\u0736\3\2\2\2\u0739\u0737"+ 21812 "\3\2\2\2\u073a\u073b\3\2\2\2\u073b\u0739\3\2\2\2\u073b\u073c\3\2\2\2\u073c"+ 21813 "\u0740\3\2\2\2\u073d\u0741\5\u008cG\2\u073e\u0741\7\35\2\2\u073f\u0741"+ 21814 "\5\4\3\2\u0740\u073d\3\2\2\2\u0740\u073e\3\2\2\2\u0740\u073f\3\2\2\2\u0741"+ 21815 "\u0745\3\2\2\2\u0742\u0744\t\7\2\2\u0743\u0742\3\2\2\2\u0744\u0747\3\2"+ 21816 "\2\2\u0745\u0743\3\2\2\2\u0745\u0746\3\2\2\2\u0746\u074a\3\2\2\2\u0747"+ 21817 "\u0745\3\2\2\2\u0748\u0749\t\7\2\2\u0749\u074b\5\u008aF\2\u074a\u0748"+ 21818 "\3\2\2\2\u074a\u074b\3\2\2\2\u074b\u07b7\3\2\2\2\u074c\u0750\7\17\2\2"+ 21819 "\u074d\u074f\t\7\2\2\u074e\u074d\3\2\2\2\u074f\u0752\3\2\2\2\u0750\u074e"+ 21820 "\3\2\2\2\u0750\u0751\3\2\2\2\u0751"; 21821 private static final String _serializedATNSegment1 = 21822 "\u0757\3\2\2\2\u0752\u0750\3\2\2\2\u0753\u0754\t\7\2\2\u0754\u0758\5\u008a"+ 21823 "F\2\u0755\u0758\7\30\2\2\u0756\u0758\7\31\2\2\u0757\u0753\3\2\2\2\u0757"+ 21824 "\u0755\3\2\2\2\u0757\u0756\3\2\2\2\u0757\u0758\3\2\2\2\u0758\u075c\3\2"+ 21825 "\2\2\u0759\u075b\t\7\2\2\u075a\u0759\3\2\2\2\u075b\u075e\3\2\2\2\u075c"+ 21826 "\u075a\3\2\2\2\u075c\u075d\3\2\2\2\u075d\u07b7\3\2\2\2\u075e\u075c\3\2"+ 21827 "\2\2\u075f\u0763\7\21\2\2\u0760\u0762\t\7\2\2\u0761\u0760\3\2\2\2\u0762"+ 21828 "\u0765\3\2\2\2\u0763\u0761\3\2\2\2\u0763\u0764\3\2\2\2\u0764\u0768\3\2"+ 21829 "\2\2\u0765\u0763\3\2\2\2\u0766\u0767\t\7\2\2\u0767\u0769\5\u008aF\2\u0768"+ 21830 "\u0766\3\2\2\2\u0768\u0769\3\2\2\2\u0769\u07b7\3\2\2\2\u076a\u076e\7\20"+ 21831 "\2\2\u076b\u076d\t\7\2\2\u076c\u076b\3\2\2\2\u076d\u0770\3\2\2\2\u076e"+ 21832 "\u076c\3\2\2\2\u076e\u076f\3\2\2\2\u076f\u0773\3\2\2\2\u0770\u076e\3\2"+ 21833 "\2\2\u0771\u0772\t\7\2\2\u0772\u0774\7)\2\2\u0773\u0771\3\2\2\2\u0773"+ 21834 "\u0774\3\2\2\2\u0774\u0778\3\2\2\2\u0775\u0777\t\7\2\2\u0776\u0775\3\2"+ 21835 "\2\2\u0777\u077a\3\2\2\2\u0778\u0776\3\2\2\2\u0778\u0779\3\2\2\2\u0779"+ 21836 "\u077d\3\2\2\2\u077a\u0778\3\2\2\2\u077b\u077c\t\7\2\2\u077c\u077e\7+"+ 21837 "\2\2\u077d\u077b\3\2\2\2\u077d\u077e\3\2\2\2\u077e\u0782\3\2\2\2\u077f"+ 21838 "\u0781\t\7\2\2\u0780\u077f\3\2\2\2\u0781\u0784\3\2\2\2\u0782\u0780\3\2"+ 21839 "\2\2\u0782\u0783\3\2\2\2\u0783\u0787\3\2\2\2\u0784\u0782\3\2\2\2\u0785"+ 21840 "\u0786\t\7\2\2\u0786\u0788\5\u008aF\2\u0787\u0785\3\2\2\2\u0787\u0788"+ 21841 "\3\2\2\2\u0788\u07b7\3\2\2\2\u0789\u078b\7\22\2\2\u078a\u078c\t\7\2\2"+ 21842 "\u078b\u078a\3\2\2\2\u078c\u078d\3\2\2\2\u078d\u078b\3\2\2\2\u078d\u078e"+ 21843 "\3\2\2\2\u078e\u078f\3\2\2\2\u078f\u07b7\5\u008aF\2\u0790\u0795\7\23\2"+ 21844 "\2\u0791\u0796\7\6\2\2\u0792\u0796\7\b\2\2\u0793\u0794\6I\30\2\u0794\u0796"+ 21845 "\7\3\2\2\u0795\u0791\3\2\2\2\u0795\u0792\3\2\2\2\u0795\u0793\3\2\2\2\u0796"+ 21846 "\u0797\3\2\2\2\u0797\u0795\3\2\2\2\u0797\u0798\3\2\2\2\u0798\u0799\3\2"+ 21847 "\2\2\u0799\u079d\7-\2\2\u079a\u079c\t\7\2\2\u079b\u079a\3\2\2\2\u079c"+ 21848 "\u079f\3\2\2\2\u079d\u079b\3\2\2\2\u079d\u079e\3\2\2\2\u079e\u07a2\3\2"+ 21849 "\2\2\u079f\u079d\3\2\2\2\u07a0\u07a1\t\7\2\2\u07a1\u07a3\5\u008aF\2\u07a2"+ 21850 "\u07a0\3\2\2\2\u07a2\u07a3\3\2\2\2\u07a3\u07b7\3\2\2\2\u07a4\u07a6\7\24"+ 21851 "\2\2\u07a5\u07a7\t\7\2\2\u07a6\u07a5\3\2\2\2\u07a7\u07a8\3\2\2\2\u07a8"+ 21852 "\u07a6\3\2\2\2\u07a8\u07a9\3\2\2\2\u07a9\u07aa\3\2\2\2\u07aa\u07b7\5\u008a"+ 21853 "F\2\u07ab\u07af\7\27\2\2\u07ac\u07ae\t\7\2\2\u07ad\u07ac\3\2\2\2\u07ae"+ 21854 "\u07b1\3\2\2\2\u07af\u07ad\3\2\2\2\u07af\u07b0\3\2\2\2\u07b0\u07b4\3\2"+ 21855 "\2\2\u07b1\u07af\3\2\2\2\u07b2\u07b3\t\7\2\2\u07b3\u07b5\5\u008aF\2\u07b4"+ 21856 "\u07b2\3\2\2\2\u07b4\u07b5\3\2\2\2\u07b5\u07b7\3\2\2\2\u07b6\u06f3\3\2"+ 21857 "\2\2\u07b6\u06fa\3\2\2\2\u07b6\u0705\3\2\2\2\u07b6\u0719\3\2\2\2\u07b6"+ 21858 "\u072d\3\2\2\2\u07b6\u0734\3\2\2\2\u07b6\u074c\3\2\2\2\u07b6\u075f\3\2"+ 21859 "\2\2\u07b6\u076a\3\2\2\2\u07b6\u0789\3\2\2\2\u07b6\u0790\3\2\2\2\u07b6"+ 21860 "\u07a4\3\2\2\2\u07b6\u07ab\3\2\2\2\u07b7\u0091\3\2\2\2\u07b8\u0813\7\25"+ 21861 "\2\2\u07b9\u07c0\7/\2\2\u07ba\u07bf\7\6\2\2\u07bb\u07bf\7\b\2\2\u07bc"+ 21862 "\u07bf\7\3\2\2\u07bd\u07bf\5\u0096L\2\u07be\u07ba\3\2\2\2\u07be\u07bb"+ 21863 "\3\2\2\2\u07be\u07bc\3\2\2\2\u07be\u07bd\3\2\2\2\u07bf\u07c2\3\2\2\2\u07c0"+ 21864 "\u07be\3\2\2\2\u07c0\u07c1\3\2\2\2\u07c1\u0814\3\2\2\2\u07c2\u07c0\3\2"+ 21865 "\2\2\u07c3\u07c7\7\60\2\2\u07c4\u07c6\t\2\2\2\u07c5\u07c4\3\2\2\2\u07c6"+ 21866 "\u07c9\3\2\2\2\u07c7\u07c5\3\2\2\2\u07c7\u07c8\3\2\2\2\u07c8\u0814\3\2"+ 21867 "\2\2\u07c9\u07c7\3\2\2\2\u07ca\u07ce\7\61\2\2\u07cb\u07cd\t\2\2\2\u07cc"+ 21868 "\u07cb\3\2\2\2\u07cd\u07d0\3\2\2\2\u07ce\u07cc\3\2\2\2\u07ce\u07cf\3\2"+ 21869 "\2\2\u07cf\u0814\3\2\2\2\u07d0\u07ce\3\2\2\2\u07d1\u07d3\7\62\2\2\u07d2"+ 21870 "\u07d4\t\2\2\2\u07d3\u07d2\3\2\2\2\u07d4\u07d5\3\2\2\2\u07d5\u07d3\3\2"+ 21871 "\2\2\u07d5\u07d6\3\2\2\2\u07d6\u07d7\3\2\2\2\u07d7\u07db\5\u008cG\2\u07d8"+ 21872 "\u07da\t\7\2\2\u07d9\u07d8\3\2\2\2\u07da\u07dd\3\2\2\2\u07db\u07d9\3\2"+ 21873 "\2\2\u07db\u07dc\3\2\2\2\u07dc\u07e0\3\2\2\2\u07dd\u07db\3\2\2\2\u07de"+ 21874 "\u07df\t\7\2\2\u07df\u07e1\5\u008aF\2\u07e0\u07de\3\2\2\2\u07e0\u07e1"+ 21875 "\3\2\2\2\u07e1\u0814\3\2\2\2\u07e2\u07e4\7\63\2\2\u07e3\u07e5\t\2\2\2"+ 21876 "\u07e4\u07e3\3\2\2\2\u07e5\u07e6\3\2\2\2\u07e6\u07e4\3\2\2\2\u07e6\u07e7"+ 21877 "\3\2\2\2\u07e7\u07e8\3\2\2\2\u07e8\u07ec\5\u008cG\2\u07e9\u07eb\t\7\2"+ 21878 "\2\u07ea\u07e9\3\2\2\2\u07eb\u07ee\3\2\2\2\u07ec\u07ea\3\2\2\2\u07ec\u07ed"+ 21879 "\3\2\2\2\u07ed\u07f1\3\2\2\2\u07ee\u07ec\3\2\2\2\u07ef\u07f0\t\7\2\2\u07f0"+ 21880 "\u07f2\5\u008aF\2\u07f1\u07ef\3\2\2\2\u07f1\u07f2\3\2\2\2\u07f2\u0814"+ 21881 "\3\2\2\2\u07f3\u07fa\7\64\2\2\u07f4\u07f9\7\6\2\2\u07f5\u07f9\7\b\2\2"+ 21882 "\u07f6\u07f9\7\3\2\2\u07f7\u07f9\5\u0096L\2\u07f8\u07f4\3\2\2\2\u07f8"+ 21883 "\u07f5\3\2\2\2\u07f8\u07f6\3\2\2\2\u07f8\u07f7\3\2\2\2\u07f9\u07fc\3\2"+ 21884 "\2\2\u07fa\u07f8\3\2\2\2\u07fa\u07fb\3\2\2\2\u07fb\u0814\3\2\2\2\u07fc"+ 21885 "\u07fa\3\2\2\2\u07fd\u0801\7\65\2\2\u07fe\u0800\t\2\2\2\u07ff\u07fe\3"+ 21886 "\2\2\2\u0800\u0803\3\2\2\2\u0801\u07ff\3\2\2\2\u0801\u0802\3\2\2\2\u0802"+ 21887 "\u0806\3\2\2\2\u0803\u0801\3\2\2\2\u0804\u0805\t\7\2\2\u0805\u0807\5\u008c"+ 21888 "G\2\u0806\u0804\3\2\2\2\u0806\u0807\3\2\2\2\u0807\u0814\3\2\2\2\u0808"+ 21889 "\u080c\7\27\2\2\u0809\u080b\t\2\2\2\u080a\u0809\3\2\2\2\u080b\u080e\3"+ 21890 "\2\2\2\u080c\u080a\3\2\2\2\u080c\u080d\3\2\2\2\u080d\u0811\3\2\2\2\u080e"+ 21891 "\u080c\3\2\2\2\u080f\u0810\t\7\2\2\u0810\u0812\5\u008aF\2\u0811\u080f"+ 21892 "\3\2\2\2\u0811\u0812\3\2\2\2\u0812\u0814\3\2\2\2\u0813\u07b9\3\2\2\2\u0813"+ 21893 "\u07c3\3\2\2\2\u0813\u07ca\3\2\2\2\u0813\u07d1\3\2\2\2\u0813\u07e2\3\2"+ 21894 "\2\2\u0813\u07f3\3\2\2\2\u0813\u07fd\3\2\2\2\u0813\u0808\3\2\2\2\u0814"+ 21895 "\u0815\3\2\2\2\u0815\u0816\7\26\2\2\u0816\u0093\3\2\2\2\u0817\u081d\7"+ 21896 "\4\2\2\u0818\u081c\5\u0096L\2\u0819\u081c\7\b\2\2\u081a\u081c\7\3\2\2"+ 21897 "\u081b\u0818\3\2\2\2\u081b\u0819\3\2\2\2\u081b\u081a\3\2\2\2\u081c\u081f"+ 21898 "\3\2\2\2\u081d\u081b\3\2\2\2\u081d\u081e\3\2\2\2\u081e\u0820\3\2\2\2\u081f"+ 21899 "\u081d\3\2\2\2\u0820\u0821\7]\2\2\u0821\u0095\3\2\2\2\u0822\u0823\t\b"+ 21900 "\2\2\u0823\u0825\bL\1\2\u0824\u0822\3\2\2\2\u0825\u0826\3\2\2\2\u0826"+ 21901 "\u0824\3\2\2\2\u0826\u0827\3\2\2\2\u0827\u0097\3\2\2\2\u0828\u0829\7\7"+ 21902 "\2\2\u0829\u0830\7Y\2\2\u082a\u082f\5\n\6\2\u082b\u082f\7\b\2\2\u082c"+ 21903 "\u082f\7\3\2\2\u082d\u082f\7\6\2\2\u082e\u082a\3\2\2\2\u082e\u082b\3\2"+ 21904 "\2\2\u082e\u082c\3\2\2\2\u082e\u082d\3\2\2\2\u082f\u0832\3\2\2\2\u0830"+ 21905 "\u082e\3\2\2\2\u0830\u0831\3\2\2\2\u0831\u0833\3\2\2\2\u0832\u0830\3\2"+ 21906 "\2\2\u0833\u0834\t\4\2\2\u0834\u0099\3\2\2\2\u0835\u0836\7\7\2\2\u0836"+ 21907 "\u083d\7Z\2\2\u0837\u083c\5\n\6\2\u0838\u083c\7\b\2\2\u0839\u083c\7\3"+ 21908 "\2\2\u083a\u083c\7\6\2\2\u083b\u0837\3\2\2\2\u083b\u0838\3\2\2\2\u083b"+ 21909 "\u0839\3\2\2\2\u083b\u083a\3\2\2\2\u083c\u083f\3\2\2\2\u083d\u083b\3\2"+ 21910 "\2\2\u083d\u083e\3\2\2\2\u083e\u0840\3\2\2\2\u083f\u083d\3\2\2\2\u0840"+ 21911 "\u0841\t\4\2\2\u0841\u009b\3\2\2\2\u0842\u0843\7\7\2\2\u0843\u084a\7^"+ 21912 "\2\2\u0844\u0849\5\n\6\2\u0845\u0849\7\b\2\2\u0846\u0849\7\3\2\2\u0847"+ 21913 "\u0849\7\6\2\2\u0848\u0844\3\2\2\2\u0848\u0845\3\2\2\2\u0848\u0846\3\2"+ 21914 "\2\2\u0848\u0847\3\2\2\2\u0849\u084c\3\2\2\2\u084a\u0848\3\2\2\2\u084a"+ 21915 "\u084b\3\2\2\2\u084b\u084d\3\2\2\2\u084c\u084a\3\2\2\2\u084d\u084e\t\4"+ 21916 "\2\2\u084e\u009d\3\2\2\2\u084f\u0850\7\7\2\2\u0850\u0857\7_\2\2\u0851"+ 21917 "\u0856\5\n\6\2\u0852\u0856\7\b\2\2\u0853\u0856\7\3\2\2\u0854\u0856\7\6"+ 21918 "\2\2\u0855\u0851\3\2\2\2\u0855\u0852\3\2\2\2\u0855\u0853\3\2\2\2\u0855"+ 21919 "\u0854\3\2\2\2\u0856\u0859\3\2\2\2\u0857\u0855\3\2\2\2\u0857\u0858\3\2"+ 21920 "\2\2\u0858\u085a\3\2\2\2\u0859\u0857\3\2\2\2\u085a\u085b\t\4\2\2\u085b"+ 21921 "\u009f\3\2\2\2\u085c\u085d\7\7\2\2\u085d\u0864\7`\2\2\u085e\u0863\5\n"+ 21922 "\6\2\u085f\u0863\7\b\2\2\u0860\u0863\7\3\2\2\u0861\u0863\7\6\2\2\u0862"+ 21923 "\u085e\3\2\2\2\u0862\u085f\3\2\2\2\u0862\u0860\3\2\2\2\u0862\u0861\3\2"+ 21924 "\2\2\u0863\u0866\3\2\2\2\u0864\u0862\3\2\2\2\u0864\u0865\3\2\2\2\u0865"+ 21925 "\u0867\3\2\2\2\u0866\u0864\3\2\2\2\u0867\u0868\t\4\2\2\u0868\u00a1\3\2"+ 21926 "\2\2\u0869\u086a\7\7\2\2\u086a\u0871\7a\2\2\u086b\u0870\5\n\6\2\u086c"+ 21927 "\u0870\7\b\2\2\u086d\u0870\7\3\2\2\u086e\u0870\7\6\2\2\u086f\u086b\3\2"+ 21928 "\2\2\u086f\u086c\3\2\2\2\u086f\u086d\3\2\2\2\u086f\u086e\3\2\2\2\u0870"+ 21929 "\u0873\3\2\2\2\u0871\u086f\3\2\2\2\u0871\u0872\3\2\2\2\u0872\u0874\3\2"+ 21930 "\2\2\u0873\u0871\3\2\2\2\u0874\u0875\79\2\2\u0875\u00a3\3\2\2\2\u0876"+ 21931 "\u0877\7\7\2\2\u0877\u0878\7;\2\2\u0878\u087c\7a\2\2\u0879\u087b\t\2\2"+ 21932 "\2\u087a\u0879\3\2\2\2\u087b\u087e\3\2\2\2\u087c\u087a\3\2\2\2\u087c\u087d"+ 21933 "\3\2\2\2\u087d\u087f\3\2\2\2\u087e\u087c\3\2\2\2\u087f\u0880\79\2\2\u0880"+ 21934 "\u00a5\3\2\2\2\u0881\u08a9\5\u00a2R\2\u0882\u08a8\5\f\7\2\u0883\u08a8"+ 21935 "\5h\65\2\u0884\u08a8\5\22\n\2\u0885\u08a8\5\30\r\2\u0886\u08a8\5\36\20"+ 21936 "\2\u0887\u08a8\5$\23\2\u0888\u08a8\5*\26\2\u0889\u08a8\5\60\31\2\u088a"+ 21937 "\u08a8\5\66\34\2\u088b\u08a8\5<\37\2\u088c\u08a8\5B\"\2\u088d\u08a8\5"+ 21938 "H%\2\u088e\u08a8\5N(\2\u088f\u08a8\5T+\2\u0890\u08a8\5Z.\2\u0891\u08a8"+ 21939 "\5`\61\2\u0892\u08a8\5\16\b\2\u0893\u08a8\5\24\13\2\u0894\u08a8\5\32\16"+ 21940 "\2\u0895\u08a8\5 \21\2\u0896\u08a8\5&\24\2\u0897\u08a8\5,\27\2\u0898\u08a8"+ 21941 "\5\62\32\2\u0899\u08a8\58\35\2\u089a\u08a8\5> \2\u089b\u08a8\5D#\2\u089c"+ 21942 "\u08a8\5J&\2\u089d\u08a8\5P)\2\u089e\u08a8\5V,\2\u089f\u08a8\5\\/\2\u08a0"+ 21943 "\u08a1\6T\31\2\u08a1\u08a8\7\3\2\2\u08a2\u08a8\5\u0094K\2\u08a3\u08a8"+ 21944 "\7\5\2\2\u08a4\u08a8\7\b\2\2\u08a5\u08a8\5\u0096L\2\u08a6\u08a8\5\u0092"+ 21945 "J\2\u08a7\u0882\3\2\2\2\u08a7\u0883\3\2\2\2\u08a7\u0884\3\2\2\2\u08a7"+ 21946 "\u0885\3\2\2\2\u08a7\u0886\3\2\2\2\u08a7\u0887\3\2\2\2\u08a7\u0888\3\2"+ 21947 "\2\2\u08a7\u0889\3\2\2\2\u08a7\u088a\3\2\2\2\u08a7\u088b\3\2\2\2\u08a7"+ 21948 "\u088c\3\2\2\2\u08a7\u088d\3\2\2\2\u08a7\u088e\3\2\2\2\u08a7\u088f\3\2"+ 21949 "\2\2\u08a7\u0890\3\2\2\2\u08a7\u0891\3\2\2\2\u08a7\u0892\3\2\2\2\u08a7"+ 21950 "\u0893\3\2\2\2\u08a7\u0894\3\2\2\2\u08a7\u0895\3\2\2\2\u08a7\u0896\3\2"+ 21951 "\2\2\u08a7\u0897\3\2\2\2\u08a7\u0898\3\2\2\2\u08a7\u0899\3\2\2\2\u08a7"+ 21952 "\u089a\3\2\2\2\u08a7\u089b\3\2\2\2\u08a7\u089c\3\2\2\2\u08a7\u089d\3\2"+ 21953 "\2\2\u08a7\u089e\3\2\2\2\u08a7\u089f\3\2\2\2\u08a7\u08a0\3\2\2\2\u08a7"+ 21954 "\u08a2\3\2\2\2\u08a7\u08a3\3\2\2\2\u08a7\u08a4\3\2\2\2\u08a7\u08a5\3\2"+ 21955 "\2\2\u08a7\u08a6\3\2\2\2\u08a8\u08ab\3\2\2\2\u08a9\u08a7\3\2\2\2\u08a9"+ 21956 "\u08aa\3\2\2\2\u08aa\u08ac\3\2\2\2\u08ab\u08a9\3\2\2\2\u08ac\u08ad\5\u00a4"+ 21957 "S\2\u08ad\u00a7\3\2\2\2\u08ae\u08af\7\7\2\2\u08af\u08b6\7b\2\2\u08b0\u08b5"+ 21958 "\5\n\6\2\u08b1\u08b5\7\b\2\2\u08b2\u08b5\7\3\2\2\u08b3\u08b5\7\6\2\2\u08b4"+ 21959 "\u08b0\3\2\2\2\u08b4\u08b1\3\2\2\2\u08b4\u08b2\3\2\2\2\u08b4\u08b3\3\2"+ 21960 "\2\2\u08b5\u08b8\3\2\2\2\u08b6\u08b4\3\2\2\2\u08b6\u08b7\3\2\2\2\u08b7"+ 21961 "\u08b9\3\2\2\2\u08b8\u08b6\3\2\2\2\u08b9\u08ba\79\2\2\u08ba\u00a9\3\2"+ 21962 "\2\2\u08bb\u08bc\7\7\2\2\u08bc\u08bd\7;\2\2\u08bd\u08c1\7b\2\2\u08be\u08c0"+ 21963 "\t\2\2\2\u08bf\u08be\3\2\2\2\u08c0\u08c3\3\2\2\2\u08c1\u08bf\3\2\2\2\u08c1"+ 21964 "\u08c2\3\2\2\2\u08c2\u08c4\3\2\2\2\u08c3\u08c1\3\2\2\2\u08c4\u08c5\79"+ 21965 "\2\2\u08c5\u00ab\3\2\2\2\u08c6\u08ee\5\u00a8U\2\u08c7\u08ed\5\f\7\2\u08c8"+ 21966 "\u08ed\5h\65\2\u08c9\u08ed\5\22\n\2\u08ca\u08ed\5\30\r\2\u08cb\u08ed\5"+ 21967 "\36\20\2\u08cc\u08ed\5$\23\2\u08cd\u08ed\5*\26\2\u08ce\u08ed\5\60\31\2"+ 21968 "\u08cf\u08ed\5\66\34\2\u08d0\u08ed\5<\37\2\u08d1\u08ed\5B\"\2\u08d2\u08ed"+ 21969 "\5H%\2\u08d3\u08ed\5N(\2\u08d4\u08ed\5T+\2\u08d5\u08ed\5Z.\2\u08d6\u08ed"+ 21970 "\5`\61\2\u08d7\u08ed\5\16\b\2\u08d8\u08ed\5\24\13\2\u08d9\u08ed\5\32\16"+ 21971 "\2\u08da\u08ed\5 \21\2\u08db\u08ed\5&\24\2\u08dc\u08ed\5,\27\2\u08dd\u08ed"+ 21972 "\5\62\32\2\u08de\u08ed\58\35\2\u08df\u08ed\5> \2\u08e0\u08ed\5D#\2\u08e1"+ 21973 "\u08ed\5J&\2\u08e2\u08ed\5P)\2\u08e3\u08ed\5V,\2\u08e4\u08ed\5\\/\2\u08e5"+ 21974 "\u08e6\6W\32\2\u08e6\u08ed\7\3\2\2\u08e7\u08ed\5\u0094K\2\u08e8\u08ed"+ 21975 "\7\5\2\2\u08e9\u08ed\7\b\2\2\u08ea\u08ed\5\u0096L\2\u08eb\u08ed\5\u0092"+ 21976 "J\2\u08ec\u08c7\3\2\2\2\u08ec\u08c8\3\2\2\2\u08ec\u08c9\3\2\2\2\u08ec"+ 21977 "\u08ca\3\2\2\2\u08ec\u08cb\3\2\2\2\u08ec\u08cc\3\2\2\2\u08ec\u08cd\3\2"+ 21978 "\2\2\u08ec\u08ce\3\2\2\2\u08ec\u08cf\3\2\2\2\u08ec\u08d0\3\2\2\2\u08ec"+ 21979 "\u08d1\3\2\2\2\u08ec\u08d2\3\2\2\2\u08ec\u08d3\3\2\2\2\u08ec\u08d4\3\2"+ 21980 "\2\2\u08ec\u08d5\3\2\2\2\u08ec\u08d6\3\2\2\2\u08ec\u08d7\3\2\2\2\u08ec"+ 21981 "\u08d8\3\2\2\2\u08ec\u08d9\3\2\2\2\u08ec\u08da\3\2\2\2\u08ec\u08db\3\2"+ 21982 "\2\2\u08ec\u08dc\3\2\2\2\u08ec\u08dd\3\2\2\2\u08ec\u08de\3\2\2\2\u08ec"+ 21983 "\u08df\3\2\2\2\u08ec\u08e0\3\2\2\2\u08ec\u08e1\3\2\2\2\u08ec\u08e2\3\2"+ 21984 "\2\2\u08ec\u08e3\3\2\2\2\u08ec\u08e4\3\2\2\2\u08ec\u08e5\3\2\2\2\u08ec"+ 21985 "\u08e7\3\2\2\2\u08ec\u08e8\3\2\2\2\u08ec\u08e9\3\2\2\2\u08ec\u08ea\3\2"+ 21986 "\2\2\u08ec\u08eb\3\2\2\2\u08ed\u08f0\3\2\2\2\u08ee\u08ec\3\2\2\2\u08ee"+ 21987 "\u08ef\3\2\2\2\u08ef\u08f1\3\2\2\2\u08f0\u08ee\3\2\2\2\u08f1\u08f2\5\u00aa"+ 21988 "V\2\u08f2\u00ad\3\2\2\2\u08f3\u08f4\7\7\2\2\u08f4\u08fb\7c\2\2\u08f5\u08fa"+ 21989 "\5\n\6\2\u08f6\u08fa\7\b\2\2\u08f7\u08fa\7\3\2\2\u08f8\u08fa\7\6\2\2\u08f9"+ 21990 "\u08f5\3\2\2\2\u08f9\u08f6\3\2\2\2\u08f9\u08f7\3\2\2\2\u08f9\u08f8\3\2"+ 21991 "\2\2\u08fa\u08fd\3\2\2\2\u08fb\u08f9\3\2\2\2\u08fb\u08fc\3\2\2\2\u08fc"+ 21992 "\u08fe\3\2\2\2\u08fd\u08fb\3\2\2\2\u08fe\u08ff\79\2\2\u08ff\u00af\3\2"+ 21993 "\2\2\u0900\u0901\7\7\2\2\u0901\u0902\7;\2\2\u0902\u0906\7c\2\2\u0903\u0905"+ 21994 "\t\2\2\2\u0904\u0903\3\2\2\2\u0905\u0908\3\2\2\2\u0906\u0904\3\2\2\2\u0906"+ 21995 "\u0907\3\2\2\2\u0907\u0909\3\2\2\2\u0908\u0906\3\2\2\2\u0909\u090a\79"+ 21996 "\2\2\u090a\u00b1\3\2\2\2\u090b\u0933\5\u00aeX\2\u090c\u0932\5\f\7\2\u090d"+ 21997 "\u0932\5h\65\2\u090e\u0932\5\22\n\2\u090f\u0932\5\30\r\2\u0910\u0932\5"+ 21998 "\36\20\2\u0911\u0932\5$\23\2\u0912\u0932\5*\26\2\u0913\u0932\5\60\31\2"+ 21999 "\u0914\u0932\5\66\34\2\u0915\u0932\5<\37\2\u0916\u0932\5B\"\2\u0917\u0932"+ 22000 "\5H%\2\u0918\u0932\5N(\2\u0919\u0932\5T+\2\u091a\u0932\5Z.\2\u091b\u0932"+ 22001 "\5`\61\2\u091c\u0932\5\16\b\2\u091d\u0932\5\24\13\2\u091e\u0932\5\32\16"+ 22002 "\2\u091f\u0932\5 \21\2\u0920\u0932\5&\24\2\u0921\u0932\5,\27\2\u0922\u0932"+ 22003 "\5\62\32\2\u0923\u0932\58\35\2\u0924\u0932\5> \2\u0925\u0932\5D#\2\u0926"+ 22004 "\u0932\5J&\2\u0927\u0932\5P)\2\u0928\u0932\5V,\2\u0929\u0932\5\\/\2\u092a"+ 22005 "\u092b\6Z\33\2\u092b\u0932\7\3\2\2\u092c\u0932\5\u0094K\2\u092d\u0932"+ 22006 "\7\5\2\2\u092e\u0932\7\b\2\2\u092f\u0932\5\u0096L\2\u0930\u0932\5\u0092"+ 22007 "J\2\u0931\u090c\3\2\2\2\u0931\u090d\3\2\2\2\u0931\u090e\3\2\2\2\u0931"+ 22008 "\u090f\3\2\2\2\u0931\u0910\3\2\2\2\u0931\u0911\3\2\2\2\u0931\u0912\3\2"+ 22009 "\2\2\u0931\u0913\3\2\2\2\u0931\u0914\3\2\2\2\u0931\u0915\3\2\2\2\u0931"+ 22010 "\u0916\3\2\2\2\u0931\u0917\3\2\2\2\u0931\u0918\3\2\2\2\u0931\u0919\3\2"+ 22011 "\2\2\u0931\u091a\3\2\2\2\u0931\u091b\3\2\2\2\u0931\u091c\3\2\2\2\u0931"+ 22012 "\u091d\3\2\2\2\u0931\u091e\3\2\2\2\u0931\u091f\3\2\2\2\u0931\u0920\3\2"+ 22013 "\2\2\u0931\u0921\3\2\2\2\u0931\u0922\3\2\2\2\u0931\u0923\3\2\2\2\u0931"+ 22014 "\u0924\3\2\2\2\u0931\u0925\3\2\2\2\u0931\u0926\3\2\2\2\u0931\u0927\3\2"+ 22015 "\2\2\u0931\u0928\3\2\2\2\u0931\u0929\3\2\2\2\u0931\u092a\3\2\2\2\u0931"+ 22016 "\u092c\3\2\2\2\u0931\u092d\3\2\2\2\u0931\u092e\3\2\2\2\u0931\u092f\3\2"+ 22017 "\2\2\u0931\u0930\3\2\2\2\u0932\u0935\3\2\2\2\u0933\u0931\3\2\2\2\u0933"+ 22018 "\u0934\3\2\2\2\u0934\u0936\3\2\2\2\u0935\u0933\3\2\2\2\u0936\u0937\5\u00b0"+ 22019 "Y\2\u0937\u00b3\3\2\2\2\u0938\u0939\7\7\2\2\u0939\u0940\7d\2\2\u093a\u093f"+ 22020 "\5\n\6\2\u093b\u093f\7\b\2\2\u093c\u093f\7\3\2\2\u093d\u093f\7\6\2\2\u093e"+ 22021 "\u093a\3\2\2\2\u093e\u093b\3\2\2\2\u093e\u093c\3\2\2\2\u093e\u093d\3\2"+ 22022 "\2\2\u093f\u0942\3\2\2\2\u0940\u093e\3\2\2\2\u0940\u0941\3\2\2\2\u0941"+ 22023 "\u0943\3\2\2\2\u0942\u0940\3\2\2\2\u0943\u0944\79\2\2\u0944\u00b5\3\2"+ 22024 "\2\2\u0945\u0946\7\7\2\2\u0946\u0947\7;\2\2\u0947\u094b\7d\2\2\u0948\u094a"+ 22025 "\t\2\2\2\u0949\u0948\3\2\2\2\u094a\u094d\3\2\2\2\u094b\u0949\3\2\2\2\u094b"+ 22026 "\u094c\3\2\2\2\u094c\u094e\3\2\2\2\u094d\u094b\3\2\2\2\u094e\u094f\79"+ 22027 "\2\2\u094f\u00b7\3\2\2\2\u0950\u0978\5\u00b4[\2\u0951\u0977\5\f\7\2\u0952"+ 22028 "\u0977\5h\65\2\u0953\u0977\5\22\n\2\u0954\u0977\5\30\r\2\u0955\u0977\5"+ 22029 "\36\20\2\u0956\u0977\5$\23\2\u0957\u0977\5*\26\2\u0958\u0977\5\60\31\2"+ 22030 "\u0959\u0977\5\66\34\2\u095a\u0977\5<\37\2\u095b\u0977\5B\"\2\u095c\u0977"+ 22031 "\5H%\2\u095d\u0977\5N(\2\u095e\u0977\5T+\2\u095f\u0977\5Z.\2\u0960\u0977"+ 22032 "\5`\61\2\u0961\u0977\5\16\b\2\u0962\u0977\5\24\13\2\u0963\u0977\5\32\16"+ 22033 "\2\u0964\u0977\5 \21\2\u0965\u0977\5&\24\2\u0966\u0977\5,\27\2\u0967\u0977"+ 22034 "\5\62\32\2\u0968\u0977\58\35\2\u0969\u0977\5> \2\u096a\u0977\5D#\2\u096b"+ 22035 "\u0977\5J&\2\u096c\u0977\5P)\2\u096d\u0977\5V,\2\u096e\u0977\5\\/\2\u096f"+ 22036 "\u0970\6]\34\2\u0970\u0977\7\3\2\2\u0971\u0977\5\u0094K\2\u0972\u0977"+ 22037 "\7\5\2\2\u0973\u0977\7\b\2\2\u0974\u0977\5\u0096L\2\u0975\u0977\5\u0092"+ 22038 "J\2\u0976\u0951\3\2\2\2\u0976\u0952\3\2\2\2\u0976\u0953\3\2\2\2\u0976"+ 22039 "\u0954\3\2\2\2\u0976\u0955\3\2\2\2\u0976\u0956\3\2\2\2\u0976\u0957\3\2"+ 22040 "\2\2\u0976\u0958\3\2\2\2\u0976\u0959\3\2\2\2\u0976\u095a\3\2\2\2\u0976"+ 22041 "\u095b\3\2\2\2\u0976\u095c\3\2\2\2\u0976\u095d\3\2\2\2\u0976\u095e\3\2"+ 22042 "\2\2\u0976\u095f\3\2\2\2\u0976\u0960\3\2\2\2\u0976\u0961\3\2\2\2\u0976"+ 22043 "\u0962\3\2\2\2\u0976\u0963\3\2\2\2\u0976\u0964\3\2\2\2\u0976\u0965\3\2"+ 22044 "\2\2\u0976\u0966\3\2\2\2\u0976\u0967\3\2\2\2\u0976\u0968\3\2\2\2\u0976"+ 22045 "\u0969\3\2\2\2\u0976\u096a\3\2\2\2\u0976\u096b\3\2\2\2\u0976\u096c\3\2"+ 22046 "\2\2\u0976\u096d\3\2\2\2\u0976\u096e\3\2\2\2\u0976\u096f\3\2\2\2\u0976"+ 22047 "\u0971\3\2\2\2\u0976\u0972\3\2\2\2\u0976\u0973\3\2\2\2\u0976\u0974\3\2"+ 22048 "\2\2\u0976\u0975\3\2\2\2\u0977\u097a\3\2\2\2\u0978\u0976\3\2\2\2\u0978"+ 22049 "\u0979\3\2\2\2\u0979\u097b\3\2\2\2\u097a\u0978\3\2\2\2\u097b\u097c\5\u00b6"+ 22050 "\\\2\u097c\u00b9\3\2\2\2\u097d\u097e\7\7\2\2\u097e\u0985\7e\2\2\u097f"+ 22051 "\u0984\5\n\6\2\u0980\u0984\7\b\2\2\u0981\u0984\7\3\2\2\u0982\u0984\7\6"+ 22052 "\2\2\u0983\u097f\3\2\2\2\u0983\u0980\3\2\2\2\u0983\u0981\3\2\2\2\u0983"+ 22053 "\u0982\3\2\2\2\u0984\u0987\3\2\2\2\u0985\u0983\3\2\2\2\u0985\u0986\3\2"+ 22054 "\2\2\u0986\u0988\3\2\2\2\u0987\u0985\3\2\2\2\u0988\u0989\79\2\2\u0989"+ 22055 "\u00bb\3\2\2\2\u098a\u098b\7\7\2\2\u098b\u098c\7;\2\2\u098c\u0990\7e\2"+ 22056 "\2\u098d\u098f\t\2\2\2\u098e\u098d\3\2\2\2\u098f\u0992\3\2\2\2\u0990\u098e"+ 22057 "\3\2\2\2\u0990\u0991\3\2\2\2\u0991\u0993\3\2\2\2\u0992\u0990\3\2\2\2\u0993"+ 22058 "\u0994\79\2\2\u0994\u00bd\3\2\2\2\u0995\u09bd\5\u00ba^\2\u0996\u09bc\5"+ 22059 "\f\7\2\u0997\u09bc\5h\65\2\u0998\u09bc\5\22\n\2\u0999\u09bc\5\30\r\2\u099a"+ 22060 "\u09bc\5\36\20\2\u099b\u09bc\5$\23\2\u099c\u09bc\5*\26\2\u099d\u09bc\5"+ 22061 "\60\31\2\u099e\u09bc\5\66\34\2\u099f\u09bc\5<\37\2\u09a0\u09bc\5B\"\2"+ 22062 "\u09a1\u09bc\5H%\2\u09a2\u09bc\5N(\2\u09a3\u09bc\5T+\2\u09a4\u09bc\5Z"+ 22063 ".\2\u09a5\u09bc\5`\61\2\u09a6\u09bc\5\16\b\2\u09a7\u09bc\5\24\13\2\u09a8"+ 22064 "\u09bc\5\32\16\2\u09a9\u09bc\5 \21\2\u09aa\u09bc\5&\24\2\u09ab\u09bc\5"+ 22065 ",\27\2\u09ac\u09bc\5\62\32\2\u09ad\u09bc\58\35\2\u09ae\u09bc\5> \2\u09af"+ 22066 "\u09bc\5D#\2\u09b0\u09bc\5J&\2\u09b1\u09bc\5P)\2\u09b2\u09bc\5V,\2\u09b3"+ 22067 "\u09bc\5\\/\2\u09b4\u09b5\6`\35\2\u09b5\u09bc\7\3\2\2\u09b6\u09bc\5\u0094"+ 22068 "K\2\u09b7\u09bc\7\5\2\2\u09b8\u09bc\7\b\2\2\u09b9\u09bc\5\u0096L\2\u09ba"+ 22069 "\u09bc\5\u0092J\2\u09bb\u0996\3\2\2\2\u09bb\u0997\3\2\2\2\u09bb\u0998"+ 22070 "\3\2\2\2\u09bb\u0999\3\2\2\2\u09bb\u099a\3\2\2\2\u09bb\u099b\3\2\2\2\u09bb"+ 22071 "\u099c\3\2\2\2\u09bb\u099d\3\2\2\2\u09bb\u099e\3\2\2\2\u09bb\u099f\3\2"+ 22072 "\2\2\u09bb\u09a0\3\2\2\2\u09bb\u09a1\3\2\2\2\u09bb\u09a2\3\2\2\2\u09bb"+ 22073 "\u09a3\3\2\2\2\u09bb\u09a4\3\2\2\2\u09bb\u09a5\3\2\2\2\u09bb\u09a6\3\2"+ 22074 "\2\2\u09bb\u09a7\3\2\2\2\u09bb\u09a8\3\2\2\2\u09bb\u09a9\3\2\2\2\u09bb"+ 22075 "\u09aa\3\2\2\2\u09bb\u09ab\3\2\2\2\u09bb\u09ac\3\2\2\2\u09bb\u09ad\3\2"+ 22076 "\2\2\u09bb\u09ae\3\2\2\2\u09bb\u09af\3\2\2\2\u09bb\u09b0\3\2\2\2\u09bb"+ 22077 "\u09b1\3\2\2\2\u09bb\u09b2\3\2\2\2\u09bb\u09b3\3\2\2\2\u09bb\u09b4\3\2"+ 22078 "\2\2\u09bb\u09b6\3\2\2\2\u09bb\u09b7\3\2\2\2\u09bb\u09b8\3\2\2\2\u09bb"+ 22079 "\u09b9\3\2\2\2\u09bb\u09ba\3\2\2\2\u09bc\u09bf\3\2\2\2\u09bd\u09bb\3\2"+ 22080 "\2\2\u09bd\u09be\3\2\2\2\u09be\u09c0\3\2\2\2\u09bf\u09bd\3\2\2\2\u09c0"+ 22081 "\u09c1\5\u00bc_\2\u09c1\u00bf\3\2\2\2\u00db\u00c8\u00ca\u00ce\u00d3\u00d9"+ 22082 "\u011c\u0124\u0126\u0131\u013a\u0141\u0147\u0152\u0154\u0160\u0162\u016d"+ 22083 "\u01a2\u01a4\u01af\u01b1\u01bc\u01f1\u01f3\u01fe\u0200\u020b\u0240\u0242"+ 22084 "\u024d\u024f\u025a\u028f\u0291\u029c\u029e\u02a9\u02de\u02e0\u02eb\u02ed"+ 22085 "\u02f8\u032d\u032f\u033a\u033c\u0347\u037c\u037e\u0389\u038b\u0396\u03cb"+ 22086 "\u03cd\u03d8\u03da\u03e5\u041a\u041c\u0427\u0429\u0434\u0469\u046b\u0476"+ 22087 "\u0478\u0483\u04b8\u04ba\u04c5\u04c7\u04d2\u0507\u0509\u0514\u0516\u0521"+ 22088 "\u0556\u0558\u0563\u0565\u0570\u05a5\u05a7\u05b2\u05b4\u05bf\u05f4\u05f6"+ 22089 "\u060f\u0617\u0619\u0624\u0626\u0631\u0633\u063e\u0640\u064b\u064d\u0658"+ 22090 "\u065a\u0665\u0667\u0672\u0674\u067f\u0681\u068c\u068e\u0699\u069b\u06a6"+ 22091 "\u06a8\u06b3\u06b5\u06c0\u06c2\u06d7\u06d9\u06df\u06e1\u06e6\u06e8\u06ee"+ 22092 "\u06f7\u06fe\u0703\u070a\u070c\u0712\u0717\u071e\u0720\u0726\u072b\u0731"+ 22093 "\u0739\u073b\u0740\u0745\u074a\u0750\u0757\u075c\u0763\u0768\u076e\u0773"+ 22094 "\u0778\u077d\u0782\u0787\u078d\u0795\u0797\u079d\u07a2\u07a8\u07af\u07b4"+ 22095 "\u07b6\u07be\u07c0\u07c7\u07ce\u07d5\u07db\u07e0\u07e6\u07ec\u07f1\u07f8"+ 22096 "\u07fa\u0801\u0806\u080c\u0811\u0813\u081b\u081d\u0826\u082e\u0830\u083b"+ 22097 "\u083d\u0848\u084a\u0855\u0857\u0862\u0864\u086f\u0871\u087c\u08a7\u08a9"+ 22098 "\u08b4\u08b6\u08c1\u08ec\u08ee\u08f9\u08fb\u0906\u0931\u0933\u093e\u0940"+ 22099 "\u094b\u0976\u0978\u0983\u0985\u0990\u09bb\u09bd"; 22100 public static final String _serializedATN = Utils.join( 22101 new String[] { 22102 _serializedATNSegment0, 22103 _serializedATNSegment1 22104 }, 22105 "" 22106 ); 22107 public static final ATN _ATN = 22108 new ATNDeserializer().deserialize(_serializedATN.toCharArray()); 22109 static { 22110 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; 22111 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { 22112 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); 22113 } 22114 } 22115}