001// Generated from com/puppycrawl/tools/checkstyle/grammars/javadoc/JavadocParser.g4 by ANTLR 4.7.1 002package com.puppycrawl.tools.checkstyle.grammars.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.7.1", 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 public static final String[] ruleNames = { 071 "javadoc", "htmlElement", "htmlElementStart", "htmlElementEnd", "attribute", 072 "htmlTag", "pTagStart", "pTagEnd", "paragraph", "liTagStart", "liTagEnd", 073 "li", "trTagStart", "trTagEnd", "tr", "tdTagStart", "tdTagEnd", "td", 074 "thTagStart", "thTagEnd", "th", "bodyTagStart", "bodyTagEnd", "body", 075 "colgroupTagStart", "colgroupTagEnd", "colgroup", "ddTagStart", "ddTagEnd", 076 "dd", "dtTagStart", "dtTagEnd", "dt", "headTagStart", "headTagEnd", "head", 077 "htmlTagStart", "htmlTagEnd", "html", "optionTagStart", "optionTagEnd", 078 "option", "tbodyTagStart", "tbodyTagEnd", "tbody", "tfootTagStart", "tfootTagEnd", 079 "tfoot", "theadTagStart", "theadTagEnd", "thead", "singletonElement", 080 "emptyTag", "areaTag", "baseTag", "basefontTag", "brTag", "colTag", "frameTag", 081 "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", "paramTag", 082 "wrongSingletonTag", "singletonTagName", "description", "reference", "parameters", 083 "javadocTag", "javadocInlineTag", "htmlComment", "text", "embedTag", "keygenTag", 084 "sourceTag", "trackTag", "wbrTag", "optgroupTagStart", "optgroupTagEnd", 085 "optgroup", "rbTagStart", "rbTagEnd", "rb", "rtTagStart", "rtTagEnd", 086 "rt", "rtcTagStart", "rtcTagEnd", "rtc", "rpTagStart", "rpTagEnd", "rp" 087 }; 088 089 private static final String[] _LITERAL_NAMES = { 090 null, null, null, null, null, null, null, "'@author'", "'@deprecated'", 091 null, null, "'@return'", null, "'@serial'", null, "'@serialData'", "'@since'", 092 null, "'@version'", null, null, null, "'include'", "'exclude'", null, 093 null, null, null, null, "'.'", null, null, null, null, "'('", "')'", null, 094 "','", null, null, null, null, null, null, null, null, "'@docRoot'", "'@inheritDoc'", 095 "'@link'", "'@linkplain'", null, "'@value'", null, null, null, null, null, 096 "'/'", "'='", null, null, null, null, null, null, null, null, null, null, 097 null, null, null, null, null, null, null, null, null, null, null, null, 098 null, null, null, null, null, null, null, null, null, null, "'-->'" 099 }; 100 private static final String[] _SYMBOLIC_NAMES = { 101 null, "LEADING_ASTERISK", "HTML_COMMENT_START", "CDATA", "WS", "START", 102 "NEWLINE", "AUTHOR_LITERAL", "DEPRECATED_LITERAL", "EXCEPTION_LITERAL", 103 "PARAM_LITERAL", "RETURN_LITERAL", "SEE_LITERAL", "SERIAL_LITERAL", "SERIAL_FIELD_LITERAL", 104 "SERIAL_DATA_LITERAL", "SINCE_LITERAL", "THROWS_LITERAL", "VERSION_LITERAL", 105 "JAVADOC_INLINE_TAG_START", "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", "LITERAL_INCLUDE", 106 "LITERAL_EXCLUDE", "CHAR", "PARAMETER_NAME", "Char1", "STRING", "PACKAGE_CLASS", 107 "DOT", "HASH", "CLASS", "Char2", "MEMBER", "LEFT_BRACE", "RIGHT_BRACE", 108 "ARGUMENT", "COMMA", "Char20", "FIELD_NAME", "Char3", "FIELD_TYPE", "Char4", 109 "CLASS_NAME", "Char5", "CODE_LITERAL", "DOC_ROOT_LITERAL", "INHERIT_DOC_LITERAL", 110 "LINK_LITERAL", "LINKPLAIN_LITERAL", "LITERAL_LITERAL", "VALUE_LITERAL", 111 "Char7", "Char8", "Char10", "END", "SLASH_END", "SLASH", "EQUALS", "P_HTML_TAG_NAME", 112 "LI_HTML_TAG_NAME", "TR_HTML_TAG_NAME", "TD_HTML_TAG_NAME", "TH_HTML_TAG_NAME", 113 "BODY_HTML_TAG_NAME", "COLGROUP_HTML_TAG_NAME", "DD_HTML_TAG_NAME", "DT_HTML_TAG_NAME", 114 "HEAD_HTML_TAG_NAME", "HTML_HTML_TAG_NAME", "OPTION_HTML_TAG_NAME", "TBODY_HTML_TAG_NAME", 115 "TFOOT_HTML_TAG_NAME", "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", "BASE_HTML_TAG_NAME", 116 "BASEFONT_HTML_TAG_NAME", "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", "FRAME_HTML_TAG_NAME", 117 "HR_HTML_TAG_NAME", "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", "ISINDEX_HTML_TAG_NAME", 118 "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", "EMBED_HTML_TAG_NAME", 119 "KEYGEN_HTML_TAG_NAME", "ATTR_VALUE", "Char12", "HTML_COMMENT_END", "SOURCE_HTML_TAG_NAME", 120 "TRACK_HTML_TAG_NAME", "WBR_HTML_TAG_NAME", "OPTGROUP_HTML_TAG_NAME", 121 "RB_HTML_TAG_NAME", "RT_HTML_TAG_NAME", "RTC_HTML_TAG_NAME", "RP_HTML_TAG_NAME", 122 "HTML_TAG_NAME", "Char11" 123 }; 124 public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); 125 126 /** 127 * @deprecated Use {@link #VOCABULARY} instead. 128 */ 129 @Deprecated 130 public static final String[] tokenNames; 131 static { 132 tokenNames = new String[_SYMBOLIC_NAMES.length]; 133 for (int i = 0; i < tokenNames.length; i++) { 134 tokenNames[i] = VOCABULARY.getLiteralName(i); 135 if (tokenNames[i] == null) { 136 tokenNames[i] = VOCABULARY.getSymbolicName(i); 137 } 138 139 if (tokenNames[i] == null) { 140 tokenNames[i] = "<INVALID>"; 141 } 142 } 143 } 144 145 @Override 146 @Deprecated 147 public String[] getTokenNames() { 148 return tokenNames; 149 } 150 151 @Override 152 153 public Vocabulary getVocabulary() { 154 return VOCABULARY; 155 } 156 157 @Override 158 public String getGrammarFileName() { return "JavadocParser.g4"; } 159 160 @Override 161 public String[] getRuleNames() { return ruleNames; } 162 163 @Override 164 public String getSerializedATN() { return _serializedATN; } 165 166 @Override 167 public ATN getATN() { return _ATN; } 168 169 170 boolean isNextJavadocTag() { 171 int token1 = _input.LA(2); 172 int token2 = _input.LA(3); 173 return isJavadocTag(token1) 174 || (token1 == WS && isJavadocTag(token2)); 175 } 176 177 boolean isJavadocTag(int type) { 178 switch(type) { 179 case AUTHOR_LITERAL: 180 case DEPRECATED_LITERAL: 181 case EXCEPTION_LITERAL: 182 case PARAM_LITERAL: 183 case RETURN_LITERAL: 184 case SEE_LITERAL: 185 case SERIAL_LITERAL: 186 case SERIAL_FIELD_LITERAL: 187 case SERIAL_DATA_LITERAL: 188 case SINCE_LITERAL: 189 case THROWS_LITERAL: 190 case VERSION_LITERAL: 191 case CUSTOM_NAME: 192 return true; 193 default: 194 return false; 195 } 196 } 197 198 boolean isSameTagNames(ParserRuleContext htmlTagStart, ParserRuleContext htmlTagEnd) { 199 String startTag = htmlTagStart.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 200 String endTag = htmlTagEnd.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 201 return startTag.equals(endTag); 202 } 203 204 public ParserRuleContext nonTightTagStartContext; 205 206 public JavadocParser(TokenStream input) { 207 super(input); 208 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); 209 } 210 public static class JavadocContext extends ParserRuleContext { 211 public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); } 212 public List<HtmlElementContext> htmlElement() { 213 return getRuleContexts(HtmlElementContext.class); 214 } 215 public HtmlElementContext htmlElement(int i) { 216 return getRuleContext(HtmlElementContext.class,i); 217 } 218 public List<HtmlCommentContext> htmlComment() { 219 return getRuleContexts(HtmlCommentContext.class); 220 } 221 public HtmlCommentContext htmlComment(int i) { 222 return getRuleContext(HtmlCommentContext.class,i); 223 } 224 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 225 public TerminalNode CDATA(int i) { 226 return getToken(JavadocParser.CDATA, i); 227 } 228 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 229 public TerminalNode NEWLINE(int i) { 230 return getToken(JavadocParser.NEWLINE, i); 231 } 232 public List<TextContext> text() { 233 return getRuleContexts(TextContext.class); 234 } 235 public TextContext text(int i) { 236 return getRuleContext(TextContext.class,i); 237 } 238 public List<JavadocInlineTagContext> javadocInlineTag() { 239 return getRuleContexts(JavadocInlineTagContext.class); 240 } 241 public JavadocInlineTagContext javadocInlineTag(int i) { 242 return getRuleContext(JavadocInlineTagContext.class,i); 243 } 244 public List<JavadocTagContext> javadocTag() { 245 return getRuleContexts(JavadocTagContext.class); 246 } 247 public JavadocTagContext javadocTag(int i) { 248 return getRuleContext(JavadocTagContext.class,i); 249 } 250 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 251 public TerminalNode LEADING_ASTERISK(int i) { 252 return getToken(JavadocParser.LEADING_ASTERISK, i); 253 } 254 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 255 public TerminalNode WS(int i) { 256 return getToken(JavadocParser.WS, i); 257 } 258 public JavadocContext(ParserRuleContext parent, int invokingState) { 259 super(parent, invokingState); 260 } 261 @Override public int getRuleIndex() { return RULE_javadoc; } 262 } 263 264 public final JavadocContext javadoc() throws RecognitionException { 265 JavadocContext _localctx = new JavadocContext(_ctx, getState()); 266 enterRule(_localctx, 0, RULE_javadoc); 267 int _la; 268 try { 269 int _alt; 270 enterOuterAlt(_localctx, 1); 271 { 272 setState(200); 273 _errHandler.sync(this); 274 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 275 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 276 if ( _alt==1 ) { 277 { 278 setState(198); 279 _errHandler.sync(this); 280 switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { 281 case 1: 282 { 283 setState(190); 284 htmlElement(); 285 } 286 break; 287 case 2: 288 { 289 { 290 setState(191); 291 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 292 setState(192); 293 match(LEADING_ASTERISK); 294 } 295 } 296 break; 297 case 3: 298 { 299 setState(193); 300 htmlComment(); 301 } 302 break; 303 case 4: 304 { 305 setState(194); 306 match(CDATA); 307 } 308 break; 309 case 5: 310 { 311 setState(195); 312 match(NEWLINE); 313 } 314 break; 315 case 6: 316 { 317 setState(196); 318 text(); 319 } 320 break; 321 case 7: 322 { 323 setState(197); 324 javadocInlineTag(); 325 } 326 break; 327 } 328 } 329 } 330 setState(202); 331 _errHandler.sync(this); 332 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 333 } 334 setState(215); 335 _errHandler.sync(this); 336 _la = _input.LA(1); 337 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)) { 338 { 339 { 340 setState(204); 341 _errHandler.sync(this); 342 _la = _input.LA(1); 343 if (_la==LEADING_ASTERISK) { 344 { 345 setState(203); 346 match(LEADING_ASTERISK); 347 } 348 } 349 350 setState(209); 351 _errHandler.sync(this); 352 _la = _input.LA(1); 353 while (_la==WS) { 354 { 355 { 356 setState(206); 357 match(WS); 358 } 359 } 360 setState(211); 361 _errHandler.sync(this); 362 _la = _input.LA(1); 363 } 364 setState(212); 365 javadocTag(); 366 } 367 } 368 setState(217); 369 _errHandler.sync(this); 370 _la = _input.LA(1); 371 } 372 setState(218); 373 match(EOF); 374 } 375 } 376 catch (RecognitionException re) { 377 _localctx.exception = re; 378 _errHandler.reportError(this, re); 379 _errHandler.recover(this, re); 380 } 381 finally { 382 exitRule(); 383 } 384 return _localctx; 385 } 386 387 public static class HtmlElementContext extends ParserRuleContext { 388 public HtmlTagContext htmlTag() { 389 return getRuleContext(HtmlTagContext.class,0); 390 } 391 public SingletonElementContext singletonElement() { 392 return getRuleContext(SingletonElementContext.class,0); 393 } 394 public ParagraphContext paragraph() { 395 return getRuleContext(ParagraphContext.class,0); 396 } 397 public LiContext li() { 398 return getRuleContext(LiContext.class,0); 399 } 400 public TrContext tr() { 401 return getRuleContext(TrContext.class,0); 402 } 403 public TdContext td() { 404 return getRuleContext(TdContext.class,0); 405 } 406 public ThContext th() { 407 return getRuleContext(ThContext.class,0); 408 } 409 public BodyContext body() { 410 return getRuleContext(BodyContext.class,0); 411 } 412 public ColgroupContext colgroup() { 413 return getRuleContext(ColgroupContext.class,0); 414 } 415 public DdContext dd() { 416 return getRuleContext(DdContext.class,0); 417 } 418 public DtContext dt() { 419 return getRuleContext(DtContext.class,0); 420 } 421 public HeadContext head() { 422 return getRuleContext(HeadContext.class,0); 423 } 424 public HtmlContext html() { 425 return getRuleContext(HtmlContext.class,0); 426 } 427 public OptionContext option() { 428 return getRuleContext(OptionContext.class,0); 429 } 430 public TbodyContext tbody() { 431 return getRuleContext(TbodyContext.class,0); 432 } 433 public TheadContext thead() { 434 return getRuleContext(TheadContext.class,0); 435 } 436 public TfootContext tfoot() { 437 return getRuleContext(TfootContext.class,0); 438 } 439 public OptgroupContext optgroup() { 440 return getRuleContext(OptgroupContext.class,0); 441 } 442 public RbContext rb() { 443 return getRuleContext(RbContext.class,0); 444 } 445 public RtContext rt() { 446 return getRuleContext(RtContext.class,0); 447 } 448 public RtcContext rtc() { 449 return getRuleContext(RtcContext.class,0); 450 } 451 public RpContext rp() { 452 return getRuleContext(RpContext.class,0); 453 } 454 public PTagStartContext pTagStart() { 455 return getRuleContext(PTagStartContext.class,0); 456 } 457 public LiTagStartContext liTagStart() { 458 return getRuleContext(LiTagStartContext.class,0); 459 } 460 public TrTagStartContext trTagStart() { 461 return getRuleContext(TrTagStartContext.class,0); 462 } 463 public TdTagStartContext tdTagStart() { 464 return getRuleContext(TdTagStartContext.class,0); 465 } 466 public ThTagStartContext thTagStart() { 467 return getRuleContext(ThTagStartContext.class,0); 468 } 469 public BodyTagStartContext bodyTagStart() { 470 return getRuleContext(BodyTagStartContext.class,0); 471 } 472 public ColgroupTagStartContext colgroupTagStart() { 473 return getRuleContext(ColgroupTagStartContext.class,0); 474 } 475 public DdTagStartContext ddTagStart() { 476 return getRuleContext(DdTagStartContext.class,0); 477 } 478 public DtTagStartContext dtTagStart() { 479 return getRuleContext(DtTagStartContext.class,0); 480 } 481 public HeadTagStartContext headTagStart() { 482 return getRuleContext(HeadTagStartContext.class,0); 483 } 484 public HtmlTagStartContext htmlTagStart() { 485 return getRuleContext(HtmlTagStartContext.class,0); 486 } 487 public OptionTagStartContext optionTagStart() { 488 return getRuleContext(OptionTagStartContext.class,0); 489 } 490 public TbodyTagStartContext tbodyTagStart() { 491 return getRuleContext(TbodyTagStartContext.class,0); 492 } 493 public TheadTagStartContext theadTagStart() { 494 return getRuleContext(TheadTagStartContext.class,0); 495 } 496 public TfootTagStartContext tfootTagStart() { 497 return getRuleContext(TfootTagStartContext.class,0); 498 } 499 public OptgroupTagStartContext optgroupTagStart() { 500 return getRuleContext(OptgroupTagStartContext.class,0); 501 } 502 public RbTagStartContext rbTagStart() { 503 return getRuleContext(RbTagStartContext.class,0); 504 } 505 public RtTagStartContext rtTagStart() { 506 return getRuleContext(RtTagStartContext.class,0); 507 } 508 public RtcTagStartContext rtcTagStart() { 509 return getRuleContext(RtcTagStartContext.class,0); 510 } 511 public RpTagStartContext rpTagStart() { 512 return getRuleContext(RpTagStartContext.class,0); 513 } 514 public PTagEndContext pTagEnd() { 515 return getRuleContext(PTagEndContext.class,0); 516 } 517 public LiTagEndContext liTagEnd() { 518 return getRuleContext(LiTagEndContext.class,0); 519 } 520 public TrTagEndContext trTagEnd() { 521 return getRuleContext(TrTagEndContext.class,0); 522 } 523 public TdTagEndContext tdTagEnd() { 524 return getRuleContext(TdTagEndContext.class,0); 525 } 526 public ThTagEndContext thTagEnd() { 527 return getRuleContext(ThTagEndContext.class,0); 528 } 529 public BodyTagEndContext bodyTagEnd() { 530 return getRuleContext(BodyTagEndContext.class,0); 531 } 532 public ColgroupTagEndContext colgroupTagEnd() { 533 return getRuleContext(ColgroupTagEndContext.class,0); 534 } 535 public DdTagEndContext ddTagEnd() { 536 return getRuleContext(DdTagEndContext.class,0); 537 } 538 public DtTagEndContext dtTagEnd() { 539 return getRuleContext(DtTagEndContext.class,0); 540 } 541 public HeadTagEndContext headTagEnd() { 542 return getRuleContext(HeadTagEndContext.class,0); 543 } 544 public HtmlTagEndContext htmlTagEnd() { 545 return getRuleContext(HtmlTagEndContext.class,0); 546 } 547 public OptionTagEndContext optionTagEnd() { 548 return getRuleContext(OptionTagEndContext.class,0); 549 } 550 public TbodyTagEndContext tbodyTagEnd() { 551 return getRuleContext(TbodyTagEndContext.class,0); 552 } 553 public TheadTagEndContext theadTagEnd() { 554 return getRuleContext(TheadTagEndContext.class,0); 555 } 556 public TfootTagEndContext tfootTagEnd() { 557 return getRuleContext(TfootTagEndContext.class,0); 558 } 559 public OptgroupTagEndContext optgroupTagEnd() { 560 return getRuleContext(OptgroupTagEndContext.class,0); 561 } 562 public RbTagEndContext rbTagEnd() { 563 return getRuleContext(RbTagEndContext.class,0); 564 } 565 public RtTagEndContext rtTagEnd() { 566 return getRuleContext(RtTagEndContext.class,0); 567 } 568 public RtcTagEndContext rtcTagEnd() { 569 return getRuleContext(RtcTagEndContext.class,0); 570 } 571 public RpTagEndContext rpTagEnd() { 572 return getRuleContext(RpTagEndContext.class,0); 573 } 574 public HtmlElementContext(ParserRuleContext parent, int invokingState) { 575 super(parent, invokingState); 576 } 577 @Override public int getRuleIndex() { return RULE_htmlElement; } 578 } 579 580 public final HtmlElementContext htmlElement() throws RecognitionException { 581 HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState()); 582 enterRule(_localctx, 2, RULE_htmlElement); 583 try { 584 setState(282); 585 _errHandler.sync(this); 586 switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { 587 case 1: 588 enterOuterAlt(_localctx, 1); 589 { 590 setState(220); 591 htmlTag(); 592 } 593 break; 594 case 2: 595 enterOuterAlt(_localctx, 2); 596 { 597 setState(221); 598 singletonElement(); 599 } 600 break; 601 case 3: 602 enterOuterAlt(_localctx, 3); 603 { 604 setState(222); 605 paragraph(); 606 } 607 break; 608 case 4: 609 enterOuterAlt(_localctx, 4); 610 { 611 setState(223); 612 li(); 613 } 614 break; 615 case 5: 616 enterOuterAlt(_localctx, 5); 617 { 618 setState(224); 619 tr(); 620 } 621 break; 622 case 6: 623 enterOuterAlt(_localctx, 6); 624 { 625 setState(225); 626 td(); 627 } 628 break; 629 case 7: 630 enterOuterAlt(_localctx, 7); 631 { 632 setState(226); 633 th(); 634 } 635 break; 636 case 8: 637 enterOuterAlt(_localctx, 8); 638 { 639 setState(227); 640 body(); 641 } 642 break; 643 case 9: 644 enterOuterAlt(_localctx, 9); 645 { 646 setState(228); 647 colgroup(); 648 } 649 break; 650 case 10: 651 enterOuterAlt(_localctx, 10); 652 { 653 setState(229); 654 dd(); 655 } 656 break; 657 case 11: 658 enterOuterAlt(_localctx, 11); 659 { 660 setState(230); 661 dt(); 662 } 663 break; 664 case 12: 665 enterOuterAlt(_localctx, 12); 666 { 667 setState(231); 668 head(); 669 } 670 break; 671 case 13: 672 enterOuterAlt(_localctx, 13); 673 { 674 setState(232); 675 html(); 676 } 677 break; 678 case 14: 679 enterOuterAlt(_localctx, 14); 680 { 681 setState(233); 682 option(); 683 } 684 break; 685 case 15: 686 enterOuterAlt(_localctx, 15); 687 { 688 setState(234); 689 tbody(); 690 } 691 break; 692 case 16: 693 enterOuterAlt(_localctx, 16); 694 { 695 setState(235); 696 thead(); 697 } 698 break; 699 case 17: 700 enterOuterAlt(_localctx, 17); 701 { 702 setState(236); 703 tfoot(); 704 } 705 break; 706 case 18: 707 enterOuterAlt(_localctx, 18); 708 { 709 setState(237); 710 optgroup(); 711 } 712 break; 713 case 19: 714 enterOuterAlt(_localctx, 19); 715 { 716 setState(238); 717 rb(); 718 } 719 break; 720 case 20: 721 enterOuterAlt(_localctx, 20); 722 { 723 setState(239); 724 rt(); 725 } 726 break; 727 case 21: 728 enterOuterAlt(_localctx, 21); 729 { 730 setState(240); 731 rtc(); 732 } 733 break; 734 case 22: 735 enterOuterAlt(_localctx, 22); 736 { 737 setState(241); 738 rp(); 739 } 740 break; 741 case 23: 742 enterOuterAlt(_localctx, 23); 743 { 744 setState(242); 745 pTagStart(true); 746 } 747 break; 748 case 24: 749 enterOuterAlt(_localctx, 24); 750 { 751 setState(243); 752 liTagStart(true); 753 } 754 break; 755 case 25: 756 enterOuterAlt(_localctx, 25); 757 { 758 setState(244); 759 trTagStart(true); 760 } 761 break; 762 case 26: 763 enterOuterAlt(_localctx, 26); 764 { 765 setState(245); 766 tdTagStart(true); 767 } 768 break; 769 case 27: 770 enterOuterAlt(_localctx, 27); 771 { 772 setState(246); 773 thTagStart(true); 774 } 775 break; 776 case 28: 777 enterOuterAlt(_localctx, 28); 778 { 779 setState(247); 780 bodyTagStart(true); 781 } 782 break; 783 case 29: 784 enterOuterAlt(_localctx, 29); 785 { 786 setState(248); 787 colgroupTagStart(true); 788 } 789 break; 790 case 30: 791 enterOuterAlt(_localctx, 30); 792 { 793 setState(249); 794 ddTagStart(true); 795 } 796 break; 797 case 31: 798 enterOuterAlt(_localctx, 31); 799 { 800 setState(250); 801 dtTagStart(true); 802 } 803 break; 804 case 32: 805 enterOuterAlt(_localctx, 32); 806 { 807 setState(251); 808 headTagStart(true); 809 } 810 break; 811 case 33: 812 enterOuterAlt(_localctx, 33); 813 { 814 setState(252); 815 htmlTagStart(true); 816 } 817 break; 818 case 34: 819 enterOuterAlt(_localctx, 34); 820 { 821 setState(253); 822 optionTagStart(true); 823 } 824 break; 825 case 35: 826 enterOuterAlt(_localctx, 35); 827 { 828 setState(254); 829 tbodyTagStart(true); 830 } 831 break; 832 case 36: 833 enterOuterAlt(_localctx, 36); 834 { 835 setState(255); 836 theadTagStart(true); 837 } 838 break; 839 case 37: 840 enterOuterAlt(_localctx, 37); 841 { 842 setState(256); 843 tfootTagStart(true); 844 } 845 break; 846 case 38: 847 enterOuterAlt(_localctx, 38); 848 { 849 setState(257); 850 optgroupTagStart(true); 851 } 852 break; 853 case 39: 854 enterOuterAlt(_localctx, 39); 855 { 856 setState(258); 857 rbTagStart(true); 858 } 859 break; 860 case 40: 861 enterOuterAlt(_localctx, 40); 862 { 863 setState(259); 864 rtTagStart(true); 865 } 866 break; 867 case 41: 868 enterOuterAlt(_localctx, 41); 869 { 870 setState(260); 871 rtcTagStart(true); 872 } 873 break; 874 case 42: 875 enterOuterAlt(_localctx, 42); 876 { 877 setState(261); 878 rpTagStart(true); 879 } 880 break; 881 case 43: 882 enterOuterAlt(_localctx, 43); 883 { 884 setState(262); 885 pTagEnd(); 886 } 887 break; 888 case 44: 889 enterOuterAlt(_localctx, 44); 890 { 891 setState(263); 892 liTagEnd(); 893 } 894 break; 895 case 45: 896 enterOuterAlt(_localctx, 45); 897 { 898 setState(264); 899 trTagEnd(); 900 } 901 break; 902 case 46: 903 enterOuterAlt(_localctx, 46); 904 { 905 setState(265); 906 tdTagEnd(); 907 } 908 break; 909 case 47: 910 enterOuterAlt(_localctx, 47); 911 { 912 setState(266); 913 thTagEnd(); 914 } 915 break; 916 case 48: 917 enterOuterAlt(_localctx, 48); 918 { 919 setState(267); 920 bodyTagEnd(); 921 } 922 break; 923 case 49: 924 enterOuterAlt(_localctx, 49); 925 { 926 setState(268); 927 colgroupTagEnd(); 928 } 929 break; 930 case 50: 931 enterOuterAlt(_localctx, 50); 932 { 933 setState(269); 934 ddTagEnd(); 935 } 936 break; 937 case 51: 938 enterOuterAlt(_localctx, 51); 939 { 940 setState(270); 941 dtTagEnd(); 942 } 943 break; 944 case 52: 945 enterOuterAlt(_localctx, 52); 946 { 947 setState(271); 948 headTagEnd(); 949 } 950 break; 951 case 53: 952 enterOuterAlt(_localctx, 53); 953 { 954 setState(272); 955 htmlTagEnd(); 956 } 957 break; 958 case 54: 959 enterOuterAlt(_localctx, 54); 960 { 961 setState(273); 962 optionTagEnd(); 963 } 964 break; 965 case 55: 966 enterOuterAlt(_localctx, 55); 967 { 968 setState(274); 969 tbodyTagEnd(); 970 } 971 break; 972 case 56: 973 enterOuterAlt(_localctx, 56); 974 { 975 setState(275); 976 theadTagEnd(); 977 } 978 break; 979 case 57: 980 enterOuterAlt(_localctx, 57); 981 { 982 setState(276); 983 tfootTagEnd(); 984 } 985 break; 986 case 58: 987 enterOuterAlt(_localctx, 58); 988 { 989 setState(277); 990 optgroupTagEnd(); 991 } 992 break; 993 case 59: 994 enterOuterAlt(_localctx, 59); 995 { 996 setState(278); 997 rbTagEnd(); 998 } 999 break; 1000 case 60: 1001 enterOuterAlt(_localctx, 60); 1002 { 1003 setState(279); 1004 rtTagEnd(); 1005 } 1006 break; 1007 case 61: 1008 enterOuterAlt(_localctx, 61); 1009 { 1010 setState(280); 1011 rtcTagEnd(); 1012 } 1013 break; 1014 case 62: 1015 enterOuterAlt(_localctx, 62); 1016 { 1017 setState(281); 1018 rpTagEnd(); 1019 } 1020 break; 1021 } 1022 } 1023 catch (RecognitionException re) { 1024 _localctx.exception = re; 1025 _errHandler.reportError(this, re); 1026 _errHandler.recover(this, re); 1027 } 1028 finally { 1029 exitRule(); 1030 } 1031 return _localctx; 1032 } 1033 1034 public static class HtmlElementStartContext extends ParserRuleContext { 1035 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 1036 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 1037 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 1038 public List<AttributeContext> attribute() { 1039 return getRuleContexts(AttributeContext.class); 1040 } 1041 public AttributeContext attribute(int i) { 1042 return getRuleContext(AttributeContext.class,i); 1043 } 1044 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1045 public TerminalNode NEWLINE(int i) { 1046 return getToken(JavadocParser.NEWLINE, i); 1047 } 1048 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1049 public TerminalNode LEADING_ASTERISK(int i) { 1050 return getToken(JavadocParser.LEADING_ASTERISK, i); 1051 } 1052 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1053 public TerminalNode WS(int i) { 1054 return getToken(JavadocParser.WS, i); 1055 } 1056 public HtmlElementStartContext(ParserRuleContext parent, int invokingState) { 1057 super(parent, invokingState); 1058 } 1059 @Override public int getRuleIndex() { return RULE_htmlElementStart; } 1060 } 1061 1062 public final HtmlElementStartContext htmlElementStart() throws RecognitionException { 1063 HtmlElementStartContext _localctx = new HtmlElementStartContext(_ctx, getState()); 1064 enterRule(_localctx, 4, RULE_htmlElementStart); 1065 int _la; 1066 try { 1067 enterOuterAlt(_localctx, 1); 1068 { 1069 setState(284); 1070 match(START); 1071 setState(285); 1072 match(HTML_TAG_NAME); 1073 setState(292); 1074 _errHandler.sync(this); 1075 _la = _input.LA(1); 1076 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 1077 { 1078 setState(290); 1079 _errHandler.sync(this); 1080 switch (_input.LA(1)) { 1081 case HTML_TAG_NAME: 1082 { 1083 setState(286); 1084 attribute(); 1085 } 1086 break; 1087 case NEWLINE: 1088 { 1089 setState(287); 1090 match(NEWLINE); 1091 } 1092 break; 1093 case LEADING_ASTERISK: 1094 { 1095 setState(288); 1096 match(LEADING_ASTERISK); 1097 } 1098 break; 1099 case WS: 1100 { 1101 setState(289); 1102 match(WS); 1103 } 1104 break; 1105 default: 1106 throw new NoViableAltException(this); 1107 } 1108 } 1109 setState(294); 1110 _errHandler.sync(this); 1111 _la = _input.LA(1); 1112 } 1113 setState(295); 1114 match(END); 1115 } 1116 } 1117 catch (RecognitionException re) { 1118 _localctx.exception = re; 1119 _errHandler.reportError(this, re); 1120 _errHandler.recover(this, re); 1121 } 1122 finally { 1123 exitRule(); 1124 } 1125 return _localctx; 1126 } 1127 1128 public static class HtmlElementEndContext extends ParserRuleContext { 1129 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 1130 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1131 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 1132 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 1133 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1134 public TerminalNode NEWLINE(int i) { 1135 return getToken(JavadocParser.NEWLINE, i); 1136 } 1137 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1138 public TerminalNode LEADING_ASTERISK(int i) { 1139 return getToken(JavadocParser.LEADING_ASTERISK, i); 1140 } 1141 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1142 public TerminalNode WS(int i) { 1143 return getToken(JavadocParser.WS, i); 1144 } 1145 public HtmlElementEndContext(ParserRuleContext parent, int invokingState) { 1146 super(parent, invokingState); 1147 } 1148 @Override public int getRuleIndex() { return RULE_htmlElementEnd; } 1149 } 1150 1151 public final HtmlElementEndContext htmlElementEnd() throws RecognitionException { 1152 HtmlElementEndContext _localctx = new HtmlElementEndContext(_ctx, getState()); 1153 enterRule(_localctx, 6, RULE_htmlElementEnd); 1154 int _la; 1155 try { 1156 enterOuterAlt(_localctx, 1); 1157 { 1158 setState(297); 1159 match(START); 1160 setState(298); 1161 match(SLASH); 1162 setState(299); 1163 match(HTML_TAG_NAME); 1164 setState(303); 1165 _errHandler.sync(this); 1166 _la = _input.LA(1); 1167 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1168 { 1169 { 1170 setState(300); 1171 _la = _input.LA(1); 1172 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1173 _errHandler.recoverInline(this); 1174 } 1175 else { 1176 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1177 _errHandler.reportMatch(this); 1178 consume(); 1179 } 1180 } 1181 } 1182 setState(305); 1183 _errHandler.sync(this); 1184 _la = _input.LA(1); 1185 } 1186 setState(306); 1187 match(END); 1188 } 1189 } 1190 catch (RecognitionException re) { 1191 _localctx.exception = re; 1192 _errHandler.reportError(this, re); 1193 _errHandler.recover(this, re); 1194 } 1195 finally { 1196 exitRule(); 1197 } 1198 return _localctx; 1199 } 1200 1201 public static class AttributeContext extends ParserRuleContext { 1202 public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); } 1203 public TerminalNode HTML_TAG_NAME(int i) { 1204 return getToken(JavadocParser.HTML_TAG_NAME, i); 1205 } 1206 public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); } 1207 public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); } 1208 public TextContext text() { 1209 return getRuleContext(TextContext.class,0); 1210 } 1211 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1212 public TerminalNode NEWLINE(int i) { 1213 return getToken(JavadocParser.NEWLINE, i); 1214 } 1215 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1216 public TerminalNode LEADING_ASTERISK(int i) { 1217 return getToken(JavadocParser.LEADING_ASTERISK, i); 1218 } 1219 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1220 public TerminalNode WS(int i) { 1221 return getToken(JavadocParser.WS, i); 1222 } 1223 public AttributeContext(ParserRuleContext parent, int invokingState) { 1224 super(parent, invokingState); 1225 } 1226 @Override public int getRuleIndex() { return RULE_attribute; } 1227 } 1228 1229 public final AttributeContext attribute() throws RecognitionException { 1230 AttributeContext _localctx = new AttributeContext(_ctx, getState()); 1231 enterRule(_localctx, 8, RULE_attribute); 1232 int _la; 1233 try { 1234 int _alt; 1235 enterOuterAlt(_localctx, 1); 1236 { 1237 setState(308); 1238 match(HTML_TAG_NAME); 1239 setState(312); 1240 _errHandler.sync(this); 1241 _la = _input.LA(1); 1242 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1243 { 1244 { 1245 setState(309); 1246 _la = _input.LA(1); 1247 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1248 _errHandler.recoverInline(this); 1249 } 1250 else { 1251 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1252 _errHandler.reportMatch(this); 1253 consume(); 1254 } 1255 } 1256 } 1257 setState(314); 1258 _errHandler.sync(this); 1259 _la = _input.LA(1); 1260 } 1261 setState(315); 1262 match(EQUALS); 1263 setState(319); 1264 _errHandler.sync(this); 1265 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1266 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1267 if ( _alt==1 ) { 1268 { 1269 { 1270 setState(316); 1271 _la = _input.LA(1); 1272 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1273 _errHandler.recoverInline(this); 1274 } 1275 else { 1276 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1277 _errHandler.reportMatch(this); 1278 consume(); 1279 } 1280 } 1281 } 1282 } 1283 setState(321); 1284 _errHandler.sync(this); 1285 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1286 } 1287 setState(325); 1288 _errHandler.sync(this); 1289 switch (_input.LA(1)) { 1290 case ATTR_VALUE: 1291 { 1292 setState(322); 1293 match(ATTR_VALUE); 1294 } 1295 break; 1296 case WS: 1297 case CHAR: 1298 { 1299 setState(323); 1300 text(); 1301 } 1302 break; 1303 case HTML_TAG_NAME: 1304 { 1305 setState(324); 1306 match(HTML_TAG_NAME); 1307 } 1308 break; 1309 default: 1310 throw new NoViableAltException(this); 1311 } 1312 } 1313 } 1314 catch (RecognitionException re) { 1315 _localctx.exception = re; 1316 _errHandler.reportError(this, re); 1317 _errHandler.recover(this, re); 1318 } 1319 finally { 1320 exitRule(); 1321 } 1322 return _localctx; 1323 } 1324 1325 public static class HtmlTagContext extends ParserRuleContext { 1326 public HtmlElementStartContext htmlElementStart; 1327 public HtmlElementEndContext htmlElementEnd; 1328 public HtmlElementStartContext htmlElementStart() { 1329 return getRuleContext(HtmlElementStartContext.class,0); 1330 } 1331 public HtmlElementEndContext htmlElementEnd() { 1332 return getRuleContext(HtmlElementEndContext.class,0); 1333 } 1334 public List<HtmlElementContext> htmlElement() { 1335 return getRuleContexts(HtmlElementContext.class); 1336 } 1337 public HtmlElementContext htmlElement(int i) { 1338 return getRuleContext(HtmlElementContext.class,i); 1339 } 1340 public List<HtmlCommentContext> htmlComment() { 1341 return getRuleContexts(HtmlCommentContext.class); 1342 } 1343 public HtmlCommentContext htmlComment(int i) { 1344 return getRuleContext(HtmlCommentContext.class,i); 1345 } 1346 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1347 public TerminalNode CDATA(int i) { 1348 return getToken(JavadocParser.CDATA, i); 1349 } 1350 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1351 public TerminalNode NEWLINE(int i) { 1352 return getToken(JavadocParser.NEWLINE, i); 1353 } 1354 public List<TextContext> text() { 1355 return getRuleContexts(TextContext.class); 1356 } 1357 public TextContext text(int i) { 1358 return getRuleContext(TextContext.class,i); 1359 } 1360 public List<JavadocInlineTagContext> javadocInlineTag() { 1361 return getRuleContexts(JavadocInlineTagContext.class); 1362 } 1363 public JavadocInlineTagContext javadocInlineTag(int i) { 1364 return getRuleContext(JavadocInlineTagContext.class,i); 1365 } 1366 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1367 public TerminalNode LEADING_ASTERISK(int i) { 1368 return getToken(JavadocParser.LEADING_ASTERISK, i); 1369 } 1370 public HtmlTagContext(ParserRuleContext parent, int invokingState) { 1371 super(parent, invokingState); 1372 } 1373 @Override public int getRuleIndex() { return RULE_htmlTag; } 1374 } 1375 1376 public final HtmlTagContext htmlTag() throws RecognitionException { 1377 HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState()); 1378 enterRule(_localctx, 10, RULE_htmlTag); 1379 try { 1380 int _alt; 1381 enterOuterAlt(_localctx, 1); 1382 { 1383 setState(327); 1384 ((HtmlTagContext)_localctx).htmlElementStart = htmlElementStart(); 1385 setState(338); 1386 _errHandler.sync(this); 1387 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1388 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1389 if ( _alt==1 ) { 1390 { 1391 setState(336); 1392 _errHandler.sync(this); 1393 switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { 1394 case 1: 1395 { 1396 setState(328); 1397 htmlElement(); 1398 } 1399 break; 1400 case 2: 1401 { 1402 { 1403 setState(329); 1404 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1405 setState(330); 1406 match(LEADING_ASTERISK); 1407 } 1408 } 1409 break; 1410 case 3: 1411 { 1412 setState(331); 1413 htmlComment(); 1414 } 1415 break; 1416 case 4: 1417 { 1418 setState(332); 1419 match(CDATA); 1420 } 1421 break; 1422 case 5: 1423 { 1424 setState(333); 1425 match(NEWLINE); 1426 } 1427 break; 1428 case 6: 1429 { 1430 setState(334); 1431 text(); 1432 } 1433 break; 1434 case 7: 1435 { 1436 setState(335); 1437 javadocInlineTag(); 1438 } 1439 break; 1440 } 1441 } 1442 } 1443 setState(340); 1444 _errHandler.sync(this); 1445 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1446 } 1447 setState(341); 1448 ((HtmlTagContext)_localctx).htmlElementEnd = htmlElementEnd(); 1449 setState(342); 1450 if (!(isSameTagNames(((HtmlTagContext)_localctx).htmlElementStart, ((HtmlTagContext)_localctx).htmlElementEnd))) throw new FailedPredicateException(this, "isSameTagNames($htmlElementStart.ctx, $htmlElementEnd.ctx)"); 1451 } 1452 } 1453 catch (RecognitionException re) { 1454 _localctx.exception = re; 1455 _errHandler.reportError(this, re); 1456 _errHandler.recover(this, re); 1457 } 1458 finally { 1459 exitRule(); 1460 } 1461 return _localctx; 1462 } 1463 1464 public static class PTagStartContext extends ParserRuleContext { 1465 public boolean isNonTight; 1466 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 1467 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1468 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 1469 public List<AttributeContext> attribute() { 1470 return getRuleContexts(AttributeContext.class); 1471 } 1472 public AttributeContext attribute(int i) { 1473 return getRuleContext(AttributeContext.class,i); 1474 } 1475 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1476 public TerminalNode NEWLINE(int i) { 1477 return getToken(JavadocParser.NEWLINE, i); 1478 } 1479 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1480 public TerminalNode LEADING_ASTERISK(int i) { 1481 return getToken(JavadocParser.LEADING_ASTERISK, i); 1482 } 1483 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1484 public TerminalNode WS(int i) { 1485 return getToken(JavadocParser.WS, i); 1486 } 1487 public PTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 1488 public PTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 1489 super(parent, invokingState); 1490 this.isNonTight = isNonTight; 1491 } 1492 @Override public int getRuleIndex() { return RULE_pTagStart; } 1493 } 1494 1495 public final PTagStartContext pTagStart(boolean isNonTight) throws RecognitionException { 1496 PTagStartContext _localctx = new PTagStartContext(_ctx, getState(), isNonTight); 1497 enterRule(_localctx, 12, RULE_pTagStart); 1498 int _la; 1499 try { 1500 enterOuterAlt(_localctx, 1); 1501 { 1502 setState(344); 1503 match(START); 1504 setState(345); 1505 match(P_HTML_TAG_NAME); 1506 setState(352); 1507 _errHandler.sync(this); 1508 _la = _input.LA(1); 1509 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 1510 { 1511 setState(350); 1512 _errHandler.sync(this); 1513 switch (_input.LA(1)) { 1514 case HTML_TAG_NAME: 1515 { 1516 setState(346); 1517 attribute(); 1518 } 1519 break; 1520 case NEWLINE: 1521 { 1522 setState(347); 1523 match(NEWLINE); 1524 } 1525 break; 1526 case LEADING_ASTERISK: 1527 { 1528 setState(348); 1529 match(LEADING_ASTERISK); 1530 } 1531 break; 1532 case WS: 1533 { 1534 setState(349); 1535 match(WS); 1536 } 1537 break; 1538 default: 1539 throw new NoViableAltException(this); 1540 } 1541 } 1542 setState(354); 1543 _errHandler.sync(this); 1544 _la = _input.LA(1); 1545 } 1546 setState(355); 1547 match(END); 1548 } 1549 _ctx.stop = _input.LT(-1); 1550 1551 if (isNonTight && nonTightTagStartContext == null) { 1552 nonTightTagStartContext = _localctx; 1553 } 1554 1555 } 1556 catch (RecognitionException re) { 1557 _localctx.exception = re; 1558 _errHandler.reportError(this, re); 1559 _errHandler.recover(this, re); 1560 } 1561 finally { 1562 exitRule(); 1563 } 1564 return _localctx; 1565 } 1566 1567 public static class PTagEndContext extends ParserRuleContext { 1568 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 1569 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1570 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1571 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 1572 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1573 public TerminalNode NEWLINE(int i) { 1574 return getToken(JavadocParser.NEWLINE, i); 1575 } 1576 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1577 public TerminalNode LEADING_ASTERISK(int i) { 1578 return getToken(JavadocParser.LEADING_ASTERISK, i); 1579 } 1580 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1581 public TerminalNode WS(int i) { 1582 return getToken(JavadocParser.WS, i); 1583 } 1584 public PTagEndContext(ParserRuleContext parent, int invokingState) { 1585 super(parent, invokingState); 1586 } 1587 @Override public int getRuleIndex() { return RULE_pTagEnd; } 1588 } 1589 1590 public final PTagEndContext pTagEnd() throws RecognitionException { 1591 PTagEndContext _localctx = new PTagEndContext(_ctx, getState()); 1592 enterRule(_localctx, 14, RULE_pTagEnd); 1593 int _la; 1594 try { 1595 enterOuterAlt(_localctx, 1); 1596 { 1597 setState(357); 1598 match(START); 1599 setState(358); 1600 match(SLASH); 1601 setState(359); 1602 match(P_HTML_TAG_NAME); 1603 setState(363); 1604 _errHandler.sync(this); 1605 _la = _input.LA(1); 1606 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1607 { 1608 { 1609 setState(360); 1610 _la = _input.LA(1); 1611 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1612 _errHandler.recoverInline(this); 1613 } 1614 else { 1615 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1616 _errHandler.reportMatch(this); 1617 consume(); 1618 } 1619 } 1620 } 1621 setState(365); 1622 _errHandler.sync(this); 1623 _la = _input.LA(1); 1624 } 1625 setState(366); 1626 match(END); 1627 } 1628 } 1629 catch (RecognitionException re) { 1630 _localctx.exception = re; 1631 _errHandler.reportError(this, re); 1632 _errHandler.recover(this, re); 1633 } 1634 finally { 1635 exitRule(); 1636 } 1637 return _localctx; 1638 } 1639 1640 public static class ParagraphContext extends ParserRuleContext { 1641 public PTagStartContext pTagStart() { 1642 return getRuleContext(PTagStartContext.class,0); 1643 } 1644 public PTagEndContext pTagEnd() { 1645 return getRuleContext(PTagEndContext.class,0); 1646 } 1647 public List<HtmlTagContext> htmlTag() { 1648 return getRuleContexts(HtmlTagContext.class); 1649 } 1650 public HtmlTagContext htmlTag(int i) { 1651 return getRuleContext(HtmlTagContext.class,i); 1652 } 1653 public List<SingletonElementContext> singletonElement() { 1654 return getRuleContexts(SingletonElementContext.class); 1655 } 1656 public SingletonElementContext singletonElement(int i) { 1657 return getRuleContext(SingletonElementContext.class,i); 1658 } 1659 public List<LiContext> li() { 1660 return getRuleContexts(LiContext.class); 1661 } 1662 public LiContext li(int i) { 1663 return getRuleContext(LiContext.class,i); 1664 } 1665 public List<TrContext> tr() { 1666 return getRuleContexts(TrContext.class); 1667 } 1668 public TrContext tr(int i) { 1669 return getRuleContext(TrContext.class,i); 1670 } 1671 public List<TdContext> td() { 1672 return getRuleContexts(TdContext.class); 1673 } 1674 public TdContext td(int i) { 1675 return getRuleContext(TdContext.class,i); 1676 } 1677 public List<ThContext> th() { 1678 return getRuleContexts(ThContext.class); 1679 } 1680 public ThContext th(int i) { 1681 return getRuleContext(ThContext.class,i); 1682 } 1683 public List<BodyContext> body() { 1684 return getRuleContexts(BodyContext.class); 1685 } 1686 public BodyContext body(int i) { 1687 return getRuleContext(BodyContext.class,i); 1688 } 1689 public List<ColgroupContext> colgroup() { 1690 return getRuleContexts(ColgroupContext.class); 1691 } 1692 public ColgroupContext colgroup(int i) { 1693 return getRuleContext(ColgroupContext.class,i); 1694 } 1695 public List<DdContext> dd() { 1696 return getRuleContexts(DdContext.class); 1697 } 1698 public DdContext dd(int i) { 1699 return getRuleContext(DdContext.class,i); 1700 } 1701 public List<DtContext> dt() { 1702 return getRuleContexts(DtContext.class); 1703 } 1704 public DtContext dt(int i) { 1705 return getRuleContext(DtContext.class,i); 1706 } 1707 public List<HeadContext> head() { 1708 return getRuleContexts(HeadContext.class); 1709 } 1710 public HeadContext head(int i) { 1711 return getRuleContext(HeadContext.class,i); 1712 } 1713 public List<HtmlContext> html() { 1714 return getRuleContexts(HtmlContext.class); 1715 } 1716 public HtmlContext html(int i) { 1717 return getRuleContext(HtmlContext.class,i); 1718 } 1719 public List<OptionContext> option() { 1720 return getRuleContexts(OptionContext.class); 1721 } 1722 public OptionContext option(int i) { 1723 return getRuleContext(OptionContext.class,i); 1724 } 1725 public List<TbodyContext> tbody() { 1726 return getRuleContexts(TbodyContext.class); 1727 } 1728 public TbodyContext tbody(int i) { 1729 return getRuleContext(TbodyContext.class,i); 1730 } 1731 public List<TheadContext> thead() { 1732 return getRuleContexts(TheadContext.class); 1733 } 1734 public TheadContext thead(int i) { 1735 return getRuleContext(TheadContext.class,i); 1736 } 1737 public List<TfootContext> tfoot() { 1738 return getRuleContexts(TfootContext.class); 1739 } 1740 public TfootContext tfoot(int i) { 1741 return getRuleContext(TfootContext.class,i); 1742 } 1743 public List<OptgroupContext> optgroup() { 1744 return getRuleContexts(OptgroupContext.class); 1745 } 1746 public OptgroupContext optgroup(int i) { 1747 return getRuleContext(OptgroupContext.class,i); 1748 } 1749 public List<RbContext> rb() { 1750 return getRuleContexts(RbContext.class); 1751 } 1752 public RbContext rb(int i) { 1753 return getRuleContext(RbContext.class,i); 1754 } 1755 public List<RtContext> rt() { 1756 return getRuleContexts(RtContext.class); 1757 } 1758 public RtContext rt(int i) { 1759 return getRuleContext(RtContext.class,i); 1760 } 1761 public List<RtcContext> rtc() { 1762 return getRuleContexts(RtcContext.class); 1763 } 1764 public RtcContext rtc(int i) { 1765 return getRuleContext(RtcContext.class,i); 1766 } 1767 public List<RpContext> rp() { 1768 return getRuleContexts(RpContext.class); 1769 } 1770 public RpContext rp(int i) { 1771 return getRuleContext(RpContext.class,i); 1772 } 1773 public List<LiTagStartContext> liTagStart() { 1774 return getRuleContexts(LiTagStartContext.class); 1775 } 1776 public LiTagStartContext liTagStart(int i) { 1777 return getRuleContext(LiTagStartContext.class,i); 1778 } 1779 public List<TrTagStartContext> trTagStart() { 1780 return getRuleContexts(TrTagStartContext.class); 1781 } 1782 public TrTagStartContext trTagStart(int i) { 1783 return getRuleContext(TrTagStartContext.class,i); 1784 } 1785 public List<TdTagStartContext> tdTagStart() { 1786 return getRuleContexts(TdTagStartContext.class); 1787 } 1788 public TdTagStartContext tdTagStart(int i) { 1789 return getRuleContext(TdTagStartContext.class,i); 1790 } 1791 public List<ThTagStartContext> thTagStart() { 1792 return getRuleContexts(ThTagStartContext.class); 1793 } 1794 public ThTagStartContext thTagStart(int i) { 1795 return getRuleContext(ThTagStartContext.class,i); 1796 } 1797 public List<BodyTagStartContext> bodyTagStart() { 1798 return getRuleContexts(BodyTagStartContext.class); 1799 } 1800 public BodyTagStartContext bodyTagStart(int i) { 1801 return getRuleContext(BodyTagStartContext.class,i); 1802 } 1803 public List<ColgroupTagStartContext> colgroupTagStart() { 1804 return getRuleContexts(ColgroupTagStartContext.class); 1805 } 1806 public ColgroupTagStartContext colgroupTagStart(int i) { 1807 return getRuleContext(ColgroupTagStartContext.class,i); 1808 } 1809 public List<DdTagStartContext> ddTagStart() { 1810 return getRuleContexts(DdTagStartContext.class); 1811 } 1812 public DdTagStartContext ddTagStart(int i) { 1813 return getRuleContext(DdTagStartContext.class,i); 1814 } 1815 public List<DtTagStartContext> dtTagStart() { 1816 return getRuleContexts(DtTagStartContext.class); 1817 } 1818 public DtTagStartContext dtTagStart(int i) { 1819 return getRuleContext(DtTagStartContext.class,i); 1820 } 1821 public List<HeadTagStartContext> headTagStart() { 1822 return getRuleContexts(HeadTagStartContext.class); 1823 } 1824 public HeadTagStartContext headTagStart(int i) { 1825 return getRuleContext(HeadTagStartContext.class,i); 1826 } 1827 public List<HtmlTagStartContext> htmlTagStart() { 1828 return getRuleContexts(HtmlTagStartContext.class); 1829 } 1830 public HtmlTagStartContext htmlTagStart(int i) { 1831 return getRuleContext(HtmlTagStartContext.class,i); 1832 } 1833 public List<OptionTagStartContext> optionTagStart() { 1834 return getRuleContexts(OptionTagStartContext.class); 1835 } 1836 public OptionTagStartContext optionTagStart(int i) { 1837 return getRuleContext(OptionTagStartContext.class,i); 1838 } 1839 public List<TbodyTagStartContext> tbodyTagStart() { 1840 return getRuleContexts(TbodyTagStartContext.class); 1841 } 1842 public TbodyTagStartContext tbodyTagStart(int i) { 1843 return getRuleContext(TbodyTagStartContext.class,i); 1844 } 1845 public List<TheadTagStartContext> theadTagStart() { 1846 return getRuleContexts(TheadTagStartContext.class); 1847 } 1848 public TheadTagStartContext theadTagStart(int i) { 1849 return getRuleContext(TheadTagStartContext.class,i); 1850 } 1851 public List<TfootTagStartContext> tfootTagStart() { 1852 return getRuleContexts(TfootTagStartContext.class); 1853 } 1854 public TfootTagStartContext tfootTagStart(int i) { 1855 return getRuleContext(TfootTagStartContext.class,i); 1856 } 1857 public List<OptgroupTagStartContext> optgroupTagStart() { 1858 return getRuleContexts(OptgroupTagStartContext.class); 1859 } 1860 public OptgroupTagStartContext optgroupTagStart(int i) { 1861 return getRuleContext(OptgroupTagStartContext.class,i); 1862 } 1863 public List<RbTagStartContext> rbTagStart() { 1864 return getRuleContexts(RbTagStartContext.class); 1865 } 1866 public RbTagStartContext rbTagStart(int i) { 1867 return getRuleContext(RbTagStartContext.class,i); 1868 } 1869 public List<RtTagStartContext> rtTagStart() { 1870 return getRuleContexts(RtTagStartContext.class); 1871 } 1872 public RtTagStartContext rtTagStart(int i) { 1873 return getRuleContext(RtTagStartContext.class,i); 1874 } 1875 public List<RtcTagStartContext> rtcTagStart() { 1876 return getRuleContexts(RtcTagStartContext.class); 1877 } 1878 public RtcTagStartContext rtcTagStart(int i) { 1879 return getRuleContext(RtcTagStartContext.class,i); 1880 } 1881 public List<RpTagStartContext> rpTagStart() { 1882 return getRuleContexts(RpTagStartContext.class); 1883 } 1884 public RpTagStartContext rpTagStart(int i) { 1885 return getRuleContext(RpTagStartContext.class,i); 1886 } 1887 public List<HtmlCommentContext> htmlComment() { 1888 return getRuleContexts(HtmlCommentContext.class); 1889 } 1890 public HtmlCommentContext htmlComment(int i) { 1891 return getRuleContext(HtmlCommentContext.class,i); 1892 } 1893 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1894 public TerminalNode CDATA(int i) { 1895 return getToken(JavadocParser.CDATA, i); 1896 } 1897 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1898 public TerminalNode NEWLINE(int i) { 1899 return getToken(JavadocParser.NEWLINE, i); 1900 } 1901 public List<TextContext> text() { 1902 return getRuleContexts(TextContext.class); 1903 } 1904 public TextContext text(int i) { 1905 return getRuleContext(TextContext.class,i); 1906 } 1907 public List<JavadocInlineTagContext> javadocInlineTag() { 1908 return getRuleContexts(JavadocInlineTagContext.class); 1909 } 1910 public JavadocInlineTagContext javadocInlineTag(int i) { 1911 return getRuleContext(JavadocInlineTagContext.class,i); 1912 } 1913 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1914 public TerminalNode LEADING_ASTERISK(int i) { 1915 return getToken(JavadocParser.LEADING_ASTERISK, i); 1916 } 1917 public ParagraphContext(ParserRuleContext parent, int invokingState) { 1918 super(parent, invokingState); 1919 } 1920 @Override public int getRuleIndex() { return RULE_paragraph; } 1921 } 1922 1923 public final ParagraphContext paragraph() throws RecognitionException { 1924 ParagraphContext _localctx = new ParagraphContext(_ctx, getState()); 1925 enterRule(_localctx, 16, RULE_paragraph); 1926 try { 1927 int _alt; 1928 enterOuterAlt(_localctx, 1); 1929 { 1930 setState(368); 1931 pTagStart(false); 1932 setState(418); 1933 _errHandler.sync(this); 1934 _alt = getInterpreter().adaptivePredict(_input,18,_ctx); 1935 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1936 if ( _alt==1 ) { 1937 { 1938 setState(416); 1939 _errHandler.sync(this); 1940 switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { 1941 case 1: 1942 { 1943 setState(369); 1944 htmlTag(); 1945 } 1946 break; 1947 case 2: 1948 { 1949 setState(370); 1950 singletonElement(); 1951 } 1952 break; 1953 case 3: 1954 { 1955 setState(371); 1956 li(); 1957 } 1958 break; 1959 case 4: 1960 { 1961 setState(372); 1962 tr(); 1963 } 1964 break; 1965 case 5: 1966 { 1967 setState(373); 1968 td(); 1969 } 1970 break; 1971 case 6: 1972 { 1973 setState(374); 1974 th(); 1975 } 1976 break; 1977 case 7: 1978 { 1979 setState(375); 1980 body(); 1981 } 1982 break; 1983 case 8: 1984 { 1985 setState(376); 1986 colgroup(); 1987 } 1988 break; 1989 case 9: 1990 { 1991 setState(377); 1992 dd(); 1993 } 1994 break; 1995 case 10: 1996 { 1997 setState(378); 1998 dt(); 1999 } 2000 break; 2001 case 11: 2002 { 2003 setState(379); 2004 head(); 2005 } 2006 break; 2007 case 12: 2008 { 2009 setState(380); 2010 html(); 2011 } 2012 break; 2013 case 13: 2014 { 2015 setState(381); 2016 option(); 2017 } 2018 break; 2019 case 14: 2020 { 2021 setState(382); 2022 tbody(); 2023 } 2024 break; 2025 case 15: 2026 { 2027 setState(383); 2028 thead(); 2029 } 2030 break; 2031 case 16: 2032 { 2033 setState(384); 2034 tfoot(); 2035 } 2036 break; 2037 case 17: 2038 { 2039 setState(385); 2040 optgroup(); 2041 } 2042 break; 2043 case 18: 2044 { 2045 setState(386); 2046 rb(); 2047 } 2048 break; 2049 case 19: 2050 { 2051 setState(387); 2052 rt(); 2053 } 2054 break; 2055 case 20: 2056 { 2057 setState(388); 2058 rtc(); 2059 } 2060 break; 2061 case 21: 2062 { 2063 setState(389); 2064 rp(); 2065 } 2066 break; 2067 case 22: 2068 { 2069 setState(390); 2070 liTagStart(true); 2071 } 2072 break; 2073 case 23: 2074 { 2075 setState(391); 2076 trTagStart(true); 2077 } 2078 break; 2079 case 24: 2080 { 2081 setState(392); 2082 tdTagStart(true); 2083 } 2084 break; 2085 case 25: 2086 { 2087 setState(393); 2088 thTagStart(true); 2089 } 2090 break; 2091 case 26: 2092 { 2093 setState(394); 2094 bodyTagStart(true); 2095 } 2096 break; 2097 case 27: 2098 { 2099 setState(395); 2100 colgroupTagStart(true); 2101 } 2102 break; 2103 case 28: 2104 { 2105 setState(396); 2106 ddTagStart(true); 2107 } 2108 break; 2109 case 29: 2110 { 2111 setState(397); 2112 dtTagStart(true); 2113 } 2114 break; 2115 case 30: 2116 { 2117 setState(398); 2118 headTagStart(true); 2119 } 2120 break; 2121 case 31: 2122 { 2123 setState(399); 2124 htmlTagStart(true); 2125 } 2126 break; 2127 case 32: 2128 { 2129 setState(400); 2130 optionTagStart(true); 2131 } 2132 break; 2133 case 33: 2134 { 2135 setState(401); 2136 tbodyTagStart(true); 2137 } 2138 break; 2139 case 34: 2140 { 2141 setState(402); 2142 theadTagStart(true); 2143 } 2144 break; 2145 case 35: 2146 { 2147 setState(403); 2148 tfootTagStart(true); 2149 } 2150 break; 2151 case 36: 2152 { 2153 setState(404); 2154 optgroupTagStart(true); 2155 } 2156 break; 2157 case 37: 2158 { 2159 setState(405); 2160 rbTagStart(true); 2161 } 2162 break; 2163 case 38: 2164 { 2165 setState(406); 2166 rtTagStart(true); 2167 } 2168 break; 2169 case 39: 2170 { 2171 setState(407); 2172 rtcTagStart(true); 2173 } 2174 break; 2175 case 40: 2176 { 2177 setState(408); 2178 rpTagStart(true); 2179 } 2180 break; 2181 case 41: 2182 { 2183 { 2184 setState(409); 2185 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2186 setState(410); 2187 match(LEADING_ASTERISK); 2188 } 2189 } 2190 break; 2191 case 42: 2192 { 2193 setState(411); 2194 htmlComment(); 2195 } 2196 break; 2197 case 43: 2198 { 2199 setState(412); 2200 match(CDATA); 2201 } 2202 break; 2203 case 44: 2204 { 2205 setState(413); 2206 match(NEWLINE); 2207 } 2208 break; 2209 case 45: 2210 { 2211 setState(414); 2212 text(); 2213 } 2214 break; 2215 case 46: 2216 { 2217 setState(415); 2218 javadocInlineTag(); 2219 } 2220 break; 2221 } 2222 } 2223 } 2224 setState(420); 2225 _errHandler.sync(this); 2226 _alt = getInterpreter().adaptivePredict(_input,18,_ctx); 2227 } 2228 setState(421); 2229 pTagEnd(); 2230 } 2231 } 2232 catch (RecognitionException re) { 2233 _localctx.exception = re; 2234 _errHandler.reportError(this, re); 2235 _errHandler.recover(this, re); 2236 } 2237 finally { 2238 exitRule(); 2239 } 2240 return _localctx; 2241 } 2242 2243 public static class LiTagStartContext extends ParserRuleContext { 2244 public boolean isNonTight; 2245 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 2246 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2247 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 2248 public List<AttributeContext> attribute() { 2249 return getRuleContexts(AttributeContext.class); 2250 } 2251 public AttributeContext attribute(int i) { 2252 return getRuleContext(AttributeContext.class,i); 2253 } 2254 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2255 public TerminalNode NEWLINE(int i) { 2256 return getToken(JavadocParser.NEWLINE, i); 2257 } 2258 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2259 public TerminalNode LEADING_ASTERISK(int i) { 2260 return getToken(JavadocParser.LEADING_ASTERISK, i); 2261 } 2262 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2263 public TerminalNode WS(int i) { 2264 return getToken(JavadocParser.WS, i); 2265 } 2266 public LiTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 2267 public LiTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 2268 super(parent, invokingState); 2269 this.isNonTight = isNonTight; 2270 } 2271 @Override public int getRuleIndex() { return RULE_liTagStart; } 2272 } 2273 2274 public final LiTagStartContext liTagStart(boolean isNonTight) throws RecognitionException { 2275 LiTagStartContext _localctx = new LiTagStartContext(_ctx, getState(), isNonTight); 2276 enterRule(_localctx, 18, RULE_liTagStart); 2277 int _la; 2278 try { 2279 enterOuterAlt(_localctx, 1); 2280 { 2281 setState(423); 2282 match(START); 2283 setState(424); 2284 match(LI_HTML_TAG_NAME); 2285 setState(431); 2286 _errHandler.sync(this); 2287 _la = _input.LA(1); 2288 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2289 { 2290 setState(429); 2291 _errHandler.sync(this); 2292 switch (_input.LA(1)) { 2293 case HTML_TAG_NAME: 2294 { 2295 setState(425); 2296 attribute(); 2297 } 2298 break; 2299 case NEWLINE: 2300 { 2301 setState(426); 2302 match(NEWLINE); 2303 } 2304 break; 2305 case LEADING_ASTERISK: 2306 { 2307 setState(427); 2308 match(LEADING_ASTERISK); 2309 } 2310 break; 2311 case WS: 2312 { 2313 setState(428); 2314 match(WS); 2315 } 2316 break; 2317 default: 2318 throw new NoViableAltException(this); 2319 } 2320 } 2321 setState(433); 2322 _errHandler.sync(this); 2323 _la = _input.LA(1); 2324 } 2325 setState(434); 2326 match(END); 2327 } 2328 _ctx.stop = _input.LT(-1); 2329 2330 if (isNonTight && nonTightTagStartContext == null) { 2331 nonTightTagStartContext = _localctx; 2332 } 2333 2334 } 2335 catch (RecognitionException re) { 2336 _localctx.exception = re; 2337 _errHandler.reportError(this, re); 2338 _errHandler.recover(this, re); 2339 } 2340 finally { 2341 exitRule(); 2342 } 2343 return _localctx; 2344 } 2345 2346 public static class LiTagEndContext extends ParserRuleContext { 2347 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 2348 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2349 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2350 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 2351 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2352 public TerminalNode NEWLINE(int i) { 2353 return getToken(JavadocParser.NEWLINE, i); 2354 } 2355 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2356 public TerminalNode LEADING_ASTERISK(int i) { 2357 return getToken(JavadocParser.LEADING_ASTERISK, i); 2358 } 2359 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2360 public TerminalNode WS(int i) { 2361 return getToken(JavadocParser.WS, i); 2362 } 2363 public LiTagEndContext(ParserRuleContext parent, int invokingState) { 2364 super(parent, invokingState); 2365 } 2366 @Override public int getRuleIndex() { return RULE_liTagEnd; } 2367 } 2368 2369 public final LiTagEndContext liTagEnd() throws RecognitionException { 2370 LiTagEndContext _localctx = new LiTagEndContext(_ctx, getState()); 2371 enterRule(_localctx, 20, RULE_liTagEnd); 2372 int _la; 2373 try { 2374 enterOuterAlt(_localctx, 1); 2375 { 2376 setState(436); 2377 match(START); 2378 setState(437); 2379 match(SLASH); 2380 setState(438); 2381 match(LI_HTML_TAG_NAME); 2382 setState(442); 2383 _errHandler.sync(this); 2384 _la = _input.LA(1); 2385 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2386 { 2387 { 2388 setState(439); 2389 _la = _input.LA(1); 2390 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2391 _errHandler.recoverInline(this); 2392 } 2393 else { 2394 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 2395 _errHandler.reportMatch(this); 2396 consume(); 2397 } 2398 } 2399 } 2400 setState(444); 2401 _errHandler.sync(this); 2402 _la = _input.LA(1); 2403 } 2404 setState(445); 2405 match(END); 2406 } 2407 } 2408 catch (RecognitionException re) { 2409 _localctx.exception = re; 2410 _errHandler.reportError(this, re); 2411 _errHandler.recover(this, re); 2412 } 2413 finally { 2414 exitRule(); 2415 } 2416 return _localctx; 2417 } 2418 2419 public static class LiContext extends ParserRuleContext { 2420 public LiTagStartContext liTagStart() { 2421 return getRuleContext(LiTagStartContext.class,0); 2422 } 2423 public LiTagEndContext liTagEnd() { 2424 return getRuleContext(LiTagEndContext.class,0); 2425 } 2426 public List<HtmlTagContext> htmlTag() { 2427 return getRuleContexts(HtmlTagContext.class); 2428 } 2429 public HtmlTagContext htmlTag(int i) { 2430 return getRuleContext(HtmlTagContext.class,i); 2431 } 2432 public List<SingletonElementContext> singletonElement() { 2433 return getRuleContexts(SingletonElementContext.class); 2434 } 2435 public SingletonElementContext singletonElement(int i) { 2436 return getRuleContext(SingletonElementContext.class,i); 2437 } 2438 public List<ParagraphContext> paragraph() { 2439 return getRuleContexts(ParagraphContext.class); 2440 } 2441 public ParagraphContext paragraph(int i) { 2442 return getRuleContext(ParagraphContext.class,i); 2443 } 2444 public List<TrContext> tr() { 2445 return getRuleContexts(TrContext.class); 2446 } 2447 public TrContext tr(int i) { 2448 return getRuleContext(TrContext.class,i); 2449 } 2450 public List<TdContext> td() { 2451 return getRuleContexts(TdContext.class); 2452 } 2453 public TdContext td(int i) { 2454 return getRuleContext(TdContext.class,i); 2455 } 2456 public List<ThContext> th() { 2457 return getRuleContexts(ThContext.class); 2458 } 2459 public ThContext th(int i) { 2460 return getRuleContext(ThContext.class,i); 2461 } 2462 public List<BodyContext> body() { 2463 return getRuleContexts(BodyContext.class); 2464 } 2465 public BodyContext body(int i) { 2466 return getRuleContext(BodyContext.class,i); 2467 } 2468 public List<ColgroupContext> colgroup() { 2469 return getRuleContexts(ColgroupContext.class); 2470 } 2471 public ColgroupContext colgroup(int i) { 2472 return getRuleContext(ColgroupContext.class,i); 2473 } 2474 public List<DdContext> dd() { 2475 return getRuleContexts(DdContext.class); 2476 } 2477 public DdContext dd(int i) { 2478 return getRuleContext(DdContext.class,i); 2479 } 2480 public List<DtContext> dt() { 2481 return getRuleContexts(DtContext.class); 2482 } 2483 public DtContext dt(int i) { 2484 return getRuleContext(DtContext.class,i); 2485 } 2486 public List<HeadContext> head() { 2487 return getRuleContexts(HeadContext.class); 2488 } 2489 public HeadContext head(int i) { 2490 return getRuleContext(HeadContext.class,i); 2491 } 2492 public List<HtmlContext> html() { 2493 return getRuleContexts(HtmlContext.class); 2494 } 2495 public HtmlContext html(int i) { 2496 return getRuleContext(HtmlContext.class,i); 2497 } 2498 public List<OptionContext> option() { 2499 return getRuleContexts(OptionContext.class); 2500 } 2501 public OptionContext option(int i) { 2502 return getRuleContext(OptionContext.class,i); 2503 } 2504 public List<TbodyContext> tbody() { 2505 return getRuleContexts(TbodyContext.class); 2506 } 2507 public TbodyContext tbody(int i) { 2508 return getRuleContext(TbodyContext.class,i); 2509 } 2510 public List<TheadContext> thead() { 2511 return getRuleContexts(TheadContext.class); 2512 } 2513 public TheadContext thead(int i) { 2514 return getRuleContext(TheadContext.class,i); 2515 } 2516 public List<TfootContext> tfoot() { 2517 return getRuleContexts(TfootContext.class); 2518 } 2519 public TfootContext tfoot(int i) { 2520 return getRuleContext(TfootContext.class,i); 2521 } 2522 public List<OptgroupContext> optgroup() { 2523 return getRuleContexts(OptgroupContext.class); 2524 } 2525 public OptgroupContext optgroup(int i) { 2526 return getRuleContext(OptgroupContext.class,i); 2527 } 2528 public List<RbContext> rb() { 2529 return getRuleContexts(RbContext.class); 2530 } 2531 public RbContext rb(int i) { 2532 return getRuleContext(RbContext.class,i); 2533 } 2534 public List<RtContext> rt() { 2535 return getRuleContexts(RtContext.class); 2536 } 2537 public RtContext rt(int i) { 2538 return getRuleContext(RtContext.class,i); 2539 } 2540 public List<RtcContext> rtc() { 2541 return getRuleContexts(RtcContext.class); 2542 } 2543 public RtcContext rtc(int i) { 2544 return getRuleContext(RtcContext.class,i); 2545 } 2546 public List<RpContext> rp() { 2547 return getRuleContexts(RpContext.class); 2548 } 2549 public RpContext rp(int i) { 2550 return getRuleContext(RpContext.class,i); 2551 } 2552 public List<PTagStartContext> pTagStart() { 2553 return getRuleContexts(PTagStartContext.class); 2554 } 2555 public PTagStartContext pTagStart(int i) { 2556 return getRuleContext(PTagStartContext.class,i); 2557 } 2558 public List<TrTagStartContext> trTagStart() { 2559 return getRuleContexts(TrTagStartContext.class); 2560 } 2561 public TrTagStartContext trTagStart(int i) { 2562 return getRuleContext(TrTagStartContext.class,i); 2563 } 2564 public List<TdTagStartContext> tdTagStart() { 2565 return getRuleContexts(TdTagStartContext.class); 2566 } 2567 public TdTagStartContext tdTagStart(int i) { 2568 return getRuleContext(TdTagStartContext.class,i); 2569 } 2570 public List<ThTagStartContext> thTagStart() { 2571 return getRuleContexts(ThTagStartContext.class); 2572 } 2573 public ThTagStartContext thTagStart(int i) { 2574 return getRuleContext(ThTagStartContext.class,i); 2575 } 2576 public List<BodyTagStartContext> bodyTagStart() { 2577 return getRuleContexts(BodyTagStartContext.class); 2578 } 2579 public BodyTagStartContext bodyTagStart(int i) { 2580 return getRuleContext(BodyTagStartContext.class,i); 2581 } 2582 public List<ColgroupTagStartContext> colgroupTagStart() { 2583 return getRuleContexts(ColgroupTagStartContext.class); 2584 } 2585 public ColgroupTagStartContext colgroupTagStart(int i) { 2586 return getRuleContext(ColgroupTagStartContext.class,i); 2587 } 2588 public List<DdTagStartContext> ddTagStart() { 2589 return getRuleContexts(DdTagStartContext.class); 2590 } 2591 public DdTagStartContext ddTagStart(int i) { 2592 return getRuleContext(DdTagStartContext.class,i); 2593 } 2594 public List<DtTagStartContext> dtTagStart() { 2595 return getRuleContexts(DtTagStartContext.class); 2596 } 2597 public DtTagStartContext dtTagStart(int i) { 2598 return getRuleContext(DtTagStartContext.class,i); 2599 } 2600 public List<HeadTagStartContext> headTagStart() { 2601 return getRuleContexts(HeadTagStartContext.class); 2602 } 2603 public HeadTagStartContext headTagStart(int i) { 2604 return getRuleContext(HeadTagStartContext.class,i); 2605 } 2606 public List<HtmlTagStartContext> htmlTagStart() { 2607 return getRuleContexts(HtmlTagStartContext.class); 2608 } 2609 public HtmlTagStartContext htmlTagStart(int i) { 2610 return getRuleContext(HtmlTagStartContext.class,i); 2611 } 2612 public List<OptionTagStartContext> optionTagStart() { 2613 return getRuleContexts(OptionTagStartContext.class); 2614 } 2615 public OptionTagStartContext optionTagStart(int i) { 2616 return getRuleContext(OptionTagStartContext.class,i); 2617 } 2618 public List<TbodyTagStartContext> tbodyTagStart() { 2619 return getRuleContexts(TbodyTagStartContext.class); 2620 } 2621 public TbodyTagStartContext tbodyTagStart(int i) { 2622 return getRuleContext(TbodyTagStartContext.class,i); 2623 } 2624 public List<TheadTagStartContext> theadTagStart() { 2625 return getRuleContexts(TheadTagStartContext.class); 2626 } 2627 public TheadTagStartContext theadTagStart(int i) { 2628 return getRuleContext(TheadTagStartContext.class,i); 2629 } 2630 public List<TfootTagStartContext> tfootTagStart() { 2631 return getRuleContexts(TfootTagStartContext.class); 2632 } 2633 public TfootTagStartContext tfootTagStart(int i) { 2634 return getRuleContext(TfootTagStartContext.class,i); 2635 } 2636 public List<OptgroupTagStartContext> optgroupTagStart() { 2637 return getRuleContexts(OptgroupTagStartContext.class); 2638 } 2639 public OptgroupTagStartContext optgroupTagStart(int i) { 2640 return getRuleContext(OptgroupTagStartContext.class,i); 2641 } 2642 public List<RbTagStartContext> rbTagStart() { 2643 return getRuleContexts(RbTagStartContext.class); 2644 } 2645 public RbTagStartContext rbTagStart(int i) { 2646 return getRuleContext(RbTagStartContext.class,i); 2647 } 2648 public List<RtTagStartContext> rtTagStart() { 2649 return getRuleContexts(RtTagStartContext.class); 2650 } 2651 public RtTagStartContext rtTagStart(int i) { 2652 return getRuleContext(RtTagStartContext.class,i); 2653 } 2654 public List<RtcTagStartContext> rtcTagStart() { 2655 return getRuleContexts(RtcTagStartContext.class); 2656 } 2657 public RtcTagStartContext rtcTagStart(int i) { 2658 return getRuleContext(RtcTagStartContext.class,i); 2659 } 2660 public List<RpTagStartContext> rpTagStart() { 2661 return getRuleContexts(RpTagStartContext.class); 2662 } 2663 public RpTagStartContext rpTagStart(int i) { 2664 return getRuleContext(RpTagStartContext.class,i); 2665 } 2666 public List<HtmlCommentContext> htmlComment() { 2667 return getRuleContexts(HtmlCommentContext.class); 2668 } 2669 public HtmlCommentContext htmlComment(int i) { 2670 return getRuleContext(HtmlCommentContext.class,i); 2671 } 2672 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 2673 public TerminalNode CDATA(int i) { 2674 return getToken(JavadocParser.CDATA, i); 2675 } 2676 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2677 public TerminalNode NEWLINE(int i) { 2678 return getToken(JavadocParser.NEWLINE, i); 2679 } 2680 public List<TextContext> text() { 2681 return getRuleContexts(TextContext.class); 2682 } 2683 public TextContext text(int i) { 2684 return getRuleContext(TextContext.class,i); 2685 } 2686 public List<JavadocInlineTagContext> javadocInlineTag() { 2687 return getRuleContexts(JavadocInlineTagContext.class); 2688 } 2689 public JavadocInlineTagContext javadocInlineTag(int i) { 2690 return getRuleContext(JavadocInlineTagContext.class,i); 2691 } 2692 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2693 public TerminalNode LEADING_ASTERISK(int i) { 2694 return getToken(JavadocParser.LEADING_ASTERISK, i); 2695 } 2696 public LiContext(ParserRuleContext parent, int invokingState) { 2697 super(parent, invokingState); 2698 } 2699 @Override public int getRuleIndex() { return RULE_li; } 2700 } 2701 2702 public final LiContext li() throws RecognitionException { 2703 LiContext _localctx = new LiContext(_ctx, getState()); 2704 enterRule(_localctx, 22, RULE_li); 2705 try { 2706 int _alt; 2707 enterOuterAlt(_localctx, 1); 2708 { 2709 setState(447); 2710 liTagStart(false); 2711 setState(497); 2712 _errHandler.sync(this); 2713 _alt = getInterpreter().adaptivePredict(_input,23,_ctx); 2714 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 2715 if ( _alt==1 ) { 2716 { 2717 setState(495); 2718 _errHandler.sync(this); 2719 switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) { 2720 case 1: 2721 { 2722 setState(448); 2723 htmlTag(); 2724 } 2725 break; 2726 case 2: 2727 { 2728 setState(449); 2729 singletonElement(); 2730 } 2731 break; 2732 case 3: 2733 { 2734 setState(450); 2735 paragraph(); 2736 } 2737 break; 2738 case 4: 2739 { 2740 setState(451); 2741 tr(); 2742 } 2743 break; 2744 case 5: 2745 { 2746 setState(452); 2747 td(); 2748 } 2749 break; 2750 case 6: 2751 { 2752 setState(453); 2753 th(); 2754 } 2755 break; 2756 case 7: 2757 { 2758 setState(454); 2759 body(); 2760 } 2761 break; 2762 case 8: 2763 { 2764 setState(455); 2765 colgroup(); 2766 } 2767 break; 2768 case 9: 2769 { 2770 setState(456); 2771 dd(); 2772 } 2773 break; 2774 case 10: 2775 { 2776 setState(457); 2777 dt(); 2778 } 2779 break; 2780 case 11: 2781 { 2782 setState(458); 2783 head(); 2784 } 2785 break; 2786 case 12: 2787 { 2788 setState(459); 2789 html(); 2790 } 2791 break; 2792 case 13: 2793 { 2794 setState(460); 2795 option(); 2796 } 2797 break; 2798 case 14: 2799 { 2800 setState(461); 2801 tbody(); 2802 } 2803 break; 2804 case 15: 2805 { 2806 setState(462); 2807 thead(); 2808 } 2809 break; 2810 case 16: 2811 { 2812 setState(463); 2813 tfoot(); 2814 } 2815 break; 2816 case 17: 2817 { 2818 setState(464); 2819 optgroup(); 2820 } 2821 break; 2822 case 18: 2823 { 2824 setState(465); 2825 rb(); 2826 } 2827 break; 2828 case 19: 2829 { 2830 setState(466); 2831 rt(); 2832 } 2833 break; 2834 case 20: 2835 { 2836 setState(467); 2837 rtc(); 2838 } 2839 break; 2840 case 21: 2841 { 2842 setState(468); 2843 rp(); 2844 } 2845 break; 2846 case 22: 2847 { 2848 setState(469); 2849 pTagStart(true); 2850 } 2851 break; 2852 case 23: 2853 { 2854 setState(470); 2855 trTagStart(true); 2856 } 2857 break; 2858 case 24: 2859 { 2860 setState(471); 2861 tdTagStart(true); 2862 } 2863 break; 2864 case 25: 2865 { 2866 setState(472); 2867 thTagStart(true); 2868 } 2869 break; 2870 case 26: 2871 { 2872 setState(473); 2873 bodyTagStart(true); 2874 } 2875 break; 2876 case 27: 2877 { 2878 setState(474); 2879 colgroupTagStart(true); 2880 } 2881 break; 2882 case 28: 2883 { 2884 setState(475); 2885 ddTagStart(true); 2886 } 2887 break; 2888 case 29: 2889 { 2890 setState(476); 2891 dtTagStart(true); 2892 } 2893 break; 2894 case 30: 2895 { 2896 setState(477); 2897 headTagStart(true); 2898 } 2899 break; 2900 case 31: 2901 { 2902 setState(478); 2903 htmlTagStart(true); 2904 } 2905 break; 2906 case 32: 2907 { 2908 setState(479); 2909 optionTagStart(true); 2910 } 2911 break; 2912 case 33: 2913 { 2914 setState(480); 2915 tbodyTagStart(true); 2916 } 2917 break; 2918 case 34: 2919 { 2920 setState(481); 2921 theadTagStart(true); 2922 } 2923 break; 2924 case 35: 2925 { 2926 setState(482); 2927 tfootTagStart(true); 2928 } 2929 break; 2930 case 36: 2931 { 2932 setState(483); 2933 optgroupTagStart(true); 2934 } 2935 break; 2936 case 37: 2937 { 2938 setState(484); 2939 rbTagStart(true); 2940 } 2941 break; 2942 case 38: 2943 { 2944 setState(485); 2945 rtTagStart(true); 2946 } 2947 break; 2948 case 39: 2949 { 2950 setState(486); 2951 rtcTagStart(true); 2952 } 2953 break; 2954 case 40: 2955 { 2956 setState(487); 2957 rpTagStart(true); 2958 } 2959 break; 2960 case 41: 2961 { 2962 { 2963 setState(488); 2964 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2965 setState(489); 2966 match(LEADING_ASTERISK); 2967 } 2968 } 2969 break; 2970 case 42: 2971 { 2972 setState(490); 2973 htmlComment(); 2974 } 2975 break; 2976 case 43: 2977 { 2978 setState(491); 2979 match(CDATA); 2980 } 2981 break; 2982 case 44: 2983 { 2984 setState(492); 2985 match(NEWLINE); 2986 } 2987 break; 2988 case 45: 2989 { 2990 setState(493); 2991 text(); 2992 } 2993 break; 2994 case 46: 2995 { 2996 setState(494); 2997 javadocInlineTag(); 2998 } 2999 break; 3000 } 3001 } 3002 } 3003 setState(499); 3004 _errHandler.sync(this); 3005 _alt = getInterpreter().adaptivePredict(_input,23,_ctx); 3006 } 3007 setState(500); 3008 liTagEnd(); 3009 } 3010 } 3011 catch (RecognitionException re) { 3012 _localctx.exception = re; 3013 _errHandler.reportError(this, re); 3014 _errHandler.recover(this, re); 3015 } 3016 finally { 3017 exitRule(); 3018 } 3019 return _localctx; 3020 } 3021 3022 public static class TrTagStartContext extends ParserRuleContext { 3023 public boolean isNonTight; 3024 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 3025 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 3026 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 3027 public List<AttributeContext> attribute() { 3028 return getRuleContexts(AttributeContext.class); 3029 } 3030 public AttributeContext attribute(int i) { 3031 return getRuleContext(AttributeContext.class,i); 3032 } 3033 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3034 public TerminalNode NEWLINE(int i) { 3035 return getToken(JavadocParser.NEWLINE, i); 3036 } 3037 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3038 public TerminalNode LEADING_ASTERISK(int i) { 3039 return getToken(JavadocParser.LEADING_ASTERISK, i); 3040 } 3041 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3042 public TerminalNode WS(int i) { 3043 return getToken(JavadocParser.WS, i); 3044 } 3045 public TrTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 3046 public TrTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 3047 super(parent, invokingState); 3048 this.isNonTight = isNonTight; 3049 } 3050 @Override public int getRuleIndex() { return RULE_trTagStart; } 3051 } 3052 3053 public final TrTagStartContext trTagStart(boolean isNonTight) throws RecognitionException { 3054 TrTagStartContext _localctx = new TrTagStartContext(_ctx, getState(), isNonTight); 3055 enterRule(_localctx, 24, RULE_trTagStart); 3056 int _la; 3057 try { 3058 enterOuterAlt(_localctx, 1); 3059 { 3060 setState(502); 3061 match(START); 3062 setState(503); 3063 match(TR_HTML_TAG_NAME); 3064 setState(510); 3065 _errHandler.sync(this); 3066 _la = _input.LA(1); 3067 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 3068 { 3069 setState(508); 3070 _errHandler.sync(this); 3071 switch (_input.LA(1)) { 3072 case HTML_TAG_NAME: 3073 { 3074 setState(504); 3075 attribute(); 3076 } 3077 break; 3078 case NEWLINE: 3079 { 3080 setState(505); 3081 match(NEWLINE); 3082 } 3083 break; 3084 case LEADING_ASTERISK: 3085 { 3086 setState(506); 3087 match(LEADING_ASTERISK); 3088 } 3089 break; 3090 case WS: 3091 { 3092 setState(507); 3093 match(WS); 3094 } 3095 break; 3096 default: 3097 throw new NoViableAltException(this); 3098 } 3099 } 3100 setState(512); 3101 _errHandler.sync(this); 3102 _la = _input.LA(1); 3103 } 3104 setState(513); 3105 match(END); 3106 } 3107 _ctx.stop = _input.LT(-1); 3108 3109 if (isNonTight && nonTightTagStartContext == null) { 3110 nonTightTagStartContext = _localctx; 3111 } 3112 3113 } 3114 catch (RecognitionException re) { 3115 _localctx.exception = re; 3116 _errHandler.reportError(this, re); 3117 _errHandler.recover(this, re); 3118 } 3119 finally { 3120 exitRule(); 3121 } 3122 return _localctx; 3123 } 3124 3125 public static class TrTagEndContext extends ParserRuleContext { 3126 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 3127 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 3128 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 3129 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 3130 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3131 public TerminalNode NEWLINE(int i) { 3132 return getToken(JavadocParser.NEWLINE, i); 3133 } 3134 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3135 public TerminalNode LEADING_ASTERISK(int i) { 3136 return getToken(JavadocParser.LEADING_ASTERISK, i); 3137 } 3138 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3139 public TerminalNode WS(int i) { 3140 return getToken(JavadocParser.WS, i); 3141 } 3142 public TrTagEndContext(ParserRuleContext parent, int invokingState) { 3143 super(parent, invokingState); 3144 } 3145 @Override public int getRuleIndex() { return RULE_trTagEnd; } 3146 } 3147 3148 public final TrTagEndContext trTagEnd() throws RecognitionException { 3149 TrTagEndContext _localctx = new TrTagEndContext(_ctx, getState()); 3150 enterRule(_localctx, 26, RULE_trTagEnd); 3151 int _la; 3152 try { 3153 enterOuterAlt(_localctx, 1); 3154 { 3155 setState(515); 3156 match(START); 3157 setState(516); 3158 match(SLASH); 3159 setState(517); 3160 match(TR_HTML_TAG_NAME); 3161 setState(521); 3162 _errHandler.sync(this); 3163 _la = _input.LA(1); 3164 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 3165 { 3166 { 3167 setState(518); 3168 _la = _input.LA(1); 3169 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 3170 _errHandler.recoverInline(this); 3171 } 3172 else { 3173 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3174 _errHandler.reportMatch(this); 3175 consume(); 3176 } 3177 } 3178 } 3179 setState(523); 3180 _errHandler.sync(this); 3181 _la = _input.LA(1); 3182 } 3183 setState(524); 3184 match(END); 3185 } 3186 } 3187 catch (RecognitionException re) { 3188 _localctx.exception = re; 3189 _errHandler.reportError(this, re); 3190 _errHandler.recover(this, re); 3191 } 3192 finally { 3193 exitRule(); 3194 } 3195 return _localctx; 3196 } 3197 3198 public static class TrContext extends ParserRuleContext { 3199 public TrTagStartContext trTagStart() { 3200 return getRuleContext(TrTagStartContext.class,0); 3201 } 3202 public TrTagEndContext trTagEnd() { 3203 return getRuleContext(TrTagEndContext.class,0); 3204 } 3205 public List<HtmlTagContext> htmlTag() { 3206 return getRuleContexts(HtmlTagContext.class); 3207 } 3208 public HtmlTagContext htmlTag(int i) { 3209 return getRuleContext(HtmlTagContext.class,i); 3210 } 3211 public List<SingletonElementContext> singletonElement() { 3212 return getRuleContexts(SingletonElementContext.class); 3213 } 3214 public SingletonElementContext singletonElement(int i) { 3215 return getRuleContext(SingletonElementContext.class,i); 3216 } 3217 public List<ParagraphContext> paragraph() { 3218 return getRuleContexts(ParagraphContext.class); 3219 } 3220 public ParagraphContext paragraph(int i) { 3221 return getRuleContext(ParagraphContext.class,i); 3222 } 3223 public List<LiContext> li() { 3224 return getRuleContexts(LiContext.class); 3225 } 3226 public LiContext li(int i) { 3227 return getRuleContext(LiContext.class,i); 3228 } 3229 public List<TdContext> td() { 3230 return getRuleContexts(TdContext.class); 3231 } 3232 public TdContext td(int i) { 3233 return getRuleContext(TdContext.class,i); 3234 } 3235 public List<ThContext> th() { 3236 return getRuleContexts(ThContext.class); 3237 } 3238 public ThContext th(int i) { 3239 return getRuleContext(ThContext.class,i); 3240 } 3241 public List<BodyContext> body() { 3242 return getRuleContexts(BodyContext.class); 3243 } 3244 public BodyContext body(int i) { 3245 return getRuleContext(BodyContext.class,i); 3246 } 3247 public List<ColgroupContext> colgroup() { 3248 return getRuleContexts(ColgroupContext.class); 3249 } 3250 public ColgroupContext colgroup(int i) { 3251 return getRuleContext(ColgroupContext.class,i); 3252 } 3253 public List<DdContext> dd() { 3254 return getRuleContexts(DdContext.class); 3255 } 3256 public DdContext dd(int i) { 3257 return getRuleContext(DdContext.class,i); 3258 } 3259 public List<DtContext> dt() { 3260 return getRuleContexts(DtContext.class); 3261 } 3262 public DtContext dt(int i) { 3263 return getRuleContext(DtContext.class,i); 3264 } 3265 public List<HeadContext> head() { 3266 return getRuleContexts(HeadContext.class); 3267 } 3268 public HeadContext head(int i) { 3269 return getRuleContext(HeadContext.class,i); 3270 } 3271 public List<HtmlContext> html() { 3272 return getRuleContexts(HtmlContext.class); 3273 } 3274 public HtmlContext html(int i) { 3275 return getRuleContext(HtmlContext.class,i); 3276 } 3277 public List<OptionContext> option() { 3278 return getRuleContexts(OptionContext.class); 3279 } 3280 public OptionContext option(int i) { 3281 return getRuleContext(OptionContext.class,i); 3282 } 3283 public List<TbodyContext> tbody() { 3284 return getRuleContexts(TbodyContext.class); 3285 } 3286 public TbodyContext tbody(int i) { 3287 return getRuleContext(TbodyContext.class,i); 3288 } 3289 public List<TheadContext> thead() { 3290 return getRuleContexts(TheadContext.class); 3291 } 3292 public TheadContext thead(int i) { 3293 return getRuleContext(TheadContext.class,i); 3294 } 3295 public List<TfootContext> tfoot() { 3296 return getRuleContexts(TfootContext.class); 3297 } 3298 public TfootContext tfoot(int i) { 3299 return getRuleContext(TfootContext.class,i); 3300 } 3301 public List<OptgroupContext> optgroup() { 3302 return getRuleContexts(OptgroupContext.class); 3303 } 3304 public OptgroupContext optgroup(int i) { 3305 return getRuleContext(OptgroupContext.class,i); 3306 } 3307 public List<RbContext> rb() { 3308 return getRuleContexts(RbContext.class); 3309 } 3310 public RbContext rb(int i) { 3311 return getRuleContext(RbContext.class,i); 3312 } 3313 public List<RtContext> rt() { 3314 return getRuleContexts(RtContext.class); 3315 } 3316 public RtContext rt(int i) { 3317 return getRuleContext(RtContext.class,i); 3318 } 3319 public List<RtcContext> rtc() { 3320 return getRuleContexts(RtcContext.class); 3321 } 3322 public RtcContext rtc(int i) { 3323 return getRuleContext(RtcContext.class,i); 3324 } 3325 public List<RpContext> rp() { 3326 return getRuleContexts(RpContext.class); 3327 } 3328 public RpContext rp(int i) { 3329 return getRuleContext(RpContext.class,i); 3330 } 3331 public List<PTagStartContext> pTagStart() { 3332 return getRuleContexts(PTagStartContext.class); 3333 } 3334 public PTagStartContext pTagStart(int i) { 3335 return getRuleContext(PTagStartContext.class,i); 3336 } 3337 public List<LiTagStartContext> liTagStart() { 3338 return getRuleContexts(LiTagStartContext.class); 3339 } 3340 public LiTagStartContext liTagStart(int i) { 3341 return getRuleContext(LiTagStartContext.class,i); 3342 } 3343 public List<TdTagStartContext> tdTagStart() { 3344 return getRuleContexts(TdTagStartContext.class); 3345 } 3346 public TdTagStartContext tdTagStart(int i) { 3347 return getRuleContext(TdTagStartContext.class,i); 3348 } 3349 public List<ThTagStartContext> thTagStart() { 3350 return getRuleContexts(ThTagStartContext.class); 3351 } 3352 public ThTagStartContext thTagStart(int i) { 3353 return getRuleContext(ThTagStartContext.class,i); 3354 } 3355 public List<BodyTagStartContext> bodyTagStart() { 3356 return getRuleContexts(BodyTagStartContext.class); 3357 } 3358 public BodyTagStartContext bodyTagStart(int i) { 3359 return getRuleContext(BodyTagStartContext.class,i); 3360 } 3361 public List<ColgroupTagStartContext> colgroupTagStart() { 3362 return getRuleContexts(ColgroupTagStartContext.class); 3363 } 3364 public ColgroupTagStartContext colgroupTagStart(int i) { 3365 return getRuleContext(ColgroupTagStartContext.class,i); 3366 } 3367 public List<DdTagStartContext> ddTagStart() { 3368 return getRuleContexts(DdTagStartContext.class); 3369 } 3370 public DdTagStartContext ddTagStart(int i) { 3371 return getRuleContext(DdTagStartContext.class,i); 3372 } 3373 public List<DtTagStartContext> dtTagStart() { 3374 return getRuleContexts(DtTagStartContext.class); 3375 } 3376 public DtTagStartContext dtTagStart(int i) { 3377 return getRuleContext(DtTagStartContext.class,i); 3378 } 3379 public List<HeadTagStartContext> headTagStart() { 3380 return getRuleContexts(HeadTagStartContext.class); 3381 } 3382 public HeadTagStartContext headTagStart(int i) { 3383 return getRuleContext(HeadTagStartContext.class,i); 3384 } 3385 public List<HtmlTagStartContext> htmlTagStart() { 3386 return getRuleContexts(HtmlTagStartContext.class); 3387 } 3388 public HtmlTagStartContext htmlTagStart(int i) { 3389 return getRuleContext(HtmlTagStartContext.class,i); 3390 } 3391 public List<OptionTagStartContext> optionTagStart() { 3392 return getRuleContexts(OptionTagStartContext.class); 3393 } 3394 public OptionTagStartContext optionTagStart(int i) { 3395 return getRuleContext(OptionTagStartContext.class,i); 3396 } 3397 public List<TbodyTagStartContext> tbodyTagStart() { 3398 return getRuleContexts(TbodyTagStartContext.class); 3399 } 3400 public TbodyTagStartContext tbodyTagStart(int i) { 3401 return getRuleContext(TbodyTagStartContext.class,i); 3402 } 3403 public List<TheadTagStartContext> theadTagStart() { 3404 return getRuleContexts(TheadTagStartContext.class); 3405 } 3406 public TheadTagStartContext theadTagStart(int i) { 3407 return getRuleContext(TheadTagStartContext.class,i); 3408 } 3409 public List<TfootTagStartContext> tfootTagStart() { 3410 return getRuleContexts(TfootTagStartContext.class); 3411 } 3412 public TfootTagStartContext tfootTagStart(int i) { 3413 return getRuleContext(TfootTagStartContext.class,i); 3414 } 3415 public List<OptgroupTagStartContext> optgroupTagStart() { 3416 return getRuleContexts(OptgroupTagStartContext.class); 3417 } 3418 public OptgroupTagStartContext optgroupTagStart(int i) { 3419 return getRuleContext(OptgroupTagStartContext.class,i); 3420 } 3421 public List<RbTagStartContext> rbTagStart() { 3422 return getRuleContexts(RbTagStartContext.class); 3423 } 3424 public RbTagStartContext rbTagStart(int i) { 3425 return getRuleContext(RbTagStartContext.class,i); 3426 } 3427 public List<RtTagStartContext> rtTagStart() { 3428 return getRuleContexts(RtTagStartContext.class); 3429 } 3430 public RtTagStartContext rtTagStart(int i) { 3431 return getRuleContext(RtTagStartContext.class,i); 3432 } 3433 public List<RtcTagStartContext> rtcTagStart() { 3434 return getRuleContexts(RtcTagStartContext.class); 3435 } 3436 public RtcTagStartContext rtcTagStart(int i) { 3437 return getRuleContext(RtcTagStartContext.class,i); 3438 } 3439 public List<RpTagStartContext> rpTagStart() { 3440 return getRuleContexts(RpTagStartContext.class); 3441 } 3442 public RpTagStartContext rpTagStart(int i) { 3443 return getRuleContext(RpTagStartContext.class,i); 3444 } 3445 public List<HtmlCommentContext> htmlComment() { 3446 return getRuleContexts(HtmlCommentContext.class); 3447 } 3448 public HtmlCommentContext htmlComment(int i) { 3449 return getRuleContext(HtmlCommentContext.class,i); 3450 } 3451 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3452 public TerminalNode CDATA(int i) { 3453 return getToken(JavadocParser.CDATA, i); 3454 } 3455 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3456 public TerminalNode NEWLINE(int i) { 3457 return getToken(JavadocParser.NEWLINE, i); 3458 } 3459 public List<TextContext> text() { 3460 return getRuleContexts(TextContext.class); 3461 } 3462 public TextContext text(int i) { 3463 return getRuleContext(TextContext.class,i); 3464 } 3465 public List<JavadocInlineTagContext> javadocInlineTag() { 3466 return getRuleContexts(JavadocInlineTagContext.class); 3467 } 3468 public JavadocInlineTagContext javadocInlineTag(int i) { 3469 return getRuleContext(JavadocInlineTagContext.class,i); 3470 } 3471 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3472 public TerminalNode LEADING_ASTERISK(int i) { 3473 return getToken(JavadocParser.LEADING_ASTERISK, i); 3474 } 3475 public TrContext(ParserRuleContext parent, int invokingState) { 3476 super(parent, invokingState); 3477 } 3478 @Override public int getRuleIndex() { return RULE_tr; } 3479 } 3480 3481 public final TrContext tr() throws RecognitionException { 3482 TrContext _localctx = new TrContext(_ctx, getState()); 3483 enterRule(_localctx, 28, RULE_tr); 3484 try { 3485 int _alt; 3486 enterOuterAlt(_localctx, 1); 3487 { 3488 setState(526); 3489 trTagStart(false); 3490 setState(576); 3491 _errHandler.sync(this); 3492 _alt = getInterpreter().adaptivePredict(_input,28,_ctx); 3493 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3494 if ( _alt==1 ) { 3495 { 3496 setState(574); 3497 _errHandler.sync(this); 3498 switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) { 3499 case 1: 3500 { 3501 setState(527); 3502 htmlTag(); 3503 } 3504 break; 3505 case 2: 3506 { 3507 setState(528); 3508 singletonElement(); 3509 } 3510 break; 3511 case 3: 3512 { 3513 setState(529); 3514 paragraph(); 3515 } 3516 break; 3517 case 4: 3518 { 3519 setState(530); 3520 li(); 3521 } 3522 break; 3523 case 5: 3524 { 3525 setState(531); 3526 td(); 3527 } 3528 break; 3529 case 6: 3530 { 3531 setState(532); 3532 th(); 3533 } 3534 break; 3535 case 7: 3536 { 3537 setState(533); 3538 body(); 3539 } 3540 break; 3541 case 8: 3542 { 3543 setState(534); 3544 colgroup(); 3545 } 3546 break; 3547 case 9: 3548 { 3549 setState(535); 3550 dd(); 3551 } 3552 break; 3553 case 10: 3554 { 3555 setState(536); 3556 dt(); 3557 } 3558 break; 3559 case 11: 3560 { 3561 setState(537); 3562 head(); 3563 } 3564 break; 3565 case 12: 3566 { 3567 setState(538); 3568 html(); 3569 } 3570 break; 3571 case 13: 3572 { 3573 setState(539); 3574 option(); 3575 } 3576 break; 3577 case 14: 3578 { 3579 setState(540); 3580 tbody(); 3581 } 3582 break; 3583 case 15: 3584 { 3585 setState(541); 3586 thead(); 3587 } 3588 break; 3589 case 16: 3590 { 3591 setState(542); 3592 tfoot(); 3593 } 3594 break; 3595 case 17: 3596 { 3597 setState(543); 3598 optgroup(); 3599 } 3600 break; 3601 case 18: 3602 { 3603 setState(544); 3604 rb(); 3605 } 3606 break; 3607 case 19: 3608 { 3609 setState(545); 3610 rt(); 3611 } 3612 break; 3613 case 20: 3614 { 3615 setState(546); 3616 rtc(); 3617 } 3618 break; 3619 case 21: 3620 { 3621 setState(547); 3622 rp(); 3623 } 3624 break; 3625 case 22: 3626 { 3627 setState(548); 3628 pTagStart(true); 3629 } 3630 break; 3631 case 23: 3632 { 3633 setState(549); 3634 liTagStart(true); 3635 } 3636 break; 3637 case 24: 3638 { 3639 setState(550); 3640 tdTagStart(true); 3641 } 3642 break; 3643 case 25: 3644 { 3645 setState(551); 3646 thTagStart(true); 3647 } 3648 break; 3649 case 26: 3650 { 3651 setState(552); 3652 bodyTagStart(true); 3653 } 3654 break; 3655 case 27: 3656 { 3657 setState(553); 3658 colgroupTagStart(true); 3659 } 3660 break; 3661 case 28: 3662 { 3663 setState(554); 3664 ddTagStart(true); 3665 } 3666 break; 3667 case 29: 3668 { 3669 setState(555); 3670 dtTagStart(true); 3671 } 3672 break; 3673 case 30: 3674 { 3675 setState(556); 3676 headTagStart(true); 3677 } 3678 break; 3679 case 31: 3680 { 3681 setState(557); 3682 htmlTagStart(true); 3683 } 3684 break; 3685 case 32: 3686 { 3687 setState(558); 3688 optionTagStart(true); 3689 } 3690 break; 3691 case 33: 3692 { 3693 setState(559); 3694 tbodyTagStart(true); 3695 } 3696 break; 3697 case 34: 3698 { 3699 setState(560); 3700 theadTagStart(true); 3701 } 3702 break; 3703 case 35: 3704 { 3705 setState(561); 3706 tfootTagStart(true); 3707 } 3708 break; 3709 case 36: 3710 { 3711 setState(562); 3712 optgroupTagStart(true); 3713 } 3714 break; 3715 case 37: 3716 { 3717 setState(563); 3718 rbTagStart(true); 3719 } 3720 break; 3721 case 38: 3722 { 3723 setState(564); 3724 rtTagStart(true); 3725 } 3726 break; 3727 case 39: 3728 { 3729 setState(565); 3730 rtcTagStart(true); 3731 } 3732 break; 3733 case 40: 3734 { 3735 setState(566); 3736 rpTagStart(true); 3737 } 3738 break; 3739 case 41: 3740 { 3741 { 3742 setState(567); 3743 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 3744 setState(568); 3745 match(LEADING_ASTERISK); 3746 } 3747 } 3748 break; 3749 case 42: 3750 { 3751 setState(569); 3752 htmlComment(); 3753 } 3754 break; 3755 case 43: 3756 { 3757 setState(570); 3758 match(CDATA); 3759 } 3760 break; 3761 case 44: 3762 { 3763 setState(571); 3764 match(NEWLINE); 3765 } 3766 break; 3767 case 45: 3768 { 3769 setState(572); 3770 text(); 3771 } 3772 break; 3773 case 46: 3774 { 3775 setState(573); 3776 javadocInlineTag(); 3777 } 3778 break; 3779 } 3780 } 3781 } 3782 setState(578); 3783 _errHandler.sync(this); 3784 _alt = getInterpreter().adaptivePredict(_input,28,_ctx); 3785 } 3786 setState(579); 3787 trTagEnd(); 3788 } 3789 } 3790 catch (RecognitionException re) { 3791 _localctx.exception = re; 3792 _errHandler.reportError(this, re); 3793 _errHandler.recover(this, re); 3794 } 3795 finally { 3796 exitRule(); 3797 } 3798 return _localctx; 3799 } 3800 3801 public static class TdTagStartContext extends ParserRuleContext { 3802 public boolean isNonTight; 3803 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 3804 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3805 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 3806 public List<AttributeContext> attribute() { 3807 return getRuleContexts(AttributeContext.class); 3808 } 3809 public AttributeContext attribute(int i) { 3810 return getRuleContext(AttributeContext.class,i); 3811 } 3812 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3813 public TerminalNode NEWLINE(int i) { 3814 return getToken(JavadocParser.NEWLINE, i); 3815 } 3816 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3817 public TerminalNode LEADING_ASTERISK(int i) { 3818 return getToken(JavadocParser.LEADING_ASTERISK, i); 3819 } 3820 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3821 public TerminalNode WS(int i) { 3822 return getToken(JavadocParser.WS, i); 3823 } 3824 public TdTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 3825 public TdTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 3826 super(parent, invokingState); 3827 this.isNonTight = isNonTight; 3828 } 3829 @Override public int getRuleIndex() { return RULE_tdTagStart; } 3830 } 3831 3832 public final TdTagStartContext tdTagStart(boolean isNonTight) throws RecognitionException { 3833 TdTagStartContext _localctx = new TdTagStartContext(_ctx, getState(), isNonTight); 3834 enterRule(_localctx, 30, RULE_tdTagStart); 3835 int _la; 3836 try { 3837 enterOuterAlt(_localctx, 1); 3838 { 3839 setState(581); 3840 match(START); 3841 setState(582); 3842 match(TD_HTML_TAG_NAME); 3843 setState(589); 3844 _errHandler.sync(this); 3845 _la = _input.LA(1); 3846 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 3847 { 3848 setState(587); 3849 _errHandler.sync(this); 3850 switch (_input.LA(1)) { 3851 case HTML_TAG_NAME: 3852 { 3853 setState(583); 3854 attribute(); 3855 } 3856 break; 3857 case NEWLINE: 3858 { 3859 setState(584); 3860 match(NEWLINE); 3861 } 3862 break; 3863 case LEADING_ASTERISK: 3864 { 3865 setState(585); 3866 match(LEADING_ASTERISK); 3867 } 3868 break; 3869 case WS: 3870 { 3871 setState(586); 3872 match(WS); 3873 } 3874 break; 3875 default: 3876 throw new NoViableAltException(this); 3877 } 3878 } 3879 setState(591); 3880 _errHandler.sync(this); 3881 _la = _input.LA(1); 3882 } 3883 setState(592); 3884 match(END); 3885 } 3886 _ctx.stop = _input.LT(-1); 3887 3888 if (isNonTight && nonTightTagStartContext == null) { 3889 nonTightTagStartContext = _localctx; 3890 } 3891 3892 } 3893 catch (RecognitionException re) { 3894 _localctx.exception = re; 3895 _errHandler.reportError(this, re); 3896 _errHandler.recover(this, re); 3897 } 3898 finally { 3899 exitRule(); 3900 } 3901 return _localctx; 3902 } 3903 3904 public static class TdTagEndContext extends ParserRuleContext { 3905 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 3906 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 3907 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3908 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 3909 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3910 public TerminalNode NEWLINE(int i) { 3911 return getToken(JavadocParser.NEWLINE, i); 3912 } 3913 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3914 public TerminalNode LEADING_ASTERISK(int i) { 3915 return getToken(JavadocParser.LEADING_ASTERISK, i); 3916 } 3917 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3918 public TerminalNode WS(int i) { 3919 return getToken(JavadocParser.WS, i); 3920 } 3921 public TdTagEndContext(ParserRuleContext parent, int invokingState) { 3922 super(parent, invokingState); 3923 } 3924 @Override public int getRuleIndex() { return RULE_tdTagEnd; } 3925 } 3926 3927 public final TdTagEndContext tdTagEnd() throws RecognitionException { 3928 TdTagEndContext _localctx = new TdTagEndContext(_ctx, getState()); 3929 enterRule(_localctx, 32, RULE_tdTagEnd); 3930 int _la; 3931 try { 3932 enterOuterAlt(_localctx, 1); 3933 { 3934 setState(594); 3935 match(START); 3936 setState(595); 3937 match(SLASH); 3938 setState(596); 3939 match(TD_HTML_TAG_NAME); 3940 setState(600); 3941 _errHandler.sync(this); 3942 _la = _input.LA(1); 3943 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 3944 { 3945 { 3946 setState(597); 3947 _la = _input.LA(1); 3948 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 3949 _errHandler.recoverInline(this); 3950 } 3951 else { 3952 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3953 _errHandler.reportMatch(this); 3954 consume(); 3955 } 3956 } 3957 } 3958 setState(602); 3959 _errHandler.sync(this); 3960 _la = _input.LA(1); 3961 } 3962 setState(603); 3963 match(END); 3964 } 3965 } 3966 catch (RecognitionException re) { 3967 _localctx.exception = re; 3968 _errHandler.reportError(this, re); 3969 _errHandler.recover(this, re); 3970 } 3971 finally { 3972 exitRule(); 3973 } 3974 return _localctx; 3975 } 3976 3977 public static class TdContext extends ParserRuleContext { 3978 public List<TdTagStartContext> tdTagStart() { 3979 return getRuleContexts(TdTagStartContext.class); 3980 } 3981 public TdTagStartContext tdTagStart(int i) { 3982 return getRuleContext(TdTagStartContext.class,i); 3983 } 3984 public TdTagEndContext tdTagEnd() { 3985 return getRuleContext(TdTagEndContext.class,0); 3986 } 3987 public List<HtmlTagContext> htmlTag() { 3988 return getRuleContexts(HtmlTagContext.class); 3989 } 3990 public HtmlTagContext htmlTag(int i) { 3991 return getRuleContext(HtmlTagContext.class,i); 3992 } 3993 public List<SingletonElementContext> singletonElement() { 3994 return getRuleContexts(SingletonElementContext.class); 3995 } 3996 public SingletonElementContext singletonElement(int i) { 3997 return getRuleContext(SingletonElementContext.class,i); 3998 } 3999 public List<ParagraphContext> paragraph() { 4000 return getRuleContexts(ParagraphContext.class); 4001 } 4002 public ParagraphContext paragraph(int i) { 4003 return getRuleContext(ParagraphContext.class,i); 4004 } 4005 public List<LiContext> li() { 4006 return getRuleContexts(LiContext.class); 4007 } 4008 public LiContext li(int i) { 4009 return getRuleContext(LiContext.class,i); 4010 } 4011 public List<TrContext> tr() { 4012 return getRuleContexts(TrContext.class); 4013 } 4014 public TrContext tr(int i) { 4015 return getRuleContext(TrContext.class,i); 4016 } 4017 public List<ThContext> th() { 4018 return getRuleContexts(ThContext.class); 4019 } 4020 public ThContext th(int i) { 4021 return getRuleContext(ThContext.class,i); 4022 } 4023 public List<BodyContext> body() { 4024 return getRuleContexts(BodyContext.class); 4025 } 4026 public BodyContext body(int i) { 4027 return getRuleContext(BodyContext.class,i); 4028 } 4029 public List<ColgroupContext> colgroup() { 4030 return getRuleContexts(ColgroupContext.class); 4031 } 4032 public ColgroupContext colgroup(int i) { 4033 return getRuleContext(ColgroupContext.class,i); 4034 } 4035 public List<DdContext> dd() { 4036 return getRuleContexts(DdContext.class); 4037 } 4038 public DdContext dd(int i) { 4039 return getRuleContext(DdContext.class,i); 4040 } 4041 public List<DtContext> dt() { 4042 return getRuleContexts(DtContext.class); 4043 } 4044 public DtContext dt(int i) { 4045 return getRuleContext(DtContext.class,i); 4046 } 4047 public List<HeadContext> head() { 4048 return getRuleContexts(HeadContext.class); 4049 } 4050 public HeadContext head(int i) { 4051 return getRuleContext(HeadContext.class,i); 4052 } 4053 public List<HtmlContext> html() { 4054 return getRuleContexts(HtmlContext.class); 4055 } 4056 public HtmlContext html(int i) { 4057 return getRuleContext(HtmlContext.class,i); 4058 } 4059 public List<OptionContext> option() { 4060 return getRuleContexts(OptionContext.class); 4061 } 4062 public OptionContext option(int i) { 4063 return getRuleContext(OptionContext.class,i); 4064 } 4065 public List<TbodyContext> tbody() { 4066 return getRuleContexts(TbodyContext.class); 4067 } 4068 public TbodyContext tbody(int i) { 4069 return getRuleContext(TbodyContext.class,i); 4070 } 4071 public List<TheadContext> thead() { 4072 return getRuleContexts(TheadContext.class); 4073 } 4074 public TheadContext thead(int i) { 4075 return getRuleContext(TheadContext.class,i); 4076 } 4077 public List<TfootContext> tfoot() { 4078 return getRuleContexts(TfootContext.class); 4079 } 4080 public TfootContext tfoot(int i) { 4081 return getRuleContext(TfootContext.class,i); 4082 } 4083 public List<OptgroupContext> optgroup() { 4084 return getRuleContexts(OptgroupContext.class); 4085 } 4086 public OptgroupContext optgroup(int i) { 4087 return getRuleContext(OptgroupContext.class,i); 4088 } 4089 public List<RbContext> rb() { 4090 return getRuleContexts(RbContext.class); 4091 } 4092 public RbContext rb(int i) { 4093 return getRuleContext(RbContext.class,i); 4094 } 4095 public List<RtContext> rt() { 4096 return getRuleContexts(RtContext.class); 4097 } 4098 public RtContext rt(int i) { 4099 return getRuleContext(RtContext.class,i); 4100 } 4101 public List<RtcContext> rtc() { 4102 return getRuleContexts(RtcContext.class); 4103 } 4104 public RtcContext rtc(int i) { 4105 return getRuleContext(RtcContext.class,i); 4106 } 4107 public List<RpContext> rp() { 4108 return getRuleContexts(RpContext.class); 4109 } 4110 public RpContext rp(int i) { 4111 return getRuleContext(RpContext.class,i); 4112 } 4113 public List<PTagStartContext> pTagStart() { 4114 return getRuleContexts(PTagStartContext.class); 4115 } 4116 public PTagStartContext pTagStart(int i) { 4117 return getRuleContext(PTagStartContext.class,i); 4118 } 4119 public List<LiTagStartContext> liTagStart() { 4120 return getRuleContexts(LiTagStartContext.class); 4121 } 4122 public LiTagStartContext liTagStart(int i) { 4123 return getRuleContext(LiTagStartContext.class,i); 4124 } 4125 public List<ThTagStartContext> thTagStart() { 4126 return getRuleContexts(ThTagStartContext.class); 4127 } 4128 public ThTagStartContext thTagStart(int i) { 4129 return getRuleContext(ThTagStartContext.class,i); 4130 } 4131 public List<BodyTagStartContext> bodyTagStart() { 4132 return getRuleContexts(BodyTagStartContext.class); 4133 } 4134 public BodyTagStartContext bodyTagStart(int i) { 4135 return getRuleContext(BodyTagStartContext.class,i); 4136 } 4137 public List<ColgroupTagStartContext> colgroupTagStart() { 4138 return getRuleContexts(ColgroupTagStartContext.class); 4139 } 4140 public ColgroupTagStartContext colgroupTagStart(int i) { 4141 return getRuleContext(ColgroupTagStartContext.class,i); 4142 } 4143 public List<DdTagStartContext> ddTagStart() { 4144 return getRuleContexts(DdTagStartContext.class); 4145 } 4146 public DdTagStartContext ddTagStart(int i) { 4147 return getRuleContext(DdTagStartContext.class,i); 4148 } 4149 public List<DtTagStartContext> dtTagStart() { 4150 return getRuleContexts(DtTagStartContext.class); 4151 } 4152 public DtTagStartContext dtTagStart(int i) { 4153 return getRuleContext(DtTagStartContext.class,i); 4154 } 4155 public List<HeadTagStartContext> headTagStart() { 4156 return getRuleContexts(HeadTagStartContext.class); 4157 } 4158 public HeadTagStartContext headTagStart(int i) { 4159 return getRuleContext(HeadTagStartContext.class,i); 4160 } 4161 public List<HtmlTagStartContext> htmlTagStart() { 4162 return getRuleContexts(HtmlTagStartContext.class); 4163 } 4164 public HtmlTagStartContext htmlTagStart(int i) { 4165 return getRuleContext(HtmlTagStartContext.class,i); 4166 } 4167 public List<OptionTagStartContext> optionTagStart() { 4168 return getRuleContexts(OptionTagStartContext.class); 4169 } 4170 public OptionTagStartContext optionTagStart(int i) { 4171 return getRuleContext(OptionTagStartContext.class,i); 4172 } 4173 public List<TbodyTagStartContext> tbodyTagStart() { 4174 return getRuleContexts(TbodyTagStartContext.class); 4175 } 4176 public TbodyTagStartContext tbodyTagStart(int i) { 4177 return getRuleContext(TbodyTagStartContext.class,i); 4178 } 4179 public List<TheadTagStartContext> theadTagStart() { 4180 return getRuleContexts(TheadTagStartContext.class); 4181 } 4182 public TheadTagStartContext theadTagStart(int i) { 4183 return getRuleContext(TheadTagStartContext.class,i); 4184 } 4185 public List<TfootTagStartContext> tfootTagStart() { 4186 return getRuleContexts(TfootTagStartContext.class); 4187 } 4188 public TfootTagStartContext tfootTagStart(int i) { 4189 return getRuleContext(TfootTagStartContext.class,i); 4190 } 4191 public List<OptgroupTagStartContext> optgroupTagStart() { 4192 return getRuleContexts(OptgroupTagStartContext.class); 4193 } 4194 public OptgroupTagStartContext optgroupTagStart(int i) { 4195 return getRuleContext(OptgroupTagStartContext.class,i); 4196 } 4197 public List<RbTagStartContext> rbTagStart() { 4198 return getRuleContexts(RbTagStartContext.class); 4199 } 4200 public RbTagStartContext rbTagStart(int i) { 4201 return getRuleContext(RbTagStartContext.class,i); 4202 } 4203 public List<RtTagStartContext> rtTagStart() { 4204 return getRuleContexts(RtTagStartContext.class); 4205 } 4206 public RtTagStartContext rtTagStart(int i) { 4207 return getRuleContext(RtTagStartContext.class,i); 4208 } 4209 public List<RtcTagStartContext> rtcTagStart() { 4210 return getRuleContexts(RtcTagStartContext.class); 4211 } 4212 public RtcTagStartContext rtcTagStart(int i) { 4213 return getRuleContext(RtcTagStartContext.class,i); 4214 } 4215 public List<RpTagStartContext> rpTagStart() { 4216 return getRuleContexts(RpTagStartContext.class); 4217 } 4218 public RpTagStartContext rpTagStart(int i) { 4219 return getRuleContext(RpTagStartContext.class,i); 4220 } 4221 public List<HtmlCommentContext> htmlComment() { 4222 return getRuleContexts(HtmlCommentContext.class); 4223 } 4224 public HtmlCommentContext htmlComment(int i) { 4225 return getRuleContext(HtmlCommentContext.class,i); 4226 } 4227 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 4228 public TerminalNode CDATA(int i) { 4229 return getToken(JavadocParser.CDATA, i); 4230 } 4231 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4232 public TerminalNode NEWLINE(int i) { 4233 return getToken(JavadocParser.NEWLINE, i); 4234 } 4235 public List<TextContext> text() { 4236 return getRuleContexts(TextContext.class); 4237 } 4238 public TextContext text(int i) { 4239 return getRuleContext(TextContext.class,i); 4240 } 4241 public List<JavadocInlineTagContext> javadocInlineTag() { 4242 return getRuleContexts(JavadocInlineTagContext.class); 4243 } 4244 public JavadocInlineTagContext javadocInlineTag(int i) { 4245 return getRuleContext(JavadocInlineTagContext.class,i); 4246 } 4247 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4248 public TerminalNode LEADING_ASTERISK(int i) { 4249 return getToken(JavadocParser.LEADING_ASTERISK, i); 4250 } 4251 public TdContext(ParserRuleContext parent, int invokingState) { 4252 super(parent, invokingState); 4253 } 4254 @Override public int getRuleIndex() { return RULE_td; } 4255 } 4256 4257 public final TdContext td() throws RecognitionException { 4258 TdContext _localctx = new TdContext(_ctx, getState()); 4259 enterRule(_localctx, 34, RULE_td); 4260 try { 4261 int _alt; 4262 enterOuterAlt(_localctx, 1); 4263 { 4264 setState(605); 4265 tdTagStart(false); 4266 setState(655); 4267 _errHandler.sync(this); 4268 _alt = getInterpreter().adaptivePredict(_input,33,_ctx); 4269 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 4270 if ( _alt==1 ) { 4271 { 4272 setState(653); 4273 _errHandler.sync(this); 4274 switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) { 4275 case 1: 4276 { 4277 setState(606); 4278 htmlTag(); 4279 } 4280 break; 4281 case 2: 4282 { 4283 setState(607); 4284 singletonElement(); 4285 } 4286 break; 4287 case 3: 4288 { 4289 setState(608); 4290 paragraph(); 4291 } 4292 break; 4293 case 4: 4294 { 4295 setState(609); 4296 li(); 4297 } 4298 break; 4299 case 5: 4300 { 4301 setState(610); 4302 tr(); 4303 } 4304 break; 4305 case 6: 4306 { 4307 setState(611); 4308 th(); 4309 } 4310 break; 4311 case 7: 4312 { 4313 setState(612); 4314 body(); 4315 } 4316 break; 4317 case 8: 4318 { 4319 setState(613); 4320 colgroup(); 4321 } 4322 break; 4323 case 9: 4324 { 4325 setState(614); 4326 dd(); 4327 } 4328 break; 4329 case 10: 4330 { 4331 setState(615); 4332 dt(); 4333 } 4334 break; 4335 case 11: 4336 { 4337 setState(616); 4338 head(); 4339 } 4340 break; 4341 case 12: 4342 { 4343 setState(617); 4344 html(); 4345 } 4346 break; 4347 case 13: 4348 { 4349 setState(618); 4350 option(); 4351 } 4352 break; 4353 case 14: 4354 { 4355 setState(619); 4356 tbody(); 4357 } 4358 break; 4359 case 15: 4360 { 4361 setState(620); 4362 thead(); 4363 } 4364 break; 4365 case 16: 4366 { 4367 setState(621); 4368 tfoot(); 4369 } 4370 break; 4371 case 17: 4372 { 4373 setState(622); 4374 optgroup(); 4375 } 4376 break; 4377 case 18: 4378 { 4379 setState(623); 4380 rb(); 4381 } 4382 break; 4383 case 19: 4384 { 4385 setState(624); 4386 rt(); 4387 } 4388 break; 4389 case 20: 4390 { 4391 setState(625); 4392 rtc(); 4393 } 4394 break; 4395 case 21: 4396 { 4397 setState(626); 4398 rp(); 4399 } 4400 break; 4401 case 22: 4402 { 4403 setState(627); 4404 pTagStart(true); 4405 } 4406 break; 4407 case 23: 4408 { 4409 setState(628); 4410 liTagStart(true); 4411 } 4412 break; 4413 case 24: 4414 { 4415 setState(629); 4416 tdTagStart(true); 4417 } 4418 break; 4419 case 25: 4420 { 4421 setState(630); 4422 thTagStart(true); 4423 } 4424 break; 4425 case 26: 4426 { 4427 setState(631); 4428 bodyTagStart(true); 4429 } 4430 break; 4431 case 27: 4432 { 4433 setState(632); 4434 colgroupTagStart(true); 4435 } 4436 break; 4437 case 28: 4438 { 4439 setState(633); 4440 ddTagStart(true); 4441 } 4442 break; 4443 case 29: 4444 { 4445 setState(634); 4446 dtTagStart(true); 4447 } 4448 break; 4449 case 30: 4450 { 4451 setState(635); 4452 headTagStart(true); 4453 } 4454 break; 4455 case 31: 4456 { 4457 setState(636); 4458 htmlTagStart(true); 4459 } 4460 break; 4461 case 32: 4462 { 4463 setState(637); 4464 optionTagStart(true); 4465 } 4466 break; 4467 case 33: 4468 { 4469 setState(638); 4470 tbodyTagStart(true); 4471 } 4472 break; 4473 case 34: 4474 { 4475 setState(639); 4476 theadTagStart(true); 4477 } 4478 break; 4479 case 35: 4480 { 4481 setState(640); 4482 tfootTagStart(true); 4483 } 4484 break; 4485 case 36: 4486 { 4487 setState(641); 4488 optgroupTagStart(true); 4489 } 4490 break; 4491 case 37: 4492 { 4493 setState(642); 4494 rbTagStart(true); 4495 } 4496 break; 4497 case 38: 4498 { 4499 setState(643); 4500 rtTagStart(true); 4501 } 4502 break; 4503 case 39: 4504 { 4505 setState(644); 4506 rtcTagStart(true); 4507 } 4508 break; 4509 case 40: 4510 { 4511 setState(645); 4512 rpTagStart(true); 4513 } 4514 break; 4515 case 41: 4516 { 4517 { 4518 setState(646); 4519 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4520 setState(647); 4521 match(LEADING_ASTERISK); 4522 } 4523 } 4524 break; 4525 case 42: 4526 { 4527 setState(648); 4528 htmlComment(); 4529 } 4530 break; 4531 case 43: 4532 { 4533 setState(649); 4534 match(CDATA); 4535 } 4536 break; 4537 case 44: 4538 { 4539 setState(650); 4540 match(NEWLINE); 4541 } 4542 break; 4543 case 45: 4544 { 4545 setState(651); 4546 text(); 4547 } 4548 break; 4549 case 46: 4550 { 4551 setState(652); 4552 javadocInlineTag(); 4553 } 4554 break; 4555 } 4556 } 4557 } 4558 setState(657); 4559 _errHandler.sync(this); 4560 _alt = getInterpreter().adaptivePredict(_input,33,_ctx); 4561 } 4562 setState(658); 4563 tdTagEnd(); 4564 } 4565 } 4566 catch (RecognitionException re) { 4567 _localctx.exception = re; 4568 _errHandler.reportError(this, re); 4569 _errHandler.recover(this, re); 4570 } 4571 finally { 4572 exitRule(); 4573 } 4574 return _localctx; 4575 } 4576 4577 public static class ThTagStartContext extends ParserRuleContext { 4578 public boolean isNonTight; 4579 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 4580 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4581 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 4582 public List<AttributeContext> attribute() { 4583 return getRuleContexts(AttributeContext.class); 4584 } 4585 public AttributeContext attribute(int i) { 4586 return getRuleContext(AttributeContext.class,i); 4587 } 4588 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4589 public TerminalNode NEWLINE(int i) { 4590 return getToken(JavadocParser.NEWLINE, i); 4591 } 4592 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4593 public TerminalNode LEADING_ASTERISK(int i) { 4594 return getToken(JavadocParser.LEADING_ASTERISK, i); 4595 } 4596 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4597 public TerminalNode WS(int i) { 4598 return getToken(JavadocParser.WS, i); 4599 } 4600 public ThTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 4601 public ThTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 4602 super(parent, invokingState); 4603 this.isNonTight = isNonTight; 4604 } 4605 @Override public int getRuleIndex() { return RULE_thTagStart; } 4606 } 4607 4608 public final ThTagStartContext thTagStart(boolean isNonTight) throws RecognitionException { 4609 ThTagStartContext _localctx = new ThTagStartContext(_ctx, getState(), isNonTight); 4610 enterRule(_localctx, 36, RULE_thTagStart); 4611 int _la; 4612 try { 4613 enterOuterAlt(_localctx, 1); 4614 { 4615 setState(660); 4616 match(START); 4617 setState(661); 4618 match(TH_HTML_TAG_NAME); 4619 setState(668); 4620 _errHandler.sync(this); 4621 _la = _input.LA(1); 4622 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4623 { 4624 setState(666); 4625 _errHandler.sync(this); 4626 switch (_input.LA(1)) { 4627 case HTML_TAG_NAME: 4628 { 4629 setState(662); 4630 attribute(); 4631 } 4632 break; 4633 case NEWLINE: 4634 { 4635 setState(663); 4636 match(NEWLINE); 4637 } 4638 break; 4639 case LEADING_ASTERISK: 4640 { 4641 setState(664); 4642 match(LEADING_ASTERISK); 4643 } 4644 break; 4645 case WS: 4646 { 4647 setState(665); 4648 match(WS); 4649 } 4650 break; 4651 default: 4652 throw new NoViableAltException(this); 4653 } 4654 } 4655 setState(670); 4656 _errHandler.sync(this); 4657 _la = _input.LA(1); 4658 } 4659 setState(671); 4660 match(END); 4661 } 4662 _ctx.stop = _input.LT(-1); 4663 4664 if (isNonTight && nonTightTagStartContext == null) { 4665 nonTightTagStartContext = _localctx; 4666 } 4667 4668 } 4669 catch (RecognitionException re) { 4670 _localctx.exception = re; 4671 _errHandler.reportError(this, re); 4672 _errHandler.recover(this, re); 4673 } 4674 finally { 4675 exitRule(); 4676 } 4677 return _localctx; 4678 } 4679 4680 public static class ThTagEndContext extends ParserRuleContext { 4681 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 4682 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4683 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4684 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 4685 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4686 public TerminalNode NEWLINE(int i) { 4687 return getToken(JavadocParser.NEWLINE, i); 4688 } 4689 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4690 public TerminalNode LEADING_ASTERISK(int i) { 4691 return getToken(JavadocParser.LEADING_ASTERISK, i); 4692 } 4693 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4694 public TerminalNode WS(int i) { 4695 return getToken(JavadocParser.WS, i); 4696 } 4697 public ThTagEndContext(ParserRuleContext parent, int invokingState) { 4698 super(parent, invokingState); 4699 } 4700 @Override public int getRuleIndex() { return RULE_thTagEnd; } 4701 } 4702 4703 public final ThTagEndContext thTagEnd() throws RecognitionException { 4704 ThTagEndContext _localctx = new ThTagEndContext(_ctx, getState()); 4705 enterRule(_localctx, 38, RULE_thTagEnd); 4706 int _la; 4707 try { 4708 enterOuterAlt(_localctx, 1); 4709 { 4710 setState(673); 4711 match(START); 4712 setState(674); 4713 match(SLASH); 4714 setState(675); 4715 match(TH_HTML_TAG_NAME); 4716 setState(679); 4717 _errHandler.sync(this); 4718 _la = _input.LA(1); 4719 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 4720 { 4721 { 4722 setState(676); 4723 _la = _input.LA(1); 4724 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 4725 _errHandler.recoverInline(this); 4726 } 4727 else { 4728 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 4729 _errHandler.reportMatch(this); 4730 consume(); 4731 } 4732 } 4733 } 4734 setState(681); 4735 _errHandler.sync(this); 4736 _la = _input.LA(1); 4737 } 4738 setState(682); 4739 match(END); 4740 } 4741 } 4742 catch (RecognitionException re) { 4743 _localctx.exception = re; 4744 _errHandler.reportError(this, re); 4745 _errHandler.recover(this, re); 4746 } 4747 finally { 4748 exitRule(); 4749 } 4750 return _localctx; 4751 } 4752 4753 public static class ThContext extends ParserRuleContext { 4754 public ThTagStartContext thTagStart() { 4755 return getRuleContext(ThTagStartContext.class,0); 4756 } 4757 public ThTagEndContext thTagEnd() { 4758 return getRuleContext(ThTagEndContext.class,0); 4759 } 4760 public List<HtmlTagContext> htmlTag() { 4761 return getRuleContexts(HtmlTagContext.class); 4762 } 4763 public HtmlTagContext htmlTag(int i) { 4764 return getRuleContext(HtmlTagContext.class,i); 4765 } 4766 public List<SingletonElementContext> singletonElement() { 4767 return getRuleContexts(SingletonElementContext.class); 4768 } 4769 public SingletonElementContext singletonElement(int i) { 4770 return getRuleContext(SingletonElementContext.class,i); 4771 } 4772 public List<ParagraphContext> paragraph() { 4773 return getRuleContexts(ParagraphContext.class); 4774 } 4775 public ParagraphContext paragraph(int i) { 4776 return getRuleContext(ParagraphContext.class,i); 4777 } 4778 public List<LiContext> li() { 4779 return getRuleContexts(LiContext.class); 4780 } 4781 public LiContext li(int i) { 4782 return getRuleContext(LiContext.class,i); 4783 } 4784 public List<TrContext> tr() { 4785 return getRuleContexts(TrContext.class); 4786 } 4787 public TrContext tr(int i) { 4788 return getRuleContext(TrContext.class,i); 4789 } 4790 public List<TdContext> td() { 4791 return getRuleContexts(TdContext.class); 4792 } 4793 public TdContext td(int i) { 4794 return getRuleContext(TdContext.class,i); 4795 } 4796 public List<BodyContext> body() { 4797 return getRuleContexts(BodyContext.class); 4798 } 4799 public BodyContext body(int i) { 4800 return getRuleContext(BodyContext.class,i); 4801 } 4802 public List<ColgroupContext> colgroup() { 4803 return getRuleContexts(ColgroupContext.class); 4804 } 4805 public ColgroupContext colgroup(int i) { 4806 return getRuleContext(ColgroupContext.class,i); 4807 } 4808 public List<DdContext> dd() { 4809 return getRuleContexts(DdContext.class); 4810 } 4811 public DdContext dd(int i) { 4812 return getRuleContext(DdContext.class,i); 4813 } 4814 public List<DtContext> dt() { 4815 return getRuleContexts(DtContext.class); 4816 } 4817 public DtContext dt(int i) { 4818 return getRuleContext(DtContext.class,i); 4819 } 4820 public List<HeadContext> head() { 4821 return getRuleContexts(HeadContext.class); 4822 } 4823 public HeadContext head(int i) { 4824 return getRuleContext(HeadContext.class,i); 4825 } 4826 public List<HtmlContext> html() { 4827 return getRuleContexts(HtmlContext.class); 4828 } 4829 public HtmlContext html(int i) { 4830 return getRuleContext(HtmlContext.class,i); 4831 } 4832 public List<OptionContext> option() { 4833 return getRuleContexts(OptionContext.class); 4834 } 4835 public OptionContext option(int i) { 4836 return getRuleContext(OptionContext.class,i); 4837 } 4838 public List<TbodyContext> tbody() { 4839 return getRuleContexts(TbodyContext.class); 4840 } 4841 public TbodyContext tbody(int i) { 4842 return getRuleContext(TbodyContext.class,i); 4843 } 4844 public List<TheadContext> thead() { 4845 return getRuleContexts(TheadContext.class); 4846 } 4847 public TheadContext thead(int i) { 4848 return getRuleContext(TheadContext.class,i); 4849 } 4850 public List<TfootContext> tfoot() { 4851 return getRuleContexts(TfootContext.class); 4852 } 4853 public TfootContext tfoot(int i) { 4854 return getRuleContext(TfootContext.class,i); 4855 } 4856 public List<OptgroupContext> optgroup() { 4857 return getRuleContexts(OptgroupContext.class); 4858 } 4859 public OptgroupContext optgroup(int i) { 4860 return getRuleContext(OptgroupContext.class,i); 4861 } 4862 public List<RbContext> rb() { 4863 return getRuleContexts(RbContext.class); 4864 } 4865 public RbContext rb(int i) { 4866 return getRuleContext(RbContext.class,i); 4867 } 4868 public List<RtContext> rt() { 4869 return getRuleContexts(RtContext.class); 4870 } 4871 public RtContext rt(int i) { 4872 return getRuleContext(RtContext.class,i); 4873 } 4874 public List<RtcContext> rtc() { 4875 return getRuleContexts(RtcContext.class); 4876 } 4877 public RtcContext rtc(int i) { 4878 return getRuleContext(RtcContext.class,i); 4879 } 4880 public List<RpContext> rp() { 4881 return getRuleContexts(RpContext.class); 4882 } 4883 public RpContext rp(int i) { 4884 return getRuleContext(RpContext.class,i); 4885 } 4886 public List<PTagStartContext> pTagStart() { 4887 return getRuleContexts(PTagStartContext.class); 4888 } 4889 public PTagStartContext pTagStart(int i) { 4890 return getRuleContext(PTagStartContext.class,i); 4891 } 4892 public List<LiTagStartContext> liTagStart() { 4893 return getRuleContexts(LiTagStartContext.class); 4894 } 4895 public LiTagStartContext liTagStart(int i) { 4896 return getRuleContext(LiTagStartContext.class,i); 4897 } 4898 public List<TrTagStartContext> trTagStart() { 4899 return getRuleContexts(TrTagStartContext.class); 4900 } 4901 public TrTagStartContext trTagStart(int i) { 4902 return getRuleContext(TrTagStartContext.class,i); 4903 } 4904 public List<TdTagStartContext> tdTagStart() { 4905 return getRuleContexts(TdTagStartContext.class); 4906 } 4907 public TdTagStartContext tdTagStart(int i) { 4908 return getRuleContext(TdTagStartContext.class,i); 4909 } 4910 public List<BodyTagStartContext> bodyTagStart() { 4911 return getRuleContexts(BodyTagStartContext.class); 4912 } 4913 public BodyTagStartContext bodyTagStart(int i) { 4914 return getRuleContext(BodyTagStartContext.class,i); 4915 } 4916 public List<ColgroupTagStartContext> colgroupTagStart() { 4917 return getRuleContexts(ColgroupTagStartContext.class); 4918 } 4919 public ColgroupTagStartContext colgroupTagStart(int i) { 4920 return getRuleContext(ColgroupTagStartContext.class,i); 4921 } 4922 public List<DdTagStartContext> ddTagStart() { 4923 return getRuleContexts(DdTagStartContext.class); 4924 } 4925 public DdTagStartContext ddTagStart(int i) { 4926 return getRuleContext(DdTagStartContext.class,i); 4927 } 4928 public List<DtTagStartContext> dtTagStart() { 4929 return getRuleContexts(DtTagStartContext.class); 4930 } 4931 public DtTagStartContext dtTagStart(int i) { 4932 return getRuleContext(DtTagStartContext.class,i); 4933 } 4934 public List<HeadTagStartContext> headTagStart() { 4935 return getRuleContexts(HeadTagStartContext.class); 4936 } 4937 public HeadTagStartContext headTagStart(int i) { 4938 return getRuleContext(HeadTagStartContext.class,i); 4939 } 4940 public List<HtmlTagStartContext> htmlTagStart() { 4941 return getRuleContexts(HtmlTagStartContext.class); 4942 } 4943 public HtmlTagStartContext htmlTagStart(int i) { 4944 return getRuleContext(HtmlTagStartContext.class,i); 4945 } 4946 public List<OptionTagStartContext> optionTagStart() { 4947 return getRuleContexts(OptionTagStartContext.class); 4948 } 4949 public OptionTagStartContext optionTagStart(int i) { 4950 return getRuleContext(OptionTagStartContext.class,i); 4951 } 4952 public List<TbodyTagStartContext> tbodyTagStart() { 4953 return getRuleContexts(TbodyTagStartContext.class); 4954 } 4955 public TbodyTagStartContext tbodyTagStart(int i) { 4956 return getRuleContext(TbodyTagStartContext.class,i); 4957 } 4958 public List<TheadTagStartContext> theadTagStart() { 4959 return getRuleContexts(TheadTagStartContext.class); 4960 } 4961 public TheadTagStartContext theadTagStart(int i) { 4962 return getRuleContext(TheadTagStartContext.class,i); 4963 } 4964 public List<TfootTagStartContext> tfootTagStart() { 4965 return getRuleContexts(TfootTagStartContext.class); 4966 } 4967 public TfootTagStartContext tfootTagStart(int i) { 4968 return getRuleContext(TfootTagStartContext.class,i); 4969 } 4970 public List<OptgroupTagStartContext> optgroupTagStart() { 4971 return getRuleContexts(OptgroupTagStartContext.class); 4972 } 4973 public OptgroupTagStartContext optgroupTagStart(int i) { 4974 return getRuleContext(OptgroupTagStartContext.class,i); 4975 } 4976 public List<RbTagStartContext> rbTagStart() { 4977 return getRuleContexts(RbTagStartContext.class); 4978 } 4979 public RbTagStartContext rbTagStart(int i) { 4980 return getRuleContext(RbTagStartContext.class,i); 4981 } 4982 public List<RtTagStartContext> rtTagStart() { 4983 return getRuleContexts(RtTagStartContext.class); 4984 } 4985 public RtTagStartContext rtTagStart(int i) { 4986 return getRuleContext(RtTagStartContext.class,i); 4987 } 4988 public List<RtcTagStartContext> rtcTagStart() { 4989 return getRuleContexts(RtcTagStartContext.class); 4990 } 4991 public RtcTagStartContext rtcTagStart(int i) { 4992 return getRuleContext(RtcTagStartContext.class,i); 4993 } 4994 public List<RpTagStartContext> rpTagStart() { 4995 return getRuleContexts(RpTagStartContext.class); 4996 } 4997 public RpTagStartContext rpTagStart(int i) { 4998 return getRuleContext(RpTagStartContext.class,i); 4999 } 5000 public List<HtmlCommentContext> htmlComment() { 5001 return getRuleContexts(HtmlCommentContext.class); 5002 } 5003 public HtmlCommentContext htmlComment(int i) { 5004 return getRuleContext(HtmlCommentContext.class,i); 5005 } 5006 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5007 public TerminalNode CDATA(int i) { 5008 return getToken(JavadocParser.CDATA, i); 5009 } 5010 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5011 public TerminalNode NEWLINE(int i) { 5012 return getToken(JavadocParser.NEWLINE, i); 5013 } 5014 public List<TextContext> text() { 5015 return getRuleContexts(TextContext.class); 5016 } 5017 public TextContext text(int i) { 5018 return getRuleContext(TextContext.class,i); 5019 } 5020 public List<JavadocInlineTagContext> javadocInlineTag() { 5021 return getRuleContexts(JavadocInlineTagContext.class); 5022 } 5023 public JavadocInlineTagContext javadocInlineTag(int i) { 5024 return getRuleContext(JavadocInlineTagContext.class,i); 5025 } 5026 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5027 public TerminalNode LEADING_ASTERISK(int i) { 5028 return getToken(JavadocParser.LEADING_ASTERISK, i); 5029 } 5030 public ThContext(ParserRuleContext parent, int invokingState) { 5031 super(parent, invokingState); 5032 } 5033 @Override public int getRuleIndex() { return RULE_th; } 5034 } 5035 5036 public final ThContext th() throws RecognitionException { 5037 ThContext _localctx = new ThContext(_ctx, getState()); 5038 enterRule(_localctx, 40, RULE_th); 5039 try { 5040 int _alt; 5041 enterOuterAlt(_localctx, 1); 5042 { 5043 setState(684); 5044 thTagStart(false); 5045 setState(734); 5046 _errHandler.sync(this); 5047 _alt = getInterpreter().adaptivePredict(_input,38,_ctx); 5048 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5049 if ( _alt==1 ) { 5050 { 5051 setState(732); 5052 _errHandler.sync(this); 5053 switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) { 5054 case 1: 5055 { 5056 setState(685); 5057 htmlTag(); 5058 } 5059 break; 5060 case 2: 5061 { 5062 setState(686); 5063 singletonElement(); 5064 } 5065 break; 5066 case 3: 5067 { 5068 setState(687); 5069 paragraph(); 5070 } 5071 break; 5072 case 4: 5073 { 5074 setState(688); 5075 li(); 5076 } 5077 break; 5078 case 5: 5079 { 5080 setState(689); 5081 tr(); 5082 } 5083 break; 5084 case 6: 5085 { 5086 setState(690); 5087 td(); 5088 } 5089 break; 5090 case 7: 5091 { 5092 setState(691); 5093 body(); 5094 } 5095 break; 5096 case 8: 5097 { 5098 setState(692); 5099 colgroup(); 5100 } 5101 break; 5102 case 9: 5103 { 5104 setState(693); 5105 dd(); 5106 } 5107 break; 5108 case 10: 5109 { 5110 setState(694); 5111 dt(); 5112 } 5113 break; 5114 case 11: 5115 { 5116 setState(695); 5117 head(); 5118 } 5119 break; 5120 case 12: 5121 { 5122 setState(696); 5123 html(); 5124 } 5125 break; 5126 case 13: 5127 { 5128 setState(697); 5129 option(); 5130 } 5131 break; 5132 case 14: 5133 { 5134 setState(698); 5135 tbody(); 5136 } 5137 break; 5138 case 15: 5139 { 5140 setState(699); 5141 thead(); 5142 } 5143 break; 5144 case 16: 5145 { 5146 setState(700); 5147 tfoot(); 5148 } 5149 break; 5150 case 17: 5151 { 5152 setState(701); 5153 optgroup(); 5154 } 5155 break; 5156 case 18: 5157 { 5158 setState(702); 5159 rb(); 5160 } 5161 break; 5162 case 19: 5163 { 5164 setState(703); 5165 rt(); 5166 } 5167 break; 5168 case 20: 5169 { 5170 setState(704); 5171 rtc(); 5172 } 5173 break; 5174 case 21: 5175 { 5176 setState(705); 5177 rp(); 5178 } 5179 break; 5180 case 22: 5181 { 5182 setState(706); 5183 pTagStart(true); 5184 } 5185 break; 5186 case 23: 5187 { 5188 setState(707); 5189 liTagStart(true); 5190 } 5191 break; 5192 case 24: 5193 { 5194 setState(708); 5195 trTagStart(true); 5196 } 5197 break; 5198 case 25: 5199 { 5200 setState(709); 5201 tdTagStart(true); 5202 } 5203 break; 5204 case 26: 5205 { 5206 setState(710); 5207 bodyTagStart(true); 5208 } 5209 break; 5210 case 27: 5211 { 5212 setState(711); 5213 colgroupTagStart(true); 5214 } 5215 break; 5216 case 28: 5217 { 5218 setState(712); 5219 ddTagStart(true); 5220 } 5221 break; 5222 case 29: 5223 { 5224 setState(713); 5225 dtTagStart(true); 5226 } 5227 break; 5228 case 30: 5229 { 5230 setState(714); 5231 headTagStart(true); 5232 } 5233 break; 5234 case 31: 5235 { 5236 setState(715); 5237 htmlTagStart(true); 5238 } 5239 break; 5240 case 32: 5241 { 5242 setState(716); 5243 optionTagStart(true); 5244 } 5245 break; 5246 case 33: 5247 { 5248 setState(717); 5249 tbodyTagStart(true); 5250 } 5251 break; 5252 case 34: 5253 { 5254 setState(718); 5255 theadTagStart(true); 5256 } 5257 break; 5258 case 35: 5259 { 5260 setState(719); 5261 tfootTagStart(true); 5262 } 5263 break; 5264 case 36: 5265 { 5266 setState(720); 5267 optgroupTagStart(true); 5268 } 5269 break; 5270 case 37: 5271 { 5272 setState(721); 5273 rbTagStart(true); 5274 } 5275 break; 5276 case 38: 5277 { 5278 setState(722); 5279 rtTagStart(true); 5280 } 5281 break; 5282 case 39: 5283 { 5284 setState(723); 5285 rtcTagStart(true); 5286 } 5287 break; 5288 case 40: 5289 { 5290 setState(724); 5291 rpTagStart(true); 5292 } 5293 break; 5294 case 41: 5295 { 5296 { 5297 setState(725); 5298 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 5299 setState(726); 5300 match(LEADING_ASTERISK); 5301 } 5302 } 5303 break; 5304 case 42: 5305 { 5306 setState(727); 5307 htmlComment(); 5308 } 5309 break; 5310 case 43: 5311 { 5312 setState(728); 5313 match(CDATA); 5314 } 5315 break; 5316 case 44: 5317 { 5318 setState(729); 5319 match(NEWLINE); 5320 } 5321 break; 5322 case 45: 5323 { 5324 setState(730); 5325 text(); 5326 } 5327 break; 5328 case 46: 5329 { 5330 setState(731); 5331 javadocInlineTag(); 5332 } 5333 break; 5334 } 5335 } 5336 } 5337 setState(736); 5338 _errHandler.sync(this); 5339 _alt = getInterpreter().adaptivePredict(_input,38,_ctx); 5340 } 5341 setState(737); 5342 thTagEnd(); 5343 } 5344 } 5345 catch (RecognitionException re) { 5346 _localctx.exception = re; 5347 _errHandler.reportError(this, re); 5348 _errHandler.recover(this, re); 5349 } 5350 finally { 5351 exitRule(); 5352 } 5353 return _localctx; 5354 } 5355 5356 public static class BodyTagStartContext extends ParserRuleContext { 5357 public boolean isNonTight; 5358 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 5359 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 5360 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 5361 public List<AttributeContext> attribute() { 5362 return getRuleContexts(AttributeContext.class); 5363 } 5364 public AttributeContext attribute(int i) { 5365 return getRuleContext(AttributeContext.class,i); 5366 } 5367 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5368 public TerminalNode NEWLINE(int i) { 5369 return getToken(JavadocParser.NEWLINE, i); 5370 } 5371 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5372 public TerminalNode LEADING_ASTERISK(int i) { 5373 return getToken(JavadocParser.LEADING_ASTERISK, i); 5374 } 5375 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5376 public TerminalNode WS(int i) { 5377 return getToken(JavadocParser.WS, i); 5378 } 5379 public BodyTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 5380 public BodyTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 5381 super(parent, invokingState); 5382 this.isNonTight = isNonTight; 5383 } 5384 @Override public int getRuleIndex() { return RULE_bodyTagStart; } 5385 } 5386 5387 public final BodyTagStartContext bodyTagStart(boolean isNonTight) throws RecognitionException { 5388 BodyTagStartContext _localctx = new BodyTagStartContext(_ctx, getState(), isNonTight); 5389 enterRule(_localctx, 42, RULE_bodyTagStart); 5390 int _la; 5391 try { 5392 enterOuterAlt(_localctx, 1); 5393 { 5394 setState(739); 5395 match(START); 5396 setState(740); 5397 match(BODY_HTML_TAG_NAME); 5398 setState(747); 5399 _errHandler.sync(this); 5400 _la = _input.LA(1); 5401 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 5402 { 5403 setState(745); 5404 _errHandler.sync(this); 5405 switch (_input.LA(1)) { 5406 case HTML_TAG_NAME: 5407 { 5408 setState(741); 5409 attribute(); 5410 } 5411 break; 5412 case NEWLINE: 5413 { 5414 setState(742); 5415 match(NEWLINE); 5416 } 5417 break; 5418 case LEADING_ASTERISK: 5419 { 5420 setState(743); 5421 match(LEADING_ASTERISK); 5422 } 5423 break; 5424 case WS: 5425 { 5426 setState(744); 5427 match(WS); 5428 } 5429 break; 5430 default: 5431 throw new NoViableAltException(this); 5432 } 5433 } 5434 setState(749); 5435 _errHandler.sync(this); 5436 _la = _input.LA(1); 5437 } 5438 setState(750); 5439 match(END); 5440 } 5441 _ctx.stop = _input.LT(-1); 5442 5443 if (isNonTight && nonTightTagStartContext == null) { 5444 nonTightTagStartContext = _localctx; 5445 } 5446 5447 } 5448 catch (RecognitionException re) { 5449 _localctx.exception = re; 5450 _errHandler.reportError(this, re); 5451 _errHandler.recover(this, re); 5452 } 5453 finally { 5454 exitRule(); 5455 } 5456 return _localctx; 5457 } 5458 5459 public static class BodyTagEndContext extends ParserRuleContext { 5460 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 5461 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 5462 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 5463 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 5464 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5465 public TerminalNode NEWLINE(int i) { 5466 return getToken(JavadocParser.NEWLINE, i); 5467 } 5468 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5469 public TerminalNode LEADING_ASTERISK(int i) { 5470 return getToken(JavadocParser.LEADING_ASTERISK, i); 5471 } 5472 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5473 public TerminalNode WS(int i) { 5474 return getToken(JavadocParser.WS, i); 5475 } 5476 public BodyTagEndContext(ParserRuleContext parent, int invokingState) { 5477 super(parent, invokingState); 5478 } 5479 @Override public int getRuleIndex() { return RULE_bodyTagEnd; } 5480 } 5481 5482 public final BodyTagEndContext bodyTagEnd() throws RecognitionException { 5483 BodyTagEndContext _localctx = new BodyTagEndContext(_ctx, getState()); 5484 enterRule(_localctx, 44, RULE_bodyTagEnd); 5485 int _la; 5486 try { 5487 enterOuterAlt(_localctx, 1); 5488 { 5489 setState(752); 5490 match(START); 5491 setState(753); 5492 match(SLASH); 5493 setState(754); 5494 match(BODY_HTML_TAG_NAME); 5495 setState(758); 5496 _errHandler.sync(this); 5497 _la = _input.LA(1); 5498 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5499 { 5500 { 5501 setState(755); 5502 _la = _input.LA(1); 5503 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5504 _errHandler.recoverInline(this); 5505 } 5506 else { 5507 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 5508 _errHandler.reportMatch(this); 5509 consume(); 5510 } 5511 } 5512 } 5513 setState(760); 5514 _errHandler.sync(this); 5515 _la = _input.LA(1); 5516 } 5517 setState(761); 5518 match(END); 5519 } 5520 } 5521 catch (RecognitionException re) { 5522 _localctx.exception = re; 5523 _errHandler.reportError(this, re); 5524 _errHandler.recover(this, re); 5525 } 5526 finally { 5527 exitRule(); 5528 } 5529 return _localctx; 5530 } 5531 5532 public static class BodyContext extends ParserRuleContext { 5533 public BodyTagStartContext bodyTagStart() { 5534 return getRuleContext(BodyTagStartContext.class,0); 5535 } 5536 public BodyTagEndContext bodyTagEnd() { 5537 return getRuleContext(BodyTagEndContext.class,0); 5538 } 5539 public List<HtmlTagContext> htmlTag() { 5540 return getRuleContexts(HtmlTagContext.class); 5541 } 5542 public HtmlTagContext htmlTag(int i) { 5543 return getRuleContext(HtmlTagContext.class,i); 5544 } 5545 public List<SingletonElementContext> singletonElement() { 5546 return getRuleContexts(SingletonElementContext.class); 5547 } 5548 public SingletonElementContext singletonElement(int i) { 5549 return getRuleContext(SingletonElementContext.class,i); 5550 } 5551 public List<ParagraphContext> paragraph() { 5552 return getRuleContexts(ParagraphContext.class); 5553 } 5554 public ParagraphContext paragraph(int i) { 5555 return getRuleContext(ParagraphContext.class,i); 5556 } 5557 public List<LiContext> li() { 5558 return getRuleContexts(LiContext.class); 5559 } 5560 public LiContext li(int i) { 5561 return getRuleContext(LiContext.class,i); 5562 } 5563 public List<TrContext> tr() { 5564 return getRuleContexts(TrContext.class); 5565 } 5566 public TrContext tr(int i) { 5567 return getRuleContext(TrContext.class,i); 5568 } 5569 public List<TdContext> td() { 5570 return getRuleContexts(TdContext.class); 5571 } 5572 public TdContext td(int i) { 5573 return getRuleContext(TdContext.class,i); 5574 } 5575 public List<ThContext> th() { 5576 return getRuleContexts(ThContext.class); 5577 } 5578 public ThContext th(int i) { 5579 return getRuleContext(ThContext.class,i); 5580 } 5581 public List<ColgroupContext> colgroup() { 5582 return getRuleContexts(ColgroupContext.class); 5583 } 5584 public ColgroupContext colgroup(int i) { 5585 return getRuleContext(ColgroupContext.class,i); 5586 } 5587 public List<DdContext> dd() { 5588 return getRuleContexts(DdContext.class); 5589 } 5590 public DdContext dd(int i) { 5591 return getRuleContext(DdContext.class,i); 5592 } 5593 public List<DtContext> dt() { 5594 return getRuleContexts(DtContext.class); 5595 } 5596 public DtContext dt(int i) { 5597 return getRuleContext(DtContext.class,i); 5598 } 5599 public List<HeadContext> head() { 5600 return getRuleContexts(HeadContext.class); 5601 } 5602 public HeadContext head(int i) { 5603 return getRuleContext(HeadContext.class,i); 5604 } 5605 public List<HtmlContext> html() { 5606 return getRuleContexts(HtmlContext.class); 5607 } 5608 public HtmlContext html(int i) { 5609 return getRuleContext(HtmlContext.class,i); 5610 } 5611 public List<OptionContext> option() { 5612 return getRuleContexts(OptionContext.class); 5613 } 5614 public OptionContext option(int i) { 5615 return getRuleContext(OptionContext.class,i); 5616 } 5617 public List<TbodyContext> tbody() { 5618 return getRuleContexts(TbodyContext.class); 5619 } 5620 public TbodyContext tbody(int i) { 5621 return getRuleContext(TbodyContext.class,i); 5622 } 5623 public List<TheadContext> thead() { 5624 return getRuleContexts(TheadContext.class); 5625 } 5626 public TheadContext thead(int i) { 5627 return getRuleContext(TheadContext.class,i); 5628 } 5629 public List<TfootContext> tfoot() { 5630 return getRuleContexts(TfootContext.class); 5631 } 5632 public TfootContext tfoot(int i) { 5633 return getRuleContext(TfootContext.class,i); 5634 } 5635 public List<OptgroupContext> optgroup() { 5636 return getRuleContexts(OptgroupContext.class); 5637 } 5638 public OptgroupContext optgroup(int i) { 5639 return getRuleContext(OptgroupContext.class,i); 5640 } 5641 public List<RbContext> rb() { 5642 return getRuleContexts(RbContext.class); 5643 } 5644 public RbContext rb(int i) { 5645 return getRuleContext(RbContext.class,i); 5646 } 5647 public List<RtContext> rt() { 5648 return getRuleContexts(RtContext.class); 5649 } 5650 public RtContext rt(int i) { 5651 return getRuleContext(RtContext.class,i); 5652 } 5653 public List<RtcContext> rtc() { 5654 return getRuleContexts(RtcContext.class); 5655 } 5656 public RtcContext rtc(int i) { 5657 return getRuleContext(RtcContext.class,i); 5658 } 5659 public List<RpContext> rp() { 5660 return getRuleContexts(RpContext.class); 5661 } 5662 public RpContext rp(int i) { 5663 return getRuleContext(RpContext.class,i); 5664 } 5665 public List<PTagStartContext> pTagStart() { 5666 return getRuleContexts(PTagStartContext.class); 5667 } 5668 public PTagStartContext pTagStart(int i) { 5669 return getRuleContext(PTagStartContext.class,i); 5670 } 5671 public List<LiTagStartContext> liTagStart() { 5672 return getRuleContexts(LiTagStartContext.class); 5673 } 5674 public LiTagStartContext liTagStart(int i) { 5675 return getRuleContext(LiTagStartContext.class,i); 5676 } 5677 public List<TrTagStartContext> trTagStart() { 5678 return getRuleContexts(TrTagStartContext.class); 5679 } 5680 public TrTagStartContext trTagStart(int i) { 5681 return getRuleContext(TrTagStartContext.class,i); 5682 } 5683 public List<TdTagStartContext> tdTagStart() { 5684 return getRuleContexts(TdTagStartContext.class); 5685 } 5686 public TdTagStartContext tdTagStart(int i) { 5687 return getRuleContext(TdTagStartContext.class,i); 5688 } 5689 public List<ThTagStartContext> thTagStart() { 5690 return getRuleContexts(ThTagStartContext.class); 5691 } 5692 public ThTagStartContext thTagStart(int i) { 5693 return getRuleContext(ThTagStartContext.class,i); 5694 } 5695 public List<ColgroupTagStartContext> colgroupTagStart() { 5696 return getRuleContexts(ColgroupTagStartContext.class); 5697 } 5698 public ColgroupTagStartContext colgroupTagStart(int i) { 5699 return getRuleContext(ColgroupTagStartContext.class,i); 5700 } 5701 public List<DdTagStartContext> ddTagStart() { 5702 return getRuleContexts(DdTagStartContext.class); 5703 } 5704 public DdTagStartContext ddTagStart(int i) { 5705 return getRuleContext(DdTagStartContext.class,i); 5706 } 5707 public List<DtTagStartContext> dtTagStart() { 5708 return getRuleContexts(DtTagStartContext.class); 5709 } 5710 public DtTagStartContext dtTagStart(int i) { 5711 return getRuleContext(DtTagStartContext.class,i); 5712 } 5713 public List<HeadTagStartContext> headTagStart() { 5714 return getRuleContexts(HeadTagStartContext.class); 5715 } 5716 public HeadTagStartContext headTagStart(int i) { 5717 return getRuleContext(HeadTagStartContext.class,i); 5718 } 5719 public List<HtmlTagStartContext> htmlTagStart() { 5720 return getRuleContexts(HtmlTagStartContext.class); 5721 } 5722 public HtmlTagStartContext htmlTagStart(int i) { 5723 return getRuleContext(HtmlTagStartContext.class,i); 5724 } 5725 public List<OptionTagStartContext> optionTagStart() { 5726 return getRuleContexts(OptionTagStartContext.class); 5727 } 5728 public OptionTagStartContext optionTagStart(int i) { 5729 return getRuleContext(OptionTagStartContext.class,i); 5730 } 5731 public List<TbodyTagStartContext> tbodyTagStart() { 5732 return getRuleContexts(TbodyTagStartContext.class); 5733 } 5734 public TbodyTagStartContext tbodyTagStart(int i) { 5735 return getRuleContext(TbodyTagStartContext.class,i); 5736 } 5737 public List<TheadTagStartContext> theadTagStart() { 5738 return getRuleContexts(TheadTagStartContext.class); 5739 } 5740 public TheadTagStartContext theadTagStart(int i) { 5741 return getRuleContext(TheadTagStartContext.class,i); 5742 } 5743 public List<TfootTagStartContext> tfootTagStart() { 5744 return getRuleContexts(TfootTagStartContext.class); 5745 } 5746 public TfootTagStartContext tfootTagStart(int i) { 5747 return getRuleContext(TfootTagStartContext.class,i); 5748 } 5749 public List<OptgroupTagStartContext> optgroupTagStart() { 5750 return getRuleContexts(OptgroupTagStartContext.class); 5751 } 5752 public OptgroupTagStartContext optgroupTagStart(int i) { 5753 return getRuleContext(OptgroupTagStartContext.class,i); 5754 } 5755 public List<RbTagStartContext> rbTagStart() { 5756 return getRuleContexts(RbTagStartContext.class); 5757 } 5758 public RbTagStartContext rbTagStart(int i) { 5759 return getRuleContext(RbTagStartContext.class,i); 5760 } 5761 public List<RtTagStartContext> rtTagStart() { 5762 return getRuleContexts(RtTagStartContext.class); 5763 } 5764 public RtTagStartContext rtTagStart(int i) { 5765 return getRuleContext(RtTagStartContext.class,i); 5766 } 5767 public List<RtcTagStartContext> rtcTagStart() { 5768 return getRuleContexts(RtcTagStartContext.class); 5769 } 5770 public RtcTagStartContext rtcTagStart(int i) { 5771 return getRuleContext(RtcTagStartContext.class,i); 5772 } 5773 public List<RpTagStartContext> rpTagStart() { 5774 return getRuleContexts(RpTagStartContext.class); 5775 } 5776 public RpTagStartContext rpTagStart(int i) { 5777 return getRuleContext(RpTagStartContext.class,i); 5778 } 5779 public List<HtmlCommentContext> htmlComment() { 5780 return getRuleContexts(HtmlCommentContext.class); 5781 } 5782 public HtmlCommentContext htmlComment(int i) { 5783 return getRuleContext(HtmlCommentContext.class,i); 5784 } 5785 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5786 public TerminalNode CDATA(int i) { 5787 return getToken(JavadocParser.CDATA, i); 5788 } 5789 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5790 public TerminalNode NEWLINE(int i) { 5791 return getToken(JavadocParser.NEWLINE, i); 5792 } 5793 public List<TextContext> text() { 5794 return getRuleContexts(TextContext.class); 5795 } 5796 public TextContext text(int i) { 5797 return getRuleContext(TextContext.class,i); 5798 } 5799 public List<JavadocInlineTagContext> javadocInlineTag() { 5800 return getRuleContexts(JavadocInlineTagContext.class); 5801 } 5802 public JavadocInlineTagContext javadocInlineTag(int i) { 5803 return getRuleContext(JavadocInlineTagContext.class,i); 5804 } 5805 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5806 public TerminalNode LEADING_ASTERISK(int i) { 5807 return getToken(JavadocParser.LEADING_ASTERISK, i); 5808 } 5809 public BodyContext(ParserRuleContext parent, int invokingState) { 5810 super(parent, invokingState); 5811 } 5812 @Override public int getRuleIndex() { return RULE_body; } 5813 } 5814 5815 public final BodyContext body() throws RecognitionException { 5816 BodyContext _localctx = new BodyContext(_ctx, getState()); 5817 enterRule(_localctx, 46, RULE_body); 5818 try { 5819 int _alt; 5820 enterOuterAlt(_localctx, 1); 5821 { 5822 setState(763); 5823 bodyTagStart(false); 5824 setState(813); 5825 _errHandler.sync(this); 5826 _alt = getInterpreter().adaptivePredict(_input,43,_ctx); 5827 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5828 if ( _alt==1 ) { 5829 { 5830 setState(811); 5831 _errHandler.sync(this); 5832 switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) { 5833 case 1: 5834 { 5835 setState(764); 5836 htmlTag(); 5837 } 5838 break; 5839 case 2: 5840 { 5841 setState(765); 5842 singletonElement(); 5843 } 5844 break; 5845 case 3: 5846 { 5847 setState(766); 5848 paragraph(); 5849 } 5850 break; 5851 case 4: 5852 { 5853 setState(767); 5854 li(); 5855 } 5856 break; 5857 case 5: 5858 { 5859 setState(768); 5860 tr(); 5861 } 5862 break; 5863 case 6: 5864 { 5865 setState(769); 5866 td(); 5867 } 5868 break; 5869 case 7: 5870 { 5871 setState(770); 5872 th(); 5873 } 5874 break; 5875 case 8: 5876 { 5877 setState(771); 5878 colgroup(); 5879 } 5880 break; 5881 case 9: 5882 { 5883 setState(772); 5884 dd(); 5885 } 5886 break; 5887 case 10: 5888 { 5889 setState(773); 5890 dt(); 5891 } 5892 break; 5893 case 11: 5894 { 5895 setState(774); 5896 head(); 5897 } 5898 break; 5899 case 12: 5900 { 5901 setState(775); 5902 html(); 5903 } 5904 break; 5905 case 13: 5906 { 5907 setState(776); 5908 option(); 5909 } 5910 break; 5911 case 14: 5912 { 5913 setState(777); 5914 tbody(); 5915 } 5916 break; 5917 case 15: 5918 { 5919 setState(778); 5920 thead(); 5921 } 5922 break; 5923 case 16: 5924 { 5925 setState(779); 5926 tfoot(); 5927 } 5928 break; 5929 case 17: 5930 { 5931 setState(780); 5932 optgroup(); 5933 } 5934 break; 5935 case 18: 5936 { 5937 setState(781); 5938 rb(); 5939 } 5940 break; 5941 case 19: 5942 { 5943 setState(782); 5944 rt(); 5945 } 5946 break; 5947 case 20: 5948 { 5949 setState(783); 5950 rtc(); 5951 } 5952 break; 5953 case 21: 5954 { 5955 setState(784); 5956 rp(); 5957 } 5958 break; 5959 case 22: 5960 { 5961 setState(785); 5962 pTagStart(true); 5963 } 5964 break; 5965 case 23: 5966 { 5967 setState(786); 5968 liTagStart(true); 5969 } 5970 break; 5971 case 24: 5972 { 5973 setState(787); 5974 trTagStart(true); 5975 } 5976 break; 5977 case 25: 5978 { 5979 setState(788); 5980 tdTagStart(true); 5981 } 5982 break; 5983 case 26: 5984 { 5985 setState(789); 5986 thTagStart(true); 5987 } 5988 break; 5989 case 27: 5990 { 5991 setState(790); 5992 colgroupTagStart(true); 5993 } 5994 break; 5995 case 28: 5996 { 5997 setState(791); 5998 ddTagStart(true); 5999 } 6000 break; 6001 case 29: 6002 { 6003 setState(792); 6004 dtTagStart(true); 6005 } 6006 break; 6007 case 30: 6008 { 6009 setState(793); 6010 headTagStart(true); 6011 } 6012 break; 6013 case 31: 6014 { 6015 setState(794); 6016 htmlTagStart(true); 6017 } 6018 break; 6019 case 32: 6020 { 6021 setState(795); 6022 optionTagStart(true); 6023 } 6024 break; 6025 case 33: 6026 { 6027 setState(796); 6028 tbodyTagStart(true); 6029 } 6030 break; 6031 case 34: 6032 { 6033 setState(797); 6034 theadTagStart(true); 6035 } 6036 break; 6037 case 35: 6038 { 6039 setState(798); 6040 tfootTagStart(true); 6041 } 6042 break; 6043 case 36: 6044 { 6045 setState(799); 6046 optgroupTagStart(true); 6047 } 6048 break; 6049 case 37: 6050 { 6051 setState(800); 6052 rbTagStart(true); 6053 } 6054 break; 6055 case 38: 6056 { 6057 setState(801); 6058 rtTagStart(true); 6059 } 6060 break; 6061 case 39: 6062 { 6063 setState(802); 6064 rtcTagStart(true); 6065 } 6066 break; 6067 case 40: 6068 { 6069 setState(803); 6070 rpTagStart(true); 6071 } 6072 break; 6073 case 41: 6074 { 6075 { 6076 setState(804); 6077 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6078 setState(805); 6079 match(LEADING_ASTERISK); 6080 } 6081 } 6082 break; 6083 case 42: 6084 { 6085 setState(806); 6086 htmlComment(); 6087 } 6088 break; 6089 case 43: 6090 { 6091 setState(807); 6092 match(CDATA); 6093 } 6094 break; 6095 case 44: 6096 { 6097 setState(808); 6098 match(NEWLINE); 6099 } 6100 break; 6101 case 45: 6102 { 6103 setState(809); 6104 text(); 6105 } 6106 break; 6107 case 46: 6108 { 6109 setState(810); 6110 javadocInlineTag(); 6111 } 6112 break; 6113 } 6114 } 6115 } 6116 setState(815); 6117 _errHandler.sync(this); 6118 _alt = getInterpreter().adaptivePredict(_input,43,_ctx); 6119 } 6120 setState(816); 6121 bodyTagEnd(); 6122 } 6123 } 6124 catch (RecognitionException re) { 6125 _localctx.exception = re; 6126 _errHandler.reportError(this, re); 6127 _errHandler.recover(this, re); 6128 } 6129 finally { 6130 exitRule(); 6131 } 6132 return _localctx; 6133 } 6134 6135 public static class ColgroupTagStartContext extends ParserRuleContext { 6136 public boolean isNonTight; 6137 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 6138 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 6139 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 6140 public List<AttributeContext> attribute() { 6141 return getRuleContexts(AttributeContext.class); 6142 } 6143 public AttributeContext attribute(int i) { 6144 return getRuleContext(AttributeContext.class,i); 6145 } 6146 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6147 public TerminalNode NEWLINE(int i) { 6148 return getToken(JavadocParser.NEWLINE, i); 6149 } 6150 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6151 public TerminalNode LEADING_ASTERISK(int i) { 6152 return getToken(JavadocParser.LEADING_ASTERISK, i); 6153 } 6154 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6155 public TerminalNode WS(int i) { 6156 return getToken(JavadocParser.WS, i); 6157 } 6158 public ColgroupTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 6159 public ColgroupTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 6160 super(parent, invokingState); 6161 this.isNonTight = isNonTight; 6162 } 6163 @Override public int getRuleIndex() { return RULE_colgroupTagStart; } 6164 } 6165 6166 public final ColgroupTagStartContext colgroupTagStart(boolean isNonTight) throws RecognitionException { 6167 ColgroupTagStartContext _localctx = new ColgroupTagStartContext(_ctx, getState(), isNonTight); 6168 enterRule(_localctx, 48, RULE_colgroupTagStart); 6169 int _la; 6170 try { 6171 enterOuterAlt(_localctx, 1); 6172 { 6173 setState(818); 6174 match(START); 6175 setState(819); 6176 match(COLGROUP_HTML_TAG_NAME); 6177 setState(826); 6178 _errHandler.sync(this); 6179 _la = _input.LA(1); 6180 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6181 { 6182 setState(824); 6183 _errHandler.sync(this); 6184 switch (_input.LA(1)) { 6185 case HTML_TAG_NAME: 6186 { 6187 setState(820); 6188 attribute(); 6189 } 6190 break; 6191 case NEWLINE: 6192 { 6193 setState(821); 6194 match(NEWLINE); 6195 } 6196 break; 6197 case LEADING_ASTERISK: 6198 { 6199 setState(822); 6200 match(LEADING_ASTERISK); 6201 } 6202 break; 6203 case WS: 6204 { 6205 setState(823); 6206 match(WS); 6207 } 6208 break; 6209 default: 6210 throw new NoViableAltException(this); 6211 } 6212 } 6213 setState(828); 6214 _errHandler.sync(this); 6215 _la = _input.LA(1); 6216 } 6217 setState(829); 6218 match(END); 6219 } 6220 _ctx.stop = _input.LT(-1); 6221 6222 if (isNonTight && nonTightTagStartContext == null) { 6223 nonTightTagStartContext = _localctx; 6224 } 6225 6226 } 6227 catch (RecognitionException re) { 6228 _localctx.exception = re; 6229 _errHandler.reportError(this, re); 6230 _errHandler.recover(this, re); 6231 } 6232 finally { 6233 exitRule(); 6234 } 6235 return _localctx; 6236 } 6237 6238 public static class ColgroupTagEndContext extends ParserRuleContext { 6239 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 6240 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 6241 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 6242 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 6243 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6244 public TerminalNode NEWLINE(int i) { 6245 return getToken(JavadocParser.NEWLINE, i); 6246 } 6247 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6248 public TerminalNode LEADING_ASTERISK(int i) { 6249 return getToken(JavadocParser.LEADING_ASTERISK, i); 6250 } 6251 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6252 public TerminalNode WS(int i) { 6253 return getToken(JavadocParser.WS, i); 6254 } 6255 public ColgroupTagEndContext(ParserRuleContext parent, int invokingState) { 6256 super(parent, invokingState); 6257 } 6258 @Override public int getRuleIndex() { return RULE_colgroupTagEnd; } 6259 } 6260 6261 public final ColgroupTagEndContext colgroupTagEnd() throws RecognitionException { 6262 ColgroupTagEndContext _localctx = new ColgroupTagEndContext(_ctx, getState()); 6263 enterRule(_localctx, 50, RULE_colgroupTagEnd); 6264 int _la; 6265 try { 6266 enterOuterAlt(_localctx, 1); 6267 { 6268 setState(831); 6269 match(START); 6270 setState(832); 6271 match(SLASH); 6272 setState(833); 6273 match(COLGROUP_HTML_TAG_NAME); 6274 setState(837); 6275 _errHandler.sync(this); 6276 _la = _input.LA(1); 6277 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 6278 { 6279 { 6280 setState(834); 6281 _la = _input.LA(1); 6282 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 6283 _errHandler.recoverInline(this); 6284 } 6285 else { 6286 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 6287 _errHandler.reportMatch(this); 6288 consume(); 6289 } 6290 } 6291 } 6292 setState(839); 6293 _errHandler.sync(this); 6294 _la = _input.LA(1); 6295 } 6296 setState(840); 6297 match(END); 6298 } 6299 } 6300 catch (RecognitionException re) { 6301 _localctx.exception = re; 6302 _errHandler.reportError(this, re); 6303 _errHandler.recover(this, re); 6304 } 6305 finally { 6306 exitRule(); 6307 } 6308 return _localctx; 6309 } 6310 6311 public static class ColgroupContext extends ParserRuleContext { 6312 public ColgroupTagStartContext colgroupTagStart() { 6313 return getRuleContext(ColgroupTagStartContext.class,0); 6314 } 6315 public ColgroupTagEndContext colgroupTagEnd() { 6316 return getRuleContext(ColgroupTagEndContext.class,0); 6317 } 6318 public List<HtmlTagContext> htmlTag() { 6319 return getRuleContexts(HtmlTagContext.class); 6320 } 6321 public HtmlTagContext htmlTag(int i) { 6322 return getRuleContext(HtmlTagContext.class,i); 6323 } 6324 public List<SingletonElementContext> singletonElement() { 6325 return getRuleContexts(SingletonElementContext.class); 6326 } 6327 public SingletonElementContext singletonElement(int i) { 6328 return getRuleContext(SingletonElementContext.class,i); 6329 } 6330 public List<ParagraphContext> paragraph() { 6331 return getRuleContexts(ParagraphContext.class); 6332 } 6333 public ParagraphContext paragraph(int i) { 6334 return getRuleContext(ParagraphContext.class,i); 6335 } 6336 public List<LiContext> li() { 6337 return getRuleContexts(LiContext.class); 6338 } 6339 public LiContext li(int i) { 6340 return getRuleContext(LiContext.class,i); 6341 } 6342 public List<TrContext> tr() { 6343 return getRuleContexts(TrContext.class); 6344 } 6345 public TrContext tr(int i) { 6346 return getRuleContext(TrContext.class,i); 6347 } 6348 public List<TdContext> td() { 6349 return getRuleContexts(TdContext.class); 6350 } 6351 public TdContext td(int i) { 6352 return getRuleContext(TdContext.class,i); 6353 } 6354 public List<ThContext> th() { 6355 return getRuleContexts(ThContext.class); 6356 } 6357 public ThContext th(int i) { 6358 return getRuleContext(ThContext.class,i); 6359 } 6360 public List<BodyContext> body() { 6361 return getRuleContexts(BodyContext.class); 6362 } 6363 public BodyContext body(int i) { 6364 return getRuleContext(BodyContext.class,i); 6365 } 6366 public List<DdContext> dd() { 6367 return getRuleContexts(DdContext.class); 6368 } 6369 public DdContext dd(int i) { 6370 return getRuleContext(DdContext.class,i); 6371 } 6372 public List<DtContext> dt() { 6373 return getRuleContexts(DtContext.class); 6374 } 6375 public DtContext dt(int i) { 6376 return getRuleContext(DtContext.class,i); 6377 } 6378 public List<HeadContext> head() { 6379 return getRuleContexts(HeadContext.class); 6380 } 6381 public HeadContext head(int i) { 6382 return getRuleContext(HeadContext.class,i); 6383 } 6384 public List<HtmlContext> html() { 6385 return getRuleContexts(HtmlContext.class); 6386 } 6387 public HtmlContext html(int i) { 6388 return getRuleContext(HtmlContext.class,i); 6389 } 6390 public List<OptionContext> option() { 6391 return getRuleContexts(OptionContext.class); 6392 } 6393 public OptionContext option(int i) { 6394 return getRuleContext(OptionContext.class,i); 6395 } 6396 public List<TbodyContext> tbody() { 6397 return getRuleContexts(TbodyContext.class); 6398 } 6399 public TbodyContext tbody(int i) { 6400 return getRuleContext(TbodyContext.class,i); 6401 } 6402 public List<TheadContext> thead() { 6403 return getRuleContexts(TheadContext.class); 6404 } 6405 public TheadContext thead(int i) { 6406 return getRuleContext(TheadContext.class,i); 6407 } 6408 public List<TfootContext> tfoot() { 6409 return getRuleContexts(TfootContext.class); 6410 } 6411 public TfootContext tfoot(int i) { 6412 return getRuleContext(TfootContext.class,i); 6413 } 6414 public List<OptgroupContext> optgroup() { 6415 return getRuleContexts(OptgroupContext.class); 6416 } 6417 public OptgroupContext optgroup(int i) { 6418 return getRuleContext(OptgroupContext.class,i); 6419 } 6420 public List<RbContext> rb() { 6421 return getRuleContexts(RbContext.class); 6422 } 6423 public RbContext rb(int i) { 6424 return getRuleContext(RbContext.class,i); 6425 } 6426 public List<RtContext> rt() { 6427 return getRuleContexts(RtContext.class); 6428 } 6429 public RtContext rt(int i) { 6430 return getRuleContext(RtContext.class,i); 6431 } 6432 public List<RtcContext> rtc() { 6433 return getRuleContexts(RtcContext.class); 6434 } 6435 public RtcContext rtc(int i) { 6436 return getRuleContext(RtcContext.class,i); 6437 } 6438 public List<RpContext> rp() { 6439 return getRuleContexts(RpContext.class); 6440 } 6441 public RpContext rp(int i) { 6442 return getRuleContext(RpContext.class,i); 6443 } 6444 public List<PTagStartContext> pTagStart() { 6445 return getRuleContexts(PTagStartContext.class); 6446 } 6447 public PTagStartContext pTagStart(int i) { 6448 return getRuleContext(PTagStartContext.class,i); 6449 } 6450 public List<LiTagStartContext> liTagStart() { 6451 return getRuleContexts(LiTagStartContext.class); 6452 } 6453 public LiTagStartContext liTagStart(int i) { 6454 return getRuleContext(LiTagStartContext.class,i); 6455 } 6456 public List<TrTagStartContext> trTagStart() { 6457 return getRuleContexts(TrTagStartContext.class); 6458 } 6459 public TrTagStartContext trTagStart(int i) { 6460 return getRuleContext(TrTagStartContext.class,i); 6461 } 6462 public List<TdTagStartContext> tdTagStart() { 6463 return getRuleContexts(TdTagStartContext.class); 6464 } 6465 public TdTagStartContext tdTagStart(int i) { 6466 return getRuleContext(TdTagStartContext.class,i); 6467 } 6468 public List<ThTagStartContext> thTagStart() { 6469 return getRuleContexts(ThTagStartContext.class); 6470 } 6471 public ThTagStartContext thTagStart(int i) { 6472 return getRuleContext(ThTagStartContext.class,i); 6473 } 6474 public List<BodyTagStartContext> bodyTagStart() { 6475 return getRuleContexts(BodyTagStartContext.class); 6476 } 6477 public BodyTagStartContext bodyTagStart(int i) { 6478 return getRuleContext(BodyTagStartContext.class,i); 6479 } 6480 public List<DdTagStartContext> ddTagStart() { 6481 return getRuleContexts(DdTagStartContext.class); 6482 } 6483 public DdTagStartContext ddTagStart(int i) { 6484 return getRuleContext(DdTagStartContext.class,i); 6485 } 6486 public List<DtTagStartContext> dtTagStart() { 6487 return getRuleContexts(DtTagStartContext.class); 6488 } 6489 public DtTagStartContext dtTagStart(int i) { 6490 return getRuleContext(DtTagStartContext.class,i); 6491 } 6492 public List<HeadTagStartContext> headTagStart() { 6493 return getRuleContexts(HeadTagStartContext.class); 6494 } 6495 public HeadTagStartContext headTagStart(int i) { 6496 return getRuleContext(HeadTagStartContext.class,i); 6497 } 6498 public List<HtmlTagStartContext> htmlTagStart() { 6499 return getRuleContexts(HtmlTagStartContext.class); 6500 } 6501 public HtmlTagStartContext htmlTagStart(int i) { 6502 return getRuleContext(HtmlTagStartContext.class,i); 6503 } 6504 public List<OptionTagStartContext> optionTagStart() { 6505 return getRuleContexts(OptionTagStartContext.class); 6506 } 6507 public OptionTagStartContext optionTagStart(int i) { 6508 return getRuleContext(OptionTagStartContext.class,i); 6509 } 6510 public List<TbodyTagStartContext> tbodyTagStart() { 6511 return getRuleContexts(TbodyTagStartContext.class); 6512 } 6513 public TbodyTagStartContext tbodyTagStart(int i) { 6514 return getRuleContext(TbodyTagStartContext.class,i); 6515 } 6516 public List<TheadTagStartContext> theadTagStart() { 6517 return getRuleContexts(TheadTagStartContext.class); 6518 } 6519 public TheadTagStartContext theadTagStart(int i) { 6520 return getRuleContext(TheadTagStartContext.class,i); 6521 } 6522 public List<TfootTagStartContext> tfootTagStart() { 6523 return getRuleContexts(TfootTagStartContext.class); 6524 } 6525 public TfootTagStartContext tfootTagStart(int i) { 6526 return getRuleContext(TfootTagStartContext.class,i); 6527 } 6528 public List<OptgroupTagStartContext> optgroupTagStart() { 6529 return getRuleContexts(OptgroupTagStartContext.class); 6530 } 6531 public OptgroupTagStartContext optgroupTagStart(int i) { 6532 return getRuleContext(OptgroupTagStartContext.class,i); 6533 } 6534 public List<RbTagStartContext> rbTagStart() { 6535 return getRuleContexts(RbTagStartContext.class); 6536 } 6537 public RbTagStartContext rbTagStart(int i) { 6538 return getRuleContext(RbTagStartContext.class,i); 6539 } 6540 public List<RtTagStartContext> rtTagStart() { 6541 return getRuleContexts(RtTagStartContext.class); 6542 } 6543 public RtTagStartContext rtTagStart(int i) { 6544 return getRuleContext(RtTagStartContext.class,i); 6545 } 6546 public List<RtcTagStartContext> rtcTagStart() { 6547 return getRuleContexts(RtcTagStartContext.class); 6548 } 6549 public RtcTagStartContext rtcTagStart(int i) { 6550 return getRuleContext(RtcTagStartContext.class,i); 6551 } 6552 public List<RpTagStartContext> rpTagStart() { 6553 return getRuleContexts(RpTagStartContext.class); 6554 } 6555 public RpTagStartContext rpTagStart(int i) { 6556 return getRuleContext(RpTagStartContext.class,i); 6557 } 6558 public List<HtmlCommentContext> htmlComment() { 6559 return getRuleContexts(HtmlCommentContext.class); 6560 } 6561 public HtmlCommentContext htmlComment(int i) { 6562 return getRuleContext(HtmlCommentContext.class,i); 6563 } 6564 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 6565 public TerminalNode CDATA(int i) { 6566 return getToken(JavadocParser.CDATA, i); 6567 } 6568 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6569 public TerminalNode NEWLINE(int i) { 6570 return getToken(JavadocParser.NEWLINE, i); 6571 } 6572 public List<TextContext> text() { 6573 return getRuleContexts(TextContext.class); 6574 } 6575 public TextContext text(int i) { 6576 return getRuleContext(TextContext.class,i); 6577 } 6578 public List<JavadocInlineTagContext> javadocInlineTag() { 6579 return getRuleContexts(JavadocInlineTagContext.class); 6580 } 6581 public JavadocInlineTagContext javadocInlineTag(int i) { 6582 return getRuleContext(JavadocInlineTagContext.class,i); 6583 } 6584 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6585 public TerminalNode LEADING_ASTERISK(int i) { 6586 return getToken(JavadocParser.LEADING_ASTERISK, i); 6587 } 6588 public ColgroupContext(ParserRuleContext parent, int invokingState) { 6589 super(parent, invokingState); 6590 } 6591 @Override public int getRuleIndex() { return RULE_colgroup; } 6592 } 6593 6594 public final ColgroupContext colgroup() throws RecognitionException { 6595 ColgroupContext _localctx = new ColgroupContext(_ctx, getState()); 6596 enterRule(_localctx, 52, RULE_colgroup); 6597 try { 6598 int _alt; 6599 enterOuterAlt(_localctx, 1); 6600 { 6601 setState(842); 6602 colgroupTagStart(false); 6603 setState(892); 6604 _errHandler.sync(this); 6605 _alt = getInterpreter().adaptivePredict(_input,48,_ctx); 6606 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6607 if ( _alt==1 ) { 6608 { 6609 setState(890); 6610 _errHandler.sync(this); 6611 switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) { 6612 case 1: 6613 { 6614 setState(843); 6615 htmlTag(); 6616 } 6617 break; 6618 case 2: 6619 { 6620 setState(844); 6621 singletonElement(); 6622 } 6623 break; 6624 case 3: 6625 { 6626 setState(845); 6627 paragraph(); 6628 } 6629 break; 6630 case 4: 6631 { 6632 setState(846); 6633 li(); 6634 } 6635 break; 6636 case 5: 6637 { 6638 setState(847); 6639 tr(); 6640 } 6641 break; 6642 case 6: 6643 { 6644 setState(848); 6645 td(); 6646 } 6647 break; 6648 case 7: 6649 { 6650 setState(849); 6651 th(); 6652 } 6653 break; 6654 case 8: 6655 { 6656 setState(850); 6657 body(); 6658 } 6659 break; 6660 case 9: 6661 { 6662 setState(851); 6663 dd(); 6664 } 6665 break; 6666 case 10: 6667 { 6668 setState(852); 6669 dt(); 6670 } 6671 break; 6672 case 11: 6673 { 6674 setState(853); 6675 head(); 6676 } 6677 break; 6678 case 12: 6679 { 6680 setState(854); 6681 html(); 6682 } 6683 break; 6684 case 13: 6685 { 6686 setState(855); 6687 option(); 6688 } 6689 break; 6690 case 14: 6691 { 6692 setState(856); 6693 tbody(); 6694 } 6695 break; 6696 case 15: 6697 { 6698 setState(857); 6699 thead(); 6700 } 6701 break; 6702 case 16: 6703 { 6704 setState(858); 6705 tfoot(); 6706 } 6707 break; 6708 case 17: 6709 { 6710 setState(859); 6711 optgroup(); 6712 } 6713 break; 6714 case 18: 6715 { 6716 setState(860); 6717 rb(); 6718 } 6719 break; 6720 case 19: 6721 { 6722 setState(861); 6723 rt(); 6724 } 6725 break; 6726 case 20: 6727 { 6728 setState(862); 6729 rtc(); 6730 } 6731 break; 6732 case 21: 6733 { 6734 setState(863); 6735 rp(); 6736 } 6737 break; 6738 case 22: 6739 { 6740 setState(864); 6741 pTagStart(true); 6742 } 6743 break; 6744 case 23: 6745 { 6746 setState(865); 6747 liTagStart(true); 6748 } 6749 break; 6750 case 24: 6751 { 6752 setState(866); 6753 trTagStart(true); 6754 } 6755 break; 6756 case 25: 6757 { 6758 setState(867); 6759 tdTagStart(true); 6760 } 6761 break; 6762 case 26: 6763 { 6764 setState(868); 6765 thTagStart(true); 6766 } 6767 break; 6768 case 27: 6769 { 6770 setState(869); 6771 bodyTagStart(true); 6772 } 6773 break; 6774 case 28: 6775 { 6776 setState(870); 6777 ddTagStart(true); 6778 } 6779 break; 6780 case 29: 6781 { 6782 setState(871); 6783 dtTagStart(true); 6784 } 6785 break; 6786 case 30: 6787 { 6788 setState(872); 6789 headTagStart(true); 6790 } 6791 break; 6792 case 31: 6793 { 6794 setState(873); 6795 htmlTagStart(true); 6796 } 6797 break; 6798 case 32: 6799 { 6800 setState(874); 6801 optionTagStart(true); 6802 } 6803 break; 6804 case 33: 6805 { 6806 setState(875); 6807 tbodyTagStart(true); 6808 } 6809 break; 6810 case 34: 6811 { 6812 setState(876); 6813 theadTagStart(true); 6814 } 6815 break; 6816 case 35: 6817 { 6818 setState(877); 6819 tfootTagStart(true); 6820 } 6821 break; 6822 case 36: 6823 { 6824 setState(878); 6825 optgroupTagStart(true); 6826 } 6827 break; 6828 case 37: 6829 { 6830 setState(879); 6831 rbTagStart(true); 6832 } 6833 break; 6834 case 38: 6835 { 6836 setState(880); 6837 rtTagStart(true); 6838 } 6839 break; 6840 case 39: 6841 { 6842 setState(881); 6843 rtcTagStart(true); 6844 } 6845 break; 6846 case 40: 6847 { 6848 setState(882); 6849 rpTagStart(true); 6850 } 6851 break; 6852 case 41: 6853 { 6854 { 6855 setState(883); 6856 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6857 setState(884); 6858 match(LEADING_ASTERISK); 6859 } 6860 } 6861 break; 6862 case 42: 6863 { 6864 setState(885); 6865 htmlComment(); 6866 } 6867 break; 6868 case 43: 6869 { 6870 setState(886); 6871 match(CDATA); 6872 } 6873 break; 6874 case 44: 6875 { 6876 setState(887); 6877 match(NEWLINE); 6878 } 6879 break; 6880 case 45: 6881 { 6882 setState(888); 6883 text(); 6884 } 6885 break; 6886 case 46: 6887 { 6888 setState(889); 6889 javadocInlineTag(); 6890 } 6891 break; 6892 } 6893 } 6894 } 6895 setState(894); 6896 _errHandler.sync(this); 6897 _alt = getInterpreter().adaptivePredict(_input,48,_ctx); 6898 } 6899 setState(895); 6900 colgroupTagEnd(); 6901 } 6902 } 6903 catch (RecognitionException re) { 6904 _localctx.exception = re; 6905 _errHandler.reportError(this, re); 6906 _errHandler.recover(this, re); 6907 } 6908 finally { 6909 exitRule(); 6910 } 6911 return _localctx; 6912 } 6913 6914 public static class DdTagStartContext extends ParserRuleContext { 6915 public boolean isNonTight; 6916 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 6917 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6918 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 6919 public List<AttributeContext> attribute() { 6920 return getRuleContexts(AttributeContext.class); 6921 } 6922 public AttributeContext attribute(int i) { 6923 return getRuleContext(AttributeContext.class,i); 6924 } 6925 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6926 public TerminalNode NEWLINE(int i) { 6927 return getToken(JavadocParser.NEWLINE, i); 6928 } 6929 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6930 public TerminalNode LEADING_ASTERISK(int i) { 6931 return getToken(JavadocParser.LEADING_ASTERISK, i); 6932 } 6933 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6934 public TerminalNode WS(int i) { 6935 return getToken(JavadocParser.WS, i); 6936 } 6937 public DdTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 6938 public DdTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 6939 super(parent, invokingState); 6940 this.isNonTight = isNonTight; 6941 } 6942 @Override public int getRuleIndex() { return RULE_ddTagStart; } 6943 } 6944 6945 public final DdTagStartContext ddTagStart(boolean isNonTight) throws RecognitionException { 6946 DdTagStartContext _localctx = new DdTagStartContext(_ctx, getState(), isNonTight); 6947 enterRule(_localctx, 54, RULE_ddTagStart); 6948 int _la; 6949 try { 6950 enterOuterAlt(_localctx, 1); 6951 { 6952 setState(897); 6953 match(START); 6954 setState(898); 6955 match(DD_HTML_TAG_NAME); 6956 setState(905); 6957 _errHandler.sync(this); 6958 _la = _input.LA(1); 6959 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6960 { 6961 setState(903); 6962 _errHandler.sync(this); 6963 switch (_input.LA(1)) { 6964 case HTML_TAG_NAME: 6965 { 6966 setState(899); 6967 attribute(); 6968 } 6969 break; 6970 case NEWLINE: 6971 { 6972 setState(900); 6973 match(NEWLINE); 6974 } 6975 break; 6976 case LEADING_ASTERISK: 6977 { 6978 setState(901); 6979 match(LEADING_ASTERISK); 6980 } 6981 break; 6982 case WS: 6983 { 6984 setState(902); 6985 match(WS); 6986 } 6987 break; 6988 default: 6989 throw new NoViableAltException(this); 6990 } 6991 } 6992 setState(907); 6993 _errHandler.sync(this); 6994 _la = _input.LA(1); 6995 } 6996 setState(908); 6997 match(END); 6998 } 6999 _ctx.stop = _input.LT(-1); 7000 7001 if (isNonTight && nonTightTagStartContext == null) { 7002 nonTightTagStartContext = _localctx; 7003 } 7004 7005 } 7006 catch (RecognitionException re) { 7007 _localctx.exception = re; 7008 _errHandler.reportError(this, re); 7009 _errHandler.recover(this, re); 7010 } 7011 finally { 7012 exitRule(); 7013 } 7014 return _localctx; 7015 } 7016 7017 public static class DdTagEndContext extends ParserRuleContext { 7018 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 7019 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7020 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 7021 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 7022 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7023 public TerminalNode NEWLINE(int i) { 7024 return getToken(JavadocParser.NEWLINE, i); 7025 } 7026 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7027 public TerminalNode LEADING_ASTERISK(int i) { 7028 return getToken(JavadocParser.LEADING_ASTERISK, i); 7029 } 7030 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7031 public TerminalNode WS(int i) { 7032 return getToken(JavadocParser.WS, i); 7033 } 7034 public DdTagEndContext(ParserRuleContext parent, int invokingState) { 7035 super(parent, invokingState); 7036 } 7037 @Override public int getRuleIndex() { return RULE_ddTagEnd; } 7038 } 7039 7040 public final DdTagEndContext ddTagEnd() throws RecognitionException { 7041 DdTagEndContext _localctx = new DdTagEndContext(_ctx, getState()); 7042 enterRule(_localctx, 56, RULE_ddTagEnd); 7043 int _la; 7044 try { 7045 enterOuterAlt(_localctx, 1); 7046 { 7047 setState(910); 7048 match(START); 7049 setState(911); 7050 match(SLASH); 7051 setState(912); 7052 match(DD_HTML_TAG_NAME); 7053 setState(916); 7054 _errHandler.sync(this); 7055 _la = _input.LA(1); 7056 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7057 { 7058 { 7059 setState(913); 7060 _la = _input.LA(1); 7061 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7062 _errHandler.recoverInline(this); 7063 } 7064 else { 7065 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 7066 _errHandler.reportMatch(this); 7067 consume(); 7068 } 7069 } 7070 } 7071 setState(918); 7072 _errHandler.sync(this); 7073 _la = _input.LA(1); 7074 } 7075 setState(919); 7076 match(END); 7077 } 7078 } 7079 catch (RecognitionException re) { 7080 _localctx.exception = re; 7081 _errHandler.reportError(this, re); 7082 _errHandler.recover(this, re); 7083 } 7084 finally { 7085 exitRule(); 7086 } 7087 return _localctx; 7088 } 7089 7090 public static class DdContext extends ParserRuleContext { 7091 public DdTagStartContext ddTagStart() { 7092 return getRuleContext(DdTagStartContext.class,0); 7093 } 7094 public DdTagEndContext ddTagEnd() { 7095 return getRuleContext(DdTagEndContext.class,0); 7096 } 7097 public List<HtmlTagContext> htmlTag() { 7098 return getRuleContexts(HtmlTagContext.class); 7099 } 7100 public HtmlTagContext htmlTag(int i) { 7101 return getRuleContext(HtmlTagContext.class,i); 7102 } 7103 public List<SingletonElementContext> singletonElement() { 7104 return getRuleContexts(SingletonElementContext.class); 7105 } 7106 public SingletonElementContext singletonElement(int i) { 7107 return getRuleContext(SingletonElementContext.class,i); 7108 } 7109 public List<ParagraphContext> paragraph() { 7110 return getRuleContexts(ParagraphContext.class); 7111 } 7112 public ParagraphContext paragraph(int i) { 7113 return getRuleContext(ParagraphContext.class,i); 7114 } 7115 public List<LiContext> li() { 7116 return getRuleContexts(LiContext.class); 7117 } 7118 public LiContext li(int i) { 7119 return getRuleContext(LiContext.class,i); 7120 } 7121 public List<TrContext> tr() { 7122 return getRuleContexts(TrContext.class); 7123 } 7124 public TrContext tr(int i) { 7125 return getRuleContext(TrContext.class,i); 7126 } 7127 public List<TdContext> td() { 7128 return getRuleContexts(TdContext.class); 7129 } 7130 public TdContext td(int i) { 7131 return getRuleContext(TdContext.class,i); 7132 } 7133 public List<ThContext> th() { 7134 return getRuleContexts(ThContext.class); 7135 } 7136 public ThContext th(int i) { 7137 return getRuleContext(ThContext.class,i); 7138 } 7139 public List<BodyContext> body() { 7140 return getRuleContexts(BodyContext.class); 7141 } 7142 public BodyContext body(int i) { 7143 return getRuleContext(BodyContext.class,i); 7144 } 7145 public List<ColgroupContext> colgroup() { 7146 return getRuleContexts(ColgroupContext.class); 7147 } 7148 public ColgroupContext colgroup(int i) { 7149 return getRuleContext(ColgroupContext.class,i); 7150 } 7151 public List<DtContext> dt() { 7152 return getRuleContexts(DtContext.class); 7153 } 7154 public DtContext dt(int i) { 7155 return getRuleContext(DtContext.class,i); 7156 } 7157 public List<HeadContext> head() { 7158 return getRuleContexts(HeadContext.class); 7159 } 7160 public HeadContext head(int i) { 7161 return getRuleContext(HeadContext.class,i); 7162 } 7163 public List<HtmlContext> html() { 7164 return getRuleContexts(HtmlContext.class); 7165 } 7166 public HtmlContext html(int i) { 7167 return getRuleContext(HtmlContext.class,i); 7168 } 7169 public List<OptionContext> option() { 7170 return getRuleContexts(OptionContext.class); 7171 } 7172 public OptionContext option(int i) { 7173 return getRuleContext(OptionContext.class,i); 7174 } 7175 public List<TbodyContext> tbody() { 7176 return getRuleContexts(TbodyContext.class); 7177 } 7178 public TbodyContext tbody(int i) { 7179 return getRuleContext(TbodyContext.class,i); 7180 } 7181 public List<TheadContext> thead() { 7182 return getRuleContexts(TheadContext.class); 7183 } 7184 public TheadContext thead(int i) { 7185 return getRuleContext(TheadContext.class,i); 7186 } 7187 public List<TfootContext> tfoot() { 7188 return getRuleContexts(TfootContext.class); 7189 } 7190 public TfootContext tfoot(int i) { 7191 return getRuleContext(TfootContext.class,i); 7192 } 7193 public List<OptgroupContext> optgroup() { 7194 return getRuleContexts(OptgroupContext.class); 7195 } 7196 public OptgroupContext optgroup(int i) { 7197 return getRuleContext(OptgroupContext.class,i); 7198 } 7199 public List<RbContext> rb() { 7200 return getRuleContexts(RbContext.class); 7201 } 7202 public RbContext rb(int i) { 7203 return getRuleContext(RbContext.class,i); 7204 } 7205 public List<RtContext> rt() { 7206 return getRuleContexts(RtContext.class); 7207 } 7208 public RtContext rt(int i) { 7209 return getRuleContext(RtContext.class,i); 7210 } 7211 public List<RtcContext> rtc() { 7212 return getRuleContexts(RtcContext.class); 7213 } 7214 public RtcContext rtc(int i) { 7215 return getRuleContext(RtcContext.class,i); 7216 } 7217 public List<RpContext> rp() { 7218 return getRuleContexts(RpContext.class); 7219 } 7220 public RpContext rp(int i) { 7221 return getRuleContext(RpContext.class,i); 7222 } 7223 public List<PTagStartContext> pTagStart() { 7224 return getRuleContexts(PTagStartContext.class); 7225 } 7226 public PTagStartContext pTagStart(int i) { 7227 return getRuleContext(PTagStartContext.class,i); 7228 } 7229 public List<LiTagStartContext> liTagStart() { 7230 return getRuleContexts(LiTagStartContext.class); 7231 } 7232 public LiTagStartContext liTagStart(int i) { 7233 return getRuleContext(LiTagStartContext.class,i); 7234 } 7235 public List<TrTagStartContext> trTagStart() { 7236 return getRuleContexts(TrTagStartContext.class); 7237 } 7238 public TrTagStartContext trTagStart(int i) { 7239 return getRuleContext(TrTagStartContext.class,i); 7240 } 7241 public List<TdTagStartContext> tdTagStart() { 7242 return getRuleContexts(TdTagStartContext.class); 7243 } 7244 public TdTagStartContext tdTagStart(int i) { 7245 return getRuleContext(TdTagStartContext.class,i); 7246 } 7247 public List<ThTagStartContext> thTagStart() { 7248 return getRuleContexts(ThTagStartContext.class); 7249 } 7250 public ThTagStartContext thTagStart(int i) { 7251 return getRuleContext(ThTagStartContext.class,i); 7252 } 7253 public List<BodyTagStartContext> bodyTagStart() { 7254 return getRuleContexts(BodyTagStartContext.class); 7255 } 7256 public BodyTagStartContext bodyTagStart(int i) { 7257 return getRuleContext(BodyTagStartContext.class,i); 7258 } 7259 public List<ColgroupTagStartContext> colgroupTagStart() { 7260 return getRuleContexts(ColgroupTagStartContext.class); 7261 } 7262 public ColgroupTagStartContext colgroupTagStart(int i) { 7263 return getRuleContext(ColgroupTagStartContext.class,i); 7264 } 7265 public List<DtTagStartContext> dtTagStart() { 7266 return getRuleContexts(DtTagStartContext.class); 7267 } 7268 public DtTagStartContext dtTagStart(int i) { 7269 return getRuleContext(DtTagStartContext.class,i); 7270 } 7271 public List<HeadTagStartContext> headTagStart() { 7272 return getRuleContexts(HeadTagStartContext.class); 7273 } 7274 public HeadTagStartContext headTagStart(int i) { 7275 return getRuleContext(HeadTagStartContext.class,i); 7276 } 7277 public List<HtmlTagStartContext> htmlTagStart() { 7278 return getRuleContexts(HtmlTagStartContext.class); 7279 } 7280 public HtmlTagStartContext htmlTagStart(int i) { 7281 return getRuleContext(HtmlTagStartContext.class,i); 7282 } 7283 public List<OptionTagStartContext> optionTagStart() { 7284 return getRuleContexts(OptionTagStartContext.class); 7285 } 7286 public OptionTagStartContext optionTagStart(int i) { 7287 return getRuleContext(OptionTagStartContext.class,i); 7288 } 7289 public List<TbodyTagStartContext> tbodyTagStart() { 7290 return getRuleContexts(TbodyTagStartContext.class); 7291 } 7292 public TbodyTagStartContext tbodyTagStart(int i) { 7293 return getRuleContext(TbodyTagStartContext.class,i); 7294 } 7295 public List<TheadTagStartContext> theadTagStart() { 7296 return getRuleContexts(TheadTagStartContext.class); 7297 } 7298 public TheadTagStartContext theadTagStart(int i) { 7299 return getRuleContext(TheadTagStartContext.class,i); 7300 } 7301 public List<TfootTagStartContext> tfootTagStart() { 7302 return getRuleContexts(TfootTagStartContext.class); 7303 } 7304 public TfootTagStartContext tfootTagStart(int i) { 7305 return getRuleContext(TfootTagStartContext.class,i); 7306 } 7307 public List<OptgroupTagStartContext> optgroupTagStart() { 7308 return getRuleContexts(OptgroupTagStartContext.class); 7309 } 7310 public OptgroupTagStartContext optgroupTagStart(int i) { 7311 return getRuleContext(OptgroupTagStartContext.class,i); 7312 } 7313 public List<RbTagStartContext> rbTagStart() { 7314 return getRuleContexts(RbTagStartContext.class); 7315 } 7316 public RbTagStartContext rbTagStart(int i) { 7317 return getRuleContext(RbTagStartContext.class,i); 7318 } 7319 public List<RtTagStartContext> rtTagStart() { 7320 return getRuleContexts(RtTagStartContext.class); 7321 } 7322 public RtTagStartContext rtTagStart(int i) { 7323 return getRuleContext(RtTagStartContext.class,i); 7324 } 7325 public List<RtcTagStartContext> rtcTagStart() { 7326 return getRuleContexts(RtcTagStartContext.class); 7327 } 7328 public RtcTagStartContext rtcTagStart(int i) { 7329 return getRuleContext(RtcTagStartContext.class,i); 7330 } 7331 public List<RpTagStartContext> rpTagStart() { 7332 return getRuleContexts(RpTagStartContext.class); 7333 } 7334 public RpTagStartContext rpTagStart(int i) { 7335 return getRuleContext(RpTagStartContext.class,i); 7336 } 7337 public List<HtmlCommentContext> htmlComment() { 7338 return getRuleContexts(HtmlCommentContext.class); 7339 } 7340 public HtmlCommentContext htmlComment(int i) { 7341 return getRuleContext(HtmlCommentContext.class,i); 7342 } 7343 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 7344 public TerminalNode CDATA(int i) { 7345 return getToken(JavadocParser.CDATA, i); 7346 } 7347 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7348 public TerminalNode NEWLINE(int i) { 7349 return getToken(JavadocParser.NEWLINE, i); 7350 } 7351 public List<TextContext> text() { 7352 return getRuleContexts(TextContext.class); 7353 } 7354 public TextContext text(int i) { 7355 return getRuleContext(TextContext.class,i); 7356 } 7357 public List<JavadocInlineTagContext> javadocInlineTag() { 7358 return getRuleContexts(JavadocInlineTagContext.class); 7359 } 7360 public JavadocInlineTagContext javadocInlineTag(int i) { 7361 return getRuleContext(JavadocInlineTagContext.class,i); 7362 } 7363 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7364 public TerminalNode LEADING_ASTERISK(int i) { 7365 return getToken(JavadocParser.LEADING_ASTERISK, i); 7366 } 7367 public DdContext(ParserRuleContext parent, int invokingState) { 7368 super(parent, invokingState); 7369 } 7370 @Override public int getRuleIndex() { return RULE_dd; } 7371 } 7372 7373 public final DdContext dd() throws RecognitionException { 7374 DdContext _localctx = new DdContext(_ctx, getState()); 7375 enterRule(_localctx, 58, RULE_dd); 7376 try { 7377 int _alt; 7378 enterOuterAlt(_localctx, 1); 7379 { 7380 setState(921); 7381 ddTagStart(false); 7382 setState(971); 7383 _errHandler.sync(this); 7384 _alt = getInterpreter().adaptivePredict(_input,53,_ctx); 7385 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 7386 if ( _alt==1 ) { 7387 { 7388 setState(969); 7389 _errHandler.sync(this); 7390 switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) { 7391 case 1: 7392 { 7393 setState(922); 7394 htmlTag(); 7395 } 7396 break; 7397 case 2: 7398 { 7399 setState(923); 7400 singletonElement(); 7401 } 7402 break; 7403 case 3: 7404 { 7405 setState(924); 7406 paragraph(); 7407 } 7408 break; 7409 case 4: 7410 { 7411 setState(925); 7412 li(); 7413 } 7414 break; 7415 case 5: 7416 { 7417 setState(926); 7418 tr(); 7419 } 7420 break; 7421 case 6: 7422 { 7423 setState(927); 7424 td(); 7425 } 7426 break; 7427 case 7: 7428 { 7429 setState(928); 7430 th(); 7431 } 7432 break; 7433 case 8: 7434 { 7435 setState(929); 7436 body(); 7437 } 7438 break; 7439 case 9: 7440 { 7441 setState(930); 7442 colgroup(); 7443 } 7444 break; 7445 case 10: 7446 { 7447 setState(931); 7448 dt(); 7449 } 7450 break; 7451 case 11: 7452 { 7453 setState(932); 7454 head(); 7455 } 7456 break; 7457 case 12: 7458 { 7459 setState(933); 7460 html(); 7461 } 7462 break; 7463 case 13: 7464 { 7465 setState(934); 7466 option(); 7467 } 7468 break; 7469 case 14: 7470 { 7471 setState(935); 7472 tbody(); 7473 } 7474 break; 7475 case 15: 7476 { 7477 setState(936); 7478 thead(); 7479 } 7480 break; 7481 case 16: 7482 { 7483 setState(937); 7484 tfoot(); 7485 } 7486 break; 7487 case 17: 7488 { 7489 setState(938); 7490 optgroup(); 7491 } 7492 break; 7493 case 18: 7494 { 7495 setState(939); 7496 rb(); 7497 } 7498 break; 7499 case 19: 7500 { 7501 setState(940); 7502 rt(); 7503 } 7504 break; 7505 case 20: 7506 { 7507 setState(941); 7508 rtc(); 7509 } 7510 break; 7511 case 21: 7512 { 7513 setState(942); 7514 rp(); 7515 } 7516 break; 7517 case 22: 7518 { 7519 setState(943); 7520 pTagStart(true); 7521 } 7522 break; 7523 case 23: 7524 { 7525 setState(944); 7526 liTagStart(true); 7527 } 7528 break; 7529 case 24: 7530 { 7531 setState(945); 7532 trTagStart(true); 7533 } 7534 break; 7535 case 25: 7536 { 7537 setState(946); 7538 tdTagStart(true); 7539 } 7540 break; 7541 case 26: 7542 { 7543 setState(947); 7544 thTagStart(true); 7545 } 7546 break; 7547 case 27: 7548 { 7549 setState(948); 7550 bodyTagStart(true); 7551 } 7552 break; 7553 case 28: 7554 { 7555 setState(949); 7556 colgroupTagStart(true); 7557 } 7558 break; 7559 case 29: 7560 { 7561 setState(950); 7562 dtTagStart(true); 7563 } 7564 break; 7565 case 30: 7566 { 7567 setState(951); 7568 headTagStart(true); 7569 } 7570 break; 7571 case 31: 7572 { 7573 setState(952); 7574 htmlTagStart(true); 7575 } 7576 break; 7577 case 32: 7578 { 7579 setState(953); 7580 optionTagStart(true); 7581 } 7582 break; 7583 case 33: 7584 { 7585 setState(954); 7586 tbodyTagStart(true); 7587 } 7588 break; 7589 case 34: 7590 { 7591 setState(955); 7592 theadTagStart(true); 7593 } 7594 break; 7595 case 35: 7596 { 7597 setState(956); 7598 tfootTagStart(true); 7599 } 7600 break; 7601 case 36: 7602 { 7603 setState(957); 7604 optgroupTagStart(true); 7605 } 7606 break; 7607 case 37: 7608 { 7609 setState(958); 7610 rbTagStart(true); 7611 } 7612 break; 7613 case 38: 7614 { 7615 setState(959); 7616 rtTagStart(true); 7617 } 7618 break; 7619 case 39: 7620 { 7621 setState(960); 7622 rtcTagStart(true); 7623 } 7624 break; 7625 case 40: 7626 { 7627 setState(961); 7628 rpTagStart(true); 7629 } 7630 break; 7631 case 41: 7632 { 7633 { 7634 setState(962); 7635 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 7636 setState(963); 7637 match(LEADING_ASTERISK); 7638 } 7639 } 7640 break; 7641 case 42: 7642 { 7643 setState(964); 7644 htmlComment(); 7645 } 7646 break; 7647 case 43: 7648 { 7649 setState(965); 7650 match(CDATA); 7651 } 7652 break; 7653 case 44: 7654 { 7655 setState(966); 7656 match(NEWLINE); 7657 } 7658 break; 7659 case 45: 7660 { 7661 setState(967); 7662 text(); 7663 } 7664 break; 7665 case 46: 7666 { 7667 setState(968); 7668 javadocInlineTag(); 7669 } 7670 break; 7671 } 7672 } 7673 } 7674 setState(973); 7675 _errHandler.sync(this); 7676 _alt = getInterpreter().adaptivePredict(_input,53,_ctx); 7677 } 7678 setState(974); 7679 ddTagEnd(); 7680 } 7681 } 7682 catch (RecognitionException re) { 7683 _localctx.exception = re; 7684 _errHandler.reportError(this, re); 7685 _errHandler.recover(this, re); 7686 } 7687 finally { 7688 exitRule(); 7689 } 7690 return _localctx; 7691 } 7692 7693 public static class DtTagStartContext extends ParserRuleContext { 7694 public boolean isNonTight; 7695 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 7696 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 7697 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 7698 public List<AttributeContext> attribute() { 7699 return getRuleContexts(AttributeContext.class); 7700 } 7701 public AttributeContext attribute(int i) { 7702 return getRuleContext(AttributeContext.class,i); 7703 } 7704 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7705 public TerminalNode NEWLINE(int i) { 7706 return getToken(JavadocParser.NEWLINE, i); 7707 } 7708 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7709 public TerminalNode LEADING_ASTERISK(int i) { 7710 return getToken(JavadocParser.LEADING_ASTERISK, i); 7711 } 7712 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7713 public TerminalNode WS(int i) { 7714 return getToken(JavadocParser.WS, i); 7715 } 7716 public DtTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 7717 public DtTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 7718 super(parent, invokingState); 7719 this.isNonTight = isNonTight; 7720 } 7721 @Override public int getRuleIndex() { return RULE_dtTagStart; } 7722 } 7723 7724 public final DtTagStartContext dtTagStart(boolean isNonTight) throws RecognitionException { 7725 DtTagStartContext _localctx = new DtTagStartContext(_ctx, getState(), isNonTight); 7726 enterRule(_localctx, 60, RULE_dtTagStart); 7727 int _la; 7728 try { 7729 enterOuterAlt(_localctx, 1); 7730 { 7731 setState(976); 7732 match(START); 7733 setState(977); 7734 match(DT_HTML_TAG_NAME); 7735 setState(984); 7736 _errHandler.sync(this); 7737 _la = _input.LA(1); 7738 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 7739 { 7740 setState(982); 7741 _errHandler.sync(this); 7742 switch (_input.LA(1)) { 7743 case HTML_TAG_NAME: 7744 { 7745 setState(978); 7746 attribute(); 7747 } 7748 break; 7749 case NEWLINE: 7750 { 7751 setState(979); 7752 match(NEWLINE); 7753 } 7754 break; 7755 case LEADING_ASTERISK: 7756 { 7757 setState(980); 7758 match(LEADING_ASTERISK); 7759 } 7760 break; 7761 case WS: 7762 { 7763 setState(981); 7764 match(WS); 7765 } 7766 break; 7767 default: 7768 throw new NoViableAltException(this); 7769 } 7770 } 7771 setState(986); 7772 _errHandler.sync(this); 7773 _la = _input.LA(1); 7774 } 7775 setState(987); 7776 match(END); 7777 } 7778 _ctx.stop = _input.LT(-1); 7779 7780 if (isNonTight && nonTightTagStartContext == null) { 7781 nonTightTagStartContext = _localctx; 7782 } 7783 7784 } 7785 catch (RecognitionException re) { 7786 _localctx.exception = re; 7787 _errHandler.reportError(this, re); 7788 _errHandler.recover(this, re); 7789 } 7790 finally { 7791 exitRule(); 7792 } 7793 return _localctx; 7794 } 7795 7796 public static class DtTagEndContext extends ParserRuleContext { 7797 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 7798 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7799 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 7800 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 7801 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7802 public TerminalNode NEWLINE(int i) { 7803 return getToken(JavadocParser.NEWLINE, i); 7804 } 7805 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7806 public TerminalNode LEADING_ASTERISK(int i) { 7807 return getToken(JavadocParser.LEADING_ASTERISK, i); 7808 } 7809 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7810 public TerminalNode WS(int i) { 7811 return getToken(JavadocParser.WS, i); 7812 } 7813 public DtTagEndContext(ParserRuleContext parent, int invokingState) { 7814 super(parent, invokingState); 7815 } 7816 @Override public int getRuleIndex() { return RULE_dtTagEnd; } 7817 } 7818 7819 public final DtTagEndContext dtTagEnd() throws RecognitionException { 7820 DtTagEndContext _localctx = new DtTagEndContext(_ctx, getState()); 7821 enterRule(_localctx, 62, RULE_dtTagEnd); 7822 int _la; 7823 try { 7824 enterOuterAlt(_localctx, 1); 7825 { 7826 setState(989); 7827 match(START); 7828 setState(990); 7829 match(SLASH); 7830 setState(991); 7831 match(DT_HTML_TAG_NAME); 7832 setState(995); 7833 _errHandler.sync(this); 7834 _la = _input.LA(1); 7835 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7836 { 7837 { 7838 setState(992); 7839 _la = _input.LA(1); 7840 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7841 _errHandler.recoverInline(this); 7842 } 7843 else { 7844 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 7845 _errHandler.reportMatch(this); 7846 consume(); 7847 } 7848 } 7849 } 7850 setState(997); 7851 _errHandler.sync(this); 7852 _la = _input.LA(1); 7853 } 7854 setState(998); 7855 match(END); 7856 } 7857 } 7858 catch (RecognitionException re) { 7859 _localctx.exception = re; 7860 _errHandler.reportError(this, re); 7861 _errHandler.recover(this, re); 7862 } 7863 finally { 7864 exitRule(); 7865 } 7866 return _localctx; 7867 } 7868 7869 public static class DtContext extends ParserRuleContext { 7870 public DtTagStartContext dtTagStart() { 7871 return getRuleContext(DtTagStartContext.class,0); 7872 } 7873 public DtTagEndContext dtTagEnd() { 7874 return getRuleContext(DtTagEndContext.class,0); 7875 } 7876 public List<HtmlTagContext> htmlTag() { 7877 return getRuleContexts(HtmlTagContext.class); 7878 } 7879 public HtmlTagContext htmlTag(int i) { 7880 return getRuleContext(HtmlTagContext.class,i); 7881 } 7882 public List<SingletonElementContext> singletonElement() { 7883 return getRuleContexts(SingletonElementContext.class); 7884 } 7885 public SingletonElementContext singletonElement(int i) { 7886 return getRuleContext(SingletonElementContext.class,i); 7887 } 7888 public List<ParagraphContext> paragraph() { 7889 return getRuleContexts(ParagraphContext.class); 7890 } 7891 public ParagraphContext paragraph(int i) { 7892 return getRuleContext(ParagraphContext.class,i); 7893 } 7894 public List<LiContext> li() { 7895 return getRuleContexts(LiContext.class); 7896 } 7897 public LiContext li(int i) { 7898 return getRuleContext(LiContext.class,i); 7899 } 7900 public List<TrContext> tr() { 7901 return getRuleContexts(TrContext.class); 7902 } 7903 public TrContext tr(int i) { 7904 return getRuleContext(TrContext.class,i); 7905 } 7906 public List<TdContext> td() { 7907 return getRuleContexts(TdContext.class); 7908 } 7909 public TdContext td(int i) { 7910 return getRuleContext(TdContext.class,i); 7911 } 7912 public List<ThContext> th() { 7913 return getRuleContexts(ThContext.class); 7914 } 7915 public ThContext th(int i) { 7916 return getRuleContext(ThContext.class,i); 7917 } 7918 public List<BodyContext> body() { 7919 return getRuleContexts(BodyContext.class); 7920 } 7921 public BodyContext body(int i) { 7922 return getRuleContext(BodyContext.class,i); 7923 } 7924 public List<ColgroupContext> colgroup() { 7925 return getRuleContexts(ColgroupContext.class); 7926 } 7927 public ColgroupContext colgroup(int i) { 7928 return getRuleContext(ColgroupContext.class,i); 7929 } 7930 public List<DdContext> dd() { 7931 return getRuleContexts(DdContext.class); 7932 } 7933 public DdContext dd(int i) { 7934 return getRuleContext(DdContext.class,i); 7935 } 7936 public List<HeadContext> head() { 7937 return getRuleContexts(HeadContext.class); 7938 } 7939 public HeadContext head(int i) { 7940 return getRuleContext(HeadContext.class,i); 7941 } 7942 public List<HtmlContext> html() { 7943 return getRuleContexts(HtmlContext.class); 7944 } 7945 public HtmlContext html(int i) { 7946 return getRuleContext(HtmlContext.class,i); 7947 } 7948 public List<OptionContext> option() { 7949 return getRuleContexts(OptionContext.class); 7950 } 7951 public OptionContext option(int i) { 7952 return getRuleContext(OptionContext.class,i); 7953 } 7954 public List<TbodyContext> tbody() { 7955 return getRuleContexts(TbodyContext.class); 7956 } 7957 public TbodyContext tbody(int i) { 7958 return getRuleContext(TbodyContext.class,i); 7959 } 7960 public List<TheadContext> thead() { 7961 return getRuleContexts(TheadContext.class); 7962 } 7963 public TheadContext thead(int i) { 7964 return getRuleContext(TheadContext.class,i); 7965 } 7966 public List<TfootContext> tfoot() { 7967 return getRuleContexts(TfootContext.class); 7968 } 7969 public TfootContext tfoot(int i) { 7970 return getRuleContext(TfootContext.class,i); 7971 } 7972 public List<OptgroupContext> optgroup() { 7973 return getRuleContexts(OptgroupContext.class); 7974 } 7975 public OptgroupContext optgroup(int i) { 7976 return getRuleContext(OptgroupContext.class,i); 7977 } 7978 public List<RbContext> rb() { 7979 return getRuleContexts(RbContext.class); 7980 } 7981 public RbContext rb(int i) { 7982 return getRuleContext(RbContext.class,i); 7983 } 7984 public List<RtContext> rt() { 7985 return getRuleContexts(RtContext.class); 7986 } 7987 public RtContext rt(int i) { 7988 return getRuleContext(RtContext.class,i); 7989 } 7990 public List<RtcContext> rtc() { 7991 return getRuleContexts(RtcContext.class); 7992 } 7993 public RtcContext rtc(int i) { 7994 return getRuleContext(RtcContext.class,i); 7995 } 7996 public List<RpContext> rp() { 7997 return getRuleContexts(RpContext.class); 7998 } 7999 public RpContext rp(int i) { 8000 return getRuleContext(RpContext.class,i); 8001 } 8002 public List<PTagStartContext> pTagStart() { 8003 return getRuleContexts(PTagStartContext.class); 8004 } 8005 public PTagStartContext pTagStart(int i) { 8006 return getRuleContext(PTagStartContext.class,i); 8007 } 8008 public List<LiTagStartContext> liTagStart() { 8009 return getRuleContexts(LiTagStartContext.class); 8010 } 8011 public LiTagStartContext liTagStart(int i) { 8012 return getRuleContext(LiTagStartContext.class,i); 8013 } 8014 public List<TrTagStartContext> trTagStart() { 8015 return getRuleContexts(TrTagStartContext.class); 8016 } 8017 public TrTagStartContext trTagStart(int i) { 8018 return getRuleContext(TrTagStartContext.class,i); 8019 } 8020 public List<TdTagStartContext> tdTagStart() { 8021 return getRuleContexts(TdTagStartContext.class); 8022 } 8023 public TdTagStartContext tdTagStart(int i) { 8024 return getRuleContext(TdTagStartContext.class,i); 8025 } 8026 public List<ThTagStartContext> thTagStart() { 8027 return getRuleContexts(ThTagStartContext.class); 8028 } 8029 public ThTagStartContext thTagStart(int i) { 8030 return getRuleContext(ThTagStartContext.class,i); 8031 } 8032 public List<BodyTagStartContext> bodyTagStart() { 8033 return getRuleContexts(BodyTagStartContext.class); 8034 } 8035 public BodyTagStartContext bodyTagStart(int i) { 8036 return getRuleContext(BodyTagStartContext.class,i); 8037 } 8038 public List<ColgroupTagStartContext> colgroupTagStart() { 8039 return getRuleContexts(ColgroupTagStartContext.class); 8040 } 8041 public ColgroupTagStartContext colgroupTagStart(int i) { 8042 return getRuleContext(ColgroupTagStartContext.class,i); 8043 } 8044 public List<DdTagStartContext> ddTagStart() { 8045 return getRuleContexts(DdTagStartContext.class); 8046 } 8047 public DdTagStartContext ddTagStart(int i) { 8048 return getRuleContext(DdTagStartContext.class,i); 8049 } 8050 public List<HeadTagStartContext> headTagStart() { 8051 return getRuleContexts(HeadTagStartContext.class); 8052 } 8053 public HeadTagStartContext headTagStart(int i) { 8054 return getRuleContext(HeadTagStartContext.class,i); 8055 } 8056 public List<HtmlTagStartContext> htmlTagStart() { 8057 return getRuleContexts(HtmlTagStartContext.class); 8058 } 8059 public HtmlTagStartContext htmlTagStart(int i) { 8060 return getRuleContext(HtmlTagStartContext.class,i); 8061 } 8062 public List<OptionTagStartContext> optionTagStart() { 8063 return getRuleContexts(OptionTagStartContext.class); 8064 } 8065 public OptionTagStartContext optionTagStart(int i) { 8066 return getRuleContext(OptionTagStartContext.class,i); 8067 } 8068 public List<TbodyTagStartContext> tbodyTagStart() { 8069 return getRuleContexts(TbodyTagStartContext.class); 8070 } 8071 public TbodyTagStartContext tbodyTagStart(int i) { 8072 return getRuleContext(TbodyTagStartContext.class,i); 8073 } 8074 public List<TheadTagStartContext> theadTagStart() { 8075 return getRuleContexts(TheadTagStartContext.class); 8076 } 8077 public TheadTagStartContext theadTagStart(int i) { 8078 return getRuleContext(TheadTagStartContext.class,i); 8079 } 8080 public List<TfootTagStartContext> tfootTagStart() { 8081 return getRuleContexts(TfootTagStartContext.class); 8082 } 8083 public TfootTagStartContext tfootTagStart(int i) { 8084 return getRuleContext(TfootTagStartContext.class,i); 8085 } 8086 public List<OptgroupTagStartContext> optgroupTagStart() { 8087 return getRuleContexts(OptgroupTagStartContext.class); 8088 } 8089 public OptgroupTagStartContext optgroupTagStart(int i) { 8090 return getRuleContext(OptgroupTagStartContext.class,i); 8091 } 8092 public List<RbTagStartContext> rbTagStart() { 8093 return getRuleContexts(RbTagStartContext.class); 8094 } 8095 public RbTagStartContext rbTagStart(int i) { 8096 return getRuleContext(RbTagStartContext.class,i); 8097 } 8098 public List<RtTagStartContext> rtTagStart() { 8099 return getRuleContexts(RtTagStartContext.class); 8100 } 8101 public RtTagStartContext rtTagStart(int i) { 8102 return getRuleContext(RtTagStartContext.class,i); 8103 } 8104 public List<RtcTagStartContext> rtcTagStart() { 8105 return getRuleContexts(RtcTagStartContext.class); 8106 } 8107 public RtcTagStartContext rtcTagStart(int i) { 8108 return getRuleContext(RtcTagStartContext.class,i); 8109 } 8110 public List<RpTagStartContext> rpTagStart() { 8111 return getRuleContexts(RpTagStartContext.class); 8112 } 8113 public RpTagStartContext rpTagStart(int i) { 8114 return getRuleContext(RpTagStartContext.class,i); 8115 } 8116 public List<HtmlCommentContext> htmlComment() { 8117 return getRuleContexts(HtmlCommentContext.class); 8118 } 8119 public HtmlCommentContext htmlComment(int i) { 8120 return getRuleContext(HtmlCommentContext.class,i); 8121 } 8122 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 8123 public TerminalNode CDATA(int i) { 8124 return getToken(JavadocParser.CDATA, i); 8125 } 8126 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8127 public TerminalNode NEWLINE(int i) { 8128 return getToken(JavadocParser.NEWLINE, i); 8129 } 8130 public List<TextContext> text() { 8131 return getRuleContexts(TextContext.class); 8132 } 8133 public TextContext text(int i) { 8134 return getRuleContext(TextContext.class,i); 8135 } 8136 public List<JavadocInlineTagContext> javadocInlineTag() { 8137 return getRuleContexts(JavadocInlineTagContext.class); 8138 } 8139 public JavadocInlineTagContext javadocInlineTag(int i) { 8140 return getRuleContext(JavadocInlineTagContext.class,i); 8141 } 8142 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8143 public TerminalNode LEADING_ASTERISK(int i) { 8144 return getToken(JavadocParser.LEADING_ASTERISK, i); 8145 } 8146 public DtContext(ParserRuleContext parent, int invokingState) { 8147 super(parent, invokingState); 8148 } 8149 @Override public int getRuleIndex() { return RULE_dt; } 8150 } 8151 8152 public final DtContext dt() throws RecognitionException { 8153 DtContext _localctx = new DtContext(_ctx, getState()); 8154 enterRule(_localctx, 64, RULE_dt); 8155 try { 8156 int _alt; 8157 enterOuterAlt(_localctx, 1); 8158 { 8159 setState(1000); 8160 dtTagStart(false); 8161 setState(1050); 8162 _errHandler.sync(this); 8163 _alt = getInterpreter().adaptivePredict(_input,58,_ctx); 8164 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8165 if ( _alt==1 ) { 8166 { 8167 setState(1048); 8168 _errHandler.sync(this); 8169 switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) { 8170 case 1: 8171 { 8172 setState(1001); 8173 htmlTag(); 8174 } 8175 break; 8176 case 2: 8177 { 8178 setState(1002); 8179 singletonElement(); 8180 } 8181 break; 8182 case 3: 8183 { 8184 setState(1003); 8185 paragraph(); 8186 } 8187 break; 8188 case 4: 8189 { 8190 setState(1004); 8191 li(); 8192 } 8193 break; 8194 case 5: 8195 { 8196 setState(1005); 8197 tr(); 8198 } 8199 break; 8200 case 6: 8201 { 8202 setState(1006); 8203 td(); 8204 } 8205 break; 8206 case 7: 8207 { 8208 setState(1007); 8209 th(); 8210 } 8211 break; 8212 case 8: 8213 { 8214 setState(1008); 8215 body(); 8216 } 8217 break; 8218 case 9: 8219 { 8220 setState(1009); 8221 colgroup(); 8222 } 8223 break; 8224 case 10: 8225 { 8226 setState(1010); 8227 dd(); 8228 } 8229 break; 8230 case 11: 8231 { 8232 setState(1011); 8233 head(); 8234 } 8235 break; 8236 case 12: 8237 { 8238 setState(1012); 8239 html(); 8240 } 8241 break; 8242 case 13: 8243 { 8244 setState(1013); 8245 option(); 8246 } 8247 break; 8248 case 14: 8249 { 8250 setState(1014); 8251 tbody(); 8252 } 8253 break; 8254 case 15: 8255 { 8256 setState(1015); 8257 thead(); 8258 } 8259 break; 8260 case 16: 8261 { 8262 setState(1016); 8263 tfoot(); 8264 } 8265 break; 8266 case 17: 8267 { 8268 setState(1017); 8269 optgroup(); 8270 } 8271 break; 8272 case 18: 8273 { 8274 setState(1018); 8275 rb(); 8276 } 8277 break; 8278 case 19: 8279 { 8280 setState(1019); 8281 rt(); 8282 } 8283 break; 8284 case 20: 8285 { 8286 setState(1020); 8287 rtc(); 8288 } 8289 break; 8290 case 21: 8291 { 8292 setState(1021); 8293 rp(); 8294 } 8295 break; 8296 case 22: 8297 { 8298 setState(1022); 8299 pTagStart(true); 8300 } 8301 break; 8302 case 23: 8303 { 8304 setState(1023); 8305 liTagStart(true); 8306 } 8307 break; 8308 case 24: 8309 { 8310 setState(1024); 8311 trTagStart(true); 8312 } 8313 break; 8314 case 25: 8315 { 8316 setState(1025); 8317 tdTagStart(true); 8318 } 8319 break; 8320 case 26: 8321 { 8322 setState(1026); 8323 thTagStart(true); 8324 } 8325 break; 8326 case 27: 8327 { 8328 setState(1027); 8329 bodyTagStart(true); 8330 } 8331 break; 8332 case 28: 8333 { 8334 setState(1028); 8335 colgroupTagStart(true); 8336 } 8337 break; 8338 case 29: 8339 { 8340 setState(1029); 8341 ddTagStart(true); 8342 } 8343 break; 8344 case 30: 8345 { 8346 setState(1030); 8347 headTagStart(true); 8348 } 8349 break; 8350 case 31: 8351 { 8352 setState(1031); 8353 htmlTagStart(true); 8354 } 8355 break; 8356 case 32: 8357 { 8358 setState(1032); 8359 optionTagStart(true); 8360 } 8361 break; 8362 case 33: 8363 { 8364 setState(1033); 8365 tbodyTagStart(true); 8366 } 8367 break; 8368 case 34: 8369 { 8370 setState(1034); 8371 theadTagStart(true); 8372 } 8373 break; 8374 case 35: 8375 { 8376 setState(1035); 8377 tfootTagStart(true); 8378 } 8379 break; 8380 case 36: 8381 { 8382 setState(1036); 8383 optgroupTagStart(true); 8384 } 8385 break; 8386 case 37: 8387 { 8388 setState(1037); 8389 rbTagStart(true); 8390 } 8391 break; 8392 case 38: 8393 { 8394 setState(1038); 8395 rtTagStart(true); 8396 } 8397 break; 8398 case 39: 8399 { 8400 setState(1039); 8401 rtcTagStart(true); 8402 } 8403 break; 8404 case 40: 8405 { 8406 setState(1040); 8407 rpTagStart(true); 8408 } 8409 break; 8410 case 41: 8411 { 8412 { 8413 setState(1041); 8414 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8415 setState(1042); 8416 match(LEADING_ASTERISK); 8417 } 8418 } 8419 break; 8420 case 42: 8421 { 8422 setState(1043); 8423 htmlComment(); 8424 } 8425 break; 8426 case 43: 8427 { 8428 setState(1044); 8429 match(CDATA); 8430 } 8431 break; 8432 case 44: 8433 { 8434 setState(1045); 8435 match(NEWLINE); 8436 } 8437 break; 8438 case 45: 8439 { 8440 setState(1046); 8441 text(); 8442 } 8443 break; 8444 case 46: 8445 { 8446 setState(1047); 8447 javadocInlineTag(); 8448 } 8449 break; 8450 } 8451 } 8452 } 8453 setState(1052); 8454 _errHandler.sync(this); 8455 _alt = getInterpreter().adaptivePredict(_input,58,_ctx); 8456 } 8457 setState(1053); 8458 dtTagEnd(); 8459 } 8460 } 8461 catch (RecognitionException re) { 8462 _localctx.exception = re; 8463 _errHandler.reportError(this, re); 8464 _errHandler.recover(this, re); 8465 } 8466 finally { 8467 exitRule(); 8468 } 8469 return _localctx; 8470 } 8471 8472 public static class HeadTagStartContext extends ParserRuleContext { 8473 public boolean isNonTight; 8474 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 8475 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 8476 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 8477 public List<AttributeContext> attribute() { 8478 return getRuleContexts(AttributeContext.class); 8479 } 8480 public AttributeContext attribute(int i) { 8481 return getRuleContext(AttributeContext.class,i); 8482 } 8483 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8484 public TerminalNode NEWLINE(int i) { 8485 return getToken(JavadocParser.NEWLINE, i); 8486 } 8487 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8488 public TerminalNode LEADING_ASTERISK(int i) { 8489 return getToken(JavadocParser.LEADING_ASTERISK, i); 8490 } 8491 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8492 public TerminalNode WS(int i) { 8493 return getToken(JavadocParser.WS, i); 8494 } 8495 public HeadTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 8496 public HeadTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 8497 super(parent, invokingState); 8498 this.isNonTight = isNonTight; 8499 } 8500 @Override public int getRuleIndex() { return RULE_headTagStart; } 8501 } 8502 8503 public final HeadTagStartContext headTagStart(boolean isNonTight) throws RecognitionException { 8504 HeadTagStartContext _localctx = new HeadTagStartContext(_ctx, getState(), isNonTight); 8505 enterRule(_localctx, 66, RULE_headTagStart); 8506 int _la; 8507 try { 8508 enterOuterAlt(_localctx, 1); 8509 { 8510 setState(1055); 8511 match(START); 8512 setState(1056); 8513 match(HEAD_HTML_TAG_NAME); 8514 setState(1063); 8515 _errHandler.sync(this); 8516 _la = _input.LA(1); 8517 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 8518 { 8519 setState(1061); 8520 _errHandler.sync(this); 8521 switch (_input.LA(1)) { 8522 case HTML_TAG_NAME: 8523 { 8524 setState(1057); 8525 attribute(); 8526 } 8527 break; 8528 case NEWLINE: 8529 { 8530 setState(1058); 8531 match(NEWLINE); 8532 } 8533 break; 8534 case LEADING_ASTERISK: 8535 { 8536 setState(1059); 8537 match(LEADING_ASTERISK); 8538 } 8539 break; 8540 case WS: 8541 { 8542 setState(1060); 8543 match(WS); 8544 } 8545 break; 8546 default: 8547 throw new NoViableAltException(this); 8548 } 8549 } 8550 setState(1065); 8551 _errHandler.sync(this); 8552 _la = _input.LA(1); 8553 } 8554 setState(1066); 8555 match(END); 8556 } 8557 _ctx.stop = _input.LT(-1); 8558 8559 if (isNonTight && nonTightTagStartContext == null) { 8560 nonTightTagStartContext = _localctx; 8561 } 8562 8563 } 8564 catch (RecognitionException re) { 8565 _localctx.exception = re; 8566 _errHandler.reportError(this, re); 8567 _errHandler.recover(this, re); 8568 } 8569 finally { 8570 exitRule(); 8571 } 8572 return _localctx; 8573 } 8574 8575 public static class HeadTagEndContext extends ParserRuleContext { 8576 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 8577 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 8578 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 8579 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 8580 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8581 public TerminalNode NEWLINE(int i) { 8582 return getToken(JavadocParser.NEWLINE, i); 8583 } 8584 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8585 public TerminalNode LEADING_ASTERISK(int i) { 8586 return getToken(JavadocParser.LEADING_ASTERISK, i); 8587 } 8588 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8589 public TerminalNode WS(int i) { 8590 return getToken(JavadocParser.WS, i); 8591 } 8592 public HeadTagEndContext(ParserRuleContext parent, int invokingState) { 8593 super(parent, invokingState); 8594 } 8595 @Override public int getRuleIndex() { return RULE_headTagEnd; } 8596 } 8597 8598 public final HeadTagEndContext headTagEnd() throws RecognitionException { 8599 HeadTagEndContext _localctx = new HeadTagEndContext(_ctx, getState()); 8600 enterRule(_localctx, 68, RULE_headTagEnd); 8601 int _la; 8602 try { 8603 enterOuterAlt(_localctx, 1); 8604 { 8605 setState(1068); 8606 match(START); 8607 setState(1069); 8608 match(SLASH); 8609 setState(1070); 8610 match(HEAD_HTML_TAG_NAME); 8611 setState(1074); 8612 _errHandler.sync(this); 8613 _la = _input.LA(1); 8614 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 8615 { 8616 { 8617 setState(1071); 8618 _la = _input.LA(1); 8619 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 8620 _errHandler.recoverInline(this); 8621 } 8622 else { 8623 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 8624 _errHandler.reportMatch(this); 8625 consume(); 8626 } 8627 } 8628 } 8629 setState(1076); 8630 _errHandler.sync(this); 8631 _la = _input.LA(1); 8632 } 8633 setState(1077); 8634 match(END); 8635 } 8636 } 8637 catch (RecognitionException re) { 8638 _localctx.exception = re; 8639 _errHandler.reportError(this, re); 8640 _errHandler.recover(this, re); 8641 } 8642 finally { 8643 exitRule(); 8644 } 8645 return _localctx; 8646 } 8647 8648 public static class HeadContext extends ParserRuleContext { 8649 public HeadTagStartContext headTagStart() { 8650 return getRuleContext(HeadTagStartContext.class,0); 8651 } 8652 public HeadTagEndContext headTagEnd() { 8653 return getRuleContext(HeadTagEndContext.class,0); 8654 } 8655 public List<HtmlTagContext> htmlTag() { 8656 return getRuleContexts(HtmlTagContext.class); 8657 } 8658 public HtmlTagContext htmlTag(int i) { 8659 return getRuleContext(HtmlTagContext.class,i); 8660 } 8661 public List<SingletonElementContext> singletonElement() { 8662 return getRuleContexts(SingletonElementContext.class); 8663 } 8664 public SingletonElementContext singletonElement(int i) { 8665 return getRuleContext(SingletonElementContext.class,i); 8666 } 8667 public List<ParagraphContext> paragraph() { 8668 return getRuleContexts(ParagraphContext.class); 8669 } 8670 public ParagraphContext paragraph(int i) { 8671 return getRuleContext(ParagraphContext.class,i); 8672 } 8673 public List<LiContext> li() { 8674 return getRuleContexts(LiContext.class); 8675 } 8676 public LiContext li(int i) { 8677 return getRuleContext(LiContext.class,i); 8678 } 8679 public List<TrContext> tr() { 8680 return getRuleContexts(TrContext.class); 8681 } 8682 public TrContext tr(int i) { 8683 return getRuleContext(TrContext.class,i); 8684 } 8685 public List<TdContext> td() { 8686 return getRuleContexts(TdContext.class); 8687 } 8688 public TdContext td(int i) { 8689 return getRuleContext(TdContext.class,i); 8690 } 8691 public List<ThContext> th() { 8692 return getRuleContexts(ThContext.class); 8693 } 8694 public ThContext th(int i) { 8695 return getRuleContext(ThContext.class,i); 8696 } 8697 public List<BodyContext> body() { 8698 return getRuleContexts(BodyContext.class); 8699 } 8700 public BodyContext body(int i) { 8701 return getRuleContext(BodyContext.class,i); 8702 } 8703 public List<ColgroupContext> colgroup() { 8704 return getRuleContexts(ColgroupContext.class); 8705 } 8706 public ColgroupContext colgroup(int i) { 8707 return getRuleContext(ColgroupContext.class,i); 8708 } 8709 public List<DdContext> dd() { 8710 return getRuleContexts(DdContext.class); 8711 } 8712 public DdContext dd(int i) { 8713 return getRuleContext(DdContext.class,i); 8714 } 8715 public List<DtContext> dt() { 8716 return getRuleContexts(DtContext.class); 8717 } 8718 public DtContext dt(int i) { 8719 return getRuleContext(DtContext.class,i); 8720 } 8721 public List<HtmlContext> html() { 8722 return getRuleContexts(HtmlContext.class); 8723 } 8724 public HtmlContext html(int i) { 8725 return getRuleContext(HtmlContext.class,i); 8726 } 8727 public List<OptionContext> option() { 8728 return getRuleContexts(OptionContext.class); 8729 } 8730 public OptionContext option(int i) { 8731 return getRuleContext(OptionContext.class,i); 8732 } 8733 public List<TbodyContext> tbody() { 8734 return getRuleContexts(TbodyContext.class); 8735 } 8736 public TbodyContext tbody(int i) { 8737 return getRuleContext(TbodyContext.class,i); 8738 } 8739 public List<TheadContext> thead() { 8740 return getRuleContexts(TheadContext.class); 8741 } 8742 public TheadContext thead(int i) { 8743 return getRuleContext(TheadContext.class,i); 8744 } 8745 public List<TfootContext> tfoot() { 8746 return getRuleContexts(TfootContext.class); 8747 } 8748 public TfootContext tfoot(int i) { 8749 return getRuleContext(TfootContext.class,i); 8750 } 8751 public List<OptgroupContext> optgroup() { 8752 return getRuleContexts(OptgroupContext.class); 8753 } 8754 public OptgroupContext optgroup(int i) { 8755 return getRuleContext(OptgroupContext.class,i); 8756 } 8757 public List<RbContext> rb() { 8758 return getRuleContexts(RbContext.class); 8759 } 8760 public RbContext rb(int i) { 8761 return getRuleContext(RbContext.class,i); 8762 } 8763 public List<RtContext> rt() { 8764 return getRuleContexts(RtContext.class); 8765 } 8766 public RtContext rt(int i) { 8767 return getRuleContext(RtContext.class,i); 8768 } 8769 public List<RtcContext> rtc() { 8770 return getRuleContexts(RtcContext.class); 8771 } 8772 public RtcContext rtc(int i) { 8773 return getRuleContext(RtcContext.class,i); 8774 } 8775 public List<RpContext> rp() { 8776 return getRuleContexts(RpContext.class); 8777 } 8778 public RpContext rp(int i) { 8779 return getRuleContext(RpContext.class,i); 8780 } 8781 public List<PTagStartContext> pTagStart() { 8782 return getRuleContexts(PTagStartContext.class); 8783 } 8784 public PTagStartContext pTagStart(int i) { 8785 return getRuleContext(PTagStartContext.class,i); 8786 } 8787 public List<LiTagStartContext> liTagStart() { 8788 return getRuleContexts(LiTagStartContext.class); 8789 } 8790 public LiTagStartContext liTagStart(int i) { 8791 return getRuleContext(LiTagStartContext.class,i); 8792 } 8793 public List<TrTagStartContext> trTagStart() { 8794 return getRuleContexts(TrTagStartContext.class); 8795 } 8796 public TrTagStartContext trTagStart(int i) { 8797 return getRuleContext(TrTagStartContext.class,i); 8798 } 8799 public List<TdTagStartContext> tdTagStart() { 8800 return getRuleContexts(TdTagStartContext.class); 8801 } 8802 public TdTagStartContext tdTagStart(int i) { 8803 return getRuleContext(TdTagStartContext.class,i); 8804 } 8805 public List<ThTagStartContext> thTagStart() { 8806 return getRuleContexts(ThTagStartContext.class); 8807 } 8808 public ThTagStartContext thTagStart(int i) { 8809 return getRuleContext(ThTagStartContext.class,i); 8810 } 8811 public List<BodyTagStartContext> bodyTagStart() { 8812 return getRuleContexts(BodyTagStartContext.class); 8813 } 8814 public BodyTagStartContext bodyTagStart(int i) { 8815 return getRuleContext(BodyTagStartContext.class,i); 8816 } 8817 public List<ColgroupTagStartContext> colgroupTagStart() { 8818 return getRuleContexts(ColgroupTagStartContext.class); 8819 } 8820 public ColgroupTagStartContext colgroupTagStart(int i) { 8821 return getRuleContext(ColgroupTagStartContext.class,i); 8822 } 8823 public List<DdTagStartContext> ddTagStart() { 8824 return getRuleContexts(DdTagStartContext.class); 8825 } 8826 public DdTagStartContext ddTagStart(int i) { 8827 return getRuleContext(DdTagStartContext.class,i); 8828 } 8829 public List<DtTagStartContext> dtTagStart() { 8830 return getRuleContexts(DtTagStartContext.class); 8831 } 8832 public DtTagStartContext dtTagStart(int i) { 8833 return getRuleContext(DtTagStartContext.class,i); 8834 } 8835 public List<HtmlTagStartContext> htmlTagStart() { 8836 return getRuleContexts(HtmlTagStartContext.class); 8837 } 8838 public HtmlTagStartContext htmlTagStart(int i) { 8839 return getRuleContext(HtmlTagStartContext.class,i); 8840 } 8841 public List<OptionTagStartContext> optionTagStart() { 8842 return getRuleContexts(OptionTagStartContext.class); 8843 } 8844 public OptionTagStartContext optionTagStart(int i) { 8845 return getRuleContext(OptionTagStartContext.class,i); 8846 } 8847 public List<TbodyTagStartContext> tbodyTagStart() { 8848 return getRuleContexts(TbodyTagStartContext.class); 8849 } 8850 public TbodyTagStartContext tbodyTagStart(int i) { 8851 return getRuleContext(TbodyTagStartContext.class,i); 8852 } 8853 public List<TheadTagStartContext> theadTagStart() { 8854 return getRuleContexts(TheadTagStartContext.class); 8855 } 8856 public TheadTagStartContext theadTagStart(int i) { 8857 return getRuleContext(TheadTagStartContext.class,i); 8858 } 8859 public List<TfootTagStartContext> tfootTagStart() { 8860 return getRuleContexts(TfootTagStartContext.class); 8861 } 8862 public TfootTagStartContext tfootTagStart(int i) { 8863 return getRuleContext(TfootTagStartContext.class,i); 8864 } 8865 public List<OptgroupTagStartContext> optgroupTagStart() { 8866 return getRuleContexts(OptgroupTagStartContext.class); 8867 } 8868 public OptgroupTagStartContext optgroupTagStart(int i) { 8869 return getRuleContext(OptgroupTagStartContext.class,i); 8870 } 8871 public List<RbTagStartContext> rbTagStart() { 8872 return getRuleContexts(RbTagStartContext.class); 8873 } 8874 public RbTagStartContext rbTagStart(int i) { 8875 return getRuleContext(RbTagStartContext.class,i); 8876 } 8877 public List<RtTagStartContext> rtTagStart() { 8878 return getRuleContexts(RtTagStartContext.class); 8879 } 8880 public RtTagStartContext rtTagStart(int i) { 8881 return getRuleContext(RtTagStartContext.class,i); 8882 } 8883 public List<RtcTagStartContext> rtcTagStart() { 8884 return getRuleContexts(RtcTagStartContext.class); 8885 } 8886 public RtcTagStartContext rtcTagStart(int i) { 8887 return getRuleContext(RtcTagStartContext.class,i); 8888 } 8889 public List<RpTagStartContext> rpTagStart() { 8890 return getRuleContexts(RpTagStartContext.class); 8891 } 8892 public RpTagStartContext rpTagStart(int i) { 8893 return getRuleContext(RpTagStartContext.class,i); 8894 } 8895 public List<HtmlCommentContext> htmlComment() { 8896 return getRuleContexts(HtmlCommentContext.class); 8897 } 8898 public HtmlCommentContext htmlComment(int i) { 8899 return getRuleContext(HtmlCommentContext.class,i); 8900 } 8901 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 8902 public TerminalNode CDATA(int i) { 8903 return getToken(JavadocParser.CDATA, i); 8904 } 8905 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8906 public TerminalNode NEWLINE(int i) { 8907 return getToken(JavadocParser.NEWLINE, i); 8908 } 8909 public List<TextContext> text() { 8910 return getRuleContexts(TextContext.class); 8911 } 8912 public TextContext text(int i) { 8913 return getRuleContext(TextContext.class,i); 8914 } 8915 public List<JavadocInlineTagContext> javadocInlineTag() { 8916 return getRuleContexts(JavadocInlineTagContext.class); 8917 } 8918 public JavadocInlineTagContext javadocInlineTag(int i) { 8919 return getRuleContext(JavadocInlineTagContext.class,i); 8920 } 8921 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8922 public TerminalNode LEADING_ASTERISK(int i) { 8923 return getToken(JavadocParser.LEADING_ASTERISK, i); 8924 } 8925 public HeadContext(ParserRuleContext parent, int invokingState) { 8926 super(parent, invokingState); 8927 } 8928 @Override public int getRuleIndex() { return RULE_head; } 8929 } 8930 8931 public final HeadContext head() throws RecognitionException { 8932 HeadContext _localctx = new HeadContext(_ctx, getState()); 8933 enterRule(_localctx, 70, RULE_head); 8934 try { 8935 int _alt; 8936 enterOuterAlt(_localctx, 1); 8937 { 8938 setState(1079); 8939 headTagStart(false); 8940 setState(1129); 8941 _errHandler.sync(this); 8942 _alt = getInterpreter().adaptivePredict(_input,63,_ctx); 8943 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8944 if ( _alt==1 ) { 8945 { 8946 setState(1127); 8947 _errHandler.sync(this); 8948 switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) { 8949 case 1: 8950 { 8951 setState(1080); 8952 htmlTag(); 8953 } 8954 break; 8955 case 2: 8956 { 8957 setState(1081); 8958 singletonElement(); 8959 } 8960 break; 8961 case 3: 8962 { 8963 setState(1082); 8964 paragraph(); 8965 } 8966 break; 8967 case 4: 8968 { 8969 setState(1083); 8970 li(); 8971 } 8972 break; 8973 case 5: 8974 { 8975 setState(1084); 8976 tr(); 8977 } 8978 break; 8979 case 6: 8980 { 8981 setState(1085); 8982 td(); 8983 } 8984 break; 8985 case 7: 8986 { 8987 setState(1086); 8988 th(); 8989 } 8990 break; 8991 case 8: 8992 { 8993 setState(1087); 8994 body(); 8995 } 8996 break; 8997 case 9: 8998 { 8999 setState(1088); 9000 colgroup(); 9001 } 9002 break; 9003 case 10: 9004 { 9005 setState(1089); 9006 dd(); 9007 } 9008 break; 9009 case 11: 9010 { 9011 setState(1090); 9012 dt(); 9013 } 9014 break; 9015 case 12: 9016 { 9017 setState(1091); 9018 html(); 9019 } 9020 break; 9021 case 13: 9022 { 9023 setState(1092); 9024 option(); 9025 } 9026 break; 9027 case 14: 9028 { 9029 setState(1093); 9030 tbody(); 9031 } 9032 break; 9033 case 15: 9034 { 9035 setState(1094); 9036 thead(); 9037 } 9038 break; 9039 case 16: 9040 { 9041 setState(1095); 9042 tfoot(); 9043 } 9044 break; 9045 case 17: 9046 { 9047 setState(1096); 9048 optgroup(); 9049 } 9050 break; 9051 case 18: 9052 { 9053 setState(1097); 9054 rb(); 9055 } 9056 break; 9057 case 19: 9058 { 9059 setState(1098); 9060 rt(); 9061 } 9062 break; 9063 case 20: 9064 { 9065 setState(1099); 9066 rtc(); 9067 } 9068 break; 9069 case 21: 9070 { 9071 setState(1100); 9072 rp(); 9073 } 9074 break; 9075 case 22: 9076 { 9077 setState(1101); 9078 pTagStart(true); 9079 } 9080 break; 9081 case 23: 9082 { 9083 setState(1102); 9084 liTagStart(true); 9085 } 9086 break; 9087 case 24: 9088 { 9089 setState(1103); 9090 trTagStart(true); 9091 } 9092 break; 9093 case 25: 9094 { 9095 setState(1104); 9096 tdTagStart(true); 9097 } 9098 break; 9099 case 26: 9100 { 9101 setState(1105); 9102 thTagStart(true); 9103 } 9104 break; 9105 case 27: 9106 { 9107 setState(1106); 9108 bodyTagStart(true); 9109 } 9110 break; 9111 case 28: 9112 { 9113 setState(1107); 9114 colgroupTagStart(true); 9115 } 9116 break; 9117 case 29: 9118 { 9119 setState(1108); 9120 ddTagStart(true); 9121 } 9122 break; 9123 case 30: 9124 { 9125 setState(1109); 9126 dtTagStart(true); 9127 } 9128 break; 9129 case 31: 9130 { 9131 setState(1110); 9132 htmlTagStart(true); 9133 } 9134 break; 9135 case 32: 9136 { 9137 setState(1111); 9138 optionTagStart(true); 9139 } 9140 break; 9141 case 33: 9142 { 9143 setState(1112); 9144 tbodyTagStart(true); 9145 } 9146 break; 9147 case 34: 9148 { 9149 setState(1113); 9150 theadTagStart(true); 9151 } 9152 break; 9153 case 35: 9154 { 9155 setState(1114); 9156 tfootTagStart(true); 9157 } 9158 break; 9159 case 36: 9160 { 9161 setState(1115); 9162 optgroupTagStart(true); 9163 } 9164 break; 9165 case 37: 9166 { 9167 setState(1116); 9168 rbTagStart(true); 9169 } 9170 break; 9171 case 38: 9172 { 9173 setState(1117); 9174 rtTagStart(true); 9175 } 9176 break; 9177 case 39: 9178 { 9179 setState(1118); 9180 rtcTagStart(true); 9181 } 9182 break; 9183 case 40: 9184 { 9185 setState(1119); 9186 rpTagStart(true); 9187 } 9188 break; 9189 case 41: 9190 { 9191 { 9192 setState(1120); 9193 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 9194 setState(1121); 9195 match(LEADING_ASTERISK); 9196 } 9197 } 9198 break; 9199 case 42: 9200 { 9201 setState(1122); 9202 htmlComment(); 9203 } 9204 break; 9205 case 43: 9206 { 9207 setState(1123); 9208 match(CDATA); 9209 } 9210 break; 9211 case 44: 9212 { 9213 setState(1124); 9214 match(NEWLINE); 9215 } 9216 break; 9217 case 45: 9218 { 9219 setState(1125); 9220 text(); 9221 } 9222 break; 9223 case 46: 9224 { 9225 setState(1126); 9226 javadocInlineTag(); 9227 } 9228 break; 9229 } 9230 } 9231 } 9232 setState(1131); 9233 _errHandler.sync(this); 9234 _alt = getInterpreter().adaptivePredict(_input,63,_ctx); 9235 } 9236 setState(1132); 9237 headTagEnd(); 9238 } 9239 } 9240 catch (RecognitionException re) { 9241 _localctx.exception = re; 9242 _errHandler.reportError(this, re); 9243 _errHandler.recover(this, re); 9244 } 9245 finally { 9246 exitRule(); 9247 } 9248 return _localctx; 9249 } 9250 9251 public static class HtmlTagStartContext extends ParserRuleContext { 9252 public boolean isNonTight; 9253 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 9254 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 9255 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 9256 public List<AttributeContext> attribute() { 9257 return getRuleContexts(AttributeContext.class); 9258 } 9259 public AttributeContext attribute(int i) { 9260 return getRuleContext(AttributeContext.class,i); 9261 } 9262 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9263 public TerminalNode NEWLINE(int i) { 9264 return getToken(JavadocParser.NEWLINE, i); 9265 } 9266 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9267 public TerminalNode LEADING_ASTERISK(int i) { 9268 return getToken(JavadocParser.LEADING_ASTERISK, i); 9269 } 9270 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9271 public TerminalNode WS(int i) { 9272 return getToken(JavadocParser.WS, i); 9273 } 9274 public HtmlTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 9275 public HtmlTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 9276 super(parent, invokingState); 9277 this.isNonTight = isNonTight; 9278 } 9279 @Override public int getRuleIndex() { return RULE_htmlTagStart; } 9280 } 9281 9282 public final HtmlTagStartContext htmlTagStart(boolean isNonTight) throws RecognitionException { 9283 HtmlTagStartContext _localctx = new HtmlTagStartContext(_ctx, getState(), isNonTight); 9284 enterRule(_localctx, 72, RULE_htmlTagStart); 9285 int _la; 9286 try { 9287 enterOuterAlt(_localctx, 1); 9288 { 9289 setState(1134); 9290 match(START); 9291 setState(1135); 9292 match(HTML_HTML_TAG_NAME); 9293 setState(1142); 9294 _errHandler.sync(this); 9295 _la = _input.LA(1); 9296 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9297 { 9298 setState(1140); 9299 _errHandler.sync(this); 9300 switch (_input.LA(1)) { 9301 case HTML_TAG_NAME: 9302 { 9303 setState(1136); 9304 attribute(); 9305 } 9306 break; 9307 case NEWLINE: 9308 { 9309 setState(1137); 9310 match(NEWLINE); 9311 } 9312 break; 9313 case LEADING_ASTERISK: 9314 { 9315 setState(1138); 9316 match(LEADING_ASTERISK); 9317 } 9318 break; 9319 case WS: 9320 { 9321 setState(1139); 9322 match(WS); 9323 } 9324 break; 9325 default: 9326 throw new NoViableAltException(this); 9327 } 9328 } 9329 setState(1144); 9330 _errHandler.sync(this); 9331 _la = _input.LA(1); 9332 } 9333 setState(1145); 9334 match(END); 9335 } 9336 _ctx.stop = _input.LT(-1); 9337 9338 if (isNonTight && nonTightTagStartContext == null) { 9339 nonTightTagStartContext = _localctx; 9340 } 9341 9342 } 9343 catch (RecognitionException re) { 9344 _localctx.exception = re; 9345 _errHandler.reportError(this, re); 9346 _errHandler.recover(this, re); 9347 } 9348 finally { 9349 exitRule(); 9350 } 9351 return _localctx; 9352 } 9353 9354 public static class HtmlTagEndContext extends ParserRuleContext { 9355 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 9356 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9357 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 9358 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 9359 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9360 public TerminalNode NEWLINE(int i) { 9361 return getToken(JavadocParser.NEWLINE, i); 9362 } 9363 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9364 public TerminalNode LEADING_ASTERISK(int i) { 9365 return getToken(JavadocParser.LEADING_ASTERISK, i); 9366 } 9367 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9368 public TerminalNode WS(int i) { 9369 return getToken(JavadocParser.WS, i); 9370 } 9371 public HtmlTagEndContext(ParserRuleContext parent, int invokingState) { 9372 super(parent, invokingState); 9373 } 9374 @Override public int getRuleIndex() { return RULE_htmlTagEnd; } 9375 } 9376 9377 public final HtmlTagEndContext htmlTagEnd() throws RecognitionException { 9378 HtmlTagEndContext _localctx = new HtmlTagEndContext(_ctx, getState()); 9379 enterRule(_localctx, 74, RULE_htmlTagEnd); 9380 int _la; 9381 try { 9382 enterOuterAlt(_localctx, 1); 9383 { 9384 setState(1147); 9385 match(START); 9386 setState(1148); 9387 match(SLASH); 9388 setState(1149); 9389 match(HTML_HTML_TAG_NAME); 9390 setState(1153); 9391 _errHandler.sync(this); 9392 _la = _input.LA(1); 9393 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9394 { 9395 { 9396 setState(1150); 9397 _la = _input.LA(1); 9398 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9399 _errHandler.recoverInline(this); 9400 } 9401 else { 9402 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 9403 _errHandler.reportMatch(this); 9404 consume(); 9405 } 9406 } 9407 } 9408 setState(1155); 9409 _errHandler.sync(this); 9410 _la = _input.LA(1); 9411 } 9412 setState(1156); 9413 match(END); 9414 } 9415 } 9416 catch (RecognitionException re) { 9417 _localctx.exception = re; 9418 _errHandler.reportError(this, re); 9419 _errHandler.recover(this, re); 9420 } 9421 finally { 9422 exitRule(); 9423 } 9424 return _localctx; 9425 } 9426 9427 public static class HtmlContext extends ParserRuleContext { 9428 public HtmlTagStartContext htmlTagStart() { 9429 return getRuleContext(HtmlTagStartContext.class,0); 9430 } 9431 public HtmlTagEndContext htmlTagEnd() { 9432 return getRuleContext(HtmlTagEndContext.class,0); 9433 } 9434 public List<HtmlTagContext> htmlTag() { 9435 return getRuleContexts(HtmlTagContext.class); 9436 } 9437 public HtmlTagContext htmlTag(int i) { 9438 return getRuleContext(HtmlTagContext.class,i); 9439 } 9440 public List<SingletonElementContext> singletonElement() { 9441 return getRuleContexts(SingletonElementContext.class); 9442 } 9443 public SingletonElementContext singletonElement(int i) { 9444 return getRuleContext(SingletonElementContext.class,i); 9445 } 9446 public List<ParagraphContext> paragraph() { 9447 return getRuleContexts(ParagraphContext.class); 9448 } 9449 public ParagraphContext paragraph(int i) { 9450 return getRuleContext(ParagraphContext.class,i); 9451 } 9452 public List<LiContext> li() { 9453 return getRuleContexts(LiContext.class); 9454 } 9455 public LiContext li(int i) { 9456 return getRuleContext(LiContext.class,i); 9457 } 9458 public List<TrContext> tr() { 9459 return getRuleContexts(TrContext.class); 9460 } 9461 public TrContext tr(int i) { 9462 return getRuleContext(TrContext.class,i); 9463 } 9464 public List<TdContext> td() { 9465 return getRuleContexts(TdContext.class); 9466 } 9467 public TdContext td(int i) { 9468 return getRuleContext(TdContext.class,i); 9469 } 9470 public List<ThContext> th() { 9471 return getRuleContexts(ThContext.class); 9472 } 9473 public ThContext th(int i) { 9474 return getRuleContext(ThContext.class,i); 9475 } 9476 public List<BodyContext> body() { 9477 return getRuleContexts(BodyContext.class); 9478 } 9479 public BodyContext body(int i) { 9480 return getRuleContext(BodyContext.class,i); 9481 } 9482 public List<ColgroupContext> colgroup() { 9483 return getRuleContexts(ColgroupContext.class); 9484 } 9485 public ColgroupContext colgroup(int i) { 9486 return getRuleContext(ColgroupContext.class,i); 9487 } 9488 public List<DdContext> dd() { 9489 return getRuleContexts(DdContext.class); 9490 } 9491 public DdContext dd(int i) { 9492 return getRuleContext(DdContext.class,i); 9493 } 9494 public List<DtContext> dt() { 9495 return getRuleContexts(DtContext.class); 9496 } 9497 public DtContext dt(int i) { 9498 return getRuleContext(DtContext.class,i); 9499 } 9500 public List<HeadContext> head() { 9501 return getRuleContexts(HeadContext.class); 9502 } 9503 public HeadContext head(int i) { 9504 return getRuleContext(HeadContext.class,i); 9505 } 9506 public List<OptionContext> option() { 9507 return getRuleContexts(OptionContext.class); 9508 } 9509 public OptionContext option(int i) { 9510 return getRuleContext(OptionContext.class,i); 9511 } 9512 public List<TbodyContext> tbody() { 9513 return getRuleContexts(TbodyContext.class); 9514 } 9515 public TbodyContext tbody(int i) { 9516 return getRuleContext(TbodyContext.class,i); 9517 } 9518 public List<TheadContext> thead() { 9519 return getRuleContexts(TheadContext.class); 9520 } 9521 public TheadContext thead(int i) { 9522 return getRuleContext(TheadContext.class,i); 9523 } 9524 public List<TfootContext> tfoot() { 9525 return getRuleContexts(TfootContext.class); 9526 } 9527 public TfootContext tfoot(int i) { 9528 return getRuleContext(TfootContext.class,i); 9529 } 9530 public List<OptgroupContext> optgroup() { 9531 return getRuleContexts(OptgroupContext.class); 9532 } 9533 public OptgroupContext optgroup(int i) { 9534 return getRuleContext(OptgroupContext.class,i); 9535 } 9536 public List<RbContext> rb() { 9537 return getRuleContexts(RbContext.class); 9538 } 9539 public RbContext rb(int i) { 9540 return getRuleContext(RbContext.class,i); 9541 } 9542 public List<RtContext> rt() { 9543 return getRuleContexts(RtContext.class); 9544 } 9545 public RtContext rt(int i) { 9546 return getRuleContext(RtContext.class,i); 9547 } 9548 public List<RtcContext> rtc() { 9549 return getRuleContexts(RtcContext.class); 9550 } 9551 public RtcContext rtc(int i) { 9552 return getRuleContext(RtcContext.class,i); 9553 } 9554 public List<RpContext> rp() { 9555 return getRuleContexts(RpContext.class); 9556 } 9557 public RpContext rp(int i) { 9558 return getRuleContext(RpContext.class,i); 9559 } 9560 public List<PTagStartContext> pTagStart() { 9561 return getRuleContexts(PTagStartContext.class); 9562 } 9563 public PTagStartContext pTagStart(int i) { 9564 return getRuleContext(PTagStartContext.class,i); 9565 } 9566 public List<LiTagStartContext> liTagStart() { 9567 return getRuleContexts(LiTagStartContext.class); 9568 } 9569 public LiTagStartContext liTagStart(int i) { 9570 return getRuleContext(LiTagStartContext.class,i); 9571 } 9572 public List<TrTagStartContext> trTagStart() { 9573 return getRuleContexts(TrTagStartContext.class); 9574 } 9575 public TrTagStartContext trTagStart(int i) { 9576 return getRuleContext(TrTagStartContext.class,i); 9577 } 9578 public List<TdTagStartContext> tdTagStart() { 9579 return getRuleContexts(TdTagStartContext.class); 9580 } 9581 public TdTagStartContext tdTagStart(int i) { 9582 return getRuleContext(TdTagStartContext.class,i); 9583 } 9584 public List<ThTagStartContext> thTagStart() { 9585 return getRuleContexts(ThTagStartContext.class); 9586 } 9587 public ThTagStartContext thTagStart(int i) { 9588 return getRuleContext(ThTagStartContext.class,i); 9589 } 9590 public List<BodyTagStartContext> bodyTagStart() { 9591 return getRuleContexts(BodyTagStartContext.class); 9592 } 9593 public BodyTagStartContext bodyTagStart(int i) { 9594 return getRuleContext(BodyTagStartContext.class,i); 9595 } 9596 public List<ColgroupTagStartContext> colgroupTagStart() { 9597 return getRuleContexts(ColgroupTagStartContext.class); 9598 } 9599 public ColgroupTagStartContext colgroupTagStart(int i) { 9600 return getRuleContext(ColgroupTagStartContext.class,i); 9601 } 9602 public List<DdTagStartContext> ddTagStart() { 9603 return getRuleContexts(DdTagStartContext.class); 9604 } 9605 public DdTagStartContext ddTagStart(int i) { 9606 return getRuleContext(DdTagStartContext.class,i); 9607 } 9608 public List<DtTagStartContext> dtTagStart() { 9609 return getRuleContexts(DtTagStartContext.class); 9610 } 9611 public DtTagStartContext dtTagStart(int i) { 9612 return getRuleContext(DtTagStartContext.class,i); 9613 } 9614 public List<HeadTagStartContext> headTagStart() { 9615 return getRuleContexts(HeadTagStartContext.class); 9616 } 9617 public HeadTagStartContext headTagStart(int i) { 9618 return getRuleContext(HeadTagStartContext.class,i); 9619 } 9620 public List<OptionTagStartContext> optionTagStart() { 9621 return getRuleContexts(OptionTagStartContext.class); 9622 } 9623 public OptionTagStartContext optionTagStart(int i) { 9624 return getRuleContext(OptionTagStartContext.class,i); 9625 } 9626 public List<TbodyTagStartContext> tbodyTagStart() { 9627 return getRuleContexts(TbodyTagStartContext.class); 9628 } 9629 public TbodyTagStartContext tbodyTagStart(int i) { 9630 return getRuleContext(TbodyTagStartContext.class,i); 9631 } 9632 public List<TheadTagStartContext> theadTagStart() { 9633 return getRuleContexts(TheadTagStartContext.class); 9634 } 9635 public TheadTagStartContext theadTagStart(int i) { 9636 return getRuleContext(TheadTagStartContext.class,i); 9637 } 9638 public List<TfootTagStartContext> tfootTagStart() { 9639 return getRuleContexts(TfootTagStartContext.class); 9640 } 9641 public TfootTagStartContext tfootTagStart(int i) { 9642 return getRuleContext(TfootTagStartContext.class,i); 9643 } 9644 public List<OptgroupTagStartContext> optgroupTagStart() { 9645 return getRuleContexts(OptgroupTagStartContext.class); 9646 } 9647 public OptgroupTagStartContext optgroupTagStart(int i) { 9648 return getRuleContext(OptgroupTagStartContext.class,i); 9649 } 9650 public List<RbTagStartContext> rbTagStart() { 9651 return getRuleContexts(RbTagStartContext.class); 9652 } 9653 public RbTagStartContext rbTagStart(int i) { 9654 return getRuleContext(RbTagStartContext.class,i); 9655 } 9656 public List<RtTagStartContext> rtTagStart() { 9657 return getRuleContexts(RtTagStartContext.class); 9658 } 9659 public RtTagStartContext rtTagStart(int i) { 9660 return getRuleContext(RtTagStartContext.class,i); 9661 } 9662 public List<RtcTagStartContext> rtcTagStart() { 9663 return getRuleContexts(RtcTagStartContext.class); 9664 } 9665 public RtcTagStartContext rtcTagStart(int i) { 9666 return getRuleContext(RtcTagStartContext.class,i); 9667 } 9668 public List<RpTagStartContext> rpTagStart() { 9669 return getRuleContexts(RpTagStartContext.class); 9670 } 9671 public RpTagStartContext rpTagStart(int i) { 9672 return getRuleContext(RpTagStartContext.class,i); 9673 } 9674 public List<HtmlCommentContext> htmlComment() { 9675 return getRuleContexts(HtmlCommentContext.class); 9676 } 9677 public HtmlCommentContext htmlComment(int i) { 9678 return getRuleContext(HtmlCommentContext.class,i); 9679 } 9680 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 9681 public TerminalNode CDATA(int i) { 9682 return getToken(JavadocParser.CDATA, i); 9683 } 9684 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9685 public TerminalNode NEWLINE(int i) { 9686 return getToken(JavadocParser.NEWLINE, i); 9687 } 9688 public List<TextContext> text() { 9689 return getRuleContexts(TextContext.class); 9690 } 9691 public TextContext text(int i) { 9692 return getRuleContext(TextContext.class,i); 9693 } 9694 public List<JavadocInlineTagContext> javadocInlineTag() { 9695 return getRuleContexts(JavadocInlineTagContext.class); 9696 } 9697 public JavadocInlineTagContext javadocInlineTag(int i) { 9698 return getRuleContext(JavadocInlineTagContext.class,i); 9699 } 9700 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9701 public TerminalNode LEADING_ASTERISK(int i) { 9702 return getToken(JavadocParser.LEADING_ASTERISK, i); 9703 } 9704 public HtmlContext(ParserRuleContext parent, int invokingState) { 9705 super(parent, invokingState); 9706 } 9707 @Override public int getRuleIndex() { return RULE_html; } 9708 } 9709 9710 public final HtmlContext html() throws RecognitionException { 9711 HtmlContext _localctx = new HtmlContext(_ctx, getState()); 9712 enterRule(_localctx, 76, RULE_html); 9713 try { 9714 int _alt; 9715 enterOuterAlt(_localctx, 1); 9716 { 9717 setState(1158); 9718 htmlTagStart(false); 9719 setState(1208); 9720 _errHandler.sync(this); 9721 _alt = getInterpreter().adaptivePredict(_input,68,_ctx); 9722 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 9723 if ( _alt==1 ) { 9724 { 9725 setState(1206); 9726 _errHandler.sync(this); 9727 switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) { 9728 case 1: 9729 { 9730 setState(1159); 9731 htmlTag(); 9732 } 9733 break; 9734 case 2: 9735 { 9736 setState(1160); 9737 singletonElement(); 9738 } 9739 break; 9740 case 3: 9741 { 9742 setState(1161); 9743 paragraph(); 9744 } 9745 break; 9746 case 4: 9747 { 9748 setState(1162); 9749 li(); 9750 } 9751 break; 9752 case 5: 9753 { 9754 setState(1163); 9755 tr(); 9756 } 9757 break; 9758 case 6: 9759 { 9760 setState(1164); 9761 td(); 9762 } 9763 break; 9764 case 7: 9765 { 9766 setState(1165); 9767 th(); 9768 } 9769 break; 9770 case 8: 9771 { 9772 setState(1166); 9773 body(); 9774 } 9775 break; 9776 case 9: 9777 { 9778 setState(1167); 9779 colgroup(); 9780 } 9781 break; 9782 case 10: 9783 { 9784 setState(1168); 9785 dd(); 9786 } 9787 break; 9788 case 11: 9789 { 9790 setState(1169); 9791 dt(); 9792 } 9793 break; 9794 case 12: 9795 { 9796 setState(1170); 9797 head(); 9798 } 9799 break; 9800 case 13: 9801 { 9802 setState(1171); 9803 option(); 9804 } 9805 break; 9806 case 14: 9807 { 9808 setState(1172); 9809 tbody(); 9810 } 9811 break; 9812 case 15: 9813 { 9814 setState(1173); 9815 thead(); 9816 } 9817 break; 9818 case 16: 9819 { 9820 setState(1174); 9821 tfoot(); 9822 } 9823 break; 9824 case 17: 9825 { 9826 setState(1175); 9827 optgroup(); 9828 } 9829 break; 9830 case 18: 9831 { 9832 setState(1176); 9833 rb(); 9834 } 9835 break; 9836 case 19: 9837 { 9838 setState(1177); 9839 rt(); 9840 } 9841 break; 9842 case 20: 9843 { 9844 setState(1178); 9845 rtc(); 9846 } 9847 break; 9848 case 21: 9849 { 9850 setState(1179); 9851 rp(); 9852 } 9853 break; 9854 case 22: 9855 { 9856 setState(1180); 9857 pTagStart(true); 9858 } 9859 break; 9860 case 23: 9861 { 9862 setState(1181); 9863 liTagStart(true); 9864 } 9865 break; 9866 case 24: 9867 { 9868 setState(1182); 9869 trTagStart(true); 9870 } 9871 break; 9872 case 25: 9873 { 9874 setState(1183); 9875 tdTagStart(true); 9876 } 9877 break; 9878 case 26: 9879 { 9880 setState(1184); 9881 thTagStart(true); 9882 } 9883 break; 9884 case 27: 9885 { 9886 setState(1185); 9887 bodyTagStart(true); 9888 } 9889 break; 9890 case 28: 9891 { 9892 setState(1186); 9893 colgroupTagStart(true); 9894 } 9895 break; 9896 case 29: 9897 { 9898 setState(1187); 9899 ddTagStart(true); 9900 } 9901 break; 9902 case 30: 9903 { 9904 setState(1188); 9905 dtTagStart(true); 9906 } 9907 break; 9908 case 31: 9909 { 9910 setState(1189); 9911 headTagStart(true); 9912 } 9913 break; 9914 case 32: 9915 { 9916 setState(1190); 9917 optionTagStart(true); 9918 } 9919 break; 9920 case 33: 9921 { 9922 setState(1191); 9923 tbodyTagStart(true); 9924 } 9925 break; 9926 case 34: 9927 { 9928 setState(1192); 9929 theadTagStart(true); 9930 } 9931 break; 9932 case 35: 9933 { 9934 setState(1193); 9935 tfootTagStart(true); 9936 } 9937 break; 9938 case 36: 9939 { 9940 setState(1194); 9941 optgroupTagStart(true); 9942 } 9943 break; 9944 case 37: 9945 { 9946 setState(1195); 9947 rbTagStart(true); 9948 } 9949 break; 9950 case 38: 9951 { 9952 setState(1196); 9953 rtTagStart(true); 9954 } 9955 break; 9956 case 39: 9957 { 9958 setState(1197); 9959 rtcTagStart(true); 9960 } 9961 break; 9962 case 40: 9963 { 9964 setState(1198); 9965 rpTagStart(true); 9966 } 9967 break; 9968 case 41: 9969 { 9970 { 9971 setState(1199); 9972 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 9973 setState(1200); 9974 match(LEADING_ASTERISK); 9975 } 9976 } 9977 break; 9978 case 42: 9979 { 9980 setState(1201); 9981 htmlComment(); 9982 } 9983 break; 9984 case 43: 9985 { 9986 setState(1202); 9987 match(CDATA); 9988 } 9989 break; 9990 case 44: 9991 { 9992 setState(1203); 9993 match(NEWLINE); 9994 } 9995 break; 9996 case 45: 9997 { 9998 setState(1204); 9999 text(); 10000 } 10001 break; 10002 case 46: 10003 { 10004 setState(1205); 10005 javadocInlineTag(); 10006 } 10007 break; 10008 } 10009 } 10010 } 10011 setState(1210); 10012 _errHandler.sync(this); 10013 _alt = getInterpreter().adaptivePredict(_input,68,_ctx); 10014 } 10015 setState(1211); 10016 htmlTagEnd(); 10017 } 10018 } 10019 catch (RecognitionException re) { 10020 _localctx.exception = re; 10021 _errHandler.reportError(this, re); 10022 _errHandler.recover(this, re); 10023 } 10024 finally { 10025 exitRule(); 10026 } 10027 return _localctx; 10028 } 10029 10030 public static class OptionTagStartContext extends ParserRuleContext { 10031 public boolean isNonTight; 10032 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 10033 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 10034 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 10035 public List<AttributeContext> attribute() { 10036 return getRuleContexts(AttributeContext.class); 10037 } 10038 public AttributeContext attribute(int i) { 10039 return getRuleContext(AttributeContext.class,i); 10040 } 10041 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10042 public TerminalNode NEWLINE(int i) { 10043 return getToken(JavadocParser.NEWLINE, i); 10044 } 10045 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10046 public TerminalNode LEADING_ASTERISK(int i) { 10047 return getToken(JavadocParser.LEADING_ASTERISK, i); 10048 } 10049 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10050 public TerminalNode WS(int i) { 10051 return getToken(JavadocParser.WS, i); 10052 } 10053 public OptionTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 10054 public OptionTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 10055 super(parent, invokingState); 10056 this.isNonTight = isNonTight; 10057 } 10058 @Override public int getRuleIndex() { return RULE_optionTagStart; } 10059 } 10060 10061 public final OptionTagStartContext optionTagStart(boolean isNonTight) throws RecognitionException { 10062 OptionTagStartContext _localctx = new OptionTagStartContext(_ctx, getState(), isNonTight); 10063 enterRule(_localctx, 78, RULE_optionTagStart); 10064 int _la; 10065 try { 10066 enterOuterAlt(_localctx, 1); 10067 { 10068 setState(1213); 10069 match(START); 10070 setState(1214); 10071 match(OPTION_HTML_TAG_NAME); 10072 setState(1221); 10073 _errHandler.sync(this); 10074 _la = _input.LA(1); 10075 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 10076 { 10077 setState(1219); 10078 _errHandler.sync(this); 10079 switch (_input.LA(1)) { 10080 case HTML_TAG_NAME: 10081 { 10082 setState(1215); 10083 attribute(); 10084 } 10085 break; 10086 case NEWLINE: 10087 { 10088 setState(1216); 10089 match(NEWLINE); 10090 } 10091 break; 10092 case LEADING_ASTERISK: 10093 { 10094 setState(1217); 10095 match(LEADING_ASTERISK); 10096 } 10097 break; 10098 case WS: 10099 { 10100 setState(1218); 10101 match(WS); 10102 } 10103 break; 10104 default: 10105 throw new NoViableAltException(this); 10106 } 10107 } 10108 setState(1223); 10109 _errHandler.sync(this); 10110 _la = _input.LA(1); 10111 } 10112 setState(1224); 10113 match(END); 10114 } 10115 _ctx.stop = _input.LT(-1); 10116 10117 if (isNonTight && nonTightTagStartContext == null) { 10118 nonTightTagStartContext = _localctx; 10119 } 10120 10121 } 10122 catch (RecognitionException re) { 10123 _localctx.exception = re; 10124 _errHandler.reportError(this, re); 10125 _errHandler.recover(this, re); 10126 } 10127 finally { 10128 exitRule(); 10129 } 10130 return _localctx; 10131 } 10132 10133 public static class OptionTagEndContext extends ParserRuleContext { 10134 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 10135 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 10136 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 10137 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 10138 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10139 public TerminalNode NEWLINE(int i) { 10140 return getToken(JavadocParser.NEWLINE, i); 10141 } 10142 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10143 public TerminalNode LEADING_ASTERISK(int i) { 10144 return getToken(JavadocParser.LEADING_ASTERISK, i); 10145 } 10146 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10147 public TerminalNode WS(int i) { 10148 return getToken(JavadocParser.WS, i); 10149 } 10150 public OptionTagEndContext(ParserRuleContext parent, int invokingState) { 10151 super(parent, invokingState); 10152 } 10153 @Override public int getRuleIndex() { return RULE_optionTagEnd; } 10154 } 10155 10156 public final OptionTagEndContext optionTagEnd() throws RecognitionException { 10157 OptionTagEndContext _localctx = new OptionTagEndContext(_ctx, getState()); 10158 enterRule(_localctx, 80, RULE_optionTagEnd); 10159 int _la; 10160 try { 10161 enterOuterAlt(_localctx, 1); 10162 { 10163 setState(1226); 10164 match(START); 10165 setState(1227); 10166 match(SLASH); 10167 setState(1228); 10168 match(OPTION_HTML_TAG_NAME); 10169 setState(1232); 10170 _errHandler.sync(this); 10171 _la = _input.LA(1); 10172 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 10173 { 10174 { 10175 setState(1229); 10176 _la = _input.LA(1); 10177 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 10178 _errHandler.recoverInline(this); 10179 } 10180 else { 10181 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 10182 _errHandler.reportMatch(this); 10183 consume(); 10184 } 10185 } 10186 } 10187 setState(1234); 10188 _errHandler.sync(this); 10189 _la = _input.LA(1); 10190 } 10191 setState(1235); 10192 match(END); 10193 } 10194 } 10195 catch (RecognitionException re) { 10196 _localctx.exception = re; 10197 _errHandler.reportError(this, re); 10198 _errHandler.recover(this, re); 10199 } 10200 finally { 10201 exitRule(); 10202 } 10203 return _localctx; 10204 } 10205 10206 public static class OptionContext extends ParserRuleContext { 10207 public OptionTagStartContext optionTagStart() { 10208 return getRuleContext(OptionTagStartContext.class,0); 10209 } 10210 public OptionTagEndContext optionTagEnd() { 10211 return getRuleContext(OptionTagEndContext.class,0); 10212 } 10213 public List<HtmlTagContext> htmlTag() { 10214 return getRuleContexts(HtmlTagContext.class); 10215 } 10216 public HtmlTagContext htmlTag(int i) { 10217 return getRuleContext(HtmlTagContext.class,i); 10218 } 10219 public List<SingletonElementContext> singletonElement() { 10220 return getRuleContexts(SingletonElementContext.class); 10221 } 10222 public SingletonElementContext singletonElement(int i) { 10223 return getRuleContext(SingletonElementContext.class,i); 10224 } 10225 public List<ParagraphContext> paragraph() { 10226 return getRuleContexts(ParagraphContext.class); 10227 } 10228 public ParagraphContext paragraph(int i) { 10229 return getRuleContext(ParagraphContext.class,i); 10230 } 10231 public List<LiContext> li() { 10232 return getRuleContexts(LiContext.class); 10233 } 10234 public LiContext li(int i) { 10235 return getRuleContext(LiContext.class,i); 10236 } 10237 public List<TrContext> tr() { 10238 return getRuleContexts(TrContext.class); 10239 } 10240 public TrContext tr(int i) { 10241 return getRuleContext(TrContext.class,i); 10242 } 10243 public List<TdContext> td() { 10244 return getRuleContexts(TdContext.class); 10245 } 10246 public TdContext td(int i) { 10247 return getRuleContext(TdContext.class,i); 10248 } 10249 public List<ThContext> th() { 10250 return getRuleContexts(ThContext.class); 10251 } 10252 public ThContext th(int i) { 10253 return getRuleContext(ThContext.class,i); 10254 } 10255 public List<BodyContext> body() { 10256 return getRuleContexts(BodyContext.class); 10257 } 10258 public BodyContext body(int i) { 10259 return getRuleContext(BodyContext.class,i); 10260 } 10261 public List<ColgroupContext> colgroup() { 10262 return getRuleContexts(ColgroupContext.class); 10263 } 10264 public ColgroupContext colgroup(int i) { 10265 return getRuleContext(ColgroupContext.class,i); 10266 } 10267 public List<DdContext> dd() { 10268 return getRuleContexts(DdContext.class); 10269 } 10270 public DdContext dd(int i) { 10271 return getRuleContext(DdContext.class,i); 10272 } 10273 public List<DtContext> dt() { 10274 return getRuleContexts(DtContext.class); 10275 } 10276 public DtContext dt(int i) { 10277 return getRuleContext(DtContext.class,i); 10278 } 10279 public List<HeadContext> head() { 10280 return getRuleContexts(HeadContext.class); 10281 } 10282 public HeadContext head(int i) { 10283 return getRuleContext(HeadContext.class,i); 10284 } 10285 public List<HtmlContext> html() { 10286 return getRuleContexts(HtmlContext.class); 10287 } 10288 public HtmlContext html(int i) { 10289 return getRuleContext(HtmlContext.class,i); 10290 } 10291 public List<TbodyContext> tbody() { 10292 return getRuleContexts(TbodyContext.class); 10293 } 10294 public TbodyContext tbody(int i) { 10295 return getRuleContext(TbodyContext.class,i); 10296 } 10297 public List<TheadContext> thead() { 10298 return getRuleContexts(TheadContext.class); 10299 } 10300 public TheadContext thead(int i) { 10301 return getRuleContext(TheadContext.class,i); 10302 } 10303 public List<TfootContext> tfoot() { 10304 return getRuleContexts(TfootContext.class); 10305 } 10306 public TfootContext tfoot(int i) { 10307 return getRuleContext(TfootContext.class,i); 10308 } 10309 public List<OptgroupContext> optgroup() { 10310 return getRuleContexts(OptgroupContext.class); 10311 } 10312 public OptgroupContext optgroup(int i) { 10313 return getRuleContext(OptgroupContext.class,i); 10314 } 10315 public List<RbContext> rb() { 10316 return getRuleContexts(RbContext.class); 10317 } 10318 public RbContext rb(int i) { 10319 return getRuleContext(RbContext.class,i); 10320 } 10321 public List<RtContext> rt() { 10322 return getRuleContexts(RtContext.class); 10323 } 10324 public RtContext rt(int i) { 10325 return getRuleContext(RtContext.class,i); 10326 } 10327 public List<RtcContext> rtc() { 10328 return getRuleContexts(RtcContext.class); 10329 } 10330 public RtcContext rtc(int i) { 10331 return getRuleContext(RtcContext.class,i); 10332 } 10333 public List<RpContext> rp() { 10334 return getRuleContexts(RpContext.class); 10335 } 10336 public RpContext rp(int i) { 10337 return getRuleContext(RpContext.class,i); 10338 } 10339 public List<PTagStartContext> pTagStart() { 10340 return getRuleContexts(PTagStartContext.class); 10341 } 10342 public PTagStartContext pTagStart(int i) { 10343 return getRuleContext(PTagStartContext.class,i); 10344 } 10345 public List<LiTagStartContext> liTagStart() { 10346 return getRuleContexts(LiTagStartContext.class); 10347 } 10348 public LiTagStartContext liTagStart(int i) { 10349 return getRuleContext(LiTagStartContext.class,i); 10350 } 10351 public List<TrTagStartContext> trTagStart() { 10352 return getRuleContexts(TrTagStartContext.class); 10353 } 10354 public TrTagStartContext trTagStart(int i) { 10355 return getRuleContext(TrTagStartContext.class,i); 10356 } 10357 public List<TdTagStartContext> tdTagStart() { 10358 return getRuleContexts(TdTagStartContext.class); 10359 } 10360 public TdTagStartContext tdTagStart(int i) { 10361 return getRuleContext(TdTagStartContext.class,i); 10362 } 10363 public List<ThTagStartContext> thTagStart() { 10364 return getRuleContexts(ThTagStartContext.class); 10365 } 10366 public ThTagStartContext thTagStart(int i) { 10367 return getRuleContext(ThTagStartContext.class,i); 10368 } 10369 public List<BodyTagStartContext> bodyTagStart() { 10370 return getRuleContexts(BodyTagStartContext.class); 10371 } 10372 public BodyTagStartContext bodyTagStart(int i) { 10373 return getRuleContext(BodyTagStartContext.class,i); 10374 } 10375 public List<ColgroupTagStartContext> colgroupTagStart() { 10376 return getRuleContexts(ColgroupTagStartContext.class); 10377 } 10378 public ColgroupTagStartContext colgroupTagStart(int i) { 10379 return getRuleContext(ColgroupTagStartContext.class,i); 10380 } 10381 public List<DdTagStartContext> ddTagStart() { 10382 return getRuleContexts(DdTagStartContext.class); 10383 } 10384 public DdTagStartContext ddTagStart(int i) { 10385 return getRuleContext(DdTagStartContext.class,i); 10386 } 10387 public List<DtTagStartContext> dtTagStart() { 10388 return getRuleContexts(DtTagStartContext.class); 10389 } 10390 public DtTagStartContext dtTagStart(int i) { 10391 return getRuleContext(DtTagStartContext.class,i); 10392 } 10393 public List<HeadTagStartContext> headTagStart() { 10394 return getRuleContexts(HeadTagStartContext.class); 10395 } 10396 public HeadTagStartContext headTagStart(int i) { 10397 return getRuleContext(HeadTagStartContext.class,i); 10398 } 10399 public List<HtmlTagStartContext> htmlTagStart() { 10400 return getRuleContexts(HtmlTagStartContext.class); 10401 } 10402 public HtmlTagStartContext htmlTagStart(int i) { 10403 return getRuleContext(HtmlTagStartContext.class,i); 10404 } 10405 public List<TbodyTagStartContext> tbodyTagStart() { 10406 return getRuleContexts(TbodyTagStartContext.class); 10407 } 10408 public TbodyTagStartContext tbodyTagStart(int i) { 10409 return getRuleContext(TbodyTagStartContext.class,i); 10410 } 10411 public List<TheadTagStartContext> theadTagStart() { 10412 return getRuleContexts(TheadTagStartContext.class); 10413 } 10414 public TheadTagStartContext theadTagStart(int i) { 10415 return getRuleContext(TheadTagStartContext.class,i); 10416 } 10417 public List<TfootTagStartContext> tfootTagStart() { 10418 return getRuleContexts(TfootTagStartContext.class); 10419 } 10420 public TfootTagStartContext tfootTagStart(int i) { 10421 return getRuleContext(TfootTagStartContext.class,i); 10422 } 10423 public List<OptgroupTagStartContext> optgroupTagStart() { 10424 return getRuleContexts(OptgroupTagStartContext.class); 10425 } 10426 public OptgroupTagStartContext optgroupTagStart(int i) { 10427 return getRuleContext(OptgroupTagStartContext.class,i); 10428 } 10429 public List<RbTagStartContext> rbTagStart() { 10430 return getRuleContexts(RbTagStartContext.class); 10431 } 10432 public RbTagStartContext rbTagStart(int i) { 10433 return getRuleContext(RbTagStartContext.class,i); 10434 } 10435 public List<RtTagStartContext> rtTagStart() { 10436 return getRuleContexts(RtTagStartContext.class); 10437 } 10438 public RtTagStartContext rtTagStart(int i) { 10439 return getRuleContext(RtTagStartContext.class,i); 10440 } 10441 public List<RtcTagStartContext> rtcTagStart() { 10442 return getRuleContexts(RtcTagStartContext.class); 10443 } 10444 public RtcTagStartContext rtcTagStart(int i) { 10445 return getRuleContext(RtcTagStartContext.class,i); 10446 } 10447 public List<RpTagStartContext> rpTagStart() { 10448 return getRuleContexts(RpTagStartContext.class); 10449 } 10450 public RpTagStartContext rpTagStart(int i) { 10451 return getRuleContext(RpTagStartContext.class,i); 10452 } 10453 public List<HtmlCommentContext> htmlComment() { 10454 return getRuleContexts(HtmlCommentContext.class); 10455 } 10456 public HtmlCommentContext htmlComment(int i) { 10457 return getRuleContext(HtmlCommentContext.class,i); 10458 } 10459 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10460 public TerminalNode CDATA(int i) { 10461 return getToken(JavadocParser.CDATA, i); 10462 } 10463 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10464 public TerminalNode NEWLINE(int i) { 10465 return getToken(JavadocParser.NEWLINE, i); 10466 } 10467 public List<TextContext> text() { 10468 return getRuleContexts(TextContext.class); 10469 } 10470 public TextContext text(int i) { 10471 return getRuleContext(TextContext.class,i); 10472 } 10473 public List<JavadocInlineTagContext> javadocInlineTag() { 10474 return getRuleContexts(JavadocInlineTagContext.class); 10475 } 10476 public JavadocInlineTagContext javadocInlineTag(int i) { 10477 return getRuleContext(JavadocInlineTagContext.class,i); 10478 } 10479 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10480 public TerminalNode LEADING_ASTERISK(int i) { 10481 return getToken(JavadocParser.LEADING_ASTERISK, i); 10482 } 10483 public OptionContext(ParserRuleContext parent, int invokingState) { 10484 super(parent, invokingState); 10485 } 10486 @Override public int getRuleIndex() { return RULE_option; } 10487 } 10488 10489 public final OptionContext option() throws RecognitionException { 10490 OptionContext _localctx = new OptionContext(_ctx, getState()); 10491 enterRule(_localctx, 82, RULE_option); 10492 try { 10493 int _alt; 10494 enterOuterAlt(_localctx, 1); 10495 { 10496 setState(1237); 10497 optionTagStart(false); 10498 setState(1287); 10499 _errHandler.sync(this); 10500 _alt = getInterpreter().adaptivePredict(_input,73,_ctx); 10501 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10502 if ( _alt==1 ) { 10503 { 10504 setState(1285); 10505 _errHandler.sync(this); 10506 switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) { 10507 case 1: 10508 { 10509 setState(1238); 10510 htmlTag(); 10511 } 10512 break; 10513 case 2: 10514 { 10515 setState(1239); 10516 singletonElement(); 10517 } 10518 break; 10519 case 3: 10520 { 10521 setState(1240); 10522 paragraph(); 10523 } 10524 break; 10525 case 4: 10526 { 10527 setState(1241); 10528 li(); 10529 } 10530 break; 10531 case 5: 10532 { 10533 setState(1242); 10534 tr(); 10535 } 10536 break; 10537 case 6: 10538 { 10539 setState(1243); 10540 td(); 10541 } 10542 break; 10543 case 7: 10544 { 10545 setState(1244); 10546 th(); 10547 } 10548 break; 10549 case 8: 10550 { 10551 setState(1245); 10552 body(); 10553 } 10554 break; 10555 case 9: 10556 { 10557 setState(1246); 10558 colgroup(); 10559 } 10560 break; 10561 case 10: 10562 { 10563 setState(1247); 10564 dd(); 10565 } 10566 break; 10567 case 11: 10568 { 10569 setState(1248); 10570 dt(); 10571 } 10572 break; 10573 case 12: 10574 { 10575 setState(1249); 10576 head(); 10577 } 10578 break; 10579 case 13: 10580 { 10581 setState(1250); 10582 html(); 10583 } 10584 break; 10585 case 14: 10586 { 10587 setState(1251); 10588 tbody(); 10589 } 10590 break; 10591 case 15: 10592 { 10593 setState(1252); 10594 thead(); 10595 } 10596 break; 10597 case 16: 10598 { 10599 setState(1253); 10600 tfoot(); 10601 } 10602 break; 10603 case 17: 10604 { 10605 setState(1254); 10606 optgroup(); 10607 } 10608 break; 10609 case 18: 10610 { 10611 setState(1255); 10612 rb(); 10613 } 10614 break; 10615 case 19: 10616 { 10617 setState(1256); 10618 rt(); 10619 } 10620 break; 10621 case 20: 10622 { 10623 setState(1257); 10624 rtc(); 10625 } 10626 break; 10627 case 21: 10628 { 10629 setState(1258); 10630 rp(); 10631 } 10632 break; 10633 case 22: 10634 { 10635 setState(1259); 10636 pTagStart(true); 10637 } 10638 break; 10639 case 23: 10640 { 10641 setState(1260); 10642 liTagStart(true); 10643 } 10644 break; 10645 case 24: 10646 { 10647 setState(1261); 10648 trTagStart(true); 10649 } 10650 break; 10651 case 25: 10652 { 10653 setState(1262); 10654 tdTagStart(true); 10655 } 10656 break; 10657 case 26: 10658 { 10659 setState(1263); 10660 thTagStart(true); 10661 } 10662 break; 10663 case 27: 10664 { 10665 setState(1264); 10666 bodyTagStart(true); 10667 } 10668 break; 10669 case 28: 10670 { 10671 setState(1265); 10672 colgroupTagStart(true); 10673 } 10674 break; 10675 case 29: 10676 { 10677 setState(1266); 10678 ddTagStart(true); 10679 } 10680 break; 10681 case 30: 10682 { 10683 setState(1267); 10684 dtTagStart(true); 10685 } 10686 break; 10687 case 31: 10688 { 10689 setState(1268); 10690 headTagStart(true); 10691 } 10692 break; 10693 case 32: 10694 { 10695 setState(1269); 10696 htmlTagStart(true); 10697 } 10698 break; 10699 case 33: 10700 { 10701 setState(1270); 10702 tbodyTagStart(true); 10703 } 10704 break; 10705 case 34: 10706 { 10707 setState(1271); 10708 theadTagStart(true); 10709 } 10710 break; 10711 case 35: 10712 { 10713 setState(1272); 10714 tfootTagStart(true); 10715 } 10716 break; 10717 case 36: 10718 { 10719 setState(1273); 10720 optgroupTagStart(true); 10721 } 10722 break; 10723 case 37: 10724 { 10725 setState(1274); 10726 rbTagStart(true); 10727 } 10728 break; 10729 case 38: 10730 { 10731 setState(1275); 10732 rtTagStart(true); 10733 } 10734 break; 10735 case 39: 10736 { 10737 setState(1276); 10738 rtcTagStart(true); 10739 } 10740 break; 10741 case 40: 10742 { 10743 setState(1277); 10744 rpTagStart(true); 10745 } 10746 break; 10747 case 41: 10748 { 10749 { 10750 setState(1278); 10751 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 10752 setState(1279); 10753 match(LEADING_ASTERISK); 10754 } 10755 } 10756 break; 10757 case 42: 10758 { 10759 setState(1280); 10760 htmlComment(); 10761 } 10762 break; 10763 case 43: 10764 { 10765 setState(1281); 10766 match(CDATA); 10767 } 10768 break; 10769 case 44: 10770 { 10771 setState(1282); 10772 match(NEWLINE); 10773 } 10774 break; 10775 case 45: 10776 { 10777 setState(1283); 10778 text(); 10779 } 10780 break; 10781 case 46: 10782 { 10783 setState(1284); 10784 javadocInlineTag(); 10785 } 10786 break; 10787 } 10788 } 10789 } 10790 setState(1289); 10791 _errHandler.sync(this); 10792 _alt = getInterpreter().adaptivePredict(_input,73,_ctx); 10793 } 10794 setState(1290); 10795 optionTagEnd(); 10796 } 10797 } 10798 catch (RecognitionException re) { 10799 _localctx.exception = re; 10800 _errHandler.reportError(this, re); 10801 _errHandler.recover(this, re); 10802 } 10803 finally { 10804 exitRule(); 10805 } 10806 return _localctx; 10807 } 10808 10809 public static class TbodyTagStartContext extends ParserRuleContext { 10810 public boolean isNonTight; 10811 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 10812 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 10813 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 10814 public List<AttributeContext> attribute() { 10815 return getRuleContexts(AttributeContext.class); 10816 } 10817 public AttributeContext attribute(int i) { 10818 return getRuleContext(AttributeContext.class,i); 10819 } 10820 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10821 public TerminalNode NEWLINE(int i) { 10822 return getToken(JavadocParser.NEWLINE, i); 10823 } 10824 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10825 public TerminalNode LEADING_ASTERISK(int i) { 10826 return getToken(JavadocParser.LEADING_ASTERISK, i); 10827 } 10828 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10829 public TerminalNode WS(int i) { 10830 return getToken(JavadocParser.WS, i); 10831 } 10832 public TbodyTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 10833 public TbodyTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 10834 super(parent, invokingState); 10835 this.isNonTight = isNonTight; 10836 } 10837 @Override public int getRuleIndex() { return RULE_tbodyTagStart; } 10838 } 10839 10840 public final TbodyTagStartContext tbodyTagStart(boolean isNonTight) throws RecognitionException { 10841 TbodyTagStartContext _localctx = new TbodyTagStartContext(_ctx, getState(), isNonTight); 10842 enterRule(_localctx, 84, RULE_tbodyTagStart); 10843 int _la; 10844 try { 10845 enterOuterAlt(_localctx, 1); 10846 { 10847 setState(1292); 10848 match(START); 10849 setState(1293); 10850 match(TBODY_HTML_TAG_NAME); 10851 setState(1300); 10852 _errHandler.sync(this); 10853 _la = _input.LA(1); 10854 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 10855 { 10856 setState(1298); 10857 _errHandler.sync(this); 10858 switch (_input.LA(1)) { 10859 case HTML_TAG_NAME: 10860 { 10861 setState(1294); 10862 attribute(); 10863 } 10864 break; 10865 case NEWLINE: 10866 { 10867 setState(1295); 10868 match(NEWLINE); 10869 } 10870 break; 10871 case LEADING_ASTERISK: 10872 { 10873 setState(1296); 10874 match(LEADING_ASTERISK); 10875 } 10876 break; 10877 case WS: 10878 { 10879 setState(1297); 10880 match(WS); 10881 } 10882 break; 10883 default: 10884 throw new NoViableAltException(this); 10885 } 10886 } 10887 setState(1302); 10888 _errHandler.sync(this); 10889 _la = _input.LA(1); 10890 } 10891 setState(1303); 10892 match(END); 10893 } 10894 _ctx.stop = _input.LT(-1); 10895 10896 if (isNonTight && nonTightTagStartContext == null) { 10897 nonTightTagStartContext = _localctx; 10898 } 10899 10900 } 10901 catch (RecognitionException re) { 10902 _localctx.exception = re; 10903 _errHandler.reportError(this, re); 10904 _errHandler.recover(this, re); 10905 } 10906 finally { 10907 exitRule(); 10908 } 10909 return _localctx; 10910 } 10911 10912 public static class TbodyTagEndContext extends ParserRuleContext { 10913 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 10914 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 10915 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 10916 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 10917 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10918 public TerminalNode NEWLINE(int i) { 10919 return getToken(JavadocParser.NEWLINE, i); 10920 } 10921 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10922 public TerminalNode LEADING_ASTERISK(int i) { 10923 return getToken(JavadocParser.LEADING_ASTERISK, i); 10924 } 10925 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10926 public TerminalNode WS(int i) { 10927 return getToken(JavadocParser.WS, i); 10928 } 10929 public TbodyTagEndContext(ParserRuleContext parent, int invokingState) { 10930 super(parent, invokingState); 10931 } 10932 @Override public int getRuleIndex() { return RULE_tbodyTagEnd; } 10933 } 10934 10935 public final TbodyTagEndContext tbodyTagEnd() throws RecognitionException { 10936 TbodyTagEndContext _localctx = new TbodyTagEndContext(_ctx, getState()); 10937 enterRule(_localctx, 86, RULE_tbodyTagEnd); 10938 int _la; 10939 try { 10940 enterOuterAlt(_localctx, 1); 10941 { 10942 setState(1305); 10943 match(START); 10944 setState(1306); 10945 match(SLASH); 10946 setState(1307); 10947 match(TBODY_HTML_TAG_NAME); 10948 setState(1311); 10949 _errHandler.sync(this); 10950 _la = _input.LA(1); 10951 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 10952 { 10953 { 10954 setState(1308); 10955 _la = _input.LA(1); 10956 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 10957 _errHandler.recoverInline(this); 10958 } 10959 else { 10960 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 10961 _errHandler.reportMatch(this); 10962 consume(); 10963 } 10964 } 10965 } 10966 setState(1313); 10967 _errHandler.sync(this); 10968 _la = _input.LA(1); 10969 } 10970 setState(1314); 10971 match(END); 10972 } 10973 } 10974 catch (RecognitionException re) { 10975 _localctx.exception = re; 10976 _errHandler.reportError(this, re); 10977 _errHandler.recover(this, re); 10978 } 10979 finally { 10980 exitRule(); 10981 } 10982 return _localctx; 10983 } 10984 10985 public static class TbodyContext extends ParserRuleContext { 10986 public TbodyTagStartContext tbodyTagStart() { 10987 return getRuleContext(TbodyTagStartContext.class,0); 10988 } 10989 public TbodyTagEndContext tbodyTagEnd() { 10990 return getRuleContext(TbodyTagEndContext.class,0); 10991 } 10992 public List<HtmlTagContext> htmlTag() { 10993 return getRuleContexts(HtmlTagContext.class); 10994 } 10995 public HtmlTagContext htmlTag(int i) { 10996 return getRuleContext(HtmlTagContext.class,i); 10997 } 10998 public List<SingletonElementContext> singletonElement() { 10999 return getRuleContexts(SingletonElementContext.class); 11000 } 11001 public SingletonElementContext singletonElement(int i) { 11002 return getRuleContext(SingletonElementContext.class,i); 11003 } 11004 public List<ParagraphContext> paragraph() { 11005 return getRuleContexts(ParagraphContext.class); 11006 } 11007 public ParagraphContext paragraph(int i) { 11008 return getRuleContext(ParagraphContext.class,i); 11009 } 11010 public List<LiContext> li() { 11011 return getRuleContexts(LiContext.class); 11012 } 11013 public LiContext li(int i) { 11014 return getRuleContext(LiContext.class,i); 11015 } 11016 public List<TrContext> tr() { 11017 return getRuleContexts(TrContext.class); 11018 } 11019 public TrContext tr(int i) { 11020 return getRuleContext(TrContext.class,i); 11021 } 11022 public List<TdContext> td() { 11023 return getRuleContexts(TdContext.class); 11024 } 11025 public TdContext td(int i) { 11026 return getRuleContext(TdContext.class,i); 11027 } 11028 public List<ThContext> th() { 11029 return getRuleContexts(ThContext.class); 11030 } 11031 public ThContext th(int i) { 11032 return getRuleContext(ThContext.class,i); 11033 } 11034 public List<BodyContext> body() { 11035 return getRuleContexts(BodyContext.class); 11036 } 11037 public BodyContext body(int i) { 11038 return getRuleContext(BodyContext.class,i); 11039 } 11040 public List<ColgroupContext> colgroup() { 11041 return getRuleContexts(ColgroupContext.class); 11042 } 11043 public ColgroupContext colgroup(int i) { 11044 return getRuleContext(ColgroupContext.class,i); 11045 } 11046 public List<DdContext> dd() { 11047 return getRuleContexts(DdContext.class); 11048 } 11049 public DdContext dd(int i) { 11050 return getRuleContext(DdContext.class,i); 11051 } 11052 public List<DtContext> dt() { 11053 return getRuleContexts(DtContext.class); 11054 } 11055 public DtContext dt(int i) { 11056 return getRuleContext(DtContext.class,i); 11057 } 11058 public List<HeadContext> head() { 11059 return getRuleContexts(HeadContext.class); 11060 } 11061 public HeadContext head(int i) { 11062 return getRuleContext(HeadContext.class,i); 11063 } 11064 public List<HtmlContext> html() { 11065 return getRuleContexts(HtmlContext.class); 11066 } 11067 public HtmlContext html(int i) { 11068 return getRuleContext(HtmlContext.class,i); 11069 } 11070 public List<OptionContext> option() { 11071 return getRuleContexts(OptionContext.class); 11072 } 11073 public OptionContext option(int i) { 11074 return getRuleContext(OptionContext.class,i); 11075 } 11076 public List<TheadContext> thead() { 11077 return getRuleContexts(TheadContext.class); 11078 } 11079 public TheadContext thead(int i) { 11080 return getRuleContext(TheadContext.class,i); 11081 } 11082 public List<TfootContext> tfoot() { 11083 return getRuleContexts(TfootContext.class); 11084 } 11085 public TfootContext tfoot(int i) { 11086 return getRuleContext(TfootContext.class,i); 11087 } 11088 public List<OptgroupContext> optgroup() { 11089 return getRuleContexts(OptgroupContext.class); 11090 } 11091 public OptgroupContext optgroup(int i) { 11092 return getRuleContext(OptgroupContext.class,i); 11093 } 11094 public List<RbContext> rb() { 11095 return getRuleContexts(RbContext.class); 11096 } 11097 public RbContext rb(int i) { 11098 return getRuleContext(RbContext.class,i); 11099 } 11100 public List<RtContext> rt() { 11101 return getRuleContexts(RtContext.class); 11102 } 11103 public RtContext rt(int i) { 11104 return getRuleContext(RtContext.class,i); 11105 } 11106 public List<RtcContext> rtc() { 11107 return getRuleContexts(RtcContext.class); 11108 } 11109 public RtcContext rtc(int i) { 11110 return getRuleContext(RtcContext.class,i); 11111 } 11112 public List<RpContext> rp() { 11113 return getRuleContexts(RpContext.class); 11114 } 11115 public RpContext rp(int i) { 11116 return getRuleContext(RpContext.class,i); 11117 } 11118 public List<PTagStartContext> pTagStart() { 11119 return getRuleContexts(PTagStartContext.class); 11120 } 11121 public PTagStartContext pTagStart(int i) { 11122 return getRuleContext(PTagStartContext.class,i); 11123 } 11124 public List<LiTagStartContext> liTagStart() { 11125 return getRuleContexts(LiTagStartContext.class); 11126 } 11127 public LiTagStartContext liTagStart(int i) { 11128 return getRuleContext(LiTagStartContext.class,i); 11129 } 11130 public List<TrTagStartContext> trTagStart() { 11131 return getRuleContexts(TrTagStartContext.class); 11132 } 11133 public TrTagStartContext trTagStart(int i) { 11134 return getRuleContext(TrTagStartContext.class,i); 11135 } 11136 public List<TdTagStartContext> tdTagStart() { 11137 return getRuleContexts(TdTagStartContext.class); 11138 } 11139 public TdTagStartContext tdTagStart(int i) { 11140 return getRuleContext(TdTagStartContext.class,i); 11141 } 11142 public List<ThTagStartContext> thTagStart() { 11143 return getRuleContexts(ThTagStartContext.class); 11144 } 11145 public ThTagStartContext thTagStart(int i) { 11146 return getRuleContext(ThTagStartContext.class,i); 11147 } 11148 public List<BodyTagStartContext> bodyTagStart() { 11149 return getRuleContexts(BodyTagStartContext.class); 11150 } 11151 public BodyTagStartContext bodyTagStart(int i) { 11152 return getRuleContext(BodyTagStartContext.class,i); 11153 } 11154 public List<ColgroupTagStartContext> colgroupTagStart() { 11155 return getRuleContexts(ColgroupTagStartContext.class); 11156 } 11157 public ColgroupTagStartContext colgroupTagStart(int i) { 11158 return getRuleContext(ColgroupTagStartContext.class,i); 11159 } 11160 public List<DdTagStartContext> ddTagStart() { 11161 return getRuleContexts(DdTagStartContext.class); 11162 } 11163 public DdTagStartContext ddTagStart(int i) { 11164 return getRuleContext(DdTagStartContext.class,i); 11165 } 11166 public List<DtTagStartContext> dtTagStart() { 11167 return getRuleContexts(DtTagStartContext.class); 11168 } 11169 public DtTagStartContext dtTagStart(int i) { 11170 return getRuleContext(DtTagStartContext.class,i); 11171 } 11172 public List<HeadTagStartContext> headTagStart() { 11173 return getRuleContexts(HeadTagStartContext.class); 11174 } 11175 public HeadTagStartContext headTagStart(int i) { 11176 return getRuleContext(HeadTagStartContext.class,i); 11177 } 11178 public List<HtmlTagStartContext> htmlTagStart() { 11179 return getRuleContexts(HtmlTagStartContext.class); 11180 } 11181 public HtmlTagStartContext htmlTagStart(int i) { 11182 return getRuleContext(HtmlTagStartContext.class,i); 11183 } 11184 public List<OptionTagStartContext> optionTagStart() { 11185 return getRuleContexts(OptionTagStartContext.class); 11186 } 11187 public OptionTagStartContext optionTagStart(int i) { 11188 return getRuleContext(OptionTagStartContext.class,i); 11189 } 11190 public List<TheadTagStartContext> theadTagStart() { 11191 return getRuleContexts(TheadTagStartContext.class); 11192 } 11193 public TheadTagStartContext theadTagStart(int i) { 11194 return getRuleContext(TheadTagStartContext.class,i); 11195 } 11196 public List<TfootTagStartContext> tfootTagStart() { 11197 return getRuleContexts(TfootTagStartContext.class); 11198 } 11199 public TfootTagStartContext tfootTagStart(int i) { 11200 return getRuleContext(TfootTagStartContext.class,i); 11201 } 11202 public List<OptgroupTagStartContext> optgroupTagStart() { 11203 return getRuleContexts(OptgroupTagStartContext.class); 11204 } 11205 public OptgroupTagStartContext optgroupTagStart(int i) { 11206 return getRuleContext(OptgroupTagStartContext.class,i); 11207 } 11208 public List<RbTagStartContext> rbTagStart() { 11209 return getRuleContexts(RbTagStartContext.class); 11210 } 11211 public RbTagStartContext rbTagStart(int i) { 11212 return getRuleContext(RbTagStartContext.class,i); 11213 } 11214 public List<RtTagStartContext> rtTagStart() { 11215 return getRuleContexts(RtTagStartContext.class); 11216 } 11217 public RtTagStartContext rtTagStart(int i) { 11218 return getRuleContext(RtTagStartContext.class,i); 11219 } 11220 public List<RtcTagStartContext> rtcTagStart() { 11221 return getRuleContexts(RtcTagStartContext.class); 11222 } 11223 public RtcTagStartContext rtcTagStart(int i) { 11224 return getRuleContext(RtcTagStartContext.class,i); 11225 } 11226 public List<RpTagStartContext> rpTagStart() { 11227 return getRuleContexts(RpTagStartContext.class); 11228 } 11229 public RpTagStartContext rpTagStart(int i) { 11230 return getRuleContext(RpTagStartContext.class,i); 11231 } 11232 public List<HtmlCommentContext> htmlComment() { 11233 return getRuleContexts(HtmlCommentContext.class); 11234 } 11235 public HtmlCommentContext htmlComment(int i) { 11236 return getRuleContext(HtmlCommentContext.class,i); 11237 } 11238 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 11239 public TerminalNode CDATA(int i) { 11240 return getToken(JavadocParser.CDATA, i); 11241 } 11242 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11243 public TerminalNode NEWLINE(int i) { 11244 return getToken(JavadocParser.NEWLINE, i); 11245 } 11246 public List<TextContext> text() { 11247 return getRuleContexts(TextContext.class); 11248 } 11249 public TextContext text(int i) { 11250 return getRuleContext(TextContext.class,i); 11251 } 11252 public List<JavadocInlineTagContext> javadocInlineTag() { 11253 return getRuleContexts(JavadocInlineTagContext.class); 11254 } 11255 public JavadocInlineTagContext javadocInlineTag(int i) { 11256 return getRuleContext(JavadocInlineTagContext.class,i); 11257 } 11258 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11259 public TerminalNode LEADING_ASTERISK(int i) { 11260 return getToken(JavadocParser.LEADING_ASTERISK, i); 11261 } 11262 public TbodyContext(ParserRuleContext parent, int invokingState) { 11263 super(parent, invokingState); 11264 } 11265 @Override public int getRuleIndex() { return RULE_tbody; } 11266 } 11267 11268 public final TbodyContext tbody() throws RecognitionException { 11269 TbodyContext _localctx = new TbodyContext(_ctx, getState()); 11270 enterRule(_localctx, 88, RULE_tbody); 11271 try { 11272 int _alt; 11273 enterOuterAlt(_localctx, 1); 11274 { 11275 setState(1316); 11276 tbodyTagStart(false); 11277 setState(1366); 11278 _errHandler.sync(this); 11279 _alt = getInterpreter().adaptivePredict(_input,78,_ctx); 11280 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 11281 if ( _alt==1 ) { 11282 { 11283 setState(1364); 11284 _errHandler.sync(this); 11285 switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) { 11286 case 1: 11287 { 11288 setState(1317); 11289 htmlTag(); 11290 } 11291 break; 11292 case 2: 11293 { 11294 setState(1318); 11295 singletonElement(); 11296 } 11297 break; 11298 case 3: 11299 { 11300 setState(1319); 11301 paragraph(); 11302 } 11303 break; 11304 case 4: 11305 { 11306 setState(1320); 11307 li(); 11308 } 11309 break; 11310 case 5: 11311 { 11312 setState(1321); 11313 tr(); 11314 } 11315 break; 11316 case 6: 11317 { 11318 setState(1322); 11319 td(); 11320 } 11321 break; 11322 case 7: 11323 { 11324 setState(1323); 11325 th(); 11326 } 11327 break; 11328 case 8: 11329 { 11330 setState(1324); 11331 body(); 11332 } 11333 break; 11334 case 9: 11335 { 11336 setState(1325); 11337 colgroup(); 11338 } 11339 break; 11340 case 10: 11341 { 11342 setState(1326); 11343 dd(); 11344 } 11345 break; 11346 case 11: 11347 { 11348 setState(1327); 11349 dt(); 11350 } 11351 break; 11352 case 12: 11353 { 11354 setState(1328); 11355 head(); 11356 } 11357 break; 11358 case 13: 11359 { 11360 setState(1329); 11361 html(); 11362 } 11363 break; 11364 case 14: 11365 { 11366 setState(1330); 11367 option(); 11368 } 11369 break; 11370 case 15: 11371 { 11372 setState(1331); 11373 thead(); 11374 } 11375 break; 11376 case 16: 11377 { 11378 setState(1332); 11379 tfoot(); 11380 } 11381 break; 11382 case 17: 11383 { 11384 setState(1333); 11385 optgroup(); 11386 } 11387 break; 11388 case 18: 11389 { 11390 setState(1334); 11391 rb(); 11392 } 11393 break; 11394 case 19: 11395 { 11396 setState(1335); 11397 rt(); 11398 } 11399 break; 11400 case 20: 11401 { 11402 setState(1336); 11403 rtc(); 11404 } 11405 break; 11406 case 21: 11407 { 11408 setState(1337); 11409 rp(); 11410 } 11411 break; 11412 case 22: 11413 { 11414 setState(1338); 11415 pTagStart(true); 11416 } 11417 break; 11418 case 23: 11419 { 11420 setState(1339); 11421 liTagStart(true); 11422 } 11423 break; 11424 case 24: 11425 { 11426 setState(1340); 11427 trTagStart(true); 11428 } 11429 break; 11430 case 25: 11431 { 11432 setState(1341); 11433 tdTagStart(true); 11434 } 11435 break; 11436 case 26: 11437 { 11438 setState(1342); 11439 thTagStart(true); 11440 } 11441 break; 11442 case 27: 11443 { 11444 setState(1343); 11445 bodyTagStart(true); 11446 } 11447 break; 11448 case 28: 11449 { 11450 setState(1344); 11451 colgroupTagStart(true); 11452 } 11453 break; 11454 case 29: 11455 { 11456 setState(1345); 11457 ddTagStart(true); 11458 } 11459 break; 11460 case 30: 11461 { 11462 setState(1346); 11463 dtTagStart(true); 11464 } 11465 break; 11466 case 31: 11467 { 11468 setState(1347); 11469 headTagStart(true); 11470 } 11471 break; 11472 case 32: 11473 { 11474 setState(1348); 11475 htmlTagStart(true); 11476 } 11477 break; 11478 case 33: 11479 { 11480 setState(1349); 11481 optionTagStart(true); 11482 } 11483 break; 11484 case 34: 11485 { 11486 setState(1350); 11487 theadTagStart(true); 11488 } 11489 break; 11490 case 35: 11491 { 11492 setState(1351); 11493 tfootTagStart(true); 11494 } 11495 break; 11496 case 36: 11497 { 11498 setState(1352); 11499 optgroupTagStart(true); 11500 } 11501 break; 11502 case 37: 11503 { 11504 setState(1353); 11505 rbTagStart(true); 11506 } 11507 break; 11508 case 38: 11509 { 11510 setState(1354); 11511 rtTagStart(true); 11512 } 11513 break; 11514 case 39: 11515 { 11516 setState(1355); 11517 rtcTagStart(true); 11518 } 11519 break; 11520 case 40: 11521 { 11522 setState(1356); 11523 rpTagStart(true); 11524 } 11525 break; 11526 case 41: 11527 { 11528 { 11529 setState(1357); 11530 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 11531 setState(1358); 11532 match(LEADING_ASTERISK); 11533 } 11534 } 11535 break; 11536 case 42: 11537 { 11538 setState(1359); 11539 htmlComment(); 11540 } 11541 break; 11542 case 43: 11543 { 11544 setState(1360); 11545 match(CDATA); 11546 } 11547 break; 11548 case 44: 11549 { 11550 setState(1361); 11551 match(NEWLINE); 11552 } 11553 break; 11554 case 45: 11555 { 11556 setState(1362); 11557 text(); 11558 } 11559 break; 11560 case 46: 11561 { 11562 setState(1363); 11563 javadocInlineTag(); 11564 } 11565 break; 11566 } 11567 } 11568 } 11569 setState(1368); 11570 _errHandler.sync(this); 11571 _alt = getInterpreter().adaptivePredict(_input,78,_ctx); 11572 } 11573 setState(1369); 11574 tbodyTagEnd(); 11575 } 11576 } 11577 catch (RecognitionException re) { 11578 _localctx.exception = re; 11579 _errHandler.reportError(this, re); 11580 _errHandler.recover(this, re); 11581 } 11582 finally { 11583 exitRule(); 11584 } 11585 return _localctx; 11586 } 11587 11588 public static class TfootTagStartContext extends ParserRuleContext { 11589 public boolean isNonTight; 11590 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 11591 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 11592 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 11593 public List<AttributeContext> attribute() { 11594 return getRuleContexts(AttributeContext.class); 11595 } 11596 public AttributeContext attribute(int i) { 11597 return getRuleContext(AttributeContext.class,i); 11598 } 11599 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11600 public TerminalNode NEWLINE(int i) { 11601 return getToken(JavadocParser.NEWLINE, i); 11602 } 11603 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11604 public TerminalNode LEADING_ASTERISK(int i) { 11605 return getToken(JavadocParser.LEADING_ASTERISK, i); 11606 } 11607 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11608 public TerminalNode WS(int i) { 11609 return getToken(JavadocParser.WS, i); 11610 } 11611 public TfootTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 11612 public TfootTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 11613 super(parent, invokingState); 11614 this.isNonTight = isNonTight; 11615 } 11616 @Override public int getRuleIndex() { return RULE_tfootTagStart; } 11617 } 11618 11619 public final TfootTagStartContext tfootTagStart(boolean isNonTight) throws RecognitionException { 11620 TfootTagStartContext _localctx = new TfootTagStartContext(_ctx, getState(), isNonTight); 11621 enterRule(_localctx, 90, RULE_tfootTagStart); 11622 int _la; 11623 try { 11624 enterOuterAlt(_localctx, 1); 11625 { 11626 setState(1371); 11627 match(START); 11628 setState(1372); 11629 match(TFOOT_HTML_TAG_NAME); 11630 setState(1379); 11631 _errHandler.sync(this); 11632 _la = _input.LA(1); 11633 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11634 { 11635 setState(1377); 11636 _errHandler.sync(this); 11637 switch (_input.LA(1)) { 11638 case HTML_TAG_NAME: 11639 { 11640 setState(1373); 11641 attribute(); 11642 } 11643 break; 11644 case NEWLINE: 11645 { 11646 setState(1374); 11647 match(NEWLINE); 11648 } 11649 break; 11650 case LEADING_ASTERISK: 11651 { 11652 setState(1375); 11653 match(LEADING_ASTERISK); 11654 } 11655 break; 11656 case WS: 11657 { 11658 setState(1376); 11659 match(WS); 11660 } 11661 break; 11662 default: 11663 throw new NoViableAltException(this); 11664 } 11665 } 11666 setState(1381); 11667 _errHandler.sync(this); 11668 _la = _input.LA(1); 11669 } 11670 setState(1382); 11671 match(END); 11672 } 11673 _ctx.stop = _input.LT(-1); 11674 11675 if (isNonTight && nonTightTagStartContext == null) { 11676 nonTightTagStartContext = _localctx; 11677 } 11678 11679 } 11680 catch (RecognitionException re) { 11681 _localctx.exception = re; 11682 _errHandler.reportError(this, re); 11683 _errHandler.recover(this, re); 11684 } 11685 finally { 11686 exitRule(); 11687 } 11688 return _localctx; 11689 } 11690 11691 public static class TfootTagEndContext extends ParserRuleContext { 11692 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 11693 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 11694 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 11695 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 11696 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11697 public TerminalNode NEWLINE(int i) { 11698 return getToken(JavadocParser.NEWLINE, i); 11699 } 11700 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11701 public TerminalNode LEADING_ASTERISK(int i) { 11702 return getToken(JavadocParser.LEADING_ASTERISK, i); 11703 } 11704 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11705 public TerminalNode WS(int i) { 11706 return getToken(JavadocParser.WS, i); 11707 } 11708 public TfootTagEndContext(ParserRuleContext parent, int invokingState) { 11709 super(parent, invokingState); 11710 } 11711 @Override public int getRuleIndex() { return RULE_tfootTagEnd; } 11712 } 11713 11714 public final TfootTagEndContext tfootTagEnd() throws RecognitionException { 11715 TfootTagEndContext _localctx = new TfootTagEndContext(_ctx, getState()); 11716 enterRule(_localctx, 92, RULE_tfootTagEnd); 11717 int _la; 11718 try { 11719 enterOuterAlt(_localctx, 1); 11720 { 11721 setState(1384); 11722 match(START); 11723 setState(1385); 11724 match(SLASH); 11725 setState(1386); 11726 match(TFOOT_HTML_TAG_NAME); 11727 setState(1390); 11728 _errHandler.sync(this); 11729 _la = _input.LA(1); 11730 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 11731 { 11732 { 11733 setState(1387); 11734 _la = _input.LA(1); 11735 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 11736 _errHandler.recoverInline(this); 11737 } 11738 else { 11739 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 11740 _errHandler.reportMatch(this); 11741 consume(); 11742 } 11743 } 11744 } 11745 setState(1392); 11746 _errHandler.sync(this); 11747 _la = _input.LA(1); 11748 } 11749 setState(1393); 11750 match(END); 11751 } 11752 } 11753 catch (RecognitionException re) { 11754 _localctx.exception = re; 11755 _errHandler.reportError(this, re); 11756 _errHandler.recover(this, re); 11757 } 11758 finally { 11759 exitRule(); 11760 } 11761 return _localctx; 11762 } 11763 11764 public static class TfootContext extends ParserRuleContext { 11765 public TfootTagStartContext tfootTagStart() { 11766 return getRuleContext(TfootTagStartContext.class,0); 11767 } 11768 public TfootTagEndContext tfootTagEnd() { 11769 return getRuleContext(TfootTagEndContext.class,0); 11770 } 11771 public List<HtmlTagContext> htmlTag() { 11772 return getRuleContexts(HtmlTagContext.class); 11773 } 11774 public HtmlTagContext htmlTag(int i) { 11775 return getRuleContext(HtmlTagContext.class,i); 11776 } 11777 public List<SingletonElementContext> singletonElement() { 11778 return getRuleContexts(SingletonElementContext.class); 11779 } 11780 public SingletonElementContext singletonElement(int i) { 11781 return getRuleContext(SingletonElementContext.class,i); 11782 } 11783 public List<ParagraphContext> paragraph() { 11784 return getRuleContexts(ParagraphContext.class); 11785 } 11786 public ParagraphContext paragraph(int i) { 11787 return getRuleContext(ParagraphContext.class,i); 11788 } 11789 public List<LiContext> li() { 11790 return getRuleContexts(LiContext.class); 11791 } 11792 public LiContext li(int i) { 11793 return getRuleContext(LiContext.class,i); 11794 } 11795 public List<TrContext> tr() { 11796 return getRuleContexts(TrContext.class); 11797 } 11798 public TrContext tr(int i) { 11799 return getRuleContext(TrContext.class,i); 11800 } 11801 public List<TdContext> td() { 11802 return getRuleContexts(TdContext.class); 11803 } 11804 public TdContext td(int i) { 11805 return getRuleContext(TdContext.class,i); 11806 } 11807 public List<ThContext> th() { 11808 return getRuleContexts(ThContext.class); 11809 } 11810 public ThContext th(int i) { 11811 return getRuleContext(ThContext.class,i); 11812 } 11813 public List<BodyContext> body() { 11814 return getRuleContexts(BodyContext.class); 11815 } 11816 public BodyContext body(int i) { 11817 return getRuleContext(BodyContext.class,i); 11818 } 11819 public List<ColgroupContext> colgroup() { 11820 return getRuleContexts(ColgroupContext.class); 11821 } 11822 public ColgroupContext colgroup(int i) { 11823 return getRuleContext(ColgroupContext.class,i); 11824 } 11825 public List<DdContext> dd() { 11826 return getRuleContexts(DdContext.class); 11827 } 11828 public DdContext dd(int i) { 11829 return getRuleContext(DdContext.class,i); 11830 } 11831 public List<DtContext> dt() { 11832 return getRuleContexts(DtContext.class); 11833 } 11834 public DtContext dt(int i) { 11835 return getRuleContext(DtContext.class,i); 11836 } 11837 public List<HeadContext> head() { 11838 return getRuleContexts(HeadContext.class); 11839 } 11840 public HeadContext head(int i) { 11841 return getRuleContext(HeadContext.class,i); 11842 } 11843 public List<HtmlContext> html() { 11844 return getRuleContexts(HtmlContext.class); 11845 } 11846 public HtmlContext html(int i) { 11847 return getRuleContext(HtmlContext.class,i); 11848 } 11849 public List<OptionContext> option() { 11850 return getRuleContexts(OptionContext.class); 11851 } 11852 public OptionContext option(int i) { 11853 return getRuleContext(OptionContext.class,i); 11854 } 11855 public List<TbodyContext> tbody() { 11856 return getRuleContexts(TbodyContext.class); 11857 } 11858 public TbodyContext tbody(int i) { 11859 return getRuleContext(TbodyContext.class,i); 11860 } 11861 public List<TheadContext> thead() { 11862 return getRuleContexts(TheadContext.class); 11863 } 11864 public TheadContext thead(int i) { 11865 return getRuleContext(TheadContext.class,i); 11866 } 11867 public List<OptgroupContext> optgroup() { 11868 return getRuleContexts(OptgroupContext.class); 11869 } 11870 public OptgroupContext optgroup(int i) { 11871 return getRuleContext(OptgroupContext.class,i); 11872 } 11873 public List<RbContext> rb() { 11874 return getRuleContexts(RbContext.class); 11875 } 11876 public RbContext rb(int i) { 11877 return getRuleContext(RbContext.class,i); 11878 } 11879 public List<RtContext> rt() { 11880 return getRuleContexts(RtContext.class); 11881 } 11882 public RtContext rt(int i) { 11883 return getRuleContext(RtContext.class,i); 11884 } 11885 public List<RtcContext> rtc() { 11886 return getRuleContexts(RtcContext.class); 11887 } 11888 public RtcContext rtc(int i) { 11889 return getRuleContext(RtcContext.class,i); 11890 } 11891 public List<RpContext> rp() { 11892 return getRuleContexts(RpContext.class); 11893 } 11894 public RpContext rp(int i) { 11895 return getRuleContext(RpContext.class,i); 11896 } 11897 public List<PTagStartContext> pTagStart() { 11898 return getRuleContexts(PTagStartContext.class); 11899 } 11900 public PTagStartContext pTagStart(int i) { 11901 return getRuleContext(PTagStartContext.class,i); 11902 } 11903 public List<LiTagStartContext> liTagStart() { 11904 return getRuleContexts(LiTagStartContext.class); 11905 } 11906 public LiTagStartContext liTagStart(int i) { 11907 return getRuleContext(LiTagStartContext.class,i); 11908 } 11909 public List<TrTagStartContext> trTagStart() { 11910 return getRuleContexts(TrTagStartContext.class); 11911 } 11912 public TrTagStartContext trTagStart(int i) { 11913 return getRuleContext(TrTagStartContext.class,i); 11914 } 11915 public List<TdTagStartContext> tdTagStart() { 11916 return getRuleContexts(TdTagStartContext.class); 11917 } 11918 public TdTagStartContext tdTagStart(int i) { 11919 return getRuleContext(TdTagStartContext.class,i); 11920 } 11921 public List<ThTagStartContext> thTagStart() { 11922 return getRuleContexts(ThTagStartContext.class); 11923 } 11924 public ThTagStartContext thTagStart(int i) { 11925 return getRuleContext(ThTagStartContext.class,i); 11926 } 11927 public List<BodyTagStartContext> bodyTagStart() { 11928 return getRuleContexts(BodyTagStartContext.class); 11929 } 11930 public BodyTagStartContext bodyTagStart(int i) { 11931 return getRuleContext(BodyTagStartContext.class,i); 11932 } 11933 public List<ColgroupTagStartContext> colgroupTagStart() { 11934 return getRuleContexts(ColgroupTagStartContext.class); 11935 } 11936 public ColgroupTagStartContext colgroupTagStart(int i) { 11937 return getRuleContext(ColgroupTagStartContext.class,i); 11938 } 11939 public List<DdTagStartContext> ddTagStart() { 11940 return getRuleContexts(DdTagStartContext.class); 11941 } 11942 public DdTagStartContext ddTagStart(int i) { 11943 return getRuleContext(DdTagStartContext.class,i); 11944 } 11945 public List<DtTagStartContext> dtTagStart() { 11946 return getRuleContexts(DtTagStartContext.class); 11947 } 11948 public DtTagStartContext dtTagStart(int i) { 11949 return getRuleContext(DtTagStartContext.class,i); 11950 } 11951 public List<HeadTagStartContext> headTagStart() { 11952 return getRuleContexts(HeadTagStartContext.class); 11953 } 11954 public HeadTagStartContext headTagStart(int i) { 11955 return getRuleContext(HeadTagStartContext.class,i); 11956 } 11957 public List<HtmlTagStartContext> htmlTagStart() { 11958 return getRuleContexts(HtmlTagStartContext.class); 11959 } 11960 public HtmlTagStartContext htmlTagStart(int i) { 11961 return getRuleContext(HtmlTagStartContext.class,i); 11962 } 11963 public List<OptionTagStartContext> optionTagStart() { 11964 return getRuleContexts(OptionTagStartContext.class); 11965 } 11966 public OptionTagStartContext optionTagStart(int i) { 11967 return getRuleContext(OptionTagStartContext.class,i); 11968 } 11969 public List<TbodyTagStartContext> tbodyTagStart() { 11970 return getRuleContexts(TbodyTagStartContext.class); 11971 } 11972 public TbodyTagStartContext tbodyTagStart(int i) { 11973 return getRuleContext(TbodyTagStartContext.class,i); 11974 } 11975 public List<TheadTagStartContext> theadTagStart() { 11976 return getRuleContexts(TheadTagStartContext.class); 11977 } 11978 public TheadTagStartContext theadTagStart(int i) { 11979 return getRuleContext(TheadTagStartContext.class,i); 11980 } 11981 public List<OptgroupTagStartContext> optgroupTagStart() { 11982 return getRuleContexts(OptgroupTagStartContext.class); 11983 } 11984 public OptgroupTagStartContext optgroupTagStart(int i) { 11985 return getRuleContext(OptgroupTagStartContext.class,i); 11986 } 11987 public List<RbTagStartContext> rbTagStart() { 11988 return getRuleContexts(RbTagStartContext.class); 11989 } 11990 public RbTagStartContext rbTagStart(int i) { 11991 return getRuleContext(RbTagStartContext.class,i); 11992 } 11993 public List<RtTagStartContext> rtTagStart() { 11994 return getRuleContexts(RtTagStartContext.class); 11995 } 11996 public RtTagStartContext rtTagStart(int i) { 11997 return getRuleContext(RtTagStartContext.class,i); 11998 } 11999 public List<RtcTagStartContext> rtcTagStart() { 12000 return getRuleContexts(RtcTagStartContext.class); 12001 } 12002 public RtcTagStartContext rtcTagStart(int i) { 12003 return getRuleContext(RtcTagStartContext.class,i); 12004 } 12005 public List<RpTagStartContext> rpTagStart() { 12006 return getRuleContexts(RpTagStartContext.class); 12007 } 12008 public RpTagStartContext rpTagStart(int i) { 12009 return getRuleContext(RpTagStartContext.class,i); 12010 } 12011 public List<HtmlCommentContext> htmlComment() { 12012 return getRuleContexts(HtmlCommentContext.class); 12013 } 12014 public HtmlCommentContext htmlComment(int i) { 12015 return getRuleContext(HtmlCommentContext.class,i); 12016 } 12017 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 12018 public TerminalNode CDATA(int i) { 12019 return getToken(JavadocParser.CDATA, i); 12020 } 12021 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12022 public TerminalNode NEWLINE(int i) { 12023 return getToken(JavadocParser.NEWLINE, i); 12024 } 12025 public List<TextContext> text() { 12026 return getRuleContexts(TextContext.class); 12027 } 12028 public TextContext text(int i) { 12029 return getRuleContext(TextContext.class,i); 12030 } 12031 public List<JavadocInlineTagContext> javadocInlineTag() { 12032 return getRuleContexts(JavadocInlineTagContext.class); 12033 } 12034 public JavadocInlineTagContext javadocInlineTag(int i) { 12035 return getRuleContext(JavadocInlineTagContext.class,i); 12036 } 12037 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12038 public TerminalNode LEADING_ASTERISK(int i) { 12039 return getToken(JavadocParser.LEADING_ASTERISK, i); 12040 } 12041 public TfootContext(ParserRuleContext parent, int invokingState) { 12042 super(parent, invokingState); 12043 } 12044 @Override public int getRuleIndex() { return RULE_tfoot; } 12045 } 12046 12047 public final TfootContext tfoot() throws RecognitionException { 12048 TfootContext _localctx = new TfootContext(_ctx, getState()); 12049 enterRule(_localctx, 94, RULE_tfoot); 12050 try { 12051 int _alt; 12052 enterOuterAlt(_localctx, 1); 12053 { 12054 setState(1395); 12055 tfootTagStart(false); 12056 setState(1445); 12057 _errHandler.sync(this); 12058 _alt = getInterpreter().adaptivePredict(_input,83,_ctx); 12059 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 12060 if ( _alt==1 ) { 12061 { 12062 setState(1443); 12063 _errHandler.sync(this); 12064 switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) { 12065 case 1: 12066 { 12067 setState(1396); 12068 htmlTag(); 12069 } 12070 break; 12071 case 2: 12072 { 12073 setState(1397); 12074 singletonElement(); 12075 } 12076 break; 12077 case 3: 12078 { 12079 setState(1398); 12080 paragraph(); 12081 } 12082 break; 12083 case 4: 12084 { 12085 setState(1399); 12086 li(); 12087 } 12088 break; 12089 case 5: 12090 { 12091 setState(1400); 12092 tr(); 12093 } 12094 break; 12095 case 6: 12096 { 12097 setState(1401); 12098 td(); 12099 } 12100 break; 12101 case 7: 12102 { 12103 setState(1402); 12104 th(); 12105 } 12106 break; 12107 case 8: 12108 { 12109 setState(1403); 12110 body(); 12111 } 12112 break; 12113 case 9: 12114 { 12115 setState(1404); 12116 colgroup(); 12117 } 12118 break; 12119 case 10: 12120 { 12121 setState(1405); 12122 dd(); 12123 } 12124 break; 12125 case 11: 12126 { 12127 setState(1406); 12128 dt(); 12129 } 12130 break; 12131 case 12: 12132 { 12133 setState(1407); 12134 head(); 12135 } 12136 break; 12137 case 13: 12138 { 12139 setState(1408); 12140 html(); 12141 } 12142 break; 12143 case 14: 12144 { 12145 setState(1409); 12146 option(); 12147 } 12148 break; 12149 case 15: 12150 { 12151 setState(1410); 12152 tbody(); 12153 } 12154 break; 12155 case 16: 12156 { 12157 setState(1411); 12158 thead(); 12159 } 12160 break; 12161 case 17: 12162 { 12163 setState(1412); 12164 optgroup(); 12165 } 12166 break; 12167 case 18: 12168 { 12169 setState(1413); 12170 rb(); 12171 } 12172 break; 12173 case 19: 12174 { 12175 setState(1414); 12176 rt(); 12177 } 12178 break; 12179 case 20: 12180 { 12181 setState(1415); 12182 rtc(); 12183 } 12184 break; 12185 case 21: 12186 { 12187 setState(1416); 12188 rp(); 12189 } 12190 break; 12191 case 22: 12192 { 12193 setState(1417); 12194 pTagStart(true); 12195 } 12196 break; 12197 case 23: 12198 { 12199 setState(1418); 12200 liTagStart(true); 12201 } 12202 break; 12203 case 24: 12204 { 12205 setState(1419); 12206 trTagStart(true); 12207 } 12208 break; 12209 case 25: 12210 { 12211 setState(1420); 12212 tdTagStart(true); 12213 } 12214 break; 12215 case 26: 12216 { 12217 setState(1421); 12218 thTagStart(true); 12219 } 12220 break; 12221 case 27: 12222 { 12223 setState(1422); 12224 bodyTagStart(true); 12225 } 12226 break; 12227 case 28: 12228 { 12229 setState(1423); 12230 colgroupTagStart(true); 12231 } 12232 break; 12233 case 29: 12234 { 12235 setState(1424); 12236 ddTagStart(true); 12237 } 12238 break; 12239 case 30: 12240 { 12241 setState(1425); 12242 dtTagStart(true); 12243 } 12244 break; 12245 case 31: 12246 { 12247 setState(1426); 12248 headTagStart(true); 12249 } 12250 break; 12251 case 32: 12252 { 12253 setState(1427); 12254 htmlTagStart(true); 12255 } 12256 break; 12257 case 33: 12258 { 12259 setState(1428); 12260 optionTagStart(true); 12261 } 12262 break; 12263 case 34: 12264 { 12265 setState(1429); 12266 tbodyTagStart(true); 12267 } 12268 break; 12269 case 35: 12270 { 12271 setState(1430); 12272 theadTagStart(true); 12273 } 12274 break; 12275 case 36: 12276 { 12277 setState(1431); 12278 optgroupTagStart(true); 12279 } 12280 break; 12281 case 37: 12282 { 12283 setState(1432); 12284 rbTagStart(true); 12285 } 12286 break; 12287 case 38: 12288 { 12289 setState(1433); 12290 rtTagStart(true); 12291 } 12292 break; 12293 case 39: 12294 { 12295 setState(1434); 12296 rtcTagStart(true); 12297 } 12298 break; 12299 case 40: 12300 { 12301 setState(1435); 12302 rpTagStart(true); 12303 } 12304 break; 12305 case 41: 12306 { 12307 { 12308 setState(1436); 12309 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 12310 setState(1437); 12311 match(LEADING_ASTERISK); 12312 } 12313 } 12314 break; 12315 case 42: 12316 { 12317 setState(1438); 12318 htmlComment(); 12319 } 12320 break; 12321 case 43: 12322 { 12323 setState(1439); 12324 match(CDATA); 12325 } 12326 break; 12327 case 44: 12328 { 12329 setState(1440); 12330 match(NEWLINE); 12331 } 12332 break; 12333 case 45: 12334 { 12335 setState(1441); 12336 text(); 12337 } 12338 break; 12339 case 46: 12340 { 12341 setState(1442); 12342 javadocInlineTag(); 12343 } 12344 break; 12345 } 12346 } 12347 } 12348 setState(1447); 12349 _errHandler.sync(this); 12350 _alt = getInterpreter().adaptivePredict(_input,83,_ctx); 12351 } 12352 setState(1448); 12353 tfootTagEnd(); 12354 } 12355 } 12356 catch (RecognitionException re) { 12357 _localctx.exception = re; 12358 _errHandler.reportError(this, re); 12359 _errHandler.recover(this, re); 12360 } 12361 finally { 12362 exitRule(); 12363 } 12364 return _localctx; 12365 } 12366 12367 public static class TheadTagStartContext extends ParserRuleContext { 12368 public boolean isNonTight; 12369 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 12370 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 12371 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 12372 public List<AttributeContext> attribute() { 12373 return getRuleContexts(AttributeContext.class); 12374 } 12375 public AttributeContext attribute(int i) { 12376 return getRuleContext(AttributeContext.class,i); 12377 } 12378 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12379 public TerminalNode NEWLINE(int i) { 12380 return getToken(JavadocParser.NEWLINE, i); 12381 } 12382 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12383 public TerminalNode LEADING_ASTERISK(int i) { 12384 return getToken(JavadocParser.LEADING_ASTERISK, i); 12385 } 12386 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12387 public TerminalNode WS(int i) { 12388 return getToken(JavadocParser.WS, i); 12389 } 12390 public TheadTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 12391 public TheadTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 12392 super(parent, invokingState); 12393 this.isNonTight = isNonTight; 12394 } 12395 @Override public int getRuleIndex() { return RULE_theadTagStart; } 12396 } 12397 12398 public final TheadTagStartContext theadTagStart(boolean isNonTight) throws RecognitionException { 12399 TheadTagStartContext _localctx = new TheadTagStartContext(_ctx, getState(), isNonTight); 12400 enterRule(_localctx, 96, RULE_theadTagStart); 12401 int _la; 12402 try { 12403 enterOuterAlt(_localctx, 1); 12404 { 12405 setState(1450); 12406 match(START); 12407 setState(1451); 12408 match(THEAD_HTML_TAG_NAME); 12409 setState(1458); 12410 _errHandler.sync(this); 12411 _la = _input.LA(1); 12412 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12413 { 12414 setState(1456); 12415 _errHandler.sync(this); 12416 switch (_input.LA(1)) { 12417 case HTML_TAG_NAME: 12418 { 12419 setState(1452); 12420 attribute(); 12421 } 12422 break; 12423 case NEWLINE: 12424 { 12425 setState(1453); 12426 match(NEWLINE); 12427 } 12428 break; 12429 case LEADING_ASTERISK: 12430 { 12431 setState(1454); 12432 match(LEADING_ASTERISK); 12433 } 12434 break; 12435 case WS: 12436 { 12437 setState(1455); 12438 match(WS); 12439 } 12440 break; 12441 default: 12442 throw new NoViableAltException(this); 12443 } 12444 } 12445 setState(1460); 12446 _errHandler.sync(this); 12447 _la = _input.LA(1); 12448 } 12449 setState(1461); 12450 match(END); 12451 } 12452 _ctx.stop = _input.LT(-1); 12453 12454 if (isNonTight && nonTightTagStartContext == null) { 12455 nonTightTagStartContext = _localctx; 12456 } 12457 12458 } 12459 catch (RecognitionException re) { 12460 _localctx.exception = re; 12461 _errHandler.reportError(this, re); 12462 _errHandler.recover(this, re); 12463 } 12464 finally { 12465 exitRule(); 12466 } 12467 return _localctx; 12468 } 12469 12470 public static class TheadTagEndContext extends ParserRuleContext { 12471 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 12472 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 12473 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 12474 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 12475 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12476 public TerminalNode NEWLINE(int i) { 12477 return getToken(JavadocParser.NEWLINE, i); 12478 } 12479 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12480 public TerminalNode LEADING_ASTERISK(int i) { 12481 return getToken(JavadocParser.LEADING_ASTERISK, i); 12482 } 12483 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12484 public TerminalNode WS(int i) { 12485 return getToken(JavadocParser.WS, i); 12486 } 12487 public TheadTagEndContext(ParserRuleContext parent, int invokingState) { 12488 super(parent, invokingState); 12489 } 12490 @Override public int getRuleIndex() { return RULE_theadTagEnd; } 12491 } 12492 12493 public final TheadTagEndContext theadTagEnd() throws RecognitionException { 12494 TheadTagEndContext _localctx = new TheadTagEndContext(_ctx, getState()); 12495 enterRule(_localctx, 98, RULE_theadTagEnd); 12496 int _la; 12497 try { 12498 enterOuterAlt(_localctx, 1); 12499 { 12500 setState(1463); 12501 match(START); 12502 setState(1464); 12503 match(SLASH); 12504 setState(1465); 12505 match(THEAD_HTML_TAG_NAME); 12506 setState(1469); 12507 _errHandler.sync(this); 12508 _la = _input.LA(1); 12509 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 12510 { 12511 { 12512 setState(1466); 12513 _la = _input.LA(1); 12514 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 12515 _errHandler.recoverInline(this); 12516 } 12517 else { 12518 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12519 _errHandler.reportMatch(this); 12520 consume(); 12521 } 12522 } 12523 } 12524 setState(1471); 12525 _errHandler.sync(this); 12526 _la = _input.LA(1); 12527 } 12528 setState(1472); 12529 match(END); 12530 } 12531 } 12532 catch (RecognitionException re) { 12533 _localctx.exception = re; 12534 _errHandler.reportError(this, re); 12535 _errHandler.recover(this, re); 12536 } 12537 finally { 12538 exitRule(); 12539 } 12540 return _localctx; 12541 } 12542 12543 public static class TheadContext extends ParserRuleContext { 12544 public TheadTagStartContext theadTagStart() { 12545 return getRuleContext(TheadTagStartContext.class,0); 12546 } 12547 public TheadTagEndContext theadTagEnd() { 12548 return getRuleContext(TheadTagEndContext.class,0); 12549 } 12550 public List<HtmlTagContext> htmlTag() { 12551 return getRuleContexts(HtmlTagContext.class); 12552 } 12553 public HtmlTagContext htmlTag(int i) { 12554 return getRuleContext(HtmlTagContext.class,i); 12555 } 12556 public List<SingletonElementContext> singletonElement() { 12557 return getRuleContexts(SingletonElementContext.class); 12558 } 12559 public SingletonElementContext singletonElement(int i) { 12560 return getRuleContext(SingletonElementContext.class,i); 12561 } 12562 public List<ParagraphContext> paragraph() { 12563 return getRuleContexts(ParagraphContext.class); 12564 } 12565 public ParagraphContext paragraph(int i) { 12566 return getRuleContext(ParagraphContext.class,i); 12567 } 12568 public List<LiContext> li() { 12569 return getRuleContexts(LiContext.class); 12570 } 12571 public LiContext li(int i) { 12572 return getRuleContext(LiContext.class,i); 12573 } 12574 public List<TrContext> tr() { 12575 return getRuleContexts(TrContext.class); 12576 } 12577 public TrContext tr(int i) { 12578 return getRuleContext(TrContext.class,i); 12579 } 12580 public List<TdContext> td() { 12581 return getRuleContexts(TdContext.class); 12582 } 12583 public TdContext td(int i) { 12584 return getRuleContext(TdContext.class,i); 12585 } 12586 public List<ThContext> th() { 12587 return getRuleContexts(ThContext.class); 12588 } 12589 public ThContext th(int i) { 12590 return getRuleContext(ThContext.class,i); 12591 } 12592 public List<BodyContext> body() { 12593 return getRuleContexts(BodyContext.class); 12594 } 12595 public BodyContext body(int i) { 12596 return getRuleContext(BodyContext.class,i); 12597 } 12598 public List<ColgroupContext> colgroup() { 12599 return getRuleContexts(ColgroupContext.class); 12600 } 12601 public ColgroupContext colgroup(int i) { 12602 return getRuleContext(ColgroupContext.class,i); 12603 } 12604 public List<DdContext> dd() { 12605 return getRuleContexts(DdContext.class); 12606 } 12607 public DdContext dd(int i) { 12608 return getRuleContext(DdContext.class,i); 12609 } 12610 public List<DtContext> dt() { 12611 return getRuleContexts(DtContext.class); 12612 } 12613 public DtContext dt(int i) { 12614 return getRuleContext(DtContext.class,i); 12615 } 12616 public List<HeadContext> head() { 12617 return getRuleContexts(HeadContext.class); 12618 } 12619 public HeadContext head(int i) { 12620 return getRuleContext(HeadContext.class,i); 12621 } 12622 public List<HtmlContext> html() { 12623 return getRuleContexts(HtmlContext.class); 12624 } 12625 public HtmlContext html(int i) { 12626 return getRuleContext(HtmlContext.class,i); 12627 } 12628 public List<OptionContext> option() { 12629 return getRuleContexts(OptionContext.class); 12630 } 12631 public OptionContext option(int i) { 12632 return getRuleContext(OptionContext.class,i); 12633 } 12634 public List<TbodyContext> tbody() { 12635 return getRuleContexts(TbodyContext.class); 12636 } 12637 public TbodyContext tbody(int i) { 12638 return getRuleContext(TbodyContext.class,i); 12639 } 12640 public List<TfootContext> tfoot() { 12641 return getRuleContexts(TfootContext.class); 12642 } 12643 public TfootContext tfoot(int i) { 12644 return getRuleContext(TfootContext.class,i); 12645 } 12646 public List<OptgroupContext> optgroup() { 12647 return getRuleContexts(OptgroupContext.class); 12648 } 12649 public OptgroupContext optgroup(int i) { 12650 return getRuleContext(OptgroupContext.class,i); 12651 } 12652 public List<RbContext> rb() { 12653 return getRuleContexts(RbContext.class); 12654 } 12655 public RbContext rb(int i) { 12656 return getRuleContext(RbContext.class,i); 12657 } 12658 public List<RtContext> rt() { 12659 return getRuleContexts(RtContext.class); 12660 } 12661 public RtContext rt(int i) { 12662 return getRuleContext(RtContext.class,i); 12663 } 12664 public List<RtcContext> rtc() { 12665 return getRuleContexts(RtcContext.class); 12666 } 12667 public RtcContext rtc(int i) { 12668 return getRuleContext(RtcContext.class,i); 12669 } 12670 public List<RpContext> rp() { 12671 return getRuleContexts(RpContext.class); 12672 } 12673 public RpContext rp(int i) { 12674 return getRuleContext(RpContext.class,i); 12675 } 12676 public List<PTagStartContext> pTagStart() { 12677 return getRuleContexts(PTagStartContext.class); 12678 } 12679 public PTagStartContext pTagStart(int i) { 12680 return getRuleContext(PTagStartContext.class,i); 12681 } 12682 public List<LiTagStartContext> liTagStart() { 12683 return getRuleContexts(LiTagStartContext.class); 12684 } 12685 public LiTagStartContext liTagStart(int i) { 12686 return getRuleContext(LiTagStartContext.class,i); 12687 } 12688 public List<TrTagStartContext> trTagStart() { 12689 return getRuleContexts(TrTagStartContext.class); 12690 } 12691 public TrTagStartContext trTagStart(int i) { 12692 return getRuleContext(TrTagStartContext.class,i); 12693 } 12694 public List<TdTagStartContext> tdTagStart() { 12695 return getRuleContexts(TdTagStartContext.class); 12696 } 12697 public TdTagStartContext tdTagStart(int i) { 12698 return getRuleContext(TdTagStartContext.class,i); 12699 } 12700 public List<ThTagStartContext> thTagStart() { 12701 return getRuleContexts(ThTagStartContext.class); 12702 } 12703 public ThTagStartContext thTagStart(int i) { 12704 return getRuleContext(ThTagStartContext.class,i); 12705 } 12706 public List<BodyTagStartContext> bodyTagStart() { 12707 return getRuleContexts(BodyTagStartContext.class); 12708 } 12709 public BodyTagStartContext bodyTagStart(int i) { 12710 return getRuleContext(BodyTagStartContext.class,i); 12711 } 12712 public List<ColgroupTagStartContext> colgroupTagStart() { 12713 return getRuleContexts(ColgroupTagStartContext.class); 12714 } 12715 public ColgroupTagStartContext colgroupTagStart(int i) { 12716 return getRuleContext(ColgroupTagStartContext.class,i); 12717 } 12718 public List<DdTagStartContext> ddTagStart() { 12719 return getRuleContexts(DdTagStartContext.class); 12720 } 12721 public DdTagStartContext ddTagStart(int i) { 12722 return getRuleContext(DdTagStartContext.class,i); 12723 } 12724 public List<DtTagStartContext> dtTagStart() { 12725 return getRuleContexts(DtTagStartContext.class); 12726 } 12727 public DtTagStartContext dtTagStart(int i) { 12728 return getRuleContext(DtTagStartContext.class,i); 12729 } 12730 public List<HeadTagStartContext> headTagStart() { 12731 return getRuleContexts(HeadTagStartContext.class); 12732 } 12733 public HeadTagStartContext headTagStart(int i) { 12734 return getRuleContext(HeadTagStartContext.class,i); 12735 } 12736 public List<HtmlTagStartContext> htmlTagStart() { 12737 return getRuleContexts(HtmlTagStartContext.class); 12738 } 12739 public HtmlTagStartContext htmlTagStart(int i) { 12740 return getRuleContext(HtmlTagStartContext.class,i); 12741 } 12742 public List<OptionTagStartContext> optionTagStart() { 12743 return getRuleContexts(OptionTagStartContext.class); 12744 } 12745 public OptionTagStartContext optionTagStart(int i) { 12746 return getRuleContext(OptionTagStartContext.class,i); 12747 } 12748 public List<TbodyTagStartContext> tbodyTagStart() { 12749 return getRuleContexts(TbodyTagStartContext.class); 12750 } 12751 public TbodyTagStartContext tbodyTagStart(int i) { 12752 return getRuleContext(TbodyTagStartContext.class,i); 12753 } 12754 public List<TfootTagStartContext> tfootTagStart() { 12755 return getRuleContexts(TfootTagStartContext.class); 12756 } 12757 public TfootTagStartContext tfootTagStart(int i) { 12758 return getRuleContext(TfootTagStartContext.class,i); 12759 } 12760 public List<OptgroupTagStartContext> optgroupTagStart() { 12761 return getRuleContexts(OptgroupTagStartContext.class); 12762 } 12763 public OptgroupTagStartContext optgroupTagStart(int i) { 12764 return getRuleContext(OptgroupTagStartContext.class,i); 12765 } 12766 public List<RbTagStartContext> rbTagStart() { 12767 return getRuleContexts(RbTagStartContext.class); 12768 } 12769 public RbTagStartContext rbTagStart(int i) { 12770 return getRuleContext(RbTagStartContext.class,i); 12771 } 12772 public List<RtTagStartContext> rtTagStart() { 12773 return getRuleContexts(RtTagStartContext.class); 12774 } 12775 public RtTagStartContext rtTagStart(int i) { 12776 return getRuleContext(RtTagStartContext.class,i); 12777 } 12778 public List<RtcTagStartContext> rtcTagStart() { 12779 return getRuleContexts(RtcTagStartContext.class); 12780 } 12781 public RtcTagStartContext rtcTagStart(int i) { 12782 return getRuleContext(RtcTagStartContext.class,i); 12783 } 12784 public List<RpTagStartContext> rpTagStart() { 12785 return getRuleContexts(RpTagStartContext.class); 12786 } 12787 public RpTagStartContext rpTagStart(int i) { 12788 return getRuleContext(RpTagStartContext.class,i); 12789 } 12790 public List<HtmlCommentContext> htmlComment() { 12791 return getRuleContexts(HtmlCommentContext.class); 12792 } 12793 public HtmlCommentContext htmlComment(int i) { 12794 return getRuleContext(HtmlCommentContext.class,i); 12795 } 12796 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 12797 public TerminalNode CDATA(int i) { 12798 return getToken(JavadocParser.CDATA, i); 12799 } 12800 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12801 public TerminalNode NEWLINE(int i) { 12802 return getToken(JavadocParser.NEWLINE, i); 12803 } 12804 public List<TextContext> text() { 12805 return getRuleContexts(TextContext.class); 12806 } 12807 public TextContext text(int i) { 12808 return getRuleContext(TextContext.class,i); 12809 } 12810 public List<JavadocInlineTagContext> javadocInlineTag() { 12811 return getRuleContexts(JavadocInlineTagContext.class); 12812 } 12813 public JavadocInlineTagContext javadocInlineTag(int i) { 12814 return getRuleContext(JavadocInlineTagContext.class,i); 12815 } 12816 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12817 public TerminalNode LEADING_ASTERISK(int i) { 12818 return getToken(JavadocParser.LEADING_ASTERISK, i); 12819 } 12820 public TheadContext(ParserRuleContext parent, int invokingState) { 12821 super(parent, invokingState); 12822 } 12823 @Override public int getRuleIndex() { return RULE_thead; } 12824 } 12825 12826 public final TheadContext thead() throws RecognitionException { 12827 TheadContext _localctx = new TheadContext(_ctx, getState()); 12828 enterRule(_localctx, 100, RULE_thead); 12829 try { 12830 int _alt; 12831 enterOuterAlt(_localctx, 1); 12832 { 12833 setState(1474); 12834 theadTagStart(false); 12835 setState(1524); 12836 _errHandler.sync(this); 12837 _alt = getInterpreter().adaptivePredict(_input,88,_ctx); 12838 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 12839 if ( _alt==1 ) { 12840 { 12841 setState(1522); 12842 _errHandler.sync(this); 12843 switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) { 12844 case 1: 12845 { 12846 setState(1475); 12847 htmlTag(); 12848 } 12849 break; 12850 case 2: 12851 { 12852 setState(1476); 12853 singletonElement(); 12854 } 12855 break; 12856 case 3: 12857 { 12858 setState(1477); 12859 paragraph(); 12860 } 12861 break; 12862 case 4: 12863 { 12864 setState(1478); 12865 li(); 12866 } 12867 break; 12868 case 5: 12869 { 12870 setState(1479); 12871 tr(); 12872 } 12873 break; 12874 case 6: 12875 { 12876 setState(1480); 12877 td(); 12878 } 12879 break; 12880 case 7: 12881 { 12882 setState(1481); 12883 th(); 12884 } 12885 break; 12886 case 8: 12887 { 12888 setState(1482); 12889 body(); 12890 } 12891 break; 12892 case 9: 12893 { 12894 setState(1483); 12895 colgroup(); 12896 } 12897 break; 12898 case 10: 12899 { 12900 setState(1484); 12901 dd(); 12902 } 12903 break; 12904 case 11: 12905 { 12906 setState(1485); 12907 dt(); 12908 } 12909 break; 12910 case 12: 12911 { 12912 setState(1486); 12913 head(); 12914 } 12915 break; 12916 case 13: 12917 { 12918 setState(1487); 12919 html(); 12920 } 12921 break; 12922 case 14: 12923 { 12924 setState(1488); 12925 option(); 12926 } 12927 break; 12928 case 15: 12929 { 12930 setState(1489); 12931 tbody(); 12932 } 12933 break; 12934 case 16: 12935 { 12936 setState(1490); 12937 tfoot(); 12938 } 12939 break; 12940 case 17: 12941 { 12942 setState(1491); 12943 optgroup(); 12944 } 12945 break; 12946 case 18: 12947 { 12948 setState(1492); 12949 rb(); 12950 } 12951 break; 12952 case 19: 12953 { 12954 setState(1493); 12955 rt(); 12956 } 12957 break; 12958 case 20: 12959 { 12960 setState(1494); 12961 rtc(); 12962 } 12963 break; 12964 case 21: 12965 { 12966 setState(1495); 12967 rp(); 12968 } 12969 break; 12970 case 22: 12971 { 12972 setState(1496); 12973 pTagStart(true); 12974 } 12975 break; 12976 case 23: 12977 { 12978 setState(1497); 12979 liTagStart(true); 12980 } 12981 break; 12982 case 24: 12983 { 12984 setState(1498); 12985 trTagStart(true); 12986 } 12987 break; 12988 case 25: 12989 { 12990 setState(1499); 12991 tdTagStart(true); 12992 } 12993 break; 12994 case 26: 12995 { 12996 setState(1500); 12997 thTagStart(true); 12998 } 12999 break; 13000 case 27: 13001 { 13002 setState(1501); 13003 bodyTagStart(true); 13004 } 13005 break; 13006 case 28: 13007 { 13008 setState(1502); 13009 colgroupTagStart(true); 13010 } 13011 break; 13012 case 29: 13013 { 13014 setState(1503); 13015 ddTagStart(true); 13016 } 13017 break; 13018 case 30: 13019 { 13020 setState(1504); 13021 dtTagStart(true); 13022 } 13023 break; 13024 case 31: 13025 { 13026 setState(1505); 13027 headTagStart(true); 13028 } 13029 break; 13030 case 32: 13031 { 13032 setState(1506); 13033 htmlTagStart(true); 13034 } 13035 break; 13036 case 33: 13037 { 13038 setState(1507); 13039 optionTagStart(true); 13040 } 13041 break; 13042 case 34: 13043 { 13044 setState(1508); 13045 tbodyTagStart(true); 13046 } 13047 break; 13048 case 35: 13049 { 13050 setState(1509); 13051 tfootTagStart(true); 13052 } 13053 break; 13054 case 36: 13055 { 13056 setState(1510); 13057 optgroupTagStart(true); 13058 } 13059 break; 13060 case 37: 13061 { 13062 setState(1511); 13063 rbTagStart(true); 13064 } 13065 break; 13066 case 38: 13067 { 13068 setState(1512); 13069 rtTagStart(true); 13070 } 13071 break; 13072 case 39: 13073 { 13074 setState(1513); 13075 rtcTagStart(true); 13076 } 13077 break; 13078 case 40: 13079 { 13080 setState(1514); 13081 rpTagStart(true); 13082 } 13083 break; 13084 case 41: 13085 { 13086 { 13087 setState(1515); 13088 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 13089 setState(1516); 13090 match(LEADING_ASTERISK); 13091 } 13092 } 13093 break; 13094 case 42: 13095 { 13096 setState(1517); 13097 htmlComment(); 13098 } 13099 break; 13100 case 43: 13101 { 13102 setState(1518); 13103 match(CDATA); 13104 } 13105 break; 13106 case 44: 13107 { 13108 setState(1519); 13109 match(NEWLINE); 13110 } 13111 break; 13112 case 45: 13113 { 13114 setState(1520); 13115 text(); 13116 } 13117 break; 13118 case 46: 13119 { 13120 setState(1521); 13121 javadocInlineTag(); 13122 } 13123 break; 13124 } 13125 } 13126 } 13127 setState(1526); 13128 _errHandler.sync(this); 13129 _alt = getInterpreter().adaptivePredict(_input,88,_ctx); 13130 } 13131 setState(1527); 13132 theadTagEnd(); 13133 } 13134 } 13135 catch (RecognitionException re) { 13136 _localctx.exception = re; 13137 _errHandler.reportError(this, re); 13138 _errHandler.recover(this, re); 13139 } 13140 finally { 13141 exitRule(); 13142 } 13143 return _localctx; 13144 } 13145 13146 public static class SingletonElementContext extends ParserRuleContext { 13147 public EmptyTagContext emptyTag() { 13148 return getRuleContext(EmptyTagContext.class,0); 13149 } 13150 public AreaTagContext areaTag() { 13151 return getRuleContext(AreaTagContext.class,0); 13152 } 13153 public BaseTagContext baseTag() { 13154 return getRuleContext(BaseTagContext.class,0); 13155 } 13156 public BasefontTagContext basefontTag() { 13157 return getRuleContext(BasefontTagContext.class,0); 13158 } 13159 public BrTagContext brTag() { 13160 return getRuleContext(BrTagContext.class,0); 13161 } 13162 public ColTagContext colTag() { 13163 return getRuleContext(ColTagContext.class,0); 13164 } 13165 public FrameTagContext frameTag() { 13166 return getRuleContext(FrameTagContext.class,0); 13167 } 13168 public HrTagContext hrTag() { 13169 return getRuleContext(HrTagContext.class,0); 13170 } 13171 public ImgTagContext imgTag() { 13172 return getRuleContext(ImgTagContext.class,0); 13173 } 13174 public InputTagContext inputTag() { 13175 return getRuleContext(InputTagContext.class,0); 13176 } 13177 public IsindexTagContext isindexTag() { 13178 return getRuleContext(IsindexTagContext.class,0); 13179 } 13180 public LinkTagContext linkTag() { 13181 return getRuleContext(LinkTagContext.class,0); 13182 } 13183 public MetaTagContext metaTag() { 13184 return getRuleContext(MetaTagContext.class,0); 13185 } 13186 public ParamTagContext paramTag() { 13187 return getRuleContext(ParamTagContext.class,0); 13188 } 13189 public EmbedTagContext embedTag() { 13190 return getRuleContext(EmbedTagContext.class,0); 13191 } 13192 public KeygenTagContext keygenTag() { 13193 return getRuleContext(KeygenTagContext.class,0); 13194 } 13195 public SourceTagContext sourceTag() { 13196 return getRuleContext(SourceTagContext.class,0); 13197 } 13198 public TrackTagContext trackTag() { 13199 return getRuleContext(TrackTagContext.class,0); 13200 } 13201 public WbrTagContext wbrTag() { 13202 return getRuleContext(WbrTagContext.class,0); 13203 } 13204 public WrongSingletonTagContext wrongSingletonTag() { 13205 return getRuleContext(WrongSingletonTagContext.class,0); 13206 } 13207 public SingletonElementContext(ParserRuleContext parent, int invokingState) { 13208 super(parent, invokingState); 13209 } 13210 @Override public int getRuleIndex() { return RULE_singletonElement; } 13211 } 13212 13213 public final SingletonElementContext singletonElement() throws RecognitionException { 13214 SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState()); 13215 enterRule(_localctx, 102, RULE_singletonElement); 13216 try { 13217 setState(1549); 13218 _errHandler.sync(this); 13219 switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) { 13220 case 1: 13221 enterOuterAlt(_localctx, 1); 13222 { 13223 setState(1529); 13224 emptyTag(); 13225 } 13226 break; 13227 case 2: 13228 enterOuterAlt(_localctx, 2); 13229 { 13230 setState(1530); 13231 areaTag(); 13232 } 13233 break; 13234 case 3: 13235 enterOuterAlt(_localctx, 3); 13236 { 13237 setState(1531); 13238 baseTag(); 13239 } 13240 break; 13241 case 4: 13242 enterOuterAlt(_localctx, 4); 13243 { 13244 setState(1532); 13245 basefontTag(); 13246 } 13247 break; 13248 case 5: 13249 enterOuterAlt(_localctx, 5); 13250 { 13251 setState(1533); 13252 brTag(); 13253 } 13254 break; 13255 case 6: 13256 enterOuterAlt(_localctx, 6); 13257 { 13258 setState(1534); 13259 colTag(); 13260 } 13261 break; 13262 case 7: 13263 enterOuterAlt(_localctx, 7); 13264 { 13265 setState(1535); 13266 frameTag(); 13267 } 13268 break; 13269 case 8: 13270 enterOuterAlt(_localctx, 8); 13271 { 13272 setState(1536); 13273 hrTag(); 13274 } 13275 break; 13276 case 9: 13277 enterOuterAlt(_localctx, 9); 13278 { 13279 setState(1537); 13280 imgTag(); 13281 } 13282 break; 13283 case 10: 13284 enterOuterAlt(_localctx, 10); 13285 { 13286 setState(1538); 13287 inputTag(); 13288 } 13289 break; 13290 case 11: 13291 enterOuterAlt(_localctx, 11); 13292 { 13293 setState(1539); 13294 isindexTag(); 13295 } 13296 break; 13297 case 12: 13298 enterOuterAlt(_localctx, 12); 13299 { 13300 setState(1540); 13301 linkTag(); 13302 } 13303 break; 13304 case 13: 13305 enterOuterAlt(_localctx, 13); 13306 { 13307 setState(1541); 13308 metaTag(); 13309 } 13310 break; 13311 case 14: 13312 enterOuterAlt(_localctx, 14); 13313 { 13314 setState(1542); 13315 paramTag(); 13316 } 13317 break; 13318 case 15: 13319 enterOuterAlt(_localctx, 15); 13320 { 13321 setState(1543); 13322 embedTag(); 13323 } 13324 break; 13325 case 16: 13326 enterOuterAlt(_localctx, 16); 13327 { 13328 setState(1544); 13329 keygenTag(); 13330 } 13331 break; 13332 case 17: 13333 enterOuterAlt(_localctx, 17); 13334 { 13335 setState(1545); 13336 sourceTag(); 13337 } 13338 break; 13339 case 18: 13340 enterOuterAlt(_localctx, 18); 13341 { 13342 setState(1546); 13343 trackTag(); 13344 } 13345 break; 13346 case 19: 13347 enterOuterAlt(_localctx, 19); 13348 { 13349 setState(1547); 13350 wbrTag(); 13351 } 13352 break; 13353 case 20: 13354 enterOuterAlt(_localctx, 20); 13355 { 13356 setState(1548); 13357 wrongSingletonTag(); 13358 } 13359 break; 13360 } 13361 } 13362 catch (RecognitionException re) { 13363 _localctx.exception = re; 13364 _errHandler.reportError(this, re); 13365 _errHandler.recover(this, re); 13366 } 13367 finally { 13368 exitRule(); 13369 } 13370 return _localctx; 13371 } 13372 13373 public static class EmptyTagContext extends ParserRuleContext { 13374 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13375 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13376 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 13377 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 13378 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 13379 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 13380 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 13381 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 13382 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 13383 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 13384 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 13385 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 13386 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 13387 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 13388 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 13389 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 13390 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 13391 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 13392 public List<AttributeContext> attribute() { 13393 return getRuleContexts(AttributeContext.class); 13394 } 13395 public AttributeContext attribute(int i) { 13396 return getRuleContext(AttributeContext.class,i); 13397 } 13398 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13399 public TerminalNode NEWLINE(int i) { 13400 return getToken(JavadocParser.NEWLINE, i); 13401 } 13402 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13403 public TerminalNode LEADING_ASTERISK(int i) { 13404 return getToken(JavadocParser.LEADING_ASTERISK, i); 13405 } 13406 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13407 public TerminalNode WS(int i) { 13408 return getToken(JavadocParser.WS, i); 13409 } 13410 public EmptyTagContext(ParserRuleContext parent, int invokingState) { 13411 super(parent, invokingState); 13412 } 13413 @Override public int getRuleIndex() { return RULE_emptyTag; } 13414 } 13415 13416 public final EmptyTagContext emptyTag() throws RecognitionException { 13417 EmptyTagContext _localctx = new EmptyTagContext(_ctx, getState()); 13418 enterRule(_localctx, 104, RULE_emptyTag); 13419 int _la; 13420 try { 13421 enterOuterAlt(_localctx, 1); 13422 { 13423 setState(1551); 13424 match(START); 13425 setState(1552); 13426 _la = _input.LA(1); 13427 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)) ) { 13428 _errHandler.recoverInline(this); 13429 } 13430 else { 13431 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13432 _errHandler.reportMatch(this); 13433 consume(); 13434 } 13435 setState(1559); 13436 _errHandler.sync(this); 13437 _la = _input.LA(1); 13438 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13439 { 13440 setState(1557); 13441 _errHandler.sync(this); 13442 switch (_input.LA(1)) { 13443 case HTML_TAG_NAME: 13444 { 13445 setState(1553); 13446 attribute(); 13447 } 13448 break; 13449 case NEWLINE: 13450 { 13451 setState(1554); 13452 match(NEWLINE); 13453 } 13454 break; 13455 case LEADING_ASTERISK: 13456 { 13457 setState(1555); 13458 match(LEADING_ASTERISK); 13459 } 13460 break; 13461 case WS: 13462 { 13463 setState(1556); 13464 match(WS); 13465 } 13466 break; 13467 default: 13468 throw new NoViableAltException(this); 13469 } 13470 } 13471 setState(1561); 13472 _errHandler.sync(this); 13473 _la = _input.LA(1); 13474 } 13475 setState(1562); 13476 match(SLASH_END); 13477 } 13478 } 13479 catch (RecognitionException re) { 13480 _localctx.exception = re; 13481 _errHandler.reportError(this, re); 13482 _errHandler.recover(this, re); 13483 } 13484 finally { 13485 exitRule(); 13486 } 13487 return _localctx; 13488 } 13489 13490 public static class AreaTagContext extends ParserRuleContext { 13491 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13492 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 13493 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13494 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 13495 public List<AttributeContext> attribute() { 13496 return getRuleContexts(AttributeContext.class); 13497 } 13498 public AttributeContext attribute(int i) { 13499 return getRuleContext(AttributeContext.class,i); 13500 } 13501 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13502 public TerminalNode NEWLINE(int i) { 13503 return getToken(JavadocParser.NEWLINE, i); 13504 } 13505 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13506 public TerminalNode LEADING_ASTERISK(int i) { 13507 return getToken(JavadocParser.LEADING_ASTERISK, i); 13508 } 13509 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13510 public TerminalNode WS(int i) { 13511 return getToken(JavadocParser.WS, i); 13512 } 13513 public AreaTagContext(ParserRuleContext parent, int invokingState) { 13514 super(parent, invokingState); 13515 } 13516 @Override public int getRuleIndex() { return RULE_areaTag; } 13517 } 13518 13519 public final AreaTagContext areaTag() throws RecognitionException { 13520 AreaTagContext _localctx = new AreaTagContext(_ctx, getState()); 13521 enterRule(_localctx, 106, RULE_areaTag); 13522 int _la; 13523 try { 13524 enterOuterAlt(_localctx, 1); 13525 { 13526 setState(1564); 13527 match(START); 13528 setState(1565); 13529 match(AREA_HTML_TAG_NAME); 13530 setState(1572); 13531 _errHandler.sync(this); 13532 _la = _input.LA(1); 13533 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13534 { 13535 setState(1570); 13536 _errHandler.sync(this); 13537 switch (_input.LA(1)) { 13538 case HTML_TAG_NAME: 13539 { 13540 setState(1566); 13541 attribute(); 13542 } 13543 break; 13544 case NEWLINE: 13545 { 13546 setState(1567); 13547 match(NEWLINE); 13548 } 13549 break; 13550 case LEADING_ASTERISK: 13551 { 13552 setState(1568); 13553 match(LEADING_ASTERISK); 13554 } 13555 break; 13556 case WS: 13557 { 13558 setState(1569); 13559 match(WS); 13560 } 13561 break; 13562 default: 13563 throw new NoViableAltException(this); 13564 } 13565 } 13566 setState(1574); 13567 _errHandler.sync(this); 13568 _la = _input.LA(1); 13569 } 13570 setState(1575); 13571 _la = _input.LA(1); 13572 if ( !(_la==END || _la==SLASH_END) ) { 13573 _errHandler.recoverInline(this); 13574 } 13575 else { 13576 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13577 _errHandler.reportMatch(this); 13578 consume(); 13579 } 13580 } 13581 } 13582 catch (RecognitionException re) { 13583 _localctx.exception = re; 13584 _errHandler.reportError(this, re); 13585 _errHandler.recover(this, re); 13586 } 13587 finally { 13588 exitRule(); 13589 } 13590 return _localctx; 13591 } 13592 13593 public static class BaseTagContext extends ParserRuleContext { 13594 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13595 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 13596 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13597 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 13598 public List<AttributeContext> attribute() { 13599 return getRuleContexts(AttributeContext.class); 13600 } 13601 public AttributeContext attribute(int i) { 13602 return getRuleContext(AttributeContext.class,i); 13603 } 13604 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13605 public TerminalNode NEWLINE(int i) { 13606 return getToken(JavadocParser.NEWLINE, i); 13607 } 13608 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13609 public TerminalNode LEADING_ASTERISK(int i) { 13610 return getToken(JavadocParser.LEADING_ASTERISK, i); 13611 } 13612 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13613 public TerminalNode WS(int i) { 13614 return getToken(JavadocParser.WS, i); 13615 } 13616 public BaseTagContext(ParserRuleContext parent, int invokingState) { 13617 super(parent, invokingState); 13618 } 13619 @Override public int getRuleIndex() { return RULE_baseTag; } 13620 } 13621 13622 public final BaseTagContext baseTag() throws RecognitionException { 13623 BaseTagContext _localctx = new BaseTagContext(_ctx, getState()); 13624 enterRule(_localctx, 108, RULE_baseTag); 13625 int _la; 13626 try { 13627 enterOuterAlt(_localctx, 1); 13628 { 13629 setState(1577); 13630 match(START); 13631 setState(1578); 13632 match(BASE_HTML_TAG_NAME); 13633 setState(1585); 13634 _errHandler.sync(this); 13635 _la = _input.LA(1); 13636 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13637 { 13638 setState(1583); 13639 _errHandler.sync(this); 13640 switch (_input.LA(1)) { 13641 case HTML_TAG_NAME: 13642 { 13643 setState(1579); 13644 attribute(); 13645 } 13646 break; 13647 case NEWLINE: 13648 { 13649 setState(1580); 13650 match(NEWLINE); 13651 } 13652 break; 13653 case LEADING_ASTERISK: 13654 { 13655 setState(1581); 13656 match(LEADING_ASTERISK); 13657 } 13658 break; 13659 case WS: 13660 { 13661 setState(1582); 13662 match(WS); 13663 } 13664 break; 13665 default: 13666 throw new NoViableAltException(this); 13667 } 13668 } 13669 setState(1587); 13670 _errHandler.sync(this); 13671 _la = _input.LA(1); 13672 } 13673 setState(1588); 13674 _la = _input.LA(1); 13675 if ( !(_la==END || _la==SLASH_END) ) { 13676 _errHandler.recoverInline(this); 13677 } 13678 else { 13679 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13680 _errHandler.reportMatch(this); 13681 consume(); 13682 } 13683 } 13684 } 13685 catch (RecognitionException re) { 13686 _localctx.exception = re; 13687 _errHandler.reportError(this, re); 13688 _errHandler.recover(this, re); 13689 } 13690 finally { 13691 exitRule(); 13692 } 13693 return _localctx; 13694 } 13695 13696 public static class BasefontTagContext extends ParserRuleContext { 13697 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13698 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 13699 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13700 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 13701 public List<AttributeContext> attribute() { 13702 return getRuleContexts(AttributeContext.class); 13703 } 13704 public AttributeContext attribute(int i) { 13705 return getRuleContext(AttributeContext.class,i); 13706 } 13707 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13708 public TerminalNode NEWLINE(int i) { 13709 return getToken(JavadocParser.NEWLINE, i); 13710 } 13711 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13712 public TerminalNode LEADING_ASTERISK(int i) { 13713 return getToken(JavadocParser.LEADING_ASTERISK, i); 13714 } 13715 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13716 public TerminalNode WS(int i) { 13717 return getToken(JavadocParser.WS, i); 13718 } 13719 public BasefontTagContext(ParserRuleContext parent, int invokingState) { 13720 super(parent, invokingState); 13721 } 13722 @Override public int getRuleIndex() { return RULE_basefontTag; } 13723 } 13724 13725 public final BasefontTagContext basefontTag() throws RecognitionException { 13726 BasefontTagContext _localctx = new BasefontTagContext(_ctx, getState()); 13727 enterRule(_localctx, 110, RULE_basefontTag); 13728 int _la; 13729 try { 13730 enterOuterAlt(_localctx, 1); 13731 { 13732 setState(1590); 13733 match(START); 13734 setState(1591); 13735 match(BASEFONT_HTML_TAG_NAME); 13736 setState(1598); 13737 _errHandler.sync(this); 13738 _la = _input.LA(1); 13739 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13740 { 13741 setState(1596); 13742 _errHandler.sync(this); 13743 switch (_input.LA(1)) { 13744 case HTML_TAG_NAME: 13745 { 13746 setState(1592); 13747 attribute(); 13748 } 13749 break; 13750 case NEWLINE: 13751 { 13752 setState(1593); 13753 match(NEWLINE); 13754 } 13755 break; 13756 case LEADING_ASTERISK: 13757 { 13758 setState(1594); 13759 match(LEADING_ASTERISK); 13760 } 13761 break; 13762 case WS: 13763 { 13764 setState(1595); 13765 match(WS); 13766 } 13767 break; 13768 default: 13769 throw new NoViableAltException(this); 13770 } 13771 } 13772 setState(1600); 13773 _errHandler.sync(this); 13774 _la = _input.LA(1); 13775 } 13776 setState(1601); 13777 _la = _input.LA(1); 13778 if ( !(_la==END || _la==SLASH_END) ) { 13779 _errHandler.recoverInline(this); 13780 } 13781 else { 13782 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13783 _errHandler.reportMatch(this); 13784 consume(); 13785 } 13786 } 13787 } 13788 catch (RecognitionException re) { 13789 _localctx.exception = re; 13790 _errHandler.reportError(this, re); 13791 _errHandler.recover(this, re); 13792 } 13793 finally { 13794 exitRule(); 13795 } 13796 return _localctx; 13797 } 13798 13799 public static class BrTagContext extends ParserRuleContext { 13800 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13801 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 13802 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13803 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 13804 public List<AttributeContext> attribute() { 13805 return getRuleContexts(AttributeContext.class); 13806 } 13807 public AttributeContext attribute(int i) { 13808 return getRuleContext(AttributeContext.class,i); 13809 } 13810 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13811 public TerminalNode NEWLINE(int i) { 13812 return getToken(JavadocParser.NEWLINE, i); 13813 } 13814 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13815 public TerminalNode LEADING_ASTERISK(int i) { 13816 return getToken(JavadocParser.LEADING_ASTERISK, i); 13817 } 13818 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13819 public TerminalNode WS(int i) { 13820 return getToken(JavadocParser.WS, i); 13821 } 13822 public BrTagContext(ParserRuleContext parent, int invokingState) { 13823 super(parent, invokingState); 13824 } 13825 @Override public int getRuleIndex() { return RULE_brTag; } 13826 } 13827 13828 public final BrTagContext brTag() throws RecognitionException { 13829 BrTagContext _localctx = new BrTagContext(_ctx, getState()); 13830 enterRule(_localctx, 112, RULE_brTag); 13831 int _la; 13832 try { 13833 enterOuterAlt(_localctx, 1); 13834 { 13835 setState(1603); 13836 match(START); 13837 setState(1604); 13838 match(BR_HTML_TAG_NAME); 13839 setState(1611); 13840 _errHandler.sync(this); 13841 _la = _input.LA(1); 13842 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13843 { 13844 setState(1609); 13845 _errHandler.sync(this); 13846 switch (_input.LA(1)) { 13847 case HTML_TAG_NAME: 13848 { 13849 setState(1605); 13850 attribute(); 13851 } 13852 break; 13853 case NEWLINE: 13854 { 13855 setState(1606); 13856 match(NEWLINE); 13857 } 13858 break; 13859 case LEADING_ASTERISK: 13860 { 13861 setState(1607); 13862 match(LEADING_ASTERISK); 13863 } 13864 break; 13865 case WS: 13866 { 13867 setState(1608); 13868 match(WS); 13869 } 13870 break; 13871 default: 13872 throw new NoViableAltException(this); 13873 } 13874 } 13875 setState(1613); 13876 _errHandler.sync(this); 13877 _la = _input.LA(1); 13878 } 13879 setState(1614); 13880 _la = _input.LA(1); 13881 if ( !(_la==END || _la==SLASH_END) ) { 13882 _errHandler.recoverInline(this); 13883 } 13884 else { 13885 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13886 _errHandler.reportMatch(this); 13887 consume(); 13888 } 13889 } 13890 } 13891 catch (RecognitionException re) { 13892 _localctx.exception = re; 13893 _errHandler.reportError(this, re); 13894 _errHandler.recover(this, re); 13895 } 13896 finally { 13897 exitRule(); 13898 } 13899 return _localctx; 13900 } 13901 13902 public static class ColTagContext extends ParserRuleContext { 13903 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 13904 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 13905 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 13906 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 13907 public List<AttributeContext> attribute() { 13908 return getRuleContexts(AttributeContext.class); 13909 } 13910 public AttributeContext attribute(int i) { 13911 return getRuleContext(AttributeContext.class,i); 13912 } 13913 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13914 public TerminalNode NEWLINE(int i) { 13915 return getToken(JavadocParser.NEWLINE, i); 13916 } 13917 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13918 public TerminalNode LEADING_ASTERISK(int i) { 13919 return getToken(JavadocParser.LEADING_ASTERISK, i); 13920 } 13921 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13922 public TerminalNode WS(int i) { 13923 return getToken(JavadocParser.WS, i); 13924 } 13925 public ColTagContext(ParserRuleContext parent, int invokingState) { 13926 super(parent, invokingState); 13927 } 13928 @Override public int getRuleIndex() { return RULE_colTag; } 13929 } 13930 13931 public final ColTagContext colTag() throws RecognitionException { 13932 ColTagContext _localctx = new ColTagContext(_ctx, getState()); 13933 enterRule(_localctx, 114, RULE_colTag); 13934 int _la; 13935 try { 13936 enterOuterAlt(_localctx, 1); 13937 { 13938 setState(1616); 13939 match(START); 13940 setState(1617); 13941 match(COL_HTML_TAG_NAME); 13942 setState(1624); 13943 _errHandler.sync(this); 13944 _la = _input.LA(1); 13945 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13946 { 13947 setState(1622); 13948 _errHandler.sync(this); 13949 switch (_input.LA(1)) { 13950 case HTML_TAG_NAME: 13951 { 13952 setState(1618); 13953 attribute(); 13954 } 13955 break; 13956 case NEWLINE: 13957 { 13958 setState(1619); 13959 match(NEWLINE); 13960 } 13961 break; 13962 case LEADING_ASTERISK: 13963 { 13964 setState(1620); 13965 match(LEADING_ASTERISK); 13966 } 13967 break; 13968 case WS: 13969 { 13970 setState(1621); 13971 match(WS); 13972 } 13973 break; 13974 default: 13975 throw new NoViableAltException(this); 13976 } 13977 } 13978 setState(1626); 13979 _errHandler.sync(this); 13980 _la = _input.LA(1); 13981 } 13982 setState(1627); 13983 _la = _input.LA(1); 13984 if ( !(_la==END || _la==SLASH_END) ) { 13985 _errHandler.recoverInline(this); 13986 } 13987 else { 13988 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13989 _errHandler.reportMatch(this); 13990 consume(); 13991 } 13992 } 13993 } 13994 catch (RecognitionException re) { 13995 _localctx.exception = re; 13996 _errHandler.reportError(this, re); 13997 _errHandler.recover(this, re); 13998 } 13999 finally { 14000 exitRule(); 14001 } 14002 return _localctx; 14003 } 14004 14005 public static class FrameTagContext extends ParserRuleContext { 14006 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14007 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 14008 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14009 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14010 public List<AttributeContext> attribute() { 14011 return getRuleContexts(AttributeContext.class); 14012 } 14013 public AttributeContext attribute(int i) { 14014 return getRuleContext(AttributeContext.class,i); 14015 } 14016 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14017 public TerminalNode NEWLINE(int i) { 14018 return getToken(JavadocParser.NEWLINE, i); 14019 } 14020 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14021 public TerminalNode LEADING_ASTERISK(int i) { 14022 return getToken(JavadocParser.LEADING_ASTERISK, i); 14023 } 14024 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14025 public TerminalNode WS(int i) { 14026 return getToken(JavadocParser.WS, i); 14027 } 14028 public FrameTagContext(ParserRuleContext parent, int invokingState) { 14029 super(parent, invokingState); 14030 } 14031 @Override public int getRuleIndex() { return RULE_frameTag; } 14032 } 14033 14034 public final FrameTagContext frameTag() throws RecognitionException { 14035 FrameTagContext _localctx = new FrameTagContext(_ctx, getState()); 14036 enterRule(_localctx, 116, RULE_frameTag); 14037 int _la; 14038 try { 14039 enterOuterAlt(_localctx, 1); 14040 { 14041 setState(1629); 14042 match(START); 14043 setState(1630); 14044 match(FRAME_HTML_TAG_NAME); 14045 setState(1637); 14046 _errHandler.sync(this); 14047 _la = _input.LA(1); 14048 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14049 { 14050 setState(1635); 14051 _errHandler.sync(this); 14052 switch (_input.LA(1)) { 14053 case HTML_TAG_NAME: 14054 { 14055 setState(1631); 14056 attribute(); 14057 } 14058 break; 14059 case NEWLINE: 14060 { 14061 setState(1632); 14062 match(NEWLINE); 14063 } 14064 break; 14065 case LEADING_ASTERISK: 14066 { 14067 setState(1633); 14068 match(LEADING_ASTERISK); 14069 } 14070 break; 14071 case WS: 14072 { 14073 setState(1634); 14074 match(WS); 14075 } 14076 break; 14077 default: 14078 throw new NoViableAltException(this); 14079 } 14080 } 14081 setState(1639); 14082 _errHandler.sync(this); 14083 _la = _input.LA(1); 14084 } 14085 setState(1640); 14086 _la = _input.LA(1); 14087 if ( !(_la==END || _la==SLASH_END) ) { 14088 _errHandler.recoverInline(this); 14089 } 14090 else { 14091 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14092 _errHandler.reportMatch(this); 14093 consume(); 14094 } 14095 } 14096 } 14097 catch (RecognitionException re) { 14098 _localctx.exception = re; 14099 _errHandler.reportError(this, re); 14100 _errHandler.recover(this, re); 14101 } 14102 finally { 14103 exitRule(); 14104 } 14105 return _localctx; 14106 } 14107 14108 public static class HrTagContext extends ParserRuleContext { 14109 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14110 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 14111 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14112 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14113 public List<AttributeContext> attribute() { 14114 return getRuleContexts(AttributeContext.class); 14115 } 14116 public AttributeContext attribute(int i) { 14117 return getRuleContext(AttributeContext.class,i); 14118 } 14119 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14120 public TerminalNode NEWLINE(int i) { 14121 return getToken(JavadocParser.NEWLINE, i); 14122 } 14123 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14124 public TerminalNode LEADING_ASTERISK(int i) { 14125 return getToken(JavadocParser.LEADING_ASTERISK, i); 14126 } 14127 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14128 public TerminalNode WS(int i) { 14129 return getToken(JavadocParser.WS, i); 14130 } 14131 public HrTagContext(ParserRuleContext parent, int invokingState) { 14132 super(parent, invokingState); 14133 } 14134 @Override public int getRuleIndex() { return RULE_hrTag; } 14135 } 14136 14137 public final HrTagContext hrTag() throws RecognitionException { 14138 HrTagContext _localctx = new HrTagContext(_ctx, getState()); 14139 enterRule(_localctx, 118, RULE_hrTag); 14140 int _la; 14141 try { 14142 enterOuterAlt(_localctx, 1); 14143 { 14144 setState(1642); 14145 match(START); 14146 setState(1643); 14147 match(HR_HTML_TAG_NAME); 14148 setState(1650); 14149 _errHandler.sync(this); 14150 _la = _input.LA(1); 14151 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14152 { 14153 setState(1648); 14154 _errHandler.sync(this); 14155 switch (_input.LA(1)) { 14156 case HTML_TAG_NAME: 14157 { 14158 setState(1644); 14159 attribute(); 14160 } 14161 break; 14162 case NEWLINE: 14163 { 14164 setState(1645); 14165 match(NEWLINE); 14166 } 14167 break; 14168 case LEADING_ASTERISK: 14169 { 14170 setState(1646); 14171 match(LEADING_ASTERISK); 14172 } 14173 break; 14174 case WS: 14175 { 14176 setState(1647); 14177 match(WS); 14178 } 14179 break; 14180 default: 14181 throw new NoViableAltException(this); 14182 } 14183 } 14184 setState(1652); 14185 _errHandler.sync(this); 14186 _la = _input.LA(1); 14187 } 14188 setState(1653); 14189 _la = _input.LA(1); 14190 if ( !(_la==END || _la==SLASH_END) ) { 14191 _errHandler.recoverInline(this); 14192 } 14193 else { 14194 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14195 _errHandler.reportMatch(this); 14196 consume(); 14197 } 14198 } 14199 } 14200 catch (RecognitionException re) { 14201 _localctx.exception = re; 14202 _errHandler.reportError(this, re); 14203 _errHandler.recover(this, re); 14204 } 14205 finally { 14206 exitRule(); 14207 } 14208 return _localctx; 14209 } 14210 14211 public static class ImgTagContext extends ParserRuleContext { 14212 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14213 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 14214 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14215 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14216 public List<AttributeContext> attribute() { 14217 return getRuleContexts(AttributeContext.class); 14218 } 14219 public AttributeContext attribute(int i) { 14220 return getRuleContext(AttributeContext.class,i); 14221 } 14222 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14223 public TerminalNode NEWLINE(int i) { 14224 return getToken(JavadocParser.NEWLINE, i); 14225 } 14226 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14227 public TerminalNode LEADING_ASTERISK(int i) { 14228 return getToken(JavadocParser.LEADING_ASTERISK, i); 14229 } 14230 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14231 public TerminalNode WS(int i) { 14232 return getToken(JavadocParser.WS, i); 14233 } 14234 public ImgTagContext(ParserRuleContext parent, int invokingState) { 14235 super(parent, invokingState); 14236 } 14237 @Override public int getRuleIndex() { return RULE_imgTag; } 14238 } 14239 14240 public final ImgTagContext imgTag() throws RecognitionException { 14241 ImgTagContext _localctx = new ImgTagContext(_ctx, getState()); 14242 enterRule(_localctx, 120, RULE_imgTag); 14243 int _la; 14244 try { 14245 enterOuterAlt(_localctx, 1); 14246 { 14247 setState(1655); 14248 match(START); 14249 setState(1656); 14250 match(IMG_HTML_TAG_NAME); 14251 setState(1663); 14252 _errHandler.sync(this); 14253 _la = _input.LA(1); 14254 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14255 { 14256 setState(1661); 14257 _errHandler.sync(this); 14258 switch (_input.LA(1)) { 14259 case HTML_TAG_NAME: 14260 { 14261 setState(1657); 14262 attribute(); 14263 } 14264 break; 14265 case NEWLINE: 14266 { 14267 setState(1658); 14268 match(NEWLINE); 14269 } 14270 break; 14271 case LEADING_ASTERISK: 14272 { 14273 setState(1659); 14274 match(LEADING_ASTERISK); 14275 } 14276 break; 14277 case WS: 14278 { 14279 setState(1660); 14280 match(WS); 14281 } 14282 break; 14283 default: 14284 throw new NoViableAltException(this); 14285 } 14286 } 14287 setState(1665); 14288 _errHandler.sync(this); 14289 _la = _input.LA(1); 14290 } 14291 setState(1666); 14292 _la = _input.LA(1); 14293 if ( !(_la==END || _la==SLASH_END) ) { 14294 _errHandler.recoverInline(this); 14295 } 14296 else { 14297 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14298 _errHandler.reportMatch(this); 14299 consume(); 14300 } 14301 } 14302 } 14303 catch (RecognitionException re) { 14304 _localctx.exception = re; 14305 _errHandler.reportError(this, re); 14306 _errHandler.recover(this, re); 14307 } 14308 finally { 14309 exitRule(); 14310 } 14311 return _localctx; 14312 } 14313 14314 public static class InputTagContext extends ParserRuleContext { 14315 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14316 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 14317 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14318 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14319 public List<AttributeContext> attribute() { 14320 return getRuleContexts(AttributeContext.class); 14321 } 14322 public AttributeContext attribute(int i) { 14323 return getRuleContext(AttributeContext.class,i); 14324 } 14325 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14326 public TerminalNode NEWLINE(int i) { 14327 return getToken(JavadocParser.NEWLINE, i); 14328 } 14329 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14330 public TerminalNode LEADING_ASTERISK(int i) { 14331 return getToken(JavadocParser.LEADING_ASTERISK, i); 14332 } 14333 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14334 public TerminalNode WS(int i) { 14335 return getToken(JavadocParser.WS, i); 14336 } 14337 public InputTagContext(ParserRuleContext parent, int invokingState) { 14338 super(parent, invokingState); 14339 } 14340 @Override public int getRuleIndex() { return RULE_inputTag; } 14341 } 14342 14343 public final InputTagContext inputTag() throws RecognitionException { 14344 InputTagContext _localctx = new InputTagContext(_ctx, getState()); 14345 enterRule(_localctx, 122, RULE_inputTag); 14346 int _la; 14347 try { 14348 enterOuterAlt(_localctx, 1); 14349 { 14350 setState(1668); 14351 match(START); 14352 setState(1669); 14353 match(INPUT_HTML_TAG_NAME); 14354 setState(1676); 14355 _errHandler.sync(this); 14356 _la = _input.LA(1); 14357 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14358 { 14359 setState(1674); 14360 _errHandler.sync(this); 14361 switch (_input.LA(1)) { 14362 case HTML_TAG_NAME: 14363 { 14364 setState(1670); 14365 attribute(); 14366 } 14367 break; 14368 case NEWLINE: 14369 { 14370 setState(1671); 14371 match(NEWLINE); 14372 } 14373 break; 14374 case LEADING_ASTERISK: 14375 { 14376 setState(1672); 14377 match(LEADING_ASTERISK); 14378 } 14379 break; 14380 case WS: 14381 { 14382 setState(1673); 14383 match(WS); 14384 } 14385 break; 14386 default: 14387 throw new NoViableAltException(this); 14388 } 14389 } 14390 setState(1678); 14391 _errHandler.sync(this); 14392 _la = _input.LA(1); 14393 } 14394 setState(1679); 14395 _la = _input.LA(1); 14396 if ( !(_la==END || _la==SLASH_END) ) { 14397 _errHandler.recoverInline(this); 14398 } 14399 else { 14400 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14401 _errHandler.reportMatch(this); 14402 consume(); 14403 } 14404 } 14405 } 14406 catch (RecognitionException re) { 14407 _localctx.exception = re; 14408 _errHandler.reportError(this, re); 14409 _errHandler.recover(this, re); 14410 } 14411 finally { 14412 exitRule(); 14413 } 14414 return _localctx; 14415 } 14416 14417 public static class IsindexTagContext extends ParserRuleContext { 14418 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14419 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 14420 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14421 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14422 public List<AttributeContext> attribute() { 14423 return getRuleContexts(AttributeContext.class); 14424 } 14425 public AttributeContext attribute(int i) { 14426 return getRuleContext(AttributeContext.class,i); 14427 } 14428 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14429 public TerminalNode NEWLINE(int i) { 14430 return getToken(JavadocParser.NEWLINE, i); 14431 } 14432 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14433 public TerminalNode LEADING_ASTERISK(int i) { 14434 return getToken(JavadocParser.LEADING_ASTERISK, i); 14435 } 14436 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14437 public TerminalNode WS(int i) { 14438 return getToken(JavadocParser.WS, i); 14439 } 14440 public IsindexTagContext(ParserRuleContext parent, int invokingState) { 14441 super(parent, invokingState); 14442 } 14443 @Override public int getRuleIndex() { return RULE_isindexTag; } 14444 } 14445 14446 public final IsindexTagContext isindexTag() throws RecognitionException { 14447 IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState()); 14448 enterRule(_localctx, 124, RULE_isindexTag); 14449 int _la; 14450 try { 14451 enterOuterAlt(_localctx, 1); 14452 { 14453 setState(1681); 14454 match(START); 14455 setState(1682); 14456 match(ISINDEX_HTML_TAG_NAME); 14457 setState(1689); 14458 _errHandler.sync(this); 14459 _la = _input.LA(1); 14460 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14461 { 14462 setState(1687); 14463 _errHandler.sync(this); 14464 switch (_input.LA(1)) { 14465 case HTML_TAG_NAME: 14466 { 14467 setState(1683); 14468 attribute(); 14469 } 14470 break; 14471 case NEWLINE: 14472 { 14473 setState(1684); 14474 match(NEWLINE); 14475 } 14476 break; 14477 case LEADING_ASTERISK: 14478 { 14479 setState(1685); 14480 match(LEADING_ASTERISK); 14481 } 14482 break; 14483 case WS: 14484 { 14485 setState(1686); 14486 match(WS); 14487 } 14488 break; 14489 default: 14490 throw new NoViableAltException(this); 14491 } 14492 } 14493 setState(1691); 14494 _errHandler.sync(this); 14495 _la = _input.LA(1); 14496 } 14497 setState(1692); 14498 _la = _input.LA(1); 14499 if ( !(_la==END || _la==SLASH_END) ) { 14500 _errHandler.recoverInline(this); 14501 } 14502 else { 14503 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14504 _errHandler.reportMatch(this); 14505 consume(); 14506 } 14507 } 14508 } 14509 catch (RecognitionException re) { 14510 _localctx.exception = re; 14511 _errHandler.reportError(this, re); 14512 _errHandler.recover(this, re); 14513 } 14514 finally { 14515 exitRule(); 14516 } 14517 return _localctx; 14518 } 14519 14520 public static class LinkTagContext extends ParserRuleContext { 14521 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14522 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 14523 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14524 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14525 public List<AttributeContext> attribute() { 14526 return getRuleContexts(AttributeContext.class); 14527 } 14528 public AttributeContext attribute(int i) { 14529 return getRuleContext(AttributeContext.class,i); 14530 } 14531 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14532 public TerminalNode NEWLINE(int i) { 14533 return getToken(JavadocParser.NEWLINE, i); 14534 } 14535 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14536 public TerminalNode LEADING_ASTERISK(int i) { 14537 return getToken(JavadocParser.LEADING_ASTERISK, i); 14538 } 14539 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14540 public TerminalNode WS(int i) { 14541 return getToken(JavadocParser.WS, i); 14542 } 14543 public LinkTagContext(ParserRuleContext parent, int invokingState) { 14544 super(parent, invokingState); 14545 } 14546 @Override public int getRuleIndex() { return RULE_linkTag; } 14547 } 14548 14549 public final LinkTagContext linkTag() throws RecognitionException { 14550 LinkTagContext _localctx = new LinkTagContext(_ctx, getState()); 14551 enterRule(_localctx, 126, RULE_linkTag); 14552 int _la; 14553 try { 14554 enterOuterAlt(_localctx, 1); 14555 { 14556 setState(1694); 14557 match(START); 14558 setState(1695); 14559 match(LINK_HTML_TAG_NAME); 14560 setState(1702); 14561 _errHandler.sync(this); 14562 _la = _input.LA(1); 14563 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14564 { 14565 setState(1700); 14566 _errHandler.sync(this); 14567 switch (_input.LA(1)) { 14568 case HTML_TAG_NAME: 14569 { 14570 setState(1696); 14571 attribute(); 14572 } 14573 break; 14574 case NEWLINE: 14575 { 14576 setState(1697); 14577 match(NEWLINE); 14578 } 14579 break; 14580 case LEADING_ASTERISK: 14581 { 14582 setState(1698); 14583 match(LEADING_ASTERISK); 14584 } 14585 break; 14586 case WS: 14587 { 14588 setState(1699); 14589 match(WS); 14590 } 14591 break; 14592 default: 14593 throw new NoViableAltException(this); 14594 } 14595 } 14596 setState(1704); 14597 _errHandler.sync(this); 14598 _la = _input.LA(1); 14599 } 14600 setState(1705); 14601 _la = _input.LA(1); 14602 if ( !(_la==END || _la==SLASH_END) ) { 14603 _errHandler.recoverInline(this); 14604 } 14605 else { 14606 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14607 _errHandler.reportMatch(this); 14608 consume(); 14609 } 14610 } 14611 } 14612 catch (RecognitionException re) { 14613 _localctx.exception = re; 14614 _errHandler.reportError(this, re); 14615 _errHandler.recover(this, re); 14616 } 14617 finally { 14618 exitRule(); 14619 } 14620 return _localctx; 14621 } 14622 14623 public static class MetaTagContext extends ParserRuleContext { 14624 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14625 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 14626 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14627 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14628 public List<AttributeContext> attribute() { 14629 return getRuleContexts(AttributeContext.class); 14630 } 14631 public AttributeContext attribute(int i) { 14632 return getRuleContext(AttributeContext.class,i); 14633 } 14634 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14635 public TerminalNode NEWLINE(int i) { 14636 return getToken(JavadocParser.NEWLINE, i); 14637 } 14638 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14639 public TerminalNode LEADING_ASTERISK(int i) { 14640 return getToken(JavadocParser.LEADING_ASTERISK, i); 14641 } 14642 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14643 public TerminalNode WS(int i) { 14644 return getToken(JavadocParser.WS, i); 14645 } 14646 public MetaTagContext(ParserRuleContext parent, int invokingState) { 14647 super(parent, invokingState); 14648 } 14649 @Override public int getRuleIndex() { return RULE_metaTag; } 14650 } 14651 14652 public final MetaTagContext metaTag() throws RecognitionException { 14653 MetaTagContext _localctx = new MetaTagContext(_ctx, getState()); 14654 enterRule(_localctx, 128, RULE_metaTag); 14655 int _la; 14656 try { 14657 enterOuterAlt(_localctx, 1); 14658 { 14659 setState(1707); 14660 match(START); 14661 setState(1708); 14662 match(META_HTML_TAG_NAME); 14663 setState(1715); 14664 _errHandler.sync(this); 14665 _la = _input.LA(1); 14666 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14667 { 14668 setState(1713); 14669 _errHandler.sync(this); 14670 switch (_input.LA(1)) { 14671 case HTML_TAG_NAME: 14672 { 14673 setState(1709); 14674 attribute(); 14675 } 14676 break; 14677 case NEWLINE: 14678 { 14679 setState(1710); 14680 match(NEWLINE); 14681 } 14682 break; 14683 case LEADING_ASTERISK: 14684 { 14685 setState(1711); 14686 match(LEADING_ASTERISK); 14687 } 14688 break; 14689 case WS: 14690 { 14691 setState(1712); 14692 match(WS); 14693 } 14694 break; 14695 default: 14696 throw new NoViableAltException(this); 14697 } 14698 } 14699 setState(1717); 14700 _errHandler.sync(this); 14701 _la = _input.LA(1); 14702 } 14703 setState(1718); 14704 _la = _input.LA(1); 14705 if ( !(_la==END || _la==SLASH_END) ) { 14706 _errHandler.recoverInline(this); 14707 } 14708 else { 14709 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14710 _errHandler.reportMatch(this); 14711 consume(); 14712 } 14713 } 14714 } 14715 catch (RecognitionException re) { 14716 _localctx.exception = re; 14717 _errHandler.reportError(this, re); 14718 _errHandler.recover(this, re); 14719 } 14720 finally { 14721 exitRule(); 14722 } 14723 return _localctx; 14724 } 14725 14726 public static class ParamTagContext extends ParserRuleContext { 14727 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14728 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 14729 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14730 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14731 public List<AttributeContext> attribute() { 14732 return getRuleContexts(AttributeContext.class); 14733 } 14734 public AttributeContext attribute(int i) { 14735 return getRuleContext(AttributeContext.class,i); 14736 } 14737 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14738 public TerminalNode NEWLINE(int i) { 14739 return getToken(JavadocParser.NEWLINE, i); 14740 } 14741 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14742 public TerminalNode LEADING_ASTERISK(int i) { 14743 return getToken(JavadocParser.LEADING_ASTERISK, i); 14744 } 14745 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14746 public TerminalNode WS(int i) { 14747 return getToken(JavadocParser.WS, i); 14748 } 14749 public ParamTagContext(ParserRuleContext parent, int invokingState) { 14750 super(parent, invokingState); 14751 } 14752 @Override public int getRuleIndex() { return RULE_paramTag; } 14753 } 14754 14755 public final ParamTagContext paramTag() throws RecognitionException { 14756 ParamTagContext _localctx = new ParamTagContext(_ctx, getState()); 14757 enterRule(_localctx, 130, RULE_paramTag); 14758 int _la; 14759 try { 14760 enterOuterAlt(_localctx, 1); 14761 { 14762 setState(1720); 14763 match(START); 14764 setState(1721); 14765 match(PARAM_HTML_TAG_NAME); 14766 setState(1728); 14767 _errHandler.sync(this); 14768 _la = _input.LA(1); 14769 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14770 { 14771 setState(1726); 14772 _errHandler.sync(this); 14773 switch (_input.LA(1)) { 14774 case HTML_TAG_NAME: 14775 { 14776 setState(1722); 14777 attribute(); 14778 } 14779 break; 14780 case NEWLINE: 14781 { 14782 setState(1723); 14783 match(NEWLINE); 14784 } 14785 break; 14786 case LEADING_ASTERISK: 14787 { 14788 setState(1724); 14789 match(LEADING_ASTERISK); 14790 } 14791 break; 14792 case WS: 14793 { 14794 setState(1725); 14795 match(WS); 14796 } 14797 break; 14798 default: 14799 throw new NoViableAltException(this); 14800 } 14801 } 14802 setState(1730); 14803 _errHandler.sync(this); 14804 _la = _input.LA(1); 14805 } 14806 setState(1731); 14807 _la = _input.LA(1); 14808 if ( !(_la==END || _la==SLASH_END) ) { 14809 _errHandler.recoverInline(this); 14810 } 14811 else { 14812 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14813 _errHandler.reportMatch(this); 14814 consume(); 14815 } 14816 } 14817 } 14818 catch (RecognitionException re) { 14819 _localctx.exception = re; 14820 _errHandler.reportError(this, re); 14821 _errHandler.recover(this, re); 14822 } 14823 finally { 14824 exitRule(); 14825 } 14826 return _localctx; 14827 } 14828 14829 public static class WrongSingletonTagContext extends ParserRuleContext { 14830 public SingletonTagNameContext singletonTagName; 14831 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14832 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 14833 public SingletonTagNameContext singletonTagName() { 14834 return getRuleContext(SingletonTagNameContext.class,0); 14835 } 14836 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14837 public WrongSingletonTagContext(ParserRuleContext parent, int invokingState) { 14838 super(parent, invokingState); 14839 } 14840 @Override public int getRuleIndex() { return RULE_wrongSingletonTag; } 14841 } 14842 14843 public final WrongSingletonTagContext wrongSingletonTag() throws RecognitionException { 14844 WrongSingletonTagContext _localctx = new WrongSingletonTagContext(_ctx, getState()); 14845 enterRule(_localctx, 132, RULE_wrongSingletonTag); 14846 try { 14847 enterOuterAlt(_localctx, 1); 14848 { 14849 setState(1733); 14850 match(START); 14851 setState(1734); 14852 match(SLASH); 14853 setState(1735); 14854 ((WrongSingletonTagContext)_localctx).singletonTagName = singletonTagName(); 14855 setState(1736); 14856 match(END); 14857 notifyErrorListeners((((WrongSingletonTagContext)_localctx).singletonTagName!=null?(((WrongSingletonTagContext)_localctx).singletonTagName.start):null), 14858 "javadoc.wrong.singleton.html.tag", null); 14859 } 14860 } 14861 catch (RecognitionException re) { 14862 _localctx.exception = re; 14863 _errHandler.reportError(this, re); 14864 _errHandler.recover(this, re); 14865 } 14866 finally { 14867 exitRule(); 14868 } 14869 return _localctx; 14870 } 14871 14872 public static class SingletonTagNameContext extends ParserRuleContext { 14873 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 14874 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 14875 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 14876 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 14877 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 14878 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 14879 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 14880 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 14881 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 14882 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 14883 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 14884 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 14885 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 14886 public TerminalNode EMBED_HTML_TAG_NAME() { return getToken(JavadocParser.EMBED_HTML_TAG_NAME, 0); } 14887 public TerminalNode KEYGEN_HTML_TAG_NAME() { return getToken(JavadocParser.KEYGEN_HTML_TAG_NAME, 0); } 14888 public TerminalNode SOURCE_HTML_TAG_NAME() { return getToken(JavadocParser.SOURCE_HTML_TAG_NAME, 0); } 14889 public TerminalNode TRACK_HTML_TAG_NAME() { return getToken(JavadocParser.TRACK_HTML_TAG_NAME, 0); } 14890 public TerminalNode WBR_HTML_TAG_NAME() { return getToken(JavadocParser.WBR_HTML_TAG_NAME, 0); } 14891 public SingletonTagNameContext(ParserRuleContext parent, int invokingState) { 14892 super(parent, invokingState); 14893 } 14894 @Override public int getRuleIndex() { return RULE_singletonTagName; } 14895 } 14896 14897 public final SingletonTagNameContext singletonTagName() throws RecognitionException { 14898 SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState()); 14899 enterRule(_localctx, 134, RULE_singletonTagName); 14900 int _la; 14901 try { 14902 enterOuterAlt(_localctx, 1); 14903 { 14904 setState(1739); 14905 _la = _input.LA(1); 14906 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)) ) { 14907 _errHandler.recoverInline(this); 14908 } 14909 else { 14910 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14911 _errHandler.reportMatch(this); 14912 consume(); 14913 } 14914 } 14915 } 14916 catch (RecognitionException re) { 14917 _localctx.exception = re; 14918 _errHandler.reportError(this, re); 14919 _errHandler.recover(this, re); 14920 } 14921 finally { 14922 exitRule(); 14923 } 14924 return _localctx; 14925 } 14926 14927 public static class DescriptionContext extends ParserRuleContext { 14928 public List<HtmlCommentContext> htmlComment() { 14929 return getRuleContexts(HtmlCommentContext.class); 14930 } 14931 public HtmlCommentContext htmlComment(int i) { 14932 return getRuleContext(HtmlCommentContext.class,i); 14933 } 14934 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 14935 public TerminalNode CDATA(int i) { 14936 return getToken(JavadocParser.CDATA, i); 14937 } 14938 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14939 public TerminalNode NEWLINE(int i) { 14940 return getToken(JavadocParser.NEWLINE, i); 14941 } 14942 public List<TextContext> text() { 14943 return getRuleContexts(TextContext.class); 14944 } 14945 public TextContext text(int i) { 14946 return getRuleContext(TextContext.class,i); 14947 } 14948 public List<JavadocInlineTagContext> javadocInlineTag() { 14949 return getRuleContexts(JavadocInlineTagContext.class); 14950 } 14951 public JavadocInlineTagContext javadocInlineTag(int i) { 14952 return getRuleContext(JavadocInlineTagContext.class,i); 14953 } 14954 public List<HtmlElementContext> htmlElement() { 14955 return getRuleContexts(HtmlElementContext.class); 14956 } 14957 public HtmlElementContext htmlElement(int i) { 14958 return getRuleContext(HtmlElementContext.class,i); 14959 } 14960 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14961 public TerminalNode LEADING_ASTERISK(int i) { 14962 return getToken(JavadocParser.LEADING_ASTERISK, i); 14963 } 14964 public DescriptionContext(ParserRuleContext parent, int invokingState) { 14965 super(parent, invokingState); 14966 } 14967 @Override public int getRuleIndex() { return RULE_description; } 14968 } 14969 14970 public final DescriptionContext description() throws RecognitionException { 14971 DescriptionContext _localctx = new DescriptionContext(_ctx, getState()); 14972 enterRule(_localctx, 136, RULE_description); 14973 try { 14974 int _alt; 14975 enterOuterAlt(_localctx, 1); 14976 { 14977 setState(1749); 14978 _errHandler.sync(this); 14979 _alt = 1; 14980 do { 14981 switch (_alt) { 14982 case 1: 14983 { 14984 setState(1749); 14985 _errHandler.sync(this); 14986 switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) { 14987 case 1: 14988 { 14989 { 14990 setState(1741); 14991 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 14992 setState(1742); 14993 match(LEADING_ASTERISK); 14994 } 14995 } 14996 break; 14997 case 2: 14998 { 14999 setState(1743); 15000 htmlComment(); 15001 } 15002 break; 15003 case 3: 15004 { 15005 setState(1744); 15006 match(CDATA); 15007 } 15008 break; 15009 case 4: 15010 { 15011 setState(1745); 15012 match(NEWLINE); 15013 } 15014 break; 15015 case 5: 15016 { 15017 setState(1746); 15018 text(); 15019 } 15020 break; 15021 case 6: 15022 { 15023 setState(1747); 15024 javadocInlineTag(); 15025 } 15026 break; 15027 case 7: 15028 { 15029 setState(1748); 15030 htmlElement(); 15031 } 15032 break; 15033 } 15034 } 15035 break; 15036 default: 15037 throw new NoViableAltException(this); 15038 } 15039 setState(1751); 15040 _errHandler.sync(this); 15041 _alt = getInterpreter().adaptivePredict(_input,119,_ctx); 15042 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15043 } 15044 } 15045 catch (RecognitionException re) { 15046 _localctx.exception = re; 15047 _errHandler.reportError(this, re); 15048 _errHandler.recover(this, re); 15049 } 15050 finally { 15051 exitRule(); 15052 } 15053 return _localctx; 15054 } 15055 15056 public static class ReferenceContext extends ParserRuleContext { 15057 public TerminalNode PACKAGE_CLASS() { return getToken(JavadocParser.PACKAGE_CLASS, 0); } 15058 public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); } 15059 public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); } 15060 public ParametersContext parameters() { 15061 return getRuleContext(ParametersContext.class,0); 15062 } 15063 public ReferenceContext(ParserRuleContext parent, int invokingState) { 15064 super(parent, invokingState); 15065 } 15066 @Override public int getRuleIndex() { return RULE_reference; } 15067 } 15068 15069 public final ReferenceContext reference() throws RecognitionException { 15070 ReferenceContext _localctx = new ReferenceContext(_ctx, getState()); 15071 enterRule(_localctx, 138, RULE_reference); 15072 int _la; 15073 try { 15074 setState(1766); 15075 _errHandler.sync(this); 15076 switch (_input.LA(1)) { 15077 case PACKAGE_CLASS: 15078 enterOuterAlt(_localctx, 1); 15079 { 15080 setState(1753); 15081 match(PACKAGE_CLASS); 15082 setState(1759); 15083 _errHandler.sync(this); 15084 _la = _input.LA(1); 15085 if (_la==HASH) { 15086 { 15087 setState(1754); 15088 match(HASH); 15089 setState(1755); 15090 match(MEMBER); 15091 setState(1757); 15092 _errHandler.sync(this); 15093 _la = _input.LA(1); 15094 if (_la==LEFT_BRACE) { 15095 { 15096 setState(1756); 15097 parameters(); 15098 } 15099 } 15100 15101 } 15102 } 15103 15104 } 15105 break; 15106 case HASH: 15107 enterOuterAlt(_localctx, 2); 15108 { 15109 setState(1761); 15110 match(HASH); 15111 setState(1762); 15112 match(MEMBER); 15113 setState(1764); 15114 _errHandler.sync(this); 15115 _la = _input.LA(1); 15116 if (_la==LEFT_BRACE) { 15117 { 15118 setState(1763); 15119 parameters(); 15120 } 15121 } 15122 15123 } 15124 break; 15125 default: 15126 throw new NoViableAltException(this); 15127 } 15128 } 15129 catch (RecognitionException re) { 15130 _localctx.exception = re; 15131 _errHandler.reportError(this, re); 15132 _errHandler.recover(this, re); 15133 } 15134 finally { 15135 exitRule(); 15136 } 15137 return _localctx; 15138 } 15139 15140 public static class ParametersContext extends ParserRuleContext { 15141 public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); } 15142 public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); } 15143 public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); } 15144 public TerminalNode ARGUMENT(int i) { 15145 return getToken(JavadocParser.ARGUMENT, i); 15146 } 15147 public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); } 15148 public TerminalNode COMMA(int i) { 15149 return getToken(JavadocParser.COMMA, i); 15150 } 15151 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15152 public TerminalNode WS(int i) { 15153 return getToken(JavadocParser.WS, i); 15154 } 15155 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15156 public TerminalNode NEWLINE(int i) { 15157 return getToken(JavadocParser.NEWLINE, i); 15158 } 15159 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15160 public TerminalNode LEADING_ASTERISK(int i) { 15161 return getToken(JavadocParser.LEADING_ASTERISK, i); 15162 } 15163 public ParametersContext(ParserRuleContext parent, int invokingState) { 15164 super(parent, invokingState); 15165 } 15166 @Override public int getRuleIndex() { return RULE_parameters; } 15167 } 15168 15169 public final ParametersContext parameters() throws RecognitionException { 15170 ParametersContext _localctx = new ParametersContext(_ctx, getState()); 15171 enterRule(_localctx, 140, RULE_parameters); 15172 int _la; 15173 try { 15174 enterOuterAlt(_localctx, 1); 15175 { 15176 setState(1768); 15177 match(LEFT_BRACE); 15178 setState(1772); 15179 _errHandler.sync(this); 15180 _la = _input.LA(1); 15181 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) { 15182 { 15183 { 15184 setState(1769); 15185 _la = _input.LA(1); 15186 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) { 15187 _errHandler.recoverInline(this); 15188 } 15189 else { 15190 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15191 _errHandler.reportMatch(this); 15192 consume(); 15193 } 15194 } 15195 } 15196 setState(1774); 15197 _errHandler.sync(this); 15198 _la = _input.LA(1); 15199 } 15200 setState(1775); 15201 match(RIGHT_BRACE); 15202 } 15203 } 15204 catch (RecognitionException re) { 15205 _localctx.exception = re; 15206 _errHandler.reportError(this, re); 15207 _errHandler.recover(this, re); 15208 } 15209 finally { 15210 exitRule(); 15211 } 15212 return _localctx; 15213 } 15214 15215 public static class JavadocTagContext extends ParserRuleContext { 15216 public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); } 15217 public DescriptionContext description() { 15218 return getRuleContext(DescriptionContext.class,0); 15219 } 15220 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15221 public TerminalNode WS(int i) { 15222 return getToken(JavadocParser.WS, i); 15223 } 15224 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15225 public TerminalNode NEWLINE(int i) { 15226 return getToken(JavadocParser.NEWLINE, i); 15227 } 15228 public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); } 15229 public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); } 15230 public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); } 15231 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15232 public TerminalNode LEADING_ASTERISK(int i) { 15233 return getToken(JavadocParser.LEADING_ASTERISK, i); 15234 } 15235 public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); } 15236 public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); } 15237 public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); } 15238 public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); } 15239 public ReferenceContext reference() { 15240 return getRuleContext(ReferenceContext.class,0); 15241 } 15242 public TerminalNode STRING() { return getToken(JavadocParser.STRING, 0); } 15243 public HtmlElementContext htmlElement() { 15244 return getRuleContext(HtmlElementContext.class,0); 15245 } 15246 public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); } 15247 public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); } 15248 public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); } 15249 public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); } 15250 public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); } 15251 public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); } 15252 public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); } 15253 public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); } 15254 public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); } 15255 public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); } 15256 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 15257 public JavadocTagContext(ParserRuleContext parent, int invokingState) { 15258 super(parent, invokingState); 15259 } 15260 @Override public int getRuleIndex() { return RULE_javadocTag; } 15261 } 15262 15263 public final JavadocTagContext javadocTag() throws RecognitionException { 15264 JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState()); 15265 enterRule(_localctx, 142, RULE_javadocTag); 15266 int _la; 15267 try { 15268 int _alt; 15269 setState(1972); 15270 _errHandler.sync(this); 15271 switch (_input.LA(1)) { 15272 case AUTHOR_LITERAL: 15273 enterOuterAlt(_localctx, 1); 15274 { 15275 setState(1777); 15276 match(AUTHOR_LITERAL); 15277 setState(1779); 15278 _errHandler.sync(this); 15279 _alt = 1; 15280 do { 15281 switch (_alt) { 15282 case 1: 15283 { 15284 { 15285 setState(1778); 15286 _la = _input.LA(1); 15287 if ( !(_la==WS || _la==NEWLINE) ) { 15288 _errHandler.recoverInline(this); 15289 } 15290 else { 15291 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15292 _errHandler.reportMatch(this); 15293 consume(); 15294 } 15295 } 15296 } 15297 break; 15298 default: 15299 throw new NoViableAltException(this); 15300 } 15301 setState(1781); 15302 _errHandler.sync(this); 15303 _alt = getInterpreter().adaptivePredict(_input,125,_ctx); 15304 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15305 setState(1783); 15306 description(); 15307 } 15308 break; 15309 case DEPRECATED_LITERAL: 15310 enterOuterAlt(_localctx, 2); 15311 { 15312 setState(1784); 15313 match(DEPRECATED_LITERAL); 15314 setState(1788); 15315 _errHandler.sync(this); 15316 _alt = getInterpreter().adaptivePredict(_input,126,_ctx); 15317 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15318 if ( _alt==1 ) { 15319 { 15320 { 15321 setState(1785); 15322 _la = _input.LA(1); 15323 if ( !(_la==WS || _la==NEWLINE) ) { 15324 _errHandler.recoverInline(this); 15325 } 15326 else { 15327 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15328 _errHandler.reportMatch(this); 15329 consume(); 15330 } 15331 } 15332 } 15333 } 15334 setState(1790); 15335 _errHandler.sync(this); 15336 _alt = getInterpreter().adaptivePredict(_input,126,_ctx); 15337 } 15338 setState(1793); 15339 _errHandler.sync(this); 15340 switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) { 15341 case 1: 15342 { 15343 setState(1791); 15344 _la = _input.LA(1); 15345 if ( !(_la==WS || _la==NEWLINE) ) { 15346 _errHandler.recoverInline(this); 15347 } 15348 else { 15349 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15350 _errHandler.reportMatch(this); 15351 consume(); 15352 } 15353 setState(1792); 15354 description(); 15355 } 15356 break; 15357 } 15358 } 15359 break; 15360 case EXCEPTION_LITERAL: 15361 enterOuterAlt(_localctx, 3); 15362 { 15363 setState(1795); 15364 match(EXCEPTION_LITERAL); 15365 setState(1800); 15366 _errHandler.sync(this); 15367 _alt = 1; 15368 do { 15369 switch (_alt) { 15370 case 1: 15371 { 15372 setState(1800); 15373 _errHandler.sync(this); 15374 switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { 15375 case 1: 15376 { 15377 setState(1796); 15378 match(WS); 15379 } 15380 break; 15381 case 2: 15382 { 15383 setState(1797); 15384 match(NEWLINE); 15385 } 15386 break; 15387 case 3: 15388 { 15389 setState(1798); 15390 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 15391 setState(1799); 15392 match(LEADING_ASTERISK); 15393 } 15394 break; 15395 } 15396 } 15397 break; 15398 default: 15399 throw new NoViableAltException(this); 15400 } 15401 setState(1802); 15402 _errHandler.sync(this); 15403 _alt = getInterpreter().adaptivePredict(_input,129,_ctx); 15404 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15405 setState(1804); 15406 match(CLASS_NAME); 15407 setState(1808); 15408 _errHandler.sync(this); 15409 _alt = getInterpreter().adaptivePredict(_input,130,_ctx); 15410 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15411 if ( _alt==1 ) { 15412 { 15413 { 15414 setState(1805); 15415 _la = _input.LA(1); 15416 if ( !(_la==WS || _la==NEWLINE) ) { 15417 _errHandler.recoverInline(this); 15418 } 15419 else { 15420 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15421 _errHandler.reportMatch(this); 15422 consume(); 15423 } 15424 } 15425 } 15426 } 15427 setState(1810); 15428 _errHandler.sync(this); 15429 _alt = getInterpreter().adaptivePredict(_input,130,_ctx); 15430 } 15431 setState(1813); 15432 _errHandler.sync(this); 15433 switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { 15434 case 1: 15435 { 15436 setState(1811); 15437 _la = _input.LA(1); 15438 if ( !(_la==WS || _la==NEWLINE) ) { 15439 _errHandler.recoverInline(this); 15440 } 15441 else { 15442 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15443 _errHandler.reportMatch(this); 15444 consume(); 15445 } 15446 setState(1812); 15447 description(); 15448 } 15449 break; 15450 } 15451 } 15452 break; 15453 case PARAM_LITERAL: 15454 enterOuterAlt(_localctx, 4); 15455 { 15456 setState(1815); 15457 match(PARAM_LITERAL); 15458 setState(1820); 15459 _errHandler.sync(this); 15460 _alt = 1; 15461 do { 15462 switch (_alt) { 15463 case 1: 15464 { 15465 setState(1820); 15466 _errHandler.sync(this); 15467 switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { 15468 case 1: 15469 { 15470 setState(1816); 15471 match(WS); 15472 } 15473 break; 15474 case 2: 15475 { 15476 setState(1817); 15477 match(NEWLINE); 15478 } 15479 break; 15480 case 3: 15481 { 15482 setState(1818); 15483 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 15484 setState(1819); 15485 match(LEADING_ASTERISK); 15486 } 15487 break; 15488 } 15489 } 15490 break; 15491 default: 15492 throw new NoViableAltException(this); 15493 } 15494 setState(1822); 15495 _errHandler.sync(this); 15496 _alt = getInterpreter().adaptivePredict(_input,133,_ctx); 15497 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15498 setState(1824); 15499 match(PARAMETER_NAME); 15500 setState(1828); 15501 _errHandler.sync(this); 15502 _alt = getInterpreter().adaptivePredict(_input,134,_ctx); 15503 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15504 if ( _alt==1 ) { 15505 { 15506 { 15507 setState(1825); 15508 _la = _input.LA(1); 15509 if ( !(_la==WS || _la==NEWLINE) ) { 15510 _errHandler.recoverInline(this); 15511 } 15512 else { 15513 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15514 _errHandler.reportMatch(this); 15515 consume(); 15516 } 15517 } 15518 } 15519 } 15520 setState(1830); 15521 _errHandler.sync(this); 15522 _alt = getInterpreter().adaptivePredict(_input,134,_ctx); 15523 } 15524 setState(1833); 15525 _errHandler.sync(this); 15526 switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) { 15527 case 1: 15528 { 15529 setState(1831); 15530 _la = _input.LA(1); 15531 if ( !(_la==WS || _la==NEWLINE) ) { 15532 _errHandler.recoverInline(this); 15533 } 15534 else { 15535 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15536 _errHandler.reportMatch(this); 15537 consume(); 15538 } 15539 setState(1832); 15540 description(); 15541 } 15542 break; 15543 } 15544 } 15545 break; 15546 case RETURN_LITERAL: 15547 enterOuterAlt(_localctx, 5); 15548 { 15549 setState(1835); 15550 match(RETURN_LITERAL); 15551 setState(1837); 15552 _errHandler.sync(this); 15553 _alt = 1; 15554 do { 15555 switch (_alt) { 15556 case 1: 15557 { 15558 { 15559 setState(1836); 15560 _la = _input.LA(1); 15561 if ( !(_la==WS || _la==NEWLINE) ) { 15562 _errHandler.recoverInline(this); 15563 } 15564 else { 15565 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15566 _errHandler.reportMatch(this); 15567 consume(); 15568 } 15569 } 15570 } 15571 break; 15572 default: 15573 throw new NoViableAltException(this); 15574 } 15575 setState(1839); 15576 _errHandler.sync(this); 15577 _alt = getInterpreter().adaptivePredict(_input,136,_ctx); 15578 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15579 setState(1841); 15580 description(); 15581 } 15582 break; 15583 case SEE_LITERAL: 15584 enterOuterAlt(_localctx, 6); 15585 { 15586 setState(1842); 15587 match(SEE_LITERAL); 15588 setState(1847); 15589 _errHandler.sync(this); 15590 _alt = 1; 15591 do { 15592 switch (_alt) { 15593 case 1: 15594 { 15595 setState(1847); 15596 _errHandler.sync(this); 15597 switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) { 15598 case 1: 15599 { 15600 setState(1843); 15601 match(WS); 15602 } 15603 break; 15604 case 2: 15605 { 15606 setState(1844); 15607 match(NEWLINE); 15608 } 15609 break; 15610 case 3: 15611 { 15612 setState(1845); 15613 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 15614 setState(1846); 15615 match(LEADING_ASTERISK); 15616 } 15617 break; 15618 } 15619 } 15620 break; 15621 default: 15622 throw new NoViableAltException(this); 15623 } 15624 setState(1849); 15625 _errHandler.sync(this); 15626 _alt = getInterpreter().adaptivePredict(_input,138,_ctx); 15627 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15628 setState(1854); 15629 _errHandler.sync(this); 15630 switch (_input.LA(1)) { 15631 case PACKAGE_CLASS: 15632 case HASH: 15633 { 15634 setState(1851); 15635 reference(); 15636 } 15637 break; 15638 case STRING: 15639 { 15640 setState(1852); 15641 match(STRING); 15642 } 15643 break; 15644 case START: 15645 { 15646 setState(1853); 15647 htmlElement(); 15648 } 15649 break; 15650 default: 15651 throw new NoViableAltException(this); 15652 } 15653 setState(1859); 15654 _errHandler.sync(this); 15655 _alt = getInterpreter().adaptivePredict(_input,140,_ctx); 15656 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15657 if ( _alt==1 ) { 15658 { 15659 { 15660 setState(1856); 15661 _la = _input.LA(1); 15662 if ( !(_la==WS || _la==NEWLINE) ) { 15663 _errHandler.recoverInline(this); 15664 } 15665 else { 15666 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15667 _errHandler.reportMatch(this); 15668 consume(); 15669 } 15670 } 15671 } 15672 } 15673 setState(1861); 15674 _errHandler.sync(this); 15675 _alt = getInterpreter().adaptivePredict(_input,140,_ctx); 15676 } 15677 setState(1864); 15678 _errHandler.sync(this); 15679 switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) { 15680 case 1: 15681 { 15682 setState(1862); 15683 _la = _input.LA(1); 15684 if ( !(_la==WS || _la==NEWLINE) ) { 15685 _errHandler.recoverInline(this); 15686 } 15687 else { 15688 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15689 _errHandler.reportMatch(this); 15690 consume(); 15691 } 15692 setState(1863); 15693 description(); 15694 } 15695 break; 15696 } 15697 } 15698 break; 15699 case SERIAL_LITERAL: 15700 enterOuterAlt(_localctx, 7); 15701 { 15702 setState(1866); 15703 match(SERIAL_LITERAL); 15704 setState(1870); 15705 _errHandler.sync(this); 15706 _alt = getInterpreter().adaptivePredict(_input,142,_ctx); 15707 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15708 if ( _alt==1 ) { 15709 { 15710 { 15711 setState(1867); 15712 _la = _input.LA(1); 15713 if ( !(_la==WS || _la==NEWLINE) ) { 15714 _errHandler.recoverInline(this); 15715 } 15716 else { 15717 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15718 _errHandler.reportMatch(this); 15719 consume(); 15720 } 15721 } 15722 } 15723 } 15724 setState(1872); 15725 _errHandler.sync(this); 15726 _alt = getInterpreter().adaptivePredict(_input,142,_ctx); 15727 } 15728 setState(1877); 15729 _errHandler.sync(this); 15730 switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) { 15731 case 1: 15732 { 15733 setState(1873); 15734 _la = _input.LA(1); 15735 if ( !(_la==WS || _la==NEWLINE) ) { 15736 _errHandler.recoverInline(this); 15737 } 15738 else { 15739 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15740 _errHandler.reportMatch(this); 15741 consume(); 15742 } 15743 setState(1874); 15744 description(); 15745 } 15746 break; 15747 case 2: 15748 { 15749 setState(1875); 15750 match(LITERAL_INCLUDE); 15751 } 15752 break; 15753 case 3: 15754 { 15755 setState(1876); 15756 match(LITERAL_EXCLUDE); 15757 } 15758 break; 15759 } 15760 setState(1882); 15761 _errHandler.sync(this); 15762 _alt = getInterpreter().adaptivePredict(_input,144,_ctx); 15763 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15764 if ( _alt==1 ) { 15765 { 15766 { 15767 setState(1879); 15768 _la = _input.LA(1); 15769 if ( !(_la==WS || _la==NEWLINE) ) { 15770 _errHandler.recoverInline(this); 15771 } 15772 else { 15773 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15774 _errHandler.reportMatch(this); 15775 consume(); 15776 } 15777 } 15778 } 15779 } 15780 setState(1884); 15781 _errHandler.sync(this); 15782 _alt = getInterpreter().adaptivePredict(_input,144,_ctx); 15783 } 15784 } 15785 break; 15786 case SERIAL_DATA_LITERAL: 15787 enterOuterAlt(_localctx, 8); 15788 { 15789 setState(1885); 15790 match(SERIAL_DATA_LITERAL); 15791 setState(1889); 15792 _errHandler.sync(this); 15793 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 15794 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15795 if ( _alt==1 ) { 15796 { 15797 { 15798 setState(1886); 15799 _la = _input.LA(1); 15800 if ( !(_la==WS || _la==NEWLINE) ) { 15801 _errHandler.recoverInline(this); 15802 } 15803 else { 15804 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15805 _errHandler.reportMatch(this); 15806 consume(); 15807 } 15808 } 15809 } 15810 } 15811 setState(1891); 15812 _errHandler.sync(this); 15813 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 15814 } 15815 setState(1894); 15816 _errHandler.sync(this); 15817 switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { 15818 case 1: 15819 { 15820 setState(1892); 15821 _la = _input.LA(1); 15822 if ( !(_la==WS || _la==NEWLINE) ) { 15823 _errHandler.recoverInline(this); 15824 } 15825 else { 15826 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15827 _errHandler.reportMatch(this); 15828 consume(); 15829 } 15830 setState(1893); 15831 description(); 15832 } 15833 break; 15834 } 15835 } 15836 break; 15837 case SERIAL_FIELD_LITERAL: 15838 enterOuterAlt(_localctx, 9); 15839 { 15840 setState(1896); 15841 match(SERIAL_FIELD_LITERAL); 15842 setState(1900); 15843 _errHandler.sync(this); 15844 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 15845 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15846 if ( _alt==1 ) { 15847 { 15848 { 15849 setState(1897); 15850 _la = _input.LA(1); 15851 if ( !(_la==WS || _la==NEWLINE) ) { 15852 _errHandler.recoverInline(this); 15853 } 15854 else { 15855 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15856 _errHandler.reportMatch(this); 15857 consume(); 15858 } 15859 } 15860 } 15861 } 15862 setState(1902); 15863 _errHandler.sync(this); 15864 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 15865 } 15866 setState(1905); 15867 _errHandler.sync(this); 15868 switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { 15869 case 1: 15870 { 15871 setState(1903); 15872 _la = _input.LA(1); 15873 if ( !(_la==WS || _la==NEWLINE) ) { 15874 _errHandler.recoverInline(this); 15875 } 15876 else { 15877 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15878 _errHandler.reportMatch(this); 15879 consume(); 15880 } 15881 setState(1904); 15882 match(FIELD_NAME); 15883 } 15884 break; 15885 } 15886 setState(1910); 15887 _errHandler.sync(this); 15888 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 15889 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15890 if ( _alt==1 ) { 15891 { 15892 { 15893 setState(1907); 15894 _la = _input.LA(1); 15895 if ( !(_la==WS || _la==NEWLINE) ) { 15896 _errHandler.recoverInline(this); 15897 } 15898 else { 15899 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15900 _errHandler.reportMatch(this); 15901 consume(); 15902 } 15903 } 15904 } 15905 } 15906 setState(1912); 15907 _errHandler.sync(this); 15908 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 15909 } 15910 setState(1915); 15911 _errHandler.sync(this); 15912 switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { 15913 case 1: 15914 { 15915 setState(1913); 15916 _la = _input.LA(1); 15917 if ( !(_la==WS || _la==NEWLINE) ) { 15918 _errHandler.recoverInline(this); 15919 } 15920 else { 15921 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15922 _errHandler.reportMatch(this); 15923 consume(); 15924 } 15925 setState(1914); 15926 match(FIELD_TYPE); 15927 } 15928 break; 15929 } 15930 setState(1920); 15931 _errHandler.sync(this); 15932 _alt = getInterpreter().adaptivePredict(_input,151,_ctx); 15933 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15934 if ( _alt==1 ) { 15935 { 15936 { 15937 setState(1917); 15938 _la = _input.LA(1); 15939 if ( !(_la==WS || _la==NEWLINE) ) { 15940 _errHandler.recoverInline(this); 15941 } 15942 else { 15943 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15944 _errHandler.reportMatch(this); 15945 consume(); 15946 } 15947 } 15948 } 15949 } 15950 setState(1922); 15951 _errHandler.sync(this); 15952 _alt = getInterpreter().adaptivePredict(_input,151,_ctx); 15953 } 15954 setState(1925); 15955 _errHandler.sync(this); 15956 switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) { 15957 case 1: 15958 { 15959 setState(1923); 15960 _la = _input.LA(1); 15961 if ( !(_la==WS || _la==NEWLINE) ) { 15962 _errHandler.recoverInline(this); 15963 } 15964 else { 15965 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15966 _errHandler.reportMatch(this); 15967 consume(); 15968 } 15969 setState(1924); 15970 description(); 15971 } 15972 break; 15973 } 15974 } 15975 break; 15976 case SINCE_LITERAL: 15977 enterOuterAlt(_localctx, 10); 15978 { 15979 setState(1927); 15980 match(SINCE_LITERAL); 15981 setState(1929); 15982 _errHandler.sync(this); 15983 _alt = 1; 15984 do { 15985 switch (_alt) { 15986 case 1: 15987 { 15988 { 15989 setState(1928); 15990 _la = _input.LA(1); 15991 if ( !(_la==WS || _la==NEWLINE) ) { 15992 _errHandler.recoverInline(this); 15993 } 15994 else { 15995 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15996 _errHandler.reportMatch(this); 15997 consume(); 15998 } 15999 } 16000 } 16001 break; 16002 default: 16003 throw new NoViableAltException(this); 16004 } 16005 setState(1931); 16006 _errHandler.sync(this); 16007 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 16008 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 16009 setState(1933); 16010 description(); 16011 } 16012 break; 16013 case THROWS_LITERAL: 16014 enterOuterAlt(_localctx, 11); 16015 { 16016 setState(1934); 16017 match(THROWS_LITERAL); 16018 setState(1939); 16019 _errHandler.sync(this); 16020 _alt = 1; 16021 do { 16022 switch (_alt) { 16023 case 1: 16024 { 16025 setState(1939); 16026 _errHandler.sync(this); 16027 switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) { 16028 case 1: 16029 { 16030 setState(1935); 16031 match(WS); 16032 } 16033 break; 16034 case 2: 16035 { 16036 setState(1936); 16037 match(NEWLINE); 16038 } 16039 break; 16040 case 3: 16041 { 16042 setState(1937); 16043 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 16044 setState(1938); 16045 match(LEADING_ASTERISK); 16046 } 16047 break; 16048 } 16049 } 16050 break; 16051 default: 16052 throw new NoViableAltException(this); 16053 } 16054 setState(1941); 16055 _errHandler.sync(this); 16056 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 16057 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 16058 setState(1943); 16059 match(CLASS_NAME); 16060 setState(1947); 16061 _errHandler.sync(this); 16062 _alt = getInterpreter().adaptivePredict(_input,156,_ctx); 16063 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 16064 if ( _alt==1 ) { 16065 { 16066 { 16067 setState(1944); 16068 _la = _input.LA(1); 16069 if ( !(_la==WS || _la==NEWLINE) ) { 16070 _errHandler.recoverInline(this); 16071 } 16072 else { 16073 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16074 _errHandler.reportMatch(this); 16075 consume(); 16076 } 16077 } 16078 } 16079 } 16080 setState(1949); 16081 _errHandler.sync(this); 16082 _alt = getInterpreter().adaptivePredict(_input,156,_ctx); 16083 } 16084 setState(1952); 16085 _errHandler.sync(this); 16086 switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { 16087 case 1: 16088 { 16089 setState(1950); 16090 _la = _input.LA(1); 16091 if ( !(_la==WS || _la==NEWLINE) ) { 16092 _errHandler.recoverInline(this); 16093 } 16094 else { 16095 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16096 _errHandler.reportMatch(this); 16097 consume(); 16098 } 16099 setState(1951); 16100 description(); 16101 } 16102 break; 16103 } 16104 } 16105 break; 16106 case VERSION_LITERAL: 16107 enterOuterAlt(_localctx, 12); 16108 { 16109 setState(1954); 16110 match(VERSION_LITERAL); 16111 setState(1956); 16112 _errHandler.sync(this); 16113 _alt = 1; 16114 do { 16115 switch (_alt) { 16116 case 1: 16117 { 16118 { 16119 setState(1955); 16120 _la = _input.LA(1); 16121 if ( !(_la==WS || _la==NEWLINE) ) { 16122 _errHandler.recoverInline(this); 16123 } 16124 else { 16125 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16126 _errHandler.reportMatch(this); 16127 consume(); 16128 } 16129 } 16130 } 16131 break; 16132 default: 16133 throw new NoViableAltException(this); 16134 } 16135 setState(1958); 16136 _errHandler.sync(this); 16137 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 16138 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 16139 setState(1960); 16140 description(); 16141 } 16142 break; 16143 case CUSTOM_NAME: 16144 enterOuterAlt(_localctx, 13); 16145 { 16146 setState(1961); 16147 match(CUSTOM_NAME); 16148 setState(1965); 16149 _errHandler.sync(this); 16150 _alt = getInterpreter().adaptivePredict(_input,159,_ctx); 16151 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 16152 if ( _alt==1 ) { 16153 { 16154 { 16155 setState(1962); 16156 _la = _input.LA(1); 16157 if ( !(_la==WS || _la==NEWLINE) ) { 16158 _errHandler.recoverInline(this); 16159 } 16160 else { 16161 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16162 _errHandler.reportMatch(this); 16163 consume(); 16164 } 16165 } 16166 } 16167 } 16168 setState(1967); 16169 _errHandler.sync(this); 16170 _alt = getInterpreter().adaptivePredict(_input,159,_ctx); 16171 } 16172 setState(1970); 16173 _errHandler.sync(this); 16174 switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) { 16175 case 1: 16176 { 16177 setState(1968); 16178 _la = _input.LA(1); 16179 if ( !(_la==WS || _la==NEWLINE) ) { 16180 _errHandler.recoverInline(this); 16181 } 16182 else { 16183 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16184 _errHandler.reportMatch(this); 16185 consume(); 16186 } 16187 setState(1969); 16188 description(); 16189 } 16190 break; 16191 } 16192 } 16193 break; 16194 default: 16195 throw new NoViableAltException(this); 16196 } 16197 } 16198 catch (RecognitionException re) { 16199 _localctx.exception = re; 16200 _errHandler.reportError(this, re); 16201 _errHandler.recover(this, re); 16202 } 16203 finally { 16204 exitRule(); 16205 } 16206 return _localctx; 16207 } 16208 16209 public static class JavadocInlineTagContext extends ParserRuleContext { 16210 public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); } 16211 public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); } 16212 public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); } 16213 public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); } 16214 public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); } 16215 public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); } 16216 public ReferenceContext reference() { 16217 return getRuleContext(ReferenceContext.class,0); 16218 } 16219 public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); } 16220 public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); } 16221 public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); } 16222 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 16223 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 16224 public TerminalNode WS(int i) { 16225 return getToken(JavadocParser.WS, i); 16226 } 16227 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 16228 public TerminalNode NEWLINE(int i) { 16229 return getToken(JavadocParser.NEWLINE, i); 16230 } 16231 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 16232 public TerminalNode LEADING_ASTERISK(int i) { 16233 return getToken(JavadocParser.LEADING_ASTERISK, i); 16234 } 16235 public List<TextContext> text() { 16236 return getRuleContexts(TextContext.class); 16237 } 16238 public TextContext text(int i) { 16239 return getRuleContext(TextContext.class,i); 16240 } 16241 public DescriptionContext description() { 16242 return getRuleContext(DescriptionContext.class,0); 16243 } 16244 public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) { 16245 super(parent, invokingState); 16246 } 16247 @Override public int getRuleIndex() { return RULE_javadocInlineTag; } 16248 } 16249 16250 public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException { 16251 JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState()); 16252 enterRule(_localctx, 144, RULE_javadocInlineTag); 16253 int _la; 16254 try { 16255 int _alt; 16256 enterOuterAlt(_localctx, 1); 16257 { 16258 setState(1974); 16259 match(JAVADOC_INLINE_TAG_START); 16260 setState(2065); 16261 _errHandler.sync(this); 16262 switch (_input.LA(1)) { 16263 case CODE_LITERAL: 16264 { 16265 setState(1975); 16266 match(CODE_LITERAL); 16267 setState(1982); 16268 _errHandler.sync(this); 16269 _la = _input.LA(1); 16270 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 16271 { 16272 setState(1980); 16273 _errHandler.sync(this); 16274 switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) { 16275 case 1: 16276 { 16277 setState(1976); 16278 match(WS); 16279 } 16280 break; 16281 case 2: 16282 { 16283 setState(1977); 16284 match(NEWLINE); 16285 } 16286 break; 16287 case 3: 16288 { 16289 setState(1978); 16290 match(LEADING_ASTERISK); 16291 } 16292 break; 16293 case 4: 16294 { 16295 setState(1979); 16296 text(); 16297 } 16298 break; 16299 } 16300 } 16301 setState(1984); 16302 _errHandler.sync(this); 16303 _la = _input.LA(1); 16304 } 16305 } 16306 break; 16307 case DOC_ROOT_LITERAL: 16308 { 16309 setState(1985); 16310 match(DOC_ROOT_LITERAL); 16311 setState(1989); 16312 _errHandler.sync(this); 16313 _la = _input.LA(1); 16314 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 16315 { 16316 { 16317 setState(1986); 16318 _la = _input.LA(1); 16319 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16320 _errHandler.recoverInline(this); 16321 } 16322 else { 16323 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16324 _errHandler.reportMatch(this); 16325 consume(); 16326 } 16327 } 16328 } 16329 setState(1991); 16330 _errHandler.sync(this); 16331 _la = _input.LA(1); 16332 } 16333 } 16334 break; 16335 case INHERIT_DOC_LITERAL: 16336 { 16337 setState(1992); 16338 match(INHERIT_DOC_LITERAL); 16339 setState(1996); 16340 _errHandler.sync(this); 16341 _la = _input.LA(1); 16342 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 16343 { 16344 { 16345 setState(1993); 16346 _la = _input.LA(1); 16347 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16348 _errHandler.recoverInline(this); 16349 } 16350 else { 16351 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16352 _errHandler.reportMatch(this); 16353 consume(); 16354 } 16355 } 16356 } 16357 setState(1998); 16358 _errHandler.sync(this); 16359 _la = _input.LA(1); 16360 } 16361 } 16362 break; 16363 case LINK_LITERAL: 16364 { 16365 setState(1999); 16366 match(LINK_LITERAL); 16367 setState(2001); 16368 _errHandler.sync(this); 16369 _la = _input.LA(1); 16370 do { 16371 { 16372 { 16373 setState(2000); 16374 _la = _input.LA(1); 16375 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16376 _errHandler.recoverInline(this); 16377 } 16378 else { 16379 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16380 _errHandler.reportMatch(this); 16381 consume(); 16382 } 16383 } 16384 } 16385 setState(2003); 16386 _errHandler.sync(this); 16387 _la = _input.LA(1); 16388 } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) ); 16389 setState(2005); 16390 reference(); 16391 setState(2009); 16392 _errHandler.sync(this); 16393 _alt = getInterpreter().adaptivePredict(_input,167,_ctx); 16394 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 16395 if ( _alt==1 ) { 16396 { 16397 { 16398 setState(2006); 16399 _la = _input.LA(1); 16400 if ( !(_la==WS || _la==NEWLINE) ) { 16401 _errHandler.recoverInline(this); 16402 } 16403 else { 16404 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16405 _errHandler.reportMatch(this); 16406 consume(); 16407 } 16408 } 16409 } 16410 } 16411 setState(2011); 16412 _errHandler.sync(this); 16413 _alt = getInterpreter().adaptivePredict(_input,167,_ctx); 16414 } 16415 setState(2014); 16416 _errHandler.sync(this); 16417 _la = _input.LA(1); 16418 if (_la==WS || _la==NEWLINE) { 16419 { 16420 setState(2012); 16421 _la = _input.LA(1); 16422 if ( !(_la==WS || _la==NEWLINE) ) { 16423 _errHandler.recoverInline(this); 16424 } 16425 else { 16426 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16427 _errHandler.reportMatch(this); 16428 consume(); 16429 } 16430 setState(2013); 16431 description(); 16432 } 16433 } 16434 16435 } 16436 break; 16437 case LINKPLAIN_LITERAL: 16438 { 16439 setState(2016); 16440 match(LINKPLAIN_LITERAL); 16441 setState(2018); 16442 _errHandler.sync(this); 16443 _la = _input.LA(1); 16444 do { 16445 { 16446 { 16447 setState(2017); 16448 _la = _input.LA(1); 16449 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16450 _errHandler.recoverInline(this); 16451 } 16452 else { 16453 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16454 _errHandler.reportMatch(this); 16455 consume(); 16456 } 16457 } 16458 } 16459 setState(2020); 16460 _errHandler.sync(this); 16461 _la = _input.LA(1); 16462 } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) ); 16463 setState(2022); 16464 reference(); 16465 setState(2026); 16466 _errHandler.sync(this); 16467 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 16468 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 16469 if ( _alt==1 ) { 16470 { 16471 { 16472 setState(2023); 16473 _la = _input.LA(1); 16474 if ( !(_la==WS || _la==NEWLINE) ) { 16475 _errHandler.recoverInline(this); 16476 } 16477 else { 16478 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16479 _errHandler.reportMatch(this); 16480 consume(); 16481 } 16482 } 16483 } 16484 } 16485 setState(2028); 16486 _errHandler.sync(this); 16487 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 16488 } 16489 setState(2031); 16490 _errHandler.sync(this); 16491 _la = _input.LA(1); 16492 if (_la==WS || _la==NEWLINE) { 16493 { 16494 setState(2029); 16495 _la = _input.LA(1); 16496 if ( !(_la==WS || _la==NEWLINE) ) { 16497 _errHandler.recoverInline(this); 16498 } 16499 else { 16500 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16501 _errHandler.reportMatch(this); 16502 consume(); 16503 } 16504 setState(2030); 16505 description(); 16506 } 16507 } 16508 16509 } 16510 break; 16511 case LITERAL_LITERAL: 16512 { 16513 setState(2033); 16514 match(LITERAL_LITERAL); 16515 setState(2040); 16516 _errHandler.sync(this); 16517 _la = _input.LA(1); 16518 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 16519 { 16520 setState(2038); 16521 _errHandler.sync(this); 16522 switch ( getInterpreter().adaptivePredict(_input,172,_ctx) ) { 16523 case 1: 16524 { 16525 setState(2034); 16526 match(WS); 16527 } 16528 break; 16529 case 2: 16530 { 16531 setState(2035); 16532 match(NEWLINE); 16533 } 16534 break; 16535 case 3: 16536 { 16537 setState(2036); 16538 match(LEADING_ASTERISK); 16539 } 16540 break; 16541 case 4: 16542 { 16543 setState(2037); 16544 text(); 16545 } 16546 break; 16547 } 16548 } 16549 setState(2042); 16550 _errHandler.sync(this); 16551 _la = _input.LA(1); 16552 } 16553 } 16554 break; 16555 case VALUE_LITERAL: 16556 { 16557 setState(2043); 16558 match(VALUE_LITERAL); 16559 setState(2047); 16560 _errHandler.sync(this); 16561 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 16562 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 16563 if ( _alt==1 ) { 16564 { 16565 { 16566 setState(2044); 16567 _la = _input.LA(1); 16568 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16569 _errHandler.recoverInline(this); 16570 } 16571 else { 16572 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16573 _errHandler.reportMatch(this); 16574 consume(); 16575 } 16576 } 16577 } 16578 } 16579 setState(2049); 16580 _errHandler.sync(this); 16581 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 16582 } 16583 setState(2052); 16584 _errHandler.sync(this); 16585 _la = _input.LA(1); 16586 if (_la==WS || _la==NEWLINE) { 16587 { 16588 setState(2050); 16589 _la = _input.LA(1); 16590 if ( !(_la==WS || _la==NEWLINE) ) { 16591 _errHandler.recoverInline(this); 16592 } 16593 else { 16594 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16595 _errHandler.reportMatch(this); 16596 consume(); 16597 } 16598 setState(2051); 16599 reference(); 16600 } 16601 } 16602 16603 } 16604 break; 16605 case CUSTOM_NAME: 16606 { 16607 setState(2054); 16608 match(CUSTOM_NAME); 16609 setState(2058); 16610 _errHandler.sync(this); 16611 _alt = getInterpreter().adaptivePredict(_input,176,_ctx); 16612 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 16613 if ( _alt==1 ) { 16614 { 16615 { 16616 setState(2055); 16617 _la = _input.LA(1); 16618 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 16619 _errHandler.recoverInline(this); 16620 } 16621 else { 16622 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16623 _errHandler.reportMatch(this); 16624 consume(); 16625 } 16626 } 16627 } 16628 } 16629 setState(2060); 16630 _errHandler.sync(this); 16631 _alt = getInterpreter().adaptivePredict(_input,176,_ctx); 16632 } 16633 setState(2063); 16634 _errHandler.sync(this); 16635 _la = _input.LA(1); 16636 if (_la==WS || _la==NEWLINE) { 16637 { 16638 setState(2061); 16639 _la = _input.LA(1); 16640 if ( !(_la==WS || _la==NEWLINE) ) { 16641 _errHandler.recoverInline(this); 16642 } 16643 else { 16644 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16645 _errHandler.reportMatch(this); 16646 consume(); 16647 } 16648 setState(2062); 16649 description(); 16650 } 16651 } 16652 16653 } 16654 break; 16655 default: 16656 throw new NoViableAltException(this); 16657 } 16658 setState(2067); 16659 match(JAVADOC_INLINE_TAG_END); 16660 } 16661 } 16662 catch (RecognitionException re) { 16663 _localctx.exception = re; 16664 _errHandler.reportError(this, re); 16665 _errHandler.recover(this, re); 16666 } 16667 finally { 16668 exitRule(); 16669 } 16670 return _localctx; 16671 } 16672 16673 public static class HtmlCommentContext extends ParserRuleContext { 16674 public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); } 16675 public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); } 16676 public List<TextContext> text() { 16677 return getRuleContexts(TextContext.class); 16678 } 16679 public TextContext text(int i) { 16680 return getRuleContext(TextContext.class,i); 16681 } 16682 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 16683 public TerminalNode NEWLINE(int i) { 16684 return getToken(JavadocParser.NEWLINE, i); 16685 } 16686 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 16687 public TerminalNode LEADING_ASTERISK(int i) { 16688 return getToken(JavadocParser.LEADING_ASTERISK, i); 16689 } 16690 public HtmlCommentContext(ParserRuleContext parent, int invokingState) { 16691 super(parent, invokingState); 16692 } 16693 @Override public int getRuleIndex() { return RULE_htmlComment; } 16694 } 16695 16696 public final HtmlCommentContext htmlComment() throws RecognitionException { 16697 HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState()); 16698 enterRule(_localctx, 146, RULE_htmlComment); 16699 int _la; 16700 try { 16701 enterOuterAlt(_localctx, 1); 16702 { 16703 setState(2069); 16704 match(HTML_COMMENT_START); 16705 setState(2075); 16706 _errHandler.sync(this); 16707 _la = _input.LA(1); 16708 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 16709 { 16710 setState(2073); 16711 _errHandler.sync(this); 16712 switch (_input.LA(1)) { 16713 case WS: 16714 case CHAR: 16715 { 16716 setState(2070); 16717 text(); 16718 } 16719 break; 16720 case NEWLINE: 16721 { 16722 setState(2071); 16723 match(NEWLINE); 16724 } 16725 break; 16726 case LEADING_ASTERISK: 16727 { 16728 setState(2072); 16729 match(LEADING_ASTERISK); 16730 } 16731 break; 16732 default: 16733 throw new NoViableAltException(this); 16734 } 16735 } 16736 setState(2077); 16737 _errHandler.sync(this); 16738 _la = _input.LA(1); 16739 } 16740 setState(2078); 16741 match(HTML_COMMENT_END); 16742 } 16743 } 16744 catch (RecognitionException re) { 16745 _localctx.exception = re; 16746 _errHandler.reportError(this, re); 16747 _errHandler.recover(this, re); 16748 } 16749 finally { 16750 exitRule(); 16751 } 16752 return _localctx; 16753 } 16754 16755 public static class TextContext extends ParserRuleContext { 16756 public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); } 16757 public TerminalNode CHAR(int i) { 16758 return getToken(JavadocParser.CHAR, i); 16759 } 16760 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 16761 public TerminalNode WS(int i) { 16762 return getToken(JavadocParser.WS, i); 16763 } 16764 public TextContext(ParserRuleContext parent, int invokingState) { 16765 super(parent, invokingState); 16766 } 16767 @Override public int getRuleIndex() { return RULE_text; } 16768 } 16769 16770 public final TextContext text() throws RecognitionException { 16771 TextContext _localctx = new TextContext(_ctx, getState()); 16772 enterRule(_localctx, 148, RULE_text); 16773 int _la; 16774 try { 16775 int _alt; 16776 enterOuterAlt(_localctx, 1); 16777 { 16778 setState(2082); 16779 _errHandler.sync(this); 16780 _alt = 1; 16781 do { 16782 switch (_alt) { 16783 case 1: 16784 { 16785 { 16786 setState(2080); 16787 _la = _input.LA(1); 16788 if ( !(_la==WS || _la==CHAR) ) { 16789 _errHandler.recoverInline(this); 16790 } 16791 else { 16792 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16793 _errHandler.reportMatch(this); 16794 consume(); 16795 } 16796 16797 _la = _input.LA(1); 16798 if ((_la != WS) && (_la != CHAR)) return _localctx; 16799 else if (_alt == 1) continue; 16800 16801 } 16802 } 16803 break; 16804 default: 16805 throw new NoViableAltException(this); 16806 } 16807 setState(2084); 16808 _errHandler.sync(this); 16809 _alt = getInterpreter().adaptivePredict(_input,181,_ctx); 16810 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 16811 } 16812 } 16813 catch (RecognitionException re) { 16814 _localctx.exception = re; 16815 _errHandler.reportError(this, re); 16816 _errHandler.recover(this, re); 16817 } 16818 finally { 16819 exitRule(); 16820 } 16821 return _localctx; 16822 } 16823 16824 public static class EmbedTagContext extends ParserRuleContext { 16825 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 16826 public TerminalNode EMBED_HTML_TAG_NAME() { return getToken(JavadocParser.EMBED_HTML_TAG_NAME, 0); } 16827 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 16828 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 16829 public List<AttributeContext> attribute() { 16830 return getRuleContexts(AttributeContext.class); 16831 } 16832 public AttributeContext attribute(int i) { 16833 return getRuleContext(AttributeContext.class,i); 16834 } 16835 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 16836 public TerminalNode NEWLINE(int i) { 16837 return getToken(JavadocParser.NEWLINE, i); 16838 } 16839 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 16840 public TerminalNode LEADING_ASTERISK(int i) { 16841 return getToken(JavadocParser.LEADING_ASTERISK, i); 16842 } 16843 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 16844 public TerminalNode WS(int i) { 16845 return getToken(JavadocParser.WS, i); 16846 } 16847 public EmbedTagContext(ParserRuleContext parent, int invokingState) { 16848 super(parent, invokingState); 16849 } 16850 @Override public int getRuleIndex() { return RULE_embedTag; } 16851 } 16852 16853 public final EmbedTagContext embedTag() throws RecognitionException { 16854 EmbedTagContext _localctx = new EmbedTagContext(_ctx, getState()); 16855 enterRule(_localctx, 150, RULE_embedTag); 16856 int _la; 16857 try { 16858 enterOuterAlt(_localctx, 1); 16859 { 16860 setState(2086); 16861 match(START); 16862 setState(2087); 16863 match(EMBED_HTML_TAG_NAME); 16864 setState(2094); 16865 _errHandler.sync(this); 16866 _la = _input.LA(1); 16867 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 16868 { 16869 setState(2092); 16870 _errHandler.sync(this); 16871 switch (_input.LA(1)) { 16872 case HTML_TAG_NAME: 16873 { 16874 setState(2088); 16875 attribute(); 16876 } 16877 break; 16878 case NEWLINE: 16879 { 16880 setState(2089); 16881 match(NEWLINE); 16882 } 16883 break; 16884 case LEADING_ASTERISK: 16885 { 16886 setState(2090); 16887 match(LEADING_ASTERISK); 16888 } 16889 break; 16890 case WS: 16891 { 16892 setState(2091); 16893 match(WS); 16894 } 16895 break; 16896 default: 16897 throw new NoViableAltException(this); 16898 } 16899 } 16900 setState(2096); 16901 _errHandler.sync(this); 16902 _la = _input.LA(1); 16903 } 16904 setState(2097); 16905 _la = _input.LA(1); 16906 if ( !(_la==END || _la==SLASH_END) ) { 16907 _errHandler.recoverInline(this); 16908 } 16909 else { 16910 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 16911 _errHandler.reportMatch(this); 16912 consume(); 16913 } 16914 } 16915 } 16916 catch (RecognitionException re) { 16917 _localctx.exception = re; 16918 _errHandler.reportError(this, re); 16919 _errHandler.recover(this, re); 16920 } 16921 finally { 16922 exitRule(); 16923 } 16924 return _localctx; 16925 } 16926 16927 public static class KeygenTagContext extends ParserRuleContext { 16928 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 16929 public TerminalNode KEYGEN_HTML_TAG_NAME() { return getToken(JavadocParser.KEYGEN_HTML_TAG_NAME, 0); } 16930 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 16931 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 16932 public List<AttributeContext> attribute() { 16933 return getRuleContexts(AttributeContext.class); 16934 } 16935 public AttributeContext attribute(int i) { 16936 return getRuleContext(AttributeContext.class,i); 16937 } 16938 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 16939 public TerminalNode NEWLINE(int i) { 16940 return getToken(JavadocParser.NEWLINE, i); 16941 } 16942 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 16943 public TerminalNode LEADING_ASTERISK(int i) { 16944 return getToken(JavadocParser.LEADING_ASTERISK, i); 16945 } 16946 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 16947 public TerminalNode WS(int i) { 16948 return getToken(JavadocParser.WS, i); 16949 } 16950 public KeygenTagContext(ParserRuleContext parent, int invokingState) { 16951 super(parent, invokingState); 16952 } 16953 @Override public int getRuleIndex() { return RULE_keygenTag; } 16954 } 16955 16956 public final KeygenTagContext keygenTag() throws RecognitionException { 16957 KeygenTagContext _localctx = new KeygenTagContext(_ctx, getState()); 16958 enterRule(_localctx, 152, RULE_keygenTag); 16959 int _la; 16960 try { 16961 enterOuterAlt(_localctx, 1); 16962 { 16963 setState(2099); 16964 match(START); 16965 setState(2100); 16966 match(KEYGEN_HTML_TAG_NAME); 16967 setState(2107); 16968 _errHandler.sync(this); 16969 _la = _input.LA(1); 16970 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 16971 { 16972 setState(2105); 16973 _errHandler.sync(this); 16974 switch (_input.LA(1)) { 16975 case HTML_TAG_NAME: 16976 { 16977 setState(2101); 16978 attribute(); 16979 } 16980 break; 16981 case NEWLINE: 16982 { 16983 setState(2102); 16984 match(NEWLINE); 16985 } 16986 break; 16987 case LEADING_ASTERISK: 16988 { 16989 setState(2103); 16990 match(LEADING_ASTERISK); 16991 } 16992 break; 16993 case WS: 16994 { 16995 setState(2104); 16996 match(WS); 16997 } 16998 break; 16999 default: 17000 throw new NoViableAltException(this); 17001 } 17002 } 17003 setState(2109); 17004 _errHandler.sync(this); 17005 _la = _input.LA(1); 17006 } 17007 setState(2110); 17008 _la = _input.LA(1); 17009 if ( !(_la==END || _la==SLASH_END) ) { 17010 _errHandler.recoverInline(this); 17011 } 17012 else { 17013 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 17014 _errHandler.reportMatch(this); 17015 consume(); 17016 } 17017 } 17018 } 17019 catch (RecognitionException re) { 17020 _localctx.exception = re; 17021 _errHandler.reportError(this, re); 17022 _errHandler.recover(this, re); 17023 } 17024 finally { 17025 exitRule(); 17026 } 17027 return _localctx; 17028 } 17029 17030 public static class SourceTagContext extends ParserRuleContext { 17031 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 17032 public TerminalNode SOURCE_HTML_TAG_NAME() { return getToken(JavadocParser.SOURCE_HTML_TAG_NAME, 0); } 17033 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 17034 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 17035 public List<AttributeContext> attribute() { 17036 return getRuleContexts(AttributeContext.class); 17037 } 17038 public AttributeContext attribute(int i) { 17039 return getRuleContext(AttributeContext.class,i); 17040 } 17041 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17042 public TerminalNode NEWLINE(int i) { 17043 return getToken(JavadocParser.NEWLINE, i); 17044 } 17045 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17046 public TerminalNode LEADING_ASTERISK(int i) { 17047 return getToken(JavadocParser.LEADING_ASTERISK, i); 17048 } 17049 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 17050 public TerminalNode WS(int i) { 17051 return getToken(JavadocParser.WS, i); 17052 } 17053 public SourceTagContext(ParserRuleContext parent, int invokingState) { 17054 super(parent, invokingState); 17055 } 17056 @Override public int getRuleIndex() { return RULE_sourceTag; } 17057 } 17058 17059 public final SourceTagContext sourceTag() throws RecognitionException { 17060 SourceTagContext _localctx = new SourceTagContext(_ctx, getState()); 17061 enterRule(_localctx, 154, RULE_sourceTag); 17062 int _la; 17063 try { 17064 enterOuterAlt(_localctx, 1); 17065 { 17066 setState(2112); 17067 match(START); 17068 setState(2113); 17069 match(SOURCE_HTML_TAG_NAME); 17070 setState(2120); 17071 _errHandler.sync(this); 17072 _la = _input.LA(1); 17073 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 17074 { 17075 setState(2118); 17076 _errHandler.sync(this); 17077 switch (_input.LA(1)) { 17078 case HTML_TAG_NAME: 17079 { 17080 setState(2114); 17081 attribute(); 17082 } 17083 break; 17084 case NEWLINE: 17085 { 17086 setState(2115); 17087 match(NEWLINE); 17088 } 17089 break; 17090 case LEADING_ASTERISK: 17091 { 17092 setState(2116); 17093 match(LEADING_ASTERISK); 17094 } 17095 break; 17096 case WS: 17097 { 17098 setState(2117); 17099 match(WS); 17100 } 17101 break; 17102 default: 17103 throw new NoViableAltException(this); 17104 } 17105 } 17106 setState(2122); 17107 _errHandler.sync(this); 17108 _la = _input.LA(1); 17109 } 17110 setState(2123); 17111 _la = _input.LA(1); 17112 if ( !(_la==END || _la==SLASH_END) ) { 17113 _errHandler.recoverInline(this); 17114 } 17115 else { 17116 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 17117 _errHandler.reportMatch(this); 17118 consume(); 17119 } 17120 } 17121 } 17122 catch (RecognitionException re) { 17123 _localctx.exception = re; 17124 _errHandler.reportError(this, re); 17125 _errHandler.recover(this, re); 17126 } 17127 finally { 17128 exitRule(); 17129 } 17130 return _localctx; 17131 } 17132 17133 public static class TrackTagContext extends ParserRuleContext { 17134 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 17135 public TerminalNode TRACK_HTML_TAG_NAME() { return getToken(JavadocParser.TRACK_HTML_TAG_NAME, 0); } 17136 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 17137 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 17138 public List<AttributeContext> attribute() { 17139 return getRuleContexts(AttributeContext.class); 17140 } 17141 public AttributeContext attribute(int i) { 17142 return getRuleContext(AttributeContext.class,i); 17143 } 17144 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17145 public TerminalNode NEWLINE(int i) { 17146 return getToken(JavadocParser.NEWLINE, i); 17147 } 17148 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17149 public TerminalNode LEADING_ASTERISK(int i) { 17150 return getToken(JavadocParser.LEADING_ASTERISK, i); 17151 } 17152 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 17153 public TerminalNode WS(int i) { 17154 return getToken(JavadocParser.WS, i); 17155 } 17156 public TrackTagContext(ParserRuleContext parent, int invokingState) { 17157 super(parent, invokingState); 17158 } 17159 @Override public int getRuleIndex() { return RULE_trackTag; } 17160 } 17161 17162 public final TrackTagContext trackTag() throws RecognitionException { 17163 TrackTagContext _localctx = new TrackTagContext(_ctx, getState()); 17164 enterRule(_localctx, 156, RULE_trackTag); 17165 int _la; 17166 try { 17167 enterOuterAlt(_localctx, 1); 17168 { 17169 setState(2125); 17170 match(START); 17171 setState(2126); 17172 match(TRACK_HTML_TAG_NAME); 17173 setState(2133); 17174 _errHandler.sync(this); 17175 _la = _input.LA(1); 17176 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 17177 { 17178 setState(2131); 17179 _errHandler.sync(this); 17180 switch (_input.LA(1)) { 17181 case HTML_TAG_NAME: 17182 { 17183 setState(2127); 17184 attribute(); 17185 } 17186 break; 17187 case NEWLINE: 17188 { 17189 setState(2128); 17190 match(NEWLINE); 17191 } 17192 break; 17193 case LEADING_ASTERISK: 17194 { 17195 setState(2129); 17196 match(LEADING_ASTERISK); 17197 } 17198 break; 17199 case WS: 17200 { 17201 setState(2130); 17202 match(WS); 17203 } 17204 break; 17205 default: 17206 throw new NoViableAltException(this); 17207 } 17208 } 17209 setState(2135); 17210 _errHandler.sync(this); 17211 _la = _input.LA(1); 17212 } 17213 setState(2136); 17214 _la = _input.LA(1); 17215 if ( !(_la==END || _la==SLASH_END) ) { 17216 _errHandler.recoverInline(this); 17217 } 17218 else { 17219 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 17220 _errHandler.reportMatch(this); 17221 consume(); 17222 } 17223 } 17224 } 17225 catch (RecognitionException re) { 17226 _localctx.exception = re; 17227 _errHandler.reportError(this, re); 17228 _errHandler.recover(this, re); 17229 } 17230 finally { 17231 exitRule(); 17232 } 17233 return _localctx; 17234 } 17235 17236 public static class WbrTagContext extends ParserRuleContext { 17237 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 17238 public TerminalNode WBR_HTML_TAG_NAME() { return getToken(JavadocParser.WBR_HTML_TAG_NAME, 0); } 17239 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 17240 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 17241 public List<AttributeContext> attribute() { 17242 return getRuleContexts(AttributeContext.class); 17243 } 17244 public AttributeContext attribute(int i) { 17245 return getRuleContext(AttributeContext.class,i); 17246 } 17247 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17248 public TerminalNode NEWLINE(int i) { 17249 return getToken(JavadocParser.NEWLINE, i); 17250 } 17251 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17252 public TerminalNode LEADING_ASTERISK(int i) { 17253 return getToken(JavadocParser.LEADING_ASTERISK, i); 17254 } 17255 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 17256 public TerminalNode WS(int i) { 17257 return getToken(JavadocParser.WS, i); 17258 } 17259 public WbrTagContext(ParserRuleContext parent, int invokingState) { 17260 super(parent, invokingState); 17261 } 17262 @Override public int getRuleIndex() { return RULE_wbrTag; } 17263 } 17264 17265 public final WbrTagContext wbrTag() throws RecognitionException { 17266 WbrTagContext _localctx = new WbrTagContext(_ctx, getState()); 17267 enterRule(_localctx, 158, RULE_wbrTag); 17268 int _la; 17269 try { 17270 enterOuterAlt(_localctx, 1); 17271 { 17272 setState(2138); 17273 match(START); 17274 setState(2139); 17275 match(WBR_HTML_TAG_NAME); 17276 setState(2146); 17277 _errHandler.sync(this); 17278 _la = _input.LA(1); 17279 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 17280 { 17281 setState(2144); 17282 _errHandler.sync(this); 17283 switch (_input.LA(1)) { 17284 case HTML_TAG_NAME: 17285 { 17286 setState(2140); 17287 attribute(); 17288 } 17289 break; 17290 case NEWLINE: 17291 { 17292 setState(2141); 17293 match(NEWLINE); 17294 } 17295 break; 17296 case LEADING_ASTERISK: 17297 { 17298 setState(2142); 17299 match(LEADING_ASTERISK); 17300 } 17301 break; 17302 case WS: 17303 { 17304 setState(2143); 17305 match(WS); 17306 } 17307 break; 17308 default: 17309 throw new NoViableAltException(this); 17310 } 17311 } 17312 setState(2148); 17313 _errHandler.sync(this); 17314 _la = _input.LA(1); 17315 } 17316 setState(2149); 17317 _la = _input.LA(1); 17318 if ( !(_la==END || _la==SLASH_END) ) { 17319 _errHandler.recoverInline(this); 17320 } 17321 else { 17322 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 17323 _errHandler.reportMatch(this); 17324 consume(); 17325 } 17326 } 17327 } 17328 catch (RecognitionException re) { 17329 _localctx.exception = re; 17330 _errHandler.reportError(this, re); 17331 _errHandler.recover(this, re); 17332 } 17333 finally { 17334 exitRule(); 17335 } 17336 return _localctx; 17337 } 17338 17339 public static class OptgroupTagStartContext extends ParserRuleContext { 17340 public boolean isNonTight; 17341 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 17342 public TerminalNode OPTGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.OPTGROUP_HTML_TAG_NAME, 0); } 17343 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 17344 public List<AttributeContext> attribute() { 17345 return getRuleContexts(AttributeContext.class); 17346 } 17347 public AttributeContext attribute(int i) { 17348 return getRuleContext(AttributeContext.class,i); 17349 } 17350 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17351 public TerminalNode NEWLINE(int i) { 17352 return getToken(JavadocParser.NEWLINE, i); 17353 } 17354 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17355 public TerminalNode LEADING_ASTERISK(int i) { 17356 return getToken(JavadocParser.LEADING_ASTERISK, i); 17357 } 17358 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 17359 public TerminalNode WS(int i) { 17360 return getToken(JavadocParser.WS, i); 17361 } 17362 public OptgroupTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 17363 public OptgroupTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 17364 super(parent, invokingState); 17365 this.isNonTight = isNonTight; 17366 } 17367 @Override public int getRuleIndex() { return RULE_optgroupTagStart; } 17368 } 17369 17370 public final OptgroupTagStartContext optgroupTagStart(boolean isNonTight) throws RecognitionException { 17371 OptgroupTagStartContext _localctx = new OptgroupTagStartContext(_ctx, getState(), isNonTight); 17372 enterRule(_localctx, 160, RULE_optgroupTagStart); 17373 int _la; 17374 try { 17375 enterOuterAlt(_localctx, 1); 17376 { 17377 setState(2151); 17378 match(START); 17379 setState(2152); 17380 match(OPTGROUP_HTML_TAG_NAME); 17381 setState(2159); 17382 _errHandler.sync(this); 17383 _la = _input.LA(1); 17384 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 17385 { 17386 setState(2157); 17387 _errHandler.sync(this); 17388 switch (_input.LA(1)) { 17389 case HTML_TAG_NAME: 17390 { 17391 setState(2153); 17392 attribute(); 17393 } 17394 break; 17395 case NEWLINE: 17396 { 17397 setState(2154); 17398 match(NEWLINE); 17399 } 17400 break; 17401 case LEADING_ASTERISK: 17402 { 17403 setState(2155); 17404 match(LEADING_ASTERISK); 17405 } 17406 break; 17407 case WS: 17408 { 17409 setState(2156); 17410 match(WS); 17411 } 17412 break; 17413 default: 17414 throw new NoViableAltException(this); 17415 } 17416 } 17417 setState(2161); 17418 _errHandler.sync(this); 17419 _la = _input.LA(1); 17420 } 17421 setState(2162); 17422 match(END); 17423 } 17424 _ctx.stop = _input.LT(-1); 17425 17426 if (isNonTight && nonTightTagStartContext == null) { 17427 nonTightTagStartContext = _localctx; 17428 } 17429 17430 } 17431 catch (RecognitionException re) { 17432 _localctx.exception = re; 17433 _errHandler.reportError(this, re); 17434 _errHandler.recover(this, re); 17435 } 17436 finally { 17437 exitRule(); 17438 } 17439 return _localctx; 17440 } 17441 17442 public static class OptgroupTagEndContext extends ParserRuleContext { 17443 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 17444 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 17445 public TerminalNode OPTGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.OPTGROUP_HTML_TAG_NAME, 0); } 17446 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 17447 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17448 public TerminalNode NEWLINE(int i) { 17449 return getToken(JavadocParser.NEWLINE, i); 17450 } 17451 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17452 public TerminalNode LEADING_ASTERISK(int i) { 17453 return getToken(JavadocParser.LEADING_ASTERISK, i); 17454 } 17455 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 17456 public TerminalNode WS(int i) { 17457 return getToken(JavadocParser.WS, i); 17458 } 17459 public OptgroupTagEndContext(ParserRuleContext parent, int invokingState) { 17460 super(parent, invokingState); 17461 } 17462 @Override public int getRuleIndex() { return RULE_optgroupTagEnd; } 17463 } 17464 17465 public final OptgroupTagEndContext optgroupTagEnd() throws RecognitionException { 17466 OptgroupTagEndContext _localctx = new OptgroupTagEndContext(_ctx, getState()); 17467 enterRule(_localctx, 162, RULE_optgroupTagEnd); 17468 int _la; 17469 try { 17470 enterOuterAlt(_localctx, 1); 17471 { 17472 setState(2164); 17473 match(START); 17474 setState(2165); 17475 match(SLASH); 17476 setState(2166); 17477 match(OPTGROUP_HTML_TAG_NAME); 17478 setState(2170); 17479 _errHandler.sync(this); 17480 _la = _input.LA(1); 17481 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 17482 { 17483 { 17484 setState(2167); 17485 _la = _input.LA(1); 17486 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 17487 _errHandler.recoverInline(this); 17488 } 17489 else { 17490 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 17491 _errHandler.reportMatch(this); 17492 consume(); 17493 } 17494 } 17495 } 17496 setState(2172); 17497 _errHandler.sync(this); 17498 _la = _input.LA(1); 17499 } 17500 setState(2173); 17501 match(END); 17502 } 17503 } 17504 catch (RecognitionException re) { 17505 _localctx.exception = re; 17506 _errHandler.reportError(this, re); 17507 _errHandler.recover(this, re); 17508 } 17509 finally { 17510 exitRule(); 17511 } 17512 return _localctx; 17513 } 17514 17515 public static class OptgroupContext extends ParserRuleContext { 17516 public OptgroupTagStartContext optgroupTagStart() { 17517 return getRuleContext(OptgroupTagStartContext.class,0); 17518 } 17519 public OptgroupTagEndContext optgroupTagEnd() { 17520 return getRuleContext(OptgroupTagEndContext.class,0); 17521 } 17522 public List<HtmlTagContext> htmlTag() { 17523 return getRuleContexts(HtmlTagContext.class); 17524 } 17525 public HtmlTagContext htmlTag(int i) { 17526 return getRuleContext(HtmlTagContext.class,i); 17527 } 17528 public List<SingletonElementContext> singletonElement() { 17529 return getRuleContexts(SingletonElementContext.class); 17530 } 17531 public SingletonElementContext singletonElement(int i) { 17532 return getRuleContext(SingletonElementContext.class,i); 17533 } 17534 public List<ParagraphContext> paragraph() { 17535 return getRuleContexts(ParagraphContext.class); 17536 } 17537 public ParagraphContext paragraph(int i) { 17538 return getRuleContext(ParagraphContext.class,i); 17539 } 17540 public List<LiContext> li() { 17541 return getRuleContexts(LiContext.class); 17542 } 17543 public LiContext li(int i) { 17544 return getRuleContext(LiContext.class,i); 17545 } 17546 public List<TrContext> tr() { 17547 return getRuleContexts(TrContext.class); 17548 } 17549 public TrContext tr(int i) { 17550 return getRuleContext(TrContext.class,i); 17551 } 17552 public List<TdContext> td() { 17553 return getRuleContexts(TdContext.class); 17554 } 17555 public TdContext td(int i) { 17556 return getRuleContext(TdContext.class,i); 17557 } 17558 public List<ThContext> th() { 17559 return getRuleContexts(ThContext.class); 17560 } 17561 public ThContext th(int i) { 17562 return getRuleContext(ThContext.class,i); 17563 } 17564 public List<BodyContext> body() { 17565 return getRuleContexts(BodyContext.class); 17566 } 17567 public BodyContext body(int i) { 17568 return getRuleContext(BodyContext.class,i); 17569 } 17570 public List<ColgroupContext> colgroup() { 17571 return getRuleContexts(ColgroupContext.class); 17572 } 17573 public ColgroupContext colgroup(int i) { 17574 return getRuleContext(ColgroupContext.class,i); 17575 } 17576 public List<DdContext> dd() { 17577 return getRuleContexts(DdContext.class); 17578 } 17579 public DdContext dd(int i) { 17580 return getRuleContext(DdContext.class,i); 17581 } 17582 public List<DtContext> dt() { 17583 return getRuleContexts(DtContext.class); 17584 } 17585 public DtContext dt(int i) { 17586 return getRuleContext(DtContext.class,i); 17587 } 17588 public List<HeadContext> head() { 17589 return getRuleContexts(HeadContext.class); 17590 } 17591 public HeadContext head(int i) { 17592 return getRuleContext(HeadContext.class,i); 17593 } 17594 public List<HtmlContext> html() { 17595 return getRuleContexts(HtmlContext.class); 17596 } 17597 public HtmlContext html(int i) { 17598 return getRuleContext(HtmlContext.class,i); 17599 } 17600 public List<OptionContext> option() { 17601 return getRuleContexts(OptionContext.class); 17602 } 17603 public OptionContext option(int i) { 17604 return getRuleContext(OptionContext.class,i); 17605 } 17606 public List<TbodyContext> tbody() { 17607 return getRuleContexts(TbodyContext.class); 17608 } 17609 public TbodyContext tbody(int i) { 17610 return getRuleContext(TbodyContext.class,i); 17611 } 17612 public List<TfootContext> tfoot() { 17613 return getRuleContexts(TfootContext.class); 17614 } 17615 public TfootContext tfoot(int i) { 17616 return getRuleContext(TfootContext.class,i); 17617 } 17618 public List<PTagStartContext> pTagStart() { 17619 return getRuleContexts(PTagStartContext.class); 17620 } 17621 public PTagStartContext pTagStart(int i) { 17622 return getRuleContext(PTagStartContext.class,i); 17623 } 17624 public List<LiTagStartContext> liTagStart() { 17625 return getRuleContexts(LiTagStartContext.class); 17626 } 17627 public LiTagStartContext liTagStart(int i) { 17628 return getRuleContext(LiTagStartContext.class,i); 17629 } 17630 public List<TrTagStartContext> trTagStart() { 17631 return getRuleContexts(TrTagStartContext.class); 17632 } 17633 public TrTagStartContext trTagStart(int i) { 17634 return getRuleContext(TrTagStartContext.class,i); 17635 } 17636 public List<TdTagStartContext> tdTagStart() { 17637 return getRuleContexts(TdTagStartContext.class); 17638 } 17639 public TdTagStartContext tdTagStart(int i) { 17640 return getRuleContext(TdTagStartContext.class,i); 17641 } 17642 public List<ThTagStartContext> thTagStart() { 17643 return getRuleContexts(ThTagStartContext.class); 17644 } 17645 public ThTagStartContext thTagStart(int i) { 17646 return getRuleContext(ThTagStartContext.class,i); 17647 } 17648 public List<BodyTagStartContext> bodyTagStart() { 17649 return getRuleContexts(BodyTagStartContext.class); 17650 } 17651 public BodyTagStartContext bodyTagStart(int i) { 17652 return getRuleContext(BodyTagStartContext.class,i); 17653 } 17654 public List<ColgroupTagStartContext> colgroupTagStart() { 17655 return getRuleContexts(ColgroupTagStartContext.class); 17656 } 17657 public ColgroupTagStartContext colgroupTagStart(int i) { 17658 return getRuleContext(ColgroupTagStartContext.class,i); 17659 } 17660 public List<DdTagStartContext> ddTagStart() { 17661 return getRuleContexts(DdTagStartContext.class); 17662 } 17663 public DdTagStartContext ddTagStart(int i) { 17664 return getRuleContext(DdTagStartContext.class,i); 17665 } 17666 public List<DtTagStartContext> dtTagStart() { 17667 return getRuleContexts(DtTagStartContext.class); 17668 } 17669 public DtTagStartContext dtTagStart(int i) { 17670 return getRuleContext(DtTagStartContext.class,i); 17671 } 17672 public List<HeadTagStartContext> headTagStart() { 17673 return getRuleContexts(HeadTagStartContext.class); 17674 } 17675 public HeadTagStartContext headTagStart(int i) { 17676 return getRuleContext(HeadTagStartContext.class,i); 17677 } 17678 public List<HtmlTagStartContext> htmlTagStart() { 17679 return getRuleContexts(HtmlTagStartContext.class); 17680 } 17681 public HtmlTagStartContext htmlTagStart(int i) { 17682 return getRuleContext(HtmlTagStartContext.class,i); 17683 } 17684 public List<OptionTagStartContext> optionTagStart() { 17685 return getRuleContexts(OptionTagStartContext.class); 17686 } 17687 public OptionTagStartContext optionTagStart(int i) { 17688 return getRuleContext(OptionTagStartContext.class,i); 17689 } 17690 public List<TbodyTagStartContext> tbodyTagStart() { 17691 return getRuleContexts(TbodyTagStartContext.class); 17692 } 17693 public TbodyTagStartContext tbodyTagStart(int i) { 17694 return getRuleContext(TbodyTagStartContext.class,i); 17695 } 17696 public List<TfootTagStartContext> tfootTagStart() { 17697 return getRuleContexts(TfootTagStartContext.class); 17698 } 17699 public TfootTagStartContext tfootTagStart(int i) { 17700 return getRuleContext(TfootTagStartContext.class,i); 17701 } 17702 public List<HtmlCommentContext> htmlComment() { 17703 return getRuleContexts(HtmlCommentContext.class); 17704 } 17705 public HtmlCommentContext htmlComment(int i) { 17706 return getRuleContext(HtmlCommentContext.class,i); 17707 } 17708 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 17709 public TerminalNode CDATA(int i) { 17710 return getToken(JavadocParser.CDATA, i); 17711 } 17712 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 17713 public TerminalNode NEWLINE(int i) { 17714 return getToken(JavadocParser.NEWLINE, i); 17715 } 17716 public List<TextContext> text() { 17717 return getRuleContexts(TextContext.class); 17718 } 17719 public TextContext text(int i) { 17720 return getRuleContext(TextContext.class,i); 17721 } 17722 public List<JavadocInlineTagContext> javadocInlineTag() { 17723 return getRuleContexts(JavadocInlineTagContext.class); 17724 } 17725 public JavadocInlineTagContext javadocInlineTag(int i) { 17726 return getRuleContext(JavadocInlineTagContext.class,i); 17727 } 17728 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 17729 public TerminalNode LEADING_ASTERISK(int i) { 17730 return getToken(JavadocParser.LEADING_ASTERISK, i); 17731 } 17732 public OptgroupContext(ParserRuleContext parent, int invokingState) { 17733 super(parent, invokingState); 17734 } 17735 @Override public int getRuleIndex() { return RULE_optgroup; } 17736 } 17737 17738 public final OptgroupContext optgroup() throws RecognitionException { 17739 OptgroupContext _localctx = new OptgroupContext(_ctx, getState()); 17740 enterRule(_localctx, 164, RULE_optgroup); 17741 try { 17742 int _alt; 17743 enterOuterAlt(_localctx, 1); 17744 { 17745 setState(2175); 17746 optgroupTagStart(false); 17747 setState(2215); 17748 _errHandler.sync(this); 17749 _alt = getInterpreter().adaptivePredict(_input,196,_ctx); 17750 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 17751 if ( _alt==1 ) { 17752 { 17753 setState(2213); 17754 _errHandler.sync(this); 17755 switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) { 17756 case 1: 17757 { 17758 setState(2176); 17759 htmlTag(); 17760 } 17761 break; 17762 case 2: 17763 { 17764 setState(2177); 17765 singletonElement(); 17766 } 17767 break; 17768 case 3: 17769 { 17770 setState(2178); 17771 paragraph(); 17772 } 17773 break; 17774 case 4: 17775 { 17776 setState(2179); 17777 li(); 17778 } 17779 break; 17780 case 5: 17781 { 17782 setState(2180); 17783 tr(); 17784 } 17785 break; 17786 case 6: 17787 { 17788 setState(2181); 17789 td(); 17790 } 17791 break; 17792 case 7: 17793 { 17794 setState(2182); 17795 th(); 17796 } 17797 break; 17798 case 8: 17799 { 17800 setState(2183); 17801 body(); 17802 } 17803 break; 17804 case 9: 17805 { 17806 setState(2184); 17807 colgroup(); 17808 } 17809 break; 17810 case 10: 17811 { 17812 setState(2185); 17813 dd(); 17814 } 17815 break; 17816 case 11: 17817 { 17818 setState(2186); 17819 dt(); 17820 } 17821 break; 17822 case 12: 17823 { 17824 setState(2187); 17825 head(); 17826 } 17827 break; 17828 case 13: 17829 { 17830 setState(2188); 17831 html(); 17832 } 17833 break; 17834 case 14: 17835 { 17836 setState(2189); 17837 option(); 17838 } 17839 break; 17840 case 15: 17841 { 17842 setState(2190); 17843 tbody(); 17844 } 17845 break; 17846 case 16: 17847 { 17848 setState(2191); 17849 tfoot(); 17850 } 17851 break; 17852 case 17: 17853 { 17854 setState(2192); 17855 pTagStart(true); 17856 } 17857 break; 17858 case 18: 17859 { 17860 setState(2193); 17861 liTagStart(true); 17862 } 17863 break; 17864 case 19: 17865 { 17866 setState(2194); 17867 trTagStart(true); 17868 } 17869 break; 17870 case 20: 17871 { 17872 setState(2195); 17873 tdTagStart(true); 17874 } 17875 break; 17876 case 21: 17877 { 17878 setState(2196); 17879 thTagStart(true); 17880 } 17881 break; 17882 case 22: 17883 { 17884 setState(2197); 17885 bodyTagStart(true); 17886 } 17887 break; 17888 case 23: 17889 { 17890 setState(2198); 17891 colgroupTagStart(true); 17892 } 17893 break; 17894 case 24: 17895 { 17896 setState(2199); 17897 ddTagStart(true); 17898 } 17899 break; 17900 case 25: 17901 { 17902 setState(2200); 17903 dtTagStart(true); 17904 } 17905 break; 17906 case 26: 17907 { 17908 setState(2201); 17909 headTagStart(true); 17910 } 17911 break; 17912 case 27: 17913 { 17914 setState(2202); 17915 htmlTagStart(true); 17916 } 17917 break; 17918 case 28: 17919 { 17920 setState(2203); 17921 optionTagStart(true); 17922 } 17923 break; 17924 case 29: 17925 { 17926 setState(2204); 17927 tbodyTagStart(true); 17928 } 17929 break; 17930 case 30: 17931 { 17932 setState(2205); 17933 tfootTagStart(true); 17934 } 17935 break; 17936 case 31: 17937 { 17938 { 17939 setState(2206); 17940 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 17941 setState(2207); 17942 match(LEADING_ASTERISK); 17943 } 17944 } 17945 break; 17946 case 32: 17947 { 17948 setState(2208); 17949 htmlComment(); 17950 } 17951 break; 17952 case 33: 17953 { 17954 setState(2209); 17955 match(CDATA); 17956 } 17957 break; 17958 case 34: 17959 { 17960 setState(2210); 17961 match(NEWLINE); 17962 } 17963 break; 17964 case 35: 17965 { 17966 setState(2211); 17967 text(); 17968 } 17969 break; 17970 case 36: 17971 { 17972 setState(2212); 17973 javadocInlineTag(); 17974 } 17975 break; 17976 } 17977 } 17978 } 17979 setState(2217); 17980 _errHandler.sync(this); 17981 _alt = getInterpreter().adaptivePredict(_input,196,_ctx); 17982 } 17983 setState(2218); 17984 optgroupTagEnd(); 17985 } 17986 } 17987 catch (RecognitionException re) { 17988 _localctx.exception = re; 17989 _errHandler.reportError(this, re); 17990 _errHandler.recover(this, re); 17991 } 17992 finally { 17993 exitRule(); 17994 } 17995 return _localctx; 17996 } 17997 17998 public static class RbTagStartContext extends ParserRuleContext { 17999 public boolean isNonTight; 18000 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 18001 public TerminalNode RB_HTML_TAG_NAME() { return getToken(JavadocParser.RB_HTML_TAG_NAME, 0); } 18002 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 18003 public List<AttributeContext> attribute() { 18004 return getRuleContexts(AttributeContext.class); 18005 } 18006 public AttributeContext attribute(int i) { 18007 return getRuleContext(AttributeContext.class,i); 18008 } 18009 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 18010 public TerminalNode NEWLINE(int i) { 18011 return getToken(JavadocParser.NEWLINE, i); 18012 } 18013 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 18014 public TerminalNode LEADING_ASTERISK(int i) { 18015 return getToken(JavadocParser.LEADING_ASTERISK, i); 18016 } 18017 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 18018 public TerminalNode WS(int i) { 18019 return getToken(JavadocParser.WS, i); 18020 } 18021 public RbTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 18022 public RbTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 18023 super(parent, invokingState); 18024 this.isNonTight = isNonTight; 18025 } 18026 @Override public int getRuleIndex() { return RULE_rbTagStart; } 18027 } 18028 18029 public final RbTagStartContext rbTagStart(boolean isNonTight) throws RecognitionException { 18030 RbTagStartContext _localctx = new RbTagStartContext(_ctx, getState(), isNonTight); 18031 enterRule(_localctx, 166, RULE_rbTagStart); 18032 int _la; 18033 try { 18034 enterOuterAlt(_localctx, 1); 18035 { 18036 setState(2220); 18037 match(START); 18038 setState(2221); 18039 match(RB_HTML_TAG_NAME); 18040 setState(2228); 18041 _errHandler.sync(this); 18042 _la = _input.LA(1); 18043 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 18044 { 18045 setState(2226); 18046 _errHandler.sync(this); 18047 switch (_input.LA(1)) { 18048 case HTML_TAG_NAME: 18049 { 18050 setState(2222); 18051 attribute(); 18052 } 18053 break; 18054 case NEWLINE: 18055 { 18056 setState(2223); 18057 match(NEWLINE); 18058 } 18059 break; 18060 case LEADING_ASTERISK: 18061 { 18062 setState(2224); 18063 match(LEADING_ASTERISK); 18064 } 18065 break; 18066 case WS: 18067 { 18068 setState(2225); 18069 match(WS); 18070 } 18071 break; 18072 default: 18073 throw new NoViableAltException(this); 18074 } 18075 } 18076 setState(2230); 18077 _errHandler.sync(this); 18078 _la = _input.LA(1); 18079 } 18080 setState(2231); 18081 match(END); 18082 } 18083 _ctx.stop = _input.LT(-1); 18084 18085 if (isNonTight && nonTightTagStartContext == null) { 18086 nonTightTagStartContext = _localctx; 18087 } 18088 18089 } 18090 catch (RecognitionException re) { 18091 _localctx.exception = re; 18092 _errHandler.reportError(this, re); 18093 _errHandler.recover(this, re); 18094 } 18095 finally { 18096 exitRule(); 18097 } 18098 return _localctx; 18099 } 18100 18101 public static class RbTagEndContext extends ParserRuleContext { 18102 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 18103 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 18104 public TerminalNode RB_HTML_TAG_NAME() { return getToken(JavadocParser.RB_HTML_TAG_NAME, 0); } 18105 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 18106 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 18107 public TerminalNode NEWLINE(int i) { 18108 return getToken(JavadocParser.NEWLINE, i); 18109 } 18110 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 18111 public TerminalNode LEADING_ASTERISK(int i) { 18112 return getToken(JavadocParser.LEADING_ASTERISK, i); 18113 } 18114 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 18115 public TerminalNode WS(int i) { 18116 return getToken(JavadocParser.WS, i); 18117 } 18118 public RbTagEndContext(ParserRuleContext parent, int invokingState) { 18119 super(parent, invokingState); 18120 } 18121 @Override public int getRuleIndex() { return RULE_rbTagEnd; } 18122 } 18123 18124 public final RbTagEndContext rbTagEnd() throws RecognitionException { 18125 RbTagEndContext _localctx = new RbTagEndContext(_ctx, getState()); 18126 enterRule(_localctx, 168, RULE_rbTagEnd); 18127 int _la; 18128 try { 18129 enterOuterAlt(_localctx, 1); 18130 { 18131 setState(2233); 18132 match(START); 18133 setState(2234); 18134 match(SLASH); 18135 setState(2235); 18136 match(RB_HTML_TAG_NAME); 18137 setState(2239); 18138 _errHandler.sync(this); 18139 _la = _input.LA(1); 18140 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 18141 { 18142 { 18143 setState(2236); 18144 _la = _input.LA(1); 18145 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 18146 _errHandler.recoverInline(this); 18147 } 18148 else { 18149 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 18150 _errHandler.reportMatch(this); 18151 consume(); 18152 } 18153 } 18154 } 18155 setState(2241); 18156 _errHandler.sync(this); 18157 _la = _input.LA(1); 18158 } 18159 setState(2242); 18160 match(END); 18161 } 18162 } 18163 catch (RecognitionException re) { 18164 _localctx.exception = re; 18165 _errHandler.reportError(this, re); 18166 _errHandler.recover(this, re); 18167 } 18168 finally { 18169 exitRule(); 18170 } 18171 return _localctx; 18172 } 18173 18174 public static class RbContext extends ParserRuleContext { 18175 public RbTagStartContext rbTagStart() { 18176 return getRuleContext(RbTagStartContext.class,0); 18177 } 18178 public RbTagEndContext rbTagEnd() { 18179 return getRuleContext(RbTagEndContext.class,0); 18180 } 18181 public List<HtmlTagContext> htmlTag() { 18182 return getRuleContexts(HtmlTagContext.class); 18183 } 18184 public HtmlTagContext htmlTag(int i) { 18185 return getRuleContext(HtmlTagContext.class,i); 18186 } 18187 public List<SingletonElementContext> singletonElement() { 18188 return getRuleContexts(SingletonElementContext.class); 18189 } 18190 public SingletonElementContext singletonElement(int i) { 18191 return getRuleContext(SingletonElementContext.class,i); 18192 } 18193 public List<ParagraphContext> paragraph() { 18194 return getRuleContexts(ParagraphContext.class); 18195 } 18196 public ParagraphContext paragraph(int i) { 18197 return getRuleContext(ParagraphContext.class,i); 18198 } 18199 public List<LiContext> li() { 18200 return getRuleContexts(LiContext.class); 18201 } 18202 public LiContext li(int i) { 18203 return getRuleContext(LiContext.class,i); 18204 } 18205 public List<TrContext> tr() { 18206 return getRuleContexts(TrContext.class); 18207 } 18208 public TrContext tr(int i) { 18209 return getRuleContext(TrContext.class,i); 18210 } 18211 public List<TdContext> td() { 18212 return getRuleContexts(TdContext.class); 18213 } 18214 public TdContext td(int i) { 18215 return getRuleContext(TdContext.class,i); 18216 } 18217 public List<ThContext> th() { 18218 return getRuleContexts(ThContext.class); 18219 } 18220 public ThContext th(int i) { 18221 return getRuleContext(ThContext.class,i); 18222 } 18223 public List<BodyContext> body() { 18224 return getRuleContexts(BodyContext.class); 18225 } 18226 public BodyContext body(int i) { 18227 return getRuleContext(BodyContext.class,i); 18228 } 18229 public List<ColgroupContext> colgroup() { 18230 return getRuleContexts(ColgroupContext.class); 18231 } 18232 public ColgroupContext colgroup(int i) { 18233 return getRuleContext(ColgroupContext.class,i); 18234 } 18235 public List<DdContext> dd() { 18236 return getRuleContexts(DdContext.class); 18237 } 18238 public DdContext dd(int i) { 18239 return getRuleContext(DdContext.class,i); 18240 } 18241 public List<DtContext> dt() { 18242 return getRuleContexts(DtContext.class); 18243 } 18244 public DtContext dt(int i) { 18245 return getRuleContext(DtContext.class,i); 18246 } 18247 public List<HeadContext> head() { 18248 return getRuleContexts(HeadContext.class); 18249 } 18250 public HeadContext head(int i) { 18251 return getRuleContext(HeadContext.class,i); 18252 } 18253 public List<HtmlContext> html() { 18254 return getRuleContexts(HtmlContext.class); 18255 } 18256 public HtmlContext html(int i) { 18257 return getRuleContext(HtmlContext.class,i); 18258 } 18259 public List<OptionContext> option() { 18260 return getRuleContexts(OptionContext.class); 18261 } 18262 public OptionContext option(int i) { 18263 return getRuleContext(OptionContext.class,i); 18264 } 18265 public List<TbodyContext> tbody() { 18266 return getRuleContexts(TbodyContext.class); 18267 } 18268 public TbodyContext tbody(int i) { 18269 return getRuleContext(TbodyContext.class,i); 18270 } 18271 public List<TfootContext> tfoot() { 18272 return getRuleContexts(TfootContext.class); 18273 } 18274 public TfootContext tfoot(int i) { 18275 return getRuleContext(TfootContext.class,i); 18276 } 18277 public List<PTagStartContext> pTagStart() { 18278 return getRuleContexts(PTagStartContext.class); 18279 } 18280 public PTagStartContext pTagStart(int i) { 18281 return getRuleContext(PTagStartContext.class,i); 18282 } 18283 public List<LiTagStartContext> liTagStart() { 18284 return getRuleContexts(LiTagStartContext.class); 18285 } 18286 public LiTagStartContext liTagStart(int i) { 18287 return getRuleContext(LiTagStartContext.class,i); 18288 } 18289 public List<TrTagStartContext> trTagStart() { 18290 return getRuleContexts(TrTagStartContext.class); 18291 } 18292 public TrTagStartContext trTagStart(int i) { 18293 return getRuleContext(TrTagStartContext.class,i); 18294 } 18295 public List<TdTagStartContext> tdTagStart() { 18296 return getRuleContexts(TdTagStartContext.class); 18297 } 18298 public TdTagStartContext tdTagStart(int i) { 18299 return getRuleContext(TdTagStartContext.class,i); 18300 } 18301 public List<ThTagStartContext> thTagStart() { 18302 return getRuleContexts(ThTagStartContext.class); 18303 } 18304 public ThTagStartContext thTagStart(int i) { 18305 return getRuleContext(ThTagStartContext.class,i); 18306 } 18307 public List<BodyTagStartContext> bodyTagStart() { 18308 return getRuleContexts(BodyTagStartContext.class); 18309 } 18310 public BodyTagStartContext bodyTagStart(int i) { 18311 return getRuleContext(BodyTagStartContext.class,i); 18312 } 18313 public List<ColgroupTagStartContext> colgroupTagStart() { 18314 return getRuleContexts(ColgroupTagStartContext.class); 18315 } 18316 public ColgroupTagStartContext colgroupTagStart(int i) { 18317 return getRuleContext(ColgroupTagStartContext.class,i); 18318 } 18319 public List<DdTagStartContext> ddTagStart() { 18320 return getRuleContexts(DdTagStartContext.class); 18321 } 18322 public DdTagStartContext ddTagStart(int i) { 18323 return getRuleContext(DdTagStartContext.class,i); 18324 } 18325 public List<DtTagStartContext> dtTagStart() { 18326 return getRuleContexts(DtTagStartContext.class); 18327 } 18328 public DtTagStartContext dtTagStart(int i) { 18329 return getRuleContext(DtTagStartContext.class,i); 18330 } 18331 public List<HeadTagStartContext> headTagStart() { 18332 return getRuleContexts(HeadTagStartContext.class); 18333 } 18334 public HeadTagStartContext headTagStart(int i) { 18335 return getRuleContext(HeadTagStartContext.class,i); 18336 } 18337 public List<HtmlTagStartContext> htmlTagStart() { 18338 return getRuleContexts(HtmlTagStartContext.class); 18339 } 18340 public HtmlTagStartContext htmlTagStart(int i) { 18341 return getRuleContext(HtmlTagStartContext.class,i); 18342 } 18343 public List<OptionTagStartContext> optionTagStart() { 18344 return getRuleContexts(OptionTagStartContext.class); 18345 } 18346 public OptionTagStartContext optionTagStart(int i) { 18347 return getRuleContext(OptionTagStartContext.class,i); 18348 } 18349 public List<TbodyTagStartContext> tbodyTagStart() { 18350 return getRuleContexts(TbodyTagStartContext.class); 18351 } 18352 public TbodyTagStartContext tbodyTagStart(int i) { 18353 return getRuleContext(TbodyTagStartContext.class,i); 18354 } 18355 public List<TfootTagStartContext> tfootTagStart() { 18356 return getRuleContexts(TfootTagStartContext.class); 18357 } 18358 public TfootTagStartContext tfootTagStart(int i) { 18359 return getRuleContext(TfootTagStartContext.class,i); 18360 } 18361 public List<HtmlCommentContext> htmlComment() { 18362 return getRuleContexts(HtmlCommentContext.class); 18363 } 18364 public HtmlCommentContext htmlComment(int i) { 18365 return getRuleContext(HtmlCommentContext.class,i); 18366 } 18367 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 18368 public TerminalNode CDATA(int i) { 18369 return getToken(JavadocParser.CDATA, i); 18370 } 18371 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 18372 public TerminalNode NEWLINE(int i) { 18373 return getToken(JavadocParser.NEWLINE, i); 18374 } 18375 public List<TextContext> text() { 18376 return getRuleContexts(TextContext.class); 18377 } 18378 public TextContext text(int i) { 18379 return getRuleContext(TextContext.class,i); 18380 } 18381 public List<JavadocInlineTagContext> javadocInlineTag() { 18382 return getRuleContexts(JavadocInlineTagContext.class); 18383 } 18384 public JavadocInlineTagContext javadocInlineTag(int i) { 18385 return getRuleContext(JavadocInlineTagContext.class,i); 18386 } 18387 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 18388 public TerminalNode LEADING_ASTERISK(int i) { 18389 return getToken(JavadocParser.LEADING_ASTERISK, i); 18390 } 18391 public RbContext(ParserRuleContext parent, int invokingState) { 18392 super(parent, invokingState); 18393 } 18394 @Override public int getRuleIndex() { return RULE_rb; } 18395 } 18396 18397 public final RbContext rb() throws RecognitionException { 18398 RbContext _localctx = new RbContext(_ctx, getState()); 18399 enterRule(_localctx, 170, RULE_rb); 18400 try { 18401 int _alt; 18402 enterOuterAlt(_localctx, 1); 18403 { 18404 setState(2244); 18405 rbTagStart(false); 18406 setState(2284); 18407 _errHandler.sync(this); 18408 _alt = getInterpreter().adaptivePredict(_input,201,_ctx); 18409 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 18410 if ( _alt==1 ) { 18411 { 18412 setState(2282); 18413 _errHandler.sync(this); 18414 switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) { 18415 case 1: 18416 { 18417 setState(2245); 18418 htmlTag(); 18419 } 18420 break; 18421 case 2: 18422 { 18423 setState(2246); 18424 singletonElement(); 18425 } 18426 break; 18427 case 3: 18428 { 18429 setState(2247); 18430 paragraph(); 18431 } 18432 break; 18433 case 4: 18434 { 18435 setState(2248); 18436 li(); 18437 } 18438 break; 18439 case 5: 18440 { 18441 setState(2249); 18442 tr(); 18443 } 18444 break; 18445 case 6: 18446 { 18447 setState(2250); 18448 td(); 18449 } 18450 break; 18451 case 7: 18452 { 18453 setState(2251); 18454 th(); 18455 } 18456 break; 18457 case 8: 18458 { 18459 setState(2252); 18460 body(); 18461 } 18462 break; 18463 case 9: 18464 { 18465 setState(2253); 18466 colgroup(); 18467 } 18468 break; 18469 case 10: 18470 { 18471 setState(2254); 18472 dd(); 18473 } 18474 break; 18475 case 11: 18476 { 18477 setState(2255); 18478 dt(); 18479 } 18480 break; 18481 case 12: 18482 { 18483 setState(2256); 18484 head(); 18485 } 18486 break; 18487 case 13: 18488 { 18489 setState(2257); 18490 html(); 18491 } 18492 break; 18493 case 14: 18494 { 18495 setState(2258); 18496 option(); 18497 } 18498 break; 18499 case 15: 18500 { 18501 setState(2259); 18502 tbody(); 18503 } 18504 break; 18505 case 16: 18506 { 18507 setState(2260); 18508 tfoot(); 18509 } 18510 break; 18511 case 17: 18512 { 18513 setState(2261); 18514 pTagStart(true); 18515 } 18516 break; 18517 case 18: 18518 { 18519 setState(2262); 18520 liTagStart(true); 18521 } 18522 break; 18523 case 19: 18524 { 18525 setState(2263); 18526 trTagStart(true); 18527 } 18528 break; 18529 case 20: 18530 { 18531 setState(2264); 18532 tdTagStart(true); 18533 } 18534 break; 18535 case 21: 18536 { 18537 setState(2265); 18538 thTagStart(true); 18539 } 18540 break; 18541 case 22: 18542 { 18543 setState(2266); 18544 bodyTagStart(true); 18545 } 18546 break; 18547 case 23: 18548 { 18549 setState(2267); 18550 colgroupTagStart(true); 18551 } 18552 break; 18553 case 24: 18554 { 18555 setState(2268); 18556 ddTagStart(true); 18557 } 18558 break; 18559 case 25: 18560 { 18561 setState(2269); 18562 dtTagStart(true); 18563 } 18564 break; 18565 case 26: 18566 { 18567 setState(2270); 18568 headTagStart(true); 18569 } 18570 break; 18571 case 27: 18572 { 18573 setState(2271); 18574 htmlTagStart(true); 18575 } 18576 break; 18577 case 28: 18578 { 18579 setState(2272); 18580 optionTagStart(true); 18581 } 18582 break; 18583 case 29: 18584 { 18585 setState(2273); 18586 tbodyTagStart(true); 18587 } 18588 break; 18589 case 30: 18590 { 18591 setState(2274); 18592 tfootTagStart(true); 18593 } 18594 break; 18595 case 31: 18596 { 18597 { 18598 setState(2275); 18599 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 18600 setState(2276); 18601 match(LEADING_ASTERISK); 18602 } 18603 } 18604 break; 18605 case 32: 18606 { 18607 setState(2277); 18608 htmlComment(); 18609 } 18610 break; 18611 case 33: 18612 { 18613 setState(2278); 18614 match(CDATA); 18615 } 18616 break; 18617 case 34: 18618 { 18619 setState(2279); 18620 match(NEWLINE); 18621 } 18622 break; 18623 case 35: 18624 { 18625 setState(2280); 18626 text(); 18627 } 18628 break; 18629 case 36: 18630 { 18631 setState(2281); 18632 javadocInlineTag(); 18633 } 18634 break; 18635 } 18636 } 18637 } 18638 setState(2286); 18639 _errHandler.sync(this); 18640 _alt = getInterpreter().adaptivePredict(_input,201,_ctx); 18641 } 18642 setState(2287); 18643 rbTagEnd(); 18644 } 18645 } 18646 catch (RecognitionException re) { 18647 _localctx.exception = re; 18648 _errHandler.reportError(this, re); 18649 _errHandler.recover(this, re); 18650 } 18651 finally { 18652 exitRule(); 18653 } 18654 return _localctx; 18655 } 18656 18657 public static class RtTagStartContext extends ParserRuleContext { 18658 public boolean isNonTight; 18659 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 18660 public TerminalNode RT_HTML_TAG_NAME() { return getToken(JavadocParser.RT_HTML_TAG_NAME, 0); } 18661 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 18662 public List<AttributeContext> attribute() { 18663 return getRuleContexts(AttributeContext.class); 18664 } 18665 public AttributeContext attribute(int i) { 18666 return getRuleContext(AttributeContext.class,i); 18667 } 18668 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 18669 public TerminalNode NEWLINE(int i) { 18670 return getToken(JavadocParser.NEWLINE, i); 18671 } 18672 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 18673 public TerminalNode LEADING_ASTERISK(int i) { 18674 return getToken(JavadocParser.LEADING_ASTERISK, i); 18675 } 18676 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 18677 public TerminalNode WS(int i) { 18678 return getToken(JavadocParser.WS, i); 18679 } 18680 public RtTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 18681 public RtTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 18682 super(parent, invokingState); 18683 this.isNonTight = isNonTight; 18684 } 18685 @Override public int getRuleIndex() { return RULE_rtTagStart; } 18686 } 18687 18688 public final RtTagStartContext rtTagStart(boolean isNonTight) throws RecognitionException { 18689 RtTagStartContext _localctx = new RtTagStartContext(_ctx, getState(), isNonTight); 18690 enterRule(_localctx, 172, RULE_rtTagStart); 18691 int _la; 18692 try { 18693 enterOuterAlt(_localctx, 1); 18694 { 18695 setState(2289); 18696 match(START); 18697 setState(2290); 18698 match(RT_HTML_TAG_NAME); 18699 setState(2297); 18700 _errHandler.sync(this); 18701 _la = _input.LA(1); 18702 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 18703 { 18704 setState(2295); 18705 _errHandler.sync(this); 18706 switch (_input.LA(1)) { 18707 case HTML_TAG_NAME: 18708 { 18709 setState(2291); 18710 attribute(); 18711 } 18712 break; 18713 case NEWLINE: 18714 { 18715 setState(2292); 18716 match(NEWLINE); 18717 } 18718 break; 18719 case LEADING_ASTERISK: 18720 { 18721 setState(2293); 18722 match(LEADING_ASTERISK); 18723 } 18724 break; 18725 case WS: 18726 { 18727 setState(2294); 18728 match(WS); 18729 } 18730 break; 18731 default: 18732 throw new NoViableAltException(this); 18733 } 18734 } 18735 setState(2299); 18736 _errHandler.sync(this); 18737 _la = _input.LA(1); 18738 } 18739 setState(2300); 18740 match(END); 18741 } 18742 _ctx.stop = _input.LT(-1); 18743 18744 if (isNonTight && nonTightTagStartContext == null) { 18745 nonTightTagStartContext = _localctx; 18746 } 18747 18748 } 18749 catch (RecognitionException re) { 18750 _localctx.exception = re; 18751 _errHandler.reportError(this, re); 18752 _errHandler.recover(this, re); 18753 } 18754 finally { 18755 exitRule(); 18756 } 18757 return _localctx; 18758 } 18759 18760 public static class RtTagEndContext extends ParserRuleContext { 18761 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 18762 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 18763 public TerminalNode RT_HTML_TAG_NAME() { return getToken(JavadocParser.RT_HTML_TAG_NAME, 0); } 18764 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 18765 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 18766 public TerminalNode NEWLINE(int i) { 18767 return getToken(JavadocParser.NEWLINE, i); 18768 } 18769 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 18770 public TerminalNode LEADING_ASTERISK(int i) { 18771 return getToken(JavadocParser.LEADING_ASTERISK, i); 18772 } 18773 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 18774 public TerminalNode WS(int i) { 18775 return getToken(JavadocParser.WS, i); 18776 } 18777 public RtTagEndContext(ParserRuleContext parent, int invokingState) { 18778 super(parent, invokingState); 18779 } 18780 @Override public int getRuleIndex() { return RULE_rtTagEnd; } 18781 } 18782 18783 public final RtTagEndContext rtTagEnd() throws RecognitionException { 18784 RtTagEndContext _localctx = new RtTagEndContext(_ctx, getState()); 18785 enterRule(_localctx, 174, RULE_rtTagEnd); 18786 int _la; 18787 try { 18788 enterOuterAlt(_localctx, 1); 18789 { 18790 setState(2302); 18791 match(START); 18792 setState(2303); 18793 match(SLASH); 18794 setState(2304); 18795 match(RT_HTML_TAG_NAME); 18796 setState(2308); 18797 _errHandler.sync(this); 18798 _la = _input.LA(1); 18799 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 18800 { 18801 { 18802 setState(2305); 18803 _la = _input.LA(1); 18804 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 18805 _errHandler.recoverInline(this); 18806 } 18807 else { 18808 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 18809 _errHandler.reportMatch(this); 18810 consume(); 18811 } 18812 } 18813 } 18814 setState(2310); 18815 _errHandler.sync(this); 18816 _la = _input.LA(1); 18817 } 18818 setState(2311); 18819 match(END); 18820 } 18821 } 18822 catch (RecognitionException re) { 18823 _localctx.exception = re; 18824 _errHandler.reportError(this, re); 18825 _errHandler.recover(this, re); 18826 } 18827 finally { 18828 exitRule(); 18829 } 18830 return _localctx; 18831 } 18832 18833 public static class RtContext extends ParserRuleContext { 18834 public RtTagStartContext rtTagStart() { 18835 return getRuleContext(RtTagStartContext.class,0); 18836 } 18837 public RtTagEndContext rtTagEnd() { 18838 return getRuleContext(RtTagEndContext.class,0); 18839 } 18840 public List<HtmlTagContext> htmlTag() { 18841 return getRuleContexts(HtmlTagContext.class); 18842 } 18843 public HtmlTagContext htmlTag(int i) { 18844 return getRuleContext(HtmlTagContext.class,i); 18845 } 18846 public List<SingletonElementContext> singletonElement() { 18847 return getRuleContexts(SingletonElementContext.class); 18848 } 18849 public SingletonElementContext singletonElement(int i) { 18850 return getRuleContext(SingletonElementContext.class,i); 18851 } 18852 public List<ParagraphContext> paragraph() { 18853 return getRuleContexts(ParagraphContext.class); 18854 } 18855 public ParagraphContext paragraph(int i) { 18856 return getRuleContext(ParagraphContext.class,i); 18857 } 18858 public List<LiContext> li() { 18859 return getRuleContexts(LiContext.class); 18860 } 18861 public LiContext li(int i) { 18862 return getRuleContext(LiContext.class,i); 18863 } 18864 public List<TrContext> tr() { 18865 return getRuleContexts(TrContext.class); 18866 } 18867 public TrContext tr(int i) { 18868 return getRuleContext(TrContext.class,i); 18869 } 18870 public List<TdContext> td() { 18871 return getRuleContexts(TdContext.class); 18872 } 18873 public TdContext td(int i) { 18874 return getRuleContext(TdContext.class,i); 18875 } 18876 public List<ThContext> th() { 18877 return getRuleContexts(ThContext.class); 18878 } 18879 public ThContext th(int i) { 18880 return getRuleContext(ThContext.class,i); 18881 } 18882 public List<BodyContext> body() { 18883 return getRuleContexts(BodyContext.class); 18884 } 18885 public BodyContext body(int i) { 18886 return getRuleContext(BodyContext.class,i); 18887 } 18888 public List<ColgroupContext> colgroup() { 18889 return getRuleContexts(ColgroupContext.class); 18890 } 18891 public ColgroupContext colgroup(int i) { 18892 return getRuleContext(ColgroupContext.class,i); 18893 } 18894 public List<DdContext> dd() { 18895 return getRuleContexts(DdContext.class); 18896 } 18897 public DdContext dd(int i) { 18898 return getRuleContext(DdContext.class,i); 18899 } 18900 public List<DtContext> dt() { 18901 return getRuleContexts(DtContext.class); 18902 } 18903 public DtContext dt(int i) { 18904 return getRuleContext(DtContext.class,i); 18905 } 18906 public List<HeadContext> head() { 18907 return getRuleContexts(HeadContext.class); 18908 } 18909 public HeadContext head(int i) { 18910 return getRuleContext(HeadContext.class,i); 18911 } 18912 public List<HtmlContext> html() { 18913 return getRuleContexts(HtmlContext.class); 18914 } 18915 public HtmlContext html(int i) { 18916 return getRuleContext(HtmlContext.class,i); 18917 } 18918 public List<OptionContext> option() { 18919 return getRuleContexts(OptionContext.class); 18920 } 18921 public OptionContext option(int i) { 18922 return getRuleContext(OptionContext.class,i); 18923 } 18924 public List<TbodyContext> tbody() { 18925 return getRuleContexts(TbodyContext.class); 18926 } 18927 public TbodyContext tbody(int i) { 18928 return getRuleContext(TbodyContext.class,i); 18929 } 18930 public List<TfootContext> tfoot() { 18931 return getRuleContexts(TfootContext.class); 18932 } 18933 public TfootContext tfoot(int i) { 18934 return getRuleContext(TfootContext.class,i); 18935 } 18936 public List<PTagStartContext> pTagStart() { 18937 return getRuleContexts(PTagStartContext.class); 18938 } 18939 public PTagStartContext pTagStart(int i) { 18940 return getRuleContext(PTagStartContext.class,i); 18941 } 18942 public List<LiTagStartContext> liTagStart() { 18943 return getRuleContexts(LiTagStartContext.class); 18944 } 18945 public LiTagStartContext liTagStart(int i) { 18946 return getRuleContext(LiTagStartContext.class,i); 18947 } 18948 public List<TrTagStartContext> trTagStart() { 18949 return getRuleContexts(TrTagStartContext.class); 18950 } 18951 public TrTagStartContext trTagStart(int i) { 18952 return getRuleContext(TrTagStartContext.class,i); 18953 } 18954 public List<TdTagStartContext> tdTagStart() { 18955 return getRuleContexts(TdTagStartContext.class); 18956 } 18957 public TdTagStartContext tdTagStart(int i) { 18958 return getRuleContext(TdTagStartContext.class,i); 18959 } 18960 public List<ThTagStartContext> thTagStart() { 18961 return getRuleContexts(ThTagStartContext.class); 18962 } 18963 public ThTagStartContext thTagStart(int i) { 18964 return getRuleContext(ThTagStartContext.class,i); 18965 } 18966 public List<BodyTagStartContext> bodyTagStart() { 18967 return getRuleContexts(BodyTagStartContext.class); 18968 } 18969 public BodyTagStartContext bodyTagStart(int i) { 18970 return getRuleContext(BodyTagStartContext.class,i); 18971 } 18972 public List<ColgroupTagStartContext> colgroupTagStart() { 18973 return getRuleContexts(ColgroupTagStartContext.class); 18974 } 18975 public ColgroupTagStartContext colgroupTagStart(int i) { 18976 return getRuleContext(ColgroupTagStartContext.class,i); 18977 } 18978 public List<DdTagStartContext> ddTagStart() { 18979 return getRuleContexts(DdTagStartContext.class); 18980 } 18981 public DdTagStartContext ddTagStart(int i) { 18982 return getRuleContext(DdTagStartContext.class,i); 18983 } 18984 public List<DtTagStartContext> dtTagStart() { 18985 return getRuleContexts(DtTagStartContext.class); 18986 } 18987 public DtTagStartContext dtTagStart(int i) { 18988 return getRuleContext(DtTagStartContext.class,i); 18989 } 18990 public List<HeadTagStartContext> headTagStart() { 18991 return getRuleContexts(HeadTagStartContext.class); 18992 } 18993 public HeadTagStartContext headTagStart(int i) { 18994 return getRuleContext(HeadTagStartContext.class,i); 18995 } 18996 public List<HtmlTagStartContext> htmlTagStart() { 18997 return getRuleContexts(HtmlTagStartContext.class); 18998 } 18999 public HtmlTagStartContext htmlTagStart(int i) { 19000 return getRuleContext(HtmlTagStartContext.class,i); 19001 } 19002 public List<OptionTagStartContext> optionTagStart() { 19003 return getRuleContexts(OptionTagStartContext.class); 19004 } 19005 public OptionTagStartContext optionTagStart(int i) { 19006 return getRuleContext(OptionTagStartContext.class,i); 19007 } 19008 public List<TbodyTagStartContext> tbodyTagStart() { 19009 return getRuleContexts(TbodyTagStartContext.class); 19010 } 19011 public TbodyTagStartContext tbodyTagStart(int i) { 19012 return getRuleContext(TbodyTagStartContext.class,i); 19013 } 19014 public List<TfootTagStartContext> tfootTagStart() { 19015 return getRuleContexts(TfootTagStartContext.class); 19016 } 19017 public TfootTagStartContext tfootTagStart(int i) { 19018 return getRuleContext(TfootTagStartContext.class,i); 19019 } 19020 public List<HtmlCommentContext> htmlComment() { 19021 return getRuleContexts(HtmlCommentContext.class); 19022 } 19023 public HtmlCommentContext htmlComment(int i) { 19024 return getRuleContext(HtmlCommentContext.class,i); 19025 } 19026 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 19027 public TerminalNode CDATA(int i) { 19028 return getToken(JavadocParser.CDATA, i); 19029 } 19030 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 19031 public TerminalNode NEWLINE(int i) { 19032 return getToken(JavadocParser.NEWLINE, i); 19033 } 19034 public List<TextContext> text() { 19035 return getRuleContexts(TextContext.class); 19036 } 19037 public TextContext text(int i) { 19038 return getRuleContext(TextContext.class,i); 19039 } 19040 public List<JavadocInlineTagContext> javadocInlineTag() { 19041 return getRuleContexts(JavadocInlineTagContext.class); 19042 } 19043 public JavadocInlineTagContext javadocInlineTag(int i) { 19044 return getRuleContext(JavadocInlineTagContext.class,i); 19045 } 19046 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 19047 public TerminalNode LEADING_ASTERISK(int i) { 19048 return getToken(JavadocParser.LEADING_ASTERISK, i); 19049 } 19050 public RtContext(ParserRuleContext parent, int invokingState) { 19051 super(parent, invokingState); 19052 } 19053 @Override public int getRuleIndex() { return RULE_rt; } 19054 } 19055 19056 public final RtContext rt() throws RecognitionException { 19057 RtContext _localctx = new RtContext(_ctx, getState()); 19058 enterRule(_localctx, 176, RULE_rt); 19059 try { 19060 int _alt; 19061 enterOuterAlt(_localctx, 1); 19062 { 19063 setState(2313); 19064 rtTagStart(false); 19065 setState(2353); 19066 _errHandler.sync(this); 19067 _alt = getInterpreter().adaptivePredict(_input,206,_ctx); 19068 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 19069 if ( _alt==1 ) { 19070 { 19071 setState(2351); 19072 _errHandler.sync(this); 19073 switch ( getInterpreter().adaptivePredict(_input,205,_ctx) ) { 19074 case 1: 19075 { 19076 setState(2314); 19077 htmlTag(); 19078 } 19079 break; 19080 case 2: 19081 { 19082 setState(2315); 19083 singletonElement(); 19084 } 19085 break; 19086 case 3: 19087 { 19088 setState(2316); 19089 paragraph(); 19090 } 19091 break; 19092 case 4: 19093 { 19094 setState(2317); 19095 li(); 19096 } 19097 break; 19098 case 5: 19099 { 19100 setState(2318); 19101 tr(); 19102 } 19103 break; 19104 case 6: 19105 { 19106 setState(2319); 19107 td(); 19108 } 19109 break; 19110 case 7: 19111 { 19112 setState(2320); 19113 th(); 19114 } 19115 break; 19116 case 8: 19117 { 19118 setState(2321); 19119 body(); 19120 } 19121 break; 19122 case 9: 19123 { 19124 setState(2322); 19125 colgroup(); 19126 } 19127 break; 19128 case 10: 19129 { 19130 setState(2323); 19131 dd(); 19132 } 19133 break; 19134 case 11: 19135 { 19136 setState(2324); 19137 dt(); 19138 } 19139 break; 19140 case 12: 19141 { 19142 setState(2325); 19143 head(); 19144 } 19145 break; 19146 case 13: 19147 { 19148 setState(2326); 19149 html(); 19150 } 19151 break; 19152 case 14: 19153 { 19154 setState(2327); 19155 option(); 19156 } 19157 break; 19158 case 15: 19159 { 19160 setState(2328); 19161 tbody(); 19162 } 19163 break; 19164 case 16: 19165 { 19166 setState(2329); 19167 tfoot(); 19168 } 19169 break; 19170 case 17: 19171 { 19172 setState(2330); 19173 pTagStart(true); 19174 } 19175 break; 19176 case 18: 19177 { 19178 setState(2331); 19179 liTagStart(true); 19180 } 19181 break; 19182 case 19: 19183 { 19184 setState(2332); 19185 trTagStart(true); 19186 } 19187 break; 19188 case 20: 19189 { 19190 setState(2333); 19191 tdTagStart(true); 19192 } 19193 break; 19194 case 21: 19195 { 19196 setState(2334); 19197 thTagStart(true); 19198 } 19199 break; 19200 case 22: 19201 { 19202 setState(2335); 19203 bodyTagStart(true); 19204 } 19205 break; 19206 case 23: 19207 { 19208 setState(2336); 19209 colgroupTagStart(true); 19210 } 19211 break; 19212 case 24: 19213 { 19214 setState(2337); 19215 ddTagStart(true); 19216 } 19217 break; 19218 case 25: 19219 { 19220 setState(2338); 19221 dtTagStart(true); 19222 } 19223 break; 19224 case 26: 19225 { 19226 setState(2339); 19227 headTagStart(true); 19228 } 19229 break; 19230 case 27: 19231 { 19232 setState(2340); 19233 htmlTagStart(true); 19234 } 19235 break; 19236 case 28: 19237 { 19238 setState(2341); 19239 optionTagStart(true); 19240 } 19241 break; 19242 case 29: 19243 { 19244 setState(2342); 19245 tbodyTagStart(true); 19246 } 19247 break; 19248 case 30: 19249 { 19250 setState(2343); 19251 tfootTagStart(true); 19252 } 19253 break; 19254 case 31: 19255 { 19256 { 19257 setState(2344); 19258 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 19259 setState(2345); 19260 match(LEADING_ASTERISK); 19261 } 19262 } 19263 break; 19264 case 32: 19265 { 19266 setState(2346); 19267 htmlComment(); 19268 } 19269 break; 19270 case 33: 19271 { 19272 setState(2347); 19273 match(CDATA); 19274 } 19275 break; 19276 case 34: 19277 { 19278 setState(2348); 19279 match(NEWLINE); 19280 } 19281 break; 19282 case 35: 19283 { 19284 setState(2349); 19285 text(); 19286 } 19287 break; 19288 case 36: 19289 { 19290 setState(2350); 19291 javadocInlineTag(); 19292 } 19293 break; 19294 } 19295 } 19296 } 19297 setState(2355); 19298 _errHandler.sync(this); 19299 _alt = getInterpreter().adaptivePredict(_input,206,_ctx); 19300 } 19301 setState(2356); 19302 rtTagEnd(); 19303 } 19304 } 19305 catch (RecognitionException re) { 19306 _localctx.exception = re; 19307 _errHandler.reportError(this, re); 19308 _errHandler.recover(this, re); 19309 } 19310 finally { 19311 exitRule(); 19312 } 19313 return _localctx; 19314 } 19315 19316 public static class RtcTagStartContext extends ParserRuleContext { 19317 public boolean isNonTight; 19318 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 19319 public TerminalNode RTC_HTML_TAG_NAME() { return getToken(JavadocParser.RTC_HTML_TAG_NAME, 0); } 19320 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 19321 public List<AttributeContext> attribute() { 19322 return getRuleContexts(AttributeContext.class); 19323 } 19324 public AttributeContext attribute(int i) { 19325 return getRuleContext(AttributeContext.class,i); 19326 } 19327 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 19328 public TerminalNode NEWLINE(int i) { 19329 return getToken(JavadocParser.NEWLINE, i); 19330 } 19331 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 19332 public TerminalNode LEADING_ASTERISK(int i) { 19333 return getToken(JavadocParser.LEADING_ASTERISK, i); 19334 } 19335 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 19336 public TerminalNode WS(int i) { 19337 return getToken(JavadocParser.WS, i); 19338 } 19339 public RtcTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 19340 public RtcTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 19341 super(parent, invokingState); 19342 this.isNonTight = isNonTight; 19343 } 19344 @Override public int getRuleIndex() { return RULE_rtcTagStart; } 19345 } 19346 19347 public final RtcTagStartContext rtcTagStart(boolean isNonTight) throws RecognitionException { 19348 RtcTagStartContext _localctx = new RtcTagStartContext(_ctx, getState(), isNonTight); 19349 enterRule(_localctx, 178, RULE_rtcTagStart); 19350 int _la; 19351 try { 19352 enterOuterAlt(_localctx, 1); 19353 { 19354 setState(2358); 19355 match(START); 19356 setState(2359); 19357 match(RTC_HTML_TAG_NAME); 19358 setState(2366); 19359 _errHandler.sync(this); 19360 _la = _input.LA(1); 19361 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 19362 { 19363 setState(2364); 19364 _errHandler.sync(this); 19365 switch (_input.LA(1)) { 19366 case HTML_TAG_NAME: 19367 { 19368 setState(2360); 19369 attribute(); 19370 } 19371 break; 19372 case NEWLINE: 19373 { 19374 setState(2361); 19375 match(NEWLINE); 19376 } 19377 break; 19378 case LEADING_ASTERISK: 19379 { 19380 setState(2362); 19381 match(LEADING_ASTERISK); 19382 } 19383 break; 19384 case WS: 19385 { 19386 setState(2363); 19387 match(WS); 19388 } 19389 break; 19390 default: 19391 throw new NoViableAltException(this); 19392 } 19393 } 19394 setState(2368); 19395 _errHandler.sync(this); 19396 _la = _input.LA(1); 19397 } 19398 setState(2369); 19399 match(END); 19400 } 19401 _ctx.stop = _input.LT(-1); 19402 19403 if (isNonTight && nonTightTagStartContext == null) { 19404 nonTightTagStartContext = _localctx; 19405 } 19406 19407 } 19408 catch (RecognitionException re) { 19409 _localctx.exception = re; 19410 _errHandler.reportError(this, re); 19411 _errHandler.recover(this, re); 19412 } 19413 finally { 19414 exitRule(); 19415 } 19416 return _localctx; 19417 } 19418 19419 public static class RtcTagEndContext extends ParserRuleContext { 19420 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 19421 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 19422 public TerminalNode RTC_HTML_TAG_NAME() { return getToken(JavadocParser.RTC_HTML_TAG_NAME, 0); } 19423 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 19424 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 19425 public TerminalNode NEWLINE(int i) { 19426 return getToken(JavadocParser.NEWLINE, i); 19427 } 19428 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 19429 public TerminalNode LEADING_ASTERISK(int i) { 19430 return getToken(JavadocParser.LEADING_ASTERISK, i); 19431 } 19432 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 19433 public TerminalNode WS(int i) { 19434 return getToken(JavadocParser.WS, i); 19435 } 19436 public RtcTagEndContext(ParserRuleContext parent, int invokingState) { 19437 super(parent, invokingState); 19438 } 19439 @Override public int getRuleIndex() { return RULE_rtcTagEnd; } 19440 } 19441 19442 public final RtcTagEndContext rtcTagEnd() throws RecognitionException { 19443 RtcTagEndContext _localctx = new RtcTagEndContext(_ctx, getState()); 19444 enterRule(_localctx, 180, RULE_rtcTagEnd); 19445 int _la; 19446 try { 19447 enterOuterAlt(_localctx, 1); 19448 { 19449 setState(2371); 19450 match(START); 19451 setState(2372); 19452 match(SLASH); 19453 setState(2373); 19454 match(RTC_HTML_TAG_NAME); 19455 setState(2377); 19456 _errHandler.sync(this); 19457 _la = _input.LA(1); 19458 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 19459 { 19460 { 19461 setState(2374); 19462 _la = _input.LA(1); 19463 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 19464 _errHandler.recoverInline(this); 19465 } 19466 else { 19467 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 19468 _errHandler.reportMatch(this); 19469 consume(); 19470 } 19471 } 19472 } 19473 setState(2379); 19474 _errHandler.sync(this); 19475 _la = _input.LA(1); 19476 } 19477 setState(2380); 19478 match(END); 19479 } 19480 } 19481 catch (RecognitionException re) { 19482 _localctx.exception = re; 19483 _errHandler.reportError(this, re); 19484 _errHandler.recover(this, re); 19485 } 19486 finally { 19487 exitRule(); 19488 } 19489 return _localctx; 19490 } 19491 19492 public static class RtcContext extends ParserRuleContext { 19493 public RtcTagStartContext rtcTagStart() { 19494 return getRuleContext(RtcTagStartContext.class,0); 19495 } 19496 public RtcTagEndContext rtcTagEnd() { 19497 return getRuleContext(RtcTagEndContext.class,0); 19498 } 19499 public List<HtmlTagContext> htmlTag() { 19500 return getRuleContexts(HtmlTagContext.class); 19501 } 19502 public HtmlTagContext htmlTag(int i) { 19503 return getRuleContext(HtmlTagContext.class,i); 19504 } 19505 public List<SingletonElementContext> singletonElement() { 19506 return getRuleContexts(SingletonElementContext.class); 19507 } 19508 public SingletonElementContext singletonElement(int i) { 19509 return getRuleContext(SingletonElementContext.class,i); 19510 } 19511 public List<ParagraphContext> paragraph() { 19512 return getRuleContexts(ParagraphContext.class); 19513 } 19514 public ParagraphContext paragraph(int i) { 19515 return getRuleContext(ParagraphContext.class,i); 19516 } 19517 public List<LiContext> li() { 19518 return getRuleContexts(LiContext.class); 19519 } 19520 public LiContext li(int i) { 19521 return getRuleContext(LiContext.class,i); 19522 } 19523 public List<TrContext> tr() { 19524 return getRuleContexts(TrContext.class); 19525 } 19526 public TrContext tr(int i) { 19527 return getRuleContext(TrContext.class,i); 19528 } 19529 public List<TdContext> td() { 19530 return getRuleContexts(TdContext.class); 19531 } 19532 public TdContext td(int i) { 19533 return getRuleContext(TdContext.class,i); 19534 } 19535 public List<ThContext> th() { 19536 return getRuleContexts(ThContext.class); 19537 } 19538 public ThContext th(int i) { 19539 return getRuleContext(ThContext.class,i); 19540 } 19541 public List<BodyContext> body() { 19542 return getRuleContexts(BodyContext.class); 19543 } 19544 public BodyContext body(int i) { 19545 return getRuleContext(BodyContext.class,i); 19546 } 19547 public List<ColgroupContext> colgroup() { 19548 return getRuleContexts(ColgroupContext.class); 19549 } 19550 public ColgroupContext colgroup(int i) { 19551 return getRuleContext(ColgroupContext.class,i); 19552 } 19553 public List<DdContext> dd() { 19554 return getRuleContexts(DdContext.class); 19555 } 19556 public DdContext dd(int i) { 19557 return getRuleContext(DdContext.class,i); 19558 } 19559 public List<DtContext> dt() { 19560 return getRuleContexts(DtContext.class); 19561 } 19562 public DtContext dt(int i) { 19563 return getRuleContext(DtContext.class,i); 19564 } 19565 public List<HeadContext> head() { 19566 return getRuleContexts(HeadContext.class); 19567 } 19568 public HeadContext head(int i) { 19569 return getRuleContext(HeadContext.class,i); 19570 } 19571 public List<HtmlContext> html() { 19572 return getRuleContexts(HtmlContext.class); 19573 } 19574 public HtmlContext html(int i) { 19575 return getRuleContext(HtmlContext.class,i); 19576 } 19577 public List<OptionContext> option() { 19578 return getRuleContexts(OptionContext.class); 19579 } 19580 public OptionContext option(int i) { 19581 return getRuleContext(OptionContext.class,i); 19582 } 19583 public List<TbodyContext> tbody() { 19584 return getRuleContexts(TbodyContext.class); 19585 } 19586 public TbodyContext tbody(int i) { 19587 return getRuleContext(TbodyContext.class,i); 19588 } 19589 public List<TfootContext> tfoot() { 19590 return getRuleContexts(TfootContext.class); 19591 } 19592 public TfootContext tfoot(int i) { 19593 return getRuleContext(TfootContext.class,i); 19594 } 19595 public List<PTagStartContext> pTagStart() { 19596 return getRuleContexts(PTagStartContext.class); 19597 } 19598 public PTagStartContext pTagStart(int i) { 19599 return getRuleContext(PTagStartContext.class,i); 19600 } 19601 public List<LiTagStartContext> liTagStart() { 19602 return getRuleContexts(LiTagStartContext.class); 19603 } 19604 public LiTagStartContext liTagStart(int i) { 19605 return getRuleContext(LiTagStartContext.class,i); 19606 } 19607 public List<TrTagStartContext> trTagStart() { 19608 return getRuleContexts(TrTagStartContext.class); 19609 } 19610 public TrTagStartContext trTagStart(int i) { 19611 return getRuleContext(TrTagStartContext.class,i); 19612 } 19613 public List<TdTagStartContext> tdTagStart() { 19614 return getRuleContexts(TdTagStartContext.class); 19615 } 19616 public TdTagStartContext tdTagStart(int i) { 19617 return getRuleContext(TdTagStartContext.class,i); 19618 } 19619 public List<ThTagStartContext> thTagStart() { 19620 return getRuleContexts(ThTagStartContext.class); 19621 } 19622 public ThTagStartContext thTagStart(int i) { 19623 return getRuleContext(ThTagStartContext.class,i); 19624 } 19625 public List<BodyTagStartContext> bodyTagStart() { 19626 return getRuleContexts(BodyTagStartContext.class); 19627 } 19628 public BodyTagStartContext bodyTagStart(int i) { 19629 return getRuleContext(BodyTagStartContext.class,i); 19630 } 19631 public List<ColgroupTagStartContext> colgroupTagStart() { 19632 return getRuleContexts(ColgroupTagStartContext.class); 19633 } 19634 public ColgroupTagStartContext colgroupTagStart(int i) { 19635 return getRuleContext(ColgroupTagStartContext.class,i); 19636 } 19637 public List<DdTagStartContext> ddTagStart() { 19638 return getRuleContexts(DdTagStartContext.class); 19639 } 19640 public DdTagStartContext ddTagStart(int i) { 19641 return getRuleContext(DdTagStartContext.class,i); 19642 } 19643 public List<DtTagStartContext> dtTagStart() { 19644 return getRuleContexts(DtTagStartContext.class); 19645 } 19646 public DtTagStartContext dtTagStart(int i) { 19647 return getRuleContext(DtTagStartContext.class,i); 19648 } 19649 public List<HeadTagStartContext> headTagStart() { 19650 return getRuleContexts(HeadTagStartContext.class); 19651 } 19652 public HeadTagStartContext headTagStart(int i) { 19653 return getRuleContext(HeadTagStartContext.class,i); 19654 } 19655 public List<HtmlTagStartContext> htmlTagStart() { 19656 return getRuleContexts(HtmlTagStartContext.class); 19657 } 19658 public HtmlTagStartContext htmlTagStart(int i) { 19659 return getRuleContext(HtmlTagStartContext.class,i); 19660 } 19661 public List<OptionTagStartContext> optionTagStart() { 19662 return getRuleContexts(OptionTagStartContext.class); 19663 } 19664 public OptionTagStartContext optionTagStart(int i) { 19665 return getRuleContext(OptionTagStartContext.class,i); 19666 } 19667 public List<TbodyTagStartContext> tbodyTagStart() { 19668 return getRuleContexts(TbodyTagStartContext.class); 19669 } 19670 public TbodyTagStartContext tbodyTagStart(int i) { 19671 return getRuleContext(TbodyTagStartContext.class,i); 19672 } 19673 public List<TfootTagStartContext> tfootTagStart() { 19674 return getRuleContexts(TfootTagStartContext.class); 19675 } 19676 public TfootTagStartContext tfootTagStart(int i) { 19677 return getRuleContext(TfootTagStartContext.class,i); 19678 } 19679 public List<HtmlCommentContext> htmlComment() { 19680 return getRuleContexts(HtmlCommentContext.class); 19681 } 19682 public HtmlCommentContext htmlComment(int i) { 19683 return getRuleContext(HtmlCommentContext.class,i); 19684 } 19685 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 19686 public TerminalNode CDATA(int i) { 19687 return getToken(JavadocParser.CDATA, i); 19688 } 19689 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 19690 public TerminalNode NEWLINE(int i) { 19691 return getToken(JavadocParser.NEWLINE, i); 19692 } 19693 public List<TextContext> text() { 19694 return getRuleContexts(TextContext.class); 19695 } 19696 public TextContext text(int i) { 19697 return getRuleContext(TextContext.class,i); 19698 } 19699 public List<JavadocInlineTagContext> javadocInlineTag() { 19700 return getRuleContexts(JavadocInlineTagContext.class); 19701 } 19702 public JavadocInlineTagContext javadocInlineTag(int i) { 19703 return getRuleContext(JavadocInlineTagContext.class,i); 19704 } 19705 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 19706 public TerminalNode LEADING_ASTERISK(int i) { 19707 return getToken(JavadocParser.LEADING_ASTERISK, i); 19708 } 19709 public RtcContext(ParserRuleContext parent, int invokingState) { 19710 super(parent, invokingState); 19711 } 19712 @Override public int getRuleIndex() { return RULE_rtc; } 19713 } 19714 19715 public final RtcContext rtc() throws RecognitionException { 19716 RtcContext _localctx = new RtcContext(_ctx, getState()); 19717 enterRule(_localctx, 182, RULE_rtc); 19718 try { 19719 int _alt; 19720 enterOuterAlt(_localctx, 1); 19721 { 19722 setState(2382); 19723 rtcTagStart(false); 19724 setState(2422); 19725 _errHandler.sync(this); 19726 _alt = getInterpreter().adaptivePredict(_input,211,_ctx); 19727 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 19728 if ( _alt==1 ) { 19729 { 19730 setState(2420); 19731 _errHandler.sync(this); 19732 switch ( getInterpreter().adaptivePredict(_input,210,_ctx) ) { 19733 case 1: 19734 { 19735 setState(2383); 19736 htmlTag(); 19737 } 19738 break; 19739 case 2: 19740 { 19741 setState(2384); 19742 singletonElement(); 19743 } 19744 break; 19745 case 3: 19746 { 19747 setState(2385); 19748 paragraph(); 19749 } 19750 break; 19751 case 4: 19752 { 19753 setState(2386); 19754 li(); 19755 } 19756 break; 19757 case 5: 19758 { 19759 setState(2387); 19760 tr(); 19761 } 19762 break; 19763 case 6: 19764 { 19765 setState(2388); 19766 td(); 19767 } 19768 break; 19769 case 7: 19770 { 19771 setState(2389); 19772 th(); 19773 } 19774 break; 19775 case 8: 19776 { 19777 setState(2390); 19778 body(); 19779 } 19780 break; 19781 case 9: 19782 { 19783 setState(2391); 19784 colgroup(); 19785 } 19786 break; 19787 case 10: 19788 { 19789 setState(2392); 19790 dd(); 19791 } 19792 break; 19793 case 11: 19794 { 19795 setState(2393); 19796 dt(); 19797 } 19798 break; 19799 case 12: 19800 { 19801 setState(2394); 19802 head(); 19803 } 19804 break; 19805 case 13: 19806 { 19807 setState(2395); 19808 html(); 19809 } 19810 break; 19811 case 14: 19812 { 19813 setState(2396); 19814 option(); 19815 } 19816 break; 19817 case 15: 19818 { 19819 setState(2397); 19820 tbody(); 19821 } 19822 break; 19823 case 16: 19824 { 19825 setState(2398); 19826 tfoot(); 19827 } 19828 break; 19829 case 17: 19830 { 19831 setState(2399); 19832 pTagStart(true); 19833 } 19834 break; 19835 case 18: 19836 { 19837 setState(2400); 19838 liTagStart(true); 19839 } 19840 break; 19841 case 19: 19842 { 19843 setState(2401); 19844 trTagStart(true); 19845 } 19846 break; 19847 case 20: 19848 { 19849 setState(2402); 19850 tdTagStart(true); 19851 } 19852 break; 19853 case 21: 19854 { 19855 setState(2403); 19856 thTagStart(true); 19857 } 19858 break; 19859 case 22: 19860 { 19861 setState(2404); 19862 bodyTagStart(true); 19863 } 19864 break; 19865 case 23: 19866 { 19867 setState(2405); 19868 colgroupTagStart(true); 19869 } 19870 break; 19871 case 24: 19872 { 19873 setState(2406); 19874 ddTagStart(true); 19875 } 19876 break; 19877 case 25: 19878 { 19879 setState(2407); 19880 dtTagStart(true); 19881 } 19882 break; 19883 case 26: 19884 { 19885 setState(2408); 19886 headTagStart(true); 19887 } 19888 break; 19889 case 27: 19890 { 19891 setState(2409); 19892 htmlTagStart(true); 19893 } 19894 break; 19895 case 28: 19896 { 19897 setState(2410); 19898 optionTagStart(true); 19899 } 19900 break; 19901 case 29: 19902 { 19903 setState(2411); 19904 tbodyTagStart(true); 19905 } 19906 break; 19907 case 30: 19908 { 19909 setState(2412); 19910 tfootTagStart(true); 19911 } 19912 break; 19913 case 31: 19914 { 19915 { 19916 setState(2413); 19917 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 19918 setState(2414); 19919 match(LEADING_ASTERISK); 19920 } 19921 } 19922 break; 19923 case 32: 19924 { 19925 setState(2415); 19926 htmlComment(); 19927 } 19928 break; 19929 case 33: 19930 { 19931 setState(2416); 19932 match(CDATA); 19933 } 19934 break; 19935 case 34: 19936 { 19937 setState(2417); 19938 match(NEWLINE); 19939 } 19940 break; 19941 case 35: 19942 { 19943 setState(2418); 19944 text(); 19945 } 19946 break; 19947 case 36: 19948 { 19949 setState(2419); 19950 javadocInlineTag(); 19951 } 19952 break; 19953 } 19954 } 19955 } 19956 setState(2424); 19957 _errHandler.sync(this); 19958 _alt = getInterpreter().adaptivePredict(_input,211,_ctx); 19959 } 19960 setState(2425); 19961 rtcTagEnd(); 19962 } 19963 } 19964 catch (RecognitionException re) { 19965 _localctx.exception = re; 19966 _errHandler.reportError(this, re); 19967 _errHandler.recover(this, re); 19968 } 19969 finally { 19970 exitRule(); 19971 } 19972 return _localctx; 19973 } 19974 19975 public static class RpTagStartContext extends ParserRuleContext { 19976 public boolean isNonTight; 19977 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 19978 public TerminalNode RP_HTML_TAG_NAME() { return getToken(JavadocParser.RP_HTML_TAG_NAME, 0); } 19979 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 19980 public List<AttributeContext> attribute() { 19981 return getRuleContexts(AttributeContext.class); 19982 } 19983 public AttributeContext attribute(int i) { 19984 return getRuleContext(AttributeContext.class,i); 19985 } 19986 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 19987 public TerminalNode NEWLINE(int i) { 19988 return getToken(JavadocParser.NEWLINE, i); 19989 } 19990 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 19991 public TerminalNode LEADING_ASTERISK(int i) { 19992 return getToken(JavadocParser.LEADING_ASTERISK, i); 19993 } 19994 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 19995 public TerminalNode WS(int i) { 19996 return getToken(JavadocParser.WS, i); 19997 } 19998 public RpTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 19999 public RpTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 20000 super(parent, invokingState); 20001 this.isNonTight = isNonTight; 20002 } 20003 @Override public int getRuleIndex() { return RULE_rpTagStart; } 20004 } 20005 20006 public final RpTagStartContext rpTagStart(boolean isNonTight) throws RecognitionException { 20007 RpTagStartContext _localctx = new RpTagStartContext(_ctx, getState(), isNonTight); 20008 enterRule(_localctx, 184, RULE_rpTagStart); 20009 int _la; 20010 try { 20011 enterOuterAlt(_localctx, 1); 20012 { 20013 setState(2427); 20014 match(START); 20015 setState(2428); 20016 match(RP_HTML_TAG_NAME); 20017 setState(2435); 20018 _errHandler.sync(this); 20019 _la = _input.LA(1); 20020 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 20021 { 20022 setState(2433); 20023 _errHandler.sync(this); 20024 switch (_input.LA(1)) { 20025 case HTML_TAG_NAME: 20026 { 20027 setState(2429); 20028 attribute(); 20029 } 20030 break; 20031 case NEWLINE: 20032 { 20033 setState(2430); 20034 match(NEWLINE); 20035 } 20036 break; 20037 case LEADING_ASTERISK: 20038 { 20039 setState(2431); 20040 match(LEADING_ASTERISK); 20041 } 20042 break; 20043 case WS: 20044 { 20045 setState(2432); 20046 match(WS); 20047 } 20048 break; 20049 default: 20050 throw new NoViableAltException(this); 20051 } 20052 } 20053 setState(2437); 20054 _errHandler.sync(this); 20055 _la = _input.LA(1); 20056 } 20057 setState(2438); 20058 match(END); 20059 } 20060 _ctx.stop = _input.LT(-1); 20061 20062 if (isNonTight && nonTightTagStartContext == null) { 20063 nonTightTagStartContext = _localctx; 20064 } 20065 20066 } 20067 catch (RecognitionException re) { 20068 _localctx.exception = re; 20069 _errHandler.reportError(this, re); 20070 _errHandler.recover(this, re); 20071 } 20072 finally { 20073 exitRule(); 20074 } 20075 return _localctx; 20076 } 20077 20078 public static class RpTagEndContext extends ParserRuleContext { 20079 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 20080 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 20081 public TerminalNode RP_HTML_TAG_NAME() { return getToken(JavadocParser.RP_HTML_TAG_NAME, 0); } 20082 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 20083 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 20084 public TerminalNode NEWLINE(int i) { 20085 return getToken(JavadocParser.NEWLINE, i); 20086 } 20087 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 20088 public TerminalNode LEADING_ASTERISK(int i) { 20089 return getToken(JavadocParser.LEADING_ASTERISK, i); 20090 } 20091 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 20092 public TerminalNode WS(int i) { 20093 return getToken(JavadocParser.WS, i); 20094 } 20095 public RpTagEndContext(ParserRuleContext parent, int invokingState) { 20096 super(parent, invokingState); 20097 } 20098 @Override public int getRuleIndex() { return RULE_rpTagEnd; } 20099 } 20100 20101 public final RpTagEndContext rpTagEnd() throws RecognitionException { 20102 RpTagEndContext _localctx = new RpTagEndContext(_ctx, getState()); 20103 enterRule(_localctx, 186, RULE_rpTagEnd); 20104 int _la; 20105 try { 20106 enterOuterAlt(_localctx, 1); 20107 { 20108 setState(2440); 20109 match(START); 20110 setState(2441); 20111 match(SLASH); 20112 setState(2442); 20113 match(RP_HTML_TAG_NAME); 20114 setState(2446); 20115 _errHandler.sync(this); 20116 _la = _input.LA(1); 20117 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 20118 { 20119 { 20120 setState(2443); 20121 _la = _input.LA(1); 20122 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 20123 _errHandler.recoverInline(this); 20124 } 20125 else { 20126 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 20127 _errHandler.reportMatch(this); 20128 consume(); 20129 } 20130 } 20131 } 20132 setState(2448); 20133 _errHandler.sync(this); 20134 _la = _input.LA(1); 20135 } 20136 setState(2449); 20137 match(END); 20138 } 20139 } 20140 catch (RecognitionException re) { 20141 _localctx.exception = re; 20142 _errHandler.reportError(this, re); 20143 _errHandler.recover(this, re); 20144 } 20145 finally { 20146 exitRule(); 20147 } 20148 return _localctx; 20149 } 20150 20151 public static class RpContext extends ParserRuleContext { 20152 public RpTagStartContext rpTagStart() { 20153 return getRuleContext(RpTagStartContext.class,0); 20154 } 20155 public RpTagEndContext rpTagEnd() { 20156 return getRuleContext(RpTagEndContext.class,0); 20157 } 20158 public List<HtmlTagContext> htmlTag() { 20159 return getRuleContexts(HtmlTagContext.class); 20160 } 20161 public HtmlTagContext htmlTag(int i) { 20162 return getRuleContext(HtmlTagContext.class,i); 20163 } 20164 public List<SingletonElementContext> singletonElement() { 20165 return getRuleContexts(SingletonElementContext.class); 20166 } 20167 public SingletonElementContext singletonElement(int i) { 20168 return getRuleContext(SingletonElementContext.class,i); 20169 } 20170 public List<ParagraphContext> paragraph() { 20171 return getRuleContexts(ParagraphContext.class); 20172 } 20173 public ParagraphContext paragraph(int i) { 20174 return getRuleContext(ParagraphContext.class,i); 20175 } 20176 public List<LiContext> li() { 20177 return getRuleContexts(LiContext.class); 20178 } 20179 public LiContext li(int i) { 20180 return getRuleContext(LiContext.class,i); 20181 } 20182 public List<TrContext> tr() { 20183 return getRuleContexts(TrContext.class); 20184 } 20185 public TrContext tr(int i) { 20186 return getRuleContext(TrContext.class,i); 20187 } 20188 public List<TdContext> td() { 20189 return getRuleContexts(TdContext.class); 20190 } 20191 public TdContext td(int i) { 20192 return getRuleContext(TdContext.class,i); 20193 } 20194 public List<ThContext> th() { 20195 return getRuleContexts(ThContext.class); 20196 } 20197 public ThContext th(int i) { 20198 return getRuleContext(ThContext.class,i); 20199 } 20200 public List<BodyContext> body() { 20201 return getRuleContexts(BodyContext.class); 20202 } 20203 public BodyContext body(int i) { 20204 return getRuleContext(BodyContext.class,i); 20205 } 20206 public List<ColgroupContext> colgroup() { 20207 return getRuleContexts(ColgroupContext.class); 20208 } 20209 public ColgroupContext colgroup(int i) { 20210 return getRuleContext(ColgroupContext.class,i); 20211 } 20212 public List<DdContext> dd() { 20213 return getRuleContexts(DdContext.class); 20214 } 20215 public DdContext dd(int i) { 20216 return getRuleContext(DdContext.class,i); 20217 } 20218 public List<DtContext> dt() { 20219 return getRuleContexts(DtContext.class); 20220 } 20221 public DtContext dt(int i) { 20222 return getRuleContext(DtContext.class,i); 20223 } 20224 public List<HeadContext> head() { 20225 return getRuleContexts(HeadContext.class); 20226 } 20227 public HeadContext head(int i) { 20228 return getRuleContext(HeadContext.class,i); 20229 } 20230 public List<HtmlContext> html() { 20231 return getRuleContexts(HtmlContext.class); 20232 } 20233 public HtmlContext html(int i) { 20234 return getRuleContext(HtmlContext.class,i); 20235 } 20236 public List<OptionContext> option() { 20237 return getRuleContexts(OptionContext.class); 20238 } 20239 public OptionContext option(int i) { 20240 return getRuleContext(OptionContext.class,i); 20241 } 20242 public List<TbodyContext> tbody() { 20243 return getRuleContexts(TbodyContext.class); 20244 } 20245 public TbodyContext tbody(int i) { 20246 return getRuleContext(TbodyContext.class,i); 20247 } 20248 public List<TfootContext> tfoot() { 20249 return getRuleContexts(TfootContext.class); 20250 } 20251 public TfootContext tfoot(int i) { 20252 return getRuleContext(TfootContext.class,i); 20253 } 20254 public List<PTagStartContext> pTagStart() { 20255 return getRuleContexts(PTagStartContext.class); 20256 } 20257 public PTagStartContext pTagStart(int i) { 20258 return getRuleContext(PTagStartContext.class,i); 20259 } 20260 public List<LiTagStartContext> liTagStart() { 20261 return getRuleContexts(LiTagStartContext.class); 20262 } 20263 public LiTagStartContext liTagStart(int i) { 20264 return getRuleContext(LiTagStartContext.class,i); 20265 } 20266 public List<TrTagStartContext> trTagStart() { 20267 return getRuleContexts(TrTagStartContext.class); 20268 } 20269 public TrTagStartContext trTagStart(int i) { 20270 return getRuleContext(TrTagStartContext.class,i); 20271 } 20272 public List<TdTagStartContext> tdTagStart() { 20273 return getRuleContexts(TdTagStartContext.class); 20274 } 20275 public TdTagStartContext tdTagStart(int i) { 20276 return getRuleContext(TdTagStartContext.class,i); 20277 } 20278 public List<ThTagStartContext> thTagStart() { 20279 return getRuleContexts(ThTagStartContext.class); 20280 } 20281 public ThTagStartContext thTagStart(int i) { 20282 return getRuleContext(ThTagStartContext.class,i); 20283 } 20284 public List<BodyTagStartContext> bodyTagStart() { 20285 return getRuleContexts(BodyTagStartContext.class); 20286 } 20287 public BodyTagStartContext bodyTagStart(int i) { 20288 return getRuleContext(BodyTagStartContext.class,i); 20289 } 20290 public List<ColgroupTagStartContext> colgroupTagStart() { 20291 return getRuleContexts(ColgroupTagStartContext.class); 20292 } 20293 public ColgroupTagStartContext colgroupTagStart(int i) { 20294 return getRuleContext(ColgroupTagStartContext.class,i); 20295 } 20296 public List<DdTagStartContext> ddTagStart() { 20297 return getRuleContexts(DdTagStartContext.class); 20298 } 20299 public DdTagStartContext ddTagStart(int i) { 20300 return getRuleContext(DdTagStartContext.class,i); 20301 } 20302 public List<DtTagStartContext> dtTagStart() { 20303 return getRuleContexts(DtTagStartContext.class); 20304 } 20305 public DtTagStartContext dtTagStart(int i) { 20306 return getRuleContext(DtTagStartContext.class,i); 20307 } 20308 public List<HeadTagStartContext> headTagStart() { 20309 return getRuleContexts(HeadTagStartContext.class); 20310 } 20311 public HeadTagStartContext headTagStart(int i) { 20312 return getRuleContext(HeadTagStartContext.class,i); 20313 } 20314 public List<HtmlTagStartContext> htmlTagStart() { 20315 return getRuleContexts(HtmlTagStartContext.class); 20316 } 20317 public HtmlTagStartContext htmlTagStart(int i) { 20318 return getRuleContext(HtmlTagStartContext.class,i); 20319 } 20320 public List<OptionTagStartContext> optionTagStart() { 20321 return getRuleContexts(OptionTagStartContext.class); 20322 } 20323 public OptionTagStartContext optionTagStart(int i) { 20324 return getRuleContext(OptionTagStartContext.class,i); 20325 } 20326 public List<TbodyTagStartContext> tbodyTagStart() { 20327 return getRuleContexts(TbodyTagStartContext.class); 20328 } 20329 public TbodyTagStartContext tbodyTagStart(int i) { 20330 return getRuleContext(TbodyTagStartContext.class,i); 20331 } 20332 public List<TfootTagStartContext> tfootTagStart() { 20333 return getRuleContexts(TfootTagStartContext.class); 20334 } 20335 public TfootTagStartContext tfootTagStart(int i) { 20336 return getRuleContext(TfootTagStartContext.class,i); 20337 } 20338 public List<HtmlCommentContext> htmlComment() { 20339 return getRuleContexts(HtmlCommentContext.class); 20340 } 20341 public HtmlCommentContext htmlComment(int i) { 20342 return getRuleContext(HtmlCommentContext.class,i); 20343 } 20344 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 20345 public TerminalNode CDATA(int i) { 20346 return getToken(JavadocParser.CDATA, i); 20347 } 20348 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 20349 public TerminalNode NEWLINE(int i) { 20350 return getToken(JavadocParser.NEWLINE, i); 20351 } 20352 public List<TextContext> text() { 20353 return getRuleContexts(TextContext.class); 20354 } 20355 public TextContext text(int i) { 20356 return getRuleContext(TextContext.class,i); 20357 } 20358 public List<JavadocInlineTagContext> javadocInlineTag() { 20359 return getRuleContexts(JavadocInlineTagContext.class); 20360 } 20361 public JavadocInlineTagContext javadocInlineTag(int i) { 20362 return getRuleContext(JavadocInlineTagContext.class,i); 20363 } 20364 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 20365 public TerminalNode LEADING_ASTERISK(int i) { 20366 return getToken(JavadocParser.LEADING_ASTERISK, i); 20367 } 20368 public RpContext(ParserRuleContext parent, int invokingState) { 20369 super(parent, invokingState); 20370 } 20371 @Override public int getRuleIndex() { return RULE_rp; } 20372 } 20373 20374 public final RpContext rp() throws RecognitionException { 20375 RpContext _localctx = new RpContext(_ctx, getState()); 20376 enterRule(_localctx, 188, RULE_rp); 20377 try { 20378 int _alt; 20379 enterOuterAlt(_localctx, 1); 20380 { 20381 setState(2451); 20382 rpTagStart(false); 20383 setState(2491); 20384 _errHandler.sync(this); 20385 _alt = getInterpreter().adaptivePredict(_input,216,_ctx); 20386 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 20387 if ( _alt==1 ) { 20388 { 20389 setState(2489); 20390 _errHandler.sync(this); 20391 switch ( getInterpreter().adaptivePredict(_input,215,_ctx) ) { 20392 case 1: 20393 { 20394 setState(2452); 20395 htmlTag(); 20396 } 20397 break; 20398 case 2: 20399 { 20400 setState(2453); 20401 singletonElement(); 20402 } 20403 break; 20404 case 3: 20405 { 20406 setState(2454); 20407 paragraph(); 20408 } 20409 break; 20410 case 4: 20411 { 20412 setState(2455); 20413 li(); 20414 } 20415 break; 20416 case 5: 20417 { 20418 setState(2456); 20419 tr(); 20420 } 20421 break; 20422 case 6: 20423 { 20424 setState(2457); 20425 td(); 20426 } 20427 break; 20428 case 7: 20429 { 20430 setState(2458); 20431 th(); 20432 } 20433 break; 20434 case 8: 20435 { 20436 setState(2459); 20437 body(); 20438 } 20439 break; 20440 case 9: 20441 { 20442 setState(2460); 20443 colgroup(); 20444 } 20445 break; 20446 case 10: 20447 { 20448 setState(2461); 20449 dd(); 20450 } 20451 break; 20452 case 11: 20453 { 20454 setState(2462); 20455 dt(); 20456 } 20457 break; 20458 case 12: 20459 { 20460 setState(2463); 20461 head(); 20462 } 20463 break; 20464 case 13: 20465 { 20466 setState(2464); 20467 html(); 20468 } 20469 break; 20470 case 14: 20471 { 20472 setState(2465); 20473 option(); 20474 } 20475 break; 20476 case 15: 20477 { 20478 setState(2466); 20479 tbody(); 20480 } 20481 break; 20482 case 16: 20483 { 20484 setState(2467); 20485 tfoot(); 20486 } 20487 break; 20488 case 17: 20489 { 20490 setState(2468); 20491 pTagStart(true); 20492 } 20493 break; 20494 case 18: 20495 { 20496 setState(2469); 20497 liTagStart(true); 20498 } 20499 break; 20500 case 19: 20501 { 20502 setState(2470); 20503 trTagStart(true); 20504 } 20505 break; 20506 case 20: 20507 { 20508 setState(2471); 20509 tdTagStart(true); 20510 } 20511 break; 20512 case 21: 20513 { 20514 setState(2472); 20515 thTagStart(true); 20516 } 20517 break; 20518 case 22: 20519 { 20520 setState(2473); 20521 bodyTagStart(true); 20522 } 20523 break; 20524 case 23: 20525 { 20526 setState(2474); 20527 colgroupTagStart(true); 20528 } 20529 break; 20530 case 24: 20531 { 20532 setState(2475); 20533 ddTagStart(true); 20534 } 20535 break; 20536 case 25: 20537 { 20538 setState(2476); 20539 dtTagStart(true); 20540 } 20541 break; 20542 case 26: 20543 { 20544 setState(2477); 20545 headTagStart(true); 20546 } 20547 break; 20548 case 27: 20549 { 20550 setState(2478); 20551 htmlTagStart(true); 20552 } 20553 break; 20554 case 28: 20555 { 20556 setState(2479); 20557 optionTagStart(true); 20558 } 20559 break; 20560 case 29: 20561 { 20562 setState(2480); 20563 tbodyTagStart(true); 20564 } 20565 break; 20566 case 30: 20567 { 20568 setState(2481); 20569 tfootTagStart(true); 20570 } 20571 break; 20572 case 31: 20573 { 20574 { 20575 setState(2482); 20576 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 20577 setState(2483); 20578 match(LEADING_ASTERISK); 20579 } 20580 } 20581 break; 20582 case 32: 20583 { 20584 setState(2484); 20585 htmlComment(); 20586 } 20587 break; 20588 case 33: 20589 { 20590 setState(2485); 20591 match(CDATA); 20592 } 20593 break; 20594 case 34: 20595 { 20596 setState(2486); 20597 match(NEWLINE); 20598 } 20599 break; 20600 case 35: 20601 { 20602 setState(2487); 20603 text(); 20604 } 20605 break; 20606 case 36: 20607 { 20608 setState(2488); 20609 javadocInlineTag(); 20610 } 20611 break; 20612 } 20613 } 20614 } 20615 setState(2493); 20616 _errHandler.sync(this); 20617 _alt = getInterpreter().adaptivePredict(_input,216,_ctx); 20618 } 20619 setState(2494); 20620 rpTagEnd(); 20621 } 20622 } 20623 catch (RecognitionException re) { 20624 _localctx.exception = re; 20625 _errHandler.reportError(this, re); 20626 _errHandler.recover(this, re); 20627 } 20628 finally { 20629 exitRule(); 20630 } 20631 return _localctx; 20632 } 20633 20634 public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { 20635 switch (ruleIndex) { 20636 case 0: 20637 return javadoc_sempred((JavadocContext)_localctx, predIndex); 20638 case 5: 20639 return htmlTag_sempred((HtmlTagContext)_localctx, predIndex); 20640 case 8: 20641 return paragraph_sempred((ParagraphContext)_localctx, predIndex); 20642 case 11: 20643 return li_sempred((LiContext)_localctx, predIndex); 20644 case 14: 20645 return tr_sempred((TrContext)_localctx, predIndex); 20646 case 17: 20647 return td_sempred((TdContext)_localctx, predIndex); 20648 case 20: 20649 return th_sempred((ThContext)_localctx, predIndex); 20650 case 23: 20651 return body_sempred((BodyContext)_localctx, predIndex); 20652 case 26: 20653 return colgroup_sempred((ColgroupContext)_localctx, predIndex); 20654 case 29: 20655 return dd_sempred((DdContext)_localctx, predIndex); 20656 case 32: 20657 return dt_sempred((DtContext)_localctx, predIndex); 20658 case 35: 20659 return head_sempred((HeadContext)_localctx, predIndex); 20660 case 38: 20661 return html_sempred((HtmlContext)_localctx, predIndex); 20662 case 41: 20663 return option_sempred((OptionContext)_localctx, predIndex); 20664 case 44: 20665 return tbody_sempred((TbodyContext)_localctx, predIndex); 20666 case 47: 20667 return tfoot_sempred((TfootContext)_localctx, predIndex); 20668 case 50: 20669 return thead_sempred((TheadContext)_localctx, predIndex); 20670 case 68: 20671 return description_sempred((DescriptionContext)_localctx, predIndex); 20672 case 71: 20673 return javadocTag_sempred((JavadocTagContext)_localctx, predIndex); 20674 case 82: 20675 return optgroup_sempred((OptgroupContext)_localctx, predIndex); 20676 case 85: 20677 return rb_sempred((RbContext)_localctx, predIndex); 20678 case 88: 20679 return rt_sempred((RtContext)_localctx, predIndex); 20680 case 91: 20681 return rtc_sempred((RtcContext)_localctx, predIndex); 20682 case 94: 20683 return rp_sempred((RpContext)_localctx, predIndex); 20684 } 20685 return true; 20686 } 20687 private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) { 20688 switch (predIndex) { 20689 case 0: 20690 return !isNextJavadocTag(); 20691 } 20692 return true; 20693 } 20694 private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) { 20695 switch (predIndex) { 20696 case 1: 20697 return !isNextJavadocTag(); 20698 case 2: 20699 return isSameTagNames(((HtmlTagContext)_localctx).htmlElementStart, ((HtmlTagContext)_localctx).htmlElementEnd); 20700 } 20701 return true; 20702 } 20703 private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) { 20704 switch (predIndex) { 20705 case 3: 20706 return !isNextJavadocTag(); 20707 } 20708 return true; 20709 } 20710 private boolean li_sempred(LiContext _localctx, int predIndex) { 20711 switch (predIndex) { 20712 case 4: 20713 return !isNextJavadocTag(); 20714 } 20715 return true; 20716 } 20717 private boolean tr_sempred(TrContext _localctx, int predIndex) { 20718 switch (predIndex) { 20719 case 5: 20720 return !isNextJavadocTag(); 20721 } 20722 return true; 20723 } 20724 private boolean td_sempred(TdContext _localctx, int predIndex) { 20725 switch (predIndex) { 20726 case 6: 20727 return !isNextJavadocTag(); 20728 } 20729 return true; 20730 } 20731 private boolean th_sempred(ThContext _localctx, int predIndex) { 20732 switch (predIndex) { 20733 case 7: 20734 return !isNextJavadocTag(); 20735 } 20736 return true; 20737 } 20738 private boolean body_sempred(BodyContext _localctx, int predIndex) { 20739 switch (predIndex) { 20740 case 8: 20741 return !isNextJavadocTag(); 20742 } 20743 return true; 20744 } 20745 private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) { 20746 switch (predIndex) { 20747 case 9: 20748 return !isNextJavadocTag(); 20749 } 20750 return true; 20751 } 20752 private boolean dd_sempred(DdContext _localctx, int predIndex) { 20753 switch (predIndex) { 20754 case 10: 20755 return !isNextJavadocTag(); 20756 } 20757 return true; 20758 } 20759 private boolean dt_sempred(DtContext _localctx, int predIndex) { 20760 switch (predIndex) { 20761 case 11: 20762 return !isNextJavadocTag(); 20763 } 20764 return true; 20765 } 20766 private boolean head_sempred(HeadContext _localctx, int predIndex) { 20767 switch (predIndex) { 20768 case 12: 20769 return !isNextJavadocTag(); 20770 } 20771 return true; 20772 } 20773 private boolean html_sempred(HtmlContext _localctx, int predIndex) { 20774 switch (predIndex) { 20775 case 13: 20776 return !isNextJavadocTag(); 20777 } 20778 return true; 20779 } 20780 private boolean option_sempred(OptionContext _localctx, int predIndex) { 20781 switch (predIndex) { 20782 case 14: 20783 return !isNextJavadocTag(); 20784 } 20785 return true; 20786 } 20787 private boolean tbody_sempred(TbodyContext _localctx, int predIndex) { 20788 switch (predIndex) { 20789 case 15: 20790 return !isNextJavadocTag(); 20791 } 20792 return true; 20793 } 20794 private boolean tfoot_sempred(TfootContext _localctx, int predIndex) { 20795 switch (predIndex) { 20796 case 16: 20797 return !isNextJavadocTag(); 20798 } 20799 return true; 20800 } 20801 private boolean thead_sempred(TheadContext _localctx, int predIndex) { 20802 switch (predIndex) { 20803 case 17: 20804 return !isNextJavadocTag(); 20805 } 20806 return true; 20807 } 20808 private boolean description_sempred(DescriptionContext _localctx, int predIndex) { 20809 switch (predIndex) { 20810 case 18: 20811 return !isNextJavadocTag(); 20812 } 20813 return true; 20814 } 20815 private boolean javadocTag_sempred(JavadocTagContext _localctx, int predIndex) { 20816 switch (predIndex) { 20817 case 19: 20818 return !isNextJavadocTag(); 20819 case 20: 20820 return !isNextJavadocTag(); 20821 case 21: 20822 return !isNextJavadocTag(); 20823 case 22: 20824 return !isNextJavadocTag(); 20825 } 20826 return true; 20827 } 20828 private boolean optgroup_sempred(OptgroupContext _localctx, int predIndex) { 20829 switch (predIndex) { 20830 case 23: 20831 return !isNextJavadocTag(); 20832 } 20833 return true; 20834 } 20835 private boolean rb_sempred(RbContext _localctx, int predIndex) { 20836 switch (predIndex) { 20837 case 24: 20838 return !isNextJavadocTag(); 20839 } 20840 return true; 20841 } 20842 private boolean rt_sempred(RtContext _localctx, int predIndex) { 20843 switch (predIndex) { 20844 case 25: 20845 return !isNextJavadocTag(); 20846 } 20847 return true; 20848 } 20849 private boolean rtc_sempred(RtcContext _localctx, int predIndex) { 20850 switch (predIndex) { 20851 case 26: 20852 return !isNextJavadocTag(); 20853 } 20854 return true; 20855 } 20856 private boolean rp_sempred(RpContext _localctx, int predIndex) { 20857 switch (predIndex) { 20858 case 27: 20859 return !isNextJavadocTag(); 20860 } 20861 return true; 20862 } 20863 20864 private static final int _serializedATNSegments = 2; 20865 private static final String _serializedATNSegment0 = 20866 "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3g\u09c3\4\2\t\2\4"+ 20867 "\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"+ 20868 "\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"+ 20869 "\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"+ 20870 "\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!"+ 20871 "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ 20872 ",\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"+ 20873 "\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="+ 20874 "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ 20875 "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ 20876 "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+ 20877 "`\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"+ 20878 "\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"+ 20879 "\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"+ 20880 "\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"+ 20881 "\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"+ 20882 "\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"+ 20883 "\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"+ 20884 "\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"+ 20885 "\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"+ 20886 "\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"+ 20887 "\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"+ 20888 "\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"+ 20889 "\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"+ 20890 "\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"+ 20891 "\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"+ 20892 "\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"+ 20893 "\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"+ 20894 "\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"+ 20895 "\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"+ 20896 "\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"+ 20897 "\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"+ 20898 "\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"+ 20899 "\13\16\3\16\3\16\3\17\3\17\3\17\3\17\7\17\u020a\n\17\f\17\16\17\u020d"+ 20900 "\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"+ 20901 "\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"+ 20902 "\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"+ 20903 "\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"+ 20904 "\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"+ 20905 "\f\21\16\21\u0251\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0259\n\22"+ 20906 "\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"+ 20907 "\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"+ 20908 "\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"+ 20909 "\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"+ 20910 "\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"+ 20911 "\24\u029d\n\24\f\24\16\24\u02a0\13\24\3\24\3\24\3\25\3\25\3\25\3\25\7"+ 20912 "\25\u02a8\n\25\f\25\16\25\u02ab\13\25\3\25\3\25\3\26\3\26\3\26\3\26\3"+ 20913 "\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"+ 20914 "\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"+ 20915 "\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"+ 20916 "\26\3\26\7\26\u02df\n\26\f\26\16\26\u02e2\13\26\3\26\3\26\3\27\3\27\3"+ 20917 "\27\3\27\3\27\3\27\7\27\u02ec\n\27\f\27\16\27\u02ef\13\27\3\27\3\27\3"+ 20918 "\30\3\30\3\30\3\30\7\30\u02f7\n\30\f\30\16\30\u02fa\13\30\3\30\3\30\3"+ 20919 "\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"+ 20920 "\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"+ 20921 "\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"+ 20922 "\31\3\31\3\31\3\31\3\31\3\31\7\31\u032e\n\31\f\31\16\31\u0331\13\31\3"+ 20923 "\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"+ 20924 "\13\32\3\32\3\32\3\33\3\33\3\33\3\33\7\33\u0346\n\33\f\33\16\33\u0349"+ 20925 "\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"+ 20926 "\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"+ 20927 "\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"+ 20928 "\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"+ 20929 "\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"+ 20930 "\f\35\16\35\u038d\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u0395\n\36"+ 20931 "\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"+ 20932 "\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"+ 20933 "\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"+ 20934 "\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"+ 20935 "\n\37\f\37\16\37\u03cf\13\37\3\37\3\37\3 \3 \3 \3 \3 \3 \7 \u03d9\n \f"+ 20936 " \16 \u03dc\13 \3 \3 \3!\3!\3!\3!\7!\u03e4\n!\f!\16!\u03e7\13!\3!\3!\3"+ 20937 "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+ 20938 "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+ 20939 "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u041b\n\"\f\"\16"+ 20940 "\"\u041e\13\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u0428\n#\f#\16#\u042b\13#\3"+ 20941 "#\3#\3$\3$\3$\3$\7$\u0433\n$\f$\16$\u0436\13$\3$\3$\3%\3%\3%\3%\3%\3%"+ 20942 "\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%"+ 20943 "\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\7%\u046a\n%"+ 20944 "\f%\16%\u046d\13%\3%\3%\3&\3&\3&\3&\3&\3&\7&\u0477\n&\f&\16&\u047a\13"+ 20945 "&\3&\3&\3\'\3\'\3\'\3\'\7\'\u0482\n\'\f\'\16\'\u0485\13\'\3\'\3\'\3(\3"+ 20946 "(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3"+ 20947 "(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3"+ 20948 "(\7(\u04b9\n(\f(\16(\u04bc\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u04c6\n)\f)"+ 20949 "\16)\u04c9\13)\3)\3)\3*\3*\3*\3*\7*\u04d1\n*\f*\16*\u04d4\13*\3*\3*\3"+ 20950 "+\3+\3+\3+\3+\3+\3+\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+\3+\3+\3+\3+\3"+ 20952 "+\3+\7+\u0508\n+\f+\16+\u050b\13+\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0515\n,"+ 20953 "\f,\16,\u0518\13,\3,\3,\3-\3-\3-\3-\7-\u0520\n-\f-\16-\u0523\13-\3-\3"+ 20954 "-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\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.\7.\u0557\n.\f.\16.\u055a\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/\u0564"+ 20957 "\n/\f/\16/\u0567\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u056f\n\60\f\60\16"+ 20958 "\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"+ 20959 "\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"+ 20960 "\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"+ 20961 "\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"+ 20962 "\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"+ 20963 "\n\62\f\62\16\62\u05b6\13\62\3\62\3\62\3\63\3\63\3\63\3\63\7\63\u05be"+ 20964 "\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"+ 20965 "\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"+ 20966 "\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"+ 20967 "\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"+ 20968 "\64\u05f5\n\64\f\64\16\64\u05f8\13\64\3\64\3\64\3\65\3\65\3\65\3\65\3"+ 20969 "\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"+ 20970 "\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"+ 20971 "\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"+ 20972 "\n\67\f\67\16\67\u0628\13\67\3\67\3\67\38\38\38\38\38\38\78\u0632\n8\f"+ 20973 "8\168\u0635\138\38\38\39\39\39\39\39\39\79\u063f\n9\f9\169\u0642\139\3"+ 20974 "9\39\3:\3:\3:\3:\3:\3:\7:\u064c\n:\f:\16:\u064f\13:\3:\3:\3;\3;\3;\3;"+ 20975 "\3;\3;\7;\u0659\n;\f;\16;\u065c\13;\3;\3;\3<\3<\3<\3<\3<\3<\7<\u0666\n"+ 20976 "<\f<\16<\u0669\13<\3<\3<\3=\3=\3=\3=\3=\3=\7=\u0673\n=\f=\16=\u0676\13"+ 20977 "=\3=\3=\3>\3>\3>\3>\3>\3>\7>\u0680\n>\f>\16>\u0683\13>\3>\3>\3?\3?\3?"+ 20978 "\3?\3?\3?\7?\u068d\n?\f?\16?\u0690\13?\3?\3?\3@\3@\3@\3@\3@\3@\7@\u069a"+ 20979 "\n@\f@\16@\u069d\13@\3@\3@\3A\3A\3A\3A\3A\3A\7A\u06a7\nA\fA\16A\u06aa"+ 20980 "\13A\3A\3A\3B\3B\3B\3B\3B\3B\7B\u06b4\nB\fB\16B\u06b7\13B\3B\3B\3C\3C"+ 20981 "\3C\3C\3C\3C\7C\u06c1\nC\fC\16C\u06c4\13C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3"+ 20982 "E\3F\3F\3F\3F\3F\3F\3F\3F\6F\u06d8\nF\rF\16F\u06d9\3G\3G\3G\3G\5G\u06e0"+ 20983 "\nG\5G\u06e2\nG\3G\3G\3G\5G\u06e7\nG\5G\u06e9\nG\3H\3H\7H\u06ed\nH\fH"+ 20984 "\16H\u06f0\13H\3H\3H\3I\3I\6I\u06f6\nI\rI\16I\u06f7\3I\3I\3I\7I\u06fd"+ 20985 "\nI\fI\16I\u0700\13I\3I\3I\5I\u0704\nI\3I\3I\3I\3I\3I\6I\u070b\nI\rI\16"+ 20986 "I\u070c\3I\3I\7I\u0711\nI\fI\16I\u0714\13I\3I\3I\5I\u0718\nI\3I\3I\3I"+ 20987 "\3I\3I\6I\u071f\nI\rI\16I\u0720\3I\3I\7I\u0725\nI\fI\16I\u0728\13I\3I"+ 20988 "\3I\5I\u072c\nI\3I\3I\6I\u0730\nI\rI\16I\u0731\3I\3I\3I\3I\3I\3I\6I\u073a"+ 20989 "\nI\rI\16I\u073b\3I\3I\3I\5I\u0741\nI\3I\7I\u0744\nI\fI\16I\u0747\13I"+ 20990 "\3I\3I\5I\u074b\nI\3I\3I\7I\u074f\nI\fI\16I\u0752\13I\3I\3I\3I\3I\5I\u0758"+ 20991 "\nI\3I\7I\u075b\nI\fI\16I\u075e\13I\3I\3I\7I\u0762\nI\fI\16I\u0765\13"+ 20992 "I\3I\3I\5I\u0769\nI\3I\3I\7I\u076d\nI\fI\16I\u0770\13I\3I\3I\5I\u0774"+ 20993 "\nI\3I\7I\u0777\nI\fI\16I\u077a\13I\3I\3I\5I\u077e\nI\3I\7I\u0781\nI\f"+ 20994 "I\16I\u0784\13I\3I\3I\5I\u0788\nI\3I\3I\6I\u078c\nI\rI\16I\u078d\3I\3"+ 20995 "I\3I\3I\3I\3I\6I\u0796\nI\rI\16I\u0797\3I\3I\7I\u079c\nI\fI\16I\u079f"+ 20996 "\13I\3I\3I\5I\u07a3\nI\3I\3I\6I\u07a7\nI\rI\16I\u07a8\3I\3I\3I\7I\u07ae"+ 20997 "\nI\fI\16I\u07b1\13I\3I\3I\5I\u07b5\nI\5I\u07b7\nI\3J\3J\3J\3J\3J\3J\7"+ 20998 "J\u07bf\nJ\fJ\16J\u07c2\13J\3J\3J\7J\u07c6\nJ\fJ\16J\u07c9\13J\3J\3J\7"+ 20999 "J\u07cd\nJ\fJ\16J\u07d0\13J\3J\3J\6J\u07d4\nJ\rJ\16J\u07d5\3J\3J\7J\u07da"+ 21000 "\nJ\fJ\16J\u07dd\13J\3J\3J\5J\u07e1\nJ\3J\3J\6J\u07e5\nJ\rJ\16J\u07e6"+ 21001 "\3J\3J\7J\u07eb\nJ\fJ\16J\u07ee\13J\3J\3J\5J\u07f2\nJ\3J\3J\3J\3J\3J\7"+ 21002 "J\u07f9\nJ\fJ\16J\u07fc\13J\3J\3J\7J\u0800\nJ\fJ\16J\u0803\13J\3J\3J\5"+ 21003 "J\u0807\nJ\3J\3J\7J\u080b\nJ\fJ\16J\u080e\13J\3J\3J\5J\u0812\nJ\5J\u0814"+ 21004 "\nJ\3J\3J\3K\3K\3K\3K\7K\u081c\nK\fK\16K\u081f\13K\3K\3K\3L\3L\6L\u0825"+ 21005 "\nL\rL\16L\u0826\3M\3M\3M\3M\3M\3M\7M\u082f\nM\fM\16M\u0832\13M\3M\3M"+ 21006 "\3N\3N\3N\3N\3N\3N\7N\u083c\nN\fN\16N\u083f\13N\3N\3N\3O\3O\3O\3O\3O\3"+ 21007 "O\7O\u0849\nO\fO\16O\u084c\13O\3O\3O\3P\3P\3P\3P\3P\3P\7P\u0856\nP\fP"+ 21008 "\16P\u0859\13P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\7Q\u0863\nQ\fQ\16Q\u0866\13Q\3"+ 21009 "Q\3Q\3R\3R\3R\3R\3R\3R\7R\u0870\nR\fR\16R\u0873\13R\3R\3R\3S\3S\3S\3S"+ 21010 "\7S\u087b\nS\fS\16S\u087e\13S\3S\3S\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3"+ 21011 "T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3"+ 21012 "T\3T\3T\3T\7T\u08a8\nT\fT\16T\u08ab\13T\3T\3T\3U\3U\3U\3U\3U\3U\7U\u08b5"+ 21013 "\nU\fU\16U\u08b8\13U\3U\3U\3V\3V\3V\3V\7V\u08c0\nV\fV\16V\u08c3\13V\3"+ 21014 "V\3V\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3"+ 21015 "W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\3W\7W\u08ed\nW\fW\16W\u08f0"+ 21016 "\13W\3W\3W\3X\3X\3X\3X\3X\3X\7X\u08fa\nX\fX\16X\u08fd\13X\3X\3X\3Y\3Y"+ 21017 "\3Y\3Y\7Y\u0905\nY\fY\16Y\u0908\13Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3"+ 21018 "Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3"+ 21019 "Z\3Z\3Z\3Z\3Z\3Z\7Z\u0932\nZ\fZ\16Z\u0935\13Z\3Z\3Z\3[\3[\3[\3[\3[\3["+ 21020 "\7[\u093f\n[\f[\16[\u0942\13[\3[\3[\3\\\3\\\3\\\3\\\7\\\u094a\n\\\f\\"+ 21021 "\16\\\u094d\13\\\3\\\3\\\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]"+ 21022 "\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]\3]"+ 21023 "\7]\u0977\n]\f]\16]\u097a\13]\3]\3]\3^\3^\3^\3^\3^\3^\7^\u0984\n^\f^\16"+ 21024 "^\u0987\13^\3^\3^\3_\3_\3_\3_\7_\u098f\n_\f_\16_\u0992\13_\3_\3_\3`\3"+ 21025 "`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3"+ 21026 "`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\7`\u09bc\n`\f`\16`\u09bf\13`"+ 21027 "\3`\3`\3`\2\2a\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64"+ 21028 "\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088"+ 21029 "\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0"+ 21030 "\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8"+ 21031 "\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"+ 21032 "\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"+ 21033 "\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"+ 21034 "\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"+ 21035 "\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"+ 21036 "\3\2\2\2 \u0247\3\2\2\2\"\u0254\3\2\2\2$\u025f\3\2\2\2&\u0296\3\2\2\2"+ 21037 "(\u02a3\3\2\2\2*\u02ae\3\2\2\2,\u02e5\3\2\2\2.\u02f2\3\2\2\2\60\u02fd"+ 21038 "\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"+ 21039 "\2\2:\u0390\3\2\2\2<\u039b\3\2\2\2>\u03d2\3\2\2\2@\u03df\3\2\2\2B\u03ea"+ 21040 "\3\2\2\2D\u0421\3\2\2\2F\u042e\3\2\2\2H\u0439\3\2\2\2J\u0470\3\2\2\2L"+ 21041 "\u047d\3\2\2\2N\u0488\3\2\2\2P\u04bf\3\2\2\2R\u04cc\3\2\2\2T\u04d7\3\2"+ 21042 "\2\2V\u050e\3\2\2\2X\u051b\3\2\2\2Z\u0526\3\2\2\2\\\u055d\3\2\2\2^\u056a"+ 21043 "\3\2\2\2`\u0575\3\2\2\2b\u05ac\3\2\2\2d\u05b9\3\2\2\2f\u05c4\3\2\2\2h"+ 21044 "\u060f\3\2\2\2j\u0611\3\2\2\2l\u061e\3\2\2\2n\u062b\3\2\2\2p\u0638\3\2"+ 21045 "\2\2r\u0645\3\2\2\2t\u0652\3\2\2\2v\u065f\3\2\2\2x\u066c\3\2\2\2z\u0679"+ 21046 "\3\2\2\2|\u0686\3\2\2\2~\u0693\3\2\2\2\u0080\u06a0\3\2\2\2\u0082\u06ad"+ 21047 "\3\2\2\2\u0084\u06ba\3\2\2\2\u0086\u06c7\3\2\2\2\u0088\u06cd\3\2\2\2\u008a"+ 21048 "\u06d7\3\2\2\2\u008c\u06e8\3\2\2\2\u008e\u06ea\3\2\2\2\u0090\u07b6\3\2"+ 21049 "\2\2\u0092\u07b8\3\2\2\2\u0094\u0817\3\2\2\2\u0096\u0824\3\2\2\2\u0098"+ 21050 "\u0828\3\2\2\2\u009a\u0835\3\2\2\2\u009c\u0842\3\2\2\2\u009e\u084f\3\2"+ 21051 "\2\2\u00a0\u085c\3\2\2\2\u00a2\u0869\3\2\2\2\u00a4\u0876\3\2\2\2\u00a6"+ 21052 "\u0881\3\2\2\2\u00a8\u08ae\3\2\2\2\u00aa\u08bb\3\2\2\2\u00ac\u08c6\3\2"+ 21053 "\2\2\u00ae\u08f3\3\2\2\2\u00b0\u0900\3\2\2\2\u00b2\u090b\3\2\2\2\u00b4"+ 21054 "\u0938\3\2\2\2\u00b6\u0945\3\2\2\2\u00b8\u0950\3\2\2\2\u00ba\u097d\3\2"+ 21055 "\2\2\u00bc\u098a\3\2\2\2\u00be\u0995\3\2\2\2\u00c0\u00c9\5\4\3\2\u00c1"+ 21056 "\u00c2\6\2\2\2\u00c2\u00c9\7\3\2\2\u00c3\u00c9\5\u0094K\2\u00c4\u00c9"+ 21057 "\7\5\2\2\u00c5\u00c9\7\b\2\2\u00c6\u00c9\5\u0096L\2\u00c7\u00c9\5\u0092"+ 21058 "J\2\u00c8\u00c0\3\2\2\2\u00c8\u00c1\3\2\2\2\u00c8\u00c3\3\2\2\2\u00c8"+ 21059 "\u00c4\3\2\2\2\u00c8\u00c5\3\2\2\2\u00c8\u00c6\3\2\2\2\u00c8\u00c7\3\2"+ 21060 "\2\2\u00c9\u00cc\3\2\2\2\u00ca\u00c8\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb"+ 21061 "\u00d9\3\2\2\2\u00cc\u00ca\3\2\2\2\u00cd\u00cf\7\3\2\2\u00ce\u00cd\3\2"+ 21062 "\2\2\u00ce\u00cf\3\2\2\2\u00cf\u00d3\3\2\2\2\u00d0\u00d2\7\6\2\2\u00d1"+ 21063 "\u00d0\3\2\2\2\u00d2\u00d5\3\2\2\2\u00d3\u00d1\3\2\2\2\u00d3\u00d4\3\2"+ 21064 "\2\2\u00d4\u00d6\3\2\2\2\u00d5\u00d3\3\2\2\2\u00d6\u00d8\5\u0090I\2\u00d7"+ 21065 "\u00ce\3\2\2\2\u00d8\u00db\3\2\2\2\u00d9\u00d7\3\2\2\2\u00d9\u00da\3\2"+ 21066 "\2\2\u00da\u00dc\3\2\2\2\u00db\u00d9\3\2\2\2\u00dc\u00dd\7\2\2\3\u00dd"+ 21067 "\3\3\2\2\2\u00de\u011d\5\f\7\2\u00df\u011d\5h\65\2\u00e0\u011d\5\22\n"+ 21068 "\2\u00e1\u011d\5\30\r\2\u00e2\u011d\5\36\20\2\u00e3\u011d\5$\23\2\u00e4"+ 21069 "\u011d\5*\26\2\u00e5\u011d\5\60\31\2\u00e6\u011d\5\66\34\2\u00e7\u011d"+ 21070 "\5<\37\2\u00e8\u011d\5B\"\2\u00e9\u011d\5H%\2\u00ea\u011d\5N(\2\u00eb"+ 21071 "\u011d\5T+\2\u00ec\u011d\5Z.\2\u00ed\u011d\5f\64\2\u00ee\u011d\5`\61\2"+ 21072 "\u00ef\u011d\5\u00a6T\2\u00f0\u011d\5\u00acW\2\u00f1\u011d\5\u00b2Z\2"+ 21073 "\u00f2\u011d\5\u00b8]\2\u00f3\u011d\5\u00be`\2\u00f4\u011d\5\16\b\2\u00f5"+ 21074 "\u011d\5\24\13\2\u00f6\u011d\5\32\16\2\u00f7\u011d\5 \21\2\u00f8\u011d"+ 21075 "\5&\24\2\u00f9\u011d\5,\27\2\u00fa\u011d\5\62\32\2\u00fb\u011d\58\35\2"+ 21076 "\u00fc\u011d\5> \2\u00fd\u011d\5D#\2\u00fe\u011d\5J&\2\u00ff\u011d\5P"+ 21077 ")\2\u0100\u011d\5V,\2\u0101\u011d\5b\62\2\u0102\u011d\5\\/\2\u0103\u011d"+ 21078 "\5\u00a2R\2\u0104\u011d\5\u00a8U\2\u0105\u011d\5\u00aeX\2\u0106\u011d"+ 21079 "\5\u00b4[\2\u0107\u011d\5\u00ba^\2\u0108\u011d\5\20\t\2\u0109\u011d\5"+ 21080 "\26\f\2\u010a\u011d\5\34\17\2\u010b\u011d\5\"\22\2\u010c\u011d\5(\25\2"+ 21081 "\u010d\u011d\5.\30\2\u010e\u011d\5\64\33\2\u010f\u011d\5:\36\2\u0110\u011d"+ 21082 "\5@!\2\u0111\u011d\5F$\2\u0112\u011d\5L\'\2\u0113\u011d\5R*\2\u0114\u011d"+ 21083 "\5X-\2\u0115\u011d\5d\63\2\u0116\u011d\5^\60\2\u0117\u011d\5\u00a4S\2"+ 21084 "\u0118\u011d\5\u00aaV\2\u0119\u011d\5\u00b0Y\2\u011a\u011d\5\u00b6\\\2"+ 21085 "\u011b\u011d\5\u00bc_\2\u011c\u00de\3\2\2\2\u011c\u00df\3\2\2\2\u011c"+ 21086 "\u00e0\3\2\2\2\u011c\u00e1\3\2\2\2\u011c\u00e2\3\2\2\2\u011c\u00e3\3\2"+ 21087 "\2\2\u011c\u00e4\3\2\2\2\u011c\u00e5\3\2\2\2\u011c\u00e6\3\2\2\2\u011c"+ 21088 "\u00e7\3\2\2\2\u011c\u00e8\3\2\2\2\u011c\u00e9\3\2\2\2\u011c\u00ea\3\2"+ 21089 "\2\2\u011c\u00eb\3\2\2\2\u011c\u00ec\3\2\2\2\u011c\u00ed\3\2\2\2\u011c"+ 21090 "\u00ee\3\2\2\2\u011c\u00ef\3\2\2\2\u011c\u00f0\3\2\2\2\u011c\u00f1\3\2"+ 21091 "\2\2\u011c\u00f2\3\2\2\2\u011c\u00f3\3\2\2\2\u011c\u00f4\3\2\2\2\u011c"+ 21092 "\u00f5\3\2\2\2\u011c\u00f6\3\2\2\2\u011c\u00f7\3\2\2\2\u011c\u00f8\3\2"+ 21093 "\2\2\u011c\u00f9\3\2\2\2\u011c\u00fa\3\2\2\2\u011c\u00fb\3\2\2\2\u011c"+ 21094 "\u00fc\3\2\2\2\u011c\u00fd\3\2\2\2\u011c\u00fe\3\2\2\2\u011c\u00ff\3\2"+ 21095 "\2\2\u011c\u0100\3\2\2\2\u011c\u0101\3\2\2\2\u011c\u0102\3\2\2\2\u011c"+ 21096 "\u0103\3\2\2\2\u011c\u0104\3\2\2\2\u011c\u0105\3\2\2\2\u011c\u0106\3\2"+ 21097 "\2\2\u011c\u0107\3\2\2\2\u011c\u0108\3\2\2\2\u011c\u0109\3\2\2\2\u011c"+ 21098 "\u010a\3\2\2\2\u011c\u010b\3\2\2\2\u011c\u010c\3\2\2\2\u011c\u010d\3\2"+ 21099 "\2\2\u011c\u010e\3\2\2\2\u011c\u010f\3\2\2\2\u011c\u0110\3\2\2\2\u011c"+ 21100 "\u0111\3\2\2\2\u011c\u0112\3\2\2\2\u011c\u0113\3\2\2\2\u011c\u0114\3\2"+ 21101 "\2\2\u011c\u0115\3\2\2\2\u011c\u0116\3\2\2\2\u011c\u0117\3\2\2\2\u011c"+ 21102 "\u0118\3\2\2\2\u011c\u0119\3\2\2\2\u011c\u011a\3\2\2\2\u011c\u011b\3\2"+ 21103 "\2\2\u011d\5\3\2\2\2\u011e\u011f\7\7\2\2\u011f\u0126\7f\2\2\u0120\u0125"+ 21104 "\5\n\6\2\u0121\u0125\7\b\2\2\u0122\u0125\7\3\2\2\u0123\u0125\7\6\2\2\u0124"+ 21105 "\u0120\3\2\2\2\u0124\u0121\3\2\2\2\u0124\u0122\3\2\2\2\u0124\u0123\3\2"+ 21106 "\2\2\u0125\u0128\3\2\2\2\u0126\u0124\3\2\2\2\u0126\u0127\3\2\2\2\u0127"+ 21107 "\u0129\3\2\2\2\u0128\u0126\3\2\2\2\u0129\u012a\79\2\2\u012a\7\3\2\2\2"+ 21108 "\u012b\u012c\7\7\2\2\u012c\u012d\7;\2\2\u012d\u0131\7f\2\2\u012e\u0130"+ 21109 "\t\2\2\2\u012f\u012e\3\2\2\2\u0130\u0133\3\2\2\2\u0131\u012f\3\2\2\2\u0131"+ 21110 "\u0132\3\2\2\2\u0132\u0134\3\2\2\2\u0133\u0131\3\2\2\2\u0134\u0135\79"+ 21111 "\2\2\u0135\t\3\2\2\2\u0136\u013a\7f\2\2\u0137\u0139\t\2\2\2\u0138\u0137"+ 21112 "\3\2\2\2\u0139\u013c\3\2\2\2\u013a\u0138\3\2\2\2\u013a\u013b\3\2\2\2\u013b"+ 21113 "\u013d\3\2\2\2\u013c\u013a\3\2\2\2\u013d\u0141\7<\2\2\u013e\u0140\t\2"+ 21114 "\2\2\u013f\u013e\3\2\2\2\u0140\u0143\3\2\2\2\u0141\u013f\3\2\2\2\u0141"+ 21115 "\u0142\3\2\2\2\u0142\u0147\3\2\2\2\u0143\u0141\3\2\2\2\u0144\u0148\7["+ 21116 "\2\2\u0145\u0148\5\u0096L\2\u0146\u0148\7f\2\2\u0147\u0144\3\2\2\2\u0147"+ 21117 "\u0145\3\2\2\2\u0147\u0146\3\2\2\2\u0148\13\3\2\2\2\u0149\u0154\5\6\4"+ 21118 "\2\u014a\u0153\5\4\3\2\u014b\u014c\6\7\3\2\u014c\u0153\7\3\2\2\u014d\u0153"+ 21119 "\5\u0094K\2\u014e\u0153\7\5\2\2\u014f\u0153\7\b\2\2\u0150\u0153\5\u0096"+ 21120 "L\2\u0151\u0153\5\u0092J\2\u0152\u014a\3\2\2\2\u0152\u014b\3\2\2\2\u0152"+ 21121 "\u014d\3\2\2\2\u0152\u014e\3\2\2\2\u0152\u014f\3\2\2\2\u0152\u0150\3\2"+ 21122 "\2\2\u0152\u0151\3\2\2\2\u0153\u0156\3\2\2\2\u0154\u0152\3\2\2\2\u0154"+ 21123 "\u0155\3\2\2\2\u0155\u0157\3\2\2\2\u0156\u0154\3\2\2\2\u0157\u0158\5\b"+ 21124 "\5\2\u0158\u0159\6\7\4\3\u0159\r\3\2\2\2\u015a\u015b\7\7\2\2\u015b\u0162"+ 21125 "\7=\2\2\u015c\u0161\5\n\6\2\u015d\u0161\7\b\2\2\u015e\u0161\7\3\2\2\u015f"+ 21126 "\u0161\7\6\2\2\u0160\u015c\3\2\2\2\u0160\u015d\3\2\2\2\u0160\u015e\3\2"+ 21127 "\2\2\u0160\u015f\3\2\2\2\u0161\u0164\3\2\2\2\u0162\u0160\3\2\2\2\u0162"+ 21128 "\u0163\3\2\2\2\u0163\u0165\3\2\2\2\u0164\u0162\3\2\2\2\u0165\u0166\79"+ 21129 "\2\2\u0166\17\3\2\2\2\u0167\u0168\7\7\2\2\u0168\u0169\7;\2\2\u0169\u016d"+ 21130 "\7=\2\2\u016a\u016c\t\2\2\2\u016b\u016a\3\2\2\2\u016c\u016f\3\2\2\2\u016d"+ 21131 "\u016b\3\2\2\2\u016d\u016e\3\2\2\2\u016e\u0170\3\2\2\2\u016f\u016d\3\2"+ 21132 "\2\2\u0170\u0171\79\2\2\u0171\21\3\2\2\2\u0172\u01a4\5\16\b\2\u0173\u01a3"+ 21133 "\5\f\7\2\u0174\u01a3\5h\65\2\u0175\u01a3\5\30\r\2\u0176\u01a3\5\36\20"+ 21134 "\2\u0177\u01a3\5$\23\2\u0178\u01a3\5*\26\2\u0179\u01a3\5\60\31\2\u017a"+ 21135 "\u01a3\5\66\34\2\u017b\u01a3\5<\37\2\u017c\u01a3\5B\"\2\u017d\u01a3\5"+ 21136 "H%\2\u017e\u01a3\5N(\2\u017f\u01a3\5T+\2\u0180\u01a3\5Z.\2\u0181\u01a3"+ 21137 "\5f\64\2\u0182\u01a3\5`\61\2\u0183\u01a3\5\u00a6T\2\u0184\u01a3\5\u00ac"+ 21138 "W\2\u0185\u01a3\5\u00b2Z\2\u0186\u01a3\5\u00b8]\2\u0187\u01a3\5\u00be"+ 21139 "`\2\u0188\u01a3\5\24\13\2\u0189\u01a3\5\32\16\2\u018a\u01a3\5 \21\2\u018b"+ 21140 "\u01a3\5&\24\2\u018c\u01a3\5,\27\2\u018d\u01a3\5\62\32\2\u018e\u01a3\5"+ 21141 "8\35\2\u018f\u01a3\5> \2\u0190\u01a3\5D#\2\u0191\u01a3\5J&\2\u0192\u01a3"+ 21142 "\5P)\2\u0193\u01a3\5V,\2\u0194\u01a3\5b\62\2\u0195\u01a3\5\\/\2\u0196"+ 21143 "\u01a3\5\u00a2R\2\u0197\u01a3\5\u00a8U\2\u0198\u01a3\5\u00aeX\2\u0199"+ 21144 "\u01a3\5\u00b4[\2\u019a\u01a3\5\u00ba^\2\u019b\u019c\6\n\5\2\u019c\u01a3"+ 21145 "\7\3\2\2\u019d\u01a3\5\u0094K\2\u019e\u01a3\7\5\2\2\u019f\u01a3\7\b\2"+ 21146 "\2\u01a0\u01a3\5\u0096L\2\u01a1\u01a3\5\u0092J\2\u01a2\u0173\3\2\2\2\u01a2"+ 21147 "\u0174\3\2\2\2\u01a2\u0175\3\2\2\2\u01a2\u0176\3\2\2\2\u01a2\u0177\3\2"+ 21148 "\2\2\u01a2\u0178\3\2\2\2\u01a2\u0179\3\2\2\2\u01a2\u017a\3\2\2\2\u01a2"+ 21149 "\u017b\3\2\2\2\u01a2\u017c\3\2\2\2\u01a2\u017d\3\2\2\2\u01a2\u017e\3\2"+ 21150 "\2\2\u01a2\u017f\3\2\2\2\u01a2\u0180\3\2\2\2\u01a2\u0181\3\2\2\2\u01a2"+ 21151 "\u0182\3\2\2\2\u01a2\u0183\3\2\2\2\u01a2\u0184\3\2\2\2\u01a2\u0185\3\2"+ 21152 "\2\2\u01a2\u0186\3\2\2\2\u01a2\u0187\3\2\2\2\u01a2\u0188\3\2\2\2\u01a2"+ 21153 "\u0189\3\2\2\2\u01a2\u018a\3\2\2\2\u01a2\u018b\3\2\2\2\u01a2\u018c\3\2"+ 21154 "\2\2\u01a2\u018d\3\2\2\2\u01a2\u018e\3\2\2\2\u01a2\u018f\3\2\2\2\u01a2"+ 21155 "\u0190\3\2\2\2\u01a2\u0191\3\2\2\2\u01a2\u0192\3\2\2\2\u01a2\u0193\3\2"+ 21156 "\2\2\u01a2\u0194\3\2\2\2\u01a2\u0195\3\2\2\2\u01a2\u0196\3\2\2\2\u01a2"+ 21157 "\u0197\3\2\2\2\u01a2\u0198\3\2\2\2\u01a2\u0199\3\2\2\2\u01a2\u019a\3\2"+ 21158 "\2\2\u01a2\u019b\3\2\2\2\u01a2\u019d\3\2\2\2\u01a2\u019e\3\2\2\2\u01a2"+ 21159 "\u019f\3\2\2\2\u01a2\u01a0\3\2\2\2\u01a2\u01a1\3\2\2\2\u01a3\u01a6\3\2"+ 21160 "\2\2\u01a4\u01a2\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5\u01a7\3\2\2\2\u01a6"+ 21161 "\u01a4\3\2\2\2\u01a7\u01a8\5\20\t\2\u01a8\23\3\2\2\2\u01a9\u01aa\7\7\2"+ 21162 "\2\u01aa\u01b1\7>\2\2\u01ab\u01b0\5\n\6\2\u01ac\u01b0\7\b\2\2\u01ad\u01b0"+ 21163 "\7\3\2\2\u01ae\u01b0\7\6\2\2\u01af\u01ab\3\2\2\2\u01af\u01ac\3\2\2\2\u01af"+ 21164 "\u01ad\3\2\2\2\u01af\u01ae\3\2\2\2\u01b0\u01b3\3\2\2\2\u01b1\u01af\3\2"+ 21165 "\2\2\u01b1\u01b2\3\2\2\2\u01b2\u01b4\3\2\2\2\u01b3\u01b1\3\2\2\2\u01b4"+ 21166 "\u01b5\79\2\2\u01b5\25\3\2\2\2\u01b6\u01b7\7\7\2\2\u01b7\u01b8\7;\2\2"+ 21167 "\u01b8\u01bc\7>\2\2\u01b9\u01bb\t\2\2\2\u01ba\u01b9\3\2\2\2\u01bb\u01be"+ 21168 "\3\2\2\2\u01bc\u01ba\3\2\2\2\u01bc\u01bd\3\2\2\2\u01bd\u01bf\3\2\2\2\u01be"+ 21169 "\u01bc\3\2\2\2\u01bf\u01c0\79\2\2\u01c0\27\3\2\2\2\u01c1\u01f3\5\24\13"+ 21170 "\2\u01c2\u01f2\5\f\7\2\u01c3\u01f2\5h\65\2\u01c4\u01f2\5\22\n\2\u01c5"+ 21171 "\u01f2\5\36\20\2\u01c6\u01f2\5$\23\2\u01c7\u01f2\5*\26\2\u01c8\u01f2\5"+ 21172 "\60\31\2\u01c9\u01f2\5\66\34\2\u01ca\u01f2\5<\37\2\u01cb\u01f2\5B\"\2"+ 21173 "\u01cc\u01f2\5H%\2\u01cd\u01f2\5N(\2\u01ce\u01f2\5T+\2\u01cf\u01f2\5Z"+ 21174 ".\2\u01d0\u01f2\5f\64\2\u01d1\u01f2\5`\61\2\u01d2\u01f2\5\u00a6T\2\u01d3"+ 21175 "\u01f2\5\u00acW\2\u01d4\u01f2\5\u00b2Z\2\u01d5\u01f2\5\u00b8]\2\u01d6"+ 21176 "\u01f2\5\u00be`\2\u01d7\u01f2\5\16\b\2\u01d8\u01f2\5\32\16\2\u01d9\u01f2"+ 21177 "\5 \21\2\u01da\u01f2\5&\24\2\u01db\u01f2\5,\27\2\u01dc\u01f2\5\62\32\2"+ 21178 "\u01dd\u01f2\58\35\2\u01de\u01f2\5> \2\u01df\u01f2\5D#\2\u01e0\u01f2\5"+ 21179 "J&\2\u01e1\u01f2\5P)\2\u01e2\u01f2\5V,\2\u01e3\u01f2\5b\62\2\u01e4\u01f2"+ 21180 "\5\\/\2\u01e5\u01f2\5\u00a2R\2\u01e6\u01f2\5\u00a8U\2\u01e7\u01f2\5\u00ae"+ 21181 "X\2\u01e8\u01f2\5\u00b4[\2\u01e9\u01f2\5\u00ba^\2\u01ea\u01eb\6\r\6\2"+ 21182 "\u01eb\u01f2\7\3\2\2\u01ec\u01f2\5\u0094K\2\u01ed\u01f2\7\5\2\2\u01ee"+ 21183 "\u01f2\7\b\2\2\u01ef\u01f2\5\u0096L\2\u01f0\u01f2\5\u0092J\2\u01f1\u01c2"+ 21184 "\3\2\2\2\u01f1\u01c3\3\2\2\2\u01f1\u01c4\3\2\2\2\u01f1\u01c5\3\2\2\2\u01f1"+ 21185 "\u01c6\3\2\2\2\u01f1\u01c7\3\2\2\2\u01f1\u01c8\3\2\2\2\u01f1\u01c9\3\2"+ 21186 "\2\2\u01f1\u01ca\3\2\2\2\u01f1\u01cb\3\2\2\2\u01f1\u01cc\3\2\2\2\u01f1"+ 21187 "\u01cd\3\2\2\2\u01f1\u01ce\3\2\2\2\u01f1\u01cf\3\2\2\2\u01f1\u01d0\3\2"+ 21188 "\2\2\u01f1\u01d1\3\2\2\2\u01f1\u01d2\3\2\2\2\u01f1\u01d3\3\2\2\2\u01f1"+ 21189 "\u01d4\3\2\2\2\u01f1\u01d5\3\2\2\2\u01f1\u01d6\3\2\2\2\u01f1\u01d7\3\2"+ 21190 "\2\2\u01f1\u01d8\3\2\2\2\u01f1\u01d9\3\2\2\2\u01f1\u01da\3\2\2\2\u01f1"+ 21191 "\u01db\3\2\2\2\u01f1\u01dc\3\2\2\2\u01f1\u01dd\3\2\2\2\u01f1\u01de\3\2"+ 21192 "\2\2\u01f1\u01df\3\2\2\2\u01f1\u01e0\3\2\2\2\u01f1\u01e1\3\2\2\2\u01f1"+ 21193 "\u01e2\3\2\2\2\u01f1\u01e3\3\2\2\2\u01f1\u01e4\3\2\2\2\u01f1\u01e5\3\2"+ 21194 "\2\2\u01f1\u01e6\3\2\2\2\u01f1\u01e7\3\2\2\2\u01f1\u01e8\3\2\2\2\u01f1"+ 21195 "\u01e9\3\2\2\2\u01f1\u01ea\3\2\2\2\u01f1\u01ec\3\2\2\2\u01f1\u01ed\3\2"+ 21196 "\2\2\u01f1\u01ee\3\2\2\2\u01f1\u01ef\3\2\2\2\u01f1\u01f0\3\2\2\2\u01f2"+ 21197 "\u01f5\3\2\2\2\u01f3\u01f1\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4\u01f6\3\2"+ 21198 "\2\2\u01f5\u01f3\3\2\2\2\u01f6\u01f7\5\26\f\2\u01f7\31\3\2\2\2\u01f8\u01f9"+ 21199 "\7\7\2\2\u01f9\u0200\7?\2\2\u01fa\u01ff\5\n\6\2\u01fb\u01ff\7\b\2\2\u01fc"+ 21200 "\u01ff\7\3\2\2\u01fd\u01ff\7\6\2\2\u01fe\u01fa\3\2\2\2\u01fe\u01fb\3\2"+ 21201 "\2\2\u01fe\u01fc\3\2\2\2\u01fe\u01fd\3\2\2\2\u01ff\u0202\3\2\2\2\u0200"+ 21202 "\u01fe\3\2\2\2\u0200\u0201\3\2\2\2\u0201\u0203\3\2\2\2\u0202\u0200\3\2"+ 21203 "\2\2\u0203\u0204\79\2\2\u0204\33\3\2\2\2\u0205\u0206\7\7\2\2\u0206\u0207"+ 21204 "\7;\2\2\u0207\u020b\7?\2\2\u0208\u020a\t\2\2\2\u0209\u0208\3\2\2\2\u020a"+ 21205 "\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2\2\2\u020c\u020e\3\2"+ 21206 "\2\2\u020d\u020b\3\2\2\2\u020e\u020f\79\2\2\u020f\35\3\2\2\2\u0210\u0242"+ 21207 "\5\32\16\2\u0211\u0241\5\f\7\2\u0212\u0241\5h\65\2\u0213\u0241\5\22\n"+ 21208 "\2\u0214\u0241\5\30\r\2\u0215\u0241\5$\23\2\u0216\u0241\5*\26\2\u0217"+ 21209 "\u0241\5\60\31\2\u0218\u0241\5\66\34\2\u0219\u0241\5<\37\2\u021a\u0241"+ 21210 "\5B\"\2\u021b\u0241\5H%\2\u021c\u0241\5N(\2\u021d\u0241\5T+\2\u021e\u0241"+ 21211 "\5Z.\2\u021f\u0241\5f\64\2\u0220\u0241\5`\61\2\u0221\u0241\5\u00a6T\2"+ 21212 "\u0222\u0241\5\u00acW\2\u0223\u0241\5\u00b2Z\2\u0224\u0241\5\u00b8]\2"+ 21213 "\u0225\u0241\5\u00be`\2\u0226\u0241\5\16\b\2\u0227\u0241\5\24\13\2\u0228"+ 21214 "\u0241\5 \21\2\u0229\u0241\5&\24\2\u022a\u0241\5,\27\2\u022b\u0241\5\62"+ 21215 "\32\2\u022c\u0241\58\35\2\u022d\u0241\5> \2\u022e\u0241\5D#\2\u022f\u0241"+ 21216 "\5J&\2\u0230\u0241\5P)\2\u0231\u0241\5V,\2\u0232\u0241\5b\62\2\u0233\u0241"+ 21217 "\5\\/\2\u0234\u0241\5\u00a2R\2\u0235\u0241\5\u00a8U\2\u0236\u0241\5\u00ae"+ 21218 "X\2\u0237\u0241\5\u00b4[\2\u0238\u0241\5\u00ba^\2\u0239\u023a\6\20\7\2"+ 21219 "\u023a\u0241\7\3\2\2\u023b\u0241\5\u0094K\2\u023c\u0241\7\5\2\2\u023d"+ 21220 "\u0241\7\b\2\2\u023e\u0241\5\u0096L\2\u023f\u0241\5\u0092J\2\u0240\u0211"+ 21221 "\3\2\2\2\u0240\u0212\3\2\2\2\u0240\u0213\3\2\2\2\u0240\u0214\3\2\2\2\u0240"+ 21222 "\u0215\3\2\2\2\u0240\u0216\3\2\2\2\u0240\u0217\3\2\2\2\u0240\u0218\3\2"+ 21223 "\2\2\u0240\u0219\3\2\2\2\u0240\u021a\3\2\2\2\u0240\u021b\3\2\2\2\u0240"+ 21224 "\u021c\3\2\2\2\u0240\u021d\3\2\2\2\u0240\u021e\3\2\2\2\u0240\u021f\3\2"+ 21225 "\2\2\u0240\u0220\3\2\2\2\u0240\u0221\3\2\2\2\u0240\u0222\3\2\2\2\u0240"+ 21226 "\u0223\3\2\2\2\u0240\u0224\3\2\2\2\u0240\u0225\3\2\2\2\u0240\u0226\3\2"+ 21227 "\2\2\u0240\u0227\3\2\2\2\u0240\u0228\3\2\2\2\u0240\u0229\3\2\2\2\u0240"+ 21228 "\u022a\3\2\2\2\u0240\u022b\3\2\2\2\u0240\u022c\3\2\2\2\u0240\u022d\3\2"+ 21229 "\2\2\u0240\u022e\3\2\2\2\u0240\u022f\3\2\2\2\u0240\u0230\3\2\2\2\u0240"+ 21230 "\u0231\3\2\2\2\u0240\u0232\3\2\2\2\u0240\u0233\3\2\2\2\u0240\u0234\3\2"+ 21231 "\2\2\u0240\u0235\3\2\2\2\u0240\u0236\3\2\2\2\u0240\u0237\3\2\2\2\u0240"+ 21232 "\u0238\3\2\2\2\u0240\u0239\3\2\2\2\u0240\u023b\3\2\2\2\u0240\u023c\3\2"+ 21233 "\2\2\u0240\u023d\3\2\2\2\u0240\u023e\3\2\2\2\u0240\u023f\3\2\2\2\u0241"+ 21234 "\u0244\3\2\2\2\u0242\u0240\3\2\2\2\u0242\u0243\3\2\2\2\u0243\u0245\3\2"+ 21235 "\2\2\u0244\u0242\3\2\2\2\u0245\u0246\5\34\17\2\u0246\37\3\2\2\2\u0247"+ 21236 "\u0248\7\7\2\2\u0248\u024f\7@\2\2\u0249\u024e\5\n\6\2\u024a\u024e\7\b"+ 21237 "\2\2\u024b\u024e\7\3\2\2\u024c\u024e\7\6\2\2\u024d\u0249\3\2\2\2\u024d"+ 21238 "\u024a\3\2\2\2\u024d\u024b\3\2\2\2\u024d\u024c\3\2\2\2\u024e\u0251\3\2"+ 21239 "\2\2\u024f\u024d\3\2\2\2\u024f\u0250\3\2\2\2\u0250\u0252\3\2\2\2\u0251"+ 21240 "\u024f\3\2\2\2\u0252\u0253\79\2\2\u0253!\3\2\2\2\u0254\u0255\7\7\2\2\u0255"+ 21241 "\u0256\7;\2\2\u0256\u025a\7@\2\2\u0257\u0259\t\2\2\2\u0258\u0257\3\2\2"+ 21242 "\2\u0259\u025c\3\2\2\2\u025a\u0258\3\2\2\2\u025a\u025b\3\2\2\2\u025b\u025d"+ 21243 "\3\2\2\2\u025c\u025a\3\2\2\2\u025d\u025e\79\2\2\u025e#\3\2\2\2\u025f\u0291"+ 21244 "\5 \21\2\u0260\u0290\5\f\7\2\u0261\u0290\5h\65\2\u0262\u0290\5\22\n\2"+ 21245 "\u0263\u0290\5\30\r\2\u0264\u0290\5\36\20\2\u0265\u0290\5*\26\2\u0266"+ 21246 "\u0290\5\60\31\2\u0267\u0290\5\66\34\2\u0268\u0290\5<\37\2\u0269\u0290"+ 21247 "\5B\"\2\u026a\u0290\5H%\2\u026b\u0290\5N(\2\u026c\u0290\5T+\2\u026d\u0290"+ 21248 "\5Z.\2\u026e\u0290\5f\64\2\u026f\u0290\5`\61\2\u0270\u0290\5\u00a6T\2"+ 21249 "\u0271\u0290\5\u00acW\2\u0272\u0290\5\u00b2Z\2\u0273\u0290\5\u00b8]\2"+ 21250 "\u0274\u0290\5\u00be`\2\u0275\u0290\5\16\b\2\u0276\u0290\5\24\13\2\u0277"+ 21251 "\u0290\5 \21\2\u0278\u0290\5&\24\2\u0279\u0290\5,\27\2\u027a\u0290\5\62"+ 21252 "\32\2\u027b\u0290\58\35\2\u027c\u0290\5> \2\u027d\u0290\5D#\2\u027e\u0290"+ 21253 "\5J&\2\u027f\u0290\5P)\2\u0280\u0290\5V,\2\u0281\u0290\5b\62\2\u0282\u0290"+ 21254 "\5\\/\2\u0283\u0290\5\u00a2R\2\u0284\u0290\5\u00a8U\2\u0285\u0290\5\u00ae"+ 21255 "X\2\u0286\u0290\5\u00b4[\2\u0287\u0290\5\u00ba^\2\u0288\u0289\6\23\b\2"+ 21256 "\u0289\u0290\7\3\2\2\u028a\u0290\5\u0094K\2\u028b\u0290\7\5\2\2\u028c"+ 21257 "\u0290\7\b\2\2\u028d\u0290\5\u0096L\2\u028e\u0290\5\u0092J\2\u028f\u0260"+ 21258 "\3\2\2\2\u028f\u0261\3\2\2\2\u028f\u0262\3\2\2\2\u028f\u0263\3\2\2\2\u028f"+ 21259 "\u0264\3\2\2\2\u028f\u0265\3\2\2\2\u028f\u0266\3\2\2\2\u028f\u0267\3\2"+ 21260 "\2\2\u028f\u0268\3\2\2\2\u028f\u0269\3\2\2\2\u028f\u026a\3\2\2\2\u028f"+ 21261 "\u026b\3\2\2\2\u028f\u026c\3\2\2\2\u028f\u026d\3\2\2\2\u028f\u026e\3\2"+ 21262 "\2\2\u028f\u026f\3\2\2\2\u028f\u0270\3\2\2\2\u028f\u0271\3\2\2\2\u028f"+ 21263 "\u0272\3\2\2\2\u028f\u0273\3\2\2\2\u028f\u0274\3\2\2\2\u028f\u0275\3\2"+ 21264 "\2\2\u028f\u0276\3\2\2\2\u028f\u0277\3\2\2\2\u028f\u0278\3\2\2\2\u028f"+ 21265 "\u0279\3\2\2\2\u028f\u027a\3\2\2\2\u028f\u027b\3\2\2\2\u028f\u027c\3\2"+ 21266 "\2\2\u028f\u027d\3\2\2\2\u028f\u027e\3\2\2\2\u028f\u027f\3\2\2\2\u028f"+ 21267 "\u0280\3\2\2\2\u028f\u0281\3\2\2\2\u028f\u0282\3\2\2\2\u028f\u0283\3\2"+ 21268 "\2\2\u028f\u0284\3\2\2\2\u028f\u0285\3\2\2\2\u028f\u0286\3\2\2\2\u028f"+ 21269 "\u0287\3\2\2\2\u028f\u0288\3\2\2\2\u028f\u028a\3\2\2\2\u028f\u028b\3\2"+ 21270 "\2\2\u028f\u028c\3\2\2\2\u028f\u028d\3\2\2\2\u028f\u028e\3\2\2\2\u0290"+ 21271 "\u0293\3\2\2\2\u0291\u028f\3\2\2\2\u0291\u0292\3\2\2\2\u0292\u0294\3\2"+ 21272 "\2\2\u0293\u0291\3\2\2\2\u0294\u0295\5\"\22\2\u0295%\3\2\2\2\u0296\u0297"+ 21273 "\7\7\2\2\u0297\u029e\7A\2\2\u0298\u029d\5\n\6\2\u0299\u029d\7\b\2\2\u029a"+ 21274 "\u029d\7\3\2\2\u029b\u029d\7\6\2\2\u029c\u0298\3\2\2\2\u029c\u0299\3\2"+ 21275 "\2\2\u029c\u029a\3\2\2\2\u029c\u029b\3\2\2\2\u029d\u02a0\3\2\2\2\u029e"+ 21276 "\u029c\3\2\2\2\u029e\u029f\3\2\2\2\u029f\u02a1\3\2\2\2\u02a0\u029e\3\2"+ 21277 "\2\2\u02a1\u02a2\79\2\2\u02a2\'\3\2\2\2\u02a3\u02a4\7\7\2\2\u02a4\u02a5"+ 21278 "\7;\2\2\u02a5\u02a9\7A\2\2\u02a6\u02a8\t\2\2\2\u02a7\u02a6\3\2\2\2\u02a8"+ 21279 "\u02ab\3\2\2\2\u02a9\u02a7\3\2\2\2\u02a9\u02aa\3\2\2\2\u02aa\u02ac\3\2"+ 21280 "\2\2\u02ab\u02a9\3\2\2\2\u02ac\u02ad\79\2\2\u02ad)\3\2\2\2\u02ae\u02e0"+ 21281 "\5&\24\2\u02af\u02df\5\f\7\2\u02b0\u02df\5h\65\2\u02b1\u02df\5\22\n\2"+ 21282 "\u02b2\u02df\5\30\r\2\u02b3\u02df\5\36\20\2\u02b4\u02df\5$\23\2\u02b5"+ 21283 "\u02df\5\60\31\2\u02b6\u02df\5\66\34\2\u02b7\u02df\5<\37\2\u02b8\u02df"+ 21284 "\5B\"\2\u02b9\u02df\5H%\2\u02ba\u02df\5N(\2\u02bb\u02df\5T+\2\u02bc\u02df"+ 21285 "\5Z.\2\u02bd\u02df\5f\64\2\u02be\u02df\5`\61\2\u02bf\u02df\5\u00a6T\2"+ 21286 "\u02c0\u02df\5\u00acW\2\u02c1\u02df\5\u00b2Z\2\u02c2\u02df\5\u00b8]\2"+ 21287 "\u02c3\u02df\5\u00be`\2\u02c4\u02df\5\16\b\2\u02c5\u02df\5\24\13\2\u02c6"+ 21288 "\u02df\5\32\16\2\u02c7\u02df\5 \21\2\u02c8\u02df\5,\27\2\u02c9\u02df\5"+ 21289 "\62\32\2\u02ca\u02df\58\35\2\u02cb\u02df\5> \2\u02cc\u02df\5D#\2\u02cd"+ 21290 "\u02df\5J&\2\u02ce\u02df\5P)\2\u02cf\u02df\5V,\2\u02d0\u02df\5b\62\2\u02d1"+ 21291 "\u02df\5\\/\2\u02d2\u02df\5\u00a2R\2\u02d3\u02df\5\u00a8U\2\u02d4\u02df"+ 21292 "\5\u00aeX\2\u02d5\u02df\5\u00b4[\2\u02d6\u02df\5\u00ba^\2\u02d7\u02d8"+ 21293 "\6\26\t\2\u02d8\u02df\7\3\2\2\u02d9\u02df\5\u0094K\2\u02da\u02df\7\5\2"+ 21294 "\2\u02db\u02df\7\b\2\2\u02dc\u02df\5\u0096L\2\u02dd\u02df\5\u0092J\2\u02de"+ 21295 "\u02af\3\2\2\2\u02de\u02b0\3\2\2\2\u02de\u02b1\3\2\2\2\u02de\u02b2\3\2"+ 21296 "\2\2\u02de\u02b3\3\2\2\2\u02de\u02b4\3\2\2\2\u02de\u02b5\3\2\2\2\u02de"+ 21297 "\u02b6\3\2\2\2\u02de\u02b7\3\2\2\2\u02de\u02b8\3\2\2\2\u02de\u02b9\3\2"+ 21298 "\2\2\u02de\u02ba\3\2\2\2\u02de\u02bb\3\2\2\2\u02de\u02bc\3\2\2\2\u02de"+ 21299 "\u02bd\3\2\2\2\u02de\u02be\3\2\2\2\u02de\u02bf\3\2\2\2\u02de\u02c0\3\2"+ 21300 "\2\2\u02de\u02c1\3\2\2\2\u02de\u02c2\3\2\2\2\u02de\u02c3\3\2\2\2\u02de"+ 21301 "\u02c4\3\2\2\2\u02de\u02c5\3\2\2\2\u02de\u02c6\3\2\2\2\u02de\u02c7\3\2"+ 21302 "\2\2\u02de\u02c8\3\2\2\2\u02de\u02c9\3\2\2\2\u02de\u02ca\3\2\2\2\u02de"+ 21303 "\u02cb\3\2\2\2\u02de\u02cc\3\2\2\2\u02de\u02cd\3\2\2\2\u02de\u02ce\3\2"+ 21304 "\2\2\u02de\u02cf\3\2\2\2\u02de\u02d0\3\2\2\2\u02de\u02d1\3\2\2\2\u02de"+ 21305 "\u02d2\3\2\2\2\u02de\u02d3\3\2\2\2\u02de\u02d4\3\2\2\2\u02de\u02d5\3\2"+ 21306 "\2\2\u02de\u02d6\3\2\2\2\u02de\u02d7\3\2\2\2\u02de\u02d9\3\2\2\2\u02de"+ 21307 "\u02da\3\2\2\2\u02de\u02db\3\2\2\2\u02de\u02dc\3\2\2\2\u02de\u02dd\3\2"+ 21308 "\2\2\u02df\u02e2\3\2\2\2\u02e0\u02de\3\2\2\2\u02e0\u02e1\3\2\2\2\u02e1"+ 21309 "\u02e3\3\2\2\2\u02e2\u02e0\3\2\2\2\u02e3\u02e4\5(\25\2\u02e4+\3\2\2\2"+ 21310 "\u02e5\u02e6\7\7\2\2\u02e6\u02ed\7B\2\2\u02e7\u02ec\5\n\6\2\u02e8\u02ec"+ 21311 "\7\b\2\2\u02e9\u02ec\7\3\2\2\u02ea\u02ec\7\6\2\2\u02eb\u02e7\3\2\2\2\u02eb"+ 21312 "\u02e8\3\2\2\2\u02eb\u02e9\3\2\2\2\u02eb\u02ea\3\2\2\2\u02ec\u02ef\3\2"+ 21313 "\2\2\u02ed\u02eb\3\2\2\2\u02ed\u02ee\3\2\2\2\u02ee\u02f0\3\2\2\2\u02ef"+ 21314 "\u02ed\3\2\2\2\u02f0\u02f1\79\2\2\u02f1-\3\2\2\2\u02f2\u02f3\7\7\2\2\u02f3"+ 21315 "\u02f4\7;\2\2\u02f4\u02f8\7B\2\2\u02f5\u02f7\t\2\2\2\u02f6\u02f5\3\2\2"+ 21316 "\2\u02f7\u02fa\3\2\2\2\u02f8\u02f6\3\2\2\2\u02f8\u02f9\3\2\2\2\u02f9\u02fb"+ 21317 "\3\2\2\2\u02fa\u02f8\3\2\2\2\u02fb\u02fc\79\2\2\u02fc/\3\2\2\2\u02fd\u032f"+ 21318 "\5,\27\2\u02fe\u032e\5\f\7\2\u02ff\u032e\5h\65\2\u0300\u032e\5\22\n\2"+ 21319 "\u0301\u032e\5\30\r\2\u0302\u032e\5\36\20\2\u0303\u032e\5$\23\2\u0304"+ 21320 "\u032e\5*\26\2\u0305\u032e\5\66\34\2\u0306\u032e\5<\37\2\u0307\u032e\5"+ 21321 "B\"\2\u0308\u032e\5H%\2\u0309\u032e\5N(\2\u030a\u032e\5T+\2\u030b\u032e"+ 21322 "\5Z.\2\u030c\u032e\5f\64\2\u030d\u032e\5`\61\2\u030e\u032e\5\u00a6T\2"+ 21323 "\u030f\u032e\5\u00acW\2\u0310\u032e\5\u00b2Z\2\u0311\u032e\5\u00b8]\2"+ 21324 "\u0312\u032e\5\u00be`\2\u0313\u032e\5\16\b\2\u0314\u032e\5\24\13\2\u0315"+ 21325 "\u032e\5\32\16\2\u0316\u032e\5 \21\2\u0317\u032e\5&\24\2\u0318\u032e\5"+ 21326 "\62\32\2\u0319\u032e\58\35\2\u031a\u032e\5> \2\u031b\u032e\5D#\2\u031c"+ 21327 "\u032e\5J&\2\u031d\u032e\5P)\2\u031e\u032e\5V,\2\u031f\u032e\5b\62\2\u0320"+ 21328 "\u032e\5\\/\2\u0321\u032e\5\u00a2R\2\u0322\u032e\5\u00a8U\2\u0323\u032e"+ 21329 "\5\u00aeX\2\u0324\u032e\5\u00b4[\2\u0325\u032e\5\u00ba^\2\u0326\u0327"+ 21330 "\6\31\n\2\u0327\u032e\7\3\2\2\u0328\u032e\5\u0094K\2\u0329\u032e\7\5\2"+ 21331 "\2\u032a\u032e\7\b\2\2\u032b\u032e\5\u0096L\2\u032c\u032e\5\u0092J\2\u032d"+ 21332 "\u02fe\3\2\2\2\u032d\u02ff\3\2\2\2\u032d\u0300\3\2\2\2\u032d\u0301\3\2"+ 21333 "\2\2\u032d\u0302\3\2\2\2\u032d\u0303\3\2\2\2\u032d\u0304\3\2\2\2\u032d"+ 21334 "\u0305\3\2\2\2\u032d\u0306\3\2\2\2\u032d\u0307\3\2\2\2\u032d\u0308\3\2"+ 21335 "\2\2\u032d\u0309\3\2\2\2\u032d\u030a\3\2\2\2\u032d\u030b\3\2\2\2\u032d"+ 21336 "\u030c\3\2\2\2\u032d\u030d\3\2\2\2\u032d\u030e\3\2\2\2\u032d\u030f\3\2"+ 21337 "\2\2\u032d\u0310\3\2\2\2\u032d\u0311\3\2\2\2\u032d\u0312\3\2\2\2\u032d"+ 21338 "\u0313\3\2\2\2\u032d\u0314\3\2\2\2\u032d\u0315\3\2\2\2\u032d\u0316\3\2"+ 21339 "\2\2\u032d\u0317\3\2\2\2\u032d\u0318\3\2\2\2\u032d\u0319\3\2\2\2\u032d"+ 21340 "\u031a\3\2\2\2\u032d\u031b\3\2\2\2\u032d\u031c\3\2\2\2\u032d\u031d\3\2"+ 21341 "\2\2\u032d\u031e\3\2\2\2\u032d\u031f\3\2\2\2\u032d\u0320\3\2\2\2\u032d"+ 21342 "\u0321\3\2\2\2\u032d\u0322\3\2\2\2\u032d\u0323\3\2\2\2\u032d\u0324\3\2"+ 21343 "\2\2\u032d\u0325\3\2\2\2\u032d\u0326\3\2\2\2\u032d\u0328\3\2\2\2\u032d"+ 21344 "\u0329\3\2\2\2\u032d\u032a\3\2\2\2\u032d\u032b\3\2\2\2\u032d\u032c\3\2"+ 21345 "\2\2\u032e\u0331\3\2\2\2\u032f\u032d\3\2\2\2\u032f\u0330\3\2\2\2\u0330"+ 21346 "\u0332\3\2\2\2\u0331\u032f\3\2\2\2\u0332\u0333\5.\30\2\u0333\61\3\2\2"+ 21347 "\2\u0334\u0335\7\7\2\2\u0335\u033c\7C\2\2\u0336\u033b\5\n\6\2\u0337\u033b"+ 21348 "\7\b\2\2\u0338\u033b\7\3\2\2\u0339\u033b\7\6\2\2\u033a\u0336\3\2\2\2\u033a"+ 21349 "\u0337\3\2\2\2\u033a\u0338\3\2\2\2\u033a\u0339\3\2\2\2\u033b\u033e\3\2"+ 21350 "\2\2\u033c\u033a\3\2\2\2\u033c\u033d\3\2\2\2\u033d\u033f\3\2\2\2\u033e"+ 21351 "\u033c\3\2\2\2\u033f\u0340\79\2\2\u0340\63\3\2\2\2\u0341\u0342\7\7\2\2"+ 21352 "\u0342\u0343\7;\2\2\u0343\u0347\7C\2\2\u0344\u0346\t\2\2\2\u0345\u0344"+ 21353 "\3\2\2\2\u0346\u0349\3\2\2\2\u0347\u0345\3\2\2\2\u0347\u0348\3\2\2\2\u0348"+ 21354 "\u034a\3\2\2\2\u0349\u0347\3\2\2\2\u034a\u034b\79\2\2\u034b\65\3\2\2\2"+ 21355 "\u034c\u037e\5\62\32\2\u034d\u037d\5\f\7\2\u034e\u037d\5h\65\2\u034f\u037d"+ 21356 "\5\22\n\2\u0350\u037d\5\30\r\2\u0351\u037d\5\36\20\2\u0352\u037d\5$\23"+ 21357 "\2\u0353\u037d\5*\26\2\u0354\u037d\5\60\31\2\u0355\u037d\5<\37\2\u0356"+ 21358 "\u037d\5B\"\2\u0357\u037d\5H%\2\u0358\u037d\5N(\2\u0359\u037d\5T+\2\u035a"+ 21359 "\u037d\5Z.\2\u035b\u037d\5f\64\2\u035c\u037d\5`\61\2\u035d\u037d\5\u00a6"+ 21360 "T\2\u035e\u037d\5\u00acW\2\u035f\u037d\5\u00b2Z\2\u0360\u037d\5\u00b8"+ 21361 "]\2\u0361\u037d\5\u00be`\2\u0362\u037d\5\16\b\2\u0363\u037d\5\24\13\2"+ 21362 "\u0364\u037d\5\32\16\2\u0365\u037d\5 \21\2\u0366\u037d\5&\24\2\u0367\u037d"+ 21363 "\5,\27\2\u0368\u037d\58\35\2\u0369\u037d\5> \2\u036a\u037d\5D#\2\u036b"+ 21364 "\u037d\5J&\2\u036c\u037d\5P)\2\u036d\u037d\5V,\2\u036e\u037d\5b\62\2\u036f"+ 21365 "\u037d\5\\/\2\u0370\u037d\5\u00a2R\2\u0371\u037d\5\u00a8U\2\u0372\u037d"+ 21366 "\5\u00aeX\2\u0373\u037d\5\u00b4[\2\u0374\u037d\5\u00ba^\2\u0375\u0376"+ 21367 "\6\34\13\2\u0376\u037d\7\3\2\2\u0377\u037d\5\u0094K\2\u0378\u037d\7\5"+ 21368 "\2\2\u0379\u037d\7\b\2\2\u037a\u037d\5\u0096L\2\u037b\u037d\5\u0092J\2"+ 21369 "\u037c\u034d\3\2\2\2\u037c\u034e\3\2\2\2\u037c\u034f\3\2\2\2\u037c\u0350"+ 21370 "\3\2\2\2\u037c\u0351\3\2\2\2\u037c\u0352\3\2\2\2\u037c\u0353\3\2\2\2\u037c"+ 21371 "\u0354\3\2\2\2\u037c\u0355\3\2\2\2\u037c\u0356\3\2\2\2\u037c\u0357\3\2"+ 21372 "\2\2\u037c\u0358\3\2\2\2\u037c\u0359\3\2\2\2\u037c\u035a\3\2\2\2\u037c"+ 21373 "\u035b\3\2\2\2\u037c\u035c\3\2\2\2\u037c\u035d\3\2\2\2\u037c\u035e\3\2"+ 21374 "\2\2\u037c\u035f\3\2\2\2\u037c\u0360\3\2\2\2\u037c\u0361\3\2\2\2\u037c"+ 21375 "\u0362\3\2\2\2\u037c\u0363\3\2\2\2\u037c\u0364\3\2\2\2\u037c\u0365\3\2"+ 21376 "\2\2\u037c\u0366\3\2\2\2\u037c\u0367\3\2\2\2\u037c\u0368\3\2\2\2\u037c"+ 21377 "\u0369\3\2\2\2\u037c\u036a\3\2\2\2\u037c\u036b\3\2\2\2\u037c\u036c\3\2"+ 21378 "\2\2\u037c\u036d\3\2\2\2\u037c\u036e\3\2\2\2\u037c\u036f\3\2\2\2\u037c"+ 21379 "\u0370\3\2\2\2\u037c\u0371\3\2\2\2\u037c\u0372\3\2\2\2\u037c\u0373\3\2"+ 21380 "\2\2\u037c\u0374\3\2\2\2\u037c\u0375\3\2\2\2\u037c\u0377\3\2\2\2\u037c"+ 21381 "\u0378\3\2\2\2\u037c\u0379\3\2\2\2\u037c\u037a\3\2\2\2\u037c\u037b\3\2"+ 21382 "\2\2\u037d\u0380\3\2\2\2\u037e\u037c\3\2\2\2\u037e\u037f\3\2\2\2\u037f"+ 21383 "\u0381\3\2\2\2\u0380\u037e\3\2\2\2\u0381\u0382\5\64\33\2\u0382\67\3\2"+ 21384 "\2\2\u0383\u0384\7\7\2\2\u0384\u038b\7D\2\2\u0385\u038a\5\n\6\2\u0386"+ 21385 "\u038a\7\b\2\2\u0387\u038a\7\3\2\2\u0388\u038a\7\6\2\2\u0389\u0385\3\2"+ 21386 "\2\2\u0389\u0386\3\2\2\2\u0389\u0387\3\2\2\2\u0389\u0388\3\2\2\2\u038a"+ 21387 "\u038d\3\2\2\2\u038b\u0389\3\2\2\2\u038b\u038c\3\2\2\2\u038c\u038e\3\2"+ 21388 "\2\2\u038d\u038b\3\2\2\2\u038e\u038f\79\2\2\u038f9\3\2\2\2\u0390\u0391"+ 21389 "\7\7\2\2\u0391\u0392\7;\2\2\u0392\u0396\7D\2\2\u0393\u0395\t\2\2\2\u0394"+ 21390 "\u0393\3\2\2\2\u0395\u0398\3\2\2\2\u0396\u0394\3\2\2\2\u0396\u0397\3\2"+ 21391 "\2\2\u0397\u0399\3\2\2\2\u0398\u0396\3\2\2\2\u0399\u039a\79\2\2\u039a"+ 21392 ";\3\2\2\2\u039b\u03cd\58\35\2\u039c\u03cc\5\f\7\2\u039d\u03cc\5h\65\2"+ 21393 "\u039e\u03cc\5\22\n\2\u039f\u03cc\5\30\r\2\u03a0\u03cc\5\36\20\2\u03a1"+ 21394 "\u03cc\5$\23\2\u03a2\u03cc\5*\26\2\u03a3\u03cc\5\60\31\2\u03a4\u03cc\5"+ 21395 "\66\34\2\u03a5\u03cc\5B\"\2\u03a6\u03cc\5H%\2\u03a7\u03cc\5N(\2\u03a8"+ 21396 "\u03cc\5T+\2\u03a9\u03cc\5Z.\2\u03aa\u03cc\5f\64\2\u03ab\u03cc\5`\61\2"+ 21397 "\u03ac\u03cc\5\u00a6T\2\u03ad\u03cc\5\u00acW\2\u03ae\u03cc\5\u00b2Z\2"+ 21398 "\u03af\u03cc\5\u00b8]\2\u03b0\u03cc\5\u00be`\2\u03b1\u03cc\5\16\b\2\u03b2"+ 21399 "\u03cc\5\24\13\2\u03b3\u03cc\5\32\16\2\u03b4\u03cc\5 \21\2\u03b5\u03cc"+ 21400 "\5&\24\2\u03b6\u03cc\5,\27\2\u03b7\u03cc\5\62\32\2\u03b8\u03cc\5> \2\u03b9"+ 21401 "\u03cc\5D#\2\u03ba\u03cc\5J&\2\u03bb\u03cc\5P)\2\u03bc\u03cc\5V,\2\u03bd"+ 21402 "\u03cc\5b\62\2\u03be\u03cc\5\\/\2\u03bf\u03cc\5\u00a2R\2\u03c0\u03cc\5"+ 21403 "\u00a8U\2\u03c1\u03cc\5\u00aeX\2\u03c2\u03cc\5\u00b4[\2\u03c3\u03cc\5"+ 21404 "\u00ba^\2\u03c4\u03c5\6\37\f\2\u03c5\u03cc\7\3\2\2\u03c6\u03cc\5\u0094"+ 21405 "K\2\u03c7\u03cc\7\5\2\2\u03c8\u03cc\7\b\2\2\u03c9\u03cc\5\u0096L\2\u03ca"+ 21406 "\u03cc\5\u0092J\2\u03cb\u039c\3\2\2\2\u03cb\u039d\3\2\2\2\u03cb\u039e"+ 21407 "\3\2\2\2\u03cb\u039f\3\2\2\2\u03cb\u03a0\3\2\2\2\u03cb\u03a1\3\2\2\2\u03cb"+ 21408 "\u03a2\3\2\2\2\u03cb\u03a3\3\2\2\2\u03cb\u03a4\3\2\2\2\u03cb\u03a5\3\2"+ 21409 "\2\2\u03cb\u03a6\3\2\2\2\u03cb\u03a7\3\2\2\2\u03cb\u03a8\3\2\2\2\u03cb"+ 21410 "\u03a9\3\2\2\2\u03cb\u03aa\3\2\2\2\u03cb\u03ab\3\2\2\2\u03cb\u03ac\3\2"+ 21411 "\2\2\u03cb\u03ad\3\2\2\2\u03cb\u03ae\3\2\2\2\u03cb\u03af\3\2\2\2\u03cb"+ 21412 "\u03b0\3\2\2\2\u03cb\u03b1\3\2\2\2\u03cb\u03b2\3\2\2\2\u03cb\u03b3\3\2"+ 21413 "\2\2\u03cb\u03b4\3\2\2\2\u03cb\u03b5\3\2\2\2\u03cb\u03b6\3\2\2\2\u03cb"+ 21414 "\u03b7\3\2\2\2\u03cb\u03b8\3\2\2\2\u03cb\u03b9\3\2\2\2\u03cb\u03ba\3\2"+ 21415 "\2\2\u03cb\u03bb\3\2\2\2\u03cb\u03bc\3\2\2\2\u03cb\u03bd\3\2\2\2\u03cb"+ 21416 "\u03be\3\2\2\2\u03cb\u03bf\3\2\2\2\u03cb\u03c0\3\2\2\2\u03cb\u03c1\3\2"+ 21417 "\2\2\u03cb\u03c2\3\2\2\2\u03cb\u03c3\3\2\2\2\u03cb\u03c4\3\2\2\2\u03cb"+ 21418 "\u03c6\3\2\2\2\u03cb\u03c7\3\2\2\2\u03cb\u03c8\3\2\2\2\u03cb\u03c9\3\2"+ 21419 "\2\2\u03cb\u03ca\3\2\2\2\u03cc\u03cf\3\2\2\2\u03cd\u03cb\3\2\2\2\u03cd"+ 21420 "\u03ce\3\2\2\2\u03ce\u03d0\3\2\2\2\u03cf\u03cd\3\2\2\2\u03d0\u03d1\5:"+ 21421 "\36\2\u03d1=\3\2\2\2\u03d2\u03d3\7\7\2\2\u03d3\u03da\7E\2\2\u03d4\u03d9"+ 21422 "\5\n\6\2\u03d5\u03d9\7\b\2\2\u03d6\u03d9\7\3\2\2\u03d7\u03d9\7\6\2\2\u03d8"+ 21423 "\u03d4\3\2\2\2\u03d8\u03d5\3\2\2\2\u03d8\u03d6\3\2\2\2\u03d8\u03d7\3\2"+ 21424 "\2\2\u03d9\u03dc\3\2\2\2\u03da\u03d8\3\2\2\2\u03da\u03db\3\2\2\2\u03db"+ 21425 "\u03dd\3\2\2\2\u03dc\u03da\3\2\2\2\u03dd\u03de\79\2\2\u03de?\3\2\2\2\u03df"+ 21426 "\u03e0\7\7\2\2\u03e0\u03e1\7;\2\2\u03e1\u03e5\7E\2\2\u03e2\u03e4\t\2\2"+ 21427 "\2\u03e3\u03e2\3\2\2\2\u03e4\u03e7\3\2\2\2\u03e5\u03e3\3\2\2\2\u03e5\u03e6"+ 21428 "\3\2\2\2\u03e6\u03e8\3\2\2\2\u03e7\u03e5\3\2\2\2\u03e8\u03e9\79\2\2\u03e9"+ 21429 "A\3\2\2\2\u03ea\u041c\5> \2\u03eb\u041b\5\f\7\2\u03ec\u041b\5h\65\2\u03ed"+ 21430 "\u041b\5\22\n\2\u03ee\u041b\5\30\r\2\u03ef\u041b\5\36\20\2\u03f0\u041b"+ 21431 "\5$\23\2\u03f1\u041b\5*\26\2\u03f2\u041b\5\60\31\2\u03f3\u041b\5\66\34"+ 21432 "\2\u03f4\u041b\5<\37\2\u03f5\u041b\5H%\2\u03f6\u041b\5N(\2\u03f7\u041b"+ 21433 "\5T+\2\u03f8\u041b\5Z.\2\u03f9\u041b\5f\64\2\u03fa\u041b\5`\61\2\u03fb"+ 21434 "\u041b\5\u00a6T\2\u03fc\u041b\5\u00acW\2\u03fd\u041b\5\u00b2Z\2\u03fe"+ 21435 "\u041b\5\u00b8]\2\u03ff\u041b\5\u00be`\2\u0400\u041b\5\16\b\2\u0401\u041b"+ 21436 "\5\24\13\2\u0402\u041b\5\32\16\2\u0403\u041b\5 \21\2\u0404\u041b\5&\24"+ 21437 "\2\u0405\u041b\5,\27\2\u0406\u041b\5\62\32\2\u0407\u041b\58\35\2\u0408"+ 21438 "\u041b\5D#\2\u0409\u041b\5J&\2\u040a\u041b\5P)\2\u040b\u041b\5V,\2\u040c"+ 21439 "\u041b\5b\62\2\u040d\u041b\5\\/\2\u040e\u041b\5\u00a2R\2\u040f\u041b\5"+ 21440 "\u00a8U\2\u0410\u041b\5\u00aeX\2\u0411\u041b\5\u00b4[\2\u0412\u041b\5"+ 21441 "\u00ba^\2\u0413\u0414\6\"\r\2\u0414\u041b\7\3\2\2\u0415\u041b\5\u0094"+ 21442 "K\2\u0416\u041b\7\5\2\2\u0417\u041b\7\b\2\2\u0418\u041b\5\u0096L\2\u0419"+ 21443 "\u041b\5\u0092J\2\u041a\u03eb\3\2\2\2\u041a\u03ec\3\2\2\2\u041a\u03ed"+ 21444 "\3\2\2\2\u041a\u03ee\3\2\2\2\u041a\u03ef\3\2\2\2\u041a\u03f0\3\2\2\2\u041a"+ 21445 "\u03f1\3\2\2\2\u041a\u03f2\3\2\2\2\u041a\u03f3\3\2\2\2\u041a\u03f4\3\2"+ 21446 "\2\2\u041a\u03f5\3\2\2\2\u041a\u03f6\3\2\2\2\u041a\u03f7\3\2\2\2\u041a"+ 21447 "\u03f8\3\2\2\2\u041a\u03f9\3\2\2\2\u041a\u03fa\3\2\2\2\u041a\u03fb\3\2"+ 21448 "\2\2\u041a\u03fc\3\2\2\2\u041a\u03fd\3\2\2\2\u041a\u03fe\3\2\2\2\u041a"+ 21449 "\u03ff\3\2\2\2\u041a\u0400\3\2\2\2\u041a\u0401\3\2\2\2\u041a\u0402\3\2"+ 21450 "\2\2\u041a\u0403\3\2\2\2\u041a\u0404\3\2\2\2\u041a\u0405\3\2\2\2\u041a"+ 21451 "\u0406\3\2\2\2\u041a\u0407\3\2\2\2\u041a\u0408\3\2\2\2\u041a\u0409\3\2"+ 21452 "\2\2\u041a\u040a\3\2\2\2\u041a\u040b\3\2\2\2\u041a\u040c\3\2\2\2\u041a"+ 21453 "\u040d\3\2\2\2\u041a\u040e\3\2\2\2\u041a\u040f\3\2\2\2\u041a\u0410\3\2"+ 21454 "\2\2\u041a\u0411\3\2\2\2\u041a\u0412\3\2\2\2\u041a\u0413\3\2\2\2\u041a"+ 21455 "\u0415\3\2\2\2\u041a\u0416\3\2\2\2\u041a\u0417\3\2\2\2\u041a\u0418\3\2"+ 21456 "\2\2\u041a\u0419\3\2\2\2\u041b\u041e\3\2\2\2\u041c\u041a\3\2\2\2\u041c"+ 21457 "\u041d\3\2\2\2\u041d\u041f\3\2\2\2\u041e\u041c\3\2\2\2\u041f\u0420\5@"+ 21458 "!\2\u0420C\3\2\2\2\u0421\u0422\7\7\2\2\u0422\u0429\7F\2\2\u0423\u0428"+ 21459 "\5\n\6\2\u0424\u0428\7\b\2\2\u0425\u0428\7\3\2\2\u0426\u0428\7\6\2\2\u0427"+ 21460 "\u0423\3\2\2\2\u0427\u0424\3\2\2\2\u0427\u0425\3\2\2\2\u0427\u0426\3\2"+ 21461 "\2\2\u0428\u042b\3\2\2\2\u0429\u0427\3\2\2\2\u0429\u042a\3\2\2\2\u042a"+ 21462 "\u042c\3\2\2\2\u042b\u0429\3\2\2\2\u042c\u042d\79\2\2\u042dE\3\2\2\2\u042e"+ 21463 "\u042f\7\7\2\2\u042f\u0430\7;\2\2\u0430\u0434\7F\2\2\u0431\u0433\t\2\2"+ 21464 "\2\u0432\u0431\3\2\2\2\u0433\u0436\3\2\2\2\u0434\u0432\3\2\2\2\u0434\u0435"+ 21465 "\3\2\2\2\u0435\u0437\3\2\2\2\u0436\u0434\3\2\2\2\u0437\u0438\79\2\2\u0438"+ 21466 "G\3\2\2\2\u0439\u046b\5D#\2\u043a\u046a\5\f\7\2\u043b\u046a\5h\65\2\u043c"+ 21467 "\u046a\5\22\n\2\u043d\u046a\5\30\r\2\u043e\u046a\5\36\20\2\u043f\u046a"+ 21468 "\5$\23\2\u0440\u046a\5*\26\2\u0441\u046a\5\60\31\2\u0442\u046a\5\66\34"+ 21469 "\2\u0443\u046a\5<\37\2\u0444\u046a\5B\"\2\u0445\u046a\5N(\2\u0446\u046a"+ 21470 "\5T+\2\u0447\u046a\5Z.\2\u0448\u046a\5f\64\2\u0449\u046a\5`\61\2\u044a"+ 21471 "\u046a\5\u00a6T\2\u044b\u046a\5\u00acW\2\u044c\u046a\5\u00b2Z\2\u044d"+ 21472 "\u046a\5\u00b8]\2\u044e\u046a\5\u00be`\2\u044f\u046a\5\16\b\2\u0450\u046a"+ 21473 "\5\24\13\2\u0451\u046a\5\32\16\2\u0452\u046a\5 \21\2\u0453\u046a\5&\24"+ 21474 "\2\u0454\u046a\5,\27\2\u0455\u046a\5\62\32\2\u0456\u046a\58\35\2\u0457"+ 21475 "\u046a\5> \2\u0458\u046a\5J&\2\u0459\u046a\5P)\2\u045a\u046a\5V,\2\u045b"+ 21476 "\u046a\5b\62\2\u045c\u046a\5\\/\2\u045d\u046a\5\u00a2R\2\u045e\u046a\5"+ 21477 "\u00a8U\2\u045f\u046a\5\u00aeX\2\u0460\u046a\5\u00b4[\2\u0461\u046a\5"+ 21478 "\u00ba^\2\u0462\u0463\6%\16\2\u0463\u046a\7\3\2\2\u0464\u046a\5\u0094"+ 21479 "K\2\u0465\u046a\7\5\2\2\u0466\u046a\7\b\2\2\u0467\u046a\5\u0096L\2\u0468"+ 21480 "\u046a\5\u0092J\2\u0469\u043a\3\2\2\2\u0469\u043b\3\2\2\2\u0469\u043c"+ 21481 "\3\2\2\2\u0469\u043d\3\2\2\2\u0469\u043e\3\2\2\2\u0469\u043f\3\2\2\2\u0469"+ 21482 "\u0440\3\2\2\2\u0469\u0441\3\2\2\2\u0469\u0442\3\2\2\2\u0469\u0443\3\2"+ 21483 "\2\2\u0469\u0444\3\2\2\2\u0469\u0445\3\2\2\2\u0469\u0446\3\2\2\2\u0469"+ 21484 "\u0447\3\2\2\2\u0469\u0448\3\2\2\2\u0469\u0449\3\2\2\2\u0469\u044a\3\2"+ 21485 "\2\2\u0469\u044b\3\2\2\2\u0469\u044c\3\2\2\2\u0469\u044d\3\2\2\2\u0469"+ 21486 "\u044e\3\2\2\2\u0469\u044f\3\2\2\2\u0469\u0450\3\2\2\2\u0469\u0451\3\2"+ 21487 "\2\2\u0469\u0452\3\2\2\2\u0469\u0453\3\2\2\2\u0469\u0454\3\2\2\2\u0469"+ 21488 "\u0455\3\2\2\2\u0469\u0456\3\2\2\2\u0469\u0457\3\2\2\2\u0469\u0458\3\2"+ 21489 "\2\2\u0469\u0459\3\2\2\2\u0469\u045a\3\2\2\2\u0469\u045b\3\2\2\2\u0469"+ 21490 "\u045c\3\2\2\2\u0469\u045d\3\2\2\2\u0469\u045e\3\2\2\2\u0469\u045f\3\2"+ 21491 "\2\2\u0469\u0460\3\2\2\2\u0469\u0461\3\2\2\2\u0469\u0462\3\2\2\2\u0469"+ 21492 "\u0464\3\2\2\2\u0469\u0465\3\2\2\2\u0469\u0466\3\2\2\2\u0469\u0467\3\2"+ 21493 "\2\2\u0469\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b"+ 21494 "\u046c\3\2\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u046f\5F"+ 21495 "$\2\u046fI\3\2\2\2\u0470\u0471\7\7\2\2\u0471\u0478\7G\2\2\u0472\u0477"+ 21496 "\5\n\6\2\u0473\u0477\7\b\2\2\u0474\u0477\7\3\2\2\u0475\u0477\7\6\2\2\u0476"+ 21497 "\u0472\3\2\2\2\u0476\u0473\3\2\2\2\u0476\u0474\3\2\2\2\u0476\u0475\3\2"+ 21498 "\2\2\u0477\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3\2\2\2\u0479"+ 21499 "\u047b\3\2\2\2\u047a\u0478\3\2\2\2\u047b\u047c\79\2\2\u047cK\3\2\2\2\u047d"+ 21500 "\u047e\7\7\2\2\u047e\u047f\7;\2\2\u047f\u0483\7G\2\2\u0480\u0482\t\2\2"+ 21501 "\2\u0481\u0480\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484"+ 21502 "\3\2\2\2\u0484\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0487\79\2\2\u0487"+ 21503 "M\3\2\2\2\u0488\u04ba\5J&\2\u0489\u04b9\5\f\7\2\u048a\u04b9\5h\65\2\u048b"+ 21504 "\u04b9\5\22\n\2\u048c\u04b9\5\30\r\2\u048d\u04b9\5\36\20\2\u048e\u04b9"+ 21505 "\5$\23\2\u048f\u04b9\5*\26\2\u0490\u04b9\5\60\31\2\u0491\u04b9\5\66\34"+ 21506 "\2\u0492\u04b9\5<\37\2\u0493\u04b9\5B\"\2\u0494\u04b9\5H%\2\u0495\u04b9"+ 21507 "\5T+\2\u0496\u04b9\5Z.\2\u0497\u04b9\5f\64\2\u0498\u04b9\5`\61\2\u0499"+ 21508 "\u04b9\5\u00a6T\2\u049a\u04b9\5\u00acW\2\u049b\u04b9\5\u00b2Z\2\u049c"+ 21509 "\u04b9\5\u00b8]\2\u049d\u04b9\5\u00be`\2\u049e\u04b9\5\16\b\2\u049f\u04b9"+ 21510 "\5\24\13\2\u04a0\u04b9\5\32\16\2\u04a1\u04b9\5 \21\2\u04a2\u04b9\5&\24"+ 21511 "\2\u04a3\u04b9\5,\27\2\u04a4\u04b9\5\62\32\2\u04a5\u04b9\58\35\2\u04a6"+ 21512 "\u04b9\5> \2\u04a7\u04b9\5D#\2\u04a8\u04b9\5P)\2\u04a9\u04b9\5V,\2\u04aa"+ 21513 "\u04b9\5b\62\2\u04ab\u04b9\5\\/\2\u04ac\u04b9\5\u00a2R\2\u04ad\u04b9\5"+ 21514 "\u00a8U\2\u04ae\u04b9\5\u00aeX\2\u04af\u04b9\5\u00b4[\2\u04b0\u04b9\5"+ 21515 "\u00ba^\2\u04b1\u04b2\6(\17\2\u04b2\u04b9\7\3\2\2\u04b3\u04b9\5\u0094"+ 21516 "K\2\u04b4\u04b9\7\5\2\2\u04b5\u04b9\7\b\2\2\u04b6\u04b9\5\u0096L\2\u04b7"+ 21517 "\u04b9\5\u0092J\2\u04b8\u0489\3\2\2\2\u04b8\u048a\3\2\2\2\u04b8\u048b"+ 21518 "\3\2\2\2\u04b8\u048c\3\2\2\2\u04b8\u048d\3\2\2\2\u04b8\u048e\3\2\2\2\u04b8"+ 21519 "\u048f\3\2\2\2\u04b8\u0490\3\2\2\2\u04b8\u0491\3\2\2\2\u04b8\u0492\3\2"+ 21520 "\2\2\u04b8\u0493\3\2\2\2\u04b8\u0494\3\2\2\2\u04b8\u0495\3\2\2\2\u04b8"+ 21521 "\u0496\3\2\2\2\u04b8\u0497\3\2\2\2\u04b8\u0498\3\2\2\2\u04b8\u0499\3\2"+ 21522 "\2\2\u04b8\u049a\3\2\2\2\u04b8\u049b\3\2\2\2\u04b8\u049c\3\2\2\2\u04b8"+ 21523 "\u049d\3\2\2\2\u04b8\u049e\3\2\2\2\u04b8\u049f\3\2\2\2\u04b8\u04a0\3\2"+ 21524 "\2\2\u04b8\u04a1\3\2\2\2\u04b8\u04a2\3\2\2\2\u04b8\u04a3\3\2\2\2\u04b8"+ 21525 "\u04a4\3\2\2\2\u04b8\u04a5\3\2\2\2\u04b8\u04a6\3\2\2\2\u04b8\u04a7\3\2"+ 21526 "\2\2\u04b8\u04a8\3\2\2\2\u04b8\u04a9\3\2\2\2\u04b8\u04aa\3\2\2\2\u04b8"+ 21527 "\u04ab\3\2\2\2\u04b8\u04ac\3\2\2\2\u04b8\u04ad\3\2\2\2\u04b8\u04ae\3\2"+ 21528 "\2\2\u04b8\u04af\3\2\2\2\u04b8\u04b0\3\2\2\2\u04b8\u04b1\3\2\2\2\u04b8"+ 21529 "\u04b3\3\2\2\2\u04b8\u04b4\3\2\2\2\u04b8\u04b5\3\2\2\2\u04b8\u04b6\3\2"+ 21530 "\2\2\u04b8\u04b7\3\2\2\2\u04b9\u04bc\3\2\2\2\u04ba\u04b8\3\2\2\2\u04ba"+ 21531 "\u04bb\3\2\2\2\u04bb\u04bd\3\2\2\2\u04bc\u04ba\3\2\2\2\u04bd\u04be\5L"+ 21532 "\'\2\u04beO\3\2\2\2\u04bf\u04c0\7\7\2\2\u04c0\u04c7\7H\2\2\u04c1\u04c6"+ 21533 "\5\n\6\2\u04c2\u04c6\7\b\2\2\u04c3\u04c6\7\3\2\2\u04c4\u04c6\7\6\2\2\u04c5"+ 21534 "\u04c1\3\2\2\2\u04c5\u04c2\3\2\2\2\u04c5\u04c3\3\2\2\2\u04c5\u04c4\3\2"+ 21535 "\2\2\u04c6\u04c9\3\2\2\2\u04c7\u04c5\3\2\2\2\u04c7\u04c8\3\2\2\2\u04c8"+ 21536 "\u04ca\3\2\2\2\u04c9\u04c7\3\2\2\2\u04ca\u04cb\79\2\2\u04cbQ\3\2\2\2\u04cc"+ 21537 "\u04cd\7\7\2\2\u04cd\u04ce\7;\2\2\u04ce\u04d2\7H\2\2\u04cf\u04d1\t\2\2"+ 21538 "\2\u04d0\u04cf\3\2\2\2\u04d1\u04d4\3\2\2\2\u04d2\u04d0\3\2\2\2\u04d2\u04d3"+ 21539 "\3\2\2\2\u04d3\u04d5\3\2\2\2\u04d4\u04d2\3\2\2\2\u04d5\u04d6\79\2\2\u04d6"+ 21540 "S\3\2\2\2\u04d7\u0509\5P)\2\u04d8\u0508\5\f\7\2\u04d9\u0508\5h\65\2\u04da"+ 21541 "\u0508\5\22\n\2\u04db\u0508\5\30\r\2\u04dc\u0508\5\36\20\2\u04dd\u0508"+ 21542 "\5$\23\2\u04de\u0508\5*\26\2\u04df\u0508\5\60\31\2\u04e0\u0508\5\66\34"+ 21543 "\2\u04e1\u0508\5<\37\2\u04e2\u0508\5B\"\2\u04e3\u0508\5H%\2\u04e4\u0508"+ 21544 "\5N(\2\u04e5\u0508\5Z.\2\u04e6\u0508\5f\64\2\u04e7\u0508\5`\61\2\u04e8"+ 21545 "\u0508\5\u00a6T\2\u04e9\u0508\5\u00acW\2\u04ea\u0508\5\u00b2Z\2\u04eb"+ 21546 "\u0508\5\u00b8]\2\u04ec\u0508\5\u00be`\2\u04ed\u0508\5\16\b\2\u04ee\u0508"+ 21547 "\5\24\13\2\u04ef\u0508\5\32\16\2\u04f0\u0508\5 \21\2\u04f1\u0508\5&\24"+ 21548 "\2\u04f2\u0508\5,\27\2\u04f3\u0508\5\62\32\2\u04f4\u0508\58\35\2\u04f5"+ 21549 "\u0508\5> \2\u04f6\u0508\5D#\2\u04f7\u0508\5J&\2\u04f8\u0508\5V,\2\u04f9"+ 21550 "\u0508\5b\62\2\u04fa\u0508\5\\/\2\u04fb\u0508\5\u00a2R\2\u04fc\u0508\5"+ 21551 "\u00a8U\2\u04fd\u0508\5\u00aeX\2\u04fe\u0508\5\u00b4[\2\u04ff\u0508\5"+ 21552 "\u00ba^\2\u0500\u0501\6+\20\2\u0501\u0508\7\3\2\2\u0502\u0508\5\u0094"+ 21553 "K\2\u0503\u0508\7\5\2\2\u0504\u0508\7\b\2\2\u0505\u0508\5\u0096L\2\u0506"+ 21554 "\u0508\5\u0092J\2\u0507\u04d8\3\2\2\2\u0507\u04d9\3\2\2\2\u0507\u04da"+ 21555 "\3\2\2\2\u0507\u04db\3\2\2\2\u0507\u04dc\3\2\2\2\u0507\u04dd\3\2\2\2\u0507"+ 21556 "\u04de\3\2\2\2\u0507\u04df\3\2\2\2\u0507\u04e0\3\2\2\2\u0507\u04e1\3\2"+ 21557 "\2\2\u0507\u04e2\3\2\2\2\u0507\u04e3\3\2\2\2\u0507\u04e4\3\2\2\2\u0507"+ 21558 "\u04e5\3\2\2\2\u0507\u04e6\3\2\2\2\u0507\u04e7\3\2\2\2\u0507\u04e8\3\2"+ 21559 "\2\2\u0507\u04e9\3\2\2\2\u0507\u04ea\3\2\2\2\u0507\u04eb\3\2\2\2\u0507"+ 21560 "\u04ec\3\2\2\2\u0507\u04ed\3\2\2\2\u0507\u04ee\3\2\2\2\u0507\u04ef\3\2"+ 21561 "\2\2\u0507\u04f0\3\2\2\2\u0507\u04f1\3\2\2\2\u0507\u04f2\3\2\2\2\u0507"+ 21562 "\u04f3\3\2\2\2\u0507\u04f4\3\2\2\2\u0507\u04f5\3\2\2\2\u0507\u04f6\3\2"+ 21563 "\2\2\u0507\u04f7\3\2\2\2\u0507\u04f8\3\2\2\2\u0507\u04f9\3\2\2\2\u0507"+ 21564 "\u04fa\3\2\2\2\u0507\u04fb\3\2\2\2\u0507\u04fc\3\2\2\2\u0507\u04fd\3\2"+ 21565 "\2\2\u0507\u04fe\3\2\2\2\u0507\u04ff\3\2\2\2\u0507\u0500\3\2\2\2\u0507"+ 21566 "\u0502\3\2\2\2\u0507\u0503\3\2\2\2\u0507\u0504\3\2\2\2\u0507\u0505\3\2"+ 21567 "\2\2\u0507\u0506\3\2\2\2\u0508\u050b\3\2\2\2\u0509\u0507\3\2\2\2\u0509"+ 21568 "\u050a\3\2\2\2\u050a\u050c\3\2\2\2\u050b\u0509\3\2\2\2\u050c\u050d\5R"+ 21569 "*\2\u050dU\3\2\2\2\u050e\u050f\7\7\2\2\u050f\u0516\7I\2\2\u0510\u0515"+ 21570 "\5\n\6\2\u0511\u0515\7\b\2\2\u0512\u0515\7\3\2\2\u0513\u0515\7\6\2\2\u0514"+ 21571 "\u0510\3\2\2\2\u0514\u0511\3\2\2\2\u0514\u0512\3\2\2\2\u0514\u0513\3\2"+ 21572 "\2\2\u0515\u0518\3\2\2\2\u0516\u0514\3\2\2\2\u0516\u0517\3\2\2\2\u0517"+ 21573 "\u0519\3\2\2\2\u0518\u0516\3\2\2\2\u0519\u051a\79\2\2\u051aW\3\2\2\2\u051b"+ 21574 "\u051c\7\7\2\2\u051c\u051d\7;\2\2\u051d\u0521\7I\2\2\u051e\u0520\t\2\2"+ 21575 "\2\u051f\u051e\3\2\2\2\u0520\u0523\3\2\2\2\u0521\u051f\3\2\2\2\u0521\u0522"+ 21576 "\3\2\2\2\u0522\u0524\3\2\2\2\u0523\u0521\3\2\2\2\u0524\u0525\79\2\2\u0525"+ 21577 "Y\3\2\2\2\u0526\u0558\5V,\2\u0527\u0557\5\f\7\2\u0528\u0557\5h\65\2\u0529"+ 21578 "\u0557\5\22\n\2\u052a\u0557\5\30\r\2\u052b\u0557\5\36\20\2\u052c\u0557"+ 21579 "\5$\23\2\u052d\u0557\5*\26\2\u052e\u0557\5\60\31\2\u052f\u0557\5\66\34"+ 21580 "\2\u0530\u0557\5<\37\2\u0531\u0557\5B\"\2\u0532\u0557\5H%\2\u0533\u0557"+ 21581 "\5N(\2\u0534\u0557\5T+\2\u0535\u0557\5f\64\2\u0536\u0557\5`\61\2\u0537"+ 21582 "\u0557\5\u00a6T\2\u0538\u0557\5\u00acW\2\u0539\u0557\5\u00b2Z\2\u053a"+ 21583 "\u0557\5\u00b8]\2\u053b\u0557\5\u00be`\2\u053c\u0557\5\16\b\2\u053d\u0557"+ 21584 "\5\24\13\2\u053e\u0557\5\32\16\2\u053f\u0557\5 \21\2\u0540\u0557\5&\24"+ 21585 "\2\u0541\u0557\5,\27\2\u0542\u0557\5\62\32\2\u0543\u0557\58\35\2\u0544"+ 21586 "\u0557\5> \2\u0545\u0557\5D#\2\u0546\u0557\5J&\2\u0547\u0557\5P)\2\u0548"+ 21587 "\u0557\5b\62\2\u0549\u0557\5\\/\2\u054a\u0557\5\u00a2R\2\u054b\u0557\5"+ 21588 "\u00a8U\2\u054c\u0557\5\u00aeX\2\u054d\u0557\5\u00b4[\2\u054e\u0557\5"+ 21589 "\u00ba^\2\u054f\u0550\6.\21\2\u0550\u0557\7\3\2\2\u0551\u0557\5\u0094"+ 21590 "K\2\u0552\u0557\7\5\2\2\u0553\u0557\7\b\2\2\u0554\u0557\5\u0096L\2\u0555"+ 21591 "\u0557\5\u0092J\2\u0556\u0527\3\2\2\2\u0556\u0528\3\2\2\2\u0556\u0529"+ 21592 "\3\2\2\2\u0556\u052a\3\2\2\2\u0556\u052b\3\2\2\2\u0556\u052c\3\2\2\2\u0556"+ 21593 "\u052d\3\2\2\2\u0556\u052e\3\2\2\2\u0556\u052f\3\2\2\2\u0556\u0530\3\2"+ 21594 "\2\2\u0556\u0531\3\2\2\2\u0556\u0532\3\2\2\2\u0556\u0533\3\2\2\2\u0556"+ 21595 "\u0534\3\2\2\2\u0556\u0535\3\2\2\2\u0556\u0536\3\2\2\2\u0556\u0537\3\2"+ 21596 "\2\2\u0556\u0538\3\2\2\2\u0556\u0539\3\2\2\2\u0556\u053a\3\2\2\2\u0556"+ 21597 "\u053b\3\2\2\2\u0556\u053c\3\2\2\2\u0556\u053d\3\2\2\2\u0556\u053e\3\2"+ 21598 "\2\2\u0556\u053f\3\2\2\2\u0556\u0540\3\2\2\2\u0556\u0541\3\2\2\2\u0556"+ 21599 "\u0542\3\2\2\2\u0556\u0543\3\2\2\2\u0556\u0544\3\2\2\2\u0556\u0545\3\2"+ 21600 "\2\2\u0556\u0546\3\2\2\2\u0556\u0547\3\2\2\2\u0556\u0548\3\2\2\2\u0556"+ 21601 "\u0549\3\2\2\2\u0556\u054a\3\2\2\2\u0556\u054b\3\2\2\2\u0556\u054c\3\2"+ 21602 "\2\2\u0556\u054d\3\2\2\2\u0556\u054e\3\2\2\2\u0556\u054f\3\2\2\2\u0556"+ 21603 "\u0551\3\2\2\2\u0556\u0552\3\2\2\2\u0556\u0553\3\2\2\2\u0556\u0554\3\2"+ 21604 "\2\2\u0556\u0555\3\2\2\2\u0557\u055a\3\2\2\2\u0558\u0556\3\2\2\2\u0558"+ 21605 "\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\5X"+ 21606 "-\2\u055c[\3\2\2\2\u055d\u055e\7\7\2\2\u055e\u0565\7J\2\2\u055f\u0564"+ 21607 "\5\n\6\2\u0560\u0564\7\b\2\2\u0561\u0564\7\3\2\2\u0562\u0564\7\6\2\2\u0563"+ 21608 "\u055f\3\2\2\2\u0563\u0560\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0562\3\2"+ 21609 "\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0565\u0566\3\2\2\2\u0566"+ 21610 "\u0568\3\2\2\2\u0567\u0565\3\2\2\2\u0568\u0569\79\2\2\u0569]\3\2\2\2\u056a"+ 21611 "\u056b\7\7\2\2\u056b\u056c\7;\2\2\u056c\u0570\7J\2\2\u056d\u056f\t\2\2"+ 21612 "\2\u056e\u056d\3\2\2\2\u056f\u0572\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u0571"+ 21613 "\3\2\2\2\u0571\u0573\3\2\2\2\u0572\u0570\3\2\2\2\u0573\u0574\79\2\2\u0574"+ 21614 "_\3\2\2\2\u0575\u05a7\5\\/\2\u0576\u05a6\5\f\7\2\u0577\u05a6\5h\65\2\u0578"+ 21615 "\u05a6\5\22\n\2\u0579\u05a6\5\30\r\2\u057a\u05a6\5\36\20\2\u057b\u05a6"+ 21616 "\5$\23\2\u057c\u05a6\5*\26\2\u057d\u05a6\5\60\31\2\u057e\u05a6\5\66\34"+ 21617 "\2\u057f\u05a6\5<\37\2\u0580\u05a6\5B\"\2\u0581\u05a6\5H%\2\u0582\u05a6"+ 21618 "\5N(\2\u0583\u05a6\5T+\2\u0584\u05a6\5Z.\2\u0585\u05a6\5f\64\2\u0586\u05a6"+ 21619 "\5\u00a6T\2\u0587\u05a6\5\u00acW\2\u0588\u05a6\5\u00b2Z\2\u0589\u05a6"+ 21620 "\5\u00b8]\2\u058a\u05a6\5\u00be`\2\u058b\u05a6\5\16\b\2\u058c\u05a6\5"+ 21621 "\24\13\2\u058d\u05a6\5\32\16\2\u058e\u05a6\5 \21\2\u058f\u05a6\5&\24\2"+ 21622 "\u0590\u05a6\5,\27\2\u0591\u05a6\5\62\32\2\u0592\u05a6\58\35\2\u0593\u05a6"+ 21623 "\5> \2\u0594\u05a6\5D#\2\u0595\u05a6\5J&\2\u0596\u05a6\5P)\2\u0597\u05a6"+ 21624 "\5V,\2\u0598\u05a6\5b\62\2\u0599\u05a6\5\u00a2R\2\u059a\u05a6\5\u00a8"+ 21625 "U\2\u059b\u05a6\5\u00aeX\2\u059c\u05a6\5\u00b4[\2\u059d\u05a6\5\u00ba"+ 21626 "^\2\u059e\u059f\6\61\22\2\u059f\u05a6\7\3\2\2\u05a0\u05a6\5\u0094K\2\u05a1"+ 21627 "\u05a6\7\5\2\2\u05a2\u05a6\7\b\2\2\u05a3\u05a6\5\u0096L\2\u05a4\u05a6"+ 21628 "\5\u0092J\2\u05a5\u0576\3\2\2\2\u05a5\u0577\3\2\2\2\u05a5\u0578\3\2\2"+ 21629 "\2\u05a5\u0579\3\2\2\2\u05a5\u057a\3\2\2\2\u05a5\u057b\3\2\2\2\u05a5\u057c"+ 21630 "\3\2\2\2\u05a5\u057d\3\2\2\2\u05a5\u057e\3\2\2\2\u05a5\u057f\3\2\2\2\u05a5"+ 21631 "\u0580\3\2\2\2\u05a5\u0581\3\2\2\2\u05a5\u0582\3\2\2\2\u05a5\u0583\3\2"+ 21632 "\2\2\u05a5\u0584\3\2\2\2\u05a5\u0585\3\2\2\2\u05a5\u0586\3\2\2\2\u05a5"+ 21633 "\u0587\3\2\2\2\u05a5\u0588\3\2\2\2\u05a5\u0589\3\2\2\2\u05a5\u058a\3\2"+ 21634 "\2\2\u05a5\u058b\3\2\2\2\u05a5\u058c\3\2\2\2\u05a5\u058d\3\2\2\2\u05a5"+ 21635 "\u058e\3\2\2\2\u05a5\u058f\3\2\2\2\u05a5\u0590\3\2\2\2\u05a5\u0591\3\2"+ 21636 "\2\2\u05a5\u0592\3\2\2\2\u05a5\u0593\3\2\2\2\u05a5\u0594\3\2\2\2\u05a5"+ 21637 "\u0595\3\2\2\2\u05a5\u0596\3\2\2\2\u05a5\u0597\3\2\2\2\u05a5\u0598\3\2"+ 21638 "\2\2\u05a5\u0599\3\2\2\2\u05a5\u059a\3\2\2\2\u05a5\u059b\3\2\2\2\u05a5"+ 21639 "\u059c\3\2\2\2\u05a5\u059d\3\2\2\2\u05a5\u059e\3\2\2\2\u05a5\u05a0\3\2"+ 21640 "\2\2\u05a5\u05a1\3\2\2\2\u05a5\u05a2\3\2\2\2\u05a5\u05a3\3\2\2\2\u05a5"+ 21641 "\u05a4\3\2\2\2\u05a6\u05a9\3\2\2\2\u05a7\u05a5\3\2\2\2\u05a7\u05a8\3\2"+ 21642 "\2\2\u05a8\u05aa\3\2\2\2\u05a9\u05a7\3\2\2\2\u05aa\u05ab\5^\60\2\u05ab"+ 21643 "a\3\2\2\2\u05ac\u05ad\7\7\2\2\u05ad\u05b4\7K\2\2\u05ae\u05b3\5\n\6\2\u05af"+ 21644 "\u05b3\7\b\2\2\u05b0\u05b3\7\3\2\2\u05b1\u05b3\7\6\2\2\u05b2\u05ae\3\2"+ 21645 "\2\2\u05b2\u05af\3\2\2\2\u05b2\u05b0\3\2\2\2\u05b2\u05b1\3\2\2\2\u05b3"+ 21646 "\u05b6\3\2\2\2\u05b4\u05b2\3\2\2\2\u05b4\u05b5\3\2\2\2\u05b5\u05b7\3\2"+ 21647 "\2\2\u05b6\u05b4\3\2\2\2\u05b7\u05b8\79\2\2\u05b8c\3\2\2\2\u05b9\u05ba"+ 21648 "\7\7\2\2\u05ba\u05bb\7;\2\2\u05bb\u05bf\7K\2\2\u05bc\u05be\t\2\2\2\u05bd"+ 21649 "\u05bc\3\2\2\2\u05be\u05c1\3\2\2\2\u05bf\u05bd\3\2\2\2\u05bf\u05c0\3\2"+ 21650 "\2\2\u05c0\u05c2\3\2\2\2\u05c1\u05bf\3\2\2\2\u05c2\u05c3\79\2\2\u05c3"+ 21651 "e\3\2\2\2\u05c4\u05f6\5b\62\2\u05c5\u05f5\5\f\7\2\u05c6\u05f5\5h\65\2"+ 21652 "\u05c7\u05f5\5\22\n\2\u05c8\u05f5\5\30\r\2\u05c9\u05f5\5\36\20\2\u05ca"+ 21653 "\u05f5\5$\23\2\u05cb\u05f5\5*\26\2\u05cc\u05f5\5\60\31\2\u05cd\u05f5\5"+ 21654 "\66\34\2\u05ce\u05f5\5<\37\2\u05cf\u05f5\5B\"\2\u05d0\u05f5\5H%\2\u05d1"+ 21655 "\u05f5\5N(\2\u05d2\u05f5\5T+\2\u05d3\u05f5\5Z.\2\u05d4\u05f5\5`\61\2\u05d5"+ 21656 "\u05f5\5\u00a6T\2\u05d6\u05f5\5\u00acW\2\u05d7\u05f5\5\u00b2Z\2\u05d8"+ 21657 "\u05f5\5\u00b8]\2\u05d9\u05f5\5\u00be`\2\u05da\u05f5\5\16\b\2\u05db\u05f5"+ 21658 "\5\24\13\2\u05dc\u05f5\5\32\16\2\u05dd\u05f5\5 \21\2\u05de\u05f5\5&\24"+ 21659 "\2\u05df\u05f5\5,\27\2\u05e0\u05f5\5\62\32\2\u05e1\u05f5\58\35\2\u05e2"+ 21660 "\u05f5\5> \2\u05e3\u05f5\5D#\2\u05e4\u05f5\5J&\2\u05e5\u05f5\5P)\2\u05e6"+ 21661 "\u05f5\5V,\2\u05e7\u05f5\5\\/\2\u05e8\u05f5\5\u00a2R\2\u05e9\u05f5\5\u00a8"+ 21662 "U\2\u05ea\u05f5\5\u00aeX\2\u05eb\u05f5\5\u00b4[\2\u05ec\u05f5\5\u00ba"+ 21663 "^\2\u05ed\u05ee\6\64\23\2\u05ee\u05f5\7\3\2\2\u05ef\u05f5\5\u0094K\2\u05f0"+ 21664 "\u05f5\7\5\2\2\u05f1\u05f5\7\b\2\2\u05f2\u05f5\5\u0096L\2\u05f3\u05f5"+ 21665 "\5\u0092J\2\u05f4\u05c5\3\2\2\2\u05f4\u05c6\3\2\2\2\u05f4\u05c7\3\2\2"+ 21666 "\2\u05f4\u05c8\3\2\2\2\u05f4\u05c9\3\2\2\2\u05f4\u05ca\3\2\2\2\u05f4\u05cb"+ 21667 "\3\2\2\2\u05f4\u05cc\3\2\2\2\u05f4\u05cd\3\2\2\2\u05f4\u05ce\3\2\2\2\u05f4"+ 21668 "\u05cf\3\2\2\2\u05f4\u05d0\3\2\2\2\u05f4\u05d1\3\2\2\2\u05f4\u05d2\3\2"+ 21669 "\2\2\u05f4\u05d3\3\2\2\2\u05f4\u05d4\3\2\2\2\u05f4\u05d5\3\2\2\2\u05f4"+ 21670 "\u05d6\3\2\2\2\u05f4\u05d7\3\2\2\2\u05f4\u05d8\3\2\2\2\u05f4\u05d9\3\2"+ 21671 "\2\2\u05f4\u05da\3\2\2\2\u05f4\u05db\3\2\2\2\u05f4\u05dc\3\2\2\2\u05f4"+ 21672 "\u05dd\3\2\2\2\u05f4\u05de\3\2\2\2\u05f4\u05df\3\2\2\2\u05f4\u05e0\3\2"+ 21673 "\2\2\u05f4\u05e1\3\2\2\2\u05f4\u05e2\3\2\2\2\u05f4\u05e3\3\2\2\2\u05f4"+ 21674 "\u05e4\3\2\2\2\u05f4\u05e5\3\2\2\2\u05f4\u05e6\3\2\2\2\u05f4\u05e7\3\2"+ 21675 "\2\2\u05f4\u05e8\3\2\2\2\u05f4\u05e9\3\2\2\2\u05f4\u05ea\3\2\2\2\u05f4"+ 21676 "\u05eb\3\2\2\2\u05f4\u05ec\3\2\2\2\u05f4\u05ed\3\2\2\2\u05f4\u05ef\3\2"+ 21677 "\2\2\u05f4\u05f0\3\2\2\2\u05f4\u05f1\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4"+ 21678 "\u05f3\3\2\2\2\u05f5\u05f8\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f6\u05f7\3\2"+ 21679 "\2\2\u05f7\u05f9\3\2\2\2\u05f8\u05f6\3\2\2\2\u05f9\u05fa\5d\63\2\u05fa"+ 21680 "g\3\2\2\2\u05fb\u0610\5j\66\2\u05fc\u0610\5l\67\2\u05fd\u0610\5n8\2\u05fe"+ 21681 "\u0610\5p9\2\u05ff\u0610\5r:\2\u0600\u0610\5t;\2\u0601\u0610\5v<\2\u0602"+ 21682 "\u0610\5x=\2\u0603\u0610\5z>\2\u0604\u0610\5|?\2\u0605\u0610\5~@\2\u0606"+ 21683 "\u0610\5\u0080A\2\u0607\u0610\5\u0082B\2\u0608\u0610\5\u0084C\2\u0609"+ 21684 "\u0610\5\u0098M\2\u060a\u0610\5\u009aN\2\u060b\u0610\5\u009cO\2\u060c"+ 21685 "\u0610\5\u009eP\2\u060d\u0610\5\u00a0Q\2\u060e\u0610\5\u0086D\2\u060f"+ 21686 "\u05fb\3\2\2\2\u060f\u05fc\3\2\2\2\u060f\u05fd\3\2\2\2\u060f\u05fe\3\2"+ 21687 "\2\2\u060f\u05ff\3\2\2\2\u060f\u0600\3\2\2\2\u060f\u0601\3\2\2\2\u060f"+ 21688 "\u0602\3\2\2\2\u060f\u0603\3\2\2\2\u060f\u0604\3\2\2\2\u060f\u0605\3\2"+ 21689 "\2\2\u060f\u0606\3\2\2\2\u060f\u0607\3\2\2\2\u060f\u0608\3\2\2\2\u060f"+ 21690 "\u0609\3\2\2\2\u060f\u060a\3\2\2\2\u060f\u060b\3\2\2\2\u060f\u060c\3\2"+ 21691 "\2\2\u060f\u060d\3\2\2\2\u060f\u060e\3\2\2\2\u0610i\3\2\2\2\u0611\u0612"+ 21692 "\7\7\2\2\u0612\u0619\t\3\2\2\u0613\u0618\5\n\6\2\u0614\u0618\7\b\2\2\u0615"+ 21693 "\u0618\7\3\2\2\u0616\u0618\7\6\2\2\u0617\u0613\3\2\2\2\u0617\u0614\3\2"+ 21694 "\2\2\u0617\u0615\3\2\2\2\u0617\u0616\3\2\2\2\u0618\u061b\3\2\2\2\u0619"+ 21695 "\u0617\3\2\2\2\u0619\u061a\3\2\2\2\u061a\u061c\3\2\2\2\u061b\u0619\3\2"+ 21696 "\2\2\u061c\u061d\7:\2\2\u061dk\3\2\2\2\u061e\u061f\7\7\2\2\u061f\u0626"+ 21697 "\7L\2\2\u0620\u0625\5\n\6\2\u0621\u0625\7\b\2\2\u0622\u0625\7\3\2\2\u0623"+ 21698 "\u0625\7\6\2\2\u0624\u0620\3\2\2\2\u0624\u0621\3\2\2\2\u0624\u0622\3\2"+ 21699 "\2\2\u0624\u0623\3\2\2\2\u0625\u0628\3\2\2\2\u0626\u0624\3\2\2\2\u0626"+ 21700 "\u0627\3\2\2\2\u0627\u0629\3\2\2\2\u0628\u0626\3\2\2\2\u0629\u062a\t\4"+ 21701 "\2\2\u062am\3\2\2\2\u062b\u062c\7\7\2\2\u062c\u0633\7M\2\2\u062d\u0632"+ 21702 "\5\n\6\2\u062e\u0632\7\b\2\2\u062f\u0632\7\3\2\2\u0630\u0632\7\6\2\2\u0631"+ 21703 "\u062d\3\2\2\2\u0631\u062e\3\2\2\2\u0631\u062f\3\2\2\2\u0631\u0630\3\2"+ 21704 "\2\2\u0632\u0635\3\2\2\2\u0633\u0631\3\2\2\2\u0633\u0634\3\2\2\2\u0634"+ 21705 "\u0636\3\2\2\2\u0635\u0633\3\2\2\2\u0636\u0637\t\4\2\2\u0637o\3\2\2\2"+ 21706 "\u0638\u0639\7\7\2\2\u0639\u0640\7N\2\2\u063a\u063f\5\n\6\2\u063b\u063f"+ 21707 "\7\b\2\2\u063c\u063f\7\3\2\2\u063d\u063f\7\6\2\2\u063e\u063a\3\2\2\2\u063e"+ 21708 "\u063b\3\2\2\2\u063e\u063c\3\2\2\2\u063e\u063d\3\2\2\2\u063f\u0642\3\2"+ 21709 "\2\2\u0640\u063e\3\2\2\2\u0640\u0641\3\2\2\2\u0641\u0643\3\2\2\2\u0642"+ 21710 "\u0640\3\2\2\2\u0643\u0644\t\4\2\2\u0644q\3\2\2\2\u0645\u0646\7\7\2\2"+ 21711 "\u0646\u064d\7O\2\2\u0647\u064c\5\n\6\2\u0648\u064c\7\b\2\2\u0649\u064c"+ 21712 "\7\3\2\2\u064a\u064c\7\6\2\2\u064b\u0647\3\2\2\2\u064b\u0648\3\2\2\2\u064b"+ 21713 "\u0649\3\2\2\2\u064b\u064a\3\2\2\2\u064c\u064f\3\2\2\2\u064d\u064b\3\2"+ 21714 "\2\2\u064d\u064e\3\2\2\2\u064e\u0650\3\2\2\2\u064f\u064d\3\2\2\2\u0650"+ 21715 "\u0651\t\4\2\2\u0651s\3\2\2\2\u0652\u0653\7\7\2\2\u0653\u065a\7P\2\2\u0654"+ 21716 "\u0659\5\n\6\2\u0655\u0659\7\b\2\2\u0656\u0659\7\3\2\2\u0657\u0659\7\6"+ 21717 "\2\2\u0658\u0654\3\2\2\2\u0658\u0655\3\2\2\2\u0658\u0656\3\2\2\2\u0658"+ 21718 "\u0657\3\2\2\2\u0659\u065c\3\2\2\2\u065a\u0658\3\2\2\2\u065a\u065b\3\2"+ 21719 "\2\2\u065b\u065d\3\2\2\2\u065c\u065a\3\2\2\2\u065d\u065e\t\4\2\2\u065e"+ 21720 "u\3\2\2\2\u065f\u0660\7\7\2\2\u0660\u0667\7Q\2\2\u0661\u0666\5\n\6\2\u0662"+ 21721 "\u0666\7\b\2\2\u0663\u0666\7\3\2\2\u0664\u0666\7\6\2\2\u0665\u0661\3\2"+ 21722 "\2\2\u0665\u0662\3\2\2\2\u0665\u0663\3\2\2\2\u0665\u0664\3\2\2\2\u0666"+ 21723 "\u0669\3\2\2\2\u0667\u0665\3\2\2\2\u0667\u0668\3\2\2\2\u0668\u066a\3\2"+ 21724 "\2\2\u0669\u0667\3\2\2\2\u066a\u066b\t\4\2\2\u066bw\3\2\2\2\u066c\u066d"+ 21725 "\7\7\2\2\u066d\u0674\7R\2\2\u066e\u0673\5\n\6\2\u066f\u0673\7\b\2\2\u0670"+ 21726 "\u0673\7\3\2\2\u0671\u0673\7\6\2\2\u0672\u066e\3\2\2\2\u0672\u066f\3\2"+ 21727 "\2\2\u0672\u0670\3\2\2\2\u0672\u0671\3\2\2\2\u0673\u0676\3\2\2\2\u0674"+ 21728 "\u0672\3\2\2\2\u0674\u0675\3\2\2\2\u0675\u0677\3\2\2\2\u0676\u0674\3\2"+ 21729 "\2\2\u0677\u0678\t\4\2\2\u0678y\3\2\2\2\u0679\u067a\7\7\2\2\u067a\u0681"+ 21730 "\7S\2\2\u067b\u0680\5\n\6\2\u067c\u0680\7\b\2\2\u067d\u0680\7\3\2\2\u067e"+ 21731 "\u0680\7\6\2\2\u067f\u067b\3\2\2\2\u067f\u067c\3\2\2\2\u067f\u067d\3\2"+ 21732 "\2\2\u067f\u067e\3\2\2\2\u0680\u0683\3\2\2\2\u0681\u067f\3\2\2\2\u0681"+ 21733 "\u0682\3\2\2\2\u0682\u0684\3\2\2\2\u0683\u0681\3\2\2\2\u0684\u0685\t\4"+ 21734 "\2\2\u0685{\3\2\2\2\u0686\u0687\7\7\2\2\u0687\u068e\7T\2\2\u0688\u068d"+ 21735 "\5\n\6\2\u0689\u068d\7\b\2\2\u068a\u068d\7\3\2\2\u068b\u068d\7\6\2\2\u068c"+ 21736 "\u0688\3\2\2\2\u068c\u0689\3\2\2\2\u068c\u068a\3\2\2\2\u068c\u068b\3\2"+ 21737 "\2\2\u068d\u0690\3\2\2\2\u068e\u068c\3\2\2\2\u068e\u068f\3\2\2\2\u068f"+ 21738 "\u0691\3\2\2\2\u0690\u068e\3\2\2\2\u0691\u0692\t\4\2\2\u0692}\3\2\2\2"+ 21739 "\u0693\u0694\7\7\2\2\u0694\u069b\7U\2\2\u0695\u069a\5\n\6\2\u0696\u069a"+ 21740 "\7\b\2\2\u0697\u069a\7\3\2\2\u0698\u069a\7\6\2\2\u0699\u0695\3\2\2\2\u0699"+ 21741 "\u0696\3\2\2\2\u0699\u0697\3\2\2\2\u0699\u0698\3\2\2\2\u069a\u069d\3\2"+ 21742 "\2\2\u069b\u0699\3\2\2\2\u069b\u069c\3\2\2\2\u069c\u069e\3\2\2\2\u069d"+ 21743 "\u069b\3\2\2\2\u069e\u069f\t\4\2\2\u069f\177\3\2\2\2\u06a0\u06a1\7\7\2"+ 21744 "\2\u06a1\u06a8\7V\2\2\u06a2\u06a7\5\n\6\2\u06a3\u06a7\7\b\2\2\u06a4\u06a7"+ 21745 "\7\3\2\2\u06a5\u06a7\7\6\2\2\u06a6\u06a2\3\2\2\2\u06a6\u06a3\3\2\2\2\u06a6"+ 21746 "\u06a4\3\2\2\2\u06a6\u06a5\3\2\2\2\u06a7\u06aa\3\2\2\2\u06a8\u06a6\3\2"+ 21747 "\2\2\u06a8\u06a9\3\2\2\2\u06a9\u06ab\3\2\2\2\u06aa\u06a8\3\2\2\2\u06ab"+ 21748 "\u06ac\t\4\2\2\u06ac\u0081\3\2\2\2\u06ad\u06ae\7\7\2\2\u06ae\u06b5\7W"+ 21749 "\2\2\u06af\u06b4\5\n\6\2\u06b0\u06b4\7\b\2\2\u06b1\u06b4\7\3\2\2\u06b2"+ 21750 "\u06b4\7\6\2\2\u06b3\u06af\3\2\2\2\u06b3\u06b0\3\2\2\2\u06b3\u06b1\3\2"+ 21751 "\2\2\u06b3\u06b2\3\2\2\2\u06b4\u06b7\3\2\2\2\u06b5\u06b3\3\2\2\2\u06b5"+ 21752 "\u06b6\3\2\2\2\u06b6\u06b8\3\2\2\2\u06b7\u06b5\3\2\2\2\u06b8\u06b9\t\4"+ 21753 "\2\2\u06b9\u0083\3\2\2\2\u06ba\u06bb\7\7\2\2\u06bb\u06c2\7X\2\2\u06bc"+ 21754 "\u06c1\5\n\6\2\u06bd\u06c1\7\b\2\2\u06be\u06c1\7\3\2\2\u06bf\u06c1\7\6"+ 21755 "\2\2\u06c0\u06bc\3\2\2\2\u06c0\u06bd\3\2\2\2\u06c0\u06be\3\2\2\2\u06c0"+ 21756 "\u06bf\3\2\2\2\u06c1\u06c4\3\2\2\2\u06c2\u06c0\3\2\2\2\u06c2\u06c3\3\2"+ 21757 "\2\2\u06c3\u06c5\3\2\2\2\u06c4\u06c2\3\2\2\2\u06c5\u06c6\t\4\2\2\u06c6"+ 21758 "\u0085\3\2\2\2\u06c7\u06c8\7\7\2\2\u06c8\u06c9\7;\2\2\u06c9\u06ca\5\u0088"+ 21759 "E\2\u06ca\u06cb\79\2\2\u06cb\u06cc\bD\1\2\u06cc\u0087\3\2\2\2\u06cd\u06ce"+ 21760 "\t\5\2\2\u06ce\u0089\3\2\2\2\u06cf\u06d0\6F\24\2\u06d0\u06d8\7\3\2\2\u06d1"+ 21761 "\u06d8\5\u0094K\2\u06d2\u06d8\7\5\2\2\u06d3\u06d8\7\b\2\2\u06d4\u06d8"+ 21762 "\5\u0096L\2\u06d5\u06d8\5\u0092J\2\u06d6\u06d8\5\4\3\2\u06d7\u06cf\3\2"+ 21763 "\2\2\u06d7\u06d1\3\2\2\2\u06d7\u06d2\3\2\2\2\u06d7\u06d3\3\2\2\2\u06d7"+ 21764 "\u06d4\3\2\2\2\u06d7\u06d5\3\2\2\2\u06d7\u06d6\3\2\2\2\u06d8\u06d9\3\2"+ 21765 "\2\2\u06d9\u06d7\3\2\2\2\u06d9\u06da\3\2\2\2\u06da\u008b\3\2\2\2\u06db"+ 21766 "\u06e1\7\36\2\2\u06dc\u06dd\7 \2\2\u06dd\u06df\7#\2\2\u06de\u06e0\5\u008e"+ 21767 "H\2\u06df\u06de\3\2\2\2\u06df\u06e0\3\2\2\2\u06e0\u06e2\3\2\2\2\u06e1"+ 21768 "\u06dc\3\2\2\2\u06e1\u06e2\3\2\2\2\u06e2\u06e9\3\2\2\2\u06e3\u06e4\7 "+ 21769 "\2\2\u06e4\u06e6\7#\2\2\u06e5\u06e7\5\u008eH\2\u06e6\u06e5\3\2\2\2\u06e6"+ 21770 "\u06e7\3\2\2\2\u06e7\u06e9\3\2\2\2\u06e8\u06db\3\2\2\2\u06e8\u06e3\3\2"+ 21771 "\2\2\u06e9\u008d\3\2\2\2\u06ea\u06ee\7$\2\2\u06eb\u06ed\t\6\2\2\u06ec"+ 21772 "\u06eb\3\2\2\2\u06ed\u06f0\3\2\2\2\u06ee\u06ec\3\2\2\2\u06ee\u06ef\3\2"+ 21773 "\2\2\u06ef\u06f1\3\2\2\2\u06f0\u06ee\3\2\2\2\u06f1\u06f2\7%\2\2\u06f2"+ 21774 "\u008f\3\2\2\2\u06f3\u06f5\7\t\2\2\u06f4\u06f6\t\7\2\2\u06f5\u06f4\3\2"+ 21775 "\2\2\u06f6\u06f7\3\2\2\2\u06f7\u06f5\3\2\2\2\u06f7\u06f8\3\2\2\2\u06f8"+ 21776 "\u06f9\3\2\2\2\u06f9\u07b7\5\u008aF\2\u06fa\u06fe\7\n\2\2\u06fb\u06fd"+ 21777 "\t\7\2\2\u06fc\u06fb\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3\2\2\2\u06fe"+ 21778 "\u06ff\3\2\2\2\u06ff\u0703\3\2\2\2\u0700\u06fe\3\2\2\2\u0701\u0702\t\7"+ 21779 "\2\2\u0702\u0704\5\u008aF\2\u0703\u0701\3\2\2\2\u0703\u0704\3\2\2\2\u0704"+ 21780 "\u07b7\3\2\2\2\u0705\u070a\7\13\2\2\u0706\u070b\7\6\2\2\u0707\u070b\7"+ 21781 "\b\2\2\u0708\u0709\6I\25\2\u0709\u070b\7\3\2\2\u070a\u0706\3\2\2\2\u070a"+ 21782 "\u0707\3\2\2\2\u070a\u0708\3\2\2\2\u070b\u070c\3\2\2\2\u070c\u070a\3\2"+ 21783 "\2\2\u070c\u070d\3\2\2\2\u070d\u070e\3\2\2\2\u070e\u0712\7-\2\2\u070f"+ 21784 "\u0711\t\7\2\2\u0710\u070f\3\2\2\2\u0711\u0714\3\2\2\2\u0712\u0710\3\2"+ 21785 "\2\2\u0712\u0713\3\2\2\2\u0713\u0717\3\2\2\2\u0714\u0712\3\2\2\2\u0715"+ 21786 "\u0716\t\7\2\2\u0716\u0718\5\u008aF\2\u0717\u0715\3\2\2\2\u0717\u0718"+ 21787 "\3\2\2\2\u0718\u07b7\3\2\2\2\u0719\u071e\7\f\2\2\u071a\u071f\7\6\2\2\u071b"+ 21788 "\u071f\7\b\2\2\u071c\u071d\6I\26\2\u071d\u071f\7\3\2\2\u071e\u071a\3\2"+ 21789 "\2\2\u071e\u071b\3\2\2\2\u071e\u071c\3\2\2\2\u071f\u0720\3\2\2\2\u0720"+ 21790 "\u071e\3\2\2\2\u0720\u0721\3\2\2\2\u0721\u0722\3\2\2\2\u0722\u0726\7\33"+ 21791 "\2\2\u0723\u0725\t\7\2\2\u0724\u0723\3\2\2\2\u0725\u0728\3\2\2\2\u0726"+ 21792 "\u0724\3\2\2\2\u0726\u0727\3\2\2\2\u0727\u072b\3\2\2\2\u0728\u0726\3\2"+ 21793 "\2\2\u0729\u072a\t\7\2\2\u072a\u072c\5\u008aF\2\u072b\u0729\3\2\2\2\u072b"+ 21794 "\u072c\3\2\2\2\u072c\u07b7\3\2\2\2\u072d\u072f\7\r\2\2\u072e\u0730\t\7"+ 21795 "\2\2\u072f\u072e\3\2\2\2\u0730\u0731\3\2\2\2\u0731\u072f\3\2\2\2\u0731"+ 21796 "\u0732\3\2\2\2\u0732\u0733\3\2\2\2\u0733\u07b7\5\u008aF\2\u0734\u0739"+ 21797 "\7\16\2\2\u0735\u073a\7\6\2\2\u0736\u073a\7\b\2\2\u0737\u0738\6I\27\2"+ 21798 "\u0738\u073a\7\3\2\2\u0739\u0735\3\2\2\2\u0739\u0736\3\2\2\2\u0739\u0737"+ 21799 "\3\2\2\2\u073a\u073b\3\2\2\2\u073b\u0739\3\2\2\2\u073b\u073c\3\2\2\2\u073c"+ 21800 "\u0740\3\2\2\2\u073d\u0741\5\u008cG\2\u073e\u0741\7\35\2\2\u073f\u0741"+ 21801 "\5\4\3\2\u0740\u073d\3\2\2\2\u0740\u073e\3\2\2\2\u0740\u073f\3\2\2\2\u0741"+ 21802 "\u0745\3\2\2\2\u0742\u0744\t\7\2\2\u0743\u0742\3\2\2\2\u0744\u0747\3\2"+ 21803 "\2\2\u0745\u0743\3\2\2\2\u0745\u0746\3\2\2\2\u0746\u074a\3\2\2\2\u0747"+ 21804 "\u0745\3\2\2\2\u0748\u0749\t\7\2\2\u0749\u074b\5\u008aF\2\u074a\u0748"+ 21805 "\3\2\2\2\u074a\u074b\3\2\2\2\u074b\u07b7\3\2\2\2\u074c\u0750\7\17\2\2"+ 21806 "\u074d\u074f\t\7\2\2\u074e\u074d\3\2\2\2\u074f\u0752\3\2\2\2\u0750\u074e"+ 21807 "\3\2\2\2\u0750\u0751\3\2\2\2\u0751"; 21808 private static final String _serializedATNSegment1 = 21809 "\u0757\3\2\2\2\u0752\u0750\3\2\2\2\u0753\u0754\t\7\2\2\u0754\u0758\5\u008a"+ 21810 "F\2\u0755\u0758\7\30\2\2\u0756\u0758\7\31\2\2\u0757\u0753\3\2\2\2\u0757"+ 21811 "\u0755\3\2\2\2\u0757\u0756\3\2\2\2\u0757\u0758\3\2\2\2\u0758\u075c\3\2"+ 21812 "\2\2\u0759\u075b\t\7\2\2\u075a\u0759\3\2\2\2\u075b\u075e\3\2\2\2\u075c"+ 21813 "\u075a\3\2\2\2\u075c\u075d\3\2\2\2\u075d\u07b7\3\2\2\2\u075e\u075c\3\2"+ 21814 "\2\2\u075f\u0763\7\21\2\2\u0760\u0762\t\7\2\2\u0761\u0760\3\2\2\2\u0762"+ 21815 "\u0765\3\2\2\2\u0763\u0761\3\2\2\2\u0763\u0764\3\2\2\2\u0764\u0768\3\2"+ 21816 "\2\2\u0765\u0763\3\2\2\2\u0766\u0767\t\7\2\2\u0767\u0769\5\u008aF\2\u0768"+ 21817 "\u0766\3\2\2\2\u0768\u0769\3\2\2\2\u0769\u07b7\3\2\2\2\u076a\u076e\7\20"+ 21818 "\2\2\u076b\u076d\t\7\2\2\u076c\u076b\3\2\2\2\u076d\u0770\3\2\2\2\u076e"+ 21819 "\u076c\3\2\2\2\u076e\u076f\3\2\2\2\u076f\u0773\3\2\2\2\u0770\u076e\3\2"+ 21820 "\2\2\u0771\u0772\t\7\2\2\u0772\u0774\7)\2\2\u0773\u0771\3\2\2\2\u0773"+ 21821 "\u0774\3\2\2\2\u0774\u0778\3\2\2\2\u0775\u0777\t\7\2\2\u0776\u0775\3\2"+ 21822 "\2\2\u0777\u077a\3\2\2\2\u0778\u0776\3\2\2\2\u0778\u0779\3\2\2\2\u0779"+ 21823 "\u077d\3\2\2\2\u077a\u0778\3\2\2\2\u077b\u077c\t\7\2\2\u077c\u077e\7+"+ 21824 "\2\2\u077d\u077b\3\2\2\2\u077d\u077e\3\2\2\2\u077e\u0782\3\2\2\2\u077f"+ 21825 "\u0781\t\7\2\2\u0780\u077f\3\2\2\2\u0781\u0784\3\2\2\2\u0782\u0780\3\2"+ 21826 "\2\2\u0782\u0783\3\2\2\2\u0783\u0787\3\2\2\2\u0784\u0782\3\2\2\2\u0785"+ 21827 "\u0786\t\7\2\2\u0786\u0788\5\u008aF\2\u0787\u0785\3\2\2\2\u0787\u0788"+ 21828 "\3\2\2\2\u0788\u07b7\3\2\2\2\u0789\u078b\7\22\2\2\u078a\u078c\t\7\2\2"+ 21829 "\u078b\u078a\3\2\2\2\u078c\u078d\3\2\2\2\u078d\u078b\3\2\2\2\u078d\u078e"+ 21830 "\3\2\2\2\u078e\u078f\3\2\2\2\u078f\u07b7\5\u008aF\2\u0790\u0795\7\23\2"+ 21831 "\2\u0791\u0796\7\6\2\2\u0792\u0796\7\b\2\2\u0793\u0794\6I\30\2\u0794\u0796"+ 21832 "\7\3\2\2\u0795\u0791\3\2\2\2\u0795\u0792\3\2\2\2\u0795\u0793\3\2\2\2\u0796"+ 21833 "\u0797\3\2\2\2\u0797\u0795\3\2\2\2\u0797\u0798\3\2\2\2\u0798\u0799\3\2"+ 21834 "\2\2\u0799\u079d\7-\2\2\u079a\u079c\t\7\2\2\u079b\u079a\3\2\2\2\u079c"+ 21835 "\u079f\3\2\2\2\u079d\u079b\3\2\2\2\u079d\u079e\3\2\2\2\u079e\u07a2\3\2"+ 21836 "\2\2\u079f\u079d\3\2\2\2\u07a0\u07a1\t\7\2\2\u07a1\u07a3\5\u008aF\2\u07a2"+ 21837 "\u07a0\3\2\2\2\u07a2\u07a3\3\2\2\2\u07a3\u07b7\3\2\2\2\u07a4\u07a6\7\24"+ 21838 "\2\2\u07a5\u07a7\t\7\2\2\u07a6\u07a5\3\2\2\2\u07a7\u07a8\3\2\2\2\u07a8"+ 21839 "\u07a6\3\2\2\2\u07a8\u07a9\3\2\2\2\u07a9\u07aa\3\2\2\2\u07aa\u07b7\5\u008a"+ 21840 "F\2\u07ab\u07af\7\27\2\2\u07ac\u07ae\t\7\2\2\u07ad\u07ac\3\2\2\2\u07ae"+ 21841 "\u07b1\3\2\2\2\u07af\u07ad\3\2\2\2\u07af\u07b0\3\2\2\2\u07b0\u07b4\3\2"+ 21842 "\2\2\u07b1\u07af\3\2\2\2\u07b2\u07b3\t\7\2\2\u07b3\u07b5\5\u008aF\2\u07b4"+ 21843 "\u07b2\3\2\2\2\u07b4\u07b5\3\2\2\2\u07b5\u07b7\3\2\2\2\u07b6\u06f3\3\2"+ 21844 "\2\2\u07b6\u06fa\3\2\2\2\u07b6\u0705\3\2\2\2\u07b6\u0719\3\2\2\2\u07b6"+ 21845 "\u072d\3\2\2\2\u07b6\u0734\3\2\2\2\u07b6\u074c\3\2\2\2\u07b6\u075f\3\2"+ 21846 "\2\2\u07b6\u076a\3\2\2\2\u07b6\u0789\3\2\2\2\u07b6\u0790\3\2\2\2\u07b6"+ 21847 "\u07a4\3\2\2\2\u07b6\u07ab\3\2\2\2\u07b7\u0091\3\2\2\2\u07b8\u0813\7\25"+ 21848 "\2\2\u07b9\u07c0\7/\2\2\u07ba\u07bf\7\6\2\2\u07bb\u07bf\7\b\2\2\u07bc"+ 21849 "\u07bf\7\3\2\2\u07bd\u07bf\5\u0096L\2\u07be\u07ba\3\2\2\2\u07be\u07bb"+ 21850 "\3\2\2\2\u07be\u07bc\3\2\2\2\u07be\u07bd\3\2\2\2\u07bf\u07c2\3\2\2\2\u07c0"+ 21851 "\u07be\3\2\2\2\u07c0\u07c1\3\2\2\2\u07c1\u0814\3\2\2\2\u07c2\u07c0\3\2"+ 21852 "\2\2\u07c3\u07c7\7\60\2\2\u07c4\u07c6\t\2\2\2\u07c5\u07c4\3\2\2\2\u07c6"+ 21853 "\u07c9\3\2\2\2\u07c7\u07c5\3\2\2\2\u07c7\u07c8\3\2\2\2\u07c8\u0814\3\2"+ 21854 "\2\2\u07c9\u07c7\3\2\2\2\u07ca\u07ce\7\61\2\2\u07cb\u07cd\t\2\2\2\u07cc"+ 21855 "\u07cb\3\2\2\2\u07cd\u07d0\3\2\2\2\u07ce\u07cc\3\2\2\2\u07ce\u07cf\3\2"+ 21856 "\2\2\u07cf\u0814\3\2\2\2\u07d0\u07ce\3\2\2\2\u07d1\u07d3\7\62\2\2\u07d2"+ 21857 "\u07d4\t\2\2\2\u07d3\u07d2\3\2\2\2\u07d4\u07d5\3\2\2\2\u07d5\u07d3\3\2"+ 21858 "\2\2\u07d5\u07d6\3\2\2\2\u07d6\u07d7\3\2\2\2\u07d7\u07db\5\u008cG\2\u07d8"+ 21859 "\u07da\t\7\2\2\u07d9\u07d8\3\2\2\2\u07da\u07dd\3\2\2\2\u07db\u07d9\3\2"+ 21860 "\2\2\u07db\u07dc\3\2\2\2\u07dc\u07e0\3\2\2\2\u07dd\u07db\3\2\2\2\u07de"+ 21861 "\u07df\t\7\2\2\u07df\u07e1\5\u008aF\2\u07e0\u07de\3\2\2\2\u07e0\u07e1"+ 21862 "\3\2\2\2\u07e1\u0814\3\2\2\2\u07e2\u07e4\7\63\2\2\u07e3\u07e5\t\2\2\2"+ 21863 "\u07e4\u07e3\3\2\2\2\u07e5\u07e6\3\2\2\2\u07e6\u07e4\3\2\2\2\u07e6\u07e7"+ 21864 "\3\2\2\2\u07e7\u07e8\3\2\2\2\u07e8\u07ec\5\u008cG\2\u07e9\u07eb\t\7\2"+ 21865 "\2\u07ea\u07e9\3\2\2\2\u07eb\u07ee\3\2\2\2\u07ec\u07ea\3\2\2\2\u07ec\u07ed"+ 21866 "\3\2\2\2\u07ed\u07f1\3\2\2\2\u07ee\u07ec\3\2\2\2\u07ef\u07f0\t\7\2\2\u07f0"+ 21867 "\u07f2\5\u008aF\2\u07f1\u07ef\3\2\2\2\u07f1\u07f2\3\2\2\2\u07f2\u0814"+ 21868 "\3\2\2\2\u07f3\u07fa\7\64\2\2\u07f4\u07f9\7\6\2\2\u07f5\u07f9\7\b\2\2"+ 21869 "\u07f6\u07f9\7\3\2\2\u07f7\u07f9\5\u0096L\2\u07f8\u07f4\3\2\2\2\u07f8"+ 21870 "\u07f5\3\2\2\2\u07f8\u07f6\3\2\2\2\u07f8\u07f7\3\2\2\2\u07f9\u07fc\3\2"+ 21871 "\2\2\u07fa\u07f8\3\2\2\2\u07fa\u07fb\3\2\2\2\u07fb\u0814\3\2\2\2\u07fc"+ 21872 "\u07fa\3\2\2\2\u07fd\u0801\7\65\2\2\u07fe\u0800\t\2\2\2\u07ff\u07fe\3"+ 21873 "\2\2\2\u0800\u0803\3\2\2\2\u0801\u07ff\3\2\2\2\u0801\u0802\3\2\2\2\u0802"+ 21874 "\u0806\3\2\2\2\u0803\u0801\3\2\2\2\u0804\u0805\t\7\2\2\u0805\u0807\5\u008c"+ 21875 "G\2\u0806\u0804\3\2\2\2\u0806\u0807\3\2\2\2\u0807\u0814\3\2\2\2\u0808"+ 21876 "\u080c\7\27\2\2\u0809\u080b\t\2\2\2\u080a\u0809\3\2\2\2\u080b\u080e\3"+ 21877 "\2\2\2\u080c\u080a\3\2\2\2\u080c\u080d\3\2\2\2\u080d\u0811\3\2\2\2\u080e"+ 21878 "\u080c\3\2\2\2\u080f\u0810\t\7\2\2\u0810\u0812\5\u008aF\2\u0811\u080f"+ 21879 "\3\2\2\2\u0811\u0812\3\2\2\2\u0812\u0814\3\2\2\2\u0813\u07b9\3\2\2\2\u0813"+ 21880 "\u07c3\3\2\2\2\u0813\u07ca\3\2\2\2\u0813\u07d1\3\2\2\2\u0813\u07e2\3\2"+ 21881 "\2\2\u0813\u07f3\3\2\2\2\u0813\u07fd\3\2\2\2\u0813\u0808\3\2\2\2\u0814"+ 21882 "\u0815\3\2\2\2\u0815\u0816\7\26\2\2\u0816\u0093\3\2\2\2\u0817\u081d\7"+ 21883 "\4\2\2\u0818\u081c\5\u0096L\2\u0819\u081c\7\b\2\2\u081a\u081c\7\3\2\2"+ 21884 "\u081b\u0818\3\2\2\2\u081b\u0819\3\2\2\2\u081b\u081a\3\2\2\2\u081c\u081f"+ 21885 "\3\2\2\2\u081d\u081b\3\2\2\2\u081d\u081e\3\2\2\2\u081e\u0820\3\2\2\2\u081f"+ 21886 "\u081d\3\2\2\2\u0820\u0821\7]\2\2\u0821\u0095\3\2\2\2\u0822\u0823\t\b"+ 21887 "\2\2\u0823\u0825\bL\1\2\u0824\u0822\3\2\2\2\u0825\u0826\3\2\2\2\u0826"+ 21888 "\u0824\3\2\2\2\u0826\u0827\3\2\2\2\u0827\u0097\3\2\2\2\u0828\u0829\7\7"+ 21889 "\2\2\u0829\u0830\7Y\2\2\u082a\u082f\5\n\6\2\u082b\u082f\7\b\2\2\u082c"+ 21890 "\u082f\7\3\2\2\u082d\u082f\7\6\2\2\u082e\u082a\3\2\2\2\u082e\u082b\3\2"+ 21891 "\2\2\u082e\u082c\3\2\2\2\u082e\u082d\3\2\2\2\u082f\u0832\3\2\2\2\u0830"+ 21892 "\u082e\3\2\2\2\u0830\u0831\3\2\2\2\u0831\u0833\3\2\2\2\u0832\u0830\3\2"+ 21893 "\2\2\u0833\u0834\t\4\2\2\u0834\u0099\3\2\2\2\u0835\u0836\7\7\2\2\u0836"+ 21894 "\u083d\7Z\2\2\u0837\u083c\5\n\6\2\u0838\u083c\7\b\2\2\u0839\u083c\7\3"+ 21895 "\2\2\u083a\u083c\7\6\2\2\u083b\u0837\3\2\2\2\u083b\u0838\3\2\2\2\u083b"+ 21896 "\u0839\3\2\2\2\u083b\u083a\3\2\2\2\u083c\u083f\3\2\2\2\u083d\u083b\3\2"+ 21897 "\2\2\u083d\u083e\3\2\2\2\u083e\u0840\3\2\2\2\u083f\u083d\3\2\2\2\u0840"+ 21898 "\u0841\t\4\2\2\u0841\u009b\3\2\2\2\u0842\u0843\7\7\2\2\u0843\u084a\7^"+ 21899 "\2\2\u0844\u0849\5\n\6\2\u0845\u0849\7\b\2\2\u0846\u0849\7\3\2\2\u0847"+ 21900 "\u0849\7\6\2\2\u0848\u0844\3\2\2\2\u0848\u0845\3\2\2\2\u0848\u0846\3\2"+ 21901 "\2\2\u0848\u0847\3\2\2\2\u0849\u084c\3\2\2\2\u084a\u0848\3\2\2\2\u084a"+ 21902 "\u084b\3\2\2\2\u084b\u084d\3\2\2\2\u084c\u084a\3\2\2\2\u084d\u084e\t\4"+ 21903 "\2\2\u084e\u009d\3\2\2\2\u084f\u0850\7\7\2\2\u0850\u0857\7_\2\2\u0851"+ 21904 "\u0856\5\n\6\2\u0852\u0856\7\b\2\2\u0853\u0856\7\3\2\2\u0854\u0856\7\6"+ 21905 "\2\2\u0855\u0851\3\2\2\2\u0855\u0852\3\2\2\2\u0855\u0853\3\2\2\2\u0855"+ 21906 "\u0854\3\2\2\2\u0856\u0859\3\2\2\2\u0857\u0855\3\2\2\2\u0857\u0858\3\2"+ 21907 "\2\2\u0858\u085a\3\2\2\2\u0859\u0857\3\2\2\2\u085a\u085b\t\4\2\2\u085b"+ 21908 "\u009f\3\2\2\2\u085c\u085d\7\7\2\2\u085d\u0864\7`\2\2\u085e\u0863\5\n"+ 21909 "\6\2\u085f\u0863\7\b\2\2\u0860\u0863\7\3\2\2\u0861\u0863\7\6\2\2\u0862"+ 21910 "\u085e\3\2\2\2\u0862\u085f\3\2\2\2\u0862\u0860\3\2\2\2\u0862\u0861\3\2"+ 21911 "\2\2\u0863\u0866\3\2\2\2\u0864\u0862\3\2\2\2\u0864\u0865\3\2\2\2\u0865"+ 21912 "\u0867\3\2\2\2\u0866\u0864\3\2\2\2\u0867\u0868\t\4\2\2\u0868\u00a1\3\2"+ 21913 "\2\2\u0869\u086a\7\7\2\2\u086a\u0871\7a\2\2\u086b\u0870\5\n\6\2\u086c"+ 21914 "\u0870\7\b\2\2\u086d\u0870\7\3\2\2\u086e\u0870\7\6\2\2\u086f\u086b\3\2"+ 21915 "\2\2\u086f\u086c\3\2\2\2\u086f\u086d\3\2\2\2\u086f\u086e\3\2\2\2\u0870"+ 21916 "\u0873\3\2\2\2\u0871\u086f\3\2\2\2\u0871\u0872\3\2\2\2\u0872\u0874\3\2"+ 21917 "\2\2\u0873\u0871\3\2\2\2\u0874\u0875\79\2\2\u0875\u00a3\3\2\2\2\u0876"+ 21918 "\u0877\7\7\2\2\u0877\u0878\7;\2\2\u0878\u087c\7a\2\2\u0879\u087b\t\2\2"+ 21919 "\2\u087a\u0879\3\2\2\2\u087b\u087e\3\2\2\2\u087c\u087a\3\2\2\2\u087c\u087d"+ 21920 "\3\2\2\2\u087d\u087f\3\2\2\2\u087e\u087c\3\2\2\2\u087f\u0880\79\2\2\u0880"+ 21921 "\u00a5\3\2\2\2\u0881\u08a9\5\u00a2R\2\u0882\u08a8\5\f\7\2\u0883\u08a8"+ 21922 "\5h\65\2\u0884\u08a8\5\22\n\2\u0885\u08a8\5\30\r\2\u0886\u08a8\5\36\20"+ 21923 "\2\u0887\u08a8\5$\23\2\u0888\u08a8\5*\26\2\u0889\u08a8\5\60\31\2\u088a"+ 21924 "\u08a8\5\66\34\2\u088b\u08a8\5<\37\2\u088c\u08a8\5B\"\2\u088d\u08a8\5"+ 21925 "H%\2\u088e\u08a8\5N(\2\u088f\u08a8\5T+\2\u0890\u08a8\5Z.\2\u0891\u08a8"+ 21926 "\5`\61\2\u0892\u08a8\5\16\b\2\u0893\u08a8\5\24\13\2\u0894\u08a8\5\32\16"+ 21927 "\2\u0895\u08a8\5 \21\2\u0896\u08a8\5&\24\2\u0897\u08a8\5,\27\2\u0898\u08a8"+ 21928 "\5\62\32\2\u0899\u08a8\58\35\2\u089a\u08a8\5> \2\u089b\u08a8\5D#\2\u089c"+ 21929 "\u08a8\5J&\2\u089d\u08a8\5P)\2\u089e\u08a8\5V,\2\u089f\u08a8\5\\/\2\u08a0"+ 21930 "\u08a1\6T\31\2\u08a1\u08a8\7\3\2\2\u08a2\u08a8\5\u0094K\2\u08a3\u08a8"+ 21931 "\7\5\2\2\u08a4\u08a8\7\b\2\2\u08a5\u08a8\5\u0096L\2\u08a6\u08a8\5\u0092"+ 21932 "J\2\u08a7\u0882\3\2\2\2\u08a7\u0883\3\2\2\2\u08a7\u0884\3\2\2\2\u08a7"+ 21933 "\u0885\3\2\2\2\u08a7\u0886\3\2\2\2\u08a7\u0887\3\2\2\2\u08a7\u0888\3\2"+ 21934 "\2\2\u08a7\u0889\3\2\2\2\u08a7\u088a\3\2\2\2\u08a7\u088b\3\2\2\2\u08a7"+ 21935 "\u088c\3\2\2\2\u08a7\u088d\3\2\2\2\u08a7\u088e\3\2\2\2\u08a7\u088f\3\2"+ 21936 "\2\2\u08a7\u0890\3\2\2\2\u08a7\u0891\3\2\2\2\u08a7\u0892\3\2\2\2\u08a7"+ 21937 "\u0893\3\2\2\2\u08a7\u0894\3\2\2\2\u08a7\u0895\3\2\2\2\u08a7\u0896\3\2"+ 21938 "\2\2\u08a7\u0897\3\2\2\2\u08a7\u0898\3\2\2\2\u08a7\u0899\3\2\2\2\u08a7"+ 21939 "\u089a\3\2\2\2\u08a7\u089b\3\2\2\2\u08a7\u089c\3\2\2\2\u08a7\u089d\3\2"+ 21940 "\2\2\u08a7\u089e\3\2\2\2\u08a7\u089f\3\2\2\2\u08a7\u08a0\3\2\2\2\u08a7"+ 21941 "\u08a2\3\2\2\2\u08a7\u08a3\3\2\2\2\u08a7\u08a4\3\2\2\2\u08a7\u08a5\3\2"+ 21942 "\2\2\u08a7\u08a6\3\2\2\2\u08a8\u08ab\3\2\2\2\u08a9\u08a7\3\2\2\2\u08a9"+ 21943 "\u08aa\3\2\2\2\u08aa\u08ac\3\2\2\2\u08ab\u08a9\3\2\2\2\u08ac\u08ad\5\u00a4"+ 21944 "S\2\u08ad\u00a7\3\2\2\2\u08ae\u08af\7\7\2\2\u08af\u08b6\7b\2\2\u08b0\u08b5"+ 21945 "\5\n\6\2\u08b1\u08b5\7\b\2\2\u08b2\u08b5\7\3\2\2\u08b3\u08b5\7\6\2\2\u08b4"+ 21946 "\u08b0\3\2\2\2\u08b4\u08b1\3\2\2\2\u08b4\u08b2\3\2\2\2\u08b4\u08b3\3\2"+ 21947 "\2\2\u08b5\u08b8\3\2\2\2\u08b6\u08b4\3\2\2\2\u08b6\u08b7\3\2\2\2\u08b7"+ 21948 "\u08b9\3\2\2\2\u08b8\u08b6\3\2\2\2\u08b9\u08ba\79\2\2\u08ba\u00a9\3\2"+ 21949 "\2\2\u08bb\u08bc\7\7\2\2\u08bc\u08bd\7;\2\2\u08bd\u08c1\7b\2\2\u08be\u08c0"+ 21950 "\t\2\2\2\u08bf\u08be\3\2\2\2\u08c0\u08c3\3\2\2\2\u08c1\u08bf\3\2\2\2\u08c1"+ 21951 "\u08c2\3\2\2\2\u08c2\u08c4\3\2\2\2\u08c3\u08c1\3\2\2\2\u08c4\u08c5\79"+ 21952 "\2\2\u08c5\u00ab\3\2\2\2\u08c6\u08ee\5\u00a8U\2\u08c7\u08ed\5\f\7\2\u08c8"+ 21953 "\u08ed\5h\65\2\u08c9\u08ed\5\22\n\2\u08ca\u08ed\5\30\r\2\u08cb\u08ed\5"+ 21954 "\36\20\2\u08cc\u08ed\5$\23\2\u08cd\u08ed\5*\26\2\u08ce\u08ed\5\60\31\2"+ 21955 "\u08cf\u08ed\5\66\34\2\u08d0\u08ed\5<\37\2\u08d1\u08ed\5B\"\2\u08d2\u08ed"+ 21956 "\5H%\2\u08d3\u08ed\5N(\2\u08d4\u08ed\5T+\2\u08d5\u08ed\5Z.\2\u08d6\u08ed"+ 21957 "\5`\61\2\u08d7\u08ed\5\16\b\2\u08d8\u08ed\5\24\13\2\u08d9\u08ed\5\32\16"+ 21958 "\2\u08da\u08ed\5 \21\2\u08db\u08ed\5&\24\2\u08dc\u08ed\5,\27\2\u08dd\u08ed"+ 21959 "\5\62\32\2\u08de\u08ed\58\35\2\u08df\u08ed\5> \2\u08e0\u08ed\5D#\2\u08e1"+ 21960 "\u08ed\5J&\2\u08e2\u08ed\5P)\2\u08e3\u08ed\5V,\2\u08e4\u08ed\5\\/\2\u08e5"+ 21961 "\u08e6\6W\32\2\u08e6\u08ed\7\3\2\2\u08e7\u08ed\5\u0094K\2\u08e8\u08ed"+ 21962 "\7\5\2\2\u08e9\u08ed\7\b\2\2\u08ea\u08ed\5\u0096L\2\u08eb\u08ed\5\u0092"+ 21963 "J\2\u08ec\u08c7\3\2\2\2\u08ec\u08c8\3\2\2\2\u08ec\u08c9\3\2\2\2\u08ec"+ 21964 "\u08ca\3\2\2\2\u08ec\u08cb\3\2\2\2\u08ec\u08cc\3\2\2\2\u08ec\u08cd\3\2"+ 21965 "\2\2\u08ec\u08ce\3\2\2\2\u08ec\u08cf\3\2\2\2\u08ec\u08d0\3\2\2\2\u08ec"+ 21966 "\u08d1\3\2\2\2\u08ec\u08d2\3\2\2\2\u08ec\u08d3\3\2\2\2\u08ec\u08d4\3\2"+ 21967 "\2\2\u08ec\u08d5\3\2\2\2\u08ec\u08d6\3\2\2\2\u08ec\u08d7\3\2\2\2\u08ec"+ 21968 "\u08d8\3\2\2\2\u08ec\u08d9\3\2\2\2\u08ec\u08da\3\2\2\2\u08ec\u08db\3\2"+ 21969 "\2\2\u08ec\u08dc\3\2\2\2\u08ec\u08dd\3\2\2\2\u08ec\u08de\3\2\2\2\u08ec"+ 21970 "\u08df\3\2\2\2\u08ec\u08e0\3\2\2\2\u08ec\u08e1\3\2\2\2\u08ec\u08e2\3\2"+ 21971 "\2\2\u08ec\u08e3\3\2\2\2\u08ec\u08e4\3\2\2\2\u08ec\u08e5\3\2\2\2\u08ec"+ 21972 "\u08e7\3\2\2\2\u08ec\u08e8\3\2\2\2\u08ec\u08e9\3\2\2\2\u08ec\u08ea\3\2"+ 21973 "\2\2\u08ec\u08eb\3\2\2\2\u08ed\u08f0\3\2\2\2\u08ee\u08ec\3\2\2\2\u08ee"+ 21974 "\u08ef\3\2\2\2\u08ef\u08f1\3\2\2\2\u08f0\u08ee\3\2\2\2\u08f1\u08f2\5\u00aa"+ 21975 "V\2\u08f2\u00ad\3\2\2\2\u08f3\u08f4\7\7\2\2\u08f4\u08fb\7c\2\2\u08f5\u08fa"+ 21976 "\5\n\6\2\u08f6\u08fa\7\b\2\2\u08f7\u08fa\7\3\2\2\u08f8\u08fa\7\6\2\2\u08f9"+ 21977 "\u08f5\3\2\2\2\u08f9\u08f6\3\2\2\2\u08f9\u08f7\3\2\2\2\u08f9\u08f8\3\2"+ 21978 "\2\2\u08fa\u08fd\3\2\2\2\u08fb\u08f9\3\2\2\2\u08fb\u08fc\3\2\2\2\u08fc"+ 21979 "\u08fe\3\2\2\2\u08fd\u08fb\3\2\2\2\u08fe\u08ff\79\2\2\u08ff\u00af\3\2"+ 21980 "\2\2\u0900\u0901\7\7\2\2\u0901\u0902\7;\2\2\u0902\u0906\7c\2\2\u0903\u0905"+ 21981 "\t\2\2\2\u0904\u0903\3\2\2\2\u0905\u0908\3\2\2\2\u0906\u0904\3\2\2\2\u0906"+ 21982 "\u0907\3\2\2\2\u0907\u0909\3\2\2\2\u0908\u0906\3\2\2\2\u0909\u090a\79"+ 21983 "\2\2\u090a\u00b1\3\2\2\2\u090b\u0933\5\u00aeX\2\u090c\u0932\5\f\7\2\u090d"+ 21984 "\u0932\5h\65\2\u090e\u0932\5\22\n\2\u090f\u0932\5\30\r\2\u0910\u0932\5"+ 21985 "\36\20\2\u0911\u0932\5$\23\2\u0912\u0932\5*\26\2\u0913\u0932\5\60\31\2"+ 21986 "\u0914\u0932\5\66\34\2\u0915\u0932\5<\37\2\u0916\u0932\5B\"\2\u0917\u0932"+ 21987 "\5H%\2\u0918\u0932\5N(\2\u0919\u0932\5T+\2\u091a\u0932\5Z.\2\u091b\u0932"+ 21988 "\5`\61\2\u091c\u0932\5\16\b\2\u091d\u0932\5\24\13\2\u091e\u0932\5\32\16"+ 21989 "\2\u091f\u0932\5 \21\2\u0920\u0932\5&\24\2\u0921\u0932\5,\27\2\u0922\u0932"+ 21990 "\5\62\32\2\u0923\u0932\58\35\2\u0924\u0932\5> \2\u0925\u0932\5D#\2\u0926"+ 21991 "\u0932\5J&\2\u0927\u0932\5P)\2\u0928\u0932\5V,\2\u0929\u0932\5\\/\2\u092a"+ 21992 "\u092b\6Z\33\2\u092b\u0932\7\3\2\2\u092c\u0932\5\u0094K\2\u092d\u0932"+ 21993 "\7\5\2\2\u092e\u0932\7\b\2\2\u092f\u0932\5\u0096L\2\u0930\u0932\5\u0092"+ 21994 "J\2\u0931\u090c\3\2\2\2\u0931\u090d\3\2\2\2\u0931\u090e\3\2\2\2\u0931"+ 21995 "\u090f\3\2\2\2\u0931\u0910\3\2\2\2\u0931\u0911\3\2\2\2\u0931\u0912\3\2"+ 21996 "\2\2\u0931\u0913\3\2\2\2\u0931\u0914\3\2\2\2\u0931\u0915\3\2\2\2\u0931"+ 21997 "\u0916\3\2\2\2\u0931\u0917\3\2\2\2\u0931\u0918\3\2\2\2\u0931\u0919\3\2"+ 21998 "\2\2\u0931\u091a\3\2\2\2\u0931\u091b\3\2\2\2\u0931\u091c\3\2\2\2\u0931"+ 21999 "\u091d\3\2\2\2\u0931\u091e\3\2\2\2\u0931\u091f\3\2\2\2\u0931\u0920\3\2"+ 22000 "\2\2\u0931\u0921\3\2\2\2\u0931\u0922\3\2\2\2\u0931\u0923\3\2\2\2\u0931"+ 22001 "\u0924\3\2\2\2\u0931\u0925\3\2\2\2\u0931\u0926\3\2\2\2\u0931\u0927\3\2"+ 22002 "\2\2\u0931\u0928\3\2\2\2\u0931\u0929\3\2\2\2\u0931\u092a\3\2\2\2\u0931"+ 22003 "\u092c\3\2\2\2\u0931\u092d\3\2\2\2\u0931\u092e\3\2\2\2\u0931\u092f\3\2"+ 22004 "\2\2\u0931\u0930\3\2\2\2\u0932\u0935\3\2\2\2\u0933\u0931\3\2\2\2\u0933"+ 22005 "\u0934\3\2\2\2\u0934\u0936\3\2\2\2\u0935\u0933\3\2\2\2\u0936\u0937\5\u00b0"+ 22006 "Y\2\u0937\u00b3\3\2\2\2\u0938\u0939\7\7\2\2\u0939\u0940\7d\2\2\u093a\u093f"+ 22007 "\5\n\6\2\u093b\u093f\7\b\2\2\u093c\u093f\7\3\2\2\u093d\u093f\7\6\2\2\u093e"+ 22008 "\u093a\3\2\2\2\u093e\u093b\3\2\2\2\u093e\u093c\3\2\2\2\u093e\u093d\3\2"+ 22009 "\2\2\u093f\u0942\3\2\2\2\u0940\u093e\3\2\2\2\u0940\u0941\3\2\2\2\u0941"+ 22010 "\u0943\3\2\2\2\u0942\u0940\3\2\2\2\u0943\u0944\79\2\2\u0944\u00b5\3\2"+ 22011 "\2\2\u0945\u0946\7\7\2\2\u0946\u0947\7;\2\2\u0947\u094b\7d\2\2\u0948\u094a"+ 22012 "\t\2\2\2\u0949\u0948\3\2\2\2\u094a\u094d\3\2\2\2\u094b\u0949\3\2\2\2\u094b"+ 22013 "\u094c\3\2\2\2\u094c\u094e\3\2\2\2\u094d\u094b\3\2\2\2\u094e\u094f\79"+ 22014 "\2\2\u094f\u00b7\3\2\2\2\u0950\u0978\5\u00b4[\2\u0951\u0977\5\f\7\2\u0952"+ 22015 "\u0977\5h\65\2\u0953\u0977\5\22\n\2\u0954\u0977\5\30\r\2\u0955\u0977\5"+ 22016 "\36\20\2\u0956\u0977\5$\23\2\u0957\u0977\5*\26\2\u0958\u0977\5\60\31\2"+ 22017 "\u0959\u0977\5\66\34\2\u095a\u0977\5<\37\2\u095b\u0977\5B\"\2\u095c\u0977"+ 22018 "\5H%\2\u095d\u0977\5N(\2\u095e\u0977\5T+\2\u095f\u0977\5Z.\2\u0960\u0977"+ 22019 "\5`\61\2\u0961\u0977\5\16\b\2\u0962\u0977\5\24\13\2\u0963\u0977\5\32\16"+ 22020 "\2\u0964\u0977\5 \21\2\u0965\u0977\5&\24\2\u0966\u0977\5,\27\2\u0967\u0977"+ 22021 "\5\62\32\2\u0968\u0977\58\35\2\u0969\u0977\5> \2\u096a\u0977\5D#\2\u096b"+ 22022 "\u0977\5J&\2\u096c\u0977\5P)\2\u096d\u0977\5V,\2\u096e\u0977\5\\/\2\u096f"+ 22023 "\u0970\6]\34\2\u0970\u0977\7\3\2\2\u0971\u0977\5\u0094K\2\u0972\u0977"+ 22024 "\7\5\2\2\u0973\u0977\7\b\2\2\u0974\u0977\5\u0096L\2\u0975\u0977\5\u0092"+ 22025 "J\2\u0976\u0951\3\2\2\2\u0976\u0952\3\2\2\2\u0976\u0953\3\2\2\2\u0976"+ 22026 "\u0954\3\2\2\2\u0976\u0955\3\2\2\2\u0976\u0956\3\2\2\2\u0976\u0957\3\2"+ 22027 "\2\2\u0976\u0958\3\2\2\2\u0976\u0959\3\2\2\2\u0976\u095a\3\2\2\2\u0976"+ 22028 "\u095b\3\2\2\2\u0976\u095c\3\2\2\2\u0976\u095d\3\2\2\2\u0976\u095e\3\2"+ 22029 "\2\2\u0976\u095f\3\2\2\2\u0976\u0960\3\2\2\2\u0976\u0961\3\2\2\2\u0976"+ 22030 "\u0962\3\2\2\2\u0976\u0963\3\2\2\2\u0976\u0964\3\2\2\2\u0976\u0965\3\2"+ 22031 "\2\2\u0976\u0966\3\2\2\2\u0976\u0967\3\2\2\2\u0976\u0968\3\2\2\2\u0976"+ 22032 "\u0969\3\2\2\2\u0976\u096a\3\2\2\2\u0976\u096b\3\2\2\2\u0976\u096c\3\2"+ 22033 "\2\2\u0976\u096d\3\2\2\2\u0976\u096e\3\2\2\2\u0976\u096f\3\2\2\2\u0976"+ 22034 "\u0971\3\2\2\2\u0976\u0972\3\2\2\2\u0976\u0973\3\2\2\2\u0976\u0974\3\2"+ 22035 "\2\2\u0976\u0975\3\2\2\2\u0977\u097a\3\2\2\2\u0978\u0976\3\2\2\2\u0978"+ 22036 "\u0979\3\2\2\2\u0979\u097b\3\2\2\2\u097a\u0978\3\2\2\2\u097b\u097c\5\u00b6"+ 22037 "\\\2\u097c\u00b9\3\2\2\2\u097d\u097e\7\7\2\2\u097e\u0985\7e\2\2\u097f"+ 22038 "\u0984\5\n\6\2\u0980\u0984\7\b\2\2\u0981\u0984\7\3\2\2\u0982\u0984\7\6"+ 22039 "\2\2\u0983\u097f\3\2\2\2\u0983\u0980\3\2\2\2\u0983\u0981\3\2\2\2\u0983"+ 22040 "\u0982\3\2\2\2\u0984\u0987\3\2\2\2\u0985\u0983\3\2\2\2\u0985\u0986\3\2"+ 22041 "\2\2\u0986\u0988\3\2\2\2\u0987\u0985\3\2\2\2\u0988\u0989\79\2\2\u0989"+ 22042 "\u00bb\3\2\2\2\u098a\u098b\7\7\2\2\u098b\u098c\7;\2\2\u098c\u0990\7e\2"+ 22043 "\2\u098d\u098f\t\2\2\2\u098e\u098d\3\2\2\2\u098f\u0992\3\2\2\2\u0990\u098e"+ 22044 "\3\2\2\2\u0990\u0991\3\2\2\2\u0991\u0993\3\2\2\2\u0992\u0990\3\2\2\2\u0993"+ 22045 "\u0994\79\2\2\u0994\u00bd\3\2\2\2\u0995\u09bd\5\u00ba^\2\u0996\u09bc\5"+ 22046 "\f\7\2\u0997\u09bc\5h\65\2\u0998\u09bc\5\22\n\2\u0999\u09bc\5\30\r\2\u099a"+ 22047 "\u09bc\5\36\20\2\u099b\u09bc\5$\23\2\u099c\u09bc\5*\26\2\u099d\u09bc\5"+ 22048 "\60\31\2\u099e\u09bc\5\66\34\2\u099f\u09bc\5<\37\2\u09a0\u09bc\5B\"\2"+ 22049 "\u09a1\u09bc\5H%\2\u09a2\u09bc\5N(\2\u09a3\u09bc\5T+\2\u09a4\u09bc\5Z"+ 22050 ".\2\u09a5\u09bc\5`\61\2\u09a6\u09bc\5\16\b\2\u09a7\u09bc\5\24\13\2\u09a8"+ 22051 "\u09bc\5\32\16\2\u09a9\u09bc\5 \21\2\u09aa\u09bc\5&\24\2\u09ab\u09bc\5"+ 22052 ",\27\2\u09ac\u09bc\5\62\32\2\u09ad\u09bc\58\35\2\u09ae\u09bc\5> \2\u09af"+ 22053 "\u09bc\5D#\2\u09b0\u09bc\5J&\2\u09b1\u09bc\5P)\2\u09b2\u09bc\5V,\2\u09b3"+ 22054 "\u09bc\5\\/\2\u09b4\u09b5\6`\35\2\u09b5\u09bc\7\3\2\2\u09b6\u09bc\5\u0094"+ 22055 "K\2\u09b7\u09bc\7\5\2\2\u09b8\u09bc\7\b\2\2\u09b9\u09bc\5\u0096L\2\u09ba"+ 22056 "\u09bc\5\u0092J\2\u09bb\u0996\3\2\2\2\u09bb\u0997\3\2\2\2\u09bb\u0998"+ 22057 "\3\2\2\2\u09bb\u0999\3\2\2\2\u09bb\u099a\3\2\2\2\u09bb\u099b\3\2\2\2\u09bb"+ 22058 "\u099c\3\2\2\2\u09bb\u099d\3\2\2\2\u09bb\u099e\3\2\2\2\u09bb\u099f\3\2"+ 22059 "\2\2\u09bb\u09a0\3\2\2\2\u09bb\u09a1\3\2\2\2\u09bb\u09a2\3\2\2\2\u09bb"+ 22060 "\u09a3\3\2\2\2\u09bb\u09a4\3\2\2\2\u09bb\u09a5\3\2\2\2\u09bb\u09a6\3\2"+ 22061 "\2\2\u09bb\u09a7\3\2\2\2\u09bb\u09a8\3\2\2\2\u09bb\u09a9\3\2\2\2\u09bb"+ 22062 "\u09aa\3\2\2\2\u09bb\u09ab\3\2\2\2\u09bb\u09ac\3\2\2\2\u09bb\u09ad\3\2"+ 22063 "\2\2\u09bb\u09ae\3\2\2\2\u09bb\u09af\3\2\2\2\u09bb\u09b0\3\2\2\2\u09bb"+ 22064 "\u09b1\3\2\2\2\u09bb\u09b2\3\2\2\2\u09bb\u09b3\3\2\2\2\u09bb\u09b4\3\2"+ 22065 "\2\2\u09bb\u09b6\3\2\2\2\u09bb\u09b7\3\2\2\2\u09bb\u09b8\3\2\2\2\u09bb"+ 22066 "\u09b9\3\2\2\2\u09bb\u09ba\3\2\2\2\u09bc\u09bf\3\2\2\2\u09bd\u09bb\3\2"+ 22067 "\2\2\u09bd\u09be\3\2\2\2\u09be\u09c0\3\2\2\2\u09bf\u09bd\3\2\2\2\u09c0"+ 22068 "\u09c1\5\u00bc_\2\u09c1\u00bf\3\2\2\2\u00db\u00c8\u00ca\u00ce\u00d3\u00d9"+ 22069 "\u011c\u0124\u0126\u0131\u013a\u0141\u0147\u0152\u0154\u0160\u0162\u016d"+ 22070 "\u01a2\u01a4\u01af\u01b1\u01bc\u01f1\u01f3\u01fe\u0200\u020b\u0240\u0242"+ 22071 "\u024d\u024f\u025a\u028f\u0291\u029c\u029e\u02a9\u02de\u02e0\u02eb\u02ed"+ 22072 "\u02f8\u032d\u032f\u033a\u033c\u0347\u037c\u037e\u0389\u038b\u0396\u03cb"+ 22073 "\u03cd\u03d8\u03da\u03e5\u041a\u041c\u0427\u0429\u0434\u0469\u046b\u0476"+ 22074 "\u0478\u0483\u04b8\u04ba\u04c5\u04c7\u04d2\u0507\u0509\u0514\u0516\u0521"+ 22075 "\u0556\u0558\u0563\u0565\u0570\u05a5\u05a7\u05b2\u05b4\u05bf\u05f4\u05f6"+ 22076 "\u060f\u0617\u0619\u0624\u0626\u0631\u0633\u063e\u0640\u064b\u064d\u0658"+ 22077 "\u065a\u0665\u0667\u0672\u0674\u067f\u0681\u068c\u068e\u0699\u069b\u06a6"+ 22078 "\u06a8\u06b3\u06b5\u06c0\u06c2\u06d7\u06d9\u06df\u06e1\u06e6\u06e8\u06ee"+ 22079 "\u06f7\u06fe\u0703\u070a\u070c\u0712\u0717\u071e\u0720\u0726\u072b\u0731"+ 22080 "\u0739\u073b\u0740\u0745\u074a\u0750\u0757\u075c\u0763\u0768\u076e\u0773"+ 22081 "\u0778\u077d\u0782\u0787\u078d\u0795\u0797\u079d\u07a2\u07a8\u07af\u07b4"+ 22082 "\u07b6\u07be\u07c0\u07c7\u07ce\u07d5\u07db\u07e0\u07e6\u07ec\u07f1\u07f8"+ 22083 "\u07fa\u0801\u0806\u080c\u0811\u0813\u081b\u081d\u0826\u082e\u0830\u083b"+ 22084 "\u083d\u0848\u084a\u0855\u0857\u0862\u0864\u086f\u0871\u087c\u08a7\u08a9"+ 22085 "\u08b4\u08b6\u08c1\u08ec\u08ee\u08f9\u08fb\u0906\u0931\u0933\u093e\u0940"+ 22086 "\u094b\u0976\u0978\u0983\u0985\u0990\u09bb\u09bd"; 22087 public static final String _serializedATN = Utils.join( 22088 new String[] { 22089 _serializedATNSegment0, 22090 _serializedATNSegment1 22091 }, 22092 "" 22093 ); 22094 public static final ATN _ATN = 22095 new ATNDeserializer().deserialize(_serializedATN.toCharArray()); 22096 static { 22097 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; 22098 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { 22099 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); 22100 } 22101 } 22102}