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 HTML_TAG_NAME=95, Char11=96; 043 public static final int 044 RULE_javadoc = 0, RULE_htmlElement = 1, RULE_htmlElementStart = 2, RULE_htmlElementEnd = 3, 045 RULE_attribute = 4, RULE_htmlTag = 5, RULE_pTagStart = 6, RULE_pTagEnd = 7, 046 RULE_paragraph = 8, RULE_liTagStart = 9, RULE_liTagEnd = 10, RULE_li = 11, 047 RULE_trTagStart = 12, RULE_trTagEnd = 13, RULE_tr = 14, RULE_tdTagStart = 15, 048 RULE_tdTagEnd = 16, RULE_td = 17, RULE_thTagStart = 18, RULE_thTagEnd = 19, 049 RULE_th = 20, RULE_bodyTagStart = 21, RULE_bodyTagEnd = 22, RULE_body = 23, 050 RULE_colgroupTagStart = 24, RULE_colgroupTagEnd = 25, RULE_colgroup = 26, 051 RULE_ddTagStart = 27, RULE_ddTagEnd = 28, RULE_dd = 29, RULE_dtTagStart = 30, 052 RULE_dtTagEnd = 31, RULE_dt = 32, RULE_headTagStart = 33, RULE_headTagEnd = 34, 053 RULE_head = 35, RULE_htmlTagStart = 36, RULE_htmlTagEnd = 37, RULE_html = 38, 054 RULE_optionTagStart = 39, RULE_optionTagEnd = 40, RULE_option = 41, RULE_tbodyTagStart = 42, 055 RULE_tbodyTagEnd = 43, RULE_tbody = 44, RULE_tfootTagStart = 45, RULE_tfootTagEnd = 46, 056 RULE_tfoot = 47, RULE_theadTagStart = 48, RULE_theadTagEnd = 49, RULE_thead = 50, 057 RULE_singletonElement = 51, RULE_emptyTag = 52, RULE_areaTag = 53, RULE_baseTag = 54, 058 RULE_basefontTag = 55, RULE_brTag = 56, RULE_colTag = 57, RULE_frameTag = 58, 059 RULE_hrTag = 59, RULE_imgTag = 60, RULE_inputTag = 61, RULE_isindexTag = 62, 060 RULE_linkTag = 63, RULE_metaTag = 64, RULE_paramTag = 65, RULE_wrongSinletonTag = 66, 061 RULE_singletonTagName = 67, RULE_description = 68, RULE_reference = 69, 062 RULE_parameters = 70, RULE_javadocTag = 71, RULE_javadocInlineTag = 72, 063 RULE_htmlComment = 73, RULE_text = 74, RULE_embedTag = 75, RULE_keygenTag = 76, 064 RULE_sourceTag = 77, RULE_trackTag = 78, RULE_wbrTag = 79; 065 public static final String[] ruleNames = { 066 "javadoc", "htmlElement", "htmlElementStart", "htmlElementEnd", "attribute", 067 "htmlTag", "pTagStart", "pTagEnd", "paragraph", "liTagStart", "liTagEnd", 068 "li", "trTagStart", "trTagEnd", "tr", "tdTagStart", "tdTagEnd", "td", 069 "thTagStart", "thTagEnd", "th", "bodyTagStart", "bodyTagEnd", "body", 070 "colgroupTagStart", "colgroupTagEnd", "colgroup", "ddTagStart", "ddTagEnd", 071 "dd", "dtTagStart", "dtTagEnd", "dt", "headTagStart", "headTagEnd", "head", 072 "htmlTagStart", "htmlTagEnd", "html", "optionTagStart", "optionTagEnd", 073 "option", "tbodyTagStart", "tbodyTagEnd", "tbody", "tfootTagStart", "tfootTagEnd", 074 "tfoot", "theadTagStart", "theadTagEnd", "thead", "singletonElement", 075 "emptyTag", "areaTag", "baseTag", "basefontTag", "brTag", "colTag", "frameTag", 076 "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", "paramTag", 077 "wrongSinletonTag", "singletonTagName", "description", "reference", "parameters", 078 "javadocTag", "javadocInlineTag", "htmlComment", "text", "embedTag", "keygenTag", 079 "sourceTag", "trackTag", "wbrTag" 080 }; 081 082 private static final String[] _LITERAL_NAMES = { 083 null, null, null, null, null, null, null, "'@author'", "'@deprecated'", 084 null, null, "'@return'", null, "'@serial'", null, "'@serialData'", "'@since'", 085 null, "'@version'", null, null, null, "'include'", "'exclude'", null, 086 null, null, null, null, "'.'", null, null, null, null, "'('", "')'", null, 087 "','", null, null, null, null, null, null, null, null, "'@docRoot'", "'@inheritDoc'", 088 "'@link'", "'@linkplain'", null, "'@value'", null, null, null, null, null, 089 "'/'", "'='", null, null, null, null, null, null, null, null, null, null, 090 null, null, null, null, null, null, null, null, null, null, null, null, 091 null, null, null, null, null, null, null, null, null, null, "'-->'" 092 }; 093 private static final String[] _SYMBOLIC_NAMES = { 094 null, "LEADING_ASTERISK", "HTML_COMMENT_START", "CDATA", "WS", "START", 095 "NEWLINE", "AUTHOR_LITERAL", "DEPRECATED_LITERAL", "EXCEPTION_LITERAL", 096 "PARAM_LITERAL", "RETURN_LITERAL", "SEE_LITERAL", "SERIAL_LITERAL", "SERIAL_FIELD_LITERAL", 097 "SERIAL_DATA_LITERAL", "SINCE_LITERAL", "THROWS_LITERAL", "VERSION_LITERAL", 098 "JAVADOC_INLINE_TAG_START", "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", "LITERAL_INCLUDE", 099 "LITERAL_EXCLUDE", "CHAR", "PARAMETER_NAME", "Char1", "STRING", "PACKAGE_CLASS", 100 "DOT", "HASH", "CLASS", "Char2", "MEMBER", "LEFT_BRACE", "RIGHT_BRACE", 101 "ARGUMENT", "COMMA", "Char20", "FIELD_NAME", "Char3", "FIELD_TYPE", "Char4", 102 "CLASS_NAME", "Char5", "CODE_LITERAL", "DOC_ROOT_LITERAL", "INHERIT_DOC_LITERAL", 103 "LINK_LITERAL", "LINKPLAIN_LITERAL", "LITERAL_LITERAL", "VALUE_LITERAL", 104 "Char7", "Char8", "Char10", "END", "SLASH_END", "SLASH", "EQUALS", "P_HTML_TAG_NAME", 105 "LI_HTML_TAG_NAME", "TR_HTML_TAG_NAME", "TD_HTML_TAG_NAME", "TH_HTML_TAG_NAME", 106 "BODY_HTML_TAG_NAME", "COLGROUP_HTML_TAG_NAME", "DD_HTML_TAG_NAME", "DT_HTML_TAG_NAME", 107 "HEAD_HTML_TAG_NAME", "HTML_HTML_TAG_NAME", "OPTION_HTML_TAG_NAME", "TBODY_HTML_TAG_NAME", 108 "TFOOT_HTML_TAG_NAME", "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", "BASE_HTML_TAG_NAME", 109 "BASEFONT_HTML_TAG_NAME", "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", "FRAME_HTML_TAG_NAME", 110 "HR_HTML_TAG_NAME", "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", "ISINDEX_HTML_TAG_NAME", 111 "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", "EMBED_HTML_TAG_NAME", 112 "KEYGEN_HTML_TAG_NAME", "ATTR_VALUE", "Char12", "HTML_COMMENT_END", "SOURCE_HTML_TAG_NAME", 113 "TRACK_HTML_TAG_NAME", "WBR_HTML_TAG_NAME", "HTML_TAG_NAME", "Char11" 114 }; 115 public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); 116 117 /** 118 * @deprecated Use {@link #VOCABULARY} instead. 119 */ 120 @Deprecated 121 public static final String[] tokenNames; 122 static { 123 tokenNames = new String[_SYMBOLIC_NAMES.length]; 124 for (int i = 0; i < tokenNames.length; i++) { 125 tokenNames[i] = VOCABULARY.getLiteralName(i); 126 if (tokenNames[i] == null) { 127 tokenNames[i] = VOCABULARY.getSymbolicName(i); 128 } 129 130 if (tokenNames[i] == null) { 131 tokenNames[i] = "<INVALID>"; 132 } 133 } 134 } 135 136 @Override 137 @Deprecated 138 public String[] getTokenNames() { 139 return tokenNames; 140 } 141 142 @Override 143 144 public Vocabulary getVocabulary() { 145 return VOCABULARY; 146 } 147 148 @Override 149 public String getGrammarFileName() { return "JavadocParser.g4"; } 150 151 @Override 152 public String[] getRuleNames() { return ruleNames; } 153 154 @Override 155 public String getSerializedATN() { return _serializedATN; } 156 157 @Override 158 public ATN getATN() { return _ATN; } 159 160 161 boolean isNextJavadocTag() { 162 int token1 = _input.LA(2); 163 int token2 = _input.LA(3); 164 return isJavadocTag(token1) 165 || (token1 == WS && isJavadocTag(token2)); 166 } 167 168 boolean isJavadocTag(int type) { 169 switch(type) { 170 case AUTHOR_LITERAL: 171 case DEPRECATED_LITERAL: 172 case EXCEPTION_LITERAL: 173 case PARAM_LITERAL: 174 case RETURN_LITERAL: 175 case SEE_LITERAL: 176 case SERIAL_LITERAL: 177 case SERIAL_FIELD_LITERAL: 178 case SERIAL_DATA_LITERAL: 179 case SINCE_LITERAL: 180 case THROWS_LITERAL: 181 case VERSION_LITERAL: 182 case CUSTOM_NAME: 183 return true; 184 default: 185 return false; 186 } 187 } 188 189 boolean isSameTagNames(ParserRuleContext htmlTagStart, ParserRuleContext htmlTagEnd) { 190 String startTag = htmlTagStart.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 191 String endTag = htmlTagEnd.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 192 return startTag.equals(endTag); 193 } 194 195 public ParserRuleContext nonTightTagStartContext; 196 197 public JavadocParser(TokenStream input) { 198 super(input); 199 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); 200 } 201 public static class JavadocContext extends ParserRuleContext { 202 public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); } 203 public List<HtmlElementContext> htmlElement() { 204 return getRuleContexts(HtmlElementContext.class); 205 } 206 public HtmlElementContext htmlElement(int i) { 207 return getRuleContext(HtmlElementContext.class,i); 208 } 209 public List<HtmlCommentContext> htmlComment() { 210 return getRuleContexts(HtmlCommentContext.class); 211 } 212 public HtmlCommentContext htmlComment(int i) { 213 return getRuleContext(HtmlCommentContext.class,i); 214 } 215 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 216 public TerminalNode CDATA(int i) { 217 return getToken(JavadocParser.CDATA, i); 218 } 219 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 220 public TerminalNode NEWLINE(int i) { 221 return getToken(JavadocParser.NEWLINE, i); 222 } 223 public List<TextContext> text() { 224 return getRuleContexts(TextContext.class); 225 } 226 public TextContext text(int i) { 227 return getRuleContext(TextContext.class,i); 228 } 229 public List<JavadocInlineTagContext> javadocInlineTag() { 230 return getRuleContexts(JavadocInlineTagContext.class); 231 } 232 public JavadocInlineTagContext javadocInlineTag(int i) { 233 return getRuleContext(JavadocInlineTagContext.class,i); 234 } 235 public List<JavadocTagContext> javadocTag() { 236 return getRuleContexts(JavadocTagContext.class); 237 } 238 public JavadocTagContext javadocTag(int i) { 239 return getRuleContext(JavadocTagContext.class,i); 240 } 241 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 242 public TerminalNode LEADING_ASTERISK(int i) { 243 return getToken(JavadocParser.LEADING_ASTERISK, i); 244 } 245 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 246 public TerminalNode WS(int i) { 247 return getToken(JavadocParser.WS, i); 248 } 249 public JavadocContext(ParserRuleContext parent, int invokingState) { 250 super(parent, invokingState); 251 } 252 @Override public int getRuleIndex() { return RULE_javadoc; } 253 } 254 255 public final JavadocContext javadoc() throws RecognitionException { 256 JavadocContext _localctx = new JavadocContext(_ctx, getState()); 257 enterRule(_localctx, 0, RULE_javadoc); 258 int _la; 259 try { 260 int _alt; 261 enterOuterAlt(_localctx, 1); 262 { 263 setState(170); 264 _errHandler.sync(this); 265 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 266 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 267 if ( _alt==1 ) { 268 { 269 setState(168); 270 _errHandler.sync(this); 271 switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { 272 case 1: 273 { 274 setState(160); 275 htmlElement(); 276 } 277 break; 278 case 2: 279 { 280 { 281 setState(161); 282 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 283 setState(162); 284 match(LEADING_ASTERISK); 285 } 286 } 287 break; 288 case 3: 289 { 290 setState(163); 291 htmlComment(); 292 } 293 break; 294 case 4: 295 { 296 setState(164); 297 match(CDATA); 298 } 299 break; 300 case 5: 301 { 302 setState(165); 303 match(NEWLINE); 304 } 305 break; 306 case 6: 307 { 308 setState(166); 309 text(); 310 } 311 break; 312 case 7: 313 { 314 setState(167); 315 javadocInlineTag(); 316 } 317 break; 318 } 319 } 320 } 321 setState(172); 322 _errHandler.sync(this); 323 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 324 } 325 setState(185); 326 _errHandler.sync(this); 327 _la = _input.LA(1); 328 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << AUTHOR_LITERAL) | (1L << DEPRECATED_LITERAL) | (1L << EXCEPTION_LITERAL) | (1L << PARAM_LITERAL) | (1L << RETURN_LITERAL) | (1L << SEE_LITERAL) | (1L << SERIAL_LITERAL) | (1L << SERIAL_FIELD_LITERAL) | (1L << SERIAL_DATA_LITERAL) | (1L << SINCE_LITERAL) | (1L << THROWS_LITERAL) | (1L << VERSION_LITERAL) | (1L << CUSTOM_NAME))) != 0)) { 329 { 330 { 331 setState(174); 332 _errHandler.sync(this); 333 _la = _input.LA(1); 334 if (_la==LEADING_ASTERISK) { 335 { 336 setState(173); 337 match(LEADING_ASTERISK); 338 } 339 } 340 341 setState(179); 342 _errHandler.sync(this); 343 _la = _input.LA(1); 344 while (_la==WS) { 345 { 346 { 347 setState(176); 348 match(WS); 349 } 350 } 351 setState(181); 352 _errHandler.sync(this); 353 _la = _input.LA(1); 354 } 355 setState(182); 356 javadocTag(); 357 } 358 } 359 setState(187); 360 _errHandler.sync(this); 361 _la = _input.LA(1); 362 } 363 setState(188); 364 match(EOF); 365 } 366 } 367 catch (RecognitionException re) { 368 _localctx.exception = re; 369 _errHandler.reportError(this, re); 370 _errHandler.recover(this, re); 371 } 372 finally { 373 exitRule(); 374 } 375 return _localctx; 376 } 377 378 public static class HtmlElementContext extends ParserRuleContext { 379 public HtmlTagContext htmlTag() { 380 return getRuleContext(HtmlTagContext.class,0); 381 } 382 public SingletonElementContext singletonElement() { 383 return getRuleContext(SingletonElementContext.class,0); 384 } 385 public ParagraphContext paragraph() { 386 return getRuleContext(ParagraphContext.class,0); 387 } 388 public LiContext li() { 389 return getRuleContext(LiContext.class,0); 390 } 391 public TrContext tr() { 392 return getRuleContext(TrContext.class,0); 393 } 394 public TdContext td() { 395 return getRuleContext(TdContext.class,0); 396 } 397 public ThContext th() { 398 return getRuleContext(ThContext.class,0); 399 } 400 public BodyContext body() { 401 return getRuleContext(BodyContext.class,0); 402 } 403 public ColgroupContext colgroup() { 404 return getRuleContext(ColgroupContext.class,0); 405 } 406 public DdContext dd() { 407 return getRuleContext(DdContext.class,0); 408 } 409 public DtContext dt() { 410 return getRuleContext(DtContext.class,0); 411 } 412 public HeadContext head() { 413 return getRuleContext(HeadContext.class,0); 414 } 415 public HtmlContext html() { 416 return getRuleContext(HtmlContext.class,0); 417 } 418 public OptionContext option() { 419 return getRuleContext(OptionContext.class,0); 420 } 421 public TbodyContext tbody() { 422 return getRuleContext(TbodyContext.class,0); 423 } 424 public TheadContext thead() { 425 return getRuleContext(TheadContext.class,0); 426 } 427 public TfootContext tfoot() { 428 return getRuleContext(TfootContext.class,0); 429 } 430 public PTagStartContext pTagStart() { 431 return getRuleContext(PTagStartContext.class,0); 432 } 433 public LiTagStartContext liTagStart() { 434 return getRuleContext(LiTagStartContext.class,0); 435 } 436 public TrTagStartContext trTagStart() { 437 return getRuleContext(TrTagStartContext.class,0); 438 } 439 public TdTagStartContext tdTagStart() { 440 return getRuleContext(TdTagStartContext.class,0); 441 } 442 public ThTagStartContext thTagStart() { 443 return getRuleContext(ThTagStartContext.class,0); 444 } 445 public BodyTagStartContext bodyTagStart() { 446 return getRuleContext(BodyTagStartContext.class,0); 447 } 448 public ColgroupTagStartContext colgroupTagStart() { 449 return getRuleContext(ColgroupTagStartContext.class,0); 450 } 451 public DdTagStartContext ddTagStart() { 452 return getRuleContext(DdTagStartContext.class,0); 453 } 454 public DtTagStartContext dtTagStart() { 455 return getRuleContext(DtTagStartContext.class,0); 456 } 457 public HeadTagStartContext headTagStart() { 458 return getRuleContext(HeadTagStartContext.class,0); 459 } 460 public HtmlTagStartContext htmlTagStart() { 461 return getRuleContext(HtmlTagStartContext.class,0); 462 } 463 public OptionTagStartContext optionTagStart() { 464 return getRuleContext(OptionTagStartContext.class,0); 465 } 466 public TbodyTagStartContext tbodyTagStart() { 467 return getRuleContext(TbodyTagStartContext.class,0); 468 } 469 public TheadTagStartContext theadTagStart() { 470 return getRuleContext(TheadTagStartContext.class,0); 471 } 472 public TfootTagStartContext tfootTagStart() { 473 return getRuleContext(TfootTagStartContext.class,0); 474 } 475 public PTagEndContext pTagEnd() { 476 return getRuleContext(PTagEndContext.class,0); 477 } 478 public LiTagEndContext liTagEnd() { 479 return getRuleContext(LiTagEndContext.class,0); 480 } 481 public TrTagEndContext trTagEnd() { 482 return getRuleContext(TrTagEndContext.class,0); 483 } 484 public TdTagEndContext tdTagEnd() { 485 return getRuleContext(TdTagEndContext.class,0); 486 } 487 public ThTagEndContext thTagEnd() { 488 return getRuleContext(ThTagEndContext.class,0); 489 } 490 public BodyTagEndContext bodyTagEnd() { 491 return getRuleContext(BodyTagEndContext.class,0); 492 } 493 public ColgroupTagEndContext colgroupTagEnd() { 494 return getRuleContext(ColgroupTagEndContext.class,0); 495 } 496 public DdTagEndContext ddTagEnd() { 497 return getRuleContext(DdTagEndContext.class,0); 498 } 499 public DtTagEndContext dtTagEnd() { 500 return getRuleContext(DtTagEndContext.class,0); 501 } 502 public HeadTagEndContext headTagEnd() { 503 return getRuleContext(HeadTagEndContext.class,0); 504 } 505 public HtmlTagEndContext htmlTagEnd() { 506 return getRuleContext(HtmlTagEndContext.class,0); 507 } 508 public OptionTagEndContext optionTagEnd() { 509 return getRuleContext(OptionTagEndContext.class,0); 510 } 511 public TbodyTagEndContext tbodyTagEnd() { 512 return getRuleContext(TbodyTagEndContext.class,0); 513 } 514 public TheadTagEndContext theadTagEnd() { 515 return getRuleContext(TheadTagEndContext.class,0); 516 } 517 public TfootTagEndContext tfootTagEnd() { 518 return getRuleContext(TfootTagEndContext.class,0); 519 } 520 public HtmlElementContext(ParserRuleContext parent, int invokingState) { 521 super(parent, invokingState); 522 } 523 @Override public int getRuleIndex() { return RULE_htmlElement; } 524 } 525 526 public final HtmlElementContext htmlElement() throws RecognitionException { 527 HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState()); 528 enterRule(_localctx, 2, RULE_htmlElement); 529 try { 530 setState(237); 531 _errHandler.sync(this); 532 switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { 533 case 1: 534 enterOuterAlt(_localctx, 1); 535 { 536 setState(190); 537 htmlTag(); 538 } 539 break; 540 case 2: 541 enterOuterAlt(_localctx, 2); 542 { 543 setState(191); 544 singletonElement(); 545 } 546 break; 547 case 3: 548 enterOuterAlt(_localctx, 3); 549 { 550 setState(192); 551 paragraph(); 552 } 553 break; 554 case 4: 555 enterOuterAlt(_localctx, 4); 556 { 557 setState(193); 558 li(); 559 } 560 break; 561 case 5: 562 enterOuterAlt(_localctx, 5); 563 { 564 setState(194); 565 tr(); 566 } 567 break; 568 case 6: 569 enterOuterAlt(_localctx, 6); 570 { 571 setState(195); 572 td(); 573 } 574 break; 575 case 7: 576 enterOuterAlt(_localctx, 7); 577 { 578 setState(196); 579 th(); 580 } 581 break; 582 case 8: 583 enterOuterAlt(_localctx, 8); 584 { 585 setState(197); 586 body(); 587 } 588 break; 589 case 9: 590 enterOuterAlt(_localctx, 9); 591 { 592 setState(198); 593 colgroup(); 594 } 595 break; 596 case 10: 597 enterOuterAlt(_localctx, 10); 598 { 599 setState(199); 600 dd(); 601 } 602 break; 603 case 11: 604 enterOuterAlt(_localctx, 11); 605 { 606 setState(200); 607 dt(); 608 } 609 break; 610 case 12: 611 enterOuterAlt(_localctx, 12); 612 { 613 setState(201); 614 head(); 615 } 616 break; 617 case 13: 618 enterOuterAlt(_localctx, 13); 619 { 620 setState(202); 621 html(); 622 } 623 break; 624 case 14: 625 enterOuterAlt(_localctx, 14); 626 { 627 setState(203); 628 option(); 629 } 630 break; 631 case 15: 632 enterOuterAlt(_localctx, 15); 633 { 634 setState(204); 635 tbody(); 636 } 637 break; 638 case 16: 639 enterOuterAlt(_localctx, 16); 640 { 641 setState(205); 642 thead(); 643 } 644 break; 645 case 17: 646 enterOuterAlt(_localctx, 17); 647 { 648 setState(206); 649 tfoot(); 650 } 651 break; 652 case 18: 653 enterOuterAlt(_localctx, 18); 654 { 655 setState(207); 656 pTagStart(true); 657 } 658 break; 659 case 19: 660 enterOuterAlt(_localctx, 19); 661 { 662 setState(208); 663 liTagStart(true); 664 } 665 break; 666 case 20: 667 enterOuterAlt(_localctx, 20); 668 { 669 setState(209); 670 trTagStart(true); 671 } 672 break; 673 case 21: 674 enterOuterAlt(_localctx, 21); 675 { 676 setState(210); 677 tdTagStart(true); 678 } 679 break; 680 case 22: 681 enterOuterAlt(_localctx, 22); 682 { 683 setState(211); 684 thTagStart(true); 685 } 686 break; 687 case 23: 688 enterOuterAlt(_localctx, 23); 689 { 690 setState(212); 691 bodyTagStart(true); 692 } 693 break; 694 case 24: 695 enterOuterAlt(_localctx, 24); 696 { 697 setState(213); 698 colgroupTagStart(true); 699 } 700 break; 701 case 25: 702 enterOuterAlt(_localctx, 25); 703 { 704 setState(214); 705 ddTagStart(true); 706 } 707 break; 708 case 26: 709 enterOuterAlt(_localctx, 26); 710 { 711 setState(215); 712 dtTagStart(true); 713 } 714 break; 715 case 27: 716 enterOuterAlt(_localctx, 27); 717 { 718 setState(216); 719 headTagStart(true); 720 } 721 break; 722 case 28: 723 enterOuterAlt(_localctx, 28); 724 { 725 setState(217); 726 htmlTagStart(true); 727 } 728 break; 729 case 29: 730 enterOuterAlt(_localctx, 29); 731 { 732 setState(218); 733 optionTagStart(true); 734 } 735 break; 736 case 30: 737 enterOuterAlt(_localctx, 30); 738 { 739 setState(219); 740 tbodyTagStart(true); 741 } 742 break; 743 case 31: 744 enterOuterAlt(_localctx, 31); 745 { 746 setState(220); 747 theadTagStart(true); 748 } 749 break; 750 case 32: 751 enterOuterAlt(_localctx, 32); 752 { 753 setState(221); 754 tfootTagStart(true); 755 } 756 break; 757 case 33: 758 enterOuterAlt(_localctx, 33); 759 { 760 setState(222); 761 pTagEnd(); 762 } 763 break; 764 case 34: 765 enterOuterAlt(_localctx, 34); 766 { 767 setState(223); 768 liTagEnd(); 769 } 770 break; 771 case 35: 772 enterOuterAlt(_localctx, 35); 773 { 774 setState(224); 775 trTagEnd(); 776 } 777 break; 778 case 36: 779 enterOuterAlt(_localctx, 36); 780 { 781 setState(225); 782 tdTagEnd(); 783 } 784 break; 785 case 37: 786 enterOuterAlt(_localctx, 37); 787 { 788 setState(226); 789 thTagEnd(); 790 } 791 break; 792 case 38: 793 enterOuterAlt(_localctx, 38); 794 { 795 setState(227); 796 bodyTagEnd(); 797 } 798 break; 799 case 39: 800 enterOuterAlt(_localctx, 39); 801 { 802 setState(228); 803 colgroupTagEnd(); 804 } 805 break; 806 case 40: 807 enterOuterAlt(_localctx, 40); 808 { 809 setState(229); 810 ddTagEnd(); 811 } 812 break; 813 case 41: 814 enterOuterAlt(_localctx, 41); 815 { 816 setState(230); 817 dtTagEnd(); 818 } 819 break; 820 case 42: 821 enterOuterAlt(_localctx, 42); 822 { 823 setState(231); 824 headTagEnd(); 825 } 826 break; 827 case 43: 828 enterOuterAlt(_localctx, 43); 829 { 830 setState(232); 831 htmlTagEnd(); 832 } 833 break; 834 case 44: 835 enterOuterAlt(_localctx, 44); 836 { 837 setState(233); 838 optionTagEnd(); 839 } 840 break; 841 case 45: 842 enterOuterAlt(_localctx, 45); 843 { 844 setState(234); 845 tbodyTagEnd(); 846 } 847 break; 848 case 46: 849 enterOuterAlt(_localctx, 46); 850 { 851 setState(235); 852 theadTagEnd(); 853 } 854 break; 855 case 47: 856 enterOuterAlt(_localctx, 47); 857 { 858 setState(236); 859 tfootTagEnd(); 860 } 861 break; 862 } 863 } 864 catch (RecognitionException re) { 865 _localctx.exception = re; 866 _errHandler.reportError(this, re); 867 _errHandler.recover(this, re); 868 } 869 finally { 870 exitRule(); 871 } 872 return _localctx; 873 } 874 875 public static class HtmlElementStartContext extends ParserRuleContext { 876 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 877 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 878 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 879 public List<AttributeContext> attribute() { 880 return getRuleContexts(AttributeContext.class); 881 } 882 public AttributeContext attribute(int i) { 883 return getRuleContext(AttributeContext.class,i); 884 } 885 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 886 public TerminalNode NEWLINE(int i) { 887 return getToken(JavadocParser.NEWLINE, i); 888 } 889 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 890 public TerminalNode LEADING_ASTERISK(int i) { 891 return getToken(JavadocParser.LEADING_ASTERISK, i); 892 } 893 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 894 public TerminalNode WS(int i) { 895 return getToken(JavadocParser.WS, i); 896 } 897 public HtmlElementStartContext(ParserRuleContext parent, int invokingState) { 898 super(parent, invokingState); 899 } 900 @Override public int getRuleIndex() { return RULE_htmlElementStart; } 901 } 902 903 public final HtmlElementStartContext htmlElementStart() throws RecognitionException { 904 HtmlElementStartContext _localctx = new HtmlElementStartContext(_ctx, getState()); 905 enterRule(_localctx, 4, RULE_htmlElementStart); 906 int _la; 907 try { 908 enterOuterAlt(_localctx, 1); 909 { 910 setState(239); 911 match(START); 912 setState(240); 913 match(HTML_TAG_NAME); 914 setState(247); 915 _errHandler.sync(this); 916 _la = _input.LA(1); 917 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 918 { 919 setState(245); 920 _errHandler.sync(this); 921 switch (_input.LA(1)) { 922 case HTML_TAG_NAME: 923 { 924 setState(241); 925 attribute(); 926 } 927 break; 928 case NEWLINE: 929 { 930 setState(242); 931 match(NEWLINE); 932 } 933 break; 934 case LEADING_ASTERISK: 935 { 936 setState(243); 937 match(LEADING_ASTERISK); 938 } 939 break; 940 case WS: 941 { 942 setState(244); 943 match(WS); 944 } 945 break; 946 default: 947 throw new NoViableAltException(this); 948 } 949 } 950 setState(249); 951 _errHandler.sync(this); 952 _la = _input.LA(1); 953 } 954 setState(250); 955 match(END); 956 } 957 } 958 catch (RecognitionException re) { 959 _localctx.exception = re; 960 _errHandler.reportError(this, re); 961 _errHandler.recover(this, re); 962 } 963 finally { 964 exitRule(); 965 } 966 return _localctx; 967 } 968 969 public static class HtmlElementEndContext extends ParserRuleContext { 970 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 971 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 972 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 973 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 974 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 975 public TerminalNode NEWLINE(int i) { 976 return getToken(JavadocParser.NEWLINE, i); 977 } 978 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 979 public TerminalNode LEADING_ASTERISK(int i) { 980 return getToken(JavadocParser.LEADING_ASTERISK, i); 981 } 982 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 983 public TerminalNode WS(int i) { 984 return getToken(JavadocParser.WS, i); 985 } 986 public HtmlElementEndContext(ParserRuleContext parent, int invokingState) { 987 super(parent, invokingState); 988 } 989 @Override public int getRuleIndex() { return RULE_htmlElementEnd; } 990 } 991 992 public final HtmlElementEndContext htmlElementEnd() throws RecognitionException { 993 HtmlElementEndContext _localctx = new HtmlElementEndContext(_ctx, getState()); 994 enterRule(_localctx, 6, RULE_htmlElementEnd); 995 int _la; 996 try { 997 enterOuterAlt(_localctx, 1); 998 { 999 setState(252); 1000 match(START); 1001 setState(253); 1002 match(SLASH); 1003 setState(254); 1004 match(HTML_TAG_NAME); 1005 setState(258); 1006 _errHandler.sync(this); 1007 _la = _input.LA(1); 1008 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1009 { 1010 { 1011 setState(255); 1012 _la = _input.LA(1); 1013 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1014 _errHandler.recoverInline(this); 1015 } 1016 else { 1017 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1018 _errHandler.reportMatch(this); 1019 consume(); 1020 } 1021 } 1022 } 1023 setState(260); 1024 _errHandler.sync(this); 1025 _la = _input.LA(1); 1026 } 1027 setState(261); 1028 match(END); 1029 } 1030 } 1031 catch (RecognitionException re) { 1032 _localctx.exception = re; 1033 _errHandler.reportError(this, re); 1034 _errHandler.recover(this, re); 1035 } 1036 finally { 1037 exitRule(); 1038 } 1039 return _localctx; 1040 } 1041 1042 public static class AttributeContext extends ParserRuleContext { 1043 public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); } 1044 public TerminalNode HTML_TAG_NAME(int i) { 1045 return getToken(JavadocParser.HTML_TAG_NAME, i); 1046 } 1047 public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); } 1048 public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); } 1049 public TextContext text() { 1050 return getRuleContext(TextContext.class,0); 1051 } 1052 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1053 public TerminalNode NEWLINE(int i) { 1054 return getToken(JavadocParser.NEWLINE, i); 1055 } 1056 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1057 public TerminalNode LEADING_ASTERISK(int i) { 1058 return getToken(JavadocParser.LEADING_ASTERISK, i); 1059 } 1060 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1061 public TerminalNode WS(int i) { 1062 return getToken(JavadocParser.WS, i); 1063 } 1064 public AttributeContext(ParserRuleContext parent, int invokingState) { 1065 super(parent, invokingState); 1066 } 1067 @Override public int getRuleIndex() { return RULE_attribute; } 1068 } 1069 1070 public final AttributeContext attribute() throws RecognitionException { 1071 AttributeContext _localctx = new AttributeContext(_ctx, getState()); 1072 enterRule(_localctx, 8, RULE_attribute); 1073 int _la; 1074 try { 1075 int _alt; 1076 enterOuterAlt(_localctx, 1); 1077 { 1078 setState(263); 1079 match(HTML_TAG_NAME); 1080 setState(267); 1081 _errHandler.sync(this); 1082 _la = _input.LA(1); 1083 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1084 { 1085 { 1086 setState(264); 1087 _la = _input.LA(1); 1088 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1089 _errHandler.recoverInline(this); 1090 } 1091 else { 1092 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1093 _errHandler.reportMatch(this); 1094 consume(); 1095 } 1096 } 1097 } 1098 setState(269); 1099 _errHandler.sync(this); 1100 _la = _input.LA(1); 1101 } 1102 setState(270); 1103 match(EQUALS); 1104 setState(274); 1105 _errHandler.sync(this); 1106 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1107 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1108 if ( _alt==1 ) { 1109 { 1110 { 1111 setState(271); 1112 _la = _input.LA(1); 1113 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1114 _errHandler.recoverInline(this); 1115 } 1116 else { 1117 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1118 _errHandler.reportMatch(this); 1119 consume(); 1120 } 1121 } 1122 } 1123 } 1124 setState(276); 1125 _errHandler.sync(this); 1126 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1127 } 1128 setState(280); 1129 _errHandler.sync(this); 1130 switch (_input.LA(1)) { 1131 case ATTR_VALUE: 1132 { 1133 setState(277); 1134 match(ATTR_VALUE); 1135 } 1136 break; 1137 case WS: 1138 case CHAR: 1139 { 1140 setState(278); 1141 text(); 1142 } 1143 break; 1144 case HTML_TAG_NAME: 1145 { 1146 setState(279); 1147 match(HTML_TAG_NAME); 1148 } 1149 break; 1150 default: 1151 throw new NoViableAltException(this); 1152 } 1153 } 1154 } 1155 catch (RecognitionException re) { 1156 _localctx.exception = re; 1157 _errHandler.reportError(this, re); 1158 _errHandler.recover(this, re); 1159 } 1160 finally { 1161 exitRule(); 1162 } 1163 return _localctx; 1164 } 1165 1166 public static class HtmlTagContext extends ParserRuleContext { 1167 public HtmlElementStartContext htmlElementStart; 1168 public HtmlElementEndContext htmlElementEnd; 1169 public HtmlElementStartContext htmlElementStart() { 1170 return getRuleContext(HtmlElementStartContext.class,0); 1171 } 1172 public HtmlElementEndContext htmlElementEnd() { 1173 return getRuleContext(HtmlElementEndContext.class,0); 1174 } 1175 public List<HtmlElementContext> htmlElement() { 1176 return getRuleContexts(HtmlElementContext.class); 1177 } 1178 public HtmlElementContext htmlElement(int i) { 1179 return getRuleContext(HtmlElementContext.class,i); 1180 } 1181 public List<HtmlCommentContext> htmlComment() { 1182 return getRuleContexts(HtmlCommentContext.class); 1183 } 1184 public HtmlCommentContext htmlComment(int i) { 1185 return getRuleContext(HtmlCommentContext.class,i); 1186 } 1187 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1188 public TerminalNode CDATA(int i) { 1189 return getToken(JavadocParser.CDATA, i); 1190 } 1191 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1192 public TerminalNode NEWLINE(int i) { 1193 return getToken(JavadocParser.NEWLINE, i); 1194 } 1195 public List<TextContext> text() { 1196 return getRuleContexts(TextContext.class); 1197 } 1198 public TextContext text(int i) { 1199 return getRuleContext(TextContext.class,i); 1200 } 1201 public List<JavadocInlineTagContext> javadocInlineTag() { 1202 return getRuleContexts(JavadocInlineTagContext.class); 1203 } 1204 public JavadocInlineTagContext javadocInlineTag(int i) { 1205 return getRuleContext(JavadocInlineTagContext.class,i); 1206 } 1207 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1208 public TerminalNode LEADING_ASTERISK(int i) { 1209 return getToken(JavadocParser.LEADING_ASTERISK, i); 1210 } 1211 public HtmlTagContext(ParserRuleContext parent, int invokingState) { 1212 super(parent, invokingState); 1213 } 1214 @Override public int getRuleIndex() { return RULE_htmlTag; } 1215 } 1216 1217 public final HtmlTagContext htmlTag() throws RecognitionException { 1218 HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState()); 1219 enterRule(_localctx, 10, RULE_htmlTag); 1220 try { 1221 int _alt; 1222 enterOuterAlt(_localctx, 1); 1223 { 1224 setState(282); 1225 ((HtmlTagContext)_localctx).htmlElementStart = htmlElementStart(); 1226 setState(293); 1227 _errHandler.sync(this); 1228 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1229 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1230 if ( _alt==1 ) { 1231 { 1232 setState(291); 1233 _errHandler.sync(this); 1234 switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { 1235 case 1: 1236 { 1237 setState(283); 1238 htmlElement(); 1239 } 1240 break; 1241 case 2: 1242 { 1243 { 1244 setState(284); 1245 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1246 setState(285); 1247 match(LEADING_ASTERISK); 1248 } 1249 } 1250 break; 1251 case 3: 1252 { 1253 setState(286); 1254 htmlComment(); 1255 } 1256 break; 1257 case 4: 1258 { 1259 setState(287); 1260 match(CDATA); 1261 } 1262 break; 1263 case 5: 1264 { 1265 setState(288); 1266 match(NEWLINE); 1267 } 1268 break; 1269 case 6: 1270 { 1271 setState(289); 1272 text(); 1273 } 1274 break; 1275 case 7: 1276 { 1277 setState(290); 1278 javadocInlineTag(); 1279 } 1280 break; 1281 } 1282 } 1283 } 1284 setState(295); 1285 _errHandler.sync(this); 1286 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1287 } 1288 setState(296); 1289 ((HtmlTagContext)_localctx).htmlElementEnd = htmlElementEnd(); 1290 setState(297); 1291 if (!(isSameTagNames(((HtmlTagContext)_localctx).htmlElementStart, ((HtmlTagContext)_localctx).htmlElementEnd))) throw new FailedPredicateException(this, "isSameTagNames($htmlElementStart.ctx, $htmlElementEnd.ctx)"); 1292 } 1293 } 1294 catch (RecognitionException re) { 1295 _localctx.exception = re; 1296 _errHandler.reportError(this, re); 1297 _errHandler.recover(this, re); 1298 } 1299 finally { 1300 exitRule(); 1301 } 1302 return _localctx; 1303 } 1304 1305 public static class PTagStartContext extends ParserRuleContext { 1306 public boolean isNonTight; 1307 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 1308 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1309 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 1310 public List<AttributeContext> attribute() { 1311 return getRuleContexts(AttributeContext.class); 1312 } 1313 public AttributeContext attribute(int i) { 1314 return getRuleContext(AttributeContext.class,i); 1315 } 1316 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1317 public TerminalNode NEWLINE(int i) { 1318 return getToken(JavadocParser.NEWLINE, i); 1319 } 1320 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1321 public TerminalNode LEADING_ASTERISK(int i) { 1322 return getToken(JavadocParser.LEADING_ASTERISK, i); 1323 } 1324 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1325 public TerminalNode WS(int i) { 1326 return getToken(JavadocParser.WS, i); 1327 } 1328 public PTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 1329 public PTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 1330 super(parent, invokingState); 1331 this.isNonTight = isNonTight; 1332 } 1333 @Override public int getRuleIndex() { return RULE_pTagStart; } 1334 } 1335 1336 public final PTagStartContext pTagStart(boolean isNonTight) throws RecognitionException { 1337 PTagStartContext _localctx = new PTagStartContext(_ctx, getState(), isNonTight); 1338 enterRule(_localctx, 12, RULE_pTagStart); 1339 int _la; 1340 try { 1341 enterOuterAlt(_localctx, 1); 1342 { 1343 setState(299); 1344 match(START); 1345 setState(300); 1346 match(P_HTML_TAG_NAME); 1347 setState(307); 1348 _errHandler.sync(this); 1349 _la = _input.LA(1); 1350 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 1351 { 1352 setState(305); 1353 _errHandler.sync(this); 1354 switch (_input.LA(1)) { 1355 case HTML_TAG_NAME: 1356 { 1357 setState(301); 1358 attribute(); 1359 } 1360 break; 1361 case NEWLINE: 1362 { 1363 setState(302); 1364 match(NEWLINE); 1365 } 1366 break; 1367 case LEADING_ASTERISK: 1368 { 1369 setState(303); 1370 match(LEADING_ASTERISK); 1371 } 1372 break; 1373 case WS: 1374 { 1375 setState(304); 1376 match(WS); 1377 } 1378 break; 1379 default: 1380 throw new NoViableAltException(this); 1381 } 1382 } 1383 setState(309); 1384 _errHandler.sync(this); 1385 _la = _input.LA(1); 1386 } 1387 setState(310); 1388 match(END); 1389 } 1390 _ctx.stop = _input.LT(-1); 1391 1392 if (isNonTight && nonTightTagStartContext == null) { 1393 nonTightTagStartContext = _localctx; 1394 } 1395 1396 } 1397 catch (RecognitionException re) { 1398 _localctx.exception = re; 1399 _errHandler.reportError(this, re); 1400 _errHandler.recover(this, re); 1401 } 1402 finally { 1403 exitRule(); 1404 } 1405 return _localctx; 1406 } 1407 1408 public static class PTagEndContext extends ParserRuleContext { 1409 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 1410 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1411 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1412 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 1413 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1414 public TerminalNode NEWLINE(int i) { 1415 return getToken(JavadocParser.NEWLINE, i); 1416 } 1417 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1418 public TerminalNode LEADING_ASTERISK(int i) { 1419 return getToken(JavadocParser.LEADING_ASTERISK, i); 1420 } 1421 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1422 public TerminalNode WS(int i) { 1423 return getToken(JavadocParser.WS, i); 1424 } 1425 public PTagEndContext(ParserRuleContext parent, int invokingState) { 1426 super(parent, invokingState); 1427 } 1428 @Override public int getRuleIndex() { return RULE_pTagEnd; } 1429 } 1430 1431 public final PTagEndContext pTagEnd() throws RecognitionException { 1432 PTagEndContext _localctx = new PTagEndContext(_ctx, getState()); 1433 enterRule(_localctx, 14, RULE_pTagEnd); 1434 int _la; 1435 try { 1436 enterOuterAlt(_localctx, 1); 1437 { 1438 setState(312); 1439 match(START); 1440 setState(313); 1441 match(SLASH); 1442 setState(314); 1443 match(P_HTML_TAG_NAME); 1444 setState(318); 1445 _errHandler.sync(this); 1446 _la = _input.LA(1); 1447 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1448 { 1449 { 1450 setState(315); 1451 _la = _input.LA(1); 1452 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1453 _errHandler.recoverInline(this); 1454 } 1455 else { 1456 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1457 _errHandler.reportMatch(this); 1458 consume(); 1459 } 1460 } 1461 } 1462 setState(320); 1463 _errHandler.sync(this); 1464 _la = _input.LA(1); 1465 } 1466 setState(321); 1467 match(END); 1468 } 1469 } 1470 catch (RecognitionException re) { 1471 _localctx.exception = re; 1472 _errHandler.reportError(this, re); 1473 _errHandler.recover(this, re); 1474 } 1475 finally { 1476 exitRule(); 1477 } 1478 return _localctx; 1479 } 1480 1481 public static class ParagraphContext extends ParserRuleContext { 1482 public PTagStartContext pTagStart() { 1483 return getRuleContext(PTagStartContext.class,0); 1484 } 1485 public PTagEndContext pTagEnd() { 1486 return getRuleContext(PTagEndContext.class,0); 1487 } 1488 public List<HtmlTagContext> htmlTag() { 1489 return getRuleContexts(HtmlTagContext.class); 1490 } 1491 public HtmlTagContext htmlTag(int i) { 1492 return getRuleContext(HtmlTagContext.class,i); 1493 } 1494 public List<SingletonElementContext> singletonElement() { 1495 return getRuleContexts(SingletonElementContext.class); 1496 } 1497 public SingletonElementContext singletonElement(int i) { 1498 return getRuleContext(SingletonElementContext.class,i); 1499 } 1500 public List<LiContext> li() { 1501 return getRuleContexts(LiContext.class); 1502 } 1503 public LiContext li(int i) { 1504 return getRuleContext(LiContext.class,i); 1505 } 1506 public List<TrContext> tr() { 1507 return getRuleContexts(TrContext.class); 1508 } 1509 public TrContext tr(int i) { 1510 return getRuleContext(TrContext.class,i); 1511 } 1512 public List<TdContext> td() { 1513 return getRuleContexts(TdContext.class); 1514 } 1515 public TdContext td(int i) { 1516 return getRuleContext(TdContext.class,i); 1517 } 1518 public List<ThContext> th() { 1519 return getRuleContexts(ThContext.class); 1520 } 1521 public ThContext th(int i) { 1522 return getRuleContext(ThContext.class,i); 1523 } 1524 public List<BodyContext> body() { 1525 return getRuleContexts(BodyContext.class); 1526 } 1527 public BodyContext body(int i) { 1528 return getRuleContext(BodyContext.class,i); 1529 } 1530 public List<ColgroupContext> colgroup() { 1531 return getRuleContexts(ColgroupContext.class); 1532 } 1533 public ColgroupContext colgroup(int i) { 1534 return getRuleContext(ColgroupContext.class,i); 1535 } 1536 public List<DdContext> dd() { 1537 return getRuleContexts(DdContext.class); 1538 } 1539 public DdContext dd(int i) { 1540 return getRuleContext(DdContext.class,i); 1541 } 1542 public List<DtContext> dt() { 1543 return getRuleContexts(DtContext.class); 1544 } 1545 public DtContext dt(int i) { 1546 return getRuleContext(DtContext.class,i); 1547 } 1548 public List<HeadContext> head() { 1549 return getRuleContexts(HeadContext.class); 1550 } 1551 public HeadContext head(int i) { 1552 return getRuleContext(HeadContext.class,i); 1553 } 1554 public List<HtmlContext> html() { 1555 return getRuleContexts(HtmlContext.class); 1556 } 1557 public HtmlContext html(int i) { 1558 return getRuleContext(HtmlContext.class,i); 1559 } 1560 public List<OptionContext> option() { 1561 return getRuleContexts(OptionContext.class); 1562 } 1563 public OptionContext option(int i) { 1564 return getRuleContext(OptionContext.class,i); 1565 } 1566 public List<TbodyContext> tbody() { 1567 return getRuleContexts(TbodyContext.class); 1568 } 1569 public TbodyContext tbody(int i) { 1570 return getRuleContext(TbodyContext.class,i); 1571 } 1572 public List<TheadContext> thead() { 1573 return getRuleContexts(TheadContext.class); 1574 } 1575 public TheadContext thead(int i) { 1576 return getRuleContext(TheadContext.class,i); 1577 } 1578 public List<TfootContext> tfoot() { 1579 return getRuleContexts(TfootContext.class); 1580 } 1581 public TfootContext tfoot(int i) { 1582 return getRuleContext(TfootContext.class,i); 1583 } 1584 public List<LiTagStartContext> liTagStart() { 1585 return getRuleContexts(LiTagStartContext.class); 1586 } 1587 public LiTagStartContext liTagStart(int i) { 1588 return getRuleContext(LiTagStartContext.class,i); 1589 } 1590 public List<TrTagStartContext> trTagStart() { 1591 return getRuleContexts(TrTagStartContext.class); 1592 } 1593 public TrTagStartContext trTagStart(int i) { 1594 return getRuleContext(TrTagStartContext.class,i); 1595 } 1596 public List<TdTagStartContext> tdTagStart() { 1597 return getRuleContexts(TdTagStartContext.class); 1598 } 1599 public TdTagStartContext tdTagStart(int i) { 1600 return getRuleContext(TdTagStartContext.class,i); 1601 } 1602 public List<ThTagStartContext> thTagStart() { 1603 return getRuleContexts(ThTagStartContext.class); 1604 } 1605 public ThTagStartContext thTagStart(int i) { 1606 return getRuleContext(ThTagStartContext.class,i); 1607 } 1608 public List<BodyTagStartContext> bodyTagStart() { 1609 return getRuleContexts(BodyTagStartContext.class); 1610 } 1611 public BodyTagStartContext bodyTagStart(int i) { 1612 return getRuleContext(BodyTagStartContext.class,i); 1613 } 1614 public List<ColgroupTagStartContext> colgroupTagStart() { 1615 return getRuleContexts(ColgroupTagStartContext.class); 1616 } 1617 public ColgroupTagStartContext colgroupTagStart(int i) { 1618 return getRuleContext(ColgroupTagStartContext.class,i); 1619 } 1620 public List<DdTagStartContext> ddTagStart() { 1621 return getRuleContexts(DdTagStartContext.class); 1622 } 1623 public DdTagStartContext ddTagStart(int i) { 1624 return getRuleContext(DdTagStartContext.class,i); 1625 } 1626 public List<DtTagStartContext> dtTagStart() { 1627 return getRuleContexts(DtTagStartContext.class); 1628 } 1629 public DtTagStartContext dtTagStart(int i) { 1630 return getRuleContext(DtTagStartContext.class,i); 1631 } 1632 public List<HeadTagStartContext> headTagStart() { 1633 return getRuleContexts(HeadTagStartContext.class); 1634 } 1635 public HeadTagStartContext headTagStart(int i) { 1636 return getRuleContext(HeadTagStartContext.class,i); 1637 } 1638 public List<HtmlTagStartContext> htmlTagStart() { 1639 return getRuleContexts(HtmlTagStartContext.class); 1640 } 1641 public HtmlTagStartContext htmlTagStart(int i) { 1642 return getRuleContext(HtmlTagStartContext.class,i); 1643 } 1644 public List<OptionTagStartContext> optionTagStart() { 1645 return getRuleContexts(OptionTagStartContext.class); 1646 } 1647 public OptionTagStartContext optionTagStart(int i) { 1648 return getRuleContext(OptionTagStartContext.class,i); 1649 } 1650 public List<TbodyTagStartContext> tbodyTagStart() { 1651 return getRuleContexts(TbodyTagStartContext.class); 1652 } 1653 public TbodyTagStartContext tbodyTagStart(int i) { 1654 return getRuleContext(TbodyTagStartContext.class,i); 1655 } 1656 public List<TheadTagStartContext> theadTagStart() { 1657 return getRuleContexts(TheadTagStartContext.class); 1658 } 1659 public TheadTagStartContext theadTagStart(int i) { 1660 return getRuleContext(TheadTagStartContext.class,i); 1661 } 1662 public List<TfootTagStartContext> tfootTagStart() { 1663 return getRuleContexts(TfootTagStartContext.class); 1664 } 1665 public TfootTagStartContext tfootTagStart(int i) { 1666 return getRuleContext(TfootTagStartContext.class,i); 1667 } 1668 public List<HtmlCommentContext> htmlComment() { 1669 return getRuleContexts(HtmlCommentContext.class); 1670 } 1671 public HtmlCommentContext htmlComment(int i) { 1672 return getRuleContext(HtmlCommentContext.class,i); 1673 } 1674 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1675 public TerminalNode CDATA(int i) { 1676 return getToken(JavadocParser.CDATA, i); 1677 } 1678 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1679 public TerminalNode NEWLINE(int i) { 1680 return getToken(JavadocParser.NEWLINE, i); 1681 } 1682 public List<TextContext> text() { 1683 return getRuleContexts(TextContext.class); 1684 } 1685 public TextContext text(int i) { 1686 return getRuleContext(TextContext.class,i); 1687 } 1688 public List<JavadocInlineTagContext> javadocInlineTag() { 1689 return getRuleContexts(JavadocInlineTagContext.class); 1690 } 1691 public JavadocInlineTagContext javadocInlineTag(int i) { 1692 return getRuleContext(JavadocInlineTagContext.class,i); 1693 } 1694 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1695 public TerminalNode LEADING_ASTERISK(int i) { 1696 return getToken(JavadocParser.LEADING_ASTERISK, i); 1697 } 1698 public ParagraphContext(ParserRuleContext parent, int invokingState) { 1699 super(parent, invokingState); 1700 } 1701 @Override public int getRuleIndex() { return RULE_paragraph; } 1702 } 1703 1704 public final ParagraphContext paragraph() throws RecognitionException { 1705 ParagraphContext _localctx = new ParagraphContext(_ctx, getState()); 1706 enterRule(_localctx, 16, RULE_paragraph); 1707 try { 1708 int _alt; 1709 enterOuterAlt(_localctx, 1); 1710 { 1711 setState(323); 1712 pTagStart(false); 1713 setState(363); 1714 _errHandler.sync(this); 1715 _alt = getInterpreter().adaptivePredict(_input,18,_ctx); 1716 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1717 if ( _alt==1 ) { 1718 { 1719 setState(361); 1720 _errHandler.sync(this); 1721 switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { 1722 case 1: 1723 { 1724 setState(324); 1725 htmlTag(); 1726 } 1727 break; 1728 case 2: 1729 { 1730 setState(325); 1731 singletonElement(); 1732 } 1733 break; 1734 case 3: 1735 { 1736 setState(326); 1737 li(); 1738 } 1739 break; 1740 case 4: 1741 { 1742 setState(327); 1743 tr(); 1744 } 1745 break; 1746 case 5: 1747 { 1748 setState(328); 1749 td(); 1750 } 1751 break; 1752 case 6: 1753 { 1754 setState(329); 1755 th(); 1756 } 1757 break; 1758 case 7: 1759 { 1760 setState(330); 1761 body(); 1762 } 1763 break; 1764 case 8: 1765 { 1766 setState(331); 1767 colgroup(); 1768 } 1769 break; 1770 case 9: 1771 { 1772 setState(332); 1773 dd(); 1774 } 1775 break; 1776 case 10: 1777 { 1778 setState(333); 1779 dt(); 1780 } 1781 break; 1782 case 11: 1783 { 1784 setState(334); 1785 head(); 1786 } 1787 break; 1788 case 12: 1789 { 1790 setState(335); 1791 html(); 1792 } 1793 break; 1794 case 13: 1795 { 1796 setState(336); 1797 option(); 1798 } 1799 break; 1800 case 14: 1801 { 1802 setState(337); 1803 tbody(); 1804 } 1805 break; 1806 case 15: 1807 { 1808 setState(338); 1809 thead(); 1810 } 1811 break; 1812 case 16: 1813 { 1814 setState(339); 1815 tfoot(); 1816 } 1817 break; 1818 case 17: 1819 { 1820 setState(340); 1821 liTagStart(true); 1822 } 1823 break; 1824 case 18: 1825 { 1826 setState(341); 1827 trTagStart(true); 1828 } 1829 break; 1830 case 19: 1831 { 1832 setState(342); 1833 tdTagStart(true); 1834 } 1835 break; 1836 case 20: 1837 { 1838 setState(343); 1839 thTagStart(true); 1840 } 1841 break; 1842 case 21: 1843 { 1844 setState(344); 1845 bodyTagStart(true); 1846 } 1847 break; 1848 case 22: 1849 { 1850 setState(345); 1851 colgroupTagStart(true); 1852 } 1853 break; 1854 case 23: 1855 { 1856 setState(346); 1857 ddTagStart(true); 1858 } 1859 break; 1860 case 24: 1861 { 1862 setState(347); 1863 dtTagStart(true); 1864 } 1865 break; 1866 case 25: 1867 { 1868 setState(348); 1869 headTagStart(true); 1870 } 1871 break; 1872 case 26: 1873 { 1874 setState(349); 1875 htmlTagStart(true); 1876 } 1877 break; 1878 case 27: 1879 { 1880 setState(350); 1881 optionTagStart(true); 1882 } 1883 break; 1884 case 28: 1885 { 1886 setState(351); 1887 tbodyTagStart(true); 1888 } 1889 break; 1890 case 29: 1891 { 1892 setState(352); 1893 theadTagStart(true); 1894 } 1895 break; 1896 case 30: 1897 { 1898 setState(353); 1899 tfootTagStart(true); 1900 } 1901 break; 1902 case 31: 1903 { 1904 { 1905 setState(354); 1906 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1907 setState(355); 1908 match(LEADING_ASTERISK); 1909 } 1910 } 1911 break; 1912 case 32: 1913 { 1914 setState(356); 1915 htmlComment(); 1916 } 1917 break; 1918 case 33: 1919 { 1920 setState(357); 1921 match(CDATA); 1922 } 1923 break; 1924 case 34: 1925 { 1926 setState(358); 1927 match(NEWLINE); 1928 } 1929 break; 1930 case 35: 1931 { 1932 setState(359); 1933 text(); 1934 } 1935 break; 1936 case 36: 1937 { 1938 setState(360); 1939 javadocInlineTag(); 1940 } 1941 break; 1942 } 1943 } 1944 } 1945 setState(365); 1946 _errHandler.sync(this); 1947 _alt = getInterpreter().adaptivePredict(_input,18,_ctx); 1948 } 1949 setState(366); 1950 pTagEnd(); 1951 } 1952 } 1953 catch (RecognitionException re) { 1954 _localctx.exception = re; 1955 _errHandler.reportError(this, re); 1956 _errHandler.recover(this, re); 1957 } 1958 finally { 1959 exitRule(); 1960 } 1961 return _localctx; 1962 } 1963 1964 public static class LiTagStartContext extends ParserRuleContext { 1965 public boolean isNonTight; 1966 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 1967 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 1968 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 1969 public List<AttributeContext> attribute() { 1970 return getRuleContexts(AttributeContext.class); 1971 } 1972 public AttributeContext attribute(int i) { 1973 return getRuleContext(AttributeContext.class,i); 1974 } 1975 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1976 public TerminalNode NEWLINE(int i) { 1977 return getToken(JavadocParser.NEWLINE, i); 1978 } 1979 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1980 public TerminalNode LEADING_ASTERISK(int i) { 1981 return getToken(JavadocParser.LEADING_ASTERISK, i); 1982 } 1983 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1984 public TerminalNode WS(int i) { 1985 return getToken(JavadocParser.WS, i); 1986 } 1987 public LiTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 1988 public LiTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 1989 super(parent, invokingState); 1990 this.isNonTight = isNonTight; 1991 } 1992 @Override public int getRuleIndex() { return RULE_liTagStart; } 1993 } 1994 1995 public final LiTagStartContext liTagStart(boolean isNonTight) throws RecognitionException { 1996 LiTagStartContext _localctx = new LiTagStartContext(_ctx, getState(), isNonTight); 1997 enterRule(_localctx, 18, RULE_liTagStart); 1998 int _la; 1999 try { 2000 enterOuterAlt(_localctx, 1); 2001 { 2002 setState(368); 2003 match(START); 2004 setState(369); 2005 match(LI_HTML_TAG_NAME); 2006 setState(376); 2007 _errHandler.sync(this); 2008 _la = _input.LA(1); 2009 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2010 { 2011 setState(374); 2012 _errHandler.sync(this); 2013 switch (_input.LA(1)) { 2014 case HTML_TAG_NAME: 2015 { 2016 setState(370); 2017 attribute(); 2018 } 2019 break; 2020 case NEWLINE: 2021 { 2022 setState(371); 2023 match(NEWLINE); 2024 } 2025 break; 2026 case LEADING_ASTERISK: 2027 { 2028 setState(372); 2029 match(LEADING_ASTERISK); 2030 } 2031 break; 2032 case WS: 2033 { 2034 setState(373); 2035 match(WS); 2036 } 2037 break; 2038 default: 2039 throw new NoViableAltException(this); 2040 } 2041 } 2042 setState(378); 2043 _errHandler.sync(this); 2044 _la = _input.LA(1); 2045 } 2046 setState(379); 2047 match(END); 2048 } 2049 _ctx.stop = _input.LT(-1); 2050 2051 if (isNonTight && nonTightTagStartContext == null) { 2052 nonTightTagStartContext = _localctx; 2053 } 2054 2055 } 2056 catch (RecognitionException re) { 2057 _localctx.exception = re; 2058 _errHandler.reportError(this, re); 2059 _errHandler.recover(this, re); 2060 } 2061 finally { 2062 exitRule(); 2063 } 2064 return _localctx; 2065 } 2066 2067 public static class LiTagEndContext extends ParserRuleContext { 2068 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 2069 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2070 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2071 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 2072 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2073 public TerminalNode NEWLINE(int i) { 2074 return getToken(JavadocParser.NEWLINE, i); 2075 } 2076 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2077 public TerminalNode LEADING_ASTERISK(int i) { 2078 return getToken(JavadocParser.LEADING_ASTERISK, i); 2079 } 2080 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2081 public TerminalNode WS(int i) { 2082 return getToken(JavadocParser.WS, i); 2083 } 2084 public LiTagEndContext(ParserRuleContext parent, int invokingState) { 2085 super(parent, invokingState); 2086 } 2087 @Override public int getRuleIndex() { return RULE_liTagEnd; } 2088 } 2089 2090 public final LiTagEndContext liTagEnd() throws RecognitionException { 2091 LiTagEndContext _localctx = new LiTagEndContext(_ctx, getState()); 2092 enterRule(_localctx, 20, RULE_liTagEnd); 2093 int _la; 2094 try { 2095 enterOuterAlt(_localctx, 1); 2096 { 2097 setState(381); 2098 match(START); 2099 setState(382); 2100 match(SLASH); 2101 setState(383); 2102 match(LI_HTML_TAG_NAME); 2103 setState(387); 2104 _errHandler.sync(this); 2105 _la = _input.LA(1); 2106 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2107 { 2108 { 2109 setState(384); 2110 _la = _input.LA(1); 2111 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2112 _errHandler.recoverInline(this); 2113 } 2114 else { 2115 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 2116 _errHandler.reportMatch(this); 2117 consume(); 2118 } 2119 } 2120 } 2121 setState(389); 2122 _errHandler.sync(this); 2123 _la = _input.LA(1); 2124 } 2125 setState(390); 2126 match(END); 2127 } 2128 } 2129 catch (RecognitionException re) { 2130 _localctx.exception = re; 2131 _errHandler.reportError(this, re); 2132 _errHandler.recover(this, re); 2133 } 2134 finally { 2135 exitRule(); 2136 } 2137 return _localctx; 2138 } 2139 2140 public static class LiContext extends ParserRuleContext { 2141 public LiTagStartContext liTagStart() { 2142 return getRuleContext(LiTagStartContext.class,0); 2143 } 2144 public LiTagEndContext liTagEnd() { 2145 return getRuleContext(LiTagEndContext.class,0); 2146 } 2147 public List<HtmlTagContext> htmlTag() { 2148 return getRuleContexts(HtmlTagContext.class); 2149 } 2150 public HtmlTagContext htmlTag(int i) { 2151 return getRuleContext(HtmlTagContext.class,i); 2152 } 2153 public List<SingletonElementContext> singletonElement() { 2154 return getRuleContexts(SingletonElementContext.class); 2155 } 2156 public SingletonElementContext singletonElement(int i) { 2157 return getRuleContext(SingletonElementContext.class,i); 2158 } 2159 public List<ParagraphContext> paragraph() { 2160 return getRuleContexts(ParagraphContext.class); 2161 } 2162 public ParagraphContext paragraph(int i) { 2163 return getRuleContext(ParagraphContext.class,i); 2164 } 2165 public List<TrContext> tr() { 2166 return getRuleContexts(TrContext.class); 2167 } 2168 public TrContext tr(int i) { 2169 return getRuleContext(TrContext.class,i); 2170 } 2171 public List<TdContext> td() { 2172 return getRuleContexts(TdContext.class); 2173 } 2174 public TdContext td(int i) { 2175 return getRuleContext(TdContext.class,i); 2176 } 2177 public List<ThContext> th() { 2178 return getRuleContexts(ThContext.class); 2179 } 2180 public ThContext th(int i) { 2181 return getRuleContext(ThContext.class,i); 2182 } 2183 public List<BodyContext> body() { 2184 return getRuleContexts(BodyContext.class); 2185 } 2186 public BodyContext body(int i) { 2187 return getRuleContext(BodyContext.class,i); 2188 } 2189 public List<ColgroupContext> colgroup() { 2190 return getRuleContexts(ColgroupContext.class); 2191 } 2192 public ColgroupContext colgroup(int i) { 2193 return getRuleContext(ColgroupContext.class,i); 2194 } 2195 public List<DdContext> dd() { 2196 return getRuleContexts(DdContext.class); 2197 } 2198 public DdContext dd(int i) { 2199 return getRuleContext(DdContext.class,i); 2200 } 2201 public List<DtContext> dt() { 2202 return getRuleContexts(DtContext.class); 2203 } 2204 public DtContext dt(int i) { 2205 return getRuleContext(DtContext.class,i); 2206 } 2207 public List<HeadContext> head() { 2208 return getRuleContexts(HeadContext.class); 2209 } 2210 public HeadContext head(int i) { 2211 return getRuleContext(HeadContext.class,i); 2212 } 2213 public List<HtmlContext> html() { 2214 return getRuleContexts(HtmlContext.class); 2215 } 2216 public HtmlContext html(int i) { 2217 return getRuleContext(HtmlContext.class,i); 2218 } 2219 public List<OptionContext> option() { 2220 return getRuleContexts(OptionContext.class); 2221 } 2222 public OptionContext option(int i) { 2223 return getRuleContext(OptionContext.class,i); 2224 } 2225 public List<TbodyContext> tbody() { 2226 return getRuleContexts(TbodyContext.class); 2227 } 2228 public TbodyContext tbody(int i) { 2229 return getRuleContext(TbodyContext.class,i); 2230 } 2231 public List<TheadContext> thead() { 2232 return getRuleContexts(TheadContext.class); 2233 } 2234 public TheadContext thead(int i) { 2235 return getRuleContext(TheadContext.class,i); 2236 } 2237 public List<TfootContext> tfoot() { 2238 return getRuleContexts(TfootContext.class); 2239 } 2240 public TfootContext tfoot(int i) { 2241 return getRuleContext(TfootContext.class,i); 2242 } 2243 public List<PTagStartContext> pTagStart() { 2244 return getRuleContexts(PTagStartContext.class); 2245 } 2246 public PTagStartContext pTagStart(int i) { 2247 return getRuleContext(PTagStartContext.class,i); 2248 } 2249 public List<TrTagStartContext> trTagStart() { 2250 return getRuleContexts(TrTagStartContext.class); 2251 } 2252 public TrTagStartContext trTagStart(int i) { 2253 return getRuleContext(TrTagStartContext.class,i); 2254 } 2255 public List<TdTagStartContext> tdTagStart() { 2256 return getRuleContexts(TdTagStartContext.class); 2257 } 2258 public TdTagStartContext tdTagStart(int i) { 2259 return getRuleContext(TdTagStartContext.class,i); 2260 } 2261 public List<ThTagStartContext> thTagStart() { 2262 return getRuleContexts(ThTagStartContext.class); 2263 } 2264 public ThTagStartContext thTagStart(int i) { 2265 return getRuleContext(ThTagStartContext.class,i); 2266 } 2267 public List<BodyTagStartContext> bodyTagStart() { 2268 return getRuleContexts(BodyTagStartContext.class); 2269 } 2270 public BodyTagStartContext bodyTagStart(int i) { 2271 return getRuleContext(BodyTagStartContext.class,i); 2272 } 2273 public List<ColgroupTagStartContext> colgroupTagStart() { 2274 return getRuleContexts(ColgroupTagStartContext.class); 2275 } 2276 public ColgroupTagStartContext colgroupTagStart(int i) { 2277 return getRuleContext(ColgroupTagStartContext.class,i); 2278 } 2279 public List<DdTagStartContext> ddTagStart() { 2280 return getRuleContexts(DdTagStartContext.class); 2281 } 2282 public DdTagStartContext ddTagStart(int i) { 2283 return getRuleContext(DdTagStartContext.class,i); 2284 } 2285 public List<DtTagStartContext> dtTagStart() { 2286 return getRuleContexts(DtTagStartContext.class); 2287 } 2288 public DtTagStartContext dtTagStart(int i) { 2289 return getRuleContext(DtTagStartContext.class,i); 2290 } 2291 public List<HeadTagStartContext> headTagStart() { 2292 return getRuleContexts(HeadTagStartContext.class); 2293 } 2294 public HeadTagStartContext headTagStart(int i) { 2295 return getRuleContext(HeadTagStartContext.class,i); 2296 } 2297 public List<HtmlTagStartContext> htmlTagStart() { 2298 return getRuleContexts(HtmlTagStartContext.class); 2299 } 2300 public HtmlTagStartContext htmlTagStart(int i) { 2301 return getRuleContext(HtmlTagStartContext.class,i); 2302 } 2303 public List<OptionTagStartContext> optionTagStart() { 2304 return getRuleContexts(OptionTagStartContext.class); 2305 } 2306 public OptionTagStartContext optionTagStart(int i) { 2307 return getRuleContext(OptionTagStartContext.class,i); 2308 } 2309 public List<TbodyTagStartContext> tbodyTagStart() { 2310 return getRuleContexts(TbodyTagStartContext.class); 2311 } 2312 public TbodyTagStartContext tbodyTagStart(int i) { 2313 return getRuleContext(TbodyTagStartContext.class,i); 2314 } 2315 public List<TheadTagStartContext> theadTagStart() { 2316 return getRuleContexts(TheadTagStartContext.class); 2317 } 2318 public TheadTagStartContext theadTagStart(int i) { 2319 return getRuleContext(TheadTagStartContext.class,i); 2320 } 2321 public List<TfootTagStartContext> tfootTagStart() { 2322 return getRuleContexts(TfootTagStartContext.class); 2323 } 2324 public TfootTagStartContext tfootTagStart(int i) { 2325 return getRuleContext(TfootTagStartContext.class,i); 2326 } 2327 public List<HtmlCommentContext> htmlComment() { 2328 return getRuleContexts(HtmlCommentContext.class); 2329 } 2330 public HtmlCommentContext htmlComment(int i) { 2331 return getRuleContext(HtmlCommentContext.class,i); 2332 } 2333 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 2334 public TerminalNode CDATA(int i) { 2335 return getToken(JavadocParser.CDATA, i); 2336 } 2337 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2338 public TerminalNode NEWLINE(int i) { 2339 return getToken(JavadocParser.NEWLINE, i); 2340 } 2341 public List<TextContext> text() { 2342 return getRuleContexts(TextContext.class); 2343 } 2344 public TextContext text(int i) { 2345 return getRuleContext(TextContext.class,i); 2346 } 2347 public List<JavadocInlineTagContext> javadocInlineTag() { 2348 return getRuleContexts(JavadocInlineTagContext.class); 2349 } 2350 public JavadocInlineTagContext javadocInlineTag(int i) { 2351 return getRuleContext(JavadocInlineTagContext.class,i); 2352 } 2353 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2354 public TerminalNode LEADING_ASTERISK(int i) { 2355 return getToken(JavadocParser.LEADING_ASTERISK, i); 2356 } 2357 public LiContext(ParserRuleContext parent, int invokingState) { 2358 super(parent, invokingState); 2359 } 2360 @Override public int getRuleIndex() { return RULE_li; } 2361 } 2362 2363 public final LiContext li() throws RecognitionException { 2364 LiContext _localctx = new LiContext(_ctx, getState()); 2365 enterRule(_localctx, 22, RULE_li); 2366 try { 2367 int _alt; 2368 enterOuterAlt(_localctx, 1); 2369 { 2370 setState(392); 2371 liTagStart(false); 2372 setState(432); 2373 _errHandler.sync(this); 2374 _alt = getInterpreter().adaptivePredict(_input,23,_ctx); 2375 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 2376 if ( _alt==1 ) { 2377 { 2378 setState(430); 2379 _errHandler.sync(this); 2380 switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) { 2381 case 1: 2382 { 2383 setState(393); 2384 htmlTag(); 2385 } 2386 break; 2387 case 2: 2388 { 2389 setState(394); 2390 singletonElement(); 2391 } 2392 break; 2393 case 3: 2394 { 2395 setState(395); 2396 paragraph(); 2397 } 2398 break; 2399 case 4: 2400 { 2401 setState(396); 2402 tr(); 2403 } 2404 break; 2405 case 5: 2406 { 2407 setState(397); 2408 td(); 2409 } 2410 break; 2411 case 6: 2412 { 2413 setState(398); 2414 th(); 2415 } 2416 break; 2417 case 7: 2418 { 2419 setState(399); 2420 body(); 2421 } 2422 break; 2423 case 8: 2424 { 2425 setState(400); 2426 colgroup(); 2427 } 2428 break; 2429 case 9: 2430 { 2431 setState(401); 2432 dd(); 2433 } 2434 break; 2435 case 10: 2436 { 2437 setState(402); 2438 dt(); 2439 } 2440 break; 2441 case 11: 2442 { 2443 setState(403); 2444 head(); 2445 } 2446 break; 2447 case 12: 2448 { 2449 setState(404); 2450 html(); 2451 } 2452 break; 2453 case 13: 2454 { 2455 setState(405); 2456 option(); 2457 } 2458 break; 2459 case 14: 2460 { 2461 setState(406); 2462 tbody(); 2463 } 2464 break; 2465 case 15: 2466 { 2467 setState(407); 2468 thead(); 2469 } 2470 break; 2471 case 16: 2472 { 2473 setState(408); 2474 tfoot(); 2475 } 2476 break; 2477 case 17: 2478 { 2479 setState(409); 2480 pTagStart(true); 2481 } 2482 break; 2483 case 18: 2484 { 2485 setState(410); 2486 trTagStart(true); 2487 } 2488 break; 2489 case 19: 2490 { 2491 setState(411); 2492 tdTagStart(true); 2493 } 2494 break; 2495 case 20: 2496 { 2497 setState(412); 2498 thTagStart(true); 2499 } 2500 break; 2501 case 21: 2502 { 2503 setState(413); 2504 bodyTagStart(true); 2505 } 2506 break; 2507 case 22: 2508 { 2509 setState(414); 2510 colgroupTagStart(true); 2511 } 2512 break; 2513 case 23: 2514 { 2515 setState(415); 2516 ddTagStart(true); 2517 } 2518 break; 2519 case 24: 2520 { 2521 setState(416); 2522 dtTagStart(true); 2523 } 2524 break; 2525 case 25: 2526 { 2527 setState(417); 2528 headTagStart(true); 2529 } 2530 break; 2531 case 26: 2532 { 2533 setState(418); 2534 htmlTagStart(true); 2535 } 2536 break; 2537 case 27: 2538 { 2539 setState(419); 2540 optionTagStart(true); 2541 } 2542 break; 2543 case 28: 2544 { 2545 setState(420); 2546 tbodyTagStart(true); 2547 } 2548 break; 2549 case 29: 2550 { 2551 setState(421); 2552 theadTagStart(true); 2553 } 2554 break; 2555 case 30: 2556 { 2557 setState(422); 2558 tfootTagStart(true); 2559 } 2560 break; 2561 case 31: 2562 { 2563 { 2564 setState(423); 2565 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2566 setState(424); 2567 match(LEADING_ASTERISK); 2568 } 2569 } 2570 break; 2571 case 32: 2572 { 2573 setState(425); 2574 htmlComment(); 2575 } 2576 break; 2577 case 33: 2578 { 2579 setState(426); 2580 match(CDATA); 2581 } 2582 break; 2583 case 34: 2584 { 2585 setState(427); 2586 match(NEWLINE); 2587 } 2588 break; 2589 case 35: 2590 { 2591 setState(428); 2592 text(); 2593 } 2594 break; 2595 case 36: 2596 { 2597 setState(429); 2598 javadocInlineTag(); 2599 } 2600 break; 2601 } 2602 } 2603 } 2604 setState(434); 2605 _errHandler.sync(this); 2606 _alt = getInterpreter().adaptivePredict(_input,23,_ctx); 2607 } 2608 setState(435); 2609 liTagEnd(); 2610 } 2611 } 2612 catch (RecognitionException re) { 2613 _localctx.exception = re; 2614 _errHandler.reportError(this, re); 2615 _errHandler.recover(this, re); 2616 } 2617 finally { 2618 exitRule(); 2619 } 2620 return _localctx; 2621 } 2622 2623 public static class TrTagStartContext extends ParserRuleContext { 2624 public boolean isNonTight; 2625 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 2626 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2627 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 2628 public List<AttributeContext> attribute() { 2629 return getRuleContexts(AttributeContext.class); 2630 } 2631 public AttributeContext attribute(int i) { 2632 return getRuleContext(AttributeContext.class,i); 2633 } 2634 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2635 public TerminalNode NEWLINE(int i) { 2636 return getToken(JavadocParser.NEWLINE, i); 2637 } 2638 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2639 public TerminalNode LEADING_ASTERISK(int i) { 2640 return getToken(JavadocParser.LEADING_ASTERISK, i); 2641 } 2642 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2643 public TerminalNode WS(int i) { 2644 return getToken(JavadocParser.WS, i); 2645 } 2646 public TrTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 2647 public TrTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 2648 super(parent, invokingState); 2649 this.isNonTight = isNonTight; 2650 } 2651 @Override public int getRuleIndex() { return RULE_trTagStart; } 2652 } 2653 2654 public final TrTagStartContext trTagStart(boolean isNonTight) throws RecognitionException { 2655 TrTagStartContext _localctx = new TrTagStartContext(_ctx, getState(), isNonTight); 2656 enterRule(_localctx, 24, RULE_trTagStart); 2657 int _la; 2658 try { 2659 enterOuterAlt(_localctx, 1); 2660 { 2661 setState(437); 2662 match(START); 2663 setState(438); 2664 match(TR_HTML_TAG_NAME); 2665 setState(445); 2666 _errHandler.sync(this); 2667 _la = _input.LA(1); 2668 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2669 { 2670 setState(443); 2671 _errHandler.sync(this); 2672 switch (_input.LA(1)) { 2673 case HTML_TAG_NAME: 2674 { 2675 setState(439); 2676 attribute(); 2677 } 2678 break; 2679 case NEWLINE: 2680 { 2681 setState(440); 2682 match(NEWLINE); 2683 } 2684 break; 2685 case LEADING_ASTERISK: 2686 { 2687 setState(441); 2688 match(LEADING_ASTERISK); 2689 } 2690 break; 2691 case WS: 2692 { 2693 setState(442); 2694 match(WS); 2695 } 2696 break; 2697 default: 2698 throw new NoViableAltException(this); 2699 } 2700 } 2701 setState(447); 2702 _errHandler.sync(this); 2703 _la = _input.LA(1); 2704 } 2705 setState(448); 2706 match(END); 2707 } 2708 _ctx.stop = _input.LT(-1); 2709 2710 if (isNonTight && nonTightTagStartContext == null) { 2711 nonTightTagStartContext = _localctx; 2712 } 2713 2714 } 2715 catch (RecognitionException re) { 2716 _localctx.exception = re; 2717 _errHandler.reportError(this, re); 2718 _errHandler.recover(this, re); 2719 } 2720 finally { 2721 exitRule(); 2722 } 2723 return _localctx; 2724 } 2725 2726 public static class TrTagEndContext extends ParserRuleContext { 2727 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 2728 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2729 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2730 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 2731 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2732 public TerminalNode NEWLINE(int i) { 2733 return getToken(JavadocParser.NEWLINE, i); 2734 } 2735 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2736 public TerminalNode LEADING_ASTERISK(int i) { 2737 return getToken(JavadocParser.LEADING_ASTERISK, i); 2738 } 2739 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2740 public TerminalNode WS(int i) { 2741 return getToken(JavadocParser.WS, i); 2742 } 2743 public TrTagEndContext(ParserRuleContext parent, int invokingState) { 2744 super(parent, invokingState); 2745 } 2746 @Override public int getRuleIndex() { return RULE_trTagEnd; } 2747 } 2748 2749 public final TrTagEndContext trTagEnd() throws RecognitionException { 2750 TrTagEndContext _localctx = new TrTagEndContext(_ctx, getState()); 2751 enterRule(_localctx, 26, RULE_trTagEnd); 2752 int _la; 2753 try { 2754 enterOuterAlt(_localctx, 1); 2755 { 2756 setState(450); 2757 match(START); 2758 setState(451); 2759 match(SLASH); 2760 setState(452); 2761 match(TR_HTML_TAG_NAME); 2762 setState(456); 2763 _errHandler.sync(this); 2764 _la = _input.LA(1); 2765 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2766 { 2767 { 2768 setState(453); 2769 _la = _input.LA(1); 2770 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2771 _errHandler.recoverInline(this); 2772 } 2773 else { 2774 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 2775 _errHandler.reportMatch(this); 2776 consume(); 2777 } 2778 } 2779 } 2780 setState(458); 2781 _errHandler.sync(this); 2782 _la = _input.LA(1); 2783 } 2784 setState(459); 2785 match(END); 2786 } 2787 } 2788 catch (RecognitionException re) { 2789 _localctx.exception = re; 2790 _errHandler.reportError(this, re); 2791 _errHandler.recover(this, re); 2792 } 2793 finally { 2794 exitRule(); 2795 } 2796 return _localctx; 2797 } 2798 2799 public static class TrContext extends ParserRuleContext { 2800 public TrTagStartContext trTagStart() { 2801 return getRuleContext(TrTagStartContext.class,0); 2802 } 2803 public TrTagEndContext trTagEnd() { 2804 return getRuleContext(TrTagEndContext.class,0); 2805 } 2806 public List<HtmlTagContext> htmlTag() { 2807 return getRuleContexts(HtmlTagContext.class); 2808 } 2809 public HtmlTagContext htmlTag(int i) { 2810 return getRuleContext(HtmlTagContext.class,i); 2811 } 2812 public List<SingletonElementContext> singletonElement() { 2813 return getRuleContexts(SingletonElementContext.class); 2814 } 2815 public SingletonElementContext singletonElement(int i) { 2816 return getRuleContext(SingletonElementContext.class,i); 2817 } 2818 public List<ParagraphContext> paragraph() { 2819 return getRuleContexts(ParagraphContext.class); 2820 } 2821 public ParagraphContext paragraph(int i) { 2822 return getRuleContext(ParagraphContext.class,i); 2823 } 2824 public List<LiContext> li() { 2825 return getRuleContexts(LiContext.class); 2826 } 2827 public LiContext li(int i) { 2828 return getRuleContext(LiContext.class,i); 2829 } 2830 public List<TdContext> td() { 2831 return getRuleContexts(TdContext.class); 2832 } 2833 public TdContext td(int i) { 2834 return getRuleContext(TdContext.class,i); 2835 } 2836 public List<ThContext> th() { 2837 return getRuleContexts(ThContext.class); 2838 } 2839 public ThContext th(int i) { 2840 return getRuleContext(ThContext.class,i); 2841 } 2842 public List<BodyContext> body() { 2843 return getRuleContexts(BodyContext.class); 2844 } 2845 public BodyContext body(int i) { 2846 return getRuleContext(BodyContext.class,i); 2847 } 2848 public List<ColgroupContext> colgroup() { 2849 return getRuleContexts(ColgroupContext.class); 2850 } 2851 public ColgroupContext colgroup(int i) { 2852 return getRuleContext(ColgroupContext.class,i); 2853 } 2854 public List<DdContext> dd() { 2855 return getRuleContexts(DdContext.class); 2856 } 2857 public DdContext dd(int i) { 2858 return getRuleContext(DdContext.class,i); 2859 } 2860 public List<DtContext> dt() { 2861 return getRuleContexts(DtContext.class); 2862 } 2863 public DtContext dt(int i) { 2864 return getRuleContext(DtContext.class,i); 2865 } 2866 public List<HeadContext> head() { 2867 return getRuleContexts(HeadContext.class); 2868 } 2869 public HeadContext head(int i) { 2870 return getRuleContext(HeadContext.class,i); 2871 } 2872 public List<HtmlContext> html() { 2873 return getRuleContexts(HtmlContext.class); 2874 } 2875 public HtmlContext html(int i) { 2876 return getRuleContext(HtmlContext.class,i); 2877 } 2878 public List<OptionContext> option() { 2879 return getRuleContexts(OptionContext.class); 2880 } 2881 public OptionContext option(int i) { 2882 return getRuleContext(OptionContext.class,i); 2883 } 2884 public List<TbodyContext> tbody() { 2885 return getRuleContexts(TbodyContext.class); 2886 } 2887 public TbodyContext tbody(int i) { 2888 return getRuleContext(TbodyContext.class,i); 2889 } 2890 public List<TheadContext> thead() { 2891 return getRuleContexts(TheadContext.class); 2892 } 2893 public TheadContext thead(int i) { 2894 return getRuleContext(TheadContext.class,i); 2895 } 2896 public List<TfootContext> tfoot() { 2897 return getRuleContexts(TfootContext.class); 2898 } 2899 public TfootContext tfoot(int i) { 2900 return getRuleContext(TfootContext.class,i); 2901 } 2902 public List<PTagStartContext> pTagStart() { 2903 return getRuleContexts(PTagStartContext.class); 2904 } 2905 public PTagStartContext pTagStart(int i) { 2906 return getRuleContext(PTagStartContext.class,i); 2907 } 2908 public List<LiTagStartContext> liTagStart() { 2909 return getRuleContexts(LiTagStartContext.class); 2910 } 2911 public LiTagStartContext liTagStart(int i) { 2912 return getRuleContext(LiTagStartContext.class,i); 2913 } 2914 public List<TdTagStartContext> tdTagStart() { 2915 return getRuleContexts(TdTagStartContext.class); 2916 } 2917 public TdTagStartContext tdTagStart(int i) { 2918 return getRuleContext(TdTagStartContext.class,i); 2919 } 2920 public List<ThTagStartContext> thTagStart() { 2921 return getRuleContexts(ThTagStartContext.class); 2922 } 2923 public ThTagStartContext thTagStart(int i) { 2924 return getRuleContext(ThTagStartContext.class,i); 2925 } 2926 public List<BodyTagStartContext> bodyTagStart() { 2927 return getRuleContexts(BodyTagStartContext.class); 2928 } 2929 public BodyTagStartContext bodyTagStart(int i) { 2930 return getRuleContext(BodyTagStartContext.class,i); 2931 } 2932 public List<ColgroupTagStartContext> colgroupTagStart() { 2933 return getRuleContexts(ColgroupTagStartContext.class); 2934 } 2935 public ColgroupTagStartContext colgroupTagStart(int i) { 2936 return getRuleContext(ColgroupTagStartContext.class,i); 2937 } 2938 public List<DdTagStartContext> ddTagStart() { 2939 return getRuleContexts(DdTagStartContext.class); 2940 } 2941 public DdTagStartContext ddTagStart(int i) { 2942 return getRuleContext(DdTagStartContext.class,i); 2943 } 2944 public List<DtTagStartContext> dtTagStart() { 2945 return getRuleContexts(DtTagStartContext.class); 2946 } 2947 public DtTagStartContext dtTagStart(int i) { 2948 return getRuleContext(DtTagStartContext.class,i); 2949 } 2950 public List<HeadTagStartContext> headTagStart() { 2951 return getRuleContexts(HeadTagStartContext.class); 2952 } 2953 public HeadTagStartContext headTagStart(int i) { 2954 return getRuleContext(HeadTagStartContext.class,i); 2955 } 2956 public List<HtmlTagStartContext> htmlTagStart() { 2957 return getRuleContexts(HtmlTagStartContext.class); 2958 } 2959 public HtmlTagStartContext htmlTagStart(int i) { 2960 return getRuleContext(HtmlTagStartContext.class,i); 2961 } 2962 public List<OptionTagStartContext> optionTagStart() { 2963 return getRuleContexts(OptionTagStartContext.class); 2964 } 2965 public OptionTagStartContext optionTagStart(int i) { 2966 return getRuleContext(OptionTagStartContext.class,i); 2967 } 2968 public List<TbodyTagStartContext> tbodyTagStart() { 2969 return getRuleContexts(TbodyTagStartContext.class); 2970 } 2971 public TbodyTagStartContext tbodyTagStart(int i) { 2972 return getRuleContext(TbodyTagStartContext.class,i); 2973 } 2974 public List<TheadTagStartContext> theadTagStart() { 2975 return getRuleContexts(TheadTagStartContext.class); 2976 } 2977 public TheadTagStartContext theadTagStart(int i) { 2978 return getRuleContext(TheadTagStartContext.class,i); 2979 } 2980 public List<TfootTagStartContext> tfootTagStart() { 2981 return getRuleContexts(TfootTagStartContext.class); 2982 } 2983 public TfootTagStartContext tfootTagStart(int i) { 2984 return getRuleContext(TfootTagStartContext.class,i); 2985 } 2986 public List<HtmlCommentContext> htmlComment() { 2987 return getRuleContexts(HtmlCommentContext.class); 2988 } 2989 public HtmlCommentContext htmlComment(int i) { 2990 return getRuleContext(HtmlCommentContext.class,i); 2991 } 2992 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 2993 public TerminalNode CDATA(int i) { 2994 return getToken(JavadocParser.CDATA, i); 2995 } 2996 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2997 public TerminalNode NEWLINE(int i) { 2998 return getToken(JavadocParser.NEWLINE, i); 2999 } 3000 public List<TextContext> text() { 3001 return getRuleContexts(TextContext.class); 3002 } 3003 public TextContext text(int i) { 3004 return getRuleContext(TextContext.class,i); 3005 } 3006 public List<JavadocInlineTagContext> javadocInlineTag() { 3007 return getRuleContexts(JavadocInlineTagContext.class); 3008 } 3009 public JavadocInlineTagContext javadocInlineTag(int i) { 3010 return getRuleContext(JavadocInlineTagContext.class,i); 3011 } 3012 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3013 public TerminalNode LEADING_ASTERISK(int i) { 3014 return getToken(JavadocParser.LEADING_ASTERISK, i); 3015 } 3016 public TrContext(ParserRuleContext parent, int invokingState) { 3017 super(parent, invokingState); 3018 } 3019 @Override public int getRuleIndex() { return RULE_tr; } 3020 } 3021 3022 public final TrContext tr() throws RecognitionException { 3023 TrContext _localctx = new TrContext(_ctx, getState()); 3024 enterRule(_localctx, 28, RULE_tr); 3025 try { 3026 int _alt; 3027 enterOuterAlt(_localctx, 1); 3028 { 3029 setState(461); 3030 trTagStart(false); 3031 setState(501); 3032 _errHandler.sync(this); 3033 _alt = getInterpreter().adaptivePredict(_input,28,_ctx); 3034 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3035 if ( _alt==1 ) { 3036 { 3037 setState(499); 3038 _errHandler.sync(this); 3039 switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) { 3040 case 1: 3041 { 3042 setState(462); 3043 htmlTag(); 3044 } 3045 break; 3046 case 2: 3047 { 3048 setState(463); 3049 singletonElement(); 3050 } 3051 break; 3052 case 3: 3053 { 3054 setState(464); 3055 paragraph(); 3056 } 3057 break; 3058 case 4: 3059 { 3060 setState(465); 3061 li(); 3062 } 3063 break; 3064 case 5: 3065 { 3066 setState(466); 3067 td(); 3068 } 3069 break; 3070 case 6: 3071 { 3072 setState(467); 3073 th(); 3074 } 3075 break; 3076 case 7: 3077 { 3078 setState(468); 3079 body(); 3080 } 3081 break; 3082 case 8: 3083 { 3084 setState(469); 3085 colgroup(); 3086 } 3087 break; 3088 case 9: 3089 { 3090 setState(470); 3091 dd(); 3092 } 3093 break; 3094 case 10: 3095 { 3096 setState(471); 3097 dt(); 3098 } 3099 break; 3100 case 11: 3101 { 3102 setState(472); 3103 head(); 3104 } 3105 break; 3106 case 12: 3107 { 3108 setState(473); 3109 html(); 3110 } 3111 break; 3112 case 13: 3113 { 3114 setState(474); 3115 option(); 3116 } 3117 break; 3118 case 14: 3119 { 3120 setState(475); 3121 tbody(); 3122 } 3123 break; 3124 case 15: 3125 { 3126 setState(476); 3127 thead(); 3128 } 3129 break; 3130 case 16: 3131 { 3132 setState(477); 3133 tfoot(); 3134 } 3135 break; 3136 case 17: 3137 { 3138 setState(478); 3139 pTagStart(true); 3140 } 3141 break; 3142 case 18: 3143 { 3144 setState(479); 3145 liTagStart(true); 3146 } 3147 break; 3148 case 19: 3149 { 3150 setState(480); 3151 tdTagStart(true); 3152 } 3153 break; 3154 case 20: 3155 { 3156 setState(481); 3157 thTagStart(true); 3158 } 3159 break; 3160 case 21: 3161 { 3162 setState(482); 3163 bodyTagStart(true); 3164 } 3165 break; 3166 case 22: 3167 { 3168 setState(483); 3169 colgroupTagStart(true); 3170 } 3171 break; 3172 case 23: 3173 { 3174 setState(484); 3175 ddTagStart(true); 3176 } 3177 break; 3178 case 24: 3179 { 3180 setState(485); 3181 dtTagStart(true); 3182 } 3183 break; 3184 case 25: 3185 { 3186 setState(486); 3187 headTagStart(true); 3188 } 3189 break; 3190 case 26: 3191 { 3192 setState(487); 3193 htmlTagStart(true); 3194 } 3195 break; 3196 case 27: 3197 { 3198 setState(488); 3199 optionTagStart(true); 3200 } 3201 break; 3202 case 28: 3203 { 3204 setState(489); 3205 tbodyTagStart(true); 3206 } 3207 break; 3208 case 29: 3209 { 3210 setState(490); 3211 theadTagStart(true); 3212 } 3213 break; 3214 case 30: 3215 { 3216 setState(491); 3217 tfootTagStart(true); 3218 } 3219 break; 3220 case 31: 3221 { 3222 { 3223 setState(492); 3224 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 3225 setState(493); 3226 match(LEADING_ASTERISK); 3227 } 3228 } 3229 break; 3230 case 32: 3231 { 3232 setState(494); 3233 htmlComment(); 3234 } 3235 break; 3236 case 33: 3237 { 3238 setState(495); 3239 match(CDATA); 3240 } 3241 break; 3242 case 34: 3243 { 3244 setState(496); 3245 match(NEWLINE); 3246 } 3247 break; 3248 case 35: 3249 { 3250 setState(497); 3251 text(); 3252 } 3253 break; 3254 case 36: 3255 { 3256 setState(498); 3257 javadocInlineTag(); 3258 } 3259 break; 3260 } 3261 } 3262 } 3263 setState(503); 3264 _errHandler.sync(this); 3265 _alt = getInterpreter().adaptivePredict(_input,28,_ctx); 3266 } 3267 setState(504); 3268 trTagEnd(); 3269 } 3270 } 3271 catch (RecognitionException re) { 3272 _localctx.exception = re; 3273 _errHandler.reportError(this, re); 3274 _errHandler.recover(this, re); 3275 } 3276 finally { 3277 exitRule(); 3278 } 3279 return _localctx; 3280 } 3281 3282 public static class TdTagStartContext extends ParserRuleContext { 3283 public boolean isNonTight; 3284 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 3285 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3286 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 3287 public List<AttributeContext> attribute() { 3288 return getRuleContexts(AttributeContext.class); 3289 } 3290 public AttributeContext attribute(int i) { 3291 return getRuleContext(AttributeContext.class,i); 3292 } 3293 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3294 public TerminalNode NEWLINE(int i) { 3295 return getToken(JavadocParser.NEWLINE, i); 3296 } 3297 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3298 public TerminalNode LEADING_ASTERISK(int i) { 3299 return getToken(JavadocParser.LEADING_ASTERISK, i); 3300 } 3301 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3302 public TerminalNode WS(int i) { 3303 return getToken(JavadocParser.WS, i); 3304 } 3305 public TdTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 3306 public TdTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 3307 super(parent, invokingState); 3308 this.isNonTight = isNonTight; 3309 } 3310 @Override public int getRuleIndex() { return RULE_tdTagStart; } 3311 } 3312 3313 public final TdTagStartContext tdTagStart(boolean isNonTight) throws RecognitionException { 3314 TdTagStartContext _localctx = new TdTagStartContext(_ctx, getState(), isNonTight); 3315 enterRule(_localctx, 30, RULE_tdTagStart); 3316 int _la; 3317 try { 3318 enterOuterAlt(_localctx, 1); 3319 { 3320 setState(506); 3321 match(START); 3322 setState(507); 3323 match(TD_HTML_TAG_NAME); 3324 setState(514); 3325 _errHandler.sync(this); 3326 _la = _input.LA(1); 3327 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 3328 { 3329 setState(512); 3330 _errHandler.sync(this); 3331 switch (_input.LA(1)) { 3332 case HTML_TAG_NAME: 3333 { 3334 setState(508); 3335 attribute(); 3336 } 3337 break; 3338 case NEWLINE: 3339 { 3340 setState(509); 3341 match(NEWLINE); 3342 } 3343 break; 3344 case LEADING_ASTERISK: 3345 { 3346 setState(510); 3347 match(LEADING_ASTERISK); 3348 } 3349 break; 3350 case WS: 3351 { 3352 setState(511); 3353 match(WS); 3354 } 3355 break; 3356 default: 3357 throw new NoViableAltException(this); 3358 } 3359 } 3360 setState(516); 3361 _errHandler.sync(this); 3362 _la = _input.LA(1); 3363 } 3364 setState(517); 3365 match(END); 3366 } 3367 _ctx.stop = _input.LT(-1); 3368 3369 if (isNonTight && nonTightTagStartContext == null) { 3370 nonTightTagStartContext = _localctx; 3371 } 3372 3373 } 3374 catch (RecognitionException re) { 3375 _localctx.exception = re; 3376 _errHandler.reportError(this, re); 3377 _errHandler.recover(this, re); 3378 } 3379 finally { 3380 exitRule(); 3381 } 3382 return _localctx; 3383 } 3384 3385 public static class TdTagEndContext extends ParserRuleContext { 3386 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 3387 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 3388 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3389 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 3390 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3391 public TerminalNode NEWLINE(int i) { 3392 return getToken(JavadocParser.NEWLINE, i); 3393 } 3394 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3395 public TerminalNode LEADING_ASTERISK(int i) { 3396 return getToken(JavadocParser.LEADING_ASTERISK, i); 3397 } 3398 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3399 public TerminalNode WS(int i) { 3400 return getToken(JavadocParser.WS, i); 3401 } 3402 public TdTagEndContext(ParserRuleContext parent, int invokingState) { 3403 super(parent, invokingState); 3404 } 3405 @Override public int getRuleIndex() { return RULE_tdTagEnd; } 3406 } 3407 3408 public final TdTagEndContext tdTagEnd() throws RecognitionException { 3409 TdTagEndContext _localctx = new TdTagEndContext(_ctx, getState()); 3410 enterRule(_localctx, 32, RULE_tdTagEnd); 3411 int _la; 3412 try { 3413 enterOuterAlt(_localctx, 1); 3414 { 3415 setState(519); 3416 match(START); 3417 setState(520); 3418 match(SLASH); 3419 setState(521); 3420 match(TD_HTML_TAG_NAME); 3421 setState(525); 3422 _errHandler.sync(this); 3423 _la = _input.LA(1); 3424 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 3425 { 3426 { 3427 setState(522); 3428 _la = _input.LA(1); 3429 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 3430 _errHandler.recoverInline(this); 3431 } 3432 else { 3433 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3434 _errHandler.reportMatch(this); 3435 consume(); 3436 } 3437 } 3438 } 3439 setState(527); 3440 _errHandler.sync(this); 3441 _la = _input.LA(1); 3442 } 3443 setState(528); 3444 match(END); 3445 } 3446 } 3447 catch (RecognitionException re) { 3448 _localctx.exception = re; 3449 _errHandler.reportError(this, re); 3450 _errHandler.recover(this, re); 3451 } 3452 finally { 3453 exitRule(); 3454 } 3455 return _localctx; 3456 } 3457 3458 public static class TdContext extends ParserRuleContext { 3459 public List<TdTagStartContext> tdTagStart() { 3460 return getRuleContexts(TdTagStartContext.class); 3461 } 3462 public TdTagStartContext tdTagStart(int i) { 3463 return getRuleContext(TdTagStartContext.class,i); 3464 } 3465 public TdTagEndContext tdTagEnd() { 3466 return getRuleContext(TdTagEndContext.class,0); 3467 } 3468 public List<HtmlTagContext> htmlTag() { 3469 return getRuleContexts(HtmlTagContext.class); 3470 } 3471 public HtmlTagContext htmlTag(int i) { 3472 return getRuleContext(HtmlTagContext.class,i); 3473 } 3474 public List<SingletonElementContext> singletonElement() { 3475 return getRuleContexts(SingletonElementContext.class); 3476 } 3477 public SingletonElementContext singletonElement(int i) { 3478 return getRuleContext(SingletonElementContext.class,i); 3479 } 3480 public List<ParagraphContext> paragraph() { 3481 return getRuleContexts(ParagraphContext.class); 3482 } 3483 public ParagraphContext paragraph(int i) { 3484 return getRuleContext(ParagraphContext.class,i); 3485 } 3486 public List<LiContext> li() { 3487 return getRuleContexts(LiContext.class); 3488 } 3489 public LiContext li(int i) { 3490 return getRuleContext(LiContext.class,i); 3491 } 3492 public List<TrContext> tr() { 3493 return getRuleContexts(TrContext.class); 3494 } 3495 public TrContext tr(int i) { 3496 return getRuleContext(TrContext.class,i); 3497 } 3498 public List<ThContext> th() { 3499 return getRuleContexts(ThContext.class); 3500 } 3501 public ThContext th(int i) { 3502 return getRuleContext(ThContext.class,i); 3503 } 3504 public List<BodyContext> body() { 3505 return getRuleContexts(BodyContext.class); 3506 } 3507 public BodyContext body(int i) { 3508 return getRuleContext(BodyContext.class,i); 3509 } 3510 public List<ColgroupContext> colgroup() { 3511 return getRuleContexts(ColgroupContext.class); 3512 } 3513 public ColgroupContext colgroup(int i) { 3514 return getRuleContext(ColgroupContext.class,i); 3515 } 3516 public List<DdContext> dd() { 3517 return getRuleContexts(DdContext.class); 3518 } 3519 public DdContext dd(int i) { 3520 return getRuleContext(DdContext.class,i); 3521 } 3522 public List<DtContext> dt() { 3523 return getRuleContexts(DtContext.class); 3524 } 3525 public DtContext dt(int i) { 3526 return getRuleContext(DtContext.class,i); 3527 } 3528 public List<HeadContext> head() { 3529 return getRuleContexts(HeadContext.class); 3530 } 3531 public HeadContext head(int i) { 3532 return getRuleContext(HeadContext.class,i); 3533 } 3534 public List<HtmlContext> html() { 3535 return getRuleContexts(HtmlContext.class); 3536 } 3537 public HtmlContext html(int i) { 3538 return getRuleContext(HtmlContext.class,i); 3539 } 3540 public List<OptionContext> option() { 3541 return getRuleContexts(OptionContext.class); 3542 } 3543 public OptionContext option(int i) { 3544 return getRuleContext(OptionContext.class,i); 3545 } 3546 public List<TbodyContext> tbody() { 3547 return getRuleContexts(TbodyContext.class); 3548 } 3549 public TbodyContext tbody(int i) { 3550 return getRuleContext(TbodyContext.class,i); 3551 } 3552 public List<TheadContext> thead() { 3553 return getRuleContexts(TheadContext.class); 3554 } 3555 public TheadContext thead(int i) { 3556 return getRuleContext(TheadContext.class,i); 3557 } 3558 public List<TfootContext> tfoot() { 3559 return getRuleContexts(TfootContext.class); 3560 } 3561 public TfootContext tfoot(int i) { 3562 return getRuleContext(TfootContext.class,i); 3563 } 3564 public List<PTagStartContext> pTagStart() { 3565 return getRuleContexts(PTagStartContext.class); 3566 } 3567 public PTagStartContext pTagStart(int i) { 3568 return getRuleContext(PTagStartContext.class,i); 3569 } 3570 public List<LiTagStartContext> liTagStart() { 3571 return getRuleContexts(LiTagStartContext.class); 3572 } 3573 public LiTagStartContext liTagStart(int i) { 3574 return getRuleContext(LiTagStartContext.class,i); 3575 } 3576 public List<ThTagStartContext> thTagStart() { 3577 return getRuleContexts(ThTagStartContext.class); 3578 } 3579 public ThTagStartContext thTagStart(int i) { 3580 return getRuleContext(ThTagStartContext.class,i); 3581 } 3582 public List<BodyTagStartContext> bodyTagStart() { 3583 return getRuleContexts(BodyTagStartContext.class); 3584 } 3585 public BodyTagStartContext bodyTagStart(int i) { 3586 return getRuleContext(BodyTagStartContext.class,i); 3587 } 3588 public List<ColgroupTagStartContext> colgroupTagStart() { 3589 return getRuleContexts(ColgroupTagStartContext.class); 3590 } 3591 public ColgroupTagStartContext colgroupTagStart(int i) { 3592 return getRuleContext(ColgroupTagStartContext.class,i); 3593 } 3594 public List<DdTagStartContext> ddTagStart() { 3595 return getRuleContexts(DdTagStartContext.class); 3596 } 3597 public DdTagStartContext ddTagStart(int i) { 3598 return getRuleContext(DdTagStartContext.class,i); 3599 } 3600 public List<DtTagStartContext> dtTagStart() { 3601 return getRuleContexts(DtTagStartContext.class); 3602 } 3603 public DtTagStartContext dtTagStart(int i) { 3604 return getRuleContext(DtTagStartContext.class,i); 3605 } 3606 public List<HeadTagStartContext> headTagStart() { 3607 return getRuleContexts(HeadTagStartContext.class); 3608 } 3609 public HeadTagStartContext headTagStart(int i) { 3610 return getRuleContext(HeadTagStartContext.class,i); 3611 } 3612 public List<HtmlTagStartContext> htmlTagStart() { 3613 return getRuleContexts(HtmlTagStartContext.class); 3614 } 3615 public HtmlTagStartContext htmlTagStart(int i) { 3616 return getRuleContext(HtmlTagStartContext.class,i); 3617 } 3618 public List<OptionTagStartContext> optionTagStart() { 3619 return getRuleContexts(OptionTagStartContext.class); 3620 } 3621 public OptionTagStartContext optionTagStart(int i) { 3622 return getRuleContext(OptionTagStartContext.class,i); 3623 } 3624 public List<TbodyTagStartContext> tbodyTagStart() { 3625 return getRuleContexts(TbodyTagStartContext.class); 3626 } 3627 public TbodyTagStartContext tbodyTagStart(int i) { 3628 return getRuleContext(TbodyTagStartContext.class,i); 3629 } 3630 public List<TheadTagStartContext> theadTagStart() { 3631 return getRuleContexts(TheadTagStartContext.class); 3632 } 3633 public TheadTagStartContext theadTagStart(int i) { 3634 return getRuleContext(TheadTagStartContext.class,i); 3635 } 3636 public List<TfootTagStartContext> tfootTagStart() { 3637 return getRuleContexts(TfootTagStartContext.class); 3638 } 3639 public TfootTagStartContext tfootTagStart(int i) { 3640 return getRuleContext(TfootTagStartContext.class,i); 3641 } 3642 public List<HtmlCommentContext> htmlComment() { 3643 return getRuleContexts(HtmlCommentContext.class); 3644 } 3645 public HtmlCommentContext htmlComment(int i) { 3646 return getRuleContext(HtmlCommentContext.class,i); 3647 } 3648 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3649 public TerminalNode CDATA(int i) { 3650 return getToken(JavadocParser.CDATA, i); 3651 } 3652 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3653 public TerminalNode NEWLINE(int i) { 3654 return getToken(JavadocParser.NEWLINE, i); 3655 } 3656 public List<TextContext> text() { 3657 return getRuleContexts(TextContext.class); 3658 } 3659 public TextContext text(int i) { 3660 return getRuleContext(TextContext.class,i); 3661 } 3662 public List<JavadocInlineTagContext> javadocInlineTag() { 3663 return getRuleContexts(JavadocInlineTagContext.class); 3664 } 3665 public JavadocInlineTagContext javadocInlineTag(int i) { 3666 return getRuleContext(JavadocInlineTagContext.class,i); 3667 } 3668 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3669 public TerminalNode LEADING_ASTERISK(int i) { 3670 return getToken(JavadocParser.LEADING_ASTERISK, i); 3671 } 3672 public TdContext(ParserRuleContext parent, int invokingState) { 3673 super(parent, invokingState); 3674 } 3675 @Override public int getRuleIndex() { return RULE_td; } 3676 } 3677 3678 public final TdContext td() throws RecognitionException { 3679 TdContext _localctx = new TdContext(_ctx, getState()); 3680 enterRule(_localctx, 34, RULE_td); 3681 try { 3682 int _alt; 3683 enterOuterAlt(_localctx, 1); 3684 { 3685 setState(530); 3686 tdTagStart(false); 3687 setState(570); 3688 _errHandler.sync(this); 3689 _alt = getInterpreter().adaptivePredict(_input,33,_ctx); 3690 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3691 if ( _alt==1 ) { 3692 { 3693 setState(568); 3694 _errHandler.sync(this); 3695 switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) { 3696 case 1: 3697 { 3698 setState(531); 3699 htmlTag(); 3700 } 3701 break; 3702 case 2: 3703 { 3704 setState(532); 3705 singletonElement(); 3706 } 3707 break; 3708 case 3: 3709 { 3710 setState(533); 3711 paragraph(); 3712 } 3713 break; 3714 case 4: 3715 { 3716 setState(534); 3717 li(); 3718 } 3719 break; 3720 case 5: 3721 { 3722 setState(535); 3723 tr(); 3724 } 3725 break; 3726 case 6: 3727 { 3728 setState(536); 3729 th(); 3730 } 3731 break; 3732 case 7: 3733 { 3734 setState(537); 3735 body(); 3736 } 3737 break; 3738 case 8: 3739 { 3740 setState(538); 3741 colgroup(); 3742 } 3743 break; 3744 case 9: 3745 { 3746 setState(539); 3747 dd(); 3748 } 3749 break; 3750 case 10: 3751 { 3752 setState(540); 3753 dt(); 3754 } 3755 break; 3756 case 11: 3757 { 3758 setState(541); 3759 head(); 3760 } 3761 break; 3762 case 12: 3763 { 3764 setState(542); 3765 html(); 3766 } 3767 break; 3768 case 13: 3769 { 3770 setState(543); 3771 option(); 3772 } 3773 break; 3774 case 14: 3775 { 3776 setState(544); 3777 tbody(); 3778 } 3779 break; 3780 case 15: 3781 { 3782 setState(545); 3783 thead(); 3784 } 3785 break; 3786 case 16: 3787 { 3788 setState(546); 3789 tfoot(); 3790 } 3791 break; 3792 case 17: 3793 { 3794 setState(547); 3795 pTagStart(true); 3796 } 3797 break; 3798 case 18: 3799 { 3800 setState(548); 3801 liTagStart(true); 3802 } 3803 break; 3804 case 19: 3805 { 3806 setState(549); 3807 tdTagStart(true); 3808 } 3809 break; 3810 case 20: 3811 { 3812 setState(550); 3813 thTagStart(true); 3814 } 3815 break; 3816 case 21: 3817 { 3818 setState(551); 3819 bodyTagStart(true); 3820 } 3821 break; 3822 case 22: 3823 { 3824 setState(552); 3825 colgroupTagStart(true); 3826 } 3827 break; 3828 case 23: 3829 { 3830 setState(553); 3831 ddTagStart(true); 3832 } 3833 break; 3834 case 24: 3835 { 3836 setState(554); 3837 dtTagStart(true); 3838 } 3839 break; 3840 case 25: 3841 { 3842 setState(555); 3843 headTagStart(true); 3844 } 3845 break; 3846 case 26: 3847 { 3848 setState(556); 3849 htmlTagStart(true); 3850 } 3851 break; 3852 case 27: 3853 { 3854 setState(557); 3855 optionTagStart(true); 3856 } 3857 break; 3858 case 28: 3859 { 3860 setState(558); 3861 tbodyTagStart(true); 3862 } 3863 break; 3864 case 29: 3865 { 3866 setState(559); 3867 theadTagStart(true); 3868 } 3869 break; 3870 case 30: 3871 { 3872 setState(560); 3873 tfootTagStart(true); 3874 } 3875 break; 3876 case 31: 3877 { 3878 { 3879 setState(561); 3880 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 3881 setState(562); 3882 match(LEADING_ASTERISK); 3883 } 3884 } 3885 break; 3886 case 32: 3887 { 3888 setState(563); 3889 htmlComment(); 3890 } 3891 break; 3892 case 33: 3893 { 3894 setState(564); 3895 match(CDATA); 3896 } 3897 break; 3898 case 34: 3899 { 3900 setState(565); 3901 match(NEWLINE); 3902 } 3903 break; 3904 case 35: 3905 { 3906 setState(566); 3907 text(); 3908 } 3909 break; 3910 case 36: 3911 { 3912 setState(567); 3913 javadocInlineTag(); 3914 } 3915 break; 3916 } 3917 } 3918 } 3919 setState(572); 3920 _errHandler.sync(this); 3921 _alt = getInterpreter().adaptivePredict(_input,33,_ctx); 3922 } 3923 setState(573); 3924 tdTagEnd(); 3925 } 3926 } 3927 catch (RecognitionException re) { 3928 _localctx.exception = re; 3929 _errHandler.reportError(this, re); 3930 _errHandler.recover(this, re); 3931 } 3932 finally { 3933 exitRule(); 3934 } 3935 return _localctx; 3936 } 3937 3938 public static class ThTagStartContext extends ParserRuleContext { 3939 public boolean isNonTight; 3940 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 3941 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 3942 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 3943 public List<AttributeContext> attribute() { 3944 return getRuleContexts(AttributeContext.class); 3945 } 3946 public AttributeContext attribute(int i) { 3947 return getRuleContext(AttributeContext.class,i); 3948 } 3949 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3950 public TerminalNode NEWLINE(int i) { 3951 return getToken(JavadocParser.NEWLINE, i); 3952 } 3953 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3954 public TerminalNode LEADING_ASTERISK(int i) { 3955 return getToken(JavadocParser.LEADING_ASTERISK, i); 3956 } 3957 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3958 public TerminalNode WS(int i) { 3959 return getToken(JavadocParser.WS, i); 3960 } 3961 public ThTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 3962 public ThTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 3963 super(parent, invokingState); 3964 this.isNonTight = isNonTight; 3965 } 3966 @Override public int getRuleIndex() { return RULE_thTagStart; } 3967 } 3968 3969 public final ThTagStartContext thTagStart(boolean isNonTight) throws RecognitionException { 3970 ThTagStartContext _localctx = new ThTagStartContext(_ctx, getState(), isNonTight); 3971 enterRule(_localctx, 36, RULE_thTagStart); 3972 int _la; 3973 try { 3974 enterOuterAlt(_localctx, 1); 3975 { 3976 setState(575); 3977 match(START); 3978 setState(576); 3979 match(TH_HTML_TAG_NAME); 3980 setState(583); 3981 _errHandler.sync(this); 3982 _la = _input.LA(1); 3983 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 3984 { 3985 setState(581); 3986 _errHandler.sync(this); 3987 switch (_input.LA(1)) { 3988 case HTML_TAG_NAME: 3989 { 3990 setState(577); 3991 attribute(); 3992 } 3993 break; 3994 case NEWLINE: 3995 { 3996 setState(578); 3997 match(NEWLINE); 3998 } 3999 break; 4000 case LEADING_ASTERISK: 4001 { 4002 setState(579); 4003 match(LEADING_ASTERISK); 4004 } 4005 break; 4006 case WS: 4007 { 4008 setState(580); 4009 match(WS); 4010 } 4011 break; 4012 default: 4013 throw new NoViableAltException(this); 4014 } 4015 } 4016 setState(585); 4017 _errHandler.sync(this); 4018 _la = _input.LA(1); 4019 } 4020 setState(586); 4021 match(END); 4022 } 4023 _ctx.stop = _input.LT(-1); 4024 4025 if (isNonTight && nonTightTagStartContext == null) { 4026 nonTightTagStartContext = _localctx; 4027 } 4028 4029 } 4030 catch (RecognitionException re) { 4031 _localctx.exception = re; 4032 _errHandler.reportError(this, re); 4033 _errHandler.recover(this, re); 4034 } 4035 finally { 4036 exitRule(); 4037 } 4038 return _localctx; 4039 } 4040 4041 public static class ThTagEndContext extends ParserRuleContext { 4042 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 4043 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4044 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4045 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 4046 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4047 public TerminalNode NEWLINE(int i) { 4048 return getToken(JavadocParser.NEWLINE, i); 4049 } 4050 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4051 public TerminalNode LEADING_ASTERISK(int i) { 4052 return getToken(JavadocParser.LEADING_ASTERISK, i); 4053 } 4054 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4055 public TerminalNode WS(int i) { 4056 return getToken(JavadocParser.WS, i); 4057 } 4058 public ThTagEndContext(ParserRuleContext parent, int invokingState) { 4059 super(parent, invokingState); 4060 } 4061 @Override public int getRuleIndex() { return RULE_thTagEnd; } 4062 } 4063 4064 public final ThTagEndContext thTagEnd() throws RecognitionException { 4065 ThTagEndContext _localctx = new ThTagEndContext(_ctx, getState()); 4066 enterRule(_localctx, 38, RULE_thTagEnd); 4067 int _la; 4068 try { 4069 enterOuterAlt(_localctx, 1); 4070 { 4071 setState(588); 4072 match(START); 4073 setState(589); 4074 match(SLASH); 4075 setState(590); 4076 match(TH_HTML_TAG_NAME); 4077 setState(594); 4078 _errHandler.sync(this); 4079 _la = _input.LA(1); 4080 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 4081 { 4082 { 4083 setState(591); 4084 _la = _input.LA(1); 4085 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 4086 _errHandler.recoverInline(this); 4087 } 4088 else { 4089 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 4090 _errHandler.reportMatch(this); 4091 consume(); 4092 } 4093 } 4094 } 4095 setState(596); 4096 _errHandler.sync(this); 4097 _la = _input.LA(1); 4098 } 4099 setState(597); 4100 match(END); 4101 } 4102 } 4103 catch (RecognitionException re) { 4104 _localctx.exception = re; 4105 _errHandler.reportError(this, re); 4106 _errHandler.recover(this, re); 4107 } 4108 finally { 4109 exitRule(); 4110 } 4111 return _localctx; 4112 } 4113 4114 public static class ThContext extends ParserRuleContext { 4115 public ThTagStartContext thTagStart() { 4116 return getRuleContext(ThTagStartContext.class,0); 4117 } 4118 public ThTagEndContext thTagEnd() { 4119 return getRuleContext(ThTagEndContext.class,0); 4120 } 4121 public List<HtmlTagContext> htmlTag() { 4122 return getRuleContexts(HtmlTagContext.class); 4123 } 4124 public HtmlTagContext htmlTag(int i) { 4125 return getRuleContext(HtmlTagContext.class,i); 4126 } 4127 public List<SingletonElementContext> singletonElement() { 4128 return getRuleContexts(SingletonElementContext.class); 4129 } 4130 public SingletonElementContext singletonElement(int i) { 4131 return getRuleContext(SingletonElementContext.class,i); 4132 } 4133 public List<ParagraphContext> paragraph() { 4134 return getRuleContexts(ParagraphContext.class); 4135 } 4136 public ParagraphContext paragraph(int i) { 4137 return getRuleContext(ParagraphContext.class,i); 4138 } 4139 public List<LiContext> li() { 4140 return getRuleContexts(LiContext.class); 4141 } 4142 public LiContext li(int i) { 4143 return getRuleContext(LiContext.class,i); 4144 } 4145 public List<TrContext> tr() { 4146 return getRuleContexts(TrContext.class); 4147 } 4148 public TrContext tr(int i) { 4149 return getRuleContext(TrContext.class,i); 4150 } 4151 public List<TdContext> td() { 4152 return getRuleContexts(TdContext.class); 4153 } 4154 public TdContext td(int i) { 4155 return getRuleContext(TdContext.class,i); 4156 } 4157 public List<BodyContext> body() { 4158 return getRuleContexts(BodyContext.class); 4159 } 4160 public BodyContext body(int i) { 4161 return getRuleContext(BodyContext.class,i); 4162 } 4163 public List<ColgroupContext> colgroup() { 4164 return getRuleContexts(ColgroupContext.class); 4165 } 4166 public ColgroupContext colgroup(int i) { 4167 return getRuleContext(ColgroupContext.class,i); 4168 } 4169 public List<DdContext> dd() { 4170 return getRuleContexts(DdContext.class); 4171 } 4172 public DdContext dd(int i) { 4173 return getRuleContext(DdContext.class,i); 4174 } 4175 public List<DtContext> dt() { 4176 return getRuleContexts(DtContext.class); 4177 } 4178 public DtContext dt(int i) { 4179 return getRuleContext(DtContext.class,i); 4180 } 4181 public List<HeadContext> head() { 4182 return getRuleContexts(HeadContext.class); 4183 } 4184 public HeadContext head(int i) { 4185 return getRuleContext(HeadContext.class,i); 4186 } 4187 public List<HtmlContext> html() { 4188 return getRuleContexts(HtmlContext.class); 4189 } 4190 public HtmlContext html(int i) { 4191 return getRuleContext(HtmlContext.class,i); 4192 } 4193 public List<OptionContext> option() { 4194 return getRuleContexts(OptionContext.class); 4195 } 4196 public OptionContext option(int i) { 4197 return getRuleContext(OptionContext.class,i); 4198 } 4199 public List<TbodyContext> tbody() { 4200 return getRuleContexts(TbodyContext.class); 4201 } 4202 public TbodyContext tbody(int i) { 4203 return getRuleContext(TbodyContext.class,i); 4204 } 4205 public List<TheadContext> thead() { 4206 return getRuleContexts(TheadContext.class); 4207 } 4208 public TheadContext thead(int i) { 4209 return getRuleContext(TheadContext.class,i); 4210 } 4211 public List<TfootContext> tfoot() { 4212 return getRuleContexts(TfootContext.class); 4213 } 4214 public TfootContext tfoot(int i) { 4215 return getRuleContext(TfootContext.class,i); 4216 } 4217 public List<PTagStartContext> pTagStart() { 4218 return getRuleContexts(PTagStartContext.class); 4219 } 4220 public PTagStartContext pTagStart(int i) { 4221 return getRuleContext(PTagStartContext.class,i); 4222 } 4223 public List<LiTagStartContext> liTagStart() { 4224 return getRuleContexts(LiTagStartContext.class); 4225 } 4226 public LiTagStartContext liTagStart(int i) { 4227 return getRuleContext(LiTagStartContext.class,i); 4228 } 4229 public List<TrTagStartContext> trTagStart() { 4230 return getRuleContexts(TrTagStartContext.class); 4231 } 4232 public TrTagStartContext trTagStart(int i) { 4233 return getRuleContext(TrTagStartContext.class,i); 4234 } 4235 public List<TdTagStartContext> tdTagStart() { 4236 return getRuleContexts(TdTagStartContext.class); 4237 } 4238 public TdTagStartContext tdTagStart(int i) { 4239 return getRuleContext(TdTagStartContext.class,i); 4240 } 4241 public List<BodyTagStartContext> bodyTagStart() { 4242 return getRuleContexts(BodyTagStartContext.class); 4243 } 4244 public BodyTagStartContext bodyTagStart(int i) { 4245 return getRuleContext(BodyTagStartContext.class,i); 4246 } 4247 public List<ColgroupTagStartContext> colgroupTagStart() { 4248 return getRuleContexts(ColgroupTagStartContext.class); 4249 } 4250 public ColgroupTagStartContext colgroupTagStart(int i) { 4251 return getRuleContext(ColgroupTagStartContext.class,i); 4252 } 4253 public List<DdTagStartContext> ddTagStart() { 4254 return getRuleContexts(DdTagStartContext.class); 4255 } 4256 public DdTagStartContext ddTagStart(int i) { 4257 return getRuleContext(DdTagStartContext.class,i); 4258 } 4259 public List<DtTagStartContext> dtTagStart() { 4260 return getRuleContexts(DtTagStartContext.class); 4261 } 4262 public DtTagStartContext dtTagStart(int i) { 4263 return getRuleContext(DtTagStartContext.class,i); 4264 } 4265 public List<HeadTagStartContext> headTagStart() { 4266 return getRuleContexts(HeadTagStartContext.class); 4267 } 4268 public HeadTagStartContext headTagStart(int i) { 4269 return getRuleContext(HeadTagStartContext.class,i); 4270 } 4271 public List<HtmlTagStartContext> htmlTagStart() { 4272 return getRuleContexts(HtmlTagStartContext.class); 4273 } 4274 public HtmlTagStartContext htmlTagStart(int i) { 4275 return getRuleContext(HtmlTagStartContext.class,i); 4276 } 4277 public List<OptionTagStartContext> optionTagStart() { 4278 return getRuleContexts(OptionTagStartContext.class); 4279 } 4280 public OptionTagStartContext optionTagStart(int i) { 4281 return getRuleContext(OptionTagStartContext.class,i); 4282 } 4283 public List<TbodyTagStartContext> tbodyTagStart() { 4284 return getRuleContexts(TbodyTagStartContext.class); 4285 } 4286 public TbodyTagStartContext tbodyTagStart(int i) { 4287 return getRuleContext(TbodyTagStartContext.class,i); 4288 } 4289 public List<TheadTagStartContext> theadTagStart() { 4290 return getRuleContexts(TheadTagStartContext.class); 4291 } 4292 public TheadTagStartContext theadTagStart(int i) { 4293 return getRuleContext(TheadTagStartContext.class,i); 4294 } 4295 public List<TfootTagStartContext> tfootTagStart() { 4296 return getRuleContexts(TfootTagStartContext.class); 4297 } 4298 public TfootTagStartContext tfootTagStart(int i) { 4299 return getRuleContext(TfootTagStartContext.class,i); 4300 } 4301 public List<HtmlCommentContext> htmlComment() { 4302 return getRuleContexts(HtmlCommentContext.class); 4303 } 4304 public HtmlCommentContext htmlComment(int i) { 4305 return getRuleContext(HtmlCommentContext.class,i); 4306 } 4307 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 4308 public TerminalNode CDATA(int i) { 4309 return getToken(JavadocParser.CDATA, i); 4310 } 4311 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4312 public TerminalNode NEWLINE(int i) { 4313 return getToken(JavadocParser.NEWLINE, i); 4314 } 4315 public List<TextContext> text() { 4316 return getRuleContexts(TextContext.class); 4317 } 4318 public TextContext text(int i) { 4319 return getRuleContext(TextContext.class,i); 4320 } 4321 public List<JavadocInlineTagContext> javadocInlineTag() { 4322 return getRuleContexts(JavadocInlineTagContext.class); 4323 } 4324 public JavadocInlineTagContext javadocInlineTag(int i) { 4325 return getRuleContext(JavadocInlineTagContext.class,i); 4326 } 4327 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4328 public TerminalNode LEADING_ASTERISK(int i) { 4329 return getToken(JavadocParser.LEADING_ASTERISK, i); 4330 } 4331 public ThContext(ParserRuleContext parent, int invokingState) { 4332 super(parent, invokingState); 4333 } 4334 @Override public int getRuleIndex() { return RULE_th; } 4335 } 4336 4337 public final ThContext th() throws RecognitionException { 4338 ThContext _localctx = new ThContext(_ctx, getState()); 4339 enterRule(_localctx, 40, RULE_th); 4340 try { 4341 int _alt; 4342 enterOuterAlt(_localctx, 1); 4343 { 4344 setState(599); 4345 thTagStart(false); 4346 setState(639); 4347 _errHandler.sync(this); 4348 _alt = getInterpreter().adaptivePredict(_input,38,_ctx); 4349 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 4350 if ( _alt==1 ) { 4351 { 4352 setState(637); 4353 _errHandler.sync(this); 4354 switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) { 4355 case 1: 4356 { 4357 setState(600); 4358 htmlTag(); 4359 } 4360 break; 4361 case 2: 4362 { 4363 setState(601); 4364 singletonElement(); 4365 } 4366 break; 4367 case 3: 4368 { 4369 setState(602); 4370 paragraph(); 4371 } 4372 break; 4373 case 4: 4374 { 4375 setState(603); 4376 li(); 4377 } 4378 break; 4379 case 5: 4380 { 4381 setState(604); 4382 tr(); 4383 } 4384 break; 4385 case 6: 4386 { 4387 setState(605); 4388 td(); 4389 } 4390 break; 4391 case 7: 4392 { 4393 setState(606); 4394 body(); 4395 } 4396 break; 4397 case 8: 4398 { 4399 setState(607); 4400 colgroup(); 4401 } 4402 break; 4403 case 9: 4404 { 4405 setState(608); 4406 dd(); 4407 } 4408 break; 4409 case 10: 4410 { 4411 setState(609); 4412 dt(); 4413 } 4414 break; 4415 case 11: 4416 { 4417 setState(610); 4418 head(); 4419 } 4420 break; 4421 case 12: 4422 { 4423 setState(611); 4424 html(); 4425 } 4426 break; 4427 case 13: 4428 { 4429 setState(612); 4430 option(); 4431 } 4432 break; 4433 case 14: 4434 { 4435 setState(613); 4436 tbody(); 4437 } 4438 break; 4439 case 15: 4440 { 4441 setState(614); 4442 thead(); 4443 } 4444 break; 4445 case 16: 4446 { 4447 setState(615); 4448 tfoot(); 4449 } 4450 break; 4451 case 17: 4452 { 4453 setState(616); 4454 pTagStart(true); 4455 } 4456 break; 4457 case 18: 4458 { 4459 setState(617); 4460 liTagStart(true); 4461 } 4462 break; 4463 case 19: 4464 { 4465 setState(618); 4466 trTagStart(true); 4467 } 4468 break; 4469 case 20: 4470 { 4471 setState(619); 4472 tdTagStart(true); 4473 } 4474 break; 4475 case 21: 4476 { 4477 setState(620); 4478 bodyTagStart(true); 4479 } 4480 break; 4481 case 22: 4482 { 4483 setState(621); 4484 colgroupTagStart(true); 4485 } 4486 break; 4487 case 23: 4488 { 4489 setState(622); 4490 ddTagStart(true); 4491 } 4492 break; 4493 case 24: 4494 { 4495 setState(623); 4496 dtTagStart(true); 4497 } 4498 break; 4499 case 25: 4500 { 4501 setState(624); 4502 headTagStart(true); 4503 } 4504 break; 4505 case 26: 4506 { 4507 setState(625); 4508 htmlTagStart(true); 4509 } 4510 break; 4511 case 27: 4512 { 4513 setState(626); 4514 optionTagStart(true); 4515 } 4516 break; 4517 case 28: 4518 { 4519 setState(627); 4520 tbodyTagStart(true); 4521 } 4522 break; 4523 case 29: 4524 { 4525 setState(628); 4526 theadTagStart(true); 4527 } 4528 break; 4529 case 30: 4530 { 4531 setState(629); 4532 tfootTagStart(true); 4533 } 4534 break; 4535 case 31: 4536 { 4537 { 4538 setState(630); 4539 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4540 setState(631); 4541 match(LEADING_ASTERISK); 4542 } 4543 } 4544 break; 4545 case 32: 4546 { 4547 setState(632); 4548 htmlComment(); 4549 } 4550 break; 4551 case 33: 4552 { 4553 setState(633); 4554 match(CDATA); 4555 } 4556 break; 4557 case 34: 4558 { 4559 setState(634); 4560 match(NEWLINE); 4561 } 4562 break; 4563 case 35: 4564 { 4565 setState(635); 4566 text(); 4567 } 4568 break; 4569 case 36: 4570 { 4571 setState(636); 4572 javadocInlineTag(); 4573 } 4574 break; 4575 } 4576 } 4577 } 4578 setState(641); 4579 _errHandler.sync(this); 4580 _alt = getInterpreter().adaptivePredict(_input,38,_ctx); 4581 } 4582 setState(642); 4583 thTagEnd(); 4584 } 4585 } 4586 catch (RecognitionException re) { 4587 _localctx.exception = re; 4588 _errHandler.reportError(this, re); 4589 _errHandler.recover(this, re); 4590 } 4591 finally { 4592 exitRule(); 4593 } 4594 return _localctx; 4595 } 4596 4597 public static class BodyTagStartContext extends ParserRuleContext { 4598 public boolean isNonTight; 4599 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 4600 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 4601 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 4602 public List<AttributeContext> attribute() { 4603 return getRuleContexts(AttributeContext.class); 4604 } 4605 public AttributeContext attribute(int i) { 4606 return getRuleContext(AttributeContext.class,i); 4607 } 4608 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4609 public TerminalNode NEWLINE(int i) { 4610 return getToken(JavadocParser.NEWLINE, i); 4611 } 4612 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4613 public TerminalNode LEADING_ASTERISK(int i) { 4614 return getToken(JavadocParser.LEADING_ASTERISK, i); 4615 } 4616 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4617 public TerminalNode WS(int i) { 4618 return getToken(JavadocParser.WS, i); 4619 } 4620 public BodyTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 4621 public BodyTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 4622 super(parent, invokingState); 4623 this.isNonTight = isNonTight; 4624 } 4625 @Override public int getRuleIndex() { return RULE_bodyTagStart; } 4626 } 4627 4628 public final BodyTagStartContext bodyTagStart(boolean isNonTight) throws RecognitionException { 4629 BodyTagStartContext _localctx = new BodyTagStartContext(_ctx, getState(), isNonTight); 4630 enterRule(_localctx, 42, RULE_bodyTagStart); 4631 int _la; 4632 try { 4633 enterOuterAlt(_localctx, 1); 4634 { 4635 setState(644); 4636 match(START); 4637 setState(645); 4638 match(BODY_HTML_TAG_NAME); 4639 setState(652); 4640 _errHandler.sync(this); 4641 _la = _input.LA(1); 4642 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4643 { 4644 setState(650); 4645 _errHandler.sync(this); 4646 switch (_input.LA(1)) { 4647 case HTML_TAG_NAME: 4648 { 4649 setState(646); 4650 attribute(); 4651 } 4652 break; 4653 case NEWLINE: 4654 { 4655 setState(647); 4656 match(NEWLINE); 4657 } 4658 break; 4659 case LEADING_ASTERISK: 4660 { 4661 setState(648); 4662 match(LEADING_ASTERISK); 4663 } 4664 break; 4665 case WS: 4666 { 4667 setState(649); 4668 match(WS); 4669 } 4670 break; 4671 default: 4672 throw new NoViableAltException(this); 4673 } 4674 } 4675 setState(654); 4676 _errHandler.sync(this); 4677 _la = _input.LA(1); 4678 } 4679 setState(655); 4680 match(END); 4681 } 4682 _ctx.stop = _input.LT(-1); 4683 4684 if (isNonTight && nonTightTagStartContext == null) { 4685 nonTightTagStartContext = _localctx; 4686 } 4687 4688 } 4689 catch (RecognitionException re) { 4690 _localctx.exception = re; 4691 _errHandler.reportError(this, re); 4692 _errHandler.recover(this, re); 4693 } 4694 finally { 4695 exitRule(); 4696 } 4697 return _localctx; 4698 } 4699 4700 public static class BodyTagEndContext extends ParserRuleContext { 4701 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 4702 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4703 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 4704 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 4705 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4706 public TerminalNode NEWLINE(int i) { 4707 return getToken(JavadocParser.NEWLINE, i); 4708 } 4709 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4710 public TerminalNode LEADING_ASTERISK(int i) { 4711 return getToken(JavadocParser.LEADING_ASTERISK, i); 4712 } 4713 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4714 public TerminalNode WS(int i) { 4715 return getToken(JavadocParser.WS, i); 4716 } 4717 public BodyTagEndContext(ParserRuleContext parent, int invokingState) { 4718 super(parent, invokingState); 4719 } 4720 @Override public int getRuleIndex() { return RULE_bodyTagEnd; } 4721 } 4722 4723 public final BodyTagEndContext bodyTagEnd() throws RecognitionException { 4724 BodyTagEndContext _localctx = new BodyTagEndContext(_ctx, getState()); 4725 enterRule(_localctx, 44, RULE_bodyTagEnd); 4726 int _la; 4727 try { 4728 enterOuterAlt(_localctx, 1); 4729 { 4730 setState(657); 4731 match(START); 4732 setState(658); 4733 match(SLASH); 4734 setState(659); 4735 match(BODY_HTML_TAG_NAME); 4736 setState(663); 4737 _errHandler.sync(this); 4738 _la = _input.LA(1); 4739 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 4740 { 4741 { 4742 setState(660); 4743 _la = _input.LA(1); 4744 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 4745 _errHandler.recoverInline(this); 4746 } 4747 else { 4748 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 4749 _errHandler.reportMatch(this); 4750 consume(); 4751 } 4752 } 4753 } 4754 setState(665); 4755 _errHandler.sync(this); 4756 _la = _input.LA(1); 4757 } 4758 setState(666); 4759 match(END); 4760 } 4761 } 4762 catch (RecognitionException re) { 4763 _localctx.exception = re; 4764 _errHandler.reportError(this, re); 4765 _errHandler.recover(this, re); 4766 } 4767 finally { 4768 exitRule(); 4769 } 4770 return _localctx; 4771 } 4772 4773 public static class BodyContext extends ParserRuleContext { 4774 public BodyTagStartContext bodyTagStart() { 4775 return getRuleContext(BodyTagStartContext.class,0); 4776 } 4777 public BodyTagEndContext bodyTagEnd() { 4778 return getRuleContext(BodyTagEndContext.class,0); 4779 } 4780 public List<HtmlTagContext> htmlTag() { 4781 return getRuleContexts(HtmlTagContext.class); 4782 } 4783 public HtmlTagContext htmlTag(int i) { 4784 return getRuleContext(HtmlTagContext.class,i); 4785 } 4786 public List<SingletonElementContext> singletonElement() { 4787 return getRuleContexts(SingletonElementContext.class); 4788 } 4789 public SingletonElementContext singletonElement(int i) { 4790 return getRuleContext(SingletonElementContext.class,i); 4791 } 4792 public List<ParagraphContext> paragraph() { 4793 return getRuleContexts(ParagraphContext.class); 4794 } 4795 public ParagraphContext paragraph(int i) { 4796 return getRuleContext(ParagraphContext.class,i); 4797 } 4798 public List<LiContext> li() { 4799 return getRuleContexts(LiContext.class); 4800 } 4801 public LiContext li(int i) { 4802 return getRuleContext(LiContext.class,i); 4803 } 4804 public List<TrContext> tr() { 4805 return getRuleContexts(TrContext.class); 4806 } 4807 public TrContext tr(int i) { 4808 return getRuleContext(TrContext.class,i); 4809 } 4810 public List<TdContext> td() { 4811 return getRuleContexts(TdContext.class); 4812 } 4813 public TdContext td(int i) { 4814 return getRuleContext(TdContext.class,i); 4815 } 4816 public List<ThContext> th() { 4817 return getRuleContexts(ThContext.class); 4818 } 4819 public ThContext th(int i) { 4820 return getRuleContext(ThContext.class,i); 4821 } 4822 public List<ColgroupContext> colgroup() { 4823 return getRuleContexts(ColgroupContext.class); 4824 } 4825 public ColgroupContext colgroup(int i) { 4826 return getRuleContext(ColgroupContext.class,i); 4827 } 4828 public List<DdContext> dd() { 4829 return getRuleContexts(DdContext.class); 4830 } 4831 public DdContext dd(int i) { 4832 return getRuleContext(DdContext.class,i); 4833 } 4834 public List<DtContext> dt() { 4835 return getRuleContexts(DtContext.class); 4836 } 4837 public DtContext dt(int i) { 4838 return getRuleContext(DtContext.class,i); 4839 } 4840 public List<HeadContext> head() { 4841 return getRuleContexts(HeadContext.class); 4842 } 4843 public HeadContext head(int i) { 4844 return getRuleContext(HeadContext.class,i); 4845 } 4846 public List<HtmlContext> html() { 4847 return getRuleContexts(HtmlContext.class); 4848 } 4849 public HtmlContext html(int i) { 4850 return getRuleContext(HtmlContext.class,i); 4851 } 4852 public List<OptionContext> option() { 4853 return getRuleContexts(OptionContext.class); 4854 } 4855 public OptionContext option(int i) { 4856 return getRuleContext(OptionContext.class,i); 4857 } 4858 public List<TbodyContext> tbody() { 4859 return getRuleContexts(TbodyContext.class); 4860 } 4861 public TbodyContext tbody(int i) { 4862 return getRuleContext(TbodyContext.class,i); 4863 } 4864 public List<TheadContext> thead() { 4865 return getRuleContexts(TheadContext.class); 4866 } 4867 public TheadContext thead(int i) { 4868 return getRuleContext(TheadContext.class,i); 4869 } 4870 public List<TfootContext> tfoot() { 4871 return getRuleContexts(TfootContext.class); 4872 } 4873 public TfootContext tfoot(int i) { 4874 return getRuleContext(TfootContext.class,i); 4875 } 4876 public List<PTagStartContext> pTagStart() { 4877 return getRuleContexts(PTagStartContext.class); 4878 } 4879 public PTagStartContext pTagStart(int i) { 4880 return getRuleContext(PTagStartContext.class,i); 4881 } 4882 public List<LiTagStartContext> liTagStart() { 4883 return getRuleContexts(LiTagStartContext.class); 4884 } 4885 public LiTagStartContext liTagStart(int i) { 4886 return getRuleContext(LiTagStartContext.class,i); 4887 } 4888 public List<TrTagStartContext> trTagStart() { 4889 return getRuleContexts(TrTagStartContext.class); 4890 } 4891 public TrTagStartContext trTagStart(int i) { 4892 return getRuleContext(TrTagStartContext.class,i); 4893 } 4894 public List<TdTagStartContext> tdTagStart() { 4895 return getRuleContexts(TdTagStartContext.class); 4896 } 4897 public TdTagStartContext tdTagStart(int i) { 4898 return getRuleContext(TdTagStartContext.class,i); 4899 } 4900 public List<ThTagStartContext> thTagStart() { 4901 return getRuleContexts(ThTagStartContext.class); 4902 } 4903 public ThTagStartContext thTagStart(int i) { 4904 return getRuleContext(ThTagStartContext.class,i); 4905 } 4906 public List<ColgroupTagStartContext> colgroupTagStart() { 4907 return getRuleContexts(ColgroupTagStartContext.class); 4908 } 4909 public ColgroupTagStartContext colgroupTagStart(int i) { 4910 return getRuleContext(ColgroupTagStartContext.class,i); 4911 } 4912 public List<DdTagStartContext> ddTagStart() { 4913 return getRuleContexts(DdTagStartContext.class); 4914 } 4915 public DdTagStartContext ddTagStart(int i) { 4916 return getRuleContext(DdTagStartContext.class,i); 4917 } 4918 public List<DtTagStartContext> dtTagStart() { 4919 return getRuleContexts(DtTagStartContext.class); 4920 } 4921 public DtTagStartContext dtTagStart(int i) { 4922 return getRuleContext(DtTagStartContext.class,i); 4923 } 4924 public List<HeadTagStartContext> headTagStart() { 4925 return getRuleContexts(HeadTagStartContext.class); 4926 } 4927 public HeadTagStartContext headTagStart(int i) { 4928 return getRuleContext(HeadTagStartContext.class,i); 4929 } 4930 public List<HtmlTagStartContext> htmlTagStart() { 4931 return getRuleContexts(HtmlTagStartContext.class); 4932 } 4933 public HtmlTagStartContext htmlTagStart(int i) { 4934 return getRuleContext(HtmlTagStartContext.class,i); 4935 } 4936 public List<OptionTagStartContext> optionTagStart() { 4937 return getRuleContexts(OptionTagStartContext.class); 4938 } 4939 public OptionTagStartContext optionTagStart(int i) { 4940 return getRuleContext(OptionTagStartContext.class,i); 4941 } 4942 public List<TbodyTagStartContext> tbodyTagStart() { 4943 return getRuleContexts(TbodyTagStartContext.class); 4944 } 4945 public TbodyTagStartContext tbodyTagStart(int i) { 4946 return getRuleContext(TbodyTagStartContext.class,i); 4947 } 4948 public List<TheadTagStartContext> theadTagStart() { 4949 return getRuleContexts(TheadTagStartContext.class); 4950 } 4951 public TheadTagStartContext theadTagStart(int i) { 4952 return getRuleContext(TheadTagStartContext.class,i); 4953 } 4954 public List<TfootTagStartContext> tfootTagStart() { 4955 return getRuleContexts(TfootTagStartContext.class); 4956 } 4957 public TfootTagStartContext tfootTagStart(int i) { 4958 return getRuleContext(TfootTagStartContext.class,i); 4959 } 4960 public List<HtmlCommentContext> htmlComment() { 4961 return getRuleContexts(HtmlCommentContext.class); 4962 } 4963 public HtmlCommentContext htmlComment(int i) { 4964 return getRuleContext(HtmlCommentContext.class,i); 4965 } 4966 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 4967 public TerminalNode CDATA(int i) { 4968 return getToken(JavadocParser.CDATA, i); 4969 } 4970 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4971 public TerminalNode NEWLINE(int i) { 4972 return getToken(JavadocParser.NEWLINE, i); 4973 } 4974 public List<TextContext> text() { 4975 return getRuleContexts(TextContext.class); 4976 } 4977 public TextContext text(int i) { 4978 return getRuleContext(TextContext.class,i); 4979 } 4980 public List<JavadocInlineTagContext> javadocInlineTag() { 4981 return getRuleContexts(JavadocInlineTagContext.class); 4982 } 4983 public JavadocInlineTagContext javadocInlineTag(int i) { 4984 return getRuleContext(JavadocInlineTagContext.class,i); 4985 } 4986 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4987 public TerminalNode LEADING_ASTERISK(int i) { 4988 return getToken(JavadocParser.LEADING_ASTERISK, i); 4989 } 4990 public BodyContext(ParserRuleContext parent, int invokingState) { 4991 super(parent, invokingState); 4992 } 4993 @Override public int getRuleIndex() { return RULE_body; } 4994 } 4995 4996 public final BodyContext body() throws RecognitionException { 4997 BodyContext _localctx = new BodyContext(_ctx, getState()); 4998 enterRule(_localctx, 46, RULE_body); 4999 try { 5000 int _alt; 5001 enterOuterAlt(_localctx, 1); 5002 { 5003 setState(668); 5004 bodyTagStart(false); 5005 setState(708); 5006 _errHandler.sync(this); 5007 _alt = getInterpreter().adaptivePredict(_input,43,_ctx); 5008 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5009 if ( _alt==1 ) { 5010 { 5011 setState(706); 5012 _errHandler.sync(this); 5013 switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) { 5014 case 1: 5015 { 5016 setState(669); 5017 htmlTag(); 5018 } 5019 break; 5020 case 2: 5021 { 5022 setState(670); 5023 singletonElement(); 5024 } 5025 break; 5026 case 3: 5027 { 5028 setState(671); 5029 paragraph(); 5030 } 5031 break; 5032 case 4: 5033 { 5034 setState(672); 5035 li(); 5036 } 5037 break; 5038 case 5: 5039 { 5040 setState(673); 5041 tr(); 5042 } 5043 break; 5044 case 6: 5045 { 5046 setState(674); 5047 td(); 5048 } 5049 break; 5050 case 7: 5051 { 5052 setState(675); 5053 th(); 5054 } 5055 break; 5056 case 8: 5057 { 5058 setState(676); 5059 colgroup(); 5060 } 5061 break; 5062 case 9: 5063 { 5064 setState(677); 5065 dd(); 5066 } 5067 break; 5068 case 10: 5069 { 5070 setState(678); 5071 dt(); 5072 } 5073 break; 5074 case 11: 5075 { 5076 setState(679); 5077 head(); 5078 } 5079 break; 5080 case 12: 5081 { 5082 setState(680); 5083 html(); 5084 } 5085 break; 5086 case 13: 5087 { 5088 setState(681); 5089 option(); 5090 } 5091 break; 5092 case 14: 5093 { 5094 setState(682); 5095 tbody(); 5096 } 5097 break; 5098 case 15: 5099 { 5100 setState(683); 5101 thead(); 5102 } 5103 break; 5104 case 16: 5105 { 5106 setState(684); 5107 tfoot(); 5108 } 5109 break; 5110 case 17: 5111 { 5112 setState(685); 5113 pTagStart(true); 5114 } 5115 break; 5116 case 18: 5117 { 5118 setState(686); 5119 liTagStart(true); 5120 } 5121 break; 5122 case 19: 5123 { 5124 setState(687); 5125 trTagStart(true); 5126 } 5127 break; 5128 case 20: 5129 { 5130 setState(688); 5131 tdTagStart(true); 5132 } 5133 break; 5134 case 21: 5135 { 5136 setState(689); 5137 thTagStart(true); 5138 } 5139 break; 5140 case 22: 5141 { 5142 setState(690); 5143 colgroupTagStart(true); 5144 } 5145 break; 5146 case 23: 5147 { 5148 setState(691); 5149 ddTagStart(true); 5150 } 5151 break; 5152 case 24: 5153 { 5154 setState(692); 5155 dtTagStart(true); 5156 } 5157 break; 5158 case 25: 5159 { 5160 setState(693); 5161 headTagStart(true); 5162 } 5163 break; 5164 case 26: 5165 { 5166 setState(694); 5167 htmlTagStart(true); 5168 } 5169 break; 5170 case 27: 5171 { 5172 setState(695); 5173 optionTagStart(true); 5174 } 5175 break; 5176 case 28: 5177 { 5178 setState(696); 5179 tbodyTagStart(true); 5180 } 5181 break; 5182 case 29: 5183 { 5184 setState(697); 5185 theadTagStart(true); 5186 } 5187 break; 5188 case 30: 5189 { 5190 setState(698); 5191 tfootTagStart(true); 5192 } 5193 break; 5194 case 31: 5195 { 5196 { 5197 setState(699); 5198 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 5199 setState(700); 5200 match(LEADING_ASTERISK); 5201 } 5202 } 5203 break; 5204 case 32: 5205 { 5206 setState(701); 5207 htmlComment(); 5208 } 5209 break; 5210 case 33: 5211 { 5212 setState(702); 5213 match(CDATA); 5214 } 5215 break; 5216 case 34: 5217 { 5218 setState(703); 5219 match(NEWLINE); 5220 } 5221 break; 5222 case 35: 5223 { 5224 setState(704); 5225 text(); 5226 } 5227 break; 5228 case 36: 5229 { 5230 setState(705); 5231 javadocInlineTag(); 5232 } 5233 break; 5234 } 5235 } 5236 } 5237 setState(710); 5238 _errHandler.sync(this); 5239 _alt = getInterpreter().adaptivePredict(_input,43,_ctx); 5240 } 5241 setState(711); 5242 bodyTagEnd(); 5243 } 5244 } 5245 catch (RecognitionException re) { 5246 _localctx.exception = re; 5247 _errHandler.reportError(this, re); 5248 _errHandler.recover(this, re); 5249 } 5250 finally { 5251 exitRule(); 5252 } 5253 return _localctx; 5254 } 5255 5256 public static class ColgroupTagStartContext extends ParserRuleContext { 5257 public boolean isNonTight; 5258 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 5259 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5260 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 5261 public List<AttributeContext> attribute() { 5262 return getRuleContexts(AttributeContext.class); 5263 } 5264 public AttributeContext attribute(int i) { 5265 return getRuleContext(AttributeContext.class,i); 5266 } 5267 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5268 public TerminalNode NEWLINE(int i) { 5269 return getToken(JavadocParser.NEWLINE, i); 5270 } 5271 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5272 public TerminalNode LEADING_ASTERISK(int i) { 5273 return getToken(JavadocParser.LEADING_ASTERISK, i); 5274 } 5275 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5276 public TerminalNode WS(int i) { 5277 return getToken(JavadocParser.WS, i); 5278 } 5279 public ColgroupTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 5280 public ColgroupTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 5281 super(parent, invokingState); 5282 this.isNonTight = isNonTight; 5283 } 5284 @Override public int getRuleIndex() { return RULE_colgroupTagStart; } 5285 } 5286 5287 public final ColgroupTagStartContext colgroupTagStart(boolean isNonTight) throws RecognitionException { 5288 ColgroupTagStartContext _localctx = new ColgroupTagStartContext(_ctx, getState(), isNonTight); 5289 enterRule(_localctx, 48, RULE_colgroupTagStart); 5290 int _la; 5291 try { 5292 enterOuterAlt(_localctx, 1); 5293 { 5294 setState(713); 5295 match(START); 5296 setState(714); 5297 match(COLGROUP_HTML_TAG_NAME); 5298 setState(721); 5299 _errHandler.sync(this); 5300 _la = _input.LA(1); 5301 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 5302 { 5303 setState(719); 5304 _errHandler.sync(this); 5305 switch (_input.LA(1)) { 5306 case HTML_TAG_NAME: 5307 { 5308 setState(715); 5309 attribute(); 5310 } 5311 break; 5312 case NEWLINE: 5313 { 5314 setState(716); 5315 match(NEWLINE); 5316 } 5317 break; 5318 case LEADING_ASTERISK: 5319 { 5320 setState(717); 5321 match(LEADING_ASTERISK); 5322 } 5323 break; 5324 case WS: 5325 { 5326 setState(718); 5327 match(WS); 5328 } 5329 break; 5330 default: 5331 throw new NoViableAltException(this); 5332 } 5333 } 5334 setState(723); 5335 _errHandler.sync(this); 5336 _la = _input.LA(1); 5337 } 5338 setState(724); 5339 match(END); 5340 } 5341 _ctx.stop = _input.LT(-1); 5342 5343 if (isNonTight && nonTightTagStartContext == null) { 5344 nonTightTagStartContext = _localctx; 5345 } 5346 5347 } 5348 catch (RecognitionException re) { 5349 _localctx.exception = re; 5350 _errHandler.reportError(this, re); 5351 _errHandler.recover(this, re); 5352 } 5353 finally { 5354 exitRule(); 5355 } 5356 return _localctx; 5357 } 5358 5359 public static class ColgroupTagEndContext extends ParserRuleContext { 5360 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 5361 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 5362 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5363 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 5364 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5365 public TerminalNode NEWLINE(int i) { 5366 return getToken(JavadocParser.NEWLINE, i); 5367 } 5368 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5369 public TerminalNode LEADING_ASTERISK(int i) { 5370 return getToken(JavadocParser.LEADING_ASTERISK, i); 5371 } 5372 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5373 public TerminalNode WS(int i) { 5374 return getToken(JavadocParser.WS, i); 5375 } 5376 public ColgroupTagEndContext(ParserRuleContext parent, int invokingState) { 5377 super(parent, invokingState); 5378 } 5379 @Override public int getRuleIndex() { return RULE_colgroupTagEnd; } 5380 } 5381 5382 public final ColgroupTagEndContext colgroupTagEnd() throws RecognitionException { 5383 ColgroupTagEndContext _localctx = new ColgroupTagEndContext(_ctx, getState()); 5384 enterRule(_localctx, 50, RULE_colgroupTagEnd); 5385 int _la; 5386 try { 5387 enterOuterAlt(_localctx, 1); 5388 { 5389 setState(726); 5390 match(START); 5391 setState(727); 5392 match(SLASH); 5393 setState(728); 5394 match(COLGROUP_HTML_TAG_NAME); 5395 setState(732); 5396 _errHandler.sync(this); 5397 _la = _input.LA(1); 5398 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5399 { 5400 { 5401 setState(729); 5402 _la = _input.LA(1); 5403 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5404 _errHandler.recoverInline(this); 5405 } 5406 else { 5407 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 5408 _errHandler.reportMatch(this); 5409 consume(); 5410 } 5411 } 5412 } 5413 setState(734); 5414 _errHandler.sync(this); 5415 _la = _input.LA(1); 5416 } 5417 setState(735); 5418 match(END); 5419 } 5420 } 5421 catch (RecognitionException re) { 5422 _localctx.exception = re; 5423 _errHandler.reportError(this, re); 5424 _errHandler.recover(this, re); 5425 } 5426 finally { 5427 exitRule(); 5428 } 5429 return _localctx; 5430 } 5431 5432 public static class ColgroupContext extends ParserRuleContext { 5433 public ColgroupTagStartContext colgroupTagStart() { 5434 return getRuleContext(ColgroupTagStartContext.class,0); 5435 } 5436 public ColgroupTagEndContext colgroupTagEnd() { 5437 return getRuleContext(ColgroupTagEndContext.class,0); 5438 } 5439 public List<HtmlTagContext> htmlTag() { 5440 return getRuleContexts(HtmlTagContext.class); 5441 } 5442 public HtmlTagContext htmlTag(int i) { 5443 return getRuleContext(HtmlTagContext.class,i); 5444 } 5445 public List<SingletonElementContext> singletonElement() { 5446 return getRuleContexts(SingletonElementContext.class); 5447 } 5448 public SingletonElementContext singletonElement(int i) { 5449 return getRuleContext(SingletonElementContext.class,i); 5450 } 5451 public List<ParagraphContext> paragraph() { 5452 return getRuleContexts(ParagraphContext.class); 5453 } 5454 public ParagraphContext paragraph(int i) { 5455 return getRuleContext(ParagraphContext.class,i); 5456 } 5457 public List<LiContext> li() { 5458 return getRuleContexts(LiContext.class); 5459 } 5460 public LiContext li(int i) { 5461 return getRuleContext(LiContext.class,i); 5462 } 5463 public List<TrContext> tr() { 5464 return getRuleContexts(TrContext.class); 5465 } 5466 public TrContext tr(int i) { 5467 return getRuleContext(TrContext.class,i); 5468 } 5469 public List<TdContext> td() { 5470 return getRuleContexts(TdContext.class); 5471 } 5472 public TdContext td(int i) { 5473 return getRuleContext(TdContext.class,i); 5474 } 5475 public List<ThContext> th() { 5476 return getRuleContexts(ThContext.class); 5477 } 5478 public ThContext th(int i) { 5479 return getRuleContext(ThContext.class,i); 5480 } 5481 public List<BodyContext> body() { 5482 return getRuleContexts(BodyContext.class); 5483 } 5484 public BodyContext body(int i) { 5485 return getRuleContext(BodyContext.class,i); 5486 } 5487 public List<DdContext> dd() { 5488 return getRuleContexts(DdContext.class); 5489 } 5490 public DdContext dd(int i) { 5491 return getRuleContext(DdContext.class,i); 5492 } 5493 public List<DtContext> dt() { 5494 return getRuleContexts(DtContext.class); 5495 } 5496 public DtContext dt(int i) { 5497 return getRuleContext(DtContext.class,i); 5498 } 5499 public List<HeadContext> head() { 5500 return getRuleContexts(HeadContext.class); 5501 } 5502 public HeadContext head(int i) { 5503 return getRuleContext(HeadContext.class,i); 5504 } 5505 public List<HtmlContext> html() { 5506 return getRuleContexts(HtmlContext.class); 5507 } 5508 public HtmlContext html(int i) { 5509 return getRuleContext(HtmlContext.class,i); 5510 } 5511 public List<OptionContext> option() { 5512 return getRuleContexts(OptionContext.class); 5513 } 5514 public OptionContext option(int i) { 5515 return getRuleContext(OptionContext.class,i); 5516 } 5517 public List<TbodyContext> tbody() { 5518 return getRuleContexts(TbodyContext.class); 5519 } 5520 public TbodyContext tbody(int i) { 5521 return getRuleContext(TbodyContext.class,i); 5522 } 5523 public List<TheadContext> thead() { 5524 return getRuleContexts(TheadContext.class); 5525 } 5526 public TheadContext thead(int i) { 5527 return getRuleContext(TheadContext.class,i); 5528 } 5529 public List<TfootContext> tfoot() { 5530 return getRuleContexts(TfootContext.class); 5531 } 5532 public TfootContext tfoot(int i) { 5533 return getRuleContext(TfootContext.class,i); 5534 } 5535 public List<PTagStartContext> pTagStart() { 5536 return getRuleContexts(PTagStartContext.class); 5537 } 5538 public PTagStartContext pTagStart(int i) { 5539 return getRuleContext(PTagStartContext.class,i); 5540 } 5541 public List<LiTagStartContext> liTagStart() { 5542 return getRuleContexts(LiTagStartContext.class); 5543 } 5544 public LiTagStartContext liTagStart(int i) { 5545 return getRuleContext(LiTagStartContext.class,i); 5546 } 5547 public List<TrTagStartContext> trTagStart() { 5548 return getRuleContexts(TrTagStartContext.class); 5549 } 5550 public TrTagStartContext trTagStart(int i) { 5551 return getRuleContext(TrTagStartContext.class,i); 5552 } 5553 public List<TdTagStartContext> tdTagStart() { 5554 return getRuleContexts(TdTagStartContext.class); 5555 } 5556 public TdTagStartContext tdTagStart(int i) { 5557 return getRuleContext(TdTagStartContext.class,i); 5558 } 5559 public List<ThTagStartContext> thTagStart() { 5560 return getRuleContexts(ThTagStartContext.class); 5561 } 5562 public ThTagStartContext thTagStart(int i) { 5563 return getRuleContext(ThTagStartContext.class,i); 5564 } 5565 public List<BodyTagStartContext> bodyTagStart() { 5566 return getRuleContexts(BodyTagStartContext.class); 5567 } 5568 public BodyTagStartContext bodyTagStart(int i) { 5569 return getRuleContext(BodyTagStartContext.class,i); 5570 } 5571 public List<DdTagStartContext> ddTagStart() { 5572 return getRuleContexts(DdTagStartContext.class); 5573 } 5574 public DdTagStartContext ddTagStart(int i) { 5575 return getRuleContext(DdTagStartContext.class,i); 5576 } 5577 public List<DtTagStartContext> dtTagStart() { 5578 return getRuleContexts(DtTagStartContext.class); 5579 } 5580 public DtTagStartContext dtTagStart(int i) { 5581 return getRuleContext(DtTagStartContext.class,i); 5582 } 5583 public List<HeadTagStartContext> headTagStart() { 5584 return getRuleContexts(HeadTagStartContext.class); 5585 } 5586 public HeadTagStartContext headTagStart(int i) { 5587 return getRuleContext(HeadTagStartContext.class,i); 5588 } 5589 public List<HtmlTagStartContext> htmlTagStart() { 5590 return getRuleContexts(HtmlTagStartContext.class); 5591 } 5592 public HtmlTagStartContext htmlTagStart(int i) { 5593 return getRuleContext(HtmlTagStartContext.class,i); 5594 } 5595 public List<OptionTagStartContext> optionTagStart() { 5596 return getRuleContexts(OptionTagStartContext.class); 5597 } 5598 public OptionTagStartContext optionTagStart(int i) { 5599 return getRuleContext(OptionTagStartContext.class,i); 5600 } 5601 public List<TbodyTagStartContext> tbodyTagStart() { 5602 return getRuleContexts(TbodyTagStartContext.class); 5603 } 5604 public TbodyTagStartContext tbodyTagStart(int i) { 5605 return getRuleContext(TbodyTagStartContext.class,i); 5606 } 5607 public List<TheadTagStartContext> theadTagStart() { 5608 return getRuleContexts(TheadTagStartContext.class); 5609 } 5610 public TheadTagStartContext theadTagStart(int i) { 5611 return getRuleContext(TheadTagStartContext.class,i); 5612 } 5613 public List<TfootTagStartContext> tfootTagStart() { 5614 return getRuleContexts(TfootTagStartContext.class); 5615 } 5616 public TfootTagStartContext tfootTagStart(int i) { 5617 return getRuleContext(TfootTagStartContext.class,i); 5618 } 5619 public List<HtmlCommentContext> htmlComment() { 5620 return getRuleContexts(HtmlCommentContext.class); 5621 } 5622 public HtmlCommentContext htmlComment(int i) { 5623 return getRuleContext(HtmlCommentContext.class,i); 5624 } 5625 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5626 public TerminalNode CDATA(int i) { 5627 return getToken(JavadocParser.CDATA, i); 5628 } 5629 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5630 public TerminalNode NEWLINE(int i) { 5631 return getToken(JavadocParser.NEWLINE, i); 5632 } 5633 public List<TextContext> text() { 5634 return getRuleContexts(TextContext.class); 5635 } 5636 public TextContext text(int i) { 5637 return getRuleContext(TextContext.class,i); 5638 } 5639 public List<JavadocInlineTagContext> javadocInlineTag() { 5640 return getRuleContexts(JavadocInlineTagContext.class); 5641 } 5642 public JavadocInlineTagContext javadocInlineTag(int i) { 5643 return getRuleContext(JavadocInlineTagContext.class,i); 5644 } 5645 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5646 public TerminalNode LEADING_ASTERISK(int i) { 5647 return getToken(JavadocParser.LEADING_ASTERISK, i); 5648 } 5649 public ColgroupContext(ParserRuleContext parent, int invokingState) { 5650 super(parent, invokingState); 5651 } 5652 @Override public int getRuleIndex() { return RULE_colgroup; } 5653 } 5654 5655 public final ColgroupContext colgroup() throws RecognitionException { 5656 ColgroupContext _localctx = new ColgroupContext(_ctx, getState()); 5657 enterRule(_localctx, 52, RULE_colgroup); 5658 try { 5659 int _alt; 5660 enterOuterAlt(_localctx, 1); 5661 { 5662 setState(737); 5663 colgroupTagStart(false); 5664 setState(777); 5665 _errHandler.sync(this); 5666 _alt = getInterpreter().adaptivePredict(_input,48,_ctx); 5667 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5668 if ( _alt==1 ) { 5669 { 5670 setState(775); 5671 _errHandler.sync(this); 5672 switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) { 5673 case 1: 5674 { 5675 setState(738); 5676 htmlTag(); 5677 } 5678 break; 5679 case 2: 5680 { 5681 setState(739); 5682 singletonElement(); 5683 } 5684 break; 5685 case 3: 5686 { 5687 setState(740); 5688 paragraph(); 5689 } 5690 break; 5691 case 4: 5692 { 5693 setState(741); 5694 li(); 5695 } 5696 break; 5697 case 5: 5698 { 5699 setState(742); 5700 tr(); 5701 } 5702 break; 5703 case 6: 5704 { 5705 setState(743); 5706 td(); 5707 } 5708 break; 5709 case 7: 5710 { 5711 setState(744); 5712 th(); 5713 } 5714 break; 5715 case 8: 5716 { 5717 setState(745); 5718 body(); 5719 } 5720 break; 5721 case 9: 5722 { 5723 setState(746); 5724 dd(); 5725 } 5726 break; 5727 case 10: 5728 { 5729 setState(747); 5730 dt(); 5731 } 5732 break; 5733 case 11: 5734 { 5735 setState(748); 5736 head(); 5737 } 5738 break; 5739 case 12: 5740 { 5741 setState(749); 5742 html(); 5743 } 5744 break; 5745 case 13: 5746 { 5747 setState(750); 5748 option(); 5749 } 5750 break; 5751 case 14: 5752 { 5753 setState(751); 5754 tbody(); 5755 } 5756 break; 5757 case 15: 5758 { 5759 setState(752); 5760 thead(); 5761 } 5762 break; 5763 case 16: 5764 { 5765 setState(753); 5766 tfoot(); 5767 } 5768 break; 5769 case 17: 5770 { 5771 setState(754); 5772 pTagStart(true); 5773 } 5774 break; 5775 case 18: 5776 { 5777 setState(755); 5778 liTagStart(true); 5779 } 5780 break; 5781 case 19: 5782 { 5783 setState(756); 5784 trTagStart(true); 5785 } 5786 break; 5787 case 20: 5788 { 5789 setState(757); 5790 tdTagStart(true); 5791 } 5792 break; 5793 case 21: 5794 { 5795 setState(758); 5796 thTagStart(true); 5797 } 5798 break; 5799 case 22: 5800 { 5801 setState(759); 5802 bodyTagStart(true); 5803 } 5804 break; 5805 case 23: 5806 { 5807 setState(760); 5808 ddTagStart(true); 5809 } 5810 break; 5811 case 24: 5812 { 5813 setState(761); 5814 dtTagStart(true); 5815 } 5816 break; 5817 case 25: 5818 { 5819 setState(762); 5820 headTagStart(true); 5821 } 5822 break; 5823 case 26: 5824 { 5825 setState(763); 5826 htmlTagStart(true); 5827 } 5828 break; 5829 case 27: 5830 { 5831 setState(764); 5832 optionTagStart(true); 5833 } 5834 break; 5835 case 28: 5836 { 5837 setState(765); 5838 tbodyTagStart(true); 5839 } 5840 break; 5841 case 29: 5842 { 5843 setState(766); 5844 theadTagStart(true); 5845 } 5846 break; 5847 case 30: 5848 { 5849 setState(767); 5850 tfootTagStart(true); 5851 } 5852 break; 5853 case 31: 5854 { 5855 { 5856 setState(768); 5857 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 5858 setState(769); 5859 match(LEADING_ASTERISK); 5860 } 5861 } 5862 break; 5863 case 32: 5864 { 5865 setState(770); 5866 htmlComment(); 5867 } 5868 break; 5869 case 33: 5870 { 5871 setState(771); 5872 match(CDATA); 5873 } 5874 break; 5875 case 34: 5876 { 5877 setState(772); 5878 match(NEWLINE); 5879 } 5880 break; 5881 case 35: 5882 { 5883 setState(773); 5884 text(); 5885 } 5886 break; 5887 case 36: 5888 { 5889 setState(774); 5890 javadocInlineTag(); 5891 } 5892 break; 5893 } 5894 } 5895 } 5896 setState(779); 5897 _errHandler.sync(this); 5898 _alt = getInterpreter().adaptivePredict(_input,48,_ctx); 5899 } 5900 setState(780); 5901 colgroupTagEnd(); 5902 } 5903 } 5904 catch (RecognitionException re) { 5905 _localctx.exception = re; 5906 _errHandler.reportError(this, re); 5907 _errHandler.recover(this, re); 5908 } 5909 finally { 5910 exitRule(); 5911 } 5912 return _localctx; 5913 } 5914 5915 public static class DdTagStartContext extends ParserRuleContext { 5916 public boolean isNonTight; 5917 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 5918 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 5919 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 5920 public List<AttributeContext> attribute() { 5921 return getRuleContexts(AttributeContext.class); 5922 } 5923 public AttributeContext attribute(int i) { 5924 return getRuleContext(AttributeContext.class,i); 5925 } 5926 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5927 public TerminalNode NEWLINE(int i) { 5928 return getToken(JavadocParser.NEWLINE, i); 5929 } 5930 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5931 public TerminalNode LEADING_ASTERISK(int i) { 5932 return getToken(JavadocParser.LEADING_ASTERISK, i); 5933 } 5934 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5935 public TerminalNode WS(int i) { 5936 return getToken(JavadocParser.WS, i); 5937 } 5938 public DdTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 5939 public DdTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 5940 super(parent, invokingState); 5941 this.isNonTight = isNonTight; 5942 } 5943 @Override public int getRuleIndex() { return RULE_ddTagStart; } 5944 } 5945 5946 public final DdTagStartContext ddTagStart(boolean isNonTight) throws RecognitionException { 5947 DdTagStartContext _localctx = new DdTagStartContext(_ctx, getState(), isNonTight); 5948 enterRule(_localctx, 54, RULE_ddTagStart); 5949 int _la; 5950 try { 5951 enterOuterAlt(_localctx, 1); 5952 { 5953 setState(782); 5954 match(START); 5955 setState(783); 5956 match(DD_HTML_TAG_NAME); 5957 setState(790); 5958 _errHandler.sync(this); 5959 _la = _input.LA(1); 5960 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 5961 { 5962 setState(788); 5963 _errHandler.sync(this); 5964 switch (_input.LA(1)) { 5965 case HTML_TAG_NAME: 5966 { 5967 setState(784); 5968 attribute(); 5969 } 5970 break; 5971 case NEWLINE: 5972 { 5973 setState(785); 5974 match(NEWLINE); 5975 } 5976 break; 5977 case LEADING_ASTERISK: 5978 { 5979 setState(786); 5980 match(LEADING_ASTERISK); 5981 } 5982 break; 5983 case WS: 5984 { 5985 setState(787); 5986 match(WS); 5987 } 5988 break; 5989 default: 5990 throw new NoViableAltException(this); 5991 } 5992 } 5993 setState(792); 5994 _errHandler.sync(this); 5995 _la = _input.LA(1); 5996 } 5997 setState(793); 5998 match(END); 5999 } 6000 _ctx.stop = _input.LT(-1); 6001 6002 if (isNonTight && nonTightTagStartContext == null) { 6003 nonTightTagStartContext = _localctx; 6004 } 6005 6006 } 6007 catch (RecognitionException re) { 6008 _localctx.exception = re; 6009 _errHandler.reportError(this, re); 6010 _errHandler.recover(this, re); 6011 } 6012 finally { 6013 exitRule(); 6014 } 6015 return _localctx; 6016 } 6017 6018 public static class DdTagEndContext extends ParserRuleContext { 6019 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 6020 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 6021 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6022 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 6023 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6024 public TerminalNode NEWLINE(int i) { 6025 return getToken(JavadocParser.NEWLINE, i); 6026 } 6027 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6028 public TerminalNode LEADING_ASTERISK(int i) { 6029 return getToken(JavadocParser.LEADING_ASTERISK, i); 6030 } 6031 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6032 public TerminalNode WS(int i) { 6033 return getToken(JavadocParser.WS, i); 6034 } 6035 public DdTagEndContext(ParserRuleContext parent, int invokingState) { 6036 super(parent, invokingState); 6037 } 6038 @Override public int getRuleIndex() { return RULE_ddTagEnd; } 6039 } 6040 6041 public final DdTagEndContext ddTagEnd() throws RecognitionException { 6042 DdTagEndContext _localctx = new DdTagEndContext(_ctx, getState()); 6043 enterRule(_localctx, 56, RULE_ddTagEnd); 6044 int _la; 6045 try { 6046 enterOuterAlt(_localctx, 1); 6047 { 6048 setState(795); 6049 match(START); 6050 setState(796); 6051 match(SLASH); 6052 setState(797); 6053 match(DD_HTML_TAG_NAME); 6054 setState(801); 6055 _errHandler.sync(this); 6056 _la = _input.LA(1); 6057 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 6058 { 6059 { 6060 setState(798); 6061 _la = _input.LA(1); 6062 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 6063 _errHandler.recoverInline(this); 6064 } 6065 else { 6066 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 6067 _errHandler.reportMatch(this); 6068 consume(); 6069 } 6070 } 6071 } 6072 setState(803); 6073 _errHandler.sync(this); 6074 _la = _input.LA(1); 6075 } 6076 setState(804); 6077 match(END); 6078 } 6079 } 6080 catch (RecognitionException re) { 6081 _localctx.exception = re; 6082 _errHandler.reportError(this, re); 6083 _errHandler.recover(this, re); 6084 } 6085 finally { 6086 exitRule(); 6087 } 6088 return _localctx; 6089 } 6090 6091 public static class DdContext extends ParserRuleContext { 6092 public DdTagStartContext ddTagStart() { 6093 return getRuleContext(DdTagStartContext.class,0); 6094 } 6095 public DdTagEndContext ddTagEnd() { 6096 return getRuleContext(DdTagEndContext.class,0); 6097 } 6098 public List<HtmlTagContext> htmlTag() { 6099 return getRuleContexts(HtmlTagContext.class); 6100 } 6101 public HtmlTagContext htmlTag(int i) { 6102 return getRuleContext(HtmlTagContext.class,i); 6103 } 6104 public List<SingletonElementContext> singletonElement() { 6105 return getRuleContexts(SingletonElementContext.class); 6106 } 6107 public SingletonElementContext singletonElement(int i) { 6108 return getRuleContext(SingletonElementContext.class,i); 6109 } 6110 public List<ParagraphContext> paragraph() { 6111 return getRuleContexts(ParagraphContext.class); 6112 } 6113 public ParagraphContext paragraph(int i) { 6114 return getRuleContext(ParagraphContext.class,i); 6115 } 6116 public List<LiContext> li() { 6117 return getRuleContexts(LiContext.class); 6118 } 6119 public LiContext li(int i) { 6120 return getRuleContext(LiContext.class,i); 6121 } 6122 public List<TrContext> tr() { 6123 return getRuleContexts(TrContext.class); 6124 } 6125 public TrContext tr(int i) { 6126 return getRuleContext(TrContext.class,i); 6127 } 6128 public List<TdContext> td() { 6129 return getRuleContexts(TdContext.class); 6130 } 6131 public TdContext td(int i) { 6132 return getRuleContext(TdContext.class,i); 6133 } 6134 public List<ThContext> th() { 6135 return getRuleContexts(ThContext.class); 6136 } 6137 public ThContext th(int i) { 6138 return getRuleContext(ThContext.class,i); 6139 } 6140 public List<BodyContext> body() { 6141 return getRuleContexts(BodyContext.class); 6142 } 6143 public BodyContext body(int i) { 6144 return getRuleContext(BodyContext.class,i); 6145 } 6146 public List<ColgroupContext> colgroup() { 6147 return getRuleContexts(ColgroupContext.class); 6148 } 6149 public ColgroupContext colgroup(int i) { 6150 return getRuleContext(ColgroupContext.class,i); 6151 } 6152 public List<DtContext> dt() { 6153 return getRuleContexts(DtContext.class); 6154 } 6155 public DtContext dt(int i) { 6156 return getRuleContext(DtContext.class,i); 6157 } 6158 public List<HeadContext> head() { 6159 return getRuleContexts(HeadContext.class); 6160 } 6161 public HeadContext head(int i) { 6162 return getRuleContext(HeadContext.class,i); 6163 } 6164 public List<HtmlContext> html() { 6165 return getRuleContexts(HtmlContext.class); 6166 } 6167 public HtmlContext html(int i) { 6168 return getRuleContext(HtmlContext.class,i); 6169 } 6170 public List<OptionContext> option() { 6171 return getRuleContexts(OptionContext.class); 6172 } 6173 public OptionContext option(int i) { 6174 return getRuleContext(OptionContext.class,i); 6175 } 6176 public List<TbodyContext> tbody() { 6177 return getRuleContexts(TbodyContext.class); 6178 } 6179 public TbodyContext tbody(int i) { 6180 return getRuleContext(TbodyContext.class,i); 6181 } 6182 public List<TheadContext> thead() { 6183 return getRuleContexts(TheadContext.class); 6184 } 6185 public TheadContext thead(int i) { 6186 return getRuleContext(TheadContext.class,i); 6187 } 6188 public List<TfootContext> tfoot() { 6189 return getRuleContexts(TfootContext.class); 6190 } 6191 public TfootContext tfoot(int i) { 6192 return getRuleContext(TfootContext.class,i); 6193 } 6194 public List<PTagStartContext> pTagStart() { 6195 return getRuleContexts(PTagStartContext.class); 6196 } 6197 public PTagStartContext pTagStart(int i) { 6198 return getRuleContext(PTagStartContext.class,i); 6199 } 6200 public List<LiTagStartContext> liTagStart() { 6201 return getRuleContexts(LiTagStartContext.class); 6202 } 6203 public LiTagStartContext liTagStart(int i) { 6204 return getRuleContext(LiTagStartContext.class,i); 6205 } 6206 public List<TrTagStartContext> trTagStart() { 6207 return getRuleContexts(TrTagStartContext.class); 6208 } 6209 public TrTagStartContext trTagStart(int i) { 6210 return getRuleContext(TrTagStartContext.class,i); 6211 } 6212 public List<TdTagStartContext> tdTagStart() { 6213 return getRuleContexts(TdTagStartContext.class); 6214 } 6215 public TdTagStartContext tdTagStart(int i) { 6216 return getRuleContext(TdTagStartContext.class,i); 6217 } 6218 public List<ThTagStartContext> thTagStart() { 6219 return getRuleContexts(ThTagStartContext.class); 6220 } 6221 public ThTagStartContext thTagStart(int i) { 6222 return getRuleContext(ThTagStartContext.class,i); 6223 } 6224 public List<BodyTagStartContext> bodyTagStart() { 6225 return getRuleContexts(BodyTagStartContext.class); 6226 } 6227 public BodyTagStartContext bodyTagStart(int i) { 6228 return getRuleContext(BodyTagStartContext.class,i); 6229 } 6230 public List<ColgroupTagStartContext> colgroupTagStart() { 6231 return getRuleContexts(ColgroupTagStartContext.class); 6232 } 6233 public ColgroupTagStartContext colgroupTagStart(int i) { 6234 return getRuleContext(ColgroupTagStartContext.class,i); 6235 } 6236 public List<DtTagStartContext> dtTagStart() { 6237 return getRuleContexts(DtTagStartContext.class); 6238 } 6239 public DtTagStartContext dtTagStart(int i) { 6240 return getRuleContext(DtTagStartContext.class,i); 6241 } 6242 public List<HeadTagStartContext> headTagStart() { 6243 return getRuleContexts(HeadTagStartContext.class); 6244 } 6245 public HeadTagStartContext headTagStart(int i) { 6246 return getRuleContext(HeadTagStartContext.class,i); 6247 } 6248 public List<HtmlTagStartContext> htmlTagStart() { 6249 return getRuleContexts(HtmlTagStartContext.class); 6250 } 6251 public HtmlTagStartContext htmlTagStart(int i) { 6252 return getRuleContext(HtmlTagStartContext.class,i); 6253 } 6254 public List<OptionTagStartContext> optionTagStart() { 6255 return getRuleContexts(OptionTagStartContext.class); 6256 } 6257 public OptionTagStartContext optionTagStart(int i) { 6258 return getRuleContext(OptionTagStartContext.class,i); 6259 } 6260 public List<TbodyTagStartContext> tbodyTagStart() { 6261 return getRuleContexts(TbodyTagStartContext.class); 6262 } 6263 public TbodyTagStartContext tbodyTagStart(int i) { 6264 return getRuleContext(TbodyTagStartContext.class,i); 6265 } 6266 public List<TheadTagStartContext> theadTagStart() { 6267 return getRuleContexts(TheadTagStartContext.class); 6268 } 6269 public TheadTagStartContext theadTagStart(int i) { 6270 return getRuleContext(TheadTagStartContext.class,i); 6271 } 6272 public List<TfootTagStartContext> tfootTagStart() { 6273 return getRuleContexts(TfootTagStartContext.class); 6274 } 6275 public TfootTagStartContext tfootTagStart(int i) { 6276 return getRuleContext(TfootTagStartContext.class,i); 6277 } 6278 public List<HtmlCommentContext> htmlComment() { 6279 return getRuleContexts(HtmlCommentContext.class); 6280 } 6281 public HtmlCommentContext htmlComment(int i) { 6282 return getRuleContext(HtmlCommentContext.class,i); 6283 } 6284 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 6285 public TerminalNode CDATA(int i) { 6286 return getToken(JavadocParser.CDATA, i); 6287 } 6288 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6289 public TerminalNode NEWLINE(int i) { 6290 return getToken(JavadocParser.NEWLINE, i); 6291 } 6292 public List<TextContext> text() { 6293 return getRuleContexts(TextContext.class); 6294 } 6295 public TextContext text(int i) { 6296 return getRuleContext(TextContext.class,i); 6297 } 6298 public List<JavadocInlineTagContext> javadocInlineTag() { 6299 return getRuleContexts(JavadocInlineTagContext.class); 6300 } 6301 public JavadocInlineTagContext javadocInlineTag(int i) { 6302 return getRuleContext(JavadocInlineTagContext.class,i); 6303 } 6304 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6305 public TerminalNode LEADING_ASTERISK(int i) { 6306 return getToken(JavadocParser.LEADING_ASTERISK, i); 6307 } 6308 public DdContext(ParserRuleContext parent, int invokingState) { 6309 super(parent, invokingState); 6310 } 6311 @Override public int getRuleIndex() { return RULE_dd; } 6312 } 6313 6314 public final DdContext dd() throws RecognitionException { 6315 DdContext _localctx = new DdContext(_ctx, getState()); 6316 enterRule(_localctx, 58, RULE_dd); 6317 try { 6318 int _alt; 6319 enterOuterAlt(_localctx, 1); 6320 { 6321 setState(806); 6322 ddTagStart(false); 6323 setState(846); 6324 _errHandler.sync(this); 6325 _alt = getInterpreter().adaptivePredict(_input,53,_ctx); 6326 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6327 if ( _alt==1 ) { 6328 { 6329 setState(844); 6330 _errHandler.sync(this); 6331 switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) { 6332 case 1: 6333 { 6334 setState(807); 6335 htmlTag(); 6336 } 6337 break; 6338 case 2: 6339 { 6340 setState(808); 6341 singletonElement(); 6342 } 6343 break; 6344 case 3: 6345 { 6346 setState(809); 6347 paragraph(); 6348 } 6349 break; 6350 case 4: 6351 { 6352 setState(810); 6353 li(); 6354 } 6355 break; 6356 case 5: 6357 { 6358 setState(811); 6359 tr(); 6360 } 6361 break; 6362 case 6: 6363 { 6364 setState(812); 6365 td(); 6366 } 6367 break; 6368 case 7: 6369 { 6370 setState(813); 6371 th(); 6372 } 6373 break; 6374 case 8: 6375 { 6376 setState(814); 6377 body(); 6378 } 6379 break; 6380 case 9: 6381 { 6382 setState(815); 6383 colgroup(); 6384 } 6385 break; 6386 case 10: 6387 { 6388 setState(816); 6389 dt(); 6390 } 6391 break; 6392 case 11: 6393 { 6394 setState(817); 6395 head(); 6396 } 6397 break; 6398 case 12: 6399 { 6400 setState(818); 6401 html(); 6402 } 6403 break; 6404 case 13: 6405 { 6406 setState(819); 6407 option(); 6408 } 6409 break; 6410 case 14: 6411 { 6412 setState(820); 6413 tbody(); 6414 } 6415 break; 6416 case 15: 6417 { 6418 setState(821); 6419 thead(); 6420 } 6421 break; 6422 case 16: 6423 { 6424 setState(822); 6425 tfoot(); 6426 } 6427 break; 6428 case 17: 6429 { 6430 setState(823); 6431 pTagStart(true); 6432 } 6433 break; 6434 case 18: 6435 { 6436 setState(824); 6437 liTagStart(true); 6438 } 6439 break; 6440 case 19: 6441 { 6442 setState(825); 6443 trTagStart(true); 6444 } 6445 break; 6446 case 20: 6447 { 6448 setState(826); 6449 tdTagStart(true); 6450 } 6451 break; 6452 case 21: 6453 { 6454 setState(827); 6455 thTagStart(true); 6456 } 6457 break; 6458 case 22: 6459 { 6460 setState(828); 6461 bodyTagStart(true); 6462 } 6463 break; 6464 case 23: 6465 { 6466 setState(829); 6467 colgroupTagStart(true); 6468 } 6469 break; 6470 case 24: 6471 { 6472 setState(830); 6473 dtTagStart(true); 6474 } 6475 break; 6476 case 25: 6477 { 6478 setState(831); 6479 headTagStart(true); 6480 } 6481 break; 6482 case 26: 6483 { 6484 setState(832); 6485 htmlTagStart(true); 6486 } 6487 break; 6488 case 27: 6489 { 6490 setState(833); 6491 optionTagStart(true); 6492 } 6493 break; 6494 case 28: 6495 { 6496 setState(834); 6497 tbodyTagStart(true); 6498 } 6499 break; 6500 case 29: 6501 { 6502 setState(835); 6503 theadTagStart(true); 6504 } 6505 break; 6506 case 30: 6507 { 6508 setState(836); 6509 tfootTagStart(true); 6510 } 6511 break; 6512 case 31: 6513 { 6514 { 6515 setState(837); 6516 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6517 setState(838); 6518 match(LEADING_ASTERISK); 6519 } 6520 } 6521 break; 6522 case 32: 6523 { 6524 setState(839); 6525 htmlComment(); 6526 } 6527 break; 6528 case 33: 6529 { 6530 setState(840); 6531 match(CDATA); 6532 } 6533 break; 6534 case 34: 6535 { 6536 setState(841); 6537 match(NEWLINE); 6538 } 6539 break; 6540 case 35: 6541 { 6542 setState(842); 6543 text(); 6544 } 6545 break; 6546 case 36: 6547 { 6548 setState(843); 6549 javadocInlineTag(); 6550 } 6551 break; 6552 } 6553 } 6554 } 6555 setState(848); 6556 _errHandler.sync(this); 6557 _alt = getInterpreter().adaptivePredict(_input,53,_ctx); 6558 } 6559 setState(849); 6560 ddTagEnd(); 6561 } 6562 } 6563 catch (RecognitionException re) { 6564 _localctx.exception = re; 6565 _errHandler.reportError(this, re); 6566 _errHandler.recover(this, re); 6567 } 6568 finally { 6569 exitRule(); 6570 } 6571 return _localctx; 6572 } 6573 6574 public static class DtTagStartContext extends ParserRuleContext { 6575 public boolean isNonTight; 6576 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 6577 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 6578 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 6579 public List<AttributeContext> attribute() { 6580 return getRuleContexts(AttributeContext.class); 6581 } 6582 public AttributeContext attribute(int i) { 6583 return getRuleContext(AttributeContext.class,i); 6584 } 6585 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6586 public TerminalNode NEWLINE(int i) { 6587 return getToken(JavadocParser.NEWLINE, i); 6588 } 6589 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6590 public TerminalNode LEADING_ASTERISK(int i) { 6591 return getToken(JavadocParser.LEADING_ASTERISK, i); 6592 } 6593 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6594 public TerminalNode WS(int i) { 6595 return getToken(JavadocParser.WS, i); 6596 } 6597 public DtTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 6598 public DtTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 6599 super(parent, invokingState); 6600 this.isNonTight = isNonTight; 6601 } 6602 @Override public int getRuleIndex() { return RULE_dtTagStart; } 6603 } 6604 6605 public final DtTagStartContext dtTagStart(boolean isNonTight) throws RecognitionException { 6606 DtTagStartContext _localctx = new DtTagStartContext(_ctx, getState(), isNonTight); 6607 enterRule(_localctx, 60, RULE_dtTagStart); 6608 int _la; 6609 try { 6610 enterOuterAlt(_localctx, 1); 6611 { 6612 setState(851); 6613 match(START); 6614 setState(852); 6615 match(DT_HTML_TAG_NAME); 6616 setState(859); 6617 _errHandler.sync(this); 6618 _la = _input.LA(1); 6619 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6620 { 6621 setState(857); 6622 _errHandler.sync(this); 6623 switch (_input.LA(1)) { 6624 case HTML_TAG_NAME: 6625 { 6626 setState(853); 6627 attribute(); 6628 } 6629 break; 6630 case NEWLINE: 6631 { 6632 setState(854); 6633 match(NEWLINE); 6634 } 6635 break; 6636 case LEADING_ASTERISK: 6637 { 6638 setState(855); 6639 match(LEADING_ASTERISK); 6640 } 6641 break; 6642 case WS: 6643 { 6644 setState(856); 6645 match(WS); 6646 } 6647 break; 6648 default: 6649 throw new NoViableAltException(this); 6650 } 6651 } 6652 setState(861); 6653 _errHandler.sync(this); 6654 _la = _input.LA(1); 6655 } 6656 setState(862); 6657 match(END); 6658 } 6659 _ctx.stop = _input.LT(-1); 6660 6661 if (isNonTight && nonTightTagStartContext == null) { 6662 nonTightTagStartContext = _localctx; 6663 } 6664 6665 } 6666 catch (RecognitionException re) { 6667 _localctx.exception = re; 6668 _errHandler.reportError(this, re); 6669 _errHandler.recover(this, re); 6670 } 6671 finally { 6672 exitRule(); 6673 } 6674 return _localctx; 6675 } 6676 6677 public static class DtTagEndContext extends ParserRuleContext { 6678 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 6679 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 6680 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 6681 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 6682 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6683 public TerminalNode NEWLINE(int i) { 6684 return getToken(JavadocParser.NEWLINE, i); 6685 } 6686 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6687 public TerminalNode LEADING_ASTERISK(int i) { 6688 return getToken(JavadocParser.LEADING_ASTERISK, i); 6689 } 6690 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6691 public TerminalNode WS(int i) { 6692 return getToken(JavadocParser.WS, i); 6693 } 6694 public DtTagEndContext(ParserRuleContext parent, int invokingState) { 6695 super(parent, invokingState); 6696 } 6697 @Override public int getRuleIndex() { return RULE_dtTagEnd; } 6698 } 6699 6700 public final DtTagEndContext dtTagEnd() throws RecognitionException { 6701 DtTagEndContext _localctx = new DtTagEndContext(_ctx, getState()); 6702 enterRule(_localctx, 62, RULE_dtTagEnd); 6703 int _la; 6704 try { 6705 enterOuterAlt(_localctx, 1); 6706 { 6707 setState(864); 6708 match(START); 6709 setState(865); 6710 match(SLASH); 6711 setState(866); 6712 match(DT_HTML_TAG_NAME); 6713 setState(870); 6714 _errHandler.sync(this); 6715 _la = _input.LA(1); 6716 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 6717 { 6718 { 6719 setState(867); 6720 _la = _input.LA(1); 6721 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 6722 _errHandler.recoverInline(this); 6723 } 6724 else { 6725 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 6726 _errHandler.reportMatch(this); 6727 consume(); 6728 } 6729 } 6730 } 6731 setState(872); 6732 _errHandler.sync(this); 6733 _la = _input.LA(1); 6734 } 6735 setState(873); 6736 match(END); 6737 } 6738 } 6739 catch (RecognitionException re) { 6740 _localctx.exception = re; 6741 _errHandler.reportError(this, re); 6742 _errHandler.recover(this, re); 6743 } 6744 finally { 6745 exitRule(); 6746 } 6747 return _localctx; 6748 } 6749 6750 public static class DtContext extends ParserRuleContext { 6751 public DtTagStartContext dtTagStart() { 6752 return getRuleContext(DtTagStartContext.class,0); 6753 } 6754 public DtTagEndContext dtTagEnd() { 6755 return getRuleContext(DtTagEndContext.class,0); 6756 } 6757 public List<HtmlTagContext> htmlTag() { 6758 return getRuleContexts(HtmlTagContext.class); 6759 } 6760 public HtmlTagContext htmlTag(int i) { 6761 return getRuleContext(HtmlTagContext.class,i); 6762 } 6763 public List<SingletonElementContext> singletonElement() { 6764 return getRuleContexts(SingletonElementContext.class); 6765 } 6766 public SingletonElementContext singletonElement(int i) { 6767 return getRuleContext(SingletonElementContext.class,i); 6768 } 6769 public List<ParagraphContext> paragraph() { 6770 return getRuleContexts(ParagraphContext.class); 6771 } 6772 public ParagraphContext paragraph(int i) { 6773 return getRuleContext(ParagraphContext.class,i); 6774 } 6775 public List<LiContext> li() { 6776 return getRuleContexts(LiContext.class); 6777 } 6778 public LiContext li(int i) { 6779 return getRuleContext(LiContext.class,i); 6780 } 6781 public List<TrContext> tr() { 6782 return getRuleContexts(TrContext.class); 6783 } 6784 public TrContext tr(int i) { 6785 return getRuleContext(TrContext.class,i); 6786 } 6787 public List<TdContext> td() { 6788 return getRuleContexts(TdContext.class); 6789 } 6790 public TdContext td(int i) { 6791 return getRuleContext(TdContext.class,i); 6792 } 6793 public List<ThContext> th() { 6794 return getRuleContexts(ThContext.class); 6795 } 6796 public ThContext th(int i) { 6797 return getRuleContext(ThContext.class,i); 6798 } 6799 public List<BodyContext> body() { 6800 return getRuleContexts(BodyContext.class); 6801 } 6802 public BodyContext body(int i) { 6803 return getRuleContext(BodyContext.class,i); 6804 } 6805 public List<ColgroupContext> colgroup() { 6806 return getRuleContexts(ColgroupContext.class); 6807 } 6808 public ColgroupContext colgroup(int i) { 6809 return getRuleContext(ColgroupContext.class,i); 6810 } 6811 public List<DdContext> dd() { 6812 return getRuleContexts(DdContext.class); 6813 } 6814 public DdContext dd(int i) { 6815 return getRuleContext(DdContext.class,i); 6816 } 6817 public List<HeadContext> head() { 6818 return getRuleContexts(HeadContext.class); 6819 } 6820 public HeadContext head(int i) { 6821 return getRuleContext(HeadContext.class,i); 6822 } 6823 public List<HtmlContext> html() { 6824 return getRuleContexts(HtmlContext.class); 6825 } 6826 public HtmlContext html(int i) { 6827 return getRuleContext(HtmlContext.class,i); 6828 } 6829 public List<OptionContext> option() { 6830 return getRuleContexts(OptionContext.class); 6831 } 6832 public OptionContext option(int i) { 6833 return getRuleContext(OptionContext.class,i); 6834 } 6835 public List<TbodyContext> tbody() { 6836 return getRuleContexts(TbodyContext.class); 6837 } 6838 public TbodyContext tbody(int i) { 6839 return getRuleContext(TbodyContext.class,i); 6840 } 6841 public List<TheadContext> thead() { 6842 return getRuleContexts(TheadContext.class); 6843 } 6844 public TheadContext thead(int i) { 6845 return getRuleContext(TheadContext.class,i); 6846 } 6847 public List<TfootContext> tfoot() { 6848 return getRuleContexts(TfootContext.class); 6849 } 6850 public TfootContext tfoot(int i) { 6851 return getRuleContext(TfootContext.class,i); 6852 } 6853 public List<PTagStartContext> pTagStart() { 6854 return getRuleContexts(PTagStartContext.class); 6855 } 6856 public PTagStartContext pTagStart(int i) { 6857 return getRuleContext(PTagStartContext.class,i); 6858 } 6859 public List<LiTagStartContext> liTagStart() { 6860 return getRuleContexts(LiTagStartContext.class); 6861 } 6862 public LiTagStartContext liTagStart(int i) { 6863 return getRuleContext(LiTagStartContext.class,i); 6864 } 6865 public List<TrTagStartContext> trTagStart() { 6866 return getRuleContexts(TrTagStartContext.class); 6867 } 6868 public TrTagStartContext trTagStart(int i) { 6869 return getRuleContext(TrTagStartContext.class,i); 6870 } 6871 public List<TdTagStartContext> tdTagStart() { 6872 return getRuleContexts(TdTagStartContext.class); 6873 } 6874 public TdTagStartContext tdTagStart(int i) { 6875 return getRuleContext(TdTagStartContext.class,i); 6876 } 6877 public List<ThTagStartContext> thTagStart() { 6878 return getRuleContexts(ThTagStartContext.class); 6879 } 6880 public ThTagStartContext thTagStart(int i) { 6881 return getRuleContext(ThTagStartContext.class,i); 6882 } 6883 public List<BodyTagStartContext> bodyTagStart() { 6884 return getRuleContexts(BodyTagStartContext.class); 6885 } 6886 public BodyTagStartContext bodyTagStart(int i) { 6887 return getRuleContext(BodyTagStartContext.class,i); 6888 } 6889 public List<ColgroupTagStartContext> colgroupTagStart() { 6890 return getRuleContexts(ColgroupTagStartContext.class); 6891 } 6892 public ColgroupTagStartContext colgroupTagStart(int i) { 6893 return getRuleContext(ColgroupTagStartContext.class,i); 6894 } 6895 public List<DdTagStartContext> ddTagStart() { 6896 return getRuleContexts(DdTagStartContext.class); 6897 } 6898 public DdTagStartContext ddTagStart(int i) { 6899 return getRuleContext(DdTagStartContext.class,i); 6900 } 6901 public List<HeadTagStartContext> headTagStart() { 6902 return getRuleContexts(HeadTagStartContext.class); 6903 } 6904 public HeadTagStartContext headTagStart(int i) { 6905 return getRuleContext(HeadTagStartContext.class,i); 6906 } 6907 public List<HtmlTagStartContext> htmlTagStart() { 6908 return getRuleContexts(HtmlTagStartContext.class); 6909 } 6910 public HtmlTagStartContext htmlTagStart(int i) { 6911 return getRuleContext(HtmlTagStartContext.class,i); 6912 } 6913 public List<OptionTagStartContext> optionTagStart() { 6914 return getRuleContexts(OptionTagStartContext.class); 6915 } 6916 public OptionTagStartContext optionTagStart(int i) { 6917 return getRuleContext(OptionTagStartContext.class,i); 6918 } 6919 public List<TbodyTagStartContext> tbodyTagStart() { 6920 return getRuleContexts(TbodyTagStartContext.class); 6921 } 6922 public TbodyTagStartContext tbodyTagStart(int i) { 6923 return getRuleContext(TbodyTagStartContext.class,i); 6924 } 6925 public List<TheadTagStartContext> theadTagStart() { 6926 return getRuleContexts(TheadTagStartContext.class); 6927 } 6928 public TheadTagStartContext theadTagStart(int i) { 6929 return getRuleContext(TheadTagStartContext.class,i); 6930 } 6931 public List<TfootTagStartContext> tfootTagStart() { 6932 return getRuleContexts(TfootTagStartContext.class); 6933 } 6934 public TfootTagStartContext tfootTagStart(int i) { 6935 return getRuleContext(TfootTagStartContext.class,i); 6936 } 6937 public List<HtmlCommentContext> htmlComment() { 6938 return getRuleContexts(HtmlCommentContext.class); 6939 } 6940 public HtmlCommentContext htmlComment(int i) { 6941 return getRuleContext(HtmlCommentContext.class,i); 6942 } 6943 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 6944 public TerminalNode CDATA(int i) { 6945 return getToken(JavadocParser.CDATA, i); 6946 } 6947 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6948 public TerminalNode NEWLINE(int i) { 6949 return getToken(JavadocParser.NEWLINE, i); 6950 } 6951 public List<TextContext> text() { 6952 return getRuleContexts(TextContext.class); 6953 } 6954 public TextContext text(int i) { 6955 return getRuleContext(TextContext.class,i); 6956 } 6957 public List<JavadocInlineTagContext> javadocInlineTag() { 6958 return getRuleContexts(JavadocInlineTagContext.class); 6959 } 6960 public JavadocInlineTagContext javadocInlineTag(int i) { 6961 return getRuleContext(JavadocInlineTagContext.class,i); 6962 } 6963 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6964 public TerminalNode LEADING_ASTERISK(int i) { 6965 return getToken(JavadocParser.LEADING_ASTERISK, i); 6966 } 6967 public DtContext(ParserRuleContext parent, int invokingState) { 6968 super(parent, invokingState); 6969 } 6970 @Override public int getRuleIndex() { return RULE_dt; } 6971 } 6972 6973 public final DtContext dt() throws RecognitionException { 6974 DtContext _localctx = new DtContext(_ctx, getState()); 6975 enterRule(_localctx, 64, RULE_dt); 6976 try { 6977 int _alt; 6978 enterOuterAlt(_localctx, 1); 6979 { 6980 setState(875); 6981 dtTagStart(false); 6982 setState(915); 6983 _errHandler.sync(this); 6984 _alt = getInterpreter().adaptivePredict(_input,58,_ctx); 6985 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6986 if ( _alt==1 ) { 6987 { 6988 setState(913); 6989 _errHandler.sync(this); 6990 switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) { 6991 case 1: 6992 { 6993 setState(876); 6994 htmlTag(); 6995 } 6996 break; 6997 case 2: 6998 { 6999 setState(877); 7000 singletonElement(); 7001 } 7002 break; 7003 case 3: 7004 { 7005 setState(878); 7006 paragraph(); 7007 } 7008 break; 7009 case 4: 7010 { 7011 setState(879); 7012 li(); 7013 } 7014 break; 7015 case 5: 7016 { 7017 setState(880); 7018 tr(); 7019 } 7020 break; 7021 case 6: 7022 { 7023 setState(881); 7024 td(); 7025 } 7026 break; 7027 case 7: 7028 { 7029 setState(882); 7030 th(); 7031 } 7032 break; 7033 case 8: 7034 { 7035 setState(883); 7036 body(); 7037 } 7038 break; 7039 case 9: 7040 { 7041 setState(884); 7042 colgroup(); 7043 } 7044 break; 7045 case 10: 7046 { 7047 setState(885); 7048 dd(); 7049 } 7050 break; 7051 case 11: 7052 { 7053 setState(886); 7054 head(); 7055 } 7056 break; 7057 case 12: 7058 { 7059 setState(887); 7060 html(); 7061 } 7062 break; 7063 case 13: 7064 { 7065 setState(888); 7066 option(); 7067 } 7068 break; 7069 case 14: 7070 { 7071 setState(889); 7072 tbody(); 7073 } 7074 break; 7075 case 15: 7076 { 7077 setState(890); 7078 thead(); 7079 } 7080 break; 7081 case 16: 7082 { 7083 setState(891); 7084 tfoot(); 7085 } 7086 break; 7087 case 17: 7088 { 7089 setState(892); 7090 pTagStart(true); 7091 } 7092 break; 7093 case 18: 7094 { 7095 setState(893); 7096 liTagStart(true); 7097 } 7098 break; 7099 case 19: 7100 { 7101 setState(894); 7102 trTagStart(true); 7103 } 7104 break; 7105 case 20: 7106 { 7107 setState(895); 7108 tdTagStart(true); 7109 } 7110 break; 7111 case 21: 7112 { 7113 setState(896); 7114 thTagStart(true); 7115 } 7116 break; 7117 case 22: 7118 { 7119 setState(897); 7120 bodyTagStart(true); 7121 } 7122 break; 7123 case 23: 7124 { 7125 setState(898); 7126 colgroupTagStart(true); 7127 } 7128 break; 7129 case 24: 7130 { 7131 setState(899); 7132 ddTagStart(true); 7133 } 7134 break; 7135 case 25: 7136 { 7137 setState(900); 7138 headTagStart(true); 7139 } 7140 break; 7141 case 26: 7142 { 7143 setState(901); 7144 htmlTagStart(true); 7145 } 7146 break; 7147 case 27: 7148 { 7149 setState(902); 7150 optionTagStart(true); 7151 } 7152 break; 7153 case 28: 7154 { 7155 setState(903); 7156 tbodyTagStart(true); 7157 } 7158 break; 7159 case 29: 7160 { 7161 setState(904); 7162 theadTagStart(true); 7163 } 7164 break; 7165 case 30: 7166 { 7167 setState(905); 7168 tfootTagStart(true); 7169 } 7170 break; 7171 case 31: 7172 { 7173 { 7174 setState(906); 7175 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 7176 setState(907); 7177 match(LEADING_ASTERISK); 7178 } 7179 } 7180 break; 7181 case 32: 7182 { 7183 setState(908); 7184 htmlComment(); 7185 } 7186 break; 7187 case 33: 7188 { 7189 setState(909); 7190 match(CDATA); 7191 } 7192 break; 7193 case 34: 7194 { 7195 setState(910); 7196 match(NEWLINE); 7197 } 7198 break; 7199 case 35: 7200 { 7201 setState(911); 7202 text(); 7203 } 7204 break; 7205 case 36: 7206 { 7207 setState(912); 7208 javadocInlineTag(); 7209 } 7210 break; 7211 } 7212 } 7213 } 7214 setState(917); 7215 _errHandler.sync(this); 7216 _alt = getInterpreter().adaptivePredict(_input,58,_ctx); 7217 } 7218 setState(918); 7219 dtTagEnd(); 7220 } 7221 } 7222 catch (RecognitionException re) { 7223 _localctx.exception = re; 7224 _errHandler.reportError(this, re); 7225 _errHandler.recover(this, re); 7226 } 7227 finally { 7228 exitRule(); 7229 } 7230 return _localctx; 7231 } 7232 7233 public static class HeadTagStartContext extends ParserRuleContext { 7234 public boolean isNonTight; 7235 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 7236 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7237 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 7238 public List<AttributeContext> attribute() { 7239 return getRuleContexts(AttributeContext.class); 7240 } 7241 public AttributeContext attribute(int i) { 7242 return getRuleContext(AttributeContext.class,i); 7243 } 7244 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7245 public TerminalNode NEWLINE(int i) { 7246 return getToken(JavadocParser.NEWLINE, i); 7247 } 7248 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7249 public TerminalNode LEADING_ASTERISK(int i) { 7250 return getToken(JavadocParser.LEADING_ASTERISK, i); 7251 } 7252 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7253 public TerminalNode WS(int i) { 7254 return getToken(JavadocParser.WS, i); 7255 } 7256 public HeadTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 7257 public HeadTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 7258 super(parent, invokingState); 7259 this.isNonTight = isNonTight; 7260 } 7261 @Override public int getRuleIndex() { return RULE_headTagStart; } 7262 } 7263 7264 public final HeadTagStartContext headTagStart(boolean isNonTight) throws RecognitionException { 7265 HeadTagStartContext _localctx = new HeadTagStartContext(_ctx, getState(), isNonTight); 7266 enterRule(_localctx, 66, RULE_headTagStart); 7267 int _la; 7268 try { 7269 enterOuterAlt(_localctx, 1); 7270 { 7271 setState(920); 7272 match(START); 7273 setState(921); 7274 match(HEAD_HTML_TAG_NAME); 7275 setState(928); 7276 _errHandler.sync(this); 7277 _la = _input.LA(1); 7278 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 7279 { 7280 setState(926); 7281 _errHandler.sync(this); 7282 switch (_input.LA(1)) { 7283 case HTML_TAG_NAME: 7284 { 7285 setState(922); 7286 attribute(); 7287 } 7288 break; 7289 case NEWLINE: 7290 { 7291 setState(923); 7292 match(NEWLINE); 7293 } 7294 break; 7295 case LEADING_ASTERISK: 7296 { 7297 setState(924); 7298 match(LEADING_ASTERISK); 7299 } 7300 break; 7301 case WS: 7302 { 7303 setState(925); 7304 match(WS); 7305 } 7306 break; 7307 default: 7308 throw new NoViableAltException(this); 7309 } 7310 } 7311 setState(930); 7312 _errHandler.sync(this); 7313 _la = _input.LA(1); 7314 } 7315 setState(931); 7316 match(END); 7317 } 7318 _ctx.stop = _input.LT(-1); 7319 7320 if (isNonTight && nonTightTagStartContext == null) { 7321 nonTightTagStartContext = _localctx; 7322 } 7323 7324 } 7325 catch (RecognitionException re) { 7326 _localctx.exception = re; 7327 _errHandler.reportError(this, re); 7328 _errHandler.recover(this, re); 7329 } 7330 finally { 7331 exitRule(); 7332 } 7333 return _localctx; 7334 } 7335 7336 public static class HeadTagEndContext extends ParserRuleContext { 7337 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 7338 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7339 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7340 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 7341 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7342 public TerminalNode NEWLINE(int i) { 7343 return getToken(JavadocParser.NEWLINE, i); 7344 } 7345 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7346 public TerminalNode LEADING_ASTERISK(int i) { 7347 return getToken(JavadocParser.LEADING_ASTERISK, i); 7348 } 7349 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7350 public TerminalNode WS(int i) { 7351 return getToken(JavadocParser.WS, i); 7352 } 7353 public HeadTagEndContext(ParserRuleContext parent, int invokingState) { 7354 super(parent, invokingState); 7355 } 7356 @Override public int getRuleIndex() { return RULE_headTagEnd; } 7357 } 7358 7359 public final HeadTagEndContext headTagEnd() throws RecognitionException { 7360 HeadTagEndContext _localctx = new HeadTagEndContext(_ctx, getState()); 7361 enterRule(_localctx, 68, RULE_headTagEnd); 7362 int _la; 7363 try { 7364 enterOuterAlt(_localctx, 1); 7365 { 7366 setState(933); 7367 match(START); 7368 setState(934); 7369 match(SLASH); 7370 setState(935); 7371 match(HEAD_HTML_TAG_NAME); 7372 setState(939); 7373 _errHandler.sync(this); 7374 _la = _input.LA(1); 7375 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7376 { 7377 { 7378 setState(936); 7379 _la = _input.LA(1); 7380 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7381 _errHandler.recoverInline(this); 7382 } 7383 else { 7384 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 7385 _errHandler.reportMatch(this); 7386 consume(); 7387 } 7388 } 7389 } 7390 setState(941); 7391 _errHandler.sync(this); 7392 _la = _input.LA(1); 7393 } 7394 setState(942); 7395 match(END); 7396 } 7397 } 7398 catch (RecognitionException re) { 7399 _localctx.exception = re; 7400 _errHandler.reportError(this, re); 7401 _errHandler.recover(this, re); 7402 } 7403 finally { 7404 exitRule(); 7405 } 7406 return _localctx; 7407 } 7408 7409 public static class HeadContext extends ParserRuleContext { 7410 public HeadTagStartContext headTagStart() { 7411 return getRuleContext(HeadTagStartContext.class,0); 7412 } 7413 public HeadTagEndContext headTagEnd() { 7414 return getRuleContext(HeadTagEndContext.class,0); 7415 } 7416 public List<HtmlTagContext> htmlTag() { 7417 return getRuleContexts(HtmlTagContext.class); 7418 } 7419 public HtmlTagContext htmlTag(int i) { 7420 return getRuleContext(HtmlTagContext.class,i); 7421 } 7422 public List<SingletonElementContext> singletonElement() { 7423 return getRuleContexts(SingletonElementContext.class); 7424 } 7425 public SingletonElementContext singletonElement(int i) { 7426 return getRuleContext(SingletonElementContext.class,i); 7427 } 7428 public List<ParagraphContext> paragraph() { 7429 return getRuleContexts(ParagraphContext.class); 7430 } 7431 public ParagraphContext paragraph(int i) { 7432 return getRuleContext(ParagraphContext.class,i); 7433 } 7434 public List<LiContext> li() { 7435 return getRuleContexts(LiContext.class); 7436 } 7437 public LiContext li(int i) { 7438 return getRuleContext(LiContext.class,i); 7439 } 7440 public List<TrContext> tr() { 7441 return getRuleContexts(TrContext.class); 7442 } 7443 public TrContext tr(int i) { 7444 return getRuleContext(TrContext.class,i); 7445 } 7446 public List<TdContext> td() { 7447 return getRuleContexts(TdContext.class); 7448 } 7449 public TdContext td(int i) { 7450 return getRuleContext(TdContext.class,i); 7451 } 7452 public List<ThContext> th() { 7453 return getRuleContexts(ThContext.class); 7454 } 7455 public ThContext th(int i) { 7456 return getRuleContext(ThContext.class,i); 7457 } 7458 public List<BodyContext> body() { 7459 return getRuleContexts(BodyContext.class); 7460 } 7461 public BodyContext body(int i) { 7462 return getRuleContext(BodyContext.class,i); 7463 } 7464 public List<ColgroupContext> colgroup() { 7465 return getRuleContexts(ColgroupContext.class); 7466 } 7467 public ColgroupContext colgroup(int i) { 7468 return getRuleContext(ColgroupContext.class,i); 7469 } 7470 public List<DdContext> dd() { 7471 return getRuleContexts(DdContext.class); 7472 } 7473 public DdContext dd(int i) { 7474 return getRuleContext(DdContext.class,i); 7475 } 7476 public List<DtContext> dt() { 7477 return getRuleContexts(DtContext.class); 7478 } 7479 public DtContext dt(int i) { 7480 return getRuleContext(DtContext.class,i); 7481 } 7482 public List<HtmlContext> html() { 7483 return getRuleContexts(HtmlContext.class); 7484 } 7485 public HtmlContext html(int i) { 7486 return getRuleContext(HtmlContext.class,i); 7487 } 7488 public List<OptionContext> option() { 7489 return getRuleContexts(OptionContext.class); 7490 } 7491 public OptionContext option(int i) { 7492 return getRuleContext(OptionContext.class,i); 7493 } 7494 public List<TbodyContext> tbody() { 7495 return getRuleContexts(TbodyContext.class); 7496 } 7497 public TbodyContext tbody(int i) { 7498 return getRuleContext(TbodyContext.class,i); 7499 } 7500 public List<TheadContext> thead() { 7501 return getRuleContexts(TheadContext.class); 7502 } 7503 public TheadContext thead(int i) { 7504 return getRuleContext(TheadContext.class,i); 7505 } 7506 public List<TfootContext> tfoot() { 7507 return getRuleContexts(TfootContext.class); 7508 } 7509 public TfootContext tfoot(int i) { 7510 return getRuleContext(TfootContext.class,i); 7511 } 7512 public List<PTagStartContext> pTagStart() { 7513 return getRuleContexts(PTagStartContext.class); 7514 } 7515 public PTagStartContext pTagStart(int i) { 7516 return getRuleContext(PTagStartContext.class,i); 7517 } 7518 public List<LiTagStartContext> liTagStart() { 7519 return getRuleContexts(LiTagStartContext.class); 7520 } 7521 public LiTagStartContext liTagStart(int i) { 7522 return getRuleContext(LiTagStartContext.class,i); 7523 } 7524 public List<TrTagStartContext> trTagStart() { 7525 return getRuleContexts(TrTagStartContext.class); 7526 } 7527 public TrTagStartContext trTagStart(int i) { 7528 return getRuleContext(TrTagStartContext.class,i); 7529 } 7530 public List<TdTagStartContext> tdTagStart() { 7531 return getRuleContexts(TdTagStartContext.class); 7532 } 7533 public TdTagStartContext tdTagStart(int i) { 7534 return getRuleContext(TdTagStartContext.class,i); 7535 } 7536 public List<ThTagStartContext> thTagStart() { 7537 return getRuleContexts(ThTagStartContext.class); 7538 } 7539 public ThTagStartContext thTagStart(int i) { 7540 return getRuleContext(ThTagStartContext.class,i); 7541 } 7542 public List<BodyTagStartContext> bodyTagStart() { 7543 return getRuleContexts(BodyTagStartContext.class); 7544 } 7545 public BodyTagStartContext bodyTagStart(int i) { 7546 return getRuleContext(BodyTagStartContext.class,i); 7547 } 7548 public List<ColgroupTagStartContext> colgroupTagStart() { 7549 return getRuleContexts(ColgroupTagStartContext.class); 7550 } 7551 public ColgroupTagStartContext colgroupTagStart(int i) { 7552 return getRuleContext(ColgroupTagStartContext.class,i); 7553 } 7554 public List<DdTagStartContext> ddTagStart() { 7555 return getRuleContexts(DdTagStartContext.class); 7556 } 7557 public DdTagStartContext ddTagStart(int i) { 7558 return getRuleContext(DdTagStartContext.class,i); 7559 } 7560 public List<DtTagStartContext> dtTagStart() { 7561 return getRuleContexts(DtTagStartContext.class); 7562 } 7563 public DtTagStartContext dtTagStart(int i) { 7564 return getRuleContext(DtTagStartContext.class,i); 7565 } 7566 public List<HtmlTagStartContext> htmlTagStart() { 7567 return getRuleContexts(HtmlTagStartContext.class); 7568 } 7569 public HtmlTagStartContext htmlTagStart(int i) { 7570 return getRuleContext(HtmlTagStartContext.class,i); 7571 } 7572 public List<OptionTagStartContext> optionTagStart() { 7573 return getRuleContexts(OptionTagStartContext.class); 7574 } 7575 public OptionTagStartContext optionTagStart(int i) { 7576 return getRuleContext(OptionTagStartContext.class,i); 7577 } 7578 public List<TbodyTagStartContext> tbodyTagStart() { 7579 return getRuleContexts(TbodyTagStartContext.class); 7580 } 7581 public TbodyTagStartContext tbodyTagStart(int i) { 7582 return getRuleContext(TbodyTagStartContext.class,i); 7583 } 7584 public List<TheadTagStartContext> theadTagStart() { 7585 return getRuleContexts(TheadTagStartContext.class); 7586 } 7587 public TheadTagStartContext theadTagStart(int i) { 7588 return getRuleContext(TheadTagStartContext.class,i); 7589 } 7590 public List<TfootTagStartContext> tfootTagStart() { 7591 return getRuleContexts(TfootTagStartContext.class); 7592 } 7593 public TfootTagStartContext tfootTagStart(int i) { 7594 return getRuleContext(TfootTagStartContext.class,i); 7595 } 7596 public List<HtmlCommentContext> htmlComment() { 7597 return getRuleContexts(HtmlCommentContext.class); 7598 } 7599 public HtmlCommentContext htmlComment(int i) { 7600 return getRuleContext(HtmlCommentContext.class,i); 7601 } 7602 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 7603 public TerminalNode CDATA(int i) { 7604 return getToken(JavadocParser.CDATA, i); 7605 } 7606 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7607 public TerminalNode NEWLINE(int i) { 7608 return getToken(JavadocParser.NEWLINE, i); 7609 } 7610 public List<TextContext> text() { 7611 return getRuleContexts(TextContext.class); 7612 } 7613 public TextContext text(int i) { 7614 return getRuleContext(TextContext.class,i); 7615 } 7616 public List<JavadocInlineTagContext> javadocInlineTag() { 7617 return getRuleContexts(JavadocInlineTagContext.class); 7618 } 7619 public JavadocInlineTagContext javadocInlineTag(int i) { 7620 return getRuleContext(JavadocInlineTagContext.class,i); 7621 } 7622 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7623 public TerminalNode LEADING_ASTERISK(int i) { 7624 return getToken(JavadocParser.LEADING_ASTERISK, i); 7625 } 7626 public HeadContext(ParserRuleContext parent, int invokingState) { 7627 super(parent, invokingState); 7628 } 7629 @Override public int getRuleIndex() { return RULE_head; } 7630 } 7631 7632 public final HeadContext head() throws RecognitionException { 7633 HeadContext _localctx = new HeadContext(_ctx, getState()); 7634 enterRule(_localctx, 70, RULE_head); 7635 try { 7636 int _alt; 7637 enterOuterAlt(_localctx, 1); 7638 { 7639 setState(944); 7640 headTagStart(false); 7641 setState(984); 7642 _errHandler.sync(this); 7643 _alt = getInterpreter().adaptivePredict(_input,63,_ctx); 7644 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 7645 if ( _alt==1 ) { 7646 { 7647 setState(982); 7648 _errHandler.sync(this); 7649 switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) { 7650 case 1: 7651 { 7652 setState(945); 7653 htmlTag(); 7654 } 7655 break; 7656 case 2: 7657 { 7658 setState(946); 7659 singletonElement(); 7660 } 7661 break; 7662 case 3: 7663 { 7664 setState(947); 7665 paragraph(); 7666 } 7667 break; 7668 case 4: 7669 { 7670 setState(948); 7671 li(); 7672 } 7673 break; 7674 case 5: 7675 { 7676 setState(949); 7677 tr(); 7678 } 7679 break; 7680 case 6: 7681 { 7682 setState(950); 7683 td(); 7684 } 7685 break; 7686 case 7: 7687 { 7688 setState(951); 7689 th(); 7690 } 7691 break; 7692 case 8: 7693 { 7694 setState(952); 7695 body(); 7696 } 7697 break; 7698 case 9: 7699 { 7700 setState(953); 7701 colgroup(); 7702 } 7703 break; 7704 case 10: 7705 { 7706 setState(954); 7707 dd(); 7708 } 7709 break; 7710 case 11: 7711 { 7712 setState(955); 7713 dt(); 7714 } 7715 break; 7716 case 12: 7717 { 7718 setState(956); 7719 html(); 7720 } 7721 break; 7722 case 13: 7723 { 7724 setState(957); 7725 option(); 7726 } 7727 break; 7728 case 14: 7729 { 7730 setState(958); 7731 tbody(); 7732 } 7733 break; 7734 case 15: 7735 { 7736 setState(959); 7737 thead(); 7738 } 7739 break; 7740 case 16: 7741 { 7742 setState(960); 7743 tfoot(); 7744 } 7745 break; 7746 case 17: 7747 { 7748 setState(961); 7749 pTagStart(true); 7750 } 7751 break; 7752 case 18: 7753 { 7754 setState(962); 7755 liTagStart(true); 7756 } 7757 break; 7758 case 19: 7759 { 7760 setState(963); 7761 trTagStart(true); 7762 } 7763 break; 7764 case 20: 7765 { 7766 setState(964); 7767 tdTagStart(true); 7768 } 7769 break; 7770 case 21: 7771 { 7772 setState(965); 7773 thTagStart(true); 7774 } 7775 break; 7776 case 22: 7777 { 7778 setState(966); 7779 bodyTagStart(true); 7780 } 7781 break; 7782 case 23: 7783 { 7784 setState(967); 7785 colgroupTagStart(true); 7786 } 7787 break; 7788 case 24: 7789 { 7790 setState(968); 7791 ddTagStart(true); 7792 } 7793 break; 7794 case 25: 7795 { 7796 setState(969); 7797 dtTagStart(true); 7798 } 7799 break; 7800 case 26: 7801 { 7802 setState(970); 7803 htmlTagStart(true); 7804 } 7805 break; 7806 case 27: 7807 { 7808 setState(971); 7809 optionTagStart(true); 7810 } 7811 break; 7812 case 28: 7813 { 7814 setState(972); 7815 tbodyTagStart(true); 7816 } 7817 break; 7818 case 29: 7819 { 7820 setState(973); 7821 theadTagStart(true); 7822 } 7823 break; 7824 case 30: 7825 { 7826 setState(974); 7827 tfootTagStart(true); 7828 } 7829 break; 7830 case 31: 7831 { 7832 { 7833 setState(975); 7834 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 7835 setState(976); 7836 match(LEADING_ASTERISK); 7837 } 7838 } 7839 break; 7840 case 32: 7841 { 7842 setState(977); 7843 htmlComment(); 7844 } 7845 break; 7846 case 33: 7847 { 7848 setState(978); 7849 match(CDATA); 7850 } 7851 break; 7852 case 34: 7853 { 7854 setState(979); 7855 match(NEWLINE); 7856 } 7857 break; 7858 case 35: 7859 { 7860 setState(980); 7861 text(); 7862 } 7863 break; 7864 case 36: 7865 { 7866 setState(981); 7867 javadocInlineTag(); 7868 } 7869 break; 7870 } 7871 } 7872 } 7873 setState(986); 7874 _errHandler.sync(this); 7875 _alt = getInterpreter().adaptivePredict(_input,63,_ctx); 7876 } 7877 setState(987); 7878 headTagEnd(); 7879 } 7880 } 7881 catch (RecognitionException re) { 7882 _localctx.exception = re; 7883 _errHandler.reportError(this, re); 7884 _errHandler.recover(this, re); 7885 } 7886 finally { 7887 exitRule(); 7888 } 7889 return _localctx; 7890 } 7891 7892 public static class HtmlTagStartContext extends ParserRuleContext { 7893 public boolean isNonTight; 7894 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 7895 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 7896 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 7897 public List<AttributeContext> attribute() { 7898 return getRuleContexts(AttributeContext.class); 7899 } 7900 public AttributeContext attribute(int i) { 7901 return getRuleContext(AttributeContext.class,i); 7902 } 7903 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7904 public TerminalNode NEWLINE(int i) { 7905 return getToken(JavadocParser.NEWLINE, i); 7906 } 7907 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7908 public TerminalNode LEADING_ASTERISK(int i) { 7909 return getToken(JavadocParser.LEADING_ASTERISK, i); 7910 } 7911 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7912 public TerminalNode WS(int i) { 7913 return getToken(JavadocParser.WS, i); 7914 } 7915 public HtmlTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 7916 public HtmlTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 7917 super(parent, invokingState); 7918 this.isNonTight = isNonTight; 7919 } 7920 @Override public int getRuleIndex() { return RULE_htmlTagStart; } 7921 } 7922 7923 public final HtmlTagStartContext htmlTagStart(boolean isNonTight) throws RecognitionException { 7924 HtmlTagStartContext _localctx = new HtmlTagStartContext(_ctx, getState(), isNonTight); 7925 enterRule(_localctx, 72, RULE_htmlTagStart); 7926 int _la; 7927 try { 7928 enterOuterAlt(_localctx, 1); 7929 { 7930 setState(989); 7931 match(START); 7932 setState(990); 7933 match(HTML_HTML_TAG_NAME); 7934 setState(997); 7935 _errHandler.sync(this); 7936 _la = _input.LA(1); 7937 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 7938 { 7939 setState(995); 7940 _errHandler.sync(this); 7941 switch (_input.LA(1)) { 7942 case HTML_TAG_NAME: 7943 { 7944 setState(991); 7945 attribute(); 7946 } 7947 break; 7948 case NEWLINE: 7949 { 7950 setState(992); 7951 match(NEWLINE); 7952 } 7953 break; 7954 case LEADING_ASTERISK: 7955 { 7956 setState(993); 7957 match(LEADING_ASTERISK); 7958 } 7959 break; 7960 case WS: 7961 { 7962 setState(994); 7963 match(WS); 7964 } 7965 break; 7966 default: 7967 throw new NoViableAltException(this); 7968 } 7969 } 7970 setState(999); 7971 _errHandler.sync(this); 7972 _la = _input.LA(1); 7973 } 7974 setState(1000); 7975 match(END); 7976 } 7977 _ctx.stop = _input.LT(-1); 7978 7979 if (isNonTight && nonTightTagStartContext == null) { 7980 nonTightTagStartContext = _localctx; 7981 } 7982 7983 } 7984 catch (RecognitionException re) { 7985 _localctx.exception = re; 7986 _errHandler.reportError(this, re); 7987 _errHandler.recover(this, re); 7988 } 7989 finally { 7990 exitRule(); 7991 } 7992 return _localctx; 7993 } 7994 7995 public static class HtmlTagEndContext extends ParserRuleContext { 7996 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 7997 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7998 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 7999 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 8000 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8001 public TerminalNode NEWLINE(int i) { 8002 return getToken(JavadocParser.NEWLINE, i); 8003 } 8004 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8005 public TerminalNode LEADING_ASTERISK(int i) { 8006 return getToken(JavadocParser.LEADING_ASTERISK, i); 8007 } 8008 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8009 public TerminalNode WS(int i) { 8010 return getToken(JavadocParser.WS, i); 8011 } 8012 public HtmlTagEndContext(ParserRuleContext parent, int invokingState) { 8013 super(parent, invokingState); 8014 } 8015 @Override public int getRuleIndex() { return RULE_htmlTagEnd; } 8016 } 8017 8018 public final HtmlTagEndContext htmlTagEnd() throws RecognitionException { 8019 HtmlTagEndContext _localctx = new HtmlTagEndContext(_ctx, getState()); 8020 enterRule(_localctx, 74, RULE_htmlTagEnd); 8021 int _la; 8022 try { 8023 enterOuterAlt(_localctx, 1); 8024 { 8025 setState(1002); 8026 match(START); 8027 setState(1003); 8028 match(SLASH); 8029 setState(1004); 8030 match(HTML_HTML_TAG_NAME); 8031 setState(1008); 8032 _errHandler.sync(this); 8033 _la = _input.LA(1); 8034 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 8035 { 8036 { 8037 setState(1005); 8038 _la = _input.LA(1); 8039 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 8040 _errHandler.recoverInline(this); 8041 } 8042 else { 8043 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 8044 _errHandler.reportMatch(this); 8045 consume(); 8046 } 8047 } 8048 } 8049 setState(1010); 8050 _errHandler.sync(this); 8051 _la = _input.LA(1); 8052 } 8053 setState(1011); 8054 match(END); 8055 } 8056 } 8057 catch (RecognitionException re) { 8058 _localctx.exception = re; 8059 _errHandler.reportError(this, re); 8060 _errHandler.recover(this, re); 8061 } 8062 finally { 8063 exitRule(); 8064 } 8065 return _localctx; 8066 } 8067 8068 public static class HtmlContext extends ParserRuleContext { 8069 public HtmlTagStartContext htmlTagStart() { 8070 return getRuleContext(HtmlTagStartContext.class,0); 8071 } 8072 public HtmlTagEndContext htmlTagEnd() { 8073 return getRuleContext(HtmlTagEndContext.class,0); 8074 } 8075 public List<HtmlTagContext> htmlTag() { 8076 return getRuleContexts(HtmlTagContext.class); 8077 } 8078 public HtmlTagContext htmlTag(int i) { 8079 return getRuleContext(HtmlTagContext.class,i); 8080 } 8081 public List<SingletonElementContext> singletonElement() { 8082 return getRuleContexts(SingletonElementContext.class); 8083 } 8084 public SingletonElementContext singletonElement(int i) { 8085 return getRuleContext(SingletonElementContext.class,i); 8086 } 8087 public List<ParagraphContext> paragraph() { 8088 return getRuleContexts(ParagraphContext.class); 8089 } 8090 public ParagraphContext paragraph(int i) { 8091 return getRuleContext(ParagraphContext.class,i); 8092 } 8093 public List<LiContext> li() { 8094 return getRuleContexts(LiContext.class); 8095 } 8096 public LiContext li(int i) { 8097 return getRuleContext(LiContext.class,i); 8098 } 8099 public List<TrContext> tr() { 8100 return getRuleContexts(TrContext.class); 8101 } 8102 public TrContext tr(int i) { 8103 return getRuleContext(TrContext.class,i); 8104 } 8105 public List<TdContext> td() { 8106 return getRuleContexts(TdContext.class); 8107 } 8108 public TdContext td(int i) { 8109 return getRuleContext(TdContext.class,i); 8110 } 8111 public List<ThContext> th() { 8112 return getRuleContexts(ThContext.class); 8113 } 8114 public ThContext th(int i) { 8115 return getRuleContext(ThContext.class,i); 8116 } 8117 public List<BodyContext> body() { 8118 return getRuleContexts(BodyContext.class); 8119 } 8120 public BodyContext body(int i) { 8121 return getRuleContext(BodyContext.class,i); 8122 } 8123 public List<ColgroupContext> colgroup() { 8124 return getRuleContexts(ColgroupContext.class); 8125 } 8126 public ColgroupContext colgroup(int i) { 8127 return getRuleContext(ColgroupContext.class,i); 8128 } 8129 public List<DdContext> dd() { 8130 return getRuleContexts(DdContext.class); 8131 } 8132 public DdContext dd(int i) { 8133 return getRuleContext(DdContext.class,i); 8134 } 8135 public List<DtContext> dt() { 8136 return getRuleContexts(DtContext.class); 8137 } 8138 public DtContext dt(int i) { 8139 return getRuleContext(DtContext.class,i); 8140 } 8141 public List<HeadContext> head() { 8142 return getRuleContexts(HeadContext.class); 8143 } 8144 public HeadContext head(int i) { 8145 return getRuleContext(HeadContext.class,i); 8146 } 8147 public List<OptionContext> option() { 8148 return getRuleContexts(OptionContext.class); 8149 } 8150 public OptionContext option(int i) { 8151 return getRuleContext(OptionContext.class,i); 8152 } 8153 public List<TbodyContext> tbody() { 8154 return getRuleContexts(TbodyContext.class); 8155 } 8156 public TbodyContext tbody(int i) { 8157 return getRuleContext(TbodyContext.class,i); 8158 } 8159 public List<TheadContext> thead() { 8160 return getRuleContexts(TheadContext.class); 8161 } 8162 public TheadContext thead(int i) { 8163 return getRuleContext(TheadContext.class,i); 8164 } 8165 public List<TfootContext> tfoot() { 8166 return getRuleContexts(TfootContext.class); 8167 } 8168 public TfootContext tfoot(int i) { 8169 return getRuleContext(TfootContext.class,i); 8170 } 8171 public List<PTagStartContext> pTagStart() { 8172 return getRuleContexts(PTagStartContext.class); 8173 } 8174 public PTagStartContext pTagStart(int i) { 8175 return getRuleContext(PTagStartContext.class,i); 8176 } 8177 public List<LiTagStartContext> liTagStart() { 8178 return getRuleContexts(LiTagStartContext.class); 8179 } 8180 public LiTagStartContext liTagStart(int i) { 8181 return getRuleContext(LiTagStartContext.class,i); 8182 } 8183 public List<TrTagStartContext> trTagStart() { 8184 return getRuleContexts(TrTagStartContext.class); 8185 } 8186 public TrTagStartContext trTagStart(int i) { 8187 return getRuleContext(TrTagStartContext.class,i); 8188 } 8189 public List<TdTagStartContext> tdTagStart() { 8190 return getRuleContexts(TdTagStartContext.class); 8191 } 8192 public TdTagStartContext tdTagStart(int i) { 8193 return getRuleContext(TdTagStartContext.class,i); 8194 } 8195 public List<ThTagStartContext> thTagStart() { 8196 return getRuleContexts(ThTagStartContext.class); 8197 } 8198 public ThTagStartContext thTagStart(int i) { 8199 return getRuleContext(ThTagStartContext.class,i); 8200 } 8201 public List<BodyTagStartContext> bodyTagStart() { 8202 return getRuleContexts(BodyTagStartContext.class); 8203 } 8204 public BodyTagStartContext bodyTagStart(int i) { 8205 return getRuleContext(BodyTagStartContext.class,i); 8206 } 8207 public List<ColgroupTagStartContext> colgroupTagStart() { 8208 return getRuleContexts(ColgroupTagStartContext.class); 8209 } 8210 public ColgroupTagStartContext colgroupTagStart(int i) { 8211 return getRuleContext(ColgroupTagStartContext.class,i); 8212 } 8213 public List<DdTagStartContext> ddTagStart() { 8214 return getRuleContexts(DdTagStartContext.class); 8215 } 8216 public DdTagStartContext ddTagStart(int i) { 8217 return getRuleContext(DdTagStartContext.class,i); 8218 } 8219 public List<DtTagStartContext> dtTagStart() { 8220 return getRuleContexts(DtTagStartContext.class); 8221 } 8222 public DtTagStartContext dtTagStart(int i) { 8223 return getRuleContext(DtTagStartContext.class,i); 8224 } 8225 public List<HeadTagStartContext> headTagStart() { 8226 return getRuleContexts(HeadTagStartContext.class); 8227 } 8228 public HeadTagStartContext headTagStart(int i) { 8229 return getRuleContext(HeadTagStartContext.class,i); 8230 } 8231 public List<OptionTagStartContext> optionTagStart() { 8232 return getRuleContexts(OptionTagStartContext.class); 8233 } 8234 public OptionTagStartContext optionTagStart(int i) { 8235 return getRuleContext(OptionTagStartContext.class,i); 8236 } 8237 public List<TbodyTagStartContext> tbodyTagStart() { 8238 return getRuleContexts(TbodyTagStartContext.class); 8239 } 8240 public TbodyTagStartContext tbodyTagStart(int i) { 8241 return getRuleContext(TbodyTagStartContext.class,i); 8242 } 8243 public List<TheadTagStartContext> theadTagStart() { 8244 return getRuleContexts(TheadTagStartContext.class); 8245 } 8246 public TheadTagStartContext theadTagStart(int i) { 8247 return getRuleContext(TheadTagStartContext.class,i); 8248 } 8249 public List<TfootTagStartContext> tfootTagStart() { 8250 return getRuleContexts(TfootTagStartContext.class); 8251 } 8252 public TfootTagStartContext tfootTagStart(int i) { 8253 return getRuleContext(TfootTagStartContext.class,i); 8254 } 8255 public List<HtmlCommentContext> htmlComment() { 8256 return getRuleContexts(HtmlCommentContext.class); 8257 } 8258 public HtmlCommentContext htmlComment(int i) { 8259 return getRuleContext(HtmlCommentContext.class,i); 8260 } 8261 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 8262 public TerminalNode CDATA(int i) { 8263 return getToken(JavadocParser.CDATA, i); 8264 } 8265 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8266 public TerminalNode NEWLINE(int i) { 8267 return getToken(JavadocParser.NEWLINE, i); 8268 } 8269 public List<TextContext> text() { 8270 return getRuleContexts(TextContext.class); 8271 } 8272 public TextContext text(int i) { 8273 return getRuleContext(TextContext.class,i); 8274 } 8275 public List<JavadocInlineTagContext> javadocInlineTag() { 8276 return getRuleContexts(JavadocInlineTagContext.class); 8277 } 8278 public JavadocInlineTagContext javadocInlineTag(int i) { 8279 return getRuleContext(JavadocInlineTagContext.class,i); 8280 } 8281 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8282 public TerminalNode LEADING_ASTERISK(int i) { 8283 return getToken(JavadocParser.LEADING_ASTERISK, i); 8284 } 8285 public HtmlContext(ParserRuleContext parent, int invokingState) { 8286 super(parent, invokingState); 8287 } 8288 @Override public int getRuleIndex() { return RULE_html; } 8289 } 8290 8291 public final HtmlContext html() throws RecognitionException { 8292 HtmlContext _localctx = new HtmlContext(_ctx, getState()); 8293 enterRule(_localctx, 76, RULE_html); 8294 try { 8295 int _alt; 8296 enterOuterAlt(_localctx, 1); 8297 { 8298 setState(1013); 8299 htmlTagStart(false); 8300 setState(1053); 8301 _errHandler.sync(this); 8302 _alt = getInterpreter().adaptivePredict(_input,68,_ctx); 8303 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8304 if ( _alt==1 ) { 8305 { 8306 setState(1051); 8307 _errHandler.sync(this); 8308 switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) { 8309 case 1: 8310 { 8311 setState(1014); 8312 htmlTag(); 8313 } 8314 break; 8315 case 2: 8316 { 8317 setState(1015); 8318 singletonElement(); 8319 } 8320 break; 8321 case 3: 8322 { 8323 setState(1016); 8324 paragraph(); 8325 } 8326 break; 8327 case 4: 8328 { 8329 setState(1017); 8330 li(); 8331 } 8332 break; 8333 case 5: 8334 { 8335 setState(1018); 8336 tr(); 8337 } 8338 break; 8339 case 6: 8340 { 8341 setState(1019); 8342 td(); 8343 } 8344 break; 8345 case 7: 8346 { 8347 setState(1020); 8348 th(); 8349 } 8350 break; 8351 case 8: 8352 { 8353 setState(1021); 8354 body(); 8355 } 8356 break; 8357 case 9: 8358 { 8359 setState(1022); 8360 colgroup(); 8361 } 8362 break; 8363 case 10: 8364 { 8365 setState(1023); 8366 dd(); 8367 } 8368 break; 8369 case 11: 8370 { 8371 setState(1024); 8372 dt(); 8373 } 8374 break; 8375 case 12: 8376 { 8377 setState(1025); 8378 head(); 8379 } 8380 break; 8381 case 13: 8382 { 8383 setState(1026); 8384 option(); 8385 } 8386 break; 8387 case 14: 8388 { 8389 setState(1027); 8390 tbody(); 8391 } 8392 break; 8393 case 15: 8394 { 8395 setState(1028); 8396 thead(); 8397 } 8398 break; 8399 case 16: 8400 { 8401 setState(1029); 8402 tfoot(); 8403 } 8404 break; 8405 case 17: 8406 { 8407 setState(1030); 8408 pTagStart(true); 8409 } 8410 break; 8411 case 18: 8412 { 8413 setState(1031); 8414 liTagStart(true); 8415 } 8416 break; 8417 case 19: 8418 { 8419 setState(1032); 8420 trTagStart(true); 8421 } 8422 break; 8423 case 20: 8424 { 8425 setState(1033); 8426 tdTagStart(true); 8427 } 8428 break; 8429 case 21: 8430 { 8431 setState(1034); 8432 thTagStart(true); 8433 } 8434 break; 8435 case 22: 8436 { 8437 setState(1035); 8438 bodyTagStart(true); 8439 } 8440 break; 8441 case 23: 8442 { 8443 setState(1036); 8444 colgroupTagStart(true); 8445 } 8446 break; 8447 case 24: 8448 { 8449 setState(1037); 8450 ddTagStart(true); 8451 } 8452 break; 8453 case 25: 8454 { 8455 setState(1038); 8456 dtTagStart(true); 8457 } 8458 break; 8459 case 26: 8460 { 8461 setState(1039); 8462 headTagStart(true); 8463 } 8464 break; 8465 case 27: 8466 { 8467 setState(1040); 8468 optionTagStart(true); 8469 } 8470 break; 8471 case 28: 8472 { 8473 setState(1041); 8474 tbodyTagStart(true); 8475 } 8476 break; 8477 case 29: 8478 { 8479 setState(1042); 8480 theadTagStart(true); 8481 } 8482 break; 8483 case 30: 8484 { 8485 setState(1043); 8486 tfootTagStart(true); 8487 } 8488 break; 8489 case 31: 8490 { 8491 { 8492 setState(1044); 8493 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8494 setState(1045); 8495 match(LEADING_ASTERISK); 8496 } 8497 } 8498 break; 8499 case 32: 8500 { 8501 setState(1046); 8502 htmlComment(); 8503 } 8504 break; 8505 case 33: 8506 { 8507 setState(1047); 8508 match(CDATA); 8509 } 8510 break; 8511 case 34: 8512 { 8513 setState(1048); 8514 match(NEWLINE); 8515 } 8516 break; 8517 case 35: 8518 { 8519 setState(1049); 8520 text(); 8521 } 8522 break; 8523 case 36: 8524 { 8525 setState(1050); 8526 javadocInlineTag(); 8527 } 8528 break; 8529 } 8530 } 8531 } 8532 setState(1055); 8533 _errHandler.sync(this); 8534 _alt = getInterpreter().adaptivePredict(_input,68,_ctx); 8535 } 8536 setState(1056); 8537 htmlTagEnd(); 8538 } 8539 } 8540 catch (RecognitionException re) { 8541 _localctx.exception = re; 8542 _errHandler.reportError(this, re); 8543 _errHandler.recover(this, re); 8544 } 8545 finally { 8546 exitRule(); 8547 } 8548 return _localctx; 8549 } 8550 8551 public static class OptionTagStartContext extends ParserRuleContext { 8552 public boolean isNonTight; 8553 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 8554 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 8555 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 8556 public List<AttributeContext> attribute() { 8557 return getRuleContexts(AttributeContext.class); 8558 } 8559 public AttributeContext attribute(int i) { 8560 return getRuleContext(AttributeContext.class,i); 8561 } 8562 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8563 public TerminalNode NEWLINE(int i) { 8564 return getToken(JavadocParser.NEWLINE, i); 8565 } 8566 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8567 public TerminalNode LEADING_ASTERISK(int i) { 8568 return getToken(JavadocParser.LEADING_ASTERISK, i); 8569 } 8570 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8571 public TerminalNode WS(int i) { 8572 return getToken(JavadocParser.WS, i); 8573 } 8574 public OptionTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 8575 public OptionTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 8576 super(parent, invokingState); 8577 this.isNonTight = isNonTight; 8578 } 8579 @Override public int getRuleIndex() { return RULE_optionTagStart; } 8580 } 8581 8582 public final OptionTagStartContext optionTagStart(boolean isNonTight) throws RecognitionException { 8583 OptionTagStartContext _localctx = new OptionTagStartContext(_ctx, getState(), isNonTight); 8584 enterRule(_localctx, 78, RULE_optionTagStart); 8585 int _la; 8586 try { 8587 enterOuterAlt(_localctx, 1); 8588 { 8589 setState(1058); 8590 match(START); 8591 setState(1059); 8592 match(OPTION_HTML_TAG_NAME); 8593 setState(1066); 8594 _errHandler.sync(this); 8595 _la = _input.LA(1); 8596 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 8597 { 8598 setState(1064); 8599 _errHandler.sync(this); 8600 switch (_input.LA(1)) { 8601 case HTML_TAG_NAME: 8602 { 8603 setState(1060); 8604 attribute(); 8605 } 8606 break; 8607 case NEWLINE: 8608 { 8609 setState(1061); 8610 match(NEWLINE); 8611 } 8612 break; 8613 case LEADING_ASTERISK: 8614 { 8615 setState(1062); 8616 match(LEADING_ASTERISK); 8617 } 8618 break; 8619 case WS: 8620 { 8621 setState(1063); 8622 match(WS); 8623 } 8624 break; 8625 default: 8626 throw new NoViableAltException(this); 8627 } 8628 } 8629 setState(1068); 8630 _errHandler.sync(this); 8631 _la = _input.LA(1); 8632 } 8633 setState(1069); 8634 match(END); 8635 } 8636 _ctx.stop = _input.LT(-1); 8637 8638 if (isNonTight && nonTightTagStartContext == null) { 8639 nonTightTagStartContext = _localctx; 8640 } 8641 8642 } 8643 catch (RecognitionException re) { 8644 _localctx.exception = re; 8645 _errHandler.reportError(this, re); 8646 _errHandler.recover(this, re); 8647 } 8648 finally { 8649 exitRule(); 8650 } 8651 return _localctx; 8652 } 8653 8654 public static class OptionTagEndContext extends ParserRuleContext { 8655 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 8656 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 8657 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 8658 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 8659 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8660 public TerminalNode NEWLINE(int i) { 8661 return getToken(JavadocParser.NEWLINE, i); 8662 } 8663 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8664 public TerminalNode LEADING_ASTERISK(int i) { 8665 return getToken(JavadocParser.LEADING_ASTERISK, i); 8666 } 8667 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8668 public TerminalNode WS(int i) { 8669 return getToken(JavadocParser.WS, i); 8670 } 8671 public OptionTagEndContext(ParserRuleContext parent, int invokingState) { 8672 super(parent, invokingState); 8673 } 8674 @Override public int getRuleIndex() { return RULE_optionTagEnd; } 8675 } 8676 8677 public final OptionTagEndContext optionTagEnd() throws RecognitionException { 8678 OptionTagEndContext _localctx = new OptionTagEndContext(_ctx, getState()); 8679 enterRule(_localctx, 80, RULE_optionTagEnd); 8680 int _la; 8681 try { 8682 enterOuterAlt(_localctx, 1); 8683 { 8684 setState(1071); 8685 match(START); 8686 setState(1072); 8687 match(SLASH); 8688 setState(1073); 8689 match(OPTION_HTML_TAG_NAME); 8690 setState(1077); 8691 _errHandler.sync(this); 8692 _la = _input.LA(1); 8693 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 8694 { 8695 { 8696 setState(1074); 8697 _la = _input.LA(1); 8698 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 8699 _errHandler.recoverInline(this); 8700 } 8701 else { 8702 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 8703 _errHandler.reportMatch(this); 8704 consume(); 8705 } 8706 } 8707 } 8708 setState(1079); 8709 _errHandler.sync(this); 8710 _la = _input.LA(1); 8711 } 8712 setState(1080); 8713 match(END); 8714 } 8715 } 8716 catch (RecognitionException re) { 8717 _localctx.exception = re; 8718 _errHandler.reportError(this, re); 8719 _errHandler.recover(this, re); 8720 } 8721 finally { 8722 exitRule(); 8723 } 8724 return _localctx; 8725 } 8726 8727 public static class OptionContext extends ParserRuleContext { 8728 public OptionTagStartContext optionTagStart() { 8729 return getRuleContext(OptionTagStartContext.class,0); 8730 } 8731 public OptionTagEndContext optionTagEnd() { 8732 return getRuleContext(OptionTagEndContext.class,0); 8733 } 8734 public List<HtmlTagContext> htmlTag() { 8735 return getRuleContexts(HtmlTagContext.class); 8736 } 8737 public HtmlTagContext htmlTag(int i) { 8738 return getRuleContext(HtmlTagContext.class,i); 8739 } 8740 public List<SingletonElementContext> singletonElement() { 8741 return getRuleContexts(SingletonElementContext.class); 8742 } 8743 public SingletonElementContext singletonElement(int i) { 8744 return getRuleContext(SingletonElementContext.class,i); 8745 } 8746 public List<ParagraphContext> paragraph() { 8747 return getRuleContexts(ParagraphContext.class); 8748 } 8749 public ParagraphContext paragraph(int i) { 8750 return getRuleContext(ParagraphContext.class,i); 8751 } 8752 public List<LiContext> li() { 8753 return getRuleContexts(LiContext.class); 8754 } 8755 public LiContext li(int i) { 8756 return getRuleContext(LiContext.class,i); 8757 } 8758 public List<TrContext> tr() { 8759 return getRuleContexts(TrContext.class); 8760 } 8761 public TrContext tr(int i) { 8762 return getRuleContext(TrContext.class,i); 8763 } 8764 public List<TdContext> td() { 8765 return getRuleContexts(TdContext.class); 8766 } 8767 public TdContext td(int i) { 8768 return getRuleContext(TdContext.class,i); 8769 } 8770 public List<ThContext> th() { 8771 return getRuleContexts(ThContext.class); 8772 } 8773 public ThContext th(int i) { 8774 return getRuleContext(ThContext.class,i); 8775 } 8776 public List<BodyContext> body() { 8777 return getRuleContexts(BodyContext.class); 8778 } 8779 public BodyContext body(int i) { 8780 return getRuleContext(BodyContext.class,i); 8781 } 8782 public List<ColgroupContext> colgroup() { 8783 return getRuleContexts(ColgroupContext.class); 8784 } 8785 public ColgroupContext colgroup(int i) { 8786 return getRuleContext(ColgroupContext.class,i); 8787 } 8788 public List<DdContext> dd() { 8789 return getRuleContexts(DdContext.class); 8790 } 8791 public DdContext dd(int i) { 8792 return getRuleContext(DdContext.class,i); 8793 } 8794 public List<DtContext> dt() { 8795 return getRuleContexts(DtContext.class); 8796 } 8797 public DtContext dt(int i) { 8798 return getRuleContext(DtContext.class,i); 8799 } 8800 public List<HeadContext> head() { 8801 return getRuleContexts(HeadContext.class); 8802 } 8803 public HeadContext head(int i) { 8804 return getRuleContext(HeadContext.class,i); 8805 } 8806 public List<HtmlContext> html() { 8807 return getRuleContexts(HtmlContext.class); 8808 } 8809 public HtmlContext html(int i) { 8810 return getRuleContext(HtmlContext.class,i); 8811 } 8812 public List<TbodyContext> tbody() { 8813 return getRuleContexts(TbodyContext.class); 8814 } 8815 public TbodyContext tbody(int i) { 8816 return getRuleContext(TbodyContext.class,i); 8817 } 8818 public List<TheadContext> thead() { 8819 return getRuleContexts(TheadContext.class); 8820 } 8821 public TheadContext thead(int i) { 8822 return getRuleContext(TheadContext.class,i); 8823 } 8824 public List<TfootContext> tfoot() { 8825 return getRuleContexts(TfootContext.class); 8826 } 8827 public TfootContext tfoot(int i) { 8828 return getRuleContext(TfootContext.class,i); 8829 } 8830 public List<PTagStartContext> pTagStart() { 8831 return getRuleContexts(PTagStartContext.class); 8832 } 8833 public PTagStartContext pTagStart(int i) { 8834 return getRuleContext(PTagStartContext.class,i); 8835 } 8836 public List<LiTagStartContext> liTagStart() { 8837 return getRuleContexts(LiTagStartContext.class); 8838 } 8839 public LiTagStartContext liTagStart(int i) { 8840 return getRuleContext(LiTagStartContext.class,i); 8841 } 8842 public List<TrTagStartContext> trTagStart() { 8843 return getRuleContexts(TrTagStartContext.class); 8844 } 8845 public TrTagStartContext trTagStart(int i) { 8846 return getRuleContext(TrTagStartContext.class,i); 8847 } 8848 public List<TdTagStartContext> tdTagStart() { 8849 return getRuleContexts(TdTagStartContext.class); 8850 } 8851 public TdTagStartContext tdTagStart(int i) { 8852 return getRuleContext(TdTagStartContext.class,i); 8853 } 8854 public List<ThTagStartContext> thTagStart() { 8855 return getRuleContexts(ThTagStartContext.class); 8856 } 8857 public ThTagStartContext thTagStart(int i) { 8858 return getRuleContext(ThTagStartContext.class,i); 8859 } 8860 public List<BodyTagStartContext> bodyTagStart() { 8861 return getRuleContexts(BodyTagStartContext.class); 8862 } 8863 public BodyTagStartContext bodyTagStart(int i) { 8864 return getRuleContext(BodyTagStartContext.class,i); 8865 } 8866 public List<ColgroupTagStartContext> colgroupTagStart() { 8867 return getRuleContexts(ColgroupTagStartContext.class); 8868 } 8869 public ColgroupTagStartContext colgroupTagStart(int i) { 8870 return getRuleContext(ColgroupTagStartContext.class,i); 8871 } 8872 public List<DdTagStartContext> ddTagStart() { 8873 return getRuleContexts(DdTagStartContext.class); 8874 } 8875 public DdTagStartContext ddTagStart(int i) { 8876 return getRuleContext(DdTagStartContext.class,i); 8877 } 8878 public List<DtTagStartContext> dtTagStart() { 8879 return getRuleContexts(DtTagStartContext.class); 8880 } 8881 public DtTagStartContext dtTagStart(int i) { 8882 return getRuleContext(DtTagStartContext.class,i); 8883 } 8884 public List<HeadTagStartContext> headTagStart() { 8885 return getRuleContexts(HeadTagStartContext.class); 8886 } 8887 public HeadTagStartContext headTagStart(int i) { 8888 return getRuleContext(HeadTagStartContext.class,i); 8889 } 8890 public List<HtmlTagStartContext> htmlTagStart() { 8891 return getRuleContexts(HtmlTagStartContext.class); 8892 } 8893 public HtmlTagStartContext htmlTagStart(int i) { 8894 return getRuleContext(HtmlTagStartContext.class,i); 8895 } 8896 public List<TbodyTagStartContext> tbodyTagStart() { 8897 return getRuleContexts(TbodyTagStartContext.class); 8898 } 8899 public TbodyTagStartContext tbodyTagStart(int i) { 8900 return getRuleContext(TbodyTagStartContext.class,i); 8901 } 8902 public List<TheadTagStartContext> theadTagStart() { 8903 return getRuleContexts(TheadTagStartContext.class); 8904 } 8905 public TheadTagStartContext theadTagStart(int i) { 8906 return getRuleContext(TheadTagStartContext.class,i); 8907 } 8908 public List<TfootTagStartContext> tfootTagStart() { 8909 return getRuleContexts(TfootTagStartContext.class); 8910 } 8911 public TfootTagStartContext tfootTagStart(int i) { 8912 return getRuleContext(TfootTagStartContext.class,i); 8913 } 8914 public List<HtmlCommentContext> htmlComment() { 8915 return getRuleContexts(HtmlCommentContext.class); 8916 } 8917 public HtmlCommentContext htmlComment(int i) { 8918 return getRuleContext(HtmlCommentContext.class,i); 8919 } 8920 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 8921 public TerminalNode CDATA(int i) { 8922 return getToken(JavadocParser.CDATA, i); 8923 } 8924 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8925 public TerminalNode NEWLINE(int i) { 8926 return getToken(JavadocParser.NEWLINE, i); 8927 } 8928 public List<TextContext> text() { 8929 return getRuleContexts(TextContext.class); 8930 } 8931 public TextContext text(int i) { 8932 return getRuleContext(TextContext.class,i); 8933 } 8934 public List<JavadocInlineTagContext> javadocInlineTag() { 8935 return getRuleContexts(JavadocInlineTagContext.class); 8936 } 8937 public JavadocInlineTagContext javadocInlineTag(int i) { 8938 return getRuleContext(JavadocInlineTagContext.class,i); 8939 } 8940 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8941 public TerminalNode LEADING_ASTERISK(int i) { 8942 return getToken(JavadocParser.LEADING_ASTERISK, i); 8943 } 8944 public OptionContext(ParserRuleContext parent, int invokingState) { 8945 super(parent, invokingState); 8946 } 8947 @Override public int getRuleIndex() { return RULE_option; } 8948 } 8949 8950 public final OptionContext option() throws RecognitionException { 8951 OptionContext _localctx = new OptionContext(_ctx, getState()); 8952 enterRule(_localctx, 82, RULE_option); 8953 try { 8954 int _alt; 8955 enterOuterAlt(_localctx, 1); 8956 { 8957 setState(1082); 8958 optionTagStart(false); 8959 setState(1122); 8960 _errHandler.sync(this); 8961 _alt = getInterpreter().adaptivePredict(_input,73,_ctx); 8962 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8963 if ( _alt==1 ) { 8964 { 8965 setState(1120); 8966 _errHandler.sync(this); 8967 switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) { 8968 case 1: 8969 { 8970 setState(1083); 8971 htmlTag(); 8972 } 8973 break; 8974 case 2: 8975 { 8976 setState(1084); 8977 singletonElement(); 8978 } 8979 break; 8980 case 3: 8981 { 8982 setState(1085); 8983 paragraph(); 8984 } 8985 break; 8986 case 4: 8987 { 8988 setState(1086); 8989 li(); 8990 } 8991 break; 8992 case 5: 8993 { 8994 setState(1087); 8995 tr(); 8996 } 8997 break; 8998 case 6: 8999 { 9000 setState(1088); 9001 td(); 9002 } 9003 break; 9004 case 7: 9005 { 9006 setState(1089); 9007 th(); 9008 } 9009 break; 9010 case 8: 9011 { 9012 setState(1090); 9013 body(); 9014 } 9015 break; 9016 case 9: 9017 { 9018 setState(1091); 9019 colgroup(); 9020 } 9021 break; 9022 case 10: 9023 { 9024 setState(1092); 9025 dd(); 9026 } 9027 break; 9028 case 11: 9029 { 9030 setState(1093); 9031 dt(); 9032 } 9033 break; 9034 case 12: 9035 { 9036 setState(1094); 9037 head(); 9038 } 9039 break; 9040 case 13: 9041 { 9042 setState(1095); 9043 html(); 9044 } 9045 break; 9046 case 14: 9047 { 9048 setState(1096); 9049 tbody(); 9050 } 9051 break; 9052 case 15: 9053 { 9054 setState(1097); 9055 thead(); 9056 } 9057 break; 9058 case 16: 9059 { 9060 setState(1098); 9061 tfoot(); 9062 } 9063 break; 9064 case 17: 9065 { 9066 setState(1099); 9067 pTagStart(true); 9068 } 9069 break; 9070 case 18: 9071 { 9072 setState(1100); 9073 liTagStart(true); 9074 } 9075 break; 9076 case 19: 9077 { 9078 setState(1101); 9079 trTagStart(true); 9080 } 9081 break; 9082 case 20: 9083 { 9084 setState(1102); 9085 tdTagStart(true); 9086 } 9087 break; 9088 case 21: 9089 { 9090 setState(1103); 9091 thTagStart(true); 9092 } 9093 break; 9094 case 22: 9095 { 9096 setState(1104); 9097 bodyTagStart(true); 9098 } 9099 break; 9100 case 23: 9101 { 9102 setState(1105); 9103 colgroupTagStart(true); 9104 } 9105 break; 9106 case 24: 9107 { 9108 setState(1106); 9109 ddTagStart(true); 9110 } 9111 break; 9112 case 25: 9113 { 9114 setState(1107); 9115 dtTagStart(true); 9116 } 9117 break; 9118 case 26: 9119 { 9120 setState(1108); 9121 headTagStart(true); 9122 } 9123 break; 9124 case 27: 9125 { 9126 setState(1109); 9127 htmlTagStart(true); 9128 } 9129 break; 9130 case 28: 9131 { 9132 setState(1110); 9133 tbodyTagStart(true); 9134 } 9135 break; 9136 case 29: 9137 { 9138 setState(1111); 9139 theadTagStart(true); 9140 } 9141 break; 9142 case 30: 9143 { 9144 setState(1112); 9145 tfootTagStart(true); 9146 } 9147 break; 9148 case 31: 9149 { 9150 { 9151 setState(1113); 9152 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 9153 setState(1114); 9154 match(LEADING_ASTERISK); 9155 } 9156 } 9157 break; 9158 case 32: 9159 { 9160 setState(1115); 9161 htmlComment(); 9162 } 9163 break; 9164 case 33: 9165 { 9166 setState(1116); 9167 match(CDATA); 9168 } 9169 break; 9170 case 34: 9171 { 9172 setState(1117); 9173 match(NEWLINE); 9174 } 9175 break; 9176 case 35: 9177 { 9178 setState(1118); 9179 text(); 9180 } 9181 break; 9182 case 36: 9183 { 9184 setState(1119); 9185 javadocInlineTag(); 9186 } 9187 break; 9188 } 9189 } 9190 } 9191 setState(1124); 9192 _errHandler.sync(this); 9193 _alt = getInterpreter().adaptivePredict(_input,73,_ctx); 9194 } 9195 setState(1125); 9196 optionTagEnd(); 9197 } 9198 } 9199 catch (RecognitionException re) { 9200 _localctx.exception = re; 9201 _errHandler.reportError(this, re); 9202 _errHandler.recover(this, re); 9203 } 9204 finally { 9205 exitRule(); 9206 } 9207 return _localctx; 9208 } 9209 9210 public static class TbodyTagStartContext extends ParserRuleContext { 9211 public boolean isNonTight; 9212 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 9213 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9214 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 9215 public List<AttributeContext> attribute() { 9216 return getRuleContexts(AttributeContext.class); 9217 } 9218 public AttributeContext attribute(int i) { 9219 return getRuleContext(AttributeContext.class,i); 9220 } 9221 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9222 public TerminalNode NEWLINE(int i) { 9223 return getToken(JavadocParser.NEWLINE, i); 9224 } 9225 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9226 public TerminalNode LEADING_ASTERISK(int i) { 9227 return getToken(JavadocParser.LEADING_ASTERISK, i); 9228 } 9229 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9230 public TerminalNode WS(int i) { 9231 return getToken(JavadocParser.WS, i); 9232 } 9233 public TbodyTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 9234 public TbodyTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 9235 super(parent, invokingState); 9236 this.isNonTight = isNonTight; 9237 } 9238 @Override public int getRuleIndex() { return RULE_tbodyTagStart; } 9239 } 9240 9241 public final TbodyTagStartContext tbodyTagStart(boolean isNonTight) throws RecognitionException { 9242 TbodyTagStartContext _localctx = new TbodyTagStartContext(_ctx, getState(), isNonTight); 9243 enterRule(_localctx, 84, RULE_tbodyTagStart); 9244 int _la; 9245 try { 9246 enterOuterAlt(_localctx, 1); 9247 { 9248 setState(1127); 9249 match(START); 9250 setState(1128); 9251 match(TBODY_HTML_TAG_NAME); 9252 setState(1135); 9253 _errHandler.sync(this); 9254 _la = _input.LA(1); 9255 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9256 { 9257 setState(1133); 9258 _errHandler.sync(this); 9259 switch (_input.LA(1)) { 9260 case HTML_TAG_NAME: 9261 { 9262 setState(1129); 9263 attribute(); 9264 } 9265 break; 9266 case NEWLINE: 9267 { 9268 setState(1130); 9269 match(NEWLINE); 9270 } 9271 break; 9272 case LEADING_ASTERISK: 9273 { 9274 setState(1131); 9275 match(LEADING_ASTERISK); 9276 } 9277 break; 9278 case WS: 9279 { 9280 setState(1132); 9281 match(WS); 9282 } 9283 break; 9284 default: 9285 throw new NoViableAltException(this); 9286 } 9287 } 9288 setState(1137); 9289 _errHandler.sync(this); 9290 _la = _input.LA(1); 9291 } 9292 setState(1138); 9293 match(END); 9294 } 9295 _ctx.stop = _input.LT(-1); 9296 9297 if (isNonTight && nonTightTagStartContext == null) { 9298 nonTightTagStartContext = _localctx; 9299 } 9300 9301 } 9302 catch (RecognitionException re) { 9303 _localctx.exception = re; 9304 _errHandler.reportError(this, re); 9305 _errHandler.recover(this, re); 9306 } 9307 finally { 9308 exitRule(); 9309 } 9310 return _localctx; 9311 } 9312 9313 public static class TbodyTagEndContext extends ParserRuleContext { 9314 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 9315 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9316 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9317 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 9318 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9319 public TerminalNode NEWLINE(int i) { 9320 return getToken(JavadocParser.NEWLINE, i); 9321 } 9322 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9323 public TerminalNode LEADING_ASTERISK(int i) { 9324 return getToken(JavadocParser.LEADING_ASTERISK, i); 9325 } 9326 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9327 public TerminalNode WS(int i) { 9328 return getToken(JavadocParser.WS, i); 9329 } 9330 public TbodyTagEndContext(ParserRuleContext parent, int invokingState) { 9331 super(parent, invokingState); 9332 } 9333 @Override public int getRuleIndex() { return RULE_tbodyTagEnd; } 9334 } 9335 9336 public final TbodyTagEndContext tbodyTagEnd() throws RecognitionException { 9337 TbodyTagEndContext _localctx = new TbodyTagEndContext(_ctx, getState()); 9338 enterRule(_localctx, 86, RULE_tbodyTagEnd); 9339 int _la; 9340 try { 9341 enterOuterAlt(_localctx, 1); 9342 { 9343 setState(1140); 9344 match(START); 9345 setState(1141); 9346 match(SLASH); 9347 setState(1142); 9348 match(TBODY_HTML_TAG_NAME); 9349 setState(1146); 9350 _errHandler.sync(this); 9351 _la = _input.LA(1); 9352 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9353 { 9354 { 9355 setState(1143); 9356 _la = _input.LA(1); 9357 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9358 _errHandler.recoverInline(this); 9359 } 9360 else { 9361 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 9362 _errHandler.reportMatch(this); 9363 consume(); 9364 } 9365 } 9366 } 9367 setState(1148); 9368 _errHandler.sync(this); 9369 _la = _input.LA(1); 9370 } 9371 setState(1149); 9372 match(END); 9373 } 9374 } 9375 catch (RecognitionException re) { 9376 _localctx.exception = re; 9377 _errHandler.reportError(this, re); 9378 _errHandler.recover(this, re); 9379 } 9380 finally { 9381 exitRule(); 9382 } 9383 return _localctx; 9384 } 9385 9386 public static class TbodyContext extends ParserRuleContext { 9387 public TbodyTagStartContext tbodyTagStart() { 9388 return getRuleContext(TbodyTagStartContext.class,0); 9389 } 9390 public TbodyTagEndContext tbodyTagEnd() { 9391 return getRuleContext(TbodyTagEndContext.class,0); 9392 } 9393 public List<HtmlTagContext> htmlTag() { 9394 return getRuleContexts(HtmlTagContext.class); 9395 } 9396 public HtmlTagContext htmlTag(int i) { 9397 return getRuleContext(HtmlTagContext.class,i); 9398 } 9399 public List<SingletonElementContext> singletonElement() { 9400 return getRuleContexts(SingletonElementContext.class); 9401 } 9402 public SingletonElementContext singletonElement(int i) { 9403 return getRuleContext(SingletonElementContext.class,i); 9404 } 9405 public List<ParagraphContext> paragraph() { 9406 return getRuleContexts(ParagraphContext.class); 9407 } 9408 public ParagraphContext paragraph(int i) { 9409 return getRuleContext(ParagraphContext.class,i); 9410 } 9411 public List<LiContext> li() { 9412 return getRuleContexts(LiContext.class); 9413 } 9414 public LiContext li(int i) { 9415 return getRuleContext(LiContext.class,i); 9416 } 9417 public List<TrContext> tr() { 9418 return getRuleContexts(TrContext.class); 9419 } 9420 public TrContext tr(int i) { 9421 return getRuleContext(TrContext.class,i); 9422 } 9423 public List<TdContext> td() { 9424 return getRuleContexts(TdContext.class); 9425 } 9426 public TdContext td(int i) { 9427 return getRuleContext(TdContext.class,i); 9428 } 9429 public List<ThContext> th() { 9430 return getRuleContexts(ThContext.class); 9431 } 9432 public ThContext th(int i) { 9433 return getRuleContext(ThContext.class,i); 9434 } 9435 public List<BodyContext> body() { 9436 return getRuleContexts(BodyContext.class); 9437 } 9438 public BodyContext body(int i) { 9439 return getRuleContext(BodyContext.class,i); 9440 } 9441 public List<ColgroupContext> colgroup() { 9442 return getRuleContexts(ColgroupContext.class); 9443 } 9444 public ColgroupContext colgroup(int i) { 9445 return getRuleContext(ColgroupContext.class,i); 9446 } 9447 public List<DdContext> dd() { 9448 return getRuleContexts(DdContext.class); 9449 } 9450 public DdContext dd(int i) { 9451 return getRuleContext(DdContext.class,i); 9452 } 9453 public List<DtContext> dt() { 9454 return getRuleContexts(DtContext.class); 9455 } 9456 public DtContext dt(int i) { 9457 return getRuleContext(DtContext.class,i); 9458 } 9459 public List<HeadContext> head() { 9460 return getRuleContexts(HeadContext.class); 9461 } 9462 public HeadContext head(int i) { 9463 return getRuleContext(HeadContext.class,i); 9464 } 9465 public List<HtmlContext> html() { 9466 return getRuleContexts(HtmlContext.class); 9467 } 9468 public HtmlContext html(int i) { 9469 return getRuleContext(HtmlContext.class,i); 9470 } 9471 public List<OptionContext> option() { 9472 return getRuleContexts(OptionContext.class); 9473 } 9474 public OptionContext option(int i) { 9475 return getRuleContext(OptionContext.class,i); 9476 } 9477 public List<TheadContext> thead() { 9478 return getRuleContexts(TheadContext.class); 9479 } 9480 public TheadContext thead(int i) { 9481 return getRuleContext(TheadContext.class,i); 9482 } 9483 public List<TfootContext> tfoot() { 9484 return getRuleContexts(TfootContext.class); 9485 } 9486 public TfootContext tfoot(int i) { 9487 return getRuleContext(TfootContext.class,i); 9488 } 9489 public List<PTagStartContext> pTagStart() { 9490 return getRuleContexts(PTagStartContext.class); 9491 } 9492 public PTagStartContext pTagStart(int i) { 9493 return getRuleContext(PTagStartContext.class,i); 9494 } 9495 public List<LiTagStartContext> liTagStart() { 9496 return getRuleContexts(LiTagStartContext.class); 9497 } 9498 public LiTagStartContext liTagStart(int i) { 9499 return getRuleContext(LiTagStartContext.class,i); 9500 } 9501 public List<TrTagStartContext> trTagStart() { 9502 return getRuleContexts(TrTagStartContext.class); 9503 } 9504 public TrTagStartContext trTagStart(int i) { 9505 return getRuleContext(TrTagStartContext.class,i); 9506 } 9507 public List<TdTagStartContext> tdTagStart() { 9508 return getRuleContexts(TdTagStartContext.class); 9509 } 9510 public TdTagStartContext tdTagStart(int i) { 9511 return getRuleContext(TdTagStartContext.class,i); 9512 } 9513 public List<ThTagStartContext> thTagStart() { 9514 return getRuleContexts(ThTagStartContext.class); 9515 } 9516 public ThTagStartContext thTagStart(int i) { 9517 return getRuleContext(ThTagStartContext.class,i); 9518 } 9519 public List<BodyTagStartContext> bodyTagStart() { 9520 return getRuleContexts(BodyTagStartContext.class); 9521 } 9522 public BodyTagStartContext bodyTagStart(int i) { 9523 return getRuleContext(BodyTagStartContext.class,i); 9524 } 9525 public List<ColgroupTagStartContext> colgroupTagStart() { 9526 return getRuleContexts(ColgroupTagStartContext.class); 9527 } 9528 public ColgroupTagStartContext colgroupTagStart(int i) { 9529 return getRuleContext(ColgroupTagStartContext.class,i); 9530 } 9531 public List<DdTagStartContext> ddTagStart() { 9532 return getRuleContexts(DdTagStartContext.class); 9533 } 9534 public DdTagStartContext ddTagStart(int i) { 9535 return getRuleContext(DdTagStartContext.class,i); 9536 } 9537 public List<DtTagStartContext> dtTagStart() { 9538 return getRuleContexts(DtTagStartContext.class); 9539 } 9540 public DtTagStartContext dtTagStart(int i) { 9541 return getRuleContext(DtTagStartContext.class,i); 9542 } 9543 public List<HeadTagStartContext> headTagStart() { 9544 return getRuleContexts(HeadTagStartContext.class); 9545 } 9546 public HeadTagStartContext headTagStart(int i) { 9547 return getRuleContext(HeadTagStartContext.class,i); 9548 } 9549 public List<HtmlTagStartContext> htmlTagStart() { 9550 return getRuleContexts(HtmlTagStartContext.class); 9551 } 9552 public HtmlTagStartContext htmlTagStart(int i) { 9553 return getRuleContext(HtmlTagStartContext.class,i); 9554 } 9555 public List<OptionTagStartContext> optionTagStart() { 9556 return getRuleContexts(OptionTagStartContext.class); 9557 } 9558 public OptionTagStartContext optionTagStart(int i) { 9559 return getRuleContext(OptionTagStartContext.class,i); 9560 } 9561 public List<TheadTagStartContext> theadTagStart() { 9562 return getRuleContexts(TheadTagStartContext.class); 9563 } 9564 public TheadTagStartContext theadTagStart(int i) { 9565 return getRuleContext(TheadTagStartContext.class,i); 9566 } 9567 public List<TfootTagStartContext> tfootTagStart() { 9568 return getRuleContexts(TfootTagStartContext.class); 9569 } 9570 public TfootTagStartContext tfootTagStart(int i) { 9571 return getRuleContext(TfootTagStartContext.class,i); 9572 } 9573 public List<HtmlCommentContext> htmlComment() { 9574 return getRuleContexts(HtmlCommentContext.class); 9575 } 9576 public HtmlCommentContext htmlComment(int i) { 9577 return getRuleContext(HtmlCommentContext.class,i); 9578 } 9579 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 9580 public TerminalNode CDATA(int i) { 9581 return getToken(JavadocParser.CDATA, i); 9582 } 9583 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9584 public TerminalNode NEWLINE(int i) { 9585 return getToken(JavadocParser.NEWLINE, i); 9586 } 9587 public List<TextContext> text() { 9588 return getRuleContexts(TextContext.class); 9589 } 9590 public TextContext text(int i) { 9591 return getRuleContext(TextContext.class,i); 9592 } 9593 public List<JavadocInlineTagContext> javadocInlineTag() { 9594 return getRuleContexts(JavadocInlineTagContext.class); 9595 } 9596 public JavadocInlineTagContext javadocInlineTag(int i) { 9597 return getRuleContext(JavadocInlineTagContext.class,i); 9598 } 9599 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9600 public TerminalNode LEADING_ASTERISK(int i) { 9601 return getToken(JavadocParser.LEADING_ASTERISK, i); 9602 } 9603 public TbodyContext(ParserRuleContext parent, int invokingState) { 9604 super(parent, invokingState); 9605 } 9606 @Override public int getRuleIndex() { return RULE_tbody; } 9607 } 9608 9609 public final TbodyContext tbody() throws RecognitionException { 9610 TbodyContext _localctx = new TbodyContext(_ctx, getState()); 9611 enterRule(_localctx, 88, RULE_tbody); 9612 try { 9613 int _alt; 9614 enterOuterAlt(_localctx, 1); 9615 { 9616 setState(1151); 9617 tbodyTagStart(false); 9618 setState(1191); 9619 _errHandler.sync(this); 9620 _alt = getInterpreter().adaptivePredict(_input,78,_ctx); 9621 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 9622 if ( _alt==1 ) { 9623 { 9624 setState(1189); 9625 _errHandler.sync(this); 9626 switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) { 9627 case 1: 9628 { 9629 setState(1152); 9630 htmlTag(); 9631 } 9632 break; 9633 case 2: 9634 { 9635 setState(1153); 9636 singletonElement(); 9637 } 9638 break; 9639 case 3: 9640 { 9641 setState(1154); 9642 paragraph(); 9643 } 9644 break; 9645 case 4: 9646 { 9647 setState(1155); 9648 li(); 9649 } 9650 break; 9651 case 5: 9652 { 9653 setState(1156); 9654 tr(); 9655 } 9656 break; 9657 case 6: 9658 { 9659 setState(1157); 9660 td(); 9661 } 9662 break; 9663 case 7: 9664 { 9665 setState(1158); 9666 th(); 9667 } 9668 break; 9669 case 8: 9670 { 9671 setState(1159); 9672 body(); 9673 } 9674 break; 9675 case 9: 9676 { 9677 setState(1160); 9678 colgroup(); 9679 } 9680 break; 9681 case 10: 9682 { 9683 setState(1161); 9684 dd(); 9685 } 9686 break; 9687 case 11: 9688 { 9689 setState(1162); 9690 dt(); 9691 } 9692 break; 9693 case 12: 9694 { 9695 setState(1163); 9696 head(); 9697 } 9698 break; 9699 case 13: 9700 { 9701 setState(1164); 9702 html(); 9703 } 9704 break; 9705 case 14: 9706 { 9707 setState(1165); 9708 option(); 9709 } 9710 break; 9711 case 15: 9712 { 9713 setState(1166); 9714 thead(); 9715 } 9716 break; 9717 case 16: 9718 { 9719 setState(1167); 9720 tfoot(); 9721 } 9722 break; 9723 case 17: 9724 { 9725 setState(1168); 9726 pTagStart(true); 9727 } 9728 break; 9729 case 18: 9730 { 9731 setState(1169); 9732 liTagStart(true); 9733 } 9734 break; 9735 case 19: 9736 { 9737 setState(1170); 9738 trTagStart(true); 9739 } 9740 break; 9741 case 20: 9742 { 9743 setState(1171); 9744 tdTagStart(true); 9745 } 9746 break; 9747 case 21: 9748 { 9749 setState(1172); 9750 thTagStart(true); 9751 } 9752 break; 9753 case 22: 9754 { 9755 setState(1173); 9756 bodyTagStart(true); 9757 } 9758 break; 9759 case 23: 9760 { 9761 setState(1174); 9762 colgroupTagStart(true); 9763 } 9764 break; 9765 case 24: 9766 { 9767 setState(1175); 9768 ddTagStart(true); 9769 } 9770 break; 9771 case 25: 9772 { 9773 setState(1176); 9774 dtTagStart(true); 9775 } 9776 break; 9777 case 26: 9778 { 9779 setState(1177); 9780 headTagStart(true); 9781 } 9782 break; 9783 case 27: 9784 { 9785 setState(1178); 9786 htmlTagStart(true); 9787 } 9788 break; 9789 case 28: 9790 { 9791 setState(1179); 9792 optionTagStart(true); 9793 } 9794 break; 9795 case 29: 9796 { 9797 setState(1180); 9798 theadTagStart(true); 9799 } 9800 break; 9801 case 30: 9802 { 9803 setState(1181); 9804 tfootTagStart(true); 9805 } 9806 break; 9807 case 31: 9808 { 9809 { 9810 setState(1182); 9811 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 9812 setState(1183); 9813 match(LEADING_ASTERISK); 9814 } 9815 } 9816 break; 9817 case 32: 9818 { 9819 setState(1184); 9820 htmlComment(); 9821 } 9822 break; 9823 case 33: 9824 { 9825 setState(1185); 9826 match(CDATA); 9827 } 9828 break; 9829 case 34: 9830 { 9831 setState(1186); 9832 match(NEWLINE); 9833 } 9834 break; 9835 case 35: 9836 { 9837 setState(1187); 9838 text(); 9839 } 9840 break; 9841 case 36: 9842 { 9843 setState(1188); 9844 javadocInlineTag(); 9845 } 9846 break; 9847 } 9848 } 9849 } 9850 setState(1193); 9851 _errHandler.sync(this); 9852 _alt = getInterpreter().adaptivePredict(_input,78,_ctx); 9853 } 9854 setState(1194); 9855 tbodyTagEnd(); 9856 } 9857 } 9858 catch (RecognitionException re) { 9859 _localctx.exception = re; 9860 _errHandler.reportError(this, re); 9861 _errHandler.recover(this, re); 9862 } 9863 finally { 9864 exitRule(); 9865 } 9866 return _localctx; 9867 } 9868 9869 public static class TfootTagStartContext extends ParserRuleContext { 9870 public boolean isNonTight; 9871 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 9872 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 9873 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 9874 public List<AttributeContext> attribute() { 9875 return getRuleContexts(AttributeContext.class); 9876 } 9877 public AttributeContext attribute(int i) { 9878 return getRuleContext(AttributeContext.class,i); 9879 } 9880 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9881 public TerminalNode NEWLINE(int i) { 9882 return getToken(JavadocParser.NEWLINE, i); 9883 } 9884 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9885 public TerminalNode LEADING_ASTERISK(int i) { 9886 return getToken(JavadocParser.LEADING_ASTERISK, i); 9887 } 9888 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9889 public TerminalNode WS(int i) { 9890 return getToken(JavadocParser.WS, i); 9891 } 9892 public TfootTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 9893 public TfootTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 9894 super(parent, invokingState); 9895 this.isNonTight = isNonTight; 9896 } 9897 @Override public int getRuleIndex() { return RULE_tfootTagStart; } 9898 } 9899 9900 public final TfootTagStartContext tfootTagStart(boolean isNonTight) throws RecognitionException { 9901 TfootTagStartContext _localctx = new TfootTagStartContext(_ctx, getState(), isNonTight); 9902 enterRule(_localctx, 90, RULE_tfootTagStart); 9903 int _la; 9904 try { 9905 enterOuterAlt(_localctx, 1); 9906 { 9907 setState(1196); 9908 match(START); 9909 setState(1197); 9910 match(TFOOT_HTML_TAG_NAME); 9911 setState(1204); 9912 _errHandler.sync(this); 9913 _la = _input.LA(1); 9914 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9915 { 9916 setState(1202); 9917 _errHandler.sync(this); 9918 switch (_input.LA(1)) { 9919 case HTML_TAG_NAME: 9920 { 9921 setState(1198); 9922 attribute(); 9923 } 9924 break; 9925 case NEWLINE: 9926 { 9927 setState(1199); 9928 match(NEWLINE); 9929 } 9930 break; 9931 case LEADING_ASTERISK: 9932 { 9933 setState(1200); 9934 match(LEADING_ASTERISK); 9935 } 9936 break; 9937 case WS: 9938 { 9939 setState(1201); 9940 match(WS); 9941 } 9942 break; 9943 default: 9944 throw new NoViableAltException(this); 9945 } 9946 } 9947 setState(1206); 9948 _errHandler.sync(this); 9949 _la = _input.LA(1); 9950 } 9951 setState(1207); 9952 match(END); 9953 } 9954 _ctx.stop = _input.LT(-1); 9955 9956 if (isNonTight && nonTightTagStartContext == null) { 9957 nonTightTagStartContext = _localctx; 9958 } 9959 9960 } 9961 catch (RecognitionException re) { 9962 _localctx.exception = re; 9963 _errHandler.reportError(this, re); 9964 _errHandler.recover(this, re); 9965 } 9966 finally { 9967 exitRule(); 9968 } 9969 return _localctx; 9970 } 9971 9972 public static class TfootTagEndContext extends ParserRuleContext { 9973 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 9974 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9975 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 9976 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 9977 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9978 public TerminalNode NEWLINE(int i) { 9979 return getToken(JavadocParser.NEWLINE, i); 9980 } 9981 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9982 public TerminalNode LEADING_ASTERISK(int i) { 9983 return getToken(JavadocParser.LEADING_ASTERISK, i); 9984 } 9985 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9986 public TerminalNode WS(int i) { 9987 return getToken(JavadocParser.WS, i); 9988 } 9989 public TfootTagEndContext(ParserRuleContext parent, int invokingState) { 9990 super(parent, invokingState); 9991 } 9992 @Override public int getRuleIndex() { return RULE_tfootTagEnd; } 9993 } 9994 9995 public final TfootTagEndContext tfootTagEnd() throws RecognitionException { 9996 TfootTagEndContext _localctx = new TfootTagEndContext(_ctx, getState()); 9997 enterRule(_localctx, 92, RULE_tfootTagEnd); 9998 int _la; 9999 try { 10000 enterOuterAlt(_localctx, 1); 10001 { 10002 setState(1209); 10003 match(START); 10004 setState(1210); 10005 match(SLASH); 10006 setState(1211); 10007 match(TFOOT_HTML_TAG_NAME); 10008 setState(1215); 10009 _errHandler.sync(this); 10010 _la = _input.LA(1); 10011 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 10012 { 10013 { 10014 setState(1212); 10015 _la = _input.LA(1); 10016 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 10017 _errHandler.recoverInline(this); 10018 } 10019 else { 10020 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 10021 _errHandler.reportMatch(this); 10022 consume(); 10023 } 10024 } 10025 } 10026 setState(1217); 10027 _errHandler.sync(this); 10028 _la = _input.LA(1); 10029 } 10030 setState(1218); 10031 match(END); 10032 } 10033 } 10034 catch (RecognitionException re) { 10035 _localctx.exception = re; 10036 _errHandler.reportError(this, re); 10037 _errHandler.recover(this, re); 10038 } 10039 finally { 10040 exitRule(); 10041 } 10042 return _localctx; 10043 } 10044 10045 public static class TfootContext extends ParserRuleContext { 10046 public TfootTagStartContext tfootTagStart() { 10047 return getRuleContext(TfootTagStartContext.class,0); 10048 } 10049 public TfootTagEndContext tfootTagEnd() { 10050 return getRuleContext(TfootTagEndContext.class,0); 10051 } 10052 public List<HtmlTagContext> htmlTag() { 10053 return getRuleContexts(HtmlTagContext.class); 10054 } 10055 public HtmlTagContext htmlTag(int i) { 10056 return getRuleContext(HtmlTagContext.class,i); 10057 } 10058 public List<SingletonElementContext> singletonElement() { 10059 return getRuleContexts(SingletonElementContext.class); 10060 } 10061 public SingletonElementContext singletonElement(int i) { 10062 return getRuleContext(SingletonElementContext.class,i); 10063 } 10064 public List<ParagraphContext> paragraph() { 10065 return getRuleContexts(ParagraphContext.class); 10066 } 10067 public ParagraphContext paragraph(int i) { 10068 return getRuleContext(ParagraphContext.class,i); 10069 } 10070 public List<LiContext> li() { 10071 return getRuleContexts(LiContext.class); 10072 } 10073 public LiContext li(int i) { 10074 return getRuleContext(LiContext.class,i); 10075 } 10076 public List<TrContext> tr() { 10077 return getRuleContexts(TrContext.class); 10078 } 10079 public TrContext tr(int i) { 10080 return getRuleContext(TrContext.class,i); 10081 } 10082 public List<TdContext> td() { 10083 return getRuleContexts(TdContext.class); 10084 } 10085 public TdContext td(int i) { 10086 return getRuleContext(TdContext.class,i); 10087 } 10088 public List<ThContext> th() { 10089 return getRuleContexts(ThContext.class); 10090 } 10091 public ThContext th(int i) { 10092 return getRuleContext(ThContext.class,i); 10093 } 10094 public List<BodyContext> body() { 10095 return getRuleContexts(BodyContext.class); 10096 } 10097 public BodyContext body(int i) { 10098 return getRuleContext(BodyContext.class,i); 10099 } 10100 public List<ColgroupContext> colgroup() { 10101 return getRuleContexts(ColgroupContext.class); 10102 } 10103 public ColgroupContext colgroup(int i) { 10104 return getRuleContext(ColgroupContext.class,i); 10105 } 10106 public List<DdContext> dd() { 10107 return getRuleContexts(DdContext.class); 10108 } 10109 public DdContext dd(int i) { 10110 return getRuleContext(DdContext.class,i); 10111 } 10112 public List<DtContext> dt() { 10113 return getRuleContexts(DtContext.class); 10114 } 10115 public DtContext dt(int i) { 10116 return getRuleContext(DtContext.class,i); 10117 } 10118 public List<HeadContext> head() { 10119 return getRuleContexts(HeadContext.class); 10120 } 10121 public HeadContext head(int i) { 10122 return getRuleContext(HeadContext.class,i); 10123 } 10124 public List<HtmlContext> html() { 10125 return getRuleContexts(HtmlContext.class); 10126 } 10127 public HtmlContext html(int i) { 10128 return getRuleContext(HtmlContext.class,i); 10129 } 10130 public List<OptionContext> option() { 10131 return getRuleContexts(OptionContext.class); 10132 } 10133 public OptionContext option(int i) { 10134 return getRuleContext(OptionContext.class,i); 10135 } 10136 public List<TbodyContext> tbody() { 10137 return getRuleContexts(TbodyContext.class); 10138 } 10139 public TbodyContext tbody(int i) { 10140 return getRuleContext(TbodyContext.class,i); 10141 } 10142 public List<TheadContext> thead() { 10143 return getRuleContexts(TheadContext.class); 10144 } 10145 public TheadContext thead(int i) { 10146 return getRuleContext(TheadContext.class,i); 10147 } 10148 public List<PTagStartContext> pTagStart() { 10149 return getRuleContexts(PTagStartContext.class); 10150 } 10151 public PTagStartContext pTagStart(int i) { 10152 return getRuleContext(PTagStartContext.class,i); 10153 } 10154 public List<LiTagStartContext> liTagStart() { 10155 return getRuleContexts(LiTagStartContext.class); 10156 } 10157 public LiTagStartContext liTagStart(int i) { 10158 return getRuleContext(LiTagStartContext.class,i); 10159 } 10160 public List<TrTagStartContext> trTagStart() { 10161 return getRuleContexts(TrTagStartContext.class); 10162 } 10163 public TrTagStartContext trTagStart(int i) { 10164 return getRuleContext(TrTagStartContext.class,i); 10165 } 10166 public List<TdTagStartContext> tdTagStart() { 10167 return getRuleContexts(TdTagStartContext.class); 10168 } 10169 public TdTagStartContext tdTagStart(int i) { 10170 return getRuleContext(TdTagStartContext.class,i); 10171 } 10172 public List<ThTagStartContext> thTagStart() { 10173 return getRuleContexts(ThTagStartContext.class); 10174 } 10175 public ThTagStartContext thTagStart(int i) { 10176 return getRuleContext(ThTagStartContext.class,i); 10177 } 10178 public List<BodyTagStartContext> bodyTagStart() { 10179 return getRuleContexts(BodyTagStartContext.class); 10180 } 10181 public BodyTagStartContext bodyTagStart(int i) { 10182 return getRuleContext(BodyTagStartContext.class,i); 10183 } 10184 public List<ColgroupTagStartContext> colgroupTagStart() { 10185 return getRuleContexts(ColgroupTagStartContext.class); 10186 } 10187 public ColgroupTagStartContext colgroupTagStart(int i) { 10188 return getRuleContext(ColgroupTagStartContext.class,i); 10189 } 10190 public List<DdTagStartContext> ddTagStart() { 10191 return getRuleContexts(DdTagStartContext.class); 10192 } 10193 public DdTagStartContext ddTagStart(int i) { 10194 return getRuleContext(DdTagStartContext.class,i); 10195 } 10196 public List<DtTagStartContext> dtTagStart() { 10197 return getRuleContexts(DtTagStartContext.class); 10198 } 10199 public DtTagStartContext dtTagStart(int i) { 10200 return getRuleContext(DtTagStartContext.class,i); 10201 } 10202 public List<HeadTagStartContext> headTagStart() { 10203 return getRuleContexts(HeadTagStartContext.class); 10204 } 10205 public HeadTagStartContext headTagStart(int i) { 10206 return getRuleContext(HeadTagStartContext.class,i); 10207 } 10208 public List<HtmlTagStartContext> htmlTagStart() { 10209 return getRuleContexts(HtmlTagStartContext.class); 10210 } 10211 public HtmlTagStartContext htmlTagStart(int i) { 10212 return getRuleContext(HtmlTagStartContext.class,i); 10213 } 10214 public List<OptionTagStartContext> optionTagStart() { 10215 return getRuleContexts(OptionTagStartContext.class); 10216 } 10217 public OptionTagStartContext optionTagStart(int i) { 10218 return getRuleContext(OptionTagStartContext.class,i); 10219 } 10220 public List<TbodyTagStartContext> tbodyTagStart() { 10221 return getRuleContexts(TbodyTagStartContext.class); 10222 } 10223 public TbodyTagStartContext tbodyTagStart(int i) { 10224 return getRuleContext(TbodyTagStartContext.class,i); 10225 } 10226 public List<TheadTagStartContext> theadTagStart() { 10227 return getRuleContexts(TheadTagStartContext.class); 10228 } 10229 public TheadTagStartContext theadTagStart(int i) { 10230 return getRuleContext(TheadTagStartContext.class,i); 10231 } 10232 public List<HtmlCommentContext> htmlComment() { 10233 return getRuleContexts(HtmlCommentContext.class); 10234 } 10235 public HtmlCommentContext htmlComment(int i) { 10236 return getRuleContext(HtmlCommentContext.class,i); 10237 } 10238 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10239 public TerminalNode CDATA(int i) { 10240 return getToken(JavadocParser.CDATA, i); 10241 } 10242 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10243 public TerminalNode NEWLINE(int i) { 10244 return getToken(JavadocParser.NEWLINE, i); 10245 } 10246 public List<TextContext> text() { 10247 return getRuleContexts(TextContext.class); 10248 } 10249 public TextContext text(int i) { 10250 return getRuleContext(TextContext.class,i); 10251 } 10252 public List<JavadocInlineTagContext> javadocInlineTag() { 10253 return getRuleContexts(JavadocInlineTagContext.class); 10254 } 10255 public JavadocInlineTagContext javadocInlineTag(int i) { 10256 return getRuleContext(JavadocInlineTagContext.class,i); 10257 } 10258 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10259 public TerminalNode LEADING_ASTERISK(int i) { 10260 return getToken(JavadocParser.LEADING_ASTERISK, i); 10261 } 10262 public TfootContext(ParserRuleContext parent, int invokingState) { 10263 super(parent, invokingState); 10264 } 10265 @Override public int getRuleIndex() { return RULE_tfoot; } 10266 } 10267 10268 public final TfootContext tfoot() throws RecognitionException { 10269 TfootContext _localctx = new TfootContext(_ctx, getState()); 10270 enterRule(_localctx, 94, RULE_tfoot); 10271 try { 10272 int _alt; 10273 enterOuterAlt(_localctx, 1); 10274 { 10275 setState(1220); 10276 tfootTagStart(false); 10277 setState(1260); 10278 _errHandler.sync(this); 10279 _alt = getInterpreter().adaptivePredict(_input,83,_ctx); 10280 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10281 if ( _alt==1 ) { 10282 { 10283 setState(1258); 10284 _errHandler.sync(this); 10285 switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) { 10286 case 1: 10287 { 10288 setState(1221); 10289 htmlTag(); 10290 } 10291 break; 10292 case 2: 10293 { 10294 setState(1222); 10295 singletonElement(); 10296 } 10297 break; 10298 case 3: 10299 { 10300 setState(1223); 10301 paragraph(); 10302 } 10303 break; 10304 case 4: 10305 { 10306 setState(1224); 10307 li(); 10308 } 10309 break; 10310 case 5: 10311 { 10312 setState(1225); 10313 tr(); 10314 } 10315 break; 10316 case 6: 10317 { 10318 setState(1226); 10319 td(); 10320 } 10321 break; 10322 case 7: 10323 { 10324 setState(1227); 10325 th(); 10326 } 10327 break; 10328 case 8: 10329 { 10330 setState(1228); 10331 body(); 10332 } 10333 break; 10334 case 9: 10335 { 10336 setState(1229); 10337 colgroup(); 10338 } 10339 break; 10340 case 10: 10341 { 10342 setState(1230); 10343 dd(); 10344 } 10345 break; 10346 case 11: 10347 { 10348 setState(1231); 10349 dt(); 10350 } 10351 break; 10352 case 12: 10353 { 10354 setState(1232); 10355 head(); 10356 } 10357 break; 10358 case 13: 10359 { 10360 setState(1233); 10361 html(); 10362 } 10363 break; 10364 case 14: 10365 { 10366 setState(1234); 10367 option(); 10368 } 10369 break; 10370 case 15: 10371 { 10372 setState(1235); 10373 tbody(); 10374 } 10375 break; 10376 case 16: 10377 { 10378 setState(1236); 10379 thead(); 10380 } 10381 break; 10382 case 17: 10383 { 10384 setState(1237); 10385 pTagStart(true); 10386 } 10387 break; 10388 case 18: 10389 { 10390 setState(1238); 10391 liTagStart(true); 10392 } 10393 break; 10394 case 19: 10395 { 10396 setState(1239); 10397 trTagStart(true); 10398 } 10399 break; 10400 case 20: 10401 { 10402 setState(1240); 10403 tdTagStart(true); 10404 } 10405 break; 10406 case 21: 10407 { 10408 setState(1241); 10409 thTagStart(true); 10410 } 10411 break; 10412 case 22: 10413 { 10414 setState(1242); 10415 bodyTagStart(true); 10416 } 10417 break; 10418 case 23: 10419 { 10420 setState(1243); 10421 colgroupTagStart(true); 10422 } 10423 break; 10424 case 24: 10425 { 10426 setState(1244); 10427 ddTagStart(true); 10428 } 10429 break; 10430 case 25: 10431 { 10432 setState(1245); 10433 dtTagStart(true); 10434 } 10435 break; 10436 case 26: 10437 { 10438 setState(1246); 10439 headTagStart(true); 10440 } 10441 break; 10442 case 27: 10443 { 10444 setState(1247); 10445 htmlTagStart(true); 10446 } 10447 break; 10448 case 28: 10449 { 10450 setState(1248); 10451 optionTagStart(true); 10452 } 10453 break; 10454 case 29: 10455 { 10456 setState(1249); 10457 tbodyTagStart(true); 10458 } 10459 break; 10460 case 30: 10461 { 10462 setState(1250); 10463 theadTagStart(true); 10464 } 10465 break; 10466 case 31: 10467 { 10468 { 10469 setState(1251); 10470 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 10471 setState(1252); 10472 match(LEADING_ASTERISK); 10473 } 10474 } 10475 break; 10476 case 32: 10477 { 10478 setState(1253); 10479 htmlComment(); 10480 } 10481 break; 10482 case 33: 10483 { 10484 setState(1254); 10485 match(CDATA); 10486 } 10487 break; 10488 case 34: 10489 { 10490 setState(1255); 10491 match(NEWLINE); 10492 } 10493 break; 10494 case 35: 10495 { 10496 setState(1256); 10497 text(); 10498 } 10499 break; 10500 case 36: 10501 { 10502 setState(1257); 10503 javadocInlineTag(); 10504 } 10505 break; 10506 } 10507 } 10508 } 10509 setState(1262); 10510 _errHandler.sync(this); 10511 _alt = getInterpreter().adaptivePredict(_input,83,_ctx); 10512 } 10513 setState(1263); 10514 tfootTagEnd(); 10515 } 10516 } 10517 catch (RecognitionException re) { 10518 _localctx.exception = re; 10519 _errHandler.reportError(this, re); 10520 _errHandler.recover(this, re); 10521 } 10522 finally { 10523 exitRule(); 10524 } 10525 return _localctx; 10526 } 10527 10528 public static class TheadTagStartContext extends ParserRuleContext { 10529 public boolean isNonTight; 10530 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 10531 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 10532 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 10533 public List<AttributeContext> attribute() { 10534 return getRuleContexts(AttributeContext.class); 10535 } 10536 public AttributeContext attribute(int i) { 10537 return getRuleContext(AttributeContext.class,i); 10538 } 10539 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10540 public TerminalNode NEWLINE(int i) { 10541 return getToken(JavadocParser.NEWLINE, i); 10542 } 10543 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10544 public TerminalNode LEADING_ASTERISK(int i) { 10545 return getToken(JavadocParser.LEADING_ASTERISK, i); 10546 } 10547 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10548 public TerminalNode WS(int i) { 10549 return getToken(JavadocParser.WS, i); 10550 } 10551 public TheadTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } 10552 public TheadTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { 10553 super(parent, invokingState); 10554 this.isNonTight = isNonTight; 10555 } 10556 @Override public int getRuleIndex() { return RULE_theadTagStart; } 10557 } 10558 10559 public final TheadTagStartContext theadTagStart(boolean isNonTight) throws RecognitionException { 10560 TheadTagStartContext _localctx = new TheadTagStartContext(_ctx, getState(), isNonTight); 10561 enterRule(_localctx, 96, RULE_theadTagStart); 10562 int _la; 10563 try { 10564 enterOuterAlt(_localctx, 1); 10565 { 10566 setState(1265); 10567 match(START); 10568 setState(1266); 10569 match(THEAD_HTML_TAG_NAME); 10570 setState(1273); 10571 _errHandler.sync(this); 10572 _la = _input.LA(1); 10573 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 10574 { 10575 setState(1271); 10576 _errHandler.sync(this); 10577 switch (_input.LA(1)) { 10578 case HTML_TAG_NAME: 10579 { 10580 setState(1267); 10581 attribute(); 10582 } 10583 break; 10584 case NEWLINE: 10585 { 10586 setState(1268); 10587 match(NEWLINE); 10588 } 10589 break; 10590 case LEADING_ASTERISK: 10591 { 10592 setState(1269); 10593 match(LEADING_ASTERISK); 10594 } 10595 break; 10596 case WS: 10597 { 10598 setState(1270); 10599 match(WS); 10600 } 10601 break; 10602 default: 10603 throw new NoViableAltException(this); 10604 } 10605 } 10606 setState(1275); 10607 _errHandler.sync(this); 10608 _la = _input.LA(1); 10609 } 10610 setState(1276); 10611 match(END); 10612 } 10613 _ctx.stop = _input.LT(-1); 10614 10615 if (isNonTight && nonTightTagStartContext == null) { 10616 nonTightTagStartContext = _localctx; 10617 } 10618 10619 } 10620 catch (RecognitionException re) { 10621 _localctx.exception = re; 10622 _errHandler.reportError(this, re); 10623 _errHandler.recover(this, re); 10624 } 10625 finally { 10626 exitRule(); 10627 } 10628 return _localctx; 10629 } 10630 10631 public static class TheadTagEndContext extends ParserRuleContext { 10632 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 10633 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 10634 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 10635 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 10636 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10637 public TerminalNode NEWLINE(int i) { 10638 return getToken(JavadocParser.NEWLINE, i); 10639 } 10640 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10641 public TerminalNode LEADING_ASTERISK(int i) { 10642 return getToken(JavadocParser.LEADING_ASTERISK, i); 10643 } 10644 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10645 public TerminalNode WS(int i) { 10646 return getToken(JavadocParser.WS, i); 10647 } 10648 public TheadTagEndContext(ParserRuleContext parent, int invokingState) { 10649 super(parent, invokingState); 10650 } 10651 @Override public int getRuleIndex() { return RULE_theadTagEnd; } 10652 } 10653 10654 public final TheadTagEndContext theadTagEnd() throws RecognitionException { 10655 TheadTagEndContext _localctx = new TheadTagEndContext(_ctx, getState()); 10656 enterRule(_localctx, 98, RULE_theadTagEnd); 10657 int _la; 10658 try { 10659 enterOuterAlt(_localctx, 1); 10660 { 10661 setState(1278); 10662 match(START); 10663 setState(1279); 10664 match(SLASH); 10665 setState(1280); 10666 match(THEAD_HTML_TAG_NAME); 10667 setState(1284); 10668 _errHandler.sync(this); 10669 _la = _input.LA(1); 10670 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 10671 { 10672 { 10673 setState(1281); 10674 _la = _input.LA(1); 10675 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 10676 _errHandler.recoverInline(this); 10677 } 10678 else { 10679 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 10680 _errHandler.reportMatch(this); 10681 consume(); 10682 } 10683 } 10684 } 10685 setState(1286); 10686 _errHandler.sync(this); 10687 _la = _input.LA(1); 10688 } 10689 setState(1287); 10690 match(END); 10691 } 10692 } 10693 catch (RecognitionException re) { 10694 _localctx.exception = re; 10695 _errHandler.reportError(this, re); 10696 _errHandler.recover(this, re); 10697 } 10698 finally { 10699 exitRule(); 10700 } 10701 return _localctx; 10702 } 10703 10704 public static class TheadContext extends ParserRuleContext { 10705 public TheadTagStartContext theadTagStart() { 10706 return getRuleContext(TheadTagStartContext.class,0); 10707 } 10708 public TheadTagEndContext theadTagEnd() { 10709 return getRuleContext(TheadTagEndContext.class,0); 10710 } 10711 public List<HtmlTagContext> htmlTag() { 10712 return getRuleContexts(HtmlTagContext.class); 10713 } 10714 public HtmlTagContext htmlTag(int i) { 10715 return getRuleContext(HtmlTagContext.class,i); 10716 } 10717 public List<SingletonElementContext> singletonElement() { 10718 return getRuleContexts(SingletonElementContext.class); 10719 } 10720 public SingletonElementContext singletonElement(int i) { 10721 return getRuleContext(SingletonElementContext.class,i); 10722 } 10723 public List<ParagraphContext> paragraph() { 10724 return getRuleContexts(ParagraphContext.class); 10725 } 10726 public ParagraphContext paragraph(int i) { 10727 return getRuleContext(ParagraphContext.class,i); 10728 } 10729 public List<LiContext> li() { 10730 return getRuleContexts(LiContext.class); 10731 } 10732 public LiContext li(int i) { 10733 return getRuleContext(LiContext.class,i); 10734 } 10735 public List<TrContext> tr() { 10736 return getRuleContexts(TrContext.class); 10737 } 10738 public TrContext tr(int i) { 10739 return getRuleContext(TrContext.class,i); 10740 } 10741 public List<TdContext> td() { 10742 return getRuleContexts(TdContext.class); 10743 } 10744 public TdContext td(int i) { 10745 return getRuleContext(TdContext.class,i); 10746 } 10747 public List<ThContext> th() { 10748 return getRuleContexts(ThContext.class); 10749 } 10750 public ThContext th(int i) { 10751 return getRuleContext(ThContext.class,i); 10752 } 10753 public List<BodyContext> body() { 10754 return getRuleContexts(BodyContext.class); 10755 } 10756 public BodyContext body(int i) { 10757 return getRuleContext(BodyContext.class,i); 10758 } 10759 public List<ColgroupContext> colgroup() { 10760 return getRuleContexts(ColgroupContext.class); 10761 } 10762 public ColgroupContext colgroup(int i) { 10763 return getRuleContext(ColgroupContext.class,i); 10764 } 10765 public List<DdContext> dd() { 10766 return getRuleContexts(DdContext.class); 10767 } 10768 public DdContext dd(int i) { 10769 return getRuleContext(DdContext.class,i); 10770 } 10771 public List<DtContext> dt() { 10772 return getRuleContexts(DtContext.class); 10773 } 10774 public DtContext dt(int i) { 10775 return getRuleContext(DtContext.class,i); 10776 } 10777 public List<HeadContext> head() { 10778 return getRuleContexts(HeadContext.class); 10779 } 10780 public HeadContext head(int i) { 10781 return getRuleContext(HeadContext.class,i); 10782 } 10783 public List<HtmlContext> html() { 10784 return getRuleContexts(HtmlContext.class); 10785 } 10786 public HtmlContext html(int i) { 10787 return getRuleContext(HtmlContext.class,i); 10788 } 10789 public List<OptionContext> option() { 10790 return getRuleContexts(OptionContext.class); 10791 } 10792 public OptionContext option(int i) { 10793 return getRuleContext(OptionContext.class,i); 10794 } 10795 public List<TbodyContext> tbody() { 10796 return getRuleContexts(TbodyContext.class); 10797 } 10798 public TbodyContext tbody(int i) { 10799 return getRuleContext(TbodyContext.class,i); 10800 } 10801 public List<TfootContext> tfoot() { 10802 return getRuleContexts(TfootContext.class); 10803 } 10804 public TfootContext tfoot(int i) { 10805 return getRuleContext(TfootContext.class,i); 10806 } 10807 public List<PTagStartContext> pTagStart() { 10808 return getRuleContexts(PTagStartContext.class); 10809 } 10810 public PTagStartContext pTagStart(int i) { 10811 return getRuleContext(PTagStartContext.class,i); 10812 } 10813 public List<LiTagStartContext> liTagStart() { 10814 return getRuleContexts(LiTagStartContext.class); 10815 } 10816 public LiTagStartContext liTagStart(int i) { 10817 return getRuleContext(LiTagStartContext.class,i); 10818 } 10819 public List<TrTagStartContext> trTagStart() { 10820 return getRuleContexts(TrTagStartContext.class); 10821 } 10822 public TrTagStartContext trTagStart(int i) { 10823 return getRuleContext(TrTagStartContext.class,i); 10824 } 10825 public List<TdTagStartContext> tdTagStart() { 10826 return getRuleContexts(TdTagStartContext.class); 10827 } 10828 public TdTagStartContext tdTagStart(int i) { 10829 return getRuleContext(TdTagStartContext.class,i); 10830 } 10831 public List<ThTagStartContext> thTagStart() { 10832 return getRuleContexts(ThTagStartContext.class); 10833 } 10834 public ThTagStartContext thTagStart(int i) { 10835 return getRuleContext(ThTagStartContext.class,i); 10836 } 10837 public List<BodyTagStartContext> bodyTagStart() { 10838 return getRuleContexts(BodyTagStartContext.class); 10839 } 10840 public BodyTagStartContext bodyTagStart(int i) { 10841 return getRuleContext(BodyTagStartContext.class,i); 10842 } 10843 public List<ColgroupTagStartContext> colgroupTagStart() { 10844 return getRuleContexts(ColgroupTagStartContext.class); 10845 } 10846 public ColgroupTagStartContext colgroupTagStart(int i) { 10847 return getRuleContext(ColgroupTagStartContext.class,i); 10848 } 10849 public List<DdTagStartContext> ddTagStart() { 10850 return getRuleContexts(DdTagStartContext.class); 10851 } 10852 public DdTagStartContext ddTagStart(int i) { 10853 return getRuleContext(DdTagStartContext.class,i); 10854 } 10855 public List<DtTagStartContext> dtTagStart() { 10856 return getRuleContexts(DtTagStartContext.class); 10857 } 10858 public DtTagStartContext dtTagStart(int i) { 10859 return getRuleContext(DtTagStartContext.class,i); 10860 } 10861 public List<HeadTagStartContext> headTagStart() { 10862 return getRuleContexts(HeadTagStartContext.class); 10863 } 10864 public HeadTagStartContext headTagStart(int i) { 10865 return getRuleContext(HeadTagStartContext.class,i); 10866 } 10867 public List<HtmlTagStartContext> htmlTagStart() { 10868 return getRuleContexts(HtmlTagStartContext.class); 10869 } 10870 public HtmlTagStartContext htmlTagStart(int i) { 10871 return getRuleContext(HtmlTagStartContext.class,i); 10872 } 10873 public List<OptionTagStartContext> optionTagStart() { 10874 return getRuleContexts(OptionTagStartContext.class); 10875 } 10876 public OptionTagStartContext optionTagStart(int i) { 10877 return getRuleContext(OptionTagStartContext.class,i); 10878 } 10879 public List<TbodyTagStartContext> tbodyTagStart() { 10880 return getRuleContexts(TbodyTagStartContext.class); 10881 } 10882 public TbodyTagStartContext tbodyTagStart(int i) { 10883 return getRuleContext(TbodyTagStartContext.class,i); 10884 } 10885 public List<TfootTagStartContext> tfootTagStart() { 10886 return getRuleContexts(TfootTagStartContext.class); 10887 } 10888 public TfootTagStartContext tfootTagStart(int i) { 10889 return getRuleContext(TfootTagStartContext.class,i); 10890 } 10891 public List<HtmlCommentContext> htmlComment() { 10892 return getRuleContexts(HtmlCommentContext.class); 10893 } 10894 public HtmlCommentContext htmlComment(int i) { 10895 return getRuleContext(HtmlCommentContext.class,i); 10896 } 10897 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10898 public TerminalNode CDATA(int i) { 10899 return getToken(JavadocParser.CDATA, i); 10900 } 10901 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10902 public TerminalNode NEWLINE(int i) { 10903 return getToken(JavadocParser.NEWLINE, i); 10904 } 10905 public List<TextContext> text() { 10906 return getRuleContexts(TextContext.class); 10907 } 10908 public TextContext text(int i) { 10909 return getRuleContext(TextContext.class,i); 10910 } 10911 public List<JavadocInlineTagContext> javadocInlineTag() { 10912 return getRuleContexts(JavadocInlineTagContext.class); 10913 } 10914 public JavadocInlineTagContext javadocInlineTag(int i) { 10915 return getRuleContext(JavadocInlineTagContext.class,i); 10916 } 10917 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10918 public TerminalNode LEADING_ASTERISK(int i) { 10919 return getToken(JavadocParser.LEADING_ASTERISK, i); 10920 } 10921 public TheadContext(ParserRuleContext parent, int invokingState) { 10922 super(parent, invokingState); 10923 } 10924 @Override public int getRuleIndex() { return RULE_thead; } 10925 } 10926 10927 public final TheadContext thead() throws RecognitionException { 10928 TheadContext _localctx = new TheadContext(_ctx, getState()); 10929 enterRule(_localctx, 100, RULE_thead); 10930 try { 10931 int _alt; 10932 enterOuterAlt(_localctx, 1); 10933 { 10934 setState(1289); 10935 theadTagStart(false); 10936 setState(1329); 10937 _errHandler.sync(this); 10938 _alt = getInterpreter().adaptivePredict(_input,88,_ctx); 10939 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10940 if ( _alt==1 ) { 10941 { 10942 setState(1327); 10943 _errHandler.sync(this); 10944 switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) { 10945 case 1: 10946 { 10947 setState(1290); 10948 htmlTag(); 10949 } 10950 break; 10951 case 2: 10952 { 10953 setState(1291); 10954 singletonElement(); 10955 } 10956 break; 10957 case 3: 10958 { 10959 setState(1292); 10960 paragraph(); 10961 } 10962 break; 10963 case 4: 10964 { 10965 setState(1293); 10966 li(); 10967 } 10968 break; 10969 case 5: 10970 { 10971 setState(1294); 10972 tr(); 10973 } 10974 break; 10975 case 6: 10976 { 10977 setState(1295); 10978 td(); 10979 } 10980 break; 10981 case 7: 10982 { 10983 setState(1296); 10984 th(); 10985 } 10986 break; 10987 case 8: 10988 { 10989 setState(1297); 10990 body(); 10991 } 10992 break; 10993 case 9: 10994 { 10995 setState(1298); 10996 colgroup(); 10997 } 10998 break; 10999 case 10: 11000 { 11001 setState(1299); 11002 dd(); 11003 } 11004 break; 11005 case 11: 11006 { 11007 setState(1300); 11008 dt(); 11009 } 11010 break; 11011 case 12: 11012 { 11013 setState(1301); 11014 head(); 11015 } 11016 break; 11017 case 13: 11018 { 11019 setState(1302); 11020 html(); 11021 } 11022 break; 11023 case 14: 11024 { 11025 setState(1303); 11026 option(); 11027 } 11028 break; 11029 case 15: 11030 { 11031 setState(1304); 11032 tbody(); 11033 } 11034 break; 11035 case 16: 11036 { 11037 setState(1305); 11038 tfoot(); 11039 } 11040 break; 11041 case 17: 11042 { 11043 setState(1306); 11044 pTagStart(true); 11045 } 11046 break; 11047 case 18: 11048 { 11049 setState(1307); 11050 liTagStart(true); 11051 } 11052 break; 11053 case 19: 11054 { 11055 setState(1308); 11056 trTagStart(true); 11057 } 11058 break; 11059 case 20: 11060 { 11061 setState(1309); 11062 tdTagStart(true); 11063 } 11064 break; 11065 case 21: 11066 { 11067 setState(1310); 11068 thTagStart(true); 11069 } 11070 break; 11071 case 22: 11072 { 11073 setState(1311); 11074 bodyTagStart(true); 11075 } 11076 break; 11077 case 23: 11078 { 11079 setState(1312); 11080 colgroupTagStart(true); 11081 } 11082 break; 11083 case 24: 11084 { 11085 setState(1313); 11086 ddTagStart(true); 11087 } 11088 break; 11089 case 25: 11090 { 11091 setState(1314); 11092 dtTagStart(true); 11093 } 11094 break; 11095 case 26: 11096 { 11097 setState(1315); 11098 headTagStart(true); 11099 } 11100 break; 11101 case 27: 11102 { 11103 setState(1316); 11104 htmlTagStart(true); 11105 } 11106 break; 11107 case 28: 11108 { 11109 setState(1317); 11110 optionTagStart(true); 11111 } 11112 break; 11113 case 29: 11114 { 11115 setState(1318); 11116 tbodyTagStart(true); 11117 } 11118 break; 11119 case 30: 11120 { 11121 setState(1319); 11122 tfootTagStart(true); 11123 } 11124 break; 11125 case 31: 11126 { 11127 { 11128 setState(1320); 11129 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 11130 setState(1321); 11131 match(LEADING_ASTERISK); 11132 } 11133 } 11134 break; 11135 case 32: 11136 { 11137 setState(1322); 11138 htmlComment(); 11139 } 11140 break; 11141 case 33: 11142 { 11143 setState(1323); 11144 match(CDATA); 11145 } 11146 break; 11147 case 34: 11148 { 11149 setState(1324); 11150 match(NEWLINE); 11151 } 11152 break; 11153 case 35: 11154 { 11155 setState(1325); 11156 text(); 11157 } 11158 break; 11159 case 36: 11160 { 11161 setState(1326); 11162 javadocInlineTag(); 11163 } 11164 break; 11165 } 11166 } 11167 } 11168 setState(1331); 11169 _errHandler.sync(this); 11170 _alt = getInterpreter().adaptivePredict(_input,88,_ctx); 11171 } 11172 setState(1332); 11173 theadTagEnd(); 11174 } 11175 } 11176 catch (RecognitionException re) { 11177 _localctx.exception = re; 11178 _errHandler.reportError(this, re); 11179 _errHandler.recover(this, re); 11180 } 11181 finally { 11182 exitRule(); 11183 } 11184 return _localctx; 11185 } 11186 11187 public static class SingletonElementContext extends ParserRuleContext { 11188 public EmptyTagContext emptyTag() { 11189 return getRuleContext(EmptyTagContext.class,0); 11190 } 11191 public AreaTagContext areaTag() { 11192 return getRuleContext(AreaTagContext.class,0); 11193 } 11194 public BaseTagContext baseTag() { 11195 return getRuleContext(BaseTagContext.class,0); 11196 } 11197 public BasefontTagContext basefontTag() { 11198 return getRuleContext(BasefontTagContext.class,0); 11199 } 11200 public BrTagContext brTag() { 11201 return getRuleContext(BrTagContext.class,0); 11202 } 11203 public ColTagContext colTag() { 11204 return getRuleContext(ColTagContext.class,0); 11205 } 11206 public FrameTagContext frameTag() { 11207 return getRuleContext(FrameTagContext.class,0); 11208 } 11209 public HrTagContext hrTag() { 11210 return getRuleContext(HrTagContext.class,0); 11211 } 11212 public ImgTagContext imgTag() { 11213 return getRuleContext(ImgTagContext.class,0); 11214 } 11215 public InputTagContext inputTag() { 11216 return getRuleContext(InputTagContext.class,0); 11217 } 11218 public IsindexTagContext isindexTag() { 11219 return getRuleContext(IsindexTagContext.class,0); 11220 } 11221 public LinkTagContext linkTag() { 11222 return getRuleContext(LinkTagContext.class,0); 11223 } 11224 public MetaTagContext metaTag() { 11225 return getRuleContext(MetaTagContext.class,0); 11226 } 11227 public ParamTagContext paramTag() { 11228 return getRuleContext(ParamTagContext.class,0); 11229 } 11230 public EmbedTagContext embedTag() { 11231 return getRuleContext(EmbedTagContext.class,0); 11232 } 11233 public KeygenTagContext keygenTag() { 11234 return getRuleContext(KeygenTagContext.class,0); 11235 } 11236 public SourceTagContext sourceTag() { 11237 return getRuleContext(SourceTagContext.class,0); 11238 } 11239 public TrackTagContext trackTag() { 11240 return getRuleContext(TrackTagContext.class,0); 11241 } 11242 public WbrTagContext wbrTag() { 11243 return getRuleContext(WbrTagContext.class,0); 11244 } 11245 public WrongSinletonTagContext wrongSinletonTag() { 11246 return getRuleContext(WrongSinletonTagContext.class,0); 11247 } 11248 public SingletonElementContext(ParserRuleContext parent, int invokingState) { 11249 super(parent, invokingState); 11250 } 11251 @Override public int getRuleIndex() { return RULE_singletonElement; } 11252 } 11253 11254 public final SingletonElementContext singletonElement() throws RecognitionException { 11255 SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState()); 11256 enterRule(_localctx, 102, RULE_singletonElement); 11257 try { 11258 setState(1354); 11259 _errHandler.sync(this); 11260 switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) { 11261 case 1: 11262 enterOuterAlt(_localctx, 1); 11263 { 11264 setState(1334); 11265 emptyTag(); 11266 } 11267 break; 11268 case 2: 11269 enterOuterAlt(_localctx, 2); 11270 { 11271 setState(1335); 11272 areaTag(); 11273 } 11274 break; 11275 case 3: 11276 enterOuterAlt(_localctx, 3); 11277 { 11278 setState(1336); 11279 baseTag(); 11280 } 11281 break; 11282 case 4: 11283 enterOuterAlt(_localctx, 4); 11284 { 11285 setState(1337); 11286 basefontTag(); 11287 } 11288 break; 11289 case 5: 11290 enterOuterAlt(_localctx, 5); 11291 { 11292 setState(1338); 11293 brTag(); 11294 } 11295 break; 11296 case 6: 11297 enterOuterAlt(_localctx, 6); 11298 { 11299 setState(1339); 11300 colTag(); 11301 } 11302 break; 11303 case 7: 11304 enterOuterAlt(_localctx, 7); 11305 { 11306 setState(1340); 11307 frameTag(); 11308 } 11309 break; 11310 case 8: 11311 enterOuterAlt(_localctx, 8); 11312 { 11313 setState(1341); 11314 hrTag(); 11315 } 11316 break; 11317 case 9: 11318 enterOuterAlt(_localctx, 9); 11319 { 11320 setState(1342); 11321 imgTag(); 11322 } 11323 break; 11324 case 10: 11325 enterOuterAlt(_localctx, 10); 11326 { 11327 setState(1343); 11328 inputTag(); 11329 } 11330 break; 11331 case 11: 11332 enterOuterAlt(_localctx, 11); 11333 { 11334 setState(1344); 11335 isindexTag(); 11336 } 11337 break; 11338 case 12: 11339 enterOuterAlt(_localctx, 12); 11340 { 11341 setState(1345); 11342 linkTag(); 11343 } 11344 break; 11345 case 13: 11346 enterOuterAlt(_localctx, 13); 11347 { 11348 setState(1346); 11349 metaTag(); 11350 } 11351 break; 11352 case 14: 11353 enterOuterAlt(_localctx, 14); 11354 { 11355 setState(1347); 11356 paramTag(); 11357 } 11358 break; 11359 case 15: 11360 enterOuterAlt(_localctx, 15); 11361 { 11362 setState(1348); 11363 embedTag(); 11364 } 11365 break; 11366 case 16: 11367 enterOuterAlt(_localctx, 16); 11368 { 11369 setState(1349); 11370 keygenTag(); 11371 } 11372 break; 11373 case 17: 11374 enterOuterAlt(_localctx, 17); 11375 { 11376 setState(1350); 11377 sourceTag(); 11378 } 11379 break; 11380 case 18: 11381 enterOuterAlt(_localctx, 18); 11382 { 11383 setState(1351); 11384 trackTag(); 11385 } 11386 break; 11387 case 19: 11388 enterOuterAlt(_localctx, 19); 11389 { 11390 setState(1352); 11391 wbrTag(); 11392 } 11393 break; 11394 case 20: 11395 enterOuterAlt(_localctx, 20); 11396 { 11397 setState(1353); 11398 wrongSinletonTag(); 11399 } 11400 break; 11401 } 11402 } 11403 catch (RecognitionException re) { 11404 _localctx.exception = re; 11405 _errHandler.reportError(this, re); 11406 _errHandler.recover(this, re); 11407 } 11408 finally { 11409 exitRule(); 11410 } 11411 return _localctx; 11412 } 11413 11414 public static class EmptyTagContext extends ParserRuleContext { 11415 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 11416 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 11417 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 11418 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 11419 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 11420 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 11421 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 11422 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 11423 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 11424 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 11425 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 11426 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 11427 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 11428 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 11429 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 11430 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 11431 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 11432 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11433 public List<AttributeContext> attribute() { 11434 return getRuleContexts(AttributeContext.class); 11435 } 11436 public AttributeContext attribute(int i) { 11437 return getRuleContext(AttributeContext.class,i); 11438 } 11439 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11440 public TerminalNode NEWLINE(int i) { 11441 return getToken(JavadocParser.NEWLINE, i); 11442 } 11443 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11444 public TerminalNode LEADING_ASTERISK(int i) { 11445 return getToken(JavadocParser.LEADING_ASTERISK, i); 11446 } 11447 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11448 public TerminalNode WS(int i) { 11449 return getToken(JavadocParser.WS, i); 11450 } 11451 public EmptyTagContext(ParserRuleContext parent, int invokingState) { 11452 super(parent, invokingState); 11453 } 11454 @Override public int getRuleIndex() { return RULE_emptyTag; } 11455 } 11456 11457 public final EmptyTagContext emptyTag() throws RecognitionException { 11458 EmptyTagContext _localctx = new EmptyTagContext(_ctx, getState()); 11459 enterRule(_localctx, 104, RULE_emptyTag); 11460 int _la; 11461 try { 11462 enterOuterAlt(_localctx, 1); 11463 { 11464 setState(1356); 11465 match(START); 11466 setState(1357); 11467 _la = _input.LA(1); 11468 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)) ) { 11469 _errHandler.recoverInline(this); 11470 } 11471 else { 11472 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 11473 _errHandler.reportMatch(this); 11474 consume(); 11475 } 11476 setState(1364); 11477 _errHandler.sync(this); 11478 _la = _input.LA(1); 11479 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11480 { 11481 setState(1362); 11482 _errHandler.sync(this); 11483 switch (_input.LA(1)) { 11484 case HTML_TAG_NAME: 11485 { 11486 setState(1358); 11487 attribute(); 11488 } 11489 break; 11490 case NEWLINE: 11491 { 11492 setState(1359); 11493 match(NEWLINE); 11494 } 11495 break; 11496 case LEADING_ASTERISK: 11497 { 11498 setState(1360); 11499 match(LEADING_ASTERISK); 11500 } 11501 break; 11502 case WS: 11503 { 11504 setState(1361); 11505 match(WS); 11506 } 11507 break; 11508 default: 11509 throw new NoViableAltException(this); 11510 } 11511 } 11512 setState(1366); 11513 _errHandler.sync(this); 11514 _la = _input.LA(1); 11515 } 11516 setState(1367); 11517 match(SLASH_END); 11518 } 11519 } 11520 catch (RecognitionException re) { 11521 _localctx.exception = re; 11522 _errHandler.reportError(this, re); 11523 _errHandler.recover(this, re); 11524 } 11525 finally { 11526 exitRule(); 11527 } 11528 return _localctx; 11529 } 11530 11531 public static class AreaTagContext extends ParserRuleContext { 11532 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 11533 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 11534 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 11535 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 11536 public List<AttributeContext> attribute() { 11537 return getRuleContexts(AttributeContext.class); 11538 } 11539 public AttributeContext attribute(int i) { 11540 return getRuleContext(AttributeContext.class,i); 11541 } 11542 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11543 public TerminalNode NEWLINE(int i) { 11544 return getToken(JavadocParser.NEWLINE, i); 11545 } 11546 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11547 public TerminalNode LEADING_ASTERISK(int i) { 11548 return getToken(JavadocParser.LEADING_ASTERISK, i); 11549 } 11550 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11551 public TerminalNode WS(int i) { 11552 return getToken(JavadocParser.WS, i); 11553 } 11554 public AreaTagContext(ParserRuleContext parent, int invokingState) { 11555 super(parent, invokingState); 11556 } 11557 @Override public int getRuleIndex() { return RULE_areaTag; } 11558 } 11559 11560 public final AreaTagContext areaTag() throws RecognitionException { 11561 AreaTagContext _localctx = new AreaTagContext(_ctx, getState()); 11562 enterRule(_localctx, 106, RULE_areaTag); 11563 int _la; 11564 try { 11565 enterOuterAlt(_localctx, 1); 11566 { 11567 setState(1369); 11568 match(START); 11569 setState(1370); 11570 match(AREA_HTML_TAG_NAME); 11571 setState(1377); 11572 _errHandler.sync(this); 11573 _la = _input.LA(1); 11574 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11575 { 11576 setState(1375); 11577 _errHandler.sync(this); 11578 switch (_input.LA(1)) { 11579 case HTML_TAG_NAME: 11580 { 11581 setState(1371); 11582 attribute(); 11583 } 11584 break; 11585 case NEWLINE: 11586 { 11587 setState(1372); 11588 match(NEWLINE); 11589 } 11590 break; 11591 case LEADING_ASTERISK: 11592 { 11593 setState(1373); 11594 match(LEADING_ASTERISK); 11595 } 11596 break; 11597 case WS: 11598 { 11599 setState(1374); 11600 match(WS); 11601 } 11602 break; 11603 default: 11604 throw new NoViableAltException(this); 11605 } 11606 } 11607 setState(1379); 11608 _errHandler.sync(this); 11609 _la = _input.LA(1); 11610 } 11611 setState(1380); 11612 _la = _input.LA(1); 11613 if ( !(_la==END || _la==SLASH_END) ) { 11614 _errHandler.recoverInline(this); 11615 } 11616 else { 11617 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 11618 _errHandler.reportMatch(this); 11619 consume(); 11620 } 11621 } 11622 } 11623 catch (RecognitionException re) { 11624 _localctx.exception = re; 11625 _errHandler.reportError(this, re); 11626 _errHandler.recover(this, re); 11627 } 11628 finally { 11629 exitRule(); 11630 } 11631 return _localctx; 11632 } 11633 11634 public static class BaseTagContext extends ParserRuleContext { 11635 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 11636 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 11637 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 11638 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 11639 public List<AttributeContext> attribute() { 11640 return getRuleContexts(AttributeContext.class); 11641 } 11642 public AttributeContext attribute(int i) { 11643 return getRuleContext(AttributeContext.class,i); 11644 } 11645 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11646 public TerminalNode NEWLINE(int i) { 11647 return getToken(JavadocParser.NEWLINE, i); 11648 } 11649 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11650 public TerminalNode LEADING_ASTERISK(int i) { 11651 return getToken(JavadocParser.LEADING_ASTERISK, i); 11652 } 11653 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11654 public TerminalNode WS(int i) { 11655 return getToken(JavadocParser.WS, i); 11656 } 11657 public BaseTagContext(ParserRuleContext parent, int invokingState) { 11658 super(parent, invokingState); 11659 } 11660 @Override public int getRuleIndex() { return RULE_baseTag; } 11661 } 11662 11663 public final BaseTagContext baseTag() throws RecognitionException { 11664 BaseTagContext _localctx = new BaseTagContext(_ctx, getState()); 11665 enterRule(_localctx, 108, RULE_baseTag); 11666 int _la; 11667 try { 11668 enterOuterAlt(_localctx, 1); 11669 { 11670 setState(1382); 11671 match(START); 11672 setState(1383); 11673 match(BASE_HTML_TAG_NAME); 11674 setState(1390); 11675 _errHandler.sync(this); 11676 _la = _input.LA(1); 11677 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11678 { 11679 setState(1388); 11680 _errHandler.sync(this); 11681 switch (_input.LA(1)) { 11682 case HTML_TAG_NAME: 11683 { 11684 setState(1384); 11685 attribute(); 11686 } 11687 break; 11688 case NEWLINE: 11689 { 11690 setState(1385); 11691 match(NEWLINE); 11692 } 11693 break; 11694 case LEADING_ASTERISK: 11695 { 11696 setState(1386); 11697 match(LEADING_ASTERISK); 11698 } 11699 break; 11700 case WS: 11701 { 11702 setState(1387); 11703 match(WS); 11704 } 11705 break; 11706 default: 11707 throw new NoViableAltException(this); 11708 } 11709 } 11710 setState(1392); 11711 _errHandler.sync(this); 11712 _la = _input.LA(1); 11713 } 11714 setState(1393); 11715 _la = _input.LA(1); 11716 if ( !(_la==END || _la==SLASH_END) ) { 11717 _errHandler.recoverInline(this); 11718 } 11719 else { 11720 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 11721 _errHandler.reportMatch(this); 11722 consume(); 11723 } 11724 } 11725 } 11726 catch (RecognitionException re) { 11727 _localctx.exception = re; 11728 _errHandler.reportError(this, re); 11729 _errHandler.recover(this, re); 11730 } 11731 finally { 11732 exitRule(); 11733 } 11734 return _localctx; 11735 } 11736 11737 public static class BasefontTagContext extends ParserRuleContext { 11738 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 11739 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 11740 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 11741 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 11742 public List<AttributeContext> attribute() { 11743 return getRuleContexts(AttributeContext.class); 11744 } 11745 public AttributeContext attribute(int i) { 11746 return getRuleContext(AttributeContext.class,i); 11747 } 11748 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11749 public TerminalNode NEWLINE(int i) { 11750 return getToken(JavadocParser.NEWLINE, i); 11751 } 11752 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11753 public TerminalNode LEADING_ASTERISK(int i) { 11754 return getToken(JavadocParser.LEADING_ASTERISK, i); 11755 } 11756 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11757 public TerminalNode WS(int i) { 11758 return getToken(JavadocParser.WS, i); 11759 } 11760 public BasefontTagContext(ParserRuleContext parent, int invokingState) { 11761 super(parent, invokingState); 11762 } 11763 @Override public int getRuleIndex() { return RULE_basefontTag; } 11764 } 11765 11766 public final BasefontTagContext basefontTag() throws RecognitionException { 11767 BasefontTagContext _localctx = new BasefontTagContext(_ctx, getState()); 11768 enterRule(_localctx, 110, RULE_basefontTag); 11769 int _la; 11770 try { 11771 enterOuterAlt(_localctx, 1); 11772 { 11773 setState(1395); 11774 match(START); 11775 setState(1396); 11776 match(BASEFONT_HTML_TAG_NAME); 11777 setState(1403); 11778 _errHandler.sync(this); 11779 _la = _input.LA(1); 11780 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11781 { 11782 setState(1401); 11783 _errHandler.sync(this); 11784 switch (_input.LA(1)) { 11785 case HTML_TAG_NAME: 11786 { 11787 setState(1397); 11788 attribute(); 11789 } 11790 break; 11791 case NEWLINE: 11792 { 11793 setState(1398); 11794 match(NEWLINE); 11795 } 11796 break; 11797 case LEADING_ASTERISK: 11798 { 11799 setState(1399); 11800 match(LEADING_ASTERISK); 11801 } 11802 break; 11803 case WS: 11804 { 11805 setState(1400); 11806 match(WS); 11807 } 11808 break; 11809 default: 11810 throw new NoViableAltException(this); 11811 } 11812 } 11813 setState(1405); 11814 _errHandler.sync(this); 11815 _la = _input.LA(1); 11816 } 11817 setState(1406); 11818 _la = _input.LA(1); 11819 if ( !(_la==END || _la==SLASH_END) ) { 11820 _errHandler.recoverInline(this); 11821 } 11822 else { 11823 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 11824 _errHandler.reportMatch(this); 11825 consume(); 11826 } 11827 } 11828 } 11829 catch (RecognitionException re) { 11830 _localctx.exception = re; 11831 _errHandler.reportError(this, re); 11832 _errHandler.recover(this, re); 11833 } 11834 finally { 11835 exitRule(); 11836 } 11837 return _localctx; 11838 } 11839 11840 public static class BrTagContext extends ParserRuleContext { 11841 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 11842 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 11843 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 11844 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 11845 public List<AttributeContext> attribute() { 11846 return getRuleContexts(AttributeContext.class); 11847 } 11848 public AttributeContext attribute(int i) { 11849 return getRuleContext(AttributeContext.class,i); 11850 } 11851 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11852 public TerminalNode NEWLINE(int i) { 11853 return getToken(JavadocParser.NEWLINE, i); 11854 } 11855 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11856 public TerminalNode LEADING_ASTERISK(int i) { 11857 return getToken(JavadocParser.LEADING_ASTERISK, i); 11858 } 11859 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11860 public TerminalNode WS(int i) { 11861 return getToken(JavadocParser.WS, i); 11862 } 11863 public BrTagContext(ParserRuleContext parent, int invokingState) { 11864 super(parent, invokingState); 11865 } 11866 @Override public int getRuleIndex() { return RULE_brTag; } 11867 } 11868 11869 public final BrTagContext brTag() throws RecognitionException { 11870 BrTagContext _localctx = new BrTagContext(_ctx, getState()); 11871 enterRule(_localctx, 112, RULE_brTag); 11872 int _la; 11873 try { 11874 enterOuterAlt(_localctx, 1); 11875 { 11876 setState(1408); 11877 match(START); 11878 setState(1409); 11879 match(BR_HTML_TAG_NAME); 11880 setState(1416); 11881 _errHandler.sync(this); 11882 _la = _input.LA(1); 11883 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11884 { 11885 setState(1414); 11886 _errHandler.sync(this); 11887 switch (_input.LA(1)) { 11888 case HTML_TAG_NAME: 11889 { 11890 setState(1410); 11891 attribute(); 11892 } 11893 break; 11894 case NEWLINE: 11895 { 11896 setState(1411); 11897 match(NEWLINE); 11898 } 11899 break; 11900 case LEADING_ASTERISK: 11901 { 11902 setState(1412); 11903 match(LEADING_ASTERISK); 11904 } 11905 break; 11906 case WS: 11907 { 11908 setState(1413); 11909 match(WS); 11910 } 11911 break; 11912 default: 11913 throw new NoViableAltException(this); 11914 } 11915 } 11916 setState(1418); 11917 _errHandler.sync(this); 11918 _la = _input.LA(1); 11919 } 11920 setState(1419); 11921 _la = _input.LA(1); 11922 if ( !(_la==END || _la==SLASH_END) ) { 11923 _errHandler.recoverInline(this); 11924 } 11925 else { 11926 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 11927 _errHandler.reportMatch(this); 11928 consume(); 11929 } 11930 } 11931 } 11932 catch (RecognitionException re) { 11933 _localctx.exception = re; 11934 _errHandler.reportError(this, re); 11935 _errHandler.recover(this, re); 11936 } 11937 finally { 11938 exitRule(); 11939 } 11940 return _localctx; 11941 } 11942 11943 public static class ColTagContext extends ParserRuleContext { 11944 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 11945 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 11946 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 11947 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 11948 public List<AttributeContext> attribute() { 11949 return getRuleContexts(AttributeContext.class); 11950 } 11951 public AttributeContext attribute(int i) { 11952 return getRuleContext(AttributeContext.class,i); 11953 } 11954 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11955 public TerminalNode NEWLINE(int i) { 11956 return getToken(JavadocParser.NEWLINE, i); 11957 } 11958 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11959 public TerminalNode LEADING_ASTERISK(int i) { 11960 return getToken(JavadocParser.LEADING_ASTERISK, i); 11961 } 11962 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11963 public TerminalNode WS(int i) { 11964 return getToken(JavadocParser.WS, i); 11965 } 11966 public ColTagContext(ParserRuleContext parent, int invokingState) { 11967 super(parent, invokingState); 11968 } 11969 @Override public int getRuleIndex() { return RULE_colTag; } 11970 } 11971 11972 public final ColTagContext colTag() throws RecognitionException { 11973 ColTagContext _localctx = new ColTagContext(_ctx, getState()); 11974 enterRule(_localctx, 114, RULE_colTag); 11975 int _la; 11976 try { 11977 enterOuterAlt(_localctx, 1); 11978 { 11979 setState(1421); 11980 match(START); 11981 setState(1422); 11982 match(COL_HTML_TAG_NAME); 11983 setState(1429); 11984 _errHandler.sync(this); 11985 _la = _input.LA(1); 11986 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11987 { 11988 setState(1427); 11989 _errHandler.sync(this); 11990 switch (_input.LA(1)) { 11991 case HTML_TAG_NAME: 11992 { 11993 setState(1423); 11994 attribute(); 11995 } 11996 break; 11997 case NEWLINE: 11998 { 11999 setState(1424); 12000 match(NEWLINE); 12001 } 12002 break; 12003 case LEADING_ASTERISK: 12004 { 12005 setState(1425); 12006 match(LEADING_ASTERISK); 12007 } 12008 break; 12009 case WS: 12010 { 12011 setState(1426); 12012 match(WS); 12013 } 12014 break; 12015 default: 12016 throw new NoViableAltException(this); 12017 } 12018 } 12019 setState(1431); 12020 _errHandler.sync(this); 12021 _la = _input.LA(1); 12022 } 12023 setState(1432); 12024 _la = _input.LA(1); 12025 if ( !(_la==END || _la==SLASH_END) ) { 12026 _errHandler.recoverInline(this); 12027 } 12028 else { 12029 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12030 _errHandler.reportMatch(this); 12031 consume(); 12032 } 12033 } 12034 } 12035 catch (RecognitionException re) { 12036 _localctx.exception = re; 12037 _errHandler.reportError(this, re); 12038 _errHandler.recover(this, re); 12039 } 12040 finally { 12041 exitRule(); 12042 } 12043 return _localctx; 12044 } 12045 12046 public static class FrameTagContext extends ParserRuleContext { 12047 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 12048 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 12049 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 12050 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 12051 public List<AttributeContext> attribute() { 12052 return getRuleContexts(AttributeContext.class); 12053 } 12054 public AttributeContext attribute(int i) { 12055 return getRuleContext(AttributeContext.class,i); 12056 } 12057 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12058 public TerminalNode NEWLINE(int i) { 12059 return getToken(JavadocParser.NEWLINE, i); 12060 } 12061 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12062 public TerminalNode LEADING_ASTERISK(int i) { 12063 return getToken(JavadocParser.LEADING_ASTERISK, i); 12064 } 12065 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12066 public TerminalNode WS(int i) { 12067 return getToken(JavadocParser.WS, i); 12068 } 12069 public FrameTagContext(ParserRuleContext parent, int invokingState) { 12070 super(parent, invokingState); 12071 } 12072 @Override public int getRuleIndex() { return RULE_frameTag; } 12073 } 12074 12075 public final FrameTagContext frameTag() throws RecognitionException { 12076 FrameTagContext _localctx = new FrameTagContext(_ctx, getState()); 12077 enterRule(_localctx, 116, RULE_frameTag); 12078 int _la; 12079 try { 12080 enterOuterAlt(_localctx, 1); 12081 { 12082 setState(1434); 12083 match(START); 12084 setState(1435); 12085 match(FRAME_HTML_TAG_NAME); 12086 setState(1442); 12087 _errHandler.sync(this); 12088 _la = _input.LA(1); 12089 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12090 { 12091 setState(1440); 12092 _errHandler.sync(this); 12093 switch (_input.LA(1)) { 12094 case HTML_TAG_NAME: 12095 { 12096 setState(1436); 12097 attribute(); 12098 } 12099 break; 12100 case NEWLINE: 12101 { 12102 setState(1437); 12103 match(NEWLINE); 12104 } 12105 break; 12106 case LEADING_ASTERISK: 12107 { 12108 setState(1438); 12109 match(LEADING_ASTERISK); 12110 } 12111 break; 12112 case WS: 12113 { 12114 setState(1439); 12115 match(WS); 12116 } 12117 break; 12118 default: 12119 throw new NoViableAltException(this); 12120 } 12121 } 12122 setState(1444); 12123 _errHandler.sync(this); 12124 _la = _input.LA(1); 12125 } 12126 setState(1445); 12127 _la = _input.LA(1); 12128 if ( !(_la==END || _la==SLASH_END) ) { 12129 _errHandler.recoverInline(this); 12130 } 12131 else { 12132 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12133 _errHandler.reportMatch(this); 12134 consume(); 12135 } 12136 } 12137 } 12138 catch (RecognitionException re) { 12139 _localctx.exception = re; 12140 _errHandler.reportError(this, re); 12141 _errHandler.recover(this, re); 12142 } 12143 finally { 12144 exitRule(); 12145 } 12146 return _localctx; 12147 } 12148 12149 public static class HrTagContext extends ParserRuleContext { 12150 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 12151 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 12152 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 12153 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 12154 public List<AttributeContext> attribute() { 12155 return getRuleContexts(AttributeContext.class); 12156 } 12157 public AttributeContext attribute(int i) { 12158 return getRuleContext(AttributeContext.class,i); 12159 } 12160 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12161 public TerminalNode NEWLINE(int i) { 12162 return getToken(JavadocParser.NEWLINE, i); 12163 } 12164 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12165 public TerminalNode LEADING_ASTERISK(int i) { 12166 return getToken(JavadocParser.LEADING_ASTERISK, i); 12167 } 12168 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12169 public TerminalNode WS(int i) { 12170 return getToken(JavadocParser.WS, i); 12171 } 12172 public HrTagContext(ParserRuleContext parent, int invokingState) { 12173 super(parent, invokingState); 12174 } 12175 @Override public int getRuleIndex() { return RULE_hrTag; } 12176 } 12177 12178 public final HrTagContext hrTag() throws RecognitionException { 12179 HrTagContext _localctx = new HrTagContext(_ctx, getState()); 12180 enterRule(_localctx, 118, RULE_hrTag); 12181 int _la; 12182 try { 12183 enterOuterAlt(_localctx, 1); 12184 { 12185 setState(1447); 12186 match(START); 12187 setState(1448); 12188 match(HR_HTML_TAG_NAME); 12189 setState(1455); 12190 _errHandler.sync(this); 12191 _la = _input.LA(1); 12192 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12193 { 12194 setState(1453); 12195 _errHandler.sync(this); 12196 switch (_input.LA(1)) { 12197 case HTML_TAG_NAME: 12198 { 12199 setState(1449); 12200 attribute(); 12201 } 12202 break; 12203 case NEWLINE: 12204 { 12205 setState(1450); 12206 match(NEWLINE); 12207 } 12208 break; 12209 case LEADING_ASTERISK: 12210 { 12211 setState(1451); 12212 match(LEADING_ASTERISK); 12213 } 12214 break; 12215 case WS: 12216 { 12217 setState(1452); 12218 match(WS); 12219 } 12220 break; 12221 default: 12222 throw new NoViableAltException(this); 12223 } 12224 } 12225 setState(1457); 12226 _errHandler.sync(this); 12227 _la = _input.LA(1); 12228 } 12229 setState(1458); 12230 _la = _input.LA(1); 12231 if ( !(_la==END || _la==SLASH_END) ) { 12232 _errHandler.recoverInline(this); 12233 } 12234 else { 12235 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12236 _errHandler.reportMatch(this); 12237 consume(); 12238 } 12239 } 12240 } 12241 catch (RecognitionException re) { 12242 _localctx.exception = re; 12243 _errHandler.reportError(this, re); 12244 _errHandler.recover(this, re); 12245 } 12246 finally { 12247 exitRule(); 12248 } 12249 return _localctx; 12250 } 12251 12252 public static class ImgTagContext extends ParserRuleContext { 12253 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 12254 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 12255 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 12256 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 12257 public List<AttributeContext> attribute() { 12258 return getRuleContexts(AttributeContext.class); 12259 } 12260 public AttributeContext attribute(int i) { 12261 return getRuleContext(AttributeContext.class,i); 12262 } 12263 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12264 public TerminalNode NEWLINE(int i) { 12265 return getToken(JavadocParser.NEWLINE, i); 12266 } 12267 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12268 public TerminalNode LEADING_ASTERISK(int i) { 12269 return getToken(JavadocParser.LEADING_ASTERISK, i); 12270 } 12271 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12272 public TerminalNode WS(int i) { 12273 return getToken(JavadocParser.WS, i); 12274 } 12275 public ImgTagContext(ParserRuleContext parent, int invokingState) { 12276 super(parent, invokingState); 12277 } 12278 @Override public int getRuleIndex() { return RULE_imgTag; } 12279 } 12280 12281 public final ImgTagContext imgTag() throws RecognitionException { 12282 ImgTagContext _localctx = new ImgTagContext(_ctx, getState()); 12283 enterRule(_localctx, 120, RULE_imgTag); 12284 int _la; 12285 try { 12286 enterOuterAlt(_localctx, 1); 12287 { 12288 setState(1460); 12289 match(START); 12290 setState(1461); 12291 match(IMG_HTML_TAG_NAME); 12292 setState(1468); 12293 _errHandler.sync(this); 12294 _la = _input.LA(1); 12295 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12296 { 12297 setState(1466); 12298 _errHandler.sync(this); 12299 switch (_input.LA(1)) { 12300 case HTML_TAG_NAME: 12301 { 12302 setState(1462); 12303 attribute(); 12304 } 12305 break; 12306 case NEWLINE: 12307 { 12308 setState(1463); 12309 match(NEWLINE); 12310 } 12311 break; 12312 case LEADING_ASTERISK: 12313 { 12314 setState(1464); 12315 match(LEADING_ASTERISK); 12316 } 12317 break; 12318 case WS: 12319 { 12320 setState(1465); 12321 match(WS); 12322 } 12323 break; 12324 default: 12325 throw new NoViableAltException(this); 12326 } 12327 } 12328 setState(1470); 12329 _errHandler.sync(this); 12330 _la = _input.LA(1); 12331 } 12332 setState(1471); 12333 _la = _input.LA(1); 12334 if ( !(_la==END || _la==SLASH_END) ) { 12335 _errHandler.recoverInline(this); 12336 } 12337 else { 12338 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12339 _errHandler.reportMatch(this); 12340 consume(); 12341 } 12342 } 12343 } 12344 catch (RecognitionException re) { 12345 _localctx.exception = re; 12346 _errHandler.reportError(this, re); 12347 _errHandler.recover(this, re); 12348 } 12349 finally { 12350 exitRule(); 12351 } 12352 return _localctx; 12353 } 12354 12355 public static class InputTagContext extends ParserRuleContext { 12356 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 12357 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 12358 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 12359 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 12360 public List<AttributeContext> attribute() { 12361 return getRuleContexts(AttributeContext.class); 12362 } 12363 public AttributeContext attribute(int i) { 12364 return getRuleContext(AttributeContext.class,i); 12365 } 12366 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12367 public TerminalNode NEWLINE(int i) { 12368 return getToken(JavadocParser.NEWLINE, i); 12369 } 12370 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12371 public TerminalNode LEADING_ASTERISK(int i) { 12372 return getToken(JavadocParser.LEADING_ASTERISK, i); 12373 } 12374 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12375 public TerminalNode WS(int i) { 12376 return getToken(JavadocParser.WS, i); 12377 } 12378 public InputTagContext(ParserRuleContext parent, int invokingState) { 12379 super(parent, invokingState); 12380 } 12381 @Override public int getRuleIndex() { return RULE_inputTag; } 12382 } 12383 12384 public final InputTagContext inputTag() throws RecognitionException { 12385 InputTagContext _localctx = new InputTagContext(_ctx, getState()); 12386 enterRule(_localctx, 122, RULE_inputTag); 12387 int _la; 12388 try { 12389 enterOuterAlt(_localctx, 1); 12390 { 12391 setState(1473); 12392 match(START); 12393 setState(1474); 12394 match(INPUT_HTML_TAG_NAME); 12395 setState(1481); 12396 _errHandler.sync(this); 12397 _la = _input.LA(1); 12398 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12399 { 12400 setState(1479); 12401 _errHandler.sync(this); 12402 switch (_input.LA(1)) { 12403 case HTML_TAG_NAME: 12404 { 12405 setState(1475); 12406 attribute(); 12407 } 12408 break; 12409 case NEWLINE: 12410 { 12411 setState(1476); 12412 match(NEWLINE); 12413 } 12414 break; 12415 case LEADING_ASTERISK: 12416 { 12417 setState(1477); 12418 match(LEADING_ASTERISK); 12419 } 12420 break; 12421 case WS: 12422 { 12423 setState(1478); 12424 match(WS); 12425 } 12426 break; 12427 default: 12428 throw new NoViableAltException(this); 12429 } 12430 } 12431 setState(1483); 12432 _errHandler.sync(this); 12433 _la = _input.LA(1); 12434 } 12435 setState(1484); 12436 _la = _input.LA(1); 12437 if ( !(_la==END || _la==SLASH_END) ) { 12438 _errHandler.recoverInline(this); 12439 } 12440 else { 12441 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12442 _errHandler.reportMatch(this); 12443 consume(); 12444 } 12445 } 12446 } 12447 catch (RecognitionException re) { 12448 _localctx.exception = re; 12449 _errHandler.reportError(this, re); 12450 _errHandler.recover(this, re); 12451 } 12452 finally { 12453 exitRule(); 12454 } 12455 return _localctx; 12456 } 12457 12458 public static class IsindexTagContext extends ParserRuleContext { 12459 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 12460 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 12461 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 12462 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 12463 public List<AttributeContext> attribute() { 12464 return getRuleContexts(AttributeContext.class); 12465 } 12466 public AttributeContext attribute(int i) { 12467 return getRuleContext(AttributeContext.class,i); 12468 } 12469 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12470 public TerminalNode NEWLINE(int i) { 12471 return getToken(JavadocParser.NEWLINE, i); 12472 } 12473 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12474 public TerminalNode LEADING_ASTERISK(int i) { 12475 return getToken(JavadocParser.LEADING_ASTERISK, i); 12476 } 12477 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12478 public TerminalNode WS(int i) { 12479 return getToken(JavadocParser.WS, i); 12480 } 12481 public IsindexTagContext(ParserRuleContext parent, int invokingState) { 12482 super(parent, invokingState); 12483 } 12484 @Override public int getRuleIndex() { return RULE_isindexTag; } 12485 } 12486 12487 public final IsindexTagContext isindexTag() throws RecognitionException { 12488 IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState()); 12489 enterRule(_localctx, 124, RULE_isindexTag); 12490 int _la; 12491 try { 12492 enterOuterAlt(_localctx, 1); 12493 { 12494 setState(1486); 12495 match(START); 12496 setState(1487); 12497 match(ISINDEX_HTML_TAG_NAME); 12498 setState(1494); 12499 _errHandler.sync(this); 12500 _la = _input.LA(1); 12501 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12502 { 12503 setState(1492); 12504 _errHandler.sync(this); 12505 switch (_input.LA(1)) { 12506 case HTML_TAG_NAME: 12507 { 12508 setState(1488); 12509 attribute(); 12510 } 12511 break; 12512 case NEWLINE: 12513 { 12514 setState(1489); 12515 match(NEWLINE); 12516 } 12517 break; 12518 case LEADING_ASTERISK: 12519 { 12520 setState(1490); 12521 match(LEADING_ASTERISK); 12522 } 12523 break; 12524 case WS: 12525 { 12526 setState(1491); 12527 match(WS); 12528 } 12529 break; 12530 default: 12531 throw new NoViableAltException(this); 12532 } 12533 } 12534 setState(1496); 12535 _errHandler.sync(this); 12536 _la = _input.LA(1); 12537 } 12538 setState(1497); 12539 _la = _input.LA(1); 12540 if ( !(_la==END || _la==SLASH_END) ) { 12541 _errHandler.recoverInline(this); 12542 } 12543 else { 12544 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12545 _errHandler.reportMatch(this); 12546 consume(); 12547 } 12548 } 12549 } 12550 catch (RecognitionException re) { 12551 _localctx.exception = re; 12552 _errHandler.reportError(this, re); 12553 _errHandler.recover(this, re); 12554 } 12555 finally { 12556 exitRule(); 12557 } 12558 return _localctx; 12559 } 12560 12561 public static class LinkTagContext extends ParserRuleContext { 12562 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 12563 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 12564 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 12565 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 12566 public List<AttributeContext> attribute() { 12567 return getRuleContexts(AttributeContext.class); 12568 } 12569 public AttributeContext attribute(int i) { 12570 return getRuleContext(AttributeContext.class,i); 12571 } 12572 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12573 public TerminalNode NEWLINE(int i) { 12574 return getToken(JavadocParser.NEWLINE, i); 12575 } 12576 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12577 public TerminalNode LEADING_ASTERISK(int i) { 12578 return getToken(JavadocParser.LEADING_ASTERISK, i); 12579 } 12580 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12581 public TerminalNode WS(int i) { 12582 return getToken(JavadocParser.WS, i); 12583 } 12584 public LinkTagContext(ParserRuleContext parent, int invokingState) { 12585 super(parent, invokingState); 12586 } 12587 @Override public int getRuleIndex() { return RULE_linkTag; } 12588 } 12589 12590 public final LinkTagContext linkTag() throws RecognitionException { 12591 LinkTagContext _localctx = new LinkTagContext(_ctx, getState()); 12592 enterRule(_localctx, 126, RULE_linkTag); 12593 int _la; 12594 try { 12595 enterOuterAlt(_localctx, 1); 12596 { 12597 setState(1499); 12598 match(START); 12599 setState(1500); 12600 match(LINK_HTML_TAG_NAME); 12601 setState(1507); 12602 _errHandler.sync(this); 12603 _la = _input.LA(1); 12604 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12605 { 12606 setState(1505); 12607 _errHandler.sync(this); 12608 switch (_input.LA(1)) { 12609 case HTML_TAG_NAME: 12610 { 12611 setState(1501); 12612 attribute(); 12613 } 12614 break; 12615 case NEWLINE: 12616 { 12617 setState(1502); 12618 match(NEWLINE); 12619 } 12620 break; 12621 case LEADING_ASTERISK: 12622 { 12623 setState(1503); 12624 match(LEADING_ASTERISK); 12625 } 12626 break; 12627 case WS: 12628 { 12629 setState(1504); 12630 match(WS); 12631 } 12632 break; 12633 default: 12634 throw new NoViableAltException(this); 12635 } 12636 } 12637 setState(1509); 12638 _errHandler.sync(this); 12639 _la = _input.LA(1); 12640 } 12641 setState(1510); 12642 _la = _input.LA(1); 12643 if ( !(_la==END || _la==SLASH_END) ) { 12644 _errHandler.recoverInline(this); 12645 } 12646 else { 12647 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12648 _errHandler.reportMatch(this); 12649 consume(); 12650 } 12651 } 12652 } 12653 catch (RecognitionException re) { 12654 _localctx.exception = re; 12655 _errHandler.reportError(this, re); 12656 _errHandler.recover(this, re); 12657 } 12658 finally { 12659 exitRule(); 12660 } 12661 return _localctx; 12662 } 12663 12664 public static class MetaTagContext extends ParserRuleContext { 12665 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 12666 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 12667 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 12668 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 12669 public List<AttributeContext> attribute() { 12670 return getRuleContexts(AttributeContext.class); 12671 } 12672 public AttributeContext attribute(int i) { 12673 return getRuleContext(AttributeContext.class,i); 12674 } 12675 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12676 public TerminalNode NEWLINE(int i) { 12677 return getToken(JavadocParser.NEWLINE, i); 12678 } 12679 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12680 public TerminalNode LEADING_ASTERISK(int i) { 12681 return getToken(JavadocParser.LEADING_ASTERISK, i); 12682 } 12683 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12684 public TerminalNode WS(int i) { 12685 return getToken(JavadocParser.WS, i); 12686 } 12687 public MetaTagContext(ParserRuleContext parent, int invokingState) { 12688 super(parent, invokingState); 12689 } 12690 @Override public int getRuleIndex() { return RULE_metaTag; } 12691 } 12692 12693 public final MetaTagContext metaTag() throws RecognitionException { 12694 MetaTagContext _localctx = new MetaTagContext(_ctx, getState()); 12695 enterRule(_localctx, 128, RULE_metaTag); 12696 int _la; 12697 try { 12698 enterOuterAlt(_localctx, 1); 12699 { 12700 setState(1512); 12701 match(START); 12702 setState(1513); 12703 match(META_HTML_TAG_NAME); 12704 setState(1520); 12705 _errHandler.sync(this); 12706 _la = _input.LA(1); 12707 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12708 { 12709 setState(1518); 12710 _errHandler.sync(this); 12711 switch (_input.LA(1)) { 12712 case HTML_TAG_NAME: 12713 { 12714 setState(1514); 12715 attribute(); 12716 } 12717 break; 12718 case NEWLINE: 12719 { 12720 setState(1515); 12721 match(NEWLINE); 12722 } 12723 break; 12724 case LEADING_ASTERISK: 12725 { 12726 setState(1516); 12727 match(LEADING_ASTERISK); 12728 } 12729 break; 12730 case WS: 12731 { 12732 setState(1517); 12733 match(WS); 12734 } 12735 break; 12736 default: 12737 throw new NoViableAltException(this); 12738 } 12739 } 12740 setState(1522); 12741 _errHandler.sync(this); 12742 _la = _input.LA(1); 12743 } 12744 setState(1523); 12745 _la = _input.LA(1); 12746 if ( !(_la==END || _la==SLASH_END) ) { 12747 _errHandler.recoverInline(this); 12748 } 12749 else { 12750 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12751 _errHandler.reportMatch(this); 12752 consume(); 12753 } 12754 } 12755 } 12756 catch (RecognitionException re) { 12757 _localctx.exception = re; 12758 _errHandler.reportError(this, re); 12759 _errHandler.recover(this, re); 12760 } 12761 finally { 12762 exitRule(); 12763 } 12764 return _localctx; 12765 } 12766 12767 public static class ParamTagContext extends ParserRuleContext { 12768 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 12769 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 12770 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 12771 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 12772 public List<AttributeContext> attribute() { 12773 return getRuleContexts(AttributeContext.class); 12774 } 12775 public AttributeContext attribute(int i) { 12776 return getRuleContext(AttributeContext.class,i); 12777 } 12778 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12779 public TerminalNode NEWLINE(int i) { 12780 return getToken(JavadocParser.NEWLINE, i); 12781 } 12782 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12783 public TerminalNode LEADING_ASTERISK(int i) { 12784 return getToken(JavadocParser.LEADING_ASTERISK, i); 12785 } 12786 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12787 public TerminalNode WS(int i) { 12788 return getToken(JavadocParser.WS, i); 12789 } 12790 public ParamTagContext(ParserRuleContext parent, int invokingState) { 12791 super(parent, invokingState); 12792 } 12793 @Override public int getRuleIndex() { return RULE_paramTag; } 12794 } 12795 12796 public final ParamTagContext paramTag() throws RecognitionException { 12797 ParamTagContext _localctx = new ParamTagContext(_ctx, getState()); 12798 enterRule(_localctx, 130, RULE_paramTag); 12799 int _la; 12800 try { 12801 enterOuterAlt(_localctx, 1); 12802 { 12803 setState(1525); 12804 match(START); 12805 setState(1526); 12806 match(PARAM_HTML_TAG_NAME); 12807 setState(1533); 12808 _errHandler.sync(this); 12809 _la = _input.LA(1); 12810 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12811 { 12812 setState(1531); 12813 _errHandler.sync(this); 12814 switch (_input.LA(1)) { 12815 case HTML_TAG_NAME: 12816 { 12817 setState(1527); 12818 attribute(); 12819 } 12820 break; 12821 case NEWLINE: 12822 { 12823 setState(1528); 12824 match(NEWLINE); 12825 } 12826 break; 12827 case LEADING_ASTERISK: 12828 { 12829 setState(1529); 12830 match(LEADING_ASTERISK); 12831 } 12832 break; 12833 case WS: 12834 { 12835 setState(1530); 12836 match(WS); 12837 } 12838 break; 12839 default: 12840 throw new NoViableAltException(this); 12841 } 12842 } 12843 setState(1535); 12844 _errHandler.sync(this); 12845 _la = _input.LA(1); 12846 } 12847 setState(1536); 12848 _la = _input.LA(1); 12849 if ( !(_la==END || _la==SLASH_END) ) { 12850 _errHandler.recoverInline(this); 12851 } 12852 else { 12853 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12854 _errHandler.reportMatch(this); 12855 consume(); 12856 } 12857 } 12858 } 12859 catch (RecognitionException re) { 12860 _localctx.exception = re; 12861 _errHandler.reportError(this, re); 12862 _errHandler.recover(this, re); 12863 } 12864 finally { 12865 exitRule(); 12866 } 12867 return _localctx; 12868 } 12869 12870 public static class WrongSinletonTagContext extends ParserRuleContext { 12871 public SingletonTagNameContext singletonTagName; 12872 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 12873 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 12874 public SingletonTagNameContext singletonTagName() { 12875 return getRuleContext(SingletonTagNameContext.class,0); 12876 } 12877 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 12878 public WrongSinletonTagContext(ParserRuleContext parent, int invokingState) { 12879 super(parent, invokingState); 12880 } 12881 @Override public int getRuleIndex() { return RULE_wrongSinletonTag; } 12882 } 12883 12884 public final WrongSinletonTagContext wrongSinletonTag() throws RecognitionException { 12885 WrongSinletonTagContext _localctx = new WrongSinletonTagContext(_ctx, getState()); 12886 enterRule(_localctx, 132, RULE_wrongSinletonTag); 12887 try { 12888 enterOuterAlt(_localctx, 1); 12889 { 12890 setState(1538); 12891 match(START); 12892 setState(1539); 12893 match(SLASH); 12894 setState(1540); 12895 ((WrongSinletonTagContext)_localctx).singletonTagName = singletonTagName(); 12896 setState(1541); 12897 match(END); 12898 notifyErrorListeners((((WrongSinletonTagContext)_localctx).singletonTagName!=null?(((WrongSinletonTagContext)_localctx).singletonTagName.start):null), 12899 "javadoc.wrong.singleton.html.tag", null); 12900 } 12901 } 12902 catch (RecognitionException re) { 12903 _localctx.exception = re; 12904 _errHandler.reportError(this, re); 12905 _errHandler.recover(this, re); 12906 } 12907 finally { 12908 exitRule(); 12909 } 12910 return _localctx; 12911 } 12912 12913 public static class SingletonTagNameContext extends ParserRuleContext { 12914 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 12915 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 12916 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 12917 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 12918 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 12919 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 12920 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 12921 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 12922 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 12923 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 12924 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 12925 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 12926 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 12927 public TerminalNode EMBED_HTML_TAG_NAME() { return getToken(JavadocParser.EMBED_HTML_TAG_NAME, 0); } 12928 public TerminalNode KEYGEN_HTML_TAG_NAME() { return getToken(JavadocParser.KEYGEN_HTML_TAG_NAME, 0); } 12929 public TerminalNode SOURCE_HTML_TAG_NAME() { return getToken(JavadocParser.SOURCE_HTML_TAG_NAME, 0); } 12930 public TerminalNode TRACK_HTML_TAG_NAME() { return getToken(JavadocParser.TRACK_HTML_TAG_NAME, 0); } 12931 public TerminalNode WBR_HTML_TAG_NAME() { return getToken(JavadocParser.WBR_HTML_TAG_NAME, 0); } 12932 public SingletonTagNameContext(ParserRuleContext parent, int invokingState) { 12933 super(parent, invokingState); 12934 } 12935 @Override public int getRuleIndex() { return RULE_singletonTagName; } 12936 } 12937 12938 public final SingletonTagNameContext singletonTagName() throws RecognitionException { 12939 SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState()); 12940 enterRule(_localctx, 134, RULE_singletonTagName); 12941 int _la; 12942 try { 12943 enterOuterAlt(_localctx, 1); 12944 { 12945 setState(1544); 12946 _la = _input.LA(1); 12947 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)) ) { 12948 _errHandler.recoverInline(this); 12949 } 12950 else { 12951 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12952 _errHandler.reportMatch(this); 12953 consume(); 12954 } 12955 } 12956 } 12957 catch (RecognitionException re) { 12958 _localctx.exception = re; 12959 _errHandler.reportError(this, re); 12960 _errHandler.recover(this, re); 12961 } 12962 finally { 12963 exitRule(); 12964 } 12965 return _localctx; 12966 } 12967 12968 public static class DescriptionContext extends ParserRuleContext { 12969 public List<HtmlCommentContext> htmlComment() { 12970 return getRuleContexts(HtmlCommentContext.class); 12971 } 12972 public HtmlCommentContext htmlComment(int i) { 12973 return getRuleContext(HtmlCommentContext.class,i); 12974 } 12975 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 12976 public TerminalNode CDATA(int i) { 12977 return getToken(JavadocParser.CDATA, i); 12978 } 12979 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12980 public TerminalNode NEWLINE(int i) { 12981 return getToken(JavadocParser.NEWLINE, i); 12982 } 12983 public List<TextContext> text() { 12984 return getRuleContexts(TextContext.class); 12985 } 12986 public TextContext text(int i) { 12987 return getRuleContext(TextContext.class,i); 12988 } 12989 public List<JavadocInlineTagContext> javadocInlineTag() { 12990 return getRuleContexts(JavadocInlineTagContext.class); 12991 } 12992 public JavadocInlineTagContext javadocInlineTag(int i) { 12993 return getRuleContext(JavadocInlineTagContext.class,i); 12994 } 12995 public List<HtmlElementContext> htmlElement() { 12996 return getRuleContexts(HtmlElementContext.class); 12997 } 12998 public HtmlElementContext htmlElement(int i) { 12999 return getRuleContext(HtmlElementContext.class,i); 13000 } 13001 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13002 public TerminalNode LEADING_ASTERISK(int i) { 13003 return getToken(JavadocParser.LEADING_ASTERISK, i); 13004 } 13005 public DescriptionContext(ParserRuleContext parent, int invokingState) { 13006 super(parent, invokingState); 13007 } 13008 @Override public int getRuleIndex() { return RULE_description; } 13009 } 13010 13011 public final DescriptionContext description() throws RecognitionException { 13012 DescriptionContext _localctx = new DescriptionContext(_ctx, getState()); 13013 enterRule(_localctx, 136, RULE_description); 13014 try { 13015 int _alt; 13016 enterOuterAlt(_localctx, 1); 13017 { 13018 setState(1554); 13019 _errHandler.sync(this); 13020 _alt = 1; 13021 do { 13022 switch (_alt) { 13023 case 1: 13024 { 13025 setState(1554); 13026 _errHandler.sync(this); 13027 switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) { 13028 case 1: 13029 { 13030 { 13031 setState(1546); 13032 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 13033 setState(1547); 13034 match(LEADING_ASTERISK); 13035 } 13036 } 13037 break; 13038 case 2: 13039 { 13040 setState(1548); 13041 htmlComment(); 13042 } 13043 break; 13044 case 3: 13045 { 13046 setState(1549); 13047 match(CDATA); 13048 } 13049 break; 13050 case 4: 13051 { 13052 setState(1550); 13053 match(NEWLINE); 13054 } 13055 break; 13056 case 5: 13057 { 13058 setState(1551); 13059 text(); 13060 } 13061 break; 13062 case 6: 13063 { 13064 setState(1552); 13065 javadocInlineTag(); 13066 } 13067 break; 13068 case 7: 13069 { 13070 setState(1553); 13071 htmlElement(); 13072 } 13073 break; 13074 } 13075 } 13076 break; 13077 default: 13078 throw new NoViableAltException(this); 13079 } 13080 setState(1556); 13081 _errHandler.sync(this); 13082 _alt = getInterpreter().adaptivePredict(_input,119,_ctx); 13083 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13084 } 13085 } 13086 catch (RecognitionException re) { 13087 _localctx.exception = re; 13088 _errHandler.reportError(this, re); 13089 _errHandler.recover(this, re); 13090 } 13091 finally { 13092 exitRule(); 13093 } 13094 return _localctx; 13095 } 13096 13097 public static class ReferenceContext extends ParserRuleContext { 13098 public TerminalNode PACKAGE_CLASS() { return getToken(JavadocParser.PACKAGE_CLASS, 0); } 13099 public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); } 13100 public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); } 13101 public ParametersContext parameters() { 13102 return getRuleContext(ParametersContext.class,0); 13103 } 13104 public ReferenceContext(ParserRuleContext parent, int invokingState) { 13105 super(parent, invokingState); 13106 } 13107 @Override public int getRuleIndex() { return RULE_reference; } 13108 } 13109 13110 public final ReferenceContext reference() throws RecognitionException { 13111 ReferenceContext _localctx = new ReferenceContext(_ctx, getState()); 13112 enterRule(_localctx, 138, RULE_reference); 13113 int _la; 13114 try { 13115 setState(1571); 13116 _errHandler.sync(this); 13117 switch (_input.LA(1)) { 13118 case PACKAGE_CLASS: 13119 enterOuterAlt(_localctx, 1); 13120 { 13121 setState(1558); 13122 match(PACKAGE_CLASS); 13123 setState(1564); 13124 _errHandler.sync(this); 13125 _la = _input.LA(1); 13126 if (_la==HASH) { 13127 { 13128 setState(1559); 13129 match(HASH); 13130 setState(1560); 13131 match(MEMBER); 13132 setState(1562); 13133 _errHandler.sync(this); 13134 _la = _input.LA(1); 13135 if (_la==LEFT_BRACE) { 13136 { 13137 setState(1561); 13138 parameters(); 13139 } 13140 } 13141 13142 } 13143 } 13144 13145 } 13146 break; 13147 case HASH: 13148 enterOuterAlt(_localctx, 2); 13149 { 13150 setState(1566); 13151 match(HASH); 13152 setState(1567); 13153 match(MEMBER); 13154 setState(1569); 13155 _errHandler.sync(this); 13156 _la = _input.LA(1); 13157 if (_la==LEFT_BRACE) { 13158 { 13159 setState(1568); 13160 parameters(); 13161 } 13162 } 13163 13164 } 13165 break; 13166 default: 13167 throw new NoViableAltException(this); 13168 } 13169 } 13170 catch (RecognitionException re) { 13171 _localctx.exception = re; 13172 _errHandler.reportError(this, re); 13173 _errHandler.recover(this, re); 13174 } 13175 finally { 13176 exitRule(); 13177 } 13178 return _localctx; 13179 } 13180 13181 public static class ParametersContext extends ParserRuleContext { 13182 public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); } 13183 public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); } 13184 public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); } 13185 public TerminalNode ARGUMENT(int i) { 13186 return getToken(JavadocParser.ARGUMENT, i); 13187 } 13188 public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); } 13189 public TerminalNode COMMA(int i) { 13190 return getToken(JavadocParser.COMMA, i); 13191 } 13192 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13193 public TerminalNode WS(int i) { 13194 return getToken(JavadocParser.WS, i); 13195 } 13196 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13197 public TerminalNode NEWLINE(int i) { 13198 return getToken(JavadocParser.NEWLINE, i); 13199 } 13200 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13201 public TerminalNode LEADING_ASTERISK(int i) { 13202 return getToken(JavadocParser.LEADING_ASTERISK, i); 13203 } 13204 public ParametersContext(ParserRuleContext parent, int invokingState) { 13205 super(parent, invokingState); 13206 } 13207 @Override public int getRuleIndex() { return RULE_parameters; } 13208 } 13209 13210 public final ParametersContext parameters() throws RecognitionException { 13211 ParametersContext _localctx = new ParametersContext(_ctx, getState()); 13212 enterRule(_localctx, 140, RULE_parameters); 13213 int _la; 13214 try { 13215 enterOuterAlt(_localctx, 1); 13216 { 13217 setState(1573); 13218 match(LEFT_BRACE); 13219 setState(1577); 13220 _errHandler.sync(this); 13221 _la = _input.LA(1); 13222 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) { 13223 { 13224 { 13225 setState(1574); 13226 _la = _input.LA(1); 13227 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) { 13228 _errHandler.recoverInline(this); 13229 } 13230 else { 13231 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13232 _errHandler.reportMatch(this); 13233 consume(); 13234 } 13235 } 13236 } 13237 setState(1579); 13238 _errHandler.sync(this); 13239 _la = _input.LA(1); 13240 } 13241 setState(1580); 13242 match(RIGHT_BRACE); 13243 } 13244 } 13245 catch (RecognitionException re) { 13246 _localctx.exception = re; 13247 _errHandler.reportError(this, re); 13248 _errHandler.recover(this, re); 13249 } 13250 finally { 13251 exitRule(); 13252 } 13253 return _localctx; 13254 } 13255 13256 public static class JavadocTagContext extends ParserRuleContext { 13257 public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); } 13258 public DescriptionContext description() { 13259 return getRuleContext(DescriptionContext.class,0); 13260 } 13261 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13262 public TerminalNode WS(int i) { 13263 return getToken(JavadocParser.WS, i); 13264 } 13265 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13266 public TerminalNode NEWLINE(int i) { 13267 return getToken(JavadocParser.NEWLINE, i); 13268 } 13269 public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); } 13270 public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); } 13271 public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); } 13272 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13273 public TerminalNode LEADING_ASTERISK(int i) { 13274 return getToken(JavadocParser.LEADING_ASTERISK, i); 13275 } 13276 public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); } 13277 public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); } 13278 public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); } 13279 public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); } 13280 public ReferenceContext reference() { 13281 return getRuleContext(ReferenceContext.class,0); 13282 } 13283 public TerminalNode STRING() { return getToken(JavadocParser.STRING, 0); } 13284 public HtmlElementContext htmlElement() { 13285 return getRuleContext(HtmlElementContext.class,0); 13286 } 13287 public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); } 13288 public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); } 13289 public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); } 13290 public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); } 13291 public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); } 13292 public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); } 13293 public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); } 13294 public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); } 13295 public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); } 13296 public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); } 13297 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 13298 public JavadocTagContext(ParserRuleContext parent, int invokingState) { 13299 super(parent, invokingState); 13300 } 13301 @Override public int getRuleIndex() { return RULE_javadocTag; } 13302 } 13303 13304 public final JavadocTagContext javadocTag() throws RecognitionException { 13305 JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState()); 13306 enterRule(_localctx, 142, RULE_javadocTag); 13307 int _la; 13308 try { 13309 int _alt; 13310 setState(1777); 13311 _errHandler.sync(this); 13312 switch (_input.LA(1)) { 13313 case AUTHOR_LITERAL: 13314 enterOuterAlt(_localctx, 1); 13315 { 13316 setState(1582); 13317 match(AUTHOR_LITERAL); 13318 setState(1584); 13319 _errHandler.sync(this); 13320 _alt = 1; 13321 do { 13322 switch (_alt) { 13323 case 1: 13324 { 13325 { 13326 setState(1583); 13327 _la = _input.LA(1); 13328 if ( !(_la==WS || _la==NEWLINE) ) { 13329 _errHandler.recoverInline(this); 13330 } 13331 else { 13332 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13333 _errHandler.reportMatch(this); 13334 consume(); 13335 } 13336 } 13337 } 13338 break; 13339 default: 13340 throw new NoViableAltException(this); 13341 } 13342 setState(1586); 13343 _errHandler.sync(this); 13344 _alt = getInterpreter().adaptivePredict(_input,125,_ctx); 13345 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13346 setState(1588); 13347 description(); 13348 } 13349 break; 13350 case DEPRECATED_LITERAL: 13351 enterOuterAlt(_localctx, 2); 13352 { 13353 setState(1589); 13354 match(DEPRECATED_LITERAL); 13355 setState(1593); 13356 _errHandler.sync(this); 13357 _alt = getInterpreter().adaptivePredict(_input,126,_ctx); 13358 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13359 if ( _alt==1 ) { 13360 { 13361 { 13362 setState(1590); 13363 _la = _input.LA(1); 13364 if ( !(_la==WS || _la==NEWLINE) ) { 13365 _errHandler.recoverInline(this); 13366 } 13367 else { 13368 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13369 _errHandler.reportMatch(this); 13370 consume(); 13371 } 13372 } 13373 } 13374 } 13375 setState(1595); 13376 _errHandler.sync(this); 13377 _alt = getInterpreter().adaptivePredict(_input,126,_ctx); 13378 } 13379 setState(1598); 13380 _errHandler.sync(this); 13381 switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) { 13382 case 1: 13383 { 13384 setState(1596); 13385 _la = _input.LA(1); 13386 if ( !(_la==WS || _la==NEWLINE) ) { 13387 _errHandler.recoverInline(this); 13388 } 13389 else { 13390 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13391 _errHandler.reportMatch(this); 13392 consume(); 13393 } 13394 setState(1597); 13395 description(); 13396 } 13397 break; 13398 } 13399 } 13400 break; 13401 case EXCEPTION_LITERAL: 13402 enterOuterAlt(_localctx, 3); 13403 { 13404 setState(1600); 13405 match(EXCEPTION_LITERAL); 13406 setState(1605); 13407 _errHandler.sync(this); 13408 _alt = 1; 13409 do { 13410 switch (_alt) { 13411 case 1: 13412 { 13413 setState(1605); 13414 _errHandler.sync(this); 13415 switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { 13416 case 1: 13417 { 13418 setState(1601); 13419 match(WS); 13420 } 13421 break; 13422 case 2: 13423 { 13424 setState(1602); 13425 match(NEWLINE); 13426 } 13427 break; 13428 case 3: 13429 { 13430 setState(1603); 13431 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 13432 setState(1604); 13433 match(LEADING_ASTERISK); 13434 } 13435 break; 13436 } 13437 } 13438 break; 13439 default: 13440 throw new NoViableAltException(this); 13441 } 13442 setState(1607); 13443 _errHandler.sync(this); 13444 _alt = getInterpreter().adaptivePredict(_input,129,_ctx); 13445 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13446 setState(1609); 13447 match(CLASS_NAME); 13448 setState(1613); 13449 _errHandler.sync(this); 13450 _alt = getInterpreter().adaptivePredict(_input,130,_ctx); 13451 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13452 if ( _alt==1 ) { 13453 { 13454 { 13455 setState(1610); 13456 _la = _input.LA(1); 13457 if ( !(_la==WS || _la==NEWLINE) ) { 13458 _errHandler.recoverInline(this); 13459 } 13460 else { 13461 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13462 _errHandler.reportMatch(this); 13463 consume(); 13464 } 13465 } 13466 } 13467 } 13468 setState(1615); 13469 _errHandler.sync(this); 13470 _alt = getInterpreter().adaptivePredict(_input,130,_ctx); 13471 } 13472 setState(1618); 13473 _errHandler.sync(this); 13474 switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { 13475 case 1: 13476 { 13477 setState(1616); 13478 _la = _input.LA(1); 13479 if ( !(_la==WS || _la==NEWLINE) ) { 13480 _errHandler.recoverInline(this); 13481 } 13482 else { 13483 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13484 _errHandler.reportMatch(this); 13485 consume(); 13486 } 13487 setState(1617); 13488 description(); 13489 } 13490 break; 13491 } 13492 } 13493 break; 13494 case PARAM_LITERAL: 13495 enterOuterAlt(_localctx, 4); 13496 { 13497 setState(1620); 13498 match(PARAM_LITERAL); 13499 setState(1625); 13500 _errHandler.sync(this); 13501 _alt = 1; 13502 do { 13503 switch (_alt) { 13504 case 1: 13505 { 13506 setState(1625); 13507 _errHandler.sync(this); 13508 switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { 13509 case 1: 13510 { 13511 setState(1621); 13512 match(WS); 13513 } 13514 break; 13515 case 2: 13516 { 13517 setState(1622); 13518 match(NEWLINE); 13519 } 13520 break; 13521 case 3: 13522 { 13523 setState(1623); 13524 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 13525 setState(1624); 13526 match(LEADING_ASTERISK); 13527 } 13528 break; 13529 } 13530 } 13531 break; 13532 default: 13533 throw new NoViableAltException(this); 13534 } 13535 setState(1627); 13536 _errHandler.sync(this); 13537 _alt = getInterpreter().adaptivePredict(_input,133,_ctx); 13538 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13539 setState(1629); 13540 match(PARAMETER_NAME); 13541 setState(1633); 13542 _errHandler.sync(this); 13543 _alt = getInterpreter().adaptivePredict(_input,134,_ctx); 13544 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13545 if ( _alt==1 ) { 13546 { 13547 { 13548 setState(1630); 13549 _la = _input.LA(1); 13550 if ( !(_la==WS || _la==NEWLINE) ) { 13551 _errHandler.recoverInline(this); 13552 } 13553 else { 13554 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13555 _errHandler.reportMatch(this); 13556 consume(); 13557 } 13558 } 13559 } 13560 } 13561 setState(1635); 13562 _errHandler.sync(this); 13563 _alt = getInterpreter().adaptivePredict(_input,134,_ctx); 13564 } 13565 setState(1638); 13566 _errHandler.sync(this); 13567 switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) { 13568 case 1: 13569 { 13570 setState(1636); 13571 _la = _input.LA(1); 13572 if ( !(_la==WS || _la==NEWLINE) ) { 13573 _errHandler.recoverInline(this); 13574 } 13575 else { 13576 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13577 _errHandler.reportMatch(this); 13578 consume(); 13579 } 13580 setState(1637); 13581 description(); 13582 } 13583 break; 13584 } 13585 } 13586 break; 13587 case RETURN_LITERAL: 13588 enterOuterAlt(_localctx, 5); 13589 { 13590 setState(1640); 13591 match(RETURN_LITERAL); 13592 setState(1642); 13593 _errHandler.sync(this); 13594 _alt = 1; 13595 do { 13596 switch (_alt) { 13597 case 1: 13598 { 13599 { 13600 setState(1641); 13601 _la = _input.LA(1); 13602 if ( !(_la==WS || _la==NEWLINE) ) { 13603 _errHandler.recoverInline(this); 13604 } 13605 else { 13606 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13607 _errHandler.reportMatch(this); 13608 consume(); 13609 } 13610 } 13611 } 13612 break; 13613 default: 13614 throw new NoViableAltException(this); 13615 } 13616 setState(1644); 13617 _errHandler.sync(this); 13618 _alt = getInterpreter().adaptivePredict(_input,136,_ctx); 13619 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13620 setState(1646); 13621 description(); 13622 } 13623 break; 13624 case SEE_LITERAL: 13625 enterOuterAlt(_localctx, 6); 13626 { 13627 setState(1647); 13628 match(SEE_LITERAL); 13629 setState(1652); 13630 _errHandler.sync(this); 13631 _alt = 1; 13632 do { 13633 switch (_alt) { 13634 case 1: 13635 { 13636 setState(1652); 13637 _errHandler.sync(this); 13638 switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) { 13639 case 1: 13640 { 13641 setState(1648); 13642 match(WS); 13643 } 13644 break; 13645 case 2: 13646 { 13647 setState(1649); 13648 match(NEWLINE); 13649 } 13650 break; 13651 case 3: 13652 { 13653 setState(1650); 13654 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 13655 setState(1651); 13656 match(LEADING_ASTERISK); 13657 } 13658 break; 13659 } 13660 } 13661 break; 13662 default: 13663 throw new NoViableAltException(this); 13664 } 13665 setState(1654); 13666 _errHandler.sync(this); 13667 _alt = getInterpreter().adaptivePredict(_input,138,_ctx); 13668 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13669 setState(1659); 13670 _errHandler.sync(this); 13671 switch (_input.LA(1)) { 13672 case PACKAGE_CLASS: 13673 case HASH: 13674 { 13675 setState(1656); 13676 reference(); 13677 } 13678 break; 13679 case STRING: 13680 { 13681 setState(1657); 13682 match(STRING); 13683 } 13684 break; 13685 case START: 13686 { 13687 setState(1658); 13688 htmlElement(); 13689 } 13690 break; 13691 default: 13692 throw new NoViableAltException(this); 13693 } 13694 setState(1664); 13695 _errHandler.sync(this); 13696 _alt = getInterpreter().adaptivePredict(_input,140,_ctx); 13697 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13698 if ( _alt==1 ) { 13699 { 13700 { 13701 setState(1661); 13702 _la = _input.LA(1); 13703 if ( !(_la==WS || _la==NEWLINE) ) { 13704 _errHandler.recoverInline(this); 13705 } 13706 else { 13707 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13708 _errHandler.reportMatch(this); 13709 consume(); 13710 } 13711 } 13712 } 13713 } 13714 setState(1666); 13715 _errHandler.sync(this); 13716 _alt = getInterpreter().adaptivePredict(_input,140,_ctx); 13717 } 13718 setState(1669); 13719 _errHandler.sync(this); 13720 switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) { 13721 case 1: 13722 { 13723 setState(1667); 13724 _la = _input.LA(1); 13725 if ( !(_la==WS || _la==NEWLINE) ) { 13726 _errHandler.recoverInline(this); 13727 } 13728 else { 13729 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13730 _errHandler.reportMatch(this); 13731 consume(); 13732 } 13733 setState(1668); 13734 description(); 13735 } 13736 break; 13737 } 13738 } 13739 break; 13740 case SERIAL_LITERAL: 13741 enterOuterAlt(_localctx, 7); 13742 { 13743 setState(1671); 13744 match(SERIAL_LITERAL); 13745 setState(1675); 13746 _errHandler.sync(this); 13747 _alt = getInterpreter().adaptivePredict(_input,142,_ctx); 13748 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13749 if ( _alt==1 ) { 13750 { 13751 { 13752 setState(1672); 13753 _la = _input.LA(1); 13754 if ( !(_la==WS || _la==NEWLINE) ) { 13755 _errHandler.recoverInline(this); 13756 } 13757 else { 13758 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13759 _errHandler.reportMatch(this); 13760 consume(); 13761 } 13762 } 13763 } 13764 } 13765 setState(1677); 13766 _errHandler.sync(this); 13767 _alt = getInterpreter().adaptivePredict(_input,142,_ctx); 13768 } 13769 setState(1682); 13770 _errHandler.sync(this); 13771 switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) { 13772 case 1: 13773 { 13774 setState(1678); 13775 _la = _input.LA(1); 13776 if ( !(_la==WS || _la==NEWLINE) ) { 13777 _errHandler.recoverInline(this); 13778 } 13779 else { 13780 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13781 _errHandler.reportMatch(this); 13782 consume(); 13783 } 13784 setState(1679); 13785 description(); 13786 } 13787 break; 13788 case 2: 13789 { 13790 setState(1680); 13791 match(LITERAL_INCLUDE); 13792 } 13793 break; 13794 case 3: 13795 { 13796 setState(1681); 13797 match(LITERAL_EXCLUDE); 13798 } 13799 break; 13800 } 13801 setState(1687); 13802 _errHandler.sync(this); 13803 _alt = getInterpreter().adaptivePredict(_input,144,_ctx); 13804 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13805 if ( _alt==1 ) { 13806 { 13807 { 13808 setState(1684); 13809 _la = _input.LA(1); 13810 if ( !(_la==WS || _la==NEWLINE) ) { 13811 _errHandler.recoverInline(this); 13812 } 13813 else { 13814 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13815 _errHandler.reportMatch(this); 13816 consume(); 13817 } 13818 } 13819 } 13820 } 13821 setState(1689); 13822 _errHandler.sync(this); 13823 _alt = getInterpreter().adaptivePredict(_input,144,_ctx); 13824 } 13825 } 13826 break; 13827 case SERIAL_DATA_LITERAL: 13828 enterOuterAlt(_localctx, 8); 13829 { 13830 setState(1690); 13831 match(SERIAL_DATA_LITERAL); 13832 setState(1694); 13833 _errHandler.sync(this); 13834 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 13835 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13836 if ( _alt==1 ) { 13837 { 13838 { 13839 setState(1691); 13840 _la = _input.LA(1); 13841 if ( !(_la==WS || _la==NEWLINE) ) { 13842 _errHandler.recoverInline(this); 13843 } 13844 else { 13845 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13846 _errHandler.reportMatch(this); 13847 consume(); 13848 } 13849 } 13850 } 13851 } 13852 setState(1696); 13853 _errHandler.sync(this); 13854 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 13855 } 13856 setState(1699); 13857 _errHandler.sync(this); 13858 switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { 13859 case 1: 13860 { 13861 setState(1697); 13862 _la = _input.LA(1); 13863 if ( !(_la==WS || _la==NEWLINE) ) { 13864 _errHandler.recoverInline(this); 13865 } 13866 else { 13867 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13868 _errHandler.reportMatch(this); 13869 consume(); 13870 } 13871 setState(1698); 13872 description(); 13873 } 13874 break; 13875 } 13876 } 13877 break; 13878 case SERIAL_FIELD_LITERAL: 13879 enterOuterAlt(_localctx, 9); 13880 { 13881 setState(1701); 13882 match(SERIAL_FIELD_LITERAL); 13883 setState(1705); 13884 _errHandler.sync(this); 13885 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 13886 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13887 if ( _alt==1 ) { 13888 { 13889 { 13890 setState(1702); 13891 _la = _input.LA(1); 13892 if ( !(_la==WS || _la==NEWLINE) ) { 13893 _errHandler.recoverInline(this); 13894 } 13895 else { 13896 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13897 _errHandler.reportMatch(this); 13898 consume(); 13899 } 13900 } 13901 } 13902 } 13903 setState(1707); 13904 _errHandler.sync(this); 13905 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 13906 } 13907 setState(1710); 13908 _errHandler.sync(this); 13909 switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { 13910 case 1: 13911 { 13912 setState(1708); 13913 _la = _input.LA(1); 13914 if ( !(_la==WS || _la==NEWLINE) ) { 13915 _errHandler.recoverInline(this); 13916 } 13917 else { 13918 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13919 _errHandler.reportMatch(this); 13920 consume(); 13921 } 13922 setState(1709); 13923 match(FIELD_NAME); 13924 } 13925 break; 13926 } 13927 setState(1715); 13928 _errHandler.sync(this); 13929 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 13930 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13931 if ( _alt==1 ) { 13932 { 13933 { 13934 setState(1712); 13935 _la = _input.LA(1); 13936 if ( !(_la==WS || _la==NEWLINE) ) { 13937 _errHandler.recoverInline(this); 13938 } 13939 else { 13940 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13941 _errHandler.reportMatch(this); 13942 consume(); 13943 } 13944 } 13945 } 13946 } 13947 setState(1717); 13948 _errHandler.sync(this); 13949 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 13950 } 13951 setState(1720); 13952 _errHandler.sync(this); 13953 switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { 13954 case 1: 13955 { 13956 setState(1718); 13957 _la = _input.LA(1); 13958 if ( !(_la==WS || _la==NEWLINE) ) { 13959 _errHandler.recoverInline(this); 13960 } 13961 else { 13962 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13963 _errHandler.reportMatch(this); 13964 consume(); 13965 } 13966 setState(1719); 13967 match(FIELD_TYPE); 13968 } 13969 break; 13970 } 13971 setState(1725); 13972 _errHandler.sync(this); 13973 _alt = getInterpreter().adaptivePredict(_input,151,_ctx); 13974 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13975 if ( _alt==1 ) { 13976 { 13977 { 13978 setState(1722); 13979 _la = _input.LA(1); 13980 if ( !(_la==WS || _la==NEWLINE) ) { 13981 _errHandler.recoverInline(this); 13982 } 13983 else { 13984 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13985 _errHandler.reportMatch(this); 13986 consume(); 13987 } 13988 } 13989 } 13990 } 13991 setState(1727); 13992 _errHandler.sync(this); 13993 _alt = getInterpreter().adaptivePredict(_input,151,_ctx); 13994 } 13995 setState(1730); 13996 _errHandler.sync(this); 13997 switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) { 13998 case 1: 13999 { 14000 setState(1728); 14001 _la = _input.LA(1); 14002 if ( !(_la==WS || _la==NEWLINE) ) { 14003 _errHandler.recoverInline(this); 14004 } 14005 else { 14006 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14007 _errHandler.reportMatch(this); 14008 consume(); 14009 } 14010 setState(1729); 14011 description(); 14012 } 14013 break; 14014 } 14015 } 14016 break; 14017 case SINCE_LITERAL: 14018 enterOuterAlt(_localctx, 10); 14019 { 14020 setState(1732); 14021 match(SINCE_LITERAL); 14022 setState(1734); 14023 _errHandler.sync(this); 14024 _alt = 1; 14025 do { 14026 switch (_alt) { 14027 case 1: 14028 { 14029 { 14030 setState(1733); 14031 _la = _input.LA(1); 14032 if ( !(_la==WS || _la==NEWLINE) ) { 14033 _errHandler.recoverInline(this); 14034 } 14035 else { 14036 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14037 _errHandler.reportMatch(this); 14038 consume(); 14039 } 14040 } 14041 } 14042 break; 14043 default: 14044 throw new NoViableAltException(this); 14045 } 14046 setState(1736); 14047 _errHandler.sync(this); 14048 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 14049 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 14050 setState(1738); 14051 description(); 14052 } 14053 break; 14054 case THROWS_LITERAL: 14055 enterOuterAlt(_localctx, 11); 14056 { 14057 setState(1739); 14058 match(THROWS_LITERAL); 14059 setState(1744); 14060 _errHandler.sync(this); 14061 _alt = 1; 14062 do { 14063 switch (_alt) { 14064 case 1: 14065 { 14066 setState(1744); 14067 _errHandler.sync(this); 14068 switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) { 14069 case 1: 14070 { 14071 setState(1740); 14072 match(WS); 14073 } 14074 break; 14075 case 2: 14076 { 14077 setState(1741); 14078 match(NEWLINE); 14079 } 14080 break; 14081 case 3: 14082 { 14083 setState(1742); 14084 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 14085 setState(1743); 14086 match(LEADING_ASTERISK); 14087 } 14088 break; 14089 } 14090 } 14091 break; 14092 default: 14093 throw new NoViableAltException(this); 14094 } 14095 setState(1746); 14096 _errHandler.sync(this); 14097 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 14098 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 14099 setState(1748); 14100 match(CLASS_NAME); 14101 setState(1752); 14102 _errHandler.sync(this); 14103 _alt = getInterpreter().adaptivePredict(_input,156,_ctx); 14104 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14105 if ( _alt==1 ) { 14106 { 14107 { 14108 setState(1749); 14109 _la = _input.LA(1); 14110 if ( !(_la==WS || _la==NEWLINE) ) { 14111 _errHandler.recoverInline(this); 14112 } 14113 else { 14114 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14115 _errHandler.reportMatch(this); 14116 consume(); 14117 } 14118 } 14119 } 14120 } 14121 setState(1754); 14122 _errHandler.sync(this); 14123 _alt = getInterpreter().adaptivePredict(_input,156,_ctx); 14124 } 14125 setState(1757); 14126 _errHandler.sync(this); 14127 switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { 14128 case 1: 14129 { 14130 setState(1755); 14131 _la = _input.LA(1); 14132 if ( !(_la==WS || _la==NEWLINE) ) { 14133 _errHandler.recoverInline(this); 14134 } 14135 else { 14136 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14137 _errHandler.reportMatch(this); 14138 consume(); 14139 } 14140 setState(1756); 14141 description(); 14142 } 14143 break; 14144 } 14145 } 14146 break; 14147 case VERSION_LITERAL: 14148 enterOuterAlt(_localctx, 12); 14149 { 14150 setState(1759); 14151 match(VERSION_LITERAL); 14152 setState(1761); 14153 _errHandler.sync(this); 14154 _alt = 1; 14155 do { 14156 switch (_alt) { 14157 case 1: 14158 { 14159 { 14160 setState(1760); 14161 _la = _input.LA(1); 14162 if ( !(_la==WS || _la==NEWLINE) ) { 14163 _errHandler.recoverInline(this); 14164 } 14165 else { 14166 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14167 _errHandler.reportMatch(this); 14168 consume(); 14169 } 14170 } 14171 } 14172 break; 14173 default: 14174 throw new NoViableAltException(this); 14175 } 14176 setState(1763); 14177 _errHandler.sync(this); 14178 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 14179 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 14180 setState(1765); 14181 description(); 14182 } 14183 break; 14184 case CUSTOM_NAME: 14185 enterOuterAlt(_localctx, 13); 14186 { 14187 setState(1766); 14188 match(CUSTOM_NAME); 14189 setState(1770); 14190 _errHandler.sync(this); 14191 _alt = getInterpreter().adaptivePredict(_input,159,_ctx); 14192 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14193 if ( _alt==1 ) { 14194 { 14195 { 14196 setState(1767); 14197 _la = _input.LA(1); 14198 if ( !(_la==WS || _la==NEWLINE) ) { 14199 _errHandler.recoverInline(this); 14200 } 14201 else { 14202 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14203 _errHandler.reportMatch(this); 14204 consume(); 14205 } 14206 } 14207 } 14208 } 14209 setState(1772); 14210 _errHandler.sync(this); 14211 _alt = getInterpreter().adaptivePredict(_input,159,_ctx); 14212 } 14213 setState(1775); 14214 _errHandler.sync(this); 14215 switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) { 14216 case 1: 14217 { 14218 setState(1773); 14219 _la = _input.LA(1); 14220 if ( !(_la==WS || _la==NEWLINE) ) { 14221 _errHandler.recoverInline(this); 14222 } 14223 else { 14224 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14225 _errHandler.reportMatch(this); 14226 consume(); 14227 } 14228 setState(1774); 14229 description(); 14230 } 14231 break; 14232 } 14233 } 14234 break; 14235 default: 14236 throw new NoViableAltException(this); 14237 } 14238 } 14239 catch (RecognitionException re) { 14240 _localctx.exception = re; 14241 _errHandler.reportError(this, re); 14242 _errHandler.recover(this, re); 14243 } 14244 finally { 14245 exitRule(); 14246 } 14247 return _localctx; 14248 } 14249 14250 public static class JavadocInlineTagContext extends ParserRuleContext { 14251 public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); } 14252 public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); } 14253 public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); } 14254 public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); } 14255 public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); } 14256 public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); } 14257 public ReferenceContext reference() { 14258 return getRuleContext(ReferenceContext.class,0); 14259 } 14260 public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); } 14261 public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); } 14262 public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); } 14263 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 14264 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14265 public TerminalNode WS(int i) { 14266 return getToken(JavadocParser.WS, i); 14267 } 14268 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14269 public TerminalNode NEWLINE(int i) { 14270 return getToken(JavadocParser.NEWLINE, i); 14271 } 14272 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14273 public TerminalNode LEADING_ASTERISK(int i) { 14274 return getToken(JavadocParser.LEADING_ASTERISK, i); 14275 } 14276 public List<TextContext> text() { 14277 return getRuleContexts(TextContext.class); 14278 } 14279 public TextContext text(int i) { 14280 return getRuleContext(TextContext.class,i); 14281 } 14282 public DescriptionContext description() { 14283 return getRuleContext(DescriptionContext.class,0); 14284 } 14285 public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) { 14286 super(parent, invokingState); 14287 } 14288 @Override public int getRuleIndex() { return RULE_javadocInlineTag; } 14289 } 14290 14291 public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException { 14292 JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState()); 14293 enterRule(_localctx, 144, RULE_javadocInlineTag); 14294 int _la; 14295 try { 14296 int _alt; 14297 enterOuterAlt(_localctx, 1); 14298 { 14299 setState(1779); 14300 match(JAVADOC_INLINE_TAG_START); 14301 setState(1870); 14302 _errHandler.sync(this); 14303 switch (_input.LA(1)) { 14304 case CODE_LITERAL: 14305 { 14306 setState(1780); 14307 match(CODE_LITERAL); 14308 setState(1787); 14309 _errHandler.sync(this); 14310 _la = _input.LA(1); 14311 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 14312 { 14313 setState(1785); 14314 _errHandler.sync(this); 14315 switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) { 14316 case 1: 14317 { 14318 setState(1781); 14319 match(WS); 14320 } 14321 break; 14322 case 2: 14323 { 14324 setState(1782); 14325 match(NEWLINE); 14326 } 14327 break; 14328 case 3: 14329 { 14330 setState(1783); 14331 match(LEADING_ASTERISK); 14332 } 14333 break; 14334 case 4: 14335 { 14336 setState(1784); 14337 text(); 14338 } 14339 break; 14340 } 14341 } 14342 setState(1789); 14343 _errHandler.sync(this); 14344 _la = _input.LA(1); 14345 } 14346 } 14347 break; 14348 case DOC_ROOT_LITERAL: 14349 { 14350 setState(1790); 14351 match(DOC_ROOT_LITERAL); 14352 setState(1794); 14353 _errHandler.sync(this); 14354 _la = _input.LA(1); 14355 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 14356 { 14357 { 14358 setState(1791); 14359 _la = _input.LA(1); 14360 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14361 _errHandler.recoverInline(this); 14362 } 14363 else { 14364 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14365 _errHandler.reportMatch(this); 14366 consume(); 14367 } 14368 } 14369 } 14370 setState(1796); 14371 _errHandler.sync(this); 14372 _la = _input.LA(1); 14373 } 14374 } 14375 break; 14376 case INHERIT_DOC_LITERAL: 14377 { 14378 setState(1797); 14379 match(INHERIT_DOC_LITERAL); 14380 setState(1801); 14381 _errHandler.sync(this); 14382 _la = _input.LA(1); 14383 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 14384 { 14385 { 14386 setState(1798); 14387 _la = _input.LA(1); 14388 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14389 _errHandler.recoverInline(this); 14390 } 14391 else { 14392 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14393 _errHandler.reportMatch(this); 14394 consume(); 14395 } 14396 } 14397 } 14398 setState(1803); 14399 _errHandler.sync(this); 14400 _la = _input.LA(1); 14401 } 14402 } 14403 break; 14404 case LINK_LITERAL: 14405 { 14406 setState(1804); 14407 match(LINK_LITERAL); 14408 setState(1806); 14409 _errHandler.sync(this); 14410 _la = _input.LA(1); 14411 do { 14412 { 14413 { 14414 setState(1805); 14415 _la = _input.LA(1); 14416 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14417 _errHandler.recoverInline(this); 14418 } 14419 else { 14420 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14421 _errHandler.reportMatch(this); 14422 consume(); 14423 } 14424 } 14425 } 14426 setState(1808); 14427 _errHandler.sync(this); 14428 _la = _input.LA(1); 14429 } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) ); 14430 setState(1810); 14431 reference(); 14432 setState(1814); 14433 _errHandler.sync(this); 14434 _alt = getInterpreter().adaptivePredict(_input,167,_ctx); 14435 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14436 if ( _alt==1 ) { 14437 { 14438 { 14439 setState(1811); 14440 _la = _input.LA(1); 14441 if ( !(_la==WS || _la==NEWLINE) ) { 14442 _errHandler.recoverInline(this); 14443 } 14444 else { 14445 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14446 _errHandler.reportMatch(this); 14447 consume(); 14448 } 14449 } 14450 } 14451 } 14452 setState(1816); 14453 _errHandler.sync(this); 14454 _alt = getInterpreter().adaptivePredict(_input,167,_ctx); 14455 } 14456 setState(1819); 14457 _errHandler.sync(this); 14458 _la = _input.LA(1); 14459 if (_la==WS || _la==NEWLINE) { 14460 { 14461 setState(1817); 14462 _la = _input.LA(1); 14463 if ( !(_la==WS || _la==NEWLINE) ) { 14464 _errHandler.recoverInline(this); 14465 } 14466 else { 14467 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14468 _errHandler.reportMatch(this); 14469 consume(); 14470 } 14471 setState(1818); 14472 description(); 14473 } 14474 } 14475 14476 } 14477 break; 14478 case LINKPLAIN_LITERAL: 14479 { 14480 setState(1821); 14481 match(LINKPLAIN_LITERAL); 14482 setState(1823); 14483 _errHandler.sync(this); 14484 _la = _input.LA(1); 14485 do { 14486 { 14487 { 14488 setState(1822); 14489 _la = _input.LA(1); 14490 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14491 _errHandler.recoverInline(this); 14492 } 14493 else { 14494 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14495 _errHandler.reportMatch(this); 14496 consume(); 14497 } 14498 } 14499 } 14500 setState(1825); 14501 _errHandler.sync(this); 14502 _la = _input.LA(1); 14503 } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) ); 14504 setState(1827); 14505 reference(); 14506 setState(1831); 14507 _errHandler.sync(this); 14508 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14509 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14510 if ( _alt==1 ) { 14511 { 14512 { 14513 setState(1828); 14514 _la = _input.LA(1); 14515 if ( !(_la==WS || _la==NEWLINE) ) { 14516 _errHandler.recoverInline(this); 14517 } 14518 else { 14519 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14520 _errHandler.reportMatch(this); 14521 consume(); 14522 } 14523 } 14524 } 14525 } 14526 setState(1833); 14527 _errHandler.sync(this); 14528 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14529 } 14530 setState(1836); 14531 _errHandler.sync(this); 14532 _la = _input.LA(1); 14533 if (_la==WS || _la==NEWLINE) { 14534 { 14535 setState(1834); 14536 _la = _input.LA(1); 14537 if ( !(_la==WS || _la==NEWLINE) ) { 14538 _errHandler.recoverInline(this); 14539 } 14540 else { 14541 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14542 _errHandler.reportMatch(this); 14543 consume(); 14544 } 14545 setState(1835); 14546 description(); 14547 } 14548 } 14549 14550 } 14551 break; 14552 case LITERAL_LITERAL: 14553 { 14554 setState(1838); 14555 match(LITERAL_LITERAL); 14556 setState(1845); 14557 _errHandler.sync(this); 14558 _la = _input.LA(1); 14559 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 14560 { 14561 setState(1843); 14562 _errHandler.sync(this); 14563 switch ( getInterpreter().adaptivePredict(_input,172,_ctx) ) { 14564 case 1: 14565 { 14566 setState(1839); 14567 match(WS); 14568 } 14569 break; 14570 case 2: 14571 { 14572 setState(1840); 14573 match(NEWLINE); 14574 } 14575 break; 14576 case 3: 14577 { 14578 setState(1841); 14579 match(LEADING_ASTERISK); 14580 } 14581 break; 14582 case 4: 14583 { 14584 setState(1842); 14585 text(); 14586 } 14587 break; 14588 } 14589 } 14590 setState(1847); 14591 _errHandler.sync(this); 14592 _la = _input.LA(1); 14593 } 14594 } 14595 break; 14596 case VALUE_LITERAL: 14597 { 14598 setState(1848); 14599 match(VALUE_LITERAL); 14600 setState(1852); 14601 _errHandler.sync(this); 14602 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 14603 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14604 if ( _alt==1 ) { 14605 { 14606 { 14607 setState(1849); 14608 _la = _input.LA(1); 14609 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14610 _errHandler.recoverInline(this); 14611 } 14612 else { 14613 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14614 _errHandler.reportMatch(this); 14615 consume(); 14616 } 14617 } 14618 } 14619 } 14620 setState(1854); 14621 _errHandler.sync(this); 14622 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 14623 } 14624 setState(1857); 14625 _errHandler.sync(this); 14626 _la = _input.LA(1); 14627 if (_la==WS || _la==NEWLINE) { 14628 { 14629 setState(1855); 14630 _la = _input.LA(1); 14631 if ( !(_la==WS || _la==NEWLINE) ) { 14632 _errHandler.recoverInline(this); 14633 } 14634 else { 14635 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14636 _errHandler.reportMatch(this); 14637 consume(); 14638 } 14639 setState(1856); 14640 reference(); 14641 } 14642 } 14643 14644 } 14645 break; 14646 case CUSTOM_NAME: 14647 { 14648 setState(1859); 14649 match(CUSTOM_NAME); 14650 setState(1863); 14651 _errHandler.sync(this); 14652 _alt = getInterpreter().adaptivePredict(_input,176,_ctx); 14653 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14654 if ( _alt==1 ) { 14655 { 14656 { 14657 setState(1860); 14658 _la = _input.LA(1); 14659 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14660 _errHandler.recoverInline(this); 14661 } 14662 else { 14663 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14664 _errHandler.reportMatch(this); 14665 consume(); 14666 } 14667 } 14668 } 14669 } 14670 setState(1865); 14671 _errHandler.sync(this); 14672 _alt = getInterpreter().adaptivePredict(_input,176,_ctx); 14673 } 14674 setState(1868); 14675 _errHandler.sync(this); 14676 _la = _input.LA(1); 14677 if (_la==WS || _la==NEWLINE) { 14678 { 14679 setState(1866); 14680 _la = _input.LA(1); 14681 if ( !(_la==WS || _la==NEWLINE) ) { 14682 _errHandler.recoverInline(this); 14683 } 14684 else { 14685 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14686 _errHandler.reportMatch(this); 14687 consume(); 14688 } 14689 setState(1867); 14690 description(); 14691 } 14692 } 14693 14694 } 14695 break; 14696 default: 14697 throw new NoViableAltException(this); 14698 } 14699 setState(1872); 14700 match(JAVADOC_INLINE_TAG_END); 14701 } 14702 } 14703 catch (RecognitionException re) { 14704 _localctx.exception = re; 14705 _errHandler.reportError(this, re); 14706 _errHandler.recover(this, re); 14707 } 14708 finally { 14709 exitRule(); 14710 } 14711 return _localctx; 14712 } 14713 14714 public static class HtmlCommentContext extends ParserRuleContext { 14715 public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); } 14716 public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); } 14717 public List<TextContext> text() { 14718 return getRuleContexts(TextContext.class); 14719 } 14720 public TextContext text(int i) { 14721 return getRuleContext(TextContext.class,i); 14722 } 14723 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14724 public TerminalNode NEWLINE(int i) { 14725 return getToken(JavadocParser.NEWLINE, i); 14726 } 14727 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14728 public TerminalNode LEADING_ASTERISK(int i) { 14729 return getToken(JavadocParser.LEADING_ASTERISK, i); 14730 } 14731 public HtmlCommentContext(ParserRuleContext parent, int invokingState) { 14732 super(parent, invokingState); 14733 } 14734 @Override public int getRuleIndex() { return RULE_htmlComment; } 14735 } 14736 14737 public final HtmlCommentContext htmlComment() throws RecognitionException { 14738 HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState()); 14739 enterRule(_localctx, 146, RULE_htmlComment); 14740 int _la; 14741 try { 14742 enterOuterAlt(_localctx, 1); 14743 { 14744 setState(1874); 14745 match(HTML_COMMENT_START); 14746 setState(1880); 14747 _errHandler.sync(this); 14748 _la = _input.LA(1); 14749 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 14750 { 14751 setState(1878); 14752 _errHandler.sync(this); 14753 switch (_input.LA(1)) { 14754 case WS: 14755 case CHAR: 14756 { 14757 setState(1875); 14758 text(); 14759 } 14760 break; 14761 case NEWLINE: 14762 { 14763 setState(1876); 14764 match(NEWLINE); 14765 } 14766 break; 14767 case LEADING_ASTERISK: 14768 { 14769 setState(1877); 14770 match(LEADING_ASTERISK); 14771 } 14772 break; 14773 default: 14774 throw new NoViableAltException(this); 14775 } 14776 } 14777 setState(1882); 14778 _errHandler.sync(this); 14779 _la = _input.LA(1); 14780 } 14781 setState(1883); 14782 match(HTML_COMMENT_END); 14783 } 14784 } 14785 catch (RecognitionException re) { 14786 _localctx.exception = re; 14787 _errHandler.reportError(this, re); 14788 _errHandler.recover(this, re); 14789 } 14790 finally { 14791 exitRule(); 14792 } 14793 return _localctx; 14794 } 14795 14796 public static class TextContext extends ParserRuleContext { 14797 public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); } 14798 public TerminalNode CHAR(int i) { 14799 return getToken(JavadocParser.CHAR, i); 14800 } 14801 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14802 public TerminalNode WS(int i) { 14803 return getToken(JavadocParser.WS, i); 14804 } 14805 public TextContext(ParserRuleContext parent, int invokingState) { 14806 super(parent, invokingState); 14807 } 14808 @Override public int getRuleIndex() { return RULE_text; } 14809 } 14810 14811 public final TextContext text() throws RecognitionException { 14812 TextContext _localctx = new TextContext(_ctx, getState()); 14813 enterRule(_localctx, 148, RULE_text); 14814 int _la; 14815 try { 14816 int _alt; 14817 enterOuterAlt(_localctx, 1); 14818 { 14819 setState(1887); 14820 _errHandler.sync(this); 14821 _alt = 1; 14822 do { 14823 switch (_alt) { 14824 case 1: 14825 { 14826 { 14827 setState(1885); 14828 _la = _input.LA(1); 14829 if ( !(_la==WS || _la==CHAR) ) { 14830 _errHandler.recoverInline(this); 14831 } 14832 else { 14833 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14834 _errHandler.reportMatch(this); 14835 consume(); 14836 } 14837 14838 _la = _input.LA(1); 14839 if ((_la != WS) && (_la != CHAR)) return _localctx; 14840 else if (_alt == 1) continue; 14841 14842 } 14843 } 14844 break; 14845 default: 14846 throw new NoViableAltException(this); 14847 } 14848 setState(1889); 14849 _errHandler.sync(this); 14850 _alt = getInterpreter().adaptivePredict(_input,181,_ctx); 14851 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 14852 } 14853 } 14854 catch (RecognitionException re) { 14855 _localctx.exception = re; 14856 _errHandler.reportError(this, re); 14857 _errHandler.recover(this, re); 14858 } 14859 finally { 14860 exitRule(); 14861 } 14862 return _localctx; 14863 } 14864 14865 public static class EmbedTagContext extends ParserRuleContext { 14866 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14867 public TerminalNode EMBED_HTML_TAG_NAME() { return getToken(JavadocParser.EMBED_HTML_TAG_NAME, 0); } 14868 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14869 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14870 public List<AttributeContext> attribute() { 14871 return getRuleContexts(AttributeContext.class); 14872 } 14873 public AttributeContext attribute(int i) { 14874 return getRuleContext(AttributeContext.class,i); 14875 } 14876 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14877 public TerminalNode NEWLINE(int i) { 14878 return getToken(JavadocParser.NEWLINE, i); 14879 } 14880 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14881 public TerminalNode LEADING_ASTERISK(int i) { 14882 return getToken(JavadocParser.LEADING_ASTERISK, i); 14883 } 14884 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14885 public TerminalNode WS(int i) { 14886 return getToken(JavadocParser.WS, i); 14887 } 14888 public EmbedTagContext(ParserRuleContext parent, int invokingState) { 14889 super(parent, invokingState); 14890 } 14891 @Override public int getRuleIndex() { return RULE_embedTag; } 14892 } 14893 14894 public final EmbedTagContext embedTag() throws RecognitionException { 14895 EmbedTagContext _localctx = new EmbedTagContext(_ctx, getState()); 14896 enterRule(_localctx, 150, RULE_embedTag); 14897 int _la; 14898 try { 14899 enterOuterAlt(_localctx, 1); 14900 { 14901 setState(1891); 14902 match(START); 14903 setState(1892); 14904 match(EMBED_HTML_TAG_NAME); 14905 setState(1899); 14906 _errHandler.sync(this); 14907 _la = _input.LA(1); 14908 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 14909 { 14910 setState(1897); 14911 _errHandler.sync(this); 14912 switch (_input.LA(1)) { 14913 case HTML_TAG_NAME: 14914 { 14915 setState(1893); 14916 attribute(); 14917 } 14918 break; 14919 case NEWLINE: 14920 { 14921 setState(1894); 14922 match(NEWLINE); 14923 } 14924 break; 14925 case LEADING_ASTERISK: 14926 { 14927 setState(1895); 14928 match(LEADING_ASTERISK); 14929 } 14930 break; 14931 case WS: 14932 { 14933 setState(1896); 14934 match(WS); 14935 } 14936 break; 14937 default: 14938 throw new NoViableAltException(this); 14939 } 14940 } 14941 setState(1901); 14942 _errHandler.sync(this); 14943 _la = _input.LA(1); 14944 } 14945 setState(1902); 14946 _la = _input.LA(1); 14947 if ( !(_la==END || _la==SLASH_END) ) { 14948 _errHandler.recoverInline(this); 14949 } 14950 else { 14951 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14952 _errHandler.reportMatch(this); 14953 consume(); 14954 } 14955 } 14956 } 14957 catch (RecognitionException re) { 14958 _localctx.exception = re; 14959 _errHandler.reportError(this, re); 14960 _errHandler.recover(this, re); 14961 } 14962 finally { 14963 exitRule(); 14964 } 14965 return _localctx; 14966 } 14967 14968 public static class KeygenTagContext extends ParserRuleContext { 14969 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 14970 public TerminalNode KEYGEN_HTML_TAG_NAME() { return getToken(JavadocParser.KEYGEN_HTML_TAG_NAME, 0); } 14971 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 14972 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 14973 public List<AttributeContext> attribute() { 14974 return getRuleContexts(AttributeContext.class); 14975 } 14976 public AttributeContext attribute(int i) { 14977 return getRuleContext(AttributeContext.class,i); 14978 } 14979 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14980 public TerminalNode NEWLINE(int i) { 14981 return getToken(JavadocParser.NEWLINE, i); 14982 } 14983 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14984 public TerminalNode LEADING_ASTERISK(int i) { 14985 return getToken(JavadocParser.LEADING_ASTERISK, i); 14986 } 14987 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14988 public TerminalNode WS(int i) { 14989 return getToken(JavadocParser.WS, i); 14990 } 14991 public KeygenTagContext(ParserRuleContext parent, int invokingState) { 14992 super(parent, invokingState); 14993 } 14994 @Override public int getRuleIndex() { return RULE_keygenTag; } 14995 } 14996 14997 public final KeygenTagContext keygenTag() throws RecognitionException { 14998 KeygenTagContext _localctx = new KeygenTagContext(_ctx, getState()); 14999 enterRule(_localctx, 152, RULE_keygenTag); 15000 int _la; 15001 try { 15002 enterOuterAlt(_localctx, 1); 15003 { 15004 setState(1904); 15005 match(START); 15006 setState(1905); 15007 match(KEYGEN_HTML_TAG_NAME); 15008 setState(1912); 15009 _errHandler.sync(this); 15010 _la = _input.LA(1); 15011 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 15012 { 15013 setState(1910); 15014 _errHandler.sync(this); 15015 switch (_input.LA(1)) { 15016 case HTML_TAG_NAME: 15017 { 15018 setState(1906); 15019 attribute(); 15020 } 15021 break; 15022 case NEWLINE: 15023 { 15024 setState(1907); 15025 match(NEWLINE); 15026 } 15027 break; 15028 case LEADING_ASTERISK: 15029 { 15030 setState(1908); 15031 match(LEADING_ASTERISK); 15032 } 15033 break; 15034 case WS: 15035 { 15036 setState(1909); 15037 match(WS); 15038 } 15039 break; 15040 default: 15041 throw new NoViableAltException(this); 15042 } 15043 } 15044 setState(1914); 15045 _errHandler.sync(this); 15046 _la = _input.LA(1); 15047 } 15048 setState(1915); 15049 _la = _input.LA(1); 15050 if ( !(_la==END || _la==SLASH_END) ) { 15051 _errHandler.recoverInline(this); 15052 } 15053 else { 15054 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15055 _errHandler.reportMatch(this); 15056 consume(); 15057 } 15058 } 15059 } 15060 catch (RecognitionException re) { 15061 _localctx.exception = re; 15062 _errHandler.reportError(this, re); 15063 _errHandler.recover(this, re); 15064 } 15065 finally { 15066 exitRule(); 15067 } 15068 return _localctx; 15069 } 15070 15071 public static class SourceTagContext extends ParserRuleContext { 15072 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 15073 public TerminalNode SOURCE_HTML_TAG_NAME() { return getToken(JavadocParser.SOURCE_HTML_TAG_NAME, 0); } 15074 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 15075 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 15076 public List<AttributeContext> attribute() { 15077 return getRuleContexts(AttributeContext.class); 15078 } 15079 public AttributeContext attribute(int i) { 15080 return getRuleContext(AttributeContext.class,i); 15081 } 15082 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15083 public TerminalNode NEWLINE(int i) { 15084 return getToken(JavadocParser.NEWLINE, i); 15085 } 15086 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15087 public TerminalNode LEADING_ASTERISK(int i) { 15088 return getToken(JavadocParser.LEADING_ASTERISK, i); 15089 } 15090 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15091 public TerminalNode WS(int i) { 15092 return getToken(JavadocParser.WS, i); 15093 } 15094 public SourceTagContext(ParserRuleContext parent, int invokingState) { 15095 super(parent, invokingState); 15096 } 15097 @Override public int getRuleIndex() { return RULE_sourceTag; } 15098 } 15099 15100 public final SourceTagContext sourceTag() throws RecognitionException { 15101 SourceTagContext _localctx = new SourceTagContext(_ctx, getState()); 15102 enterRule(_localctx, 154, RULE_sourceTag); 15103 int _la; 15104 try { 15105 enterOuterAlt(_localctx, 1); 15106 { 15107 setState(1917); 15108 match(START); 15109 setState(1918); 15110 match(SOURCE_HTML_TAG_NAME); 15111 setState(1925); 15112 _errHandler.sync(this); 15113 _la = _input.LA(1); 15114 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 15115 { 15116 setState(1923); 15117 _errHandler.sync(this); 15118 switch (_input.LA(1)) { 15119 case HTML_TAG_NAME: 15120 { 15121 setState(1919); 15122 attribute(); 15123 } 15124 break; 15125 case NEWLINE: 15126 { 15127 setState(1920); 15128 match(NEWLINE); 15129 } 15130 break; 15131 case LEADING_ASTERISK: 15132 { 15133 setState(1921); 15134 match(LEADING_ASTERISK); 15135 } 15136 break; 15137 case WS: 15138 { 15139 setState(1922); 15140 match(WS); 15141 } 15142 break; 15143 default: 15144 throw new NoViableAltException(this); 15145 } 15146 } 15147 setState(1927); 15148 _errHandler.sync(this); 15149 _la = _input.LA(1); 15150 } 15151 setState(1928); 15152 _la = _input.LA(1); 15153 if ( !(_la==END || _la==SLASH_END) ) { 15154 _errHandler.recoverInline(this); 15155 } 15156 else { 15157 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15158 _errHandler.reportMatch(this); 15159 consume(); 15160 } 15161 } 15162 } 15163 catch (RecognitionException re) { 15164 _localctx.exception = re; 15165 _errHandler.reportError(this, re); 15166 _errHandler.recover(this, re); 15167 } 15168 finally { 15169 exitRule(); 15170 } 15171 return _localctx; 15172 } 15173 15174 public static class TrackTagContext extends ParserRuleContext { 15175 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 15176 public TerminalNode TRACK_HTML_TAG_NAME() { return getToken(JavadocParser.TRACK_HTML_TAG_NAME, 0); } 15177 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 15178 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 15179 public List<AttributeContext> attribute() { 15180 return getRuleContexts(AttributeContext.class); 15181 } 15182 public AttributeContext attribute(int i) { 15183 return getRuleContext(AttributeContext.class,i); 15184 } 15185 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15186 public TerminalNode NEWLINE(int i) { 15187 return getToken(JavadocParser.NEWLINE, i); 15188 } 15189 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15190 public TerminalNode LEADING_ASTERISK(int i) { 15191 return getToken(JavadocParser.LEADING_ASTERISK, i); 15192 } 15193 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15194 public TerminalNode WS(int i) { 15195 return getToken(JavadocParser.WS, i); 15196 } 15197 public TrackTagContext(ParserRuleContext parent, int invokingState) { 15198 super(parent, invokingState); 15199 } 15200 @Override public int getRuleIndex() { return RULE_trackTag; } 15201 } 15202 15203 public final TrackTagContext trackTag() throws RecognitionException { 15204 TrackTagContext _localctx = new TrackTagContext(_ctx, getState()); 15205 enterRule(_localctx, 156, RULE_trackTag); 15206 int _la; 15207 try { 15208 enterOuterAlt(_localctx, 1); 15209 { 15210 setState(1930); 15211 match(START); 15212 setState(1931); 15213 match(TRACK_HTML_TAG_NAME); 15214 setState(1938); 15215 _errHandler.sync(this); 15216 _la = _input.LA(1); 15217 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 15218 { 15219 setState(1936); 15220 _errHandler.sync(this); 15221 switch (_input.LA(1)) { 15222 case HTML_TAG_NAME: 15223 { 15224 setState(1932); 15225 attribute(); 15226 } 15227 break; 15228 case NEWLINE: 15229 { 15230 setState(1933); 15231 match(NEWLINE); 15232 } 15233 break; 15234 case LEADING_ASTERISK: 15235 { 15236 setState(1934); 15237 match(LEADING_ASTERISK); 15238 } 15239 break; 15240 case WS: 15241 { 15242 setState(1935); 15243 match(WS); 15244 } 15245 break; 15246 default: 15247 throw new NoViableAltException(this); 15248 } 15249 } 15250 setState(1940); 15251 _errHandler.sync(this); 15252 _la = _input.LA(1); 15253 } 15254 setState(1941); 15255 _la = _input.LA(1); 15256 if ( !(_la==END || _la==SLASH_END) ) { 15257 _errHandler.recoverInline(this); 15258 } 15259 else { 15260 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15261 _errHandler.reportMatch(this); 15262 consume(); 15263 } 15264 } 15265 } 15266 catch (RecognitionException re) { 15267 _localctx.exception = re; 15268 _errHandler.reportError(this, re); 15269 _errHandler.recover(this, re); 15270 } 15271 finally { 15272 exitRule(); 15273 } 15274 return _localctx; 15275 } 15276 15277 public static class WbrTagContext extends ParserRuleContext { 15278 public TerminalNode START() { return getToken(JavadocParser.START, 0); } 15279 public TerminalNode WBR_HTML_TAG_NAME() { return getToken(JavadocParser.WBR_HTML_TAG_NAME, 0); } 15280 public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } 15281 public TerminalNode END() { return getToken(JavadocParser.END, 0); } 15282 public List<AttributeContext> attribute() { 15283 return getRuleContexts(AttributeContext.class); 15284 } 15285 public AttributeContext attribute(int i) { 15286 return getRuleContext(AttributeContext.class,i); 15287 } 15288 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15289 public TerminalNode NEWLINE(int i) { 15290 return getToken(JavadocParser.NEWLINE, i); 15291 } 15292 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15293 public TerminalNode LEADING_ASTERISK(int i) { 15294 return getToken(JavadocParser.LEADING_ASTERISK, i); 15295 } 15296 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15297 public TerminalNode WS(int i) { 15298 return getToken(JavadocParser.WS, i); 15299 } 15300 public WbrTagContext(ParserRuleContext parent, int invokingState) { 15301 super(parent, invokingState); 15302 } 15303 @Override public int getRuleIndex() { return RULE_wbrTag; } 15304 } 15305 15306 public final WbrTagContext wbrTag() throws RecognitionException { 15307 WbrTagContext _localctx = new WbrTagContext(_ctx, getState()); 15308 enterRule(_localctx, 158, RULE_wbrTag); 15309 int _la; 15310 try { 15311 enterOuterAlt(_localctx, 1); 15312 { 15313 setState(1943); 15314 match(START); 15315 setState(1944); 15316 match(WBR_HTML_TAG_NAME); 15317 setState(1951); 15318 _errHandler.sync(this); 15319 _la = _input.LA(1); 15320 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 15321 { 15322 setState(1949); 15323 _errHandler.sync(this); 15324 switch (_input.LA(1)) { 15325 case HTML_TAG_NAME: 15326 { 15327 setState(1945); 15328 attribute(); 15329 } 15330 break; 15331 case NEWLINE: 15332 { 15333 setState(1946); 15334 match(NEWLINE); 15335 } 15336 break; 15337 case LEADING_ASTERISK: 15338 { 15339 setState(1947); 15340 match(LEADING_ASTERISK); 15341 } 15342 break; 15343 case WS: 15344 { 15345 setState(1948); 15346 match(WS); 15347 } 15348 break; 15349 default: 15350 throw new NoViableAltException(this); 15351 } 15352 } 15353 setState(1953); 15354 _errHandler.sync(this); 15355 _la = _input.LA(1); 15356 } 15357 setState(1954); 15358 _la = _input.LA(1); 15359 if ( !(_la==END || _la==SLASH_END) ) { 15360 _errHandler.recoverInline(this); 15361 } 15362 else { 15363 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15364 _errHandler.reportMatch(this); 15365 consume(); 15366 } 15367 } 15368 } 15369 catch (RecognitionException re) { 15370 _localctx.exception = re; 15371 _errHandler.reportError(this, re); 15372 _errHandler.recover(this, re); 15373 } 15374 finally { 15375 exitRule(); 15376 } 15377 return _localctx; 15378 } 15379 15380 public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { 15381 switch (ruleIndex) { 15382 case 0: 15383 return javadoc_sempred((JavadocContext)_localctx, predIndex); 15384 case 5: 15385 return htmlTag_sempred((HtmlTagContext)_localctx, predIndex); 15386 case 8: 15387 return paragraph_sempred((ParagraphContext)_localctx, predIndex); 15388 case 11: 15389 return li_sempred((LiContext)_localctx, predIndex); 15390 case 14: 15391 return tr_sempred((TrContext)_localctx, predIndex); 15392 case 17: 15393 return td_sempred((TdContext)_localctx, predIndex); 15394 case 20: 15395 return th_sempred((ThContext)_localctx, predIndex); 15396 case 23: 15397 return body_sempred((BodyContext)_localctx, predIndex); 15398 case 26: 15399 return colgroup_sempred((ColgroupContext)_localctx, predIndex); 15400 case 29: 15401 return dd_sempred((DdContext)_localctx, predIndex); 15402 case 32: 15403 return dt_sempred((DtContext)_localctx, predIndex); 15404 case 35: 15405 return head_sempred((HeadContext)_localctx, predIndex); 15406 case 38: 15407 return html_sempred((HtmlContext)_localctx, predIndex); 15408 case 41: 15409 return option_sempred((OptionContext)_localctx, predIndex); 15410 case 44: 15411 return tbody_sempred((TbodyContext)_localctx, predIndex); 15412 case 47: 15413 return tfoot_sempred((TfootContext)_localctx, predIndex); 15414 case 50: 15415 return thead_sempred((TheadContext)_localctx, predIndex); 15416 case 68: 15417 return description_sempred((DescriptionContext)_localctx, predIndex); 15418 case 71: 15419 return javadocTag_sempred((JavadocTagContext)_localctx, predIndex); 15420 } 15421 return true; 15422 } 15423 private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) { 15424 switch (predIndex) { 15425 case 0: 15426 return !isNextJavadocTag(); 15427 } 15428 return true; 15429 } 15430 private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) { 15431 switch (predIndex) { 15432 case 1: 15433 return !isNextJavadocTag(); 15434 case 2: 15435 return isSameTagNames(((HtmlTagContext)_localctx).htmlElementStart, ((HtmlTagContext)_localctx).htmlElementEnd); 15436 } 15437 return true; 15438 } 15439 private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) { 15440 switch (predIndex) { 15441 case 3: 15442 return !isNextJavadocTag(); 15443 } 15444 return true; 15445 } 15446 private boolean li_sempred(LiContext _localctx, int predIndex) { 15447 switch (predIndex) { 15448 case 4: 15449 return !isNextJavadocTag(); 15450 } 15451 return true; 15452 } 15453 private boolean tr_sempred(TrContext _localctx, int predIndex) { 15454 switch (predIndex) { 15455 case 5: 15456 return !isNextJavadocTag(); 15457 } 15458 return true; 15459 } 15460 private boolean td_sempred(TdContext _localctx, int predIndex) { 15461 switch (predIndex) { 15462 case 6: 15463 return !isNextJavadocTag(); 15464 } 15465 return true; 15466 } 15467 private boolean th_sempred(ThContext _localctx, int predIndex) { 15468 switch (predIndex) { 15469 case 7: 15470 return !isNextJavadocTag(); 15471 } 15472 return true; 15473 } 15474 private boolean body_sempred(BodyContext _localctx, int predIndex) { 15475 switch (predIndex) { 15476 case 8: 15477 return !isNextJavadocTag(); 15478 } 15479 return true; 15480 } 15481 private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) { 15482 switch (predIndex) { 15483 case 9: 15484 return !isNextJavadocTag(); 15485 } 15486 return true; 15487 } 15488 private boolean dd_sempred(DdContext _localctx, int predIndex) { 15489 switch (predIndex) { 15490 case 10: 15491 return !isNextJavadocTag(); 15492 } 15493 return true; 15494 } 15495 private boolean dt_sempred(DtContext _localctx, int predIndex) { 15496 switch (predIndex) { 15497 case 11: 15498 return !isNextJavadocTag(); 15499 } 15500 return true; 15501 } 15502 private boolean head_sempred(HeadContext _localctx, int predIndex) { 15503 switch (predIndex) { 15504 case 12: 15505 return !isNextJavadocTag(); 15506 } 15507 return true; 15508 } 15509 private boolean html_sempred(HtmlContext _localctx, int predIndex) { 15510 switch (predIndex) { 15511 case 13: 15512 return !isNextJavadocTag(); 15513 } 15514 return true; 15515 } 15516 private boolean option_sempred(OptionContext _localctx, int predIndex) { 15517 switch (predIndex) { 15518 case 14: 15519 return !isNextJavadocTag(); 15520 } 15521 return true; 15522 } 15523 private boolean tbody_sempred(TbodyContext _localctx, int predIndex) { 15524 switch (predIndex) { 15525 case 15: 15526 return !isNextJavadocTag(); 15527 } 15528 return true; 15529 } 15530 private boolean tfoot_sempred(TfootContext _localctx, int predIndex) { 15531 switch (predIndex) { 15532 case 16: 15533 return !isNextJavadocTag(); 15534 } 15535 return true; 15536 } 15537 private boolean thead_sempred(TheadContext _localctx, int predIndex) { 15538 switch (predIndex) { 15539 case 17: 15540 return !isNextJavadocTag(); 15541 } 15542 return true; 15543 } 15544 private boolean description_sempred(DescriptionContext _localctx, int predIndex) { 15545 switch (predIndex) { 15546 case 18: 15547 return !isNextJavadocTag(); 15548 } 15549 return true; 15550 } 15551 private boolean javadocTag_sempred(JavadocTagContext _localctx, int predIndex) { 15552 switch (predIndex) { 15553 case 19: 15554 return !isNextJavadocTag(); 15555 case 20: 15556 return !isNextJavadocTag(); 15557 case 21: 15558 return !isNextJavadocTag(); 15559 case 22: 15560 return !isNextJavadocTag(); 15561 } 15562 return true; 15563 } 15564 15565 public static final String _serializedATN = 15566 "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3b\u07a7\4\2\t\2\4"+ 15567 "\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"+ 15568 "\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"+ 15569 "\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"+ 15570 "\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!"+ 15571 "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ 15572 ",\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"+ 15573 "\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="+ 15574 "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ 15575 "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\3\2\3\2\3\2\3\2\3"+ 15576 "\2\3\2\3\2\3\2\7\2\u00ab\n\2\f\2\16\2\u00ae\13\2\3\2\5\2\u00b1\n\2\3\2"+ 15577 "\7\2\u00b4\n\2\f\2\16\2\u00b7\13\2\3\2\7\2\u00ba\n\2\f\2\16\2\u00bd\13"+ 15578 "\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+ 15579 "\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"+ 15580 "\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u00f0\n"+ 15581 "\3\3\4\3\4\3\4\3\4\3\4\3\4\7\4\u00f8\n\4\f\4\16\4\u00fb\13\4\3\4\3\4\3"+ 15582 "\5\3\5\3\5\3\5\7\5\u0103\n\5\f\5\16\5\u0106\13\5\3\5\3\5\3\6\3\6\7\6\u010c"+ 15583 "\n\6\f\6\16\6\u010f\13\6\3\6\3\6\7\6\u0113\n\6\f\6\16\6\u0116\13\6\3\6"+ 15584 "\3\6\3\6\5\6\u011b\n\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\7\7\u0126\n"+ 15585 "\7\f\7\16\7\u0129\13\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\7\b\u0134\n"+ 15586 "\b\f\b\16\b\u0137\13\b\3\b\3\b\3\t\3\t\3\t\3\t\7\t\u013f\n\t\f\t\16\t"+ 15587 "\u0142\13\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3"+ 15588 "\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"+ 15589 "\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\7\n\u016c\n\n\f\n\16\n\u016f\13\n\3\n"+ 15590 "\3\n\3\13\3\13\3\13\3\13\3\13\3\13\7\13\u0179\n\13\f\13\16\13\u017c\13"+ 15591 "\13\3\13\3\13\3\f\3\f\3\f\3\f\7\f\u0184\n\f\f\f\16\f\u0187\13\f\3\f\3"+ 15592 "\f\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"+ 15593 "\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"+ 15594 "\r\3\r\3\r\3\r\7\r\u01b1\n\r\f\r\16\r\u01b4\13\r\3\r\3\r\3\16\3\16\3\16"+ 15595 "\3\16\3\16\3\16\7\16\u01be\n\16\f\16\16\16\u01c1\13\16\3\16\3\16\3\17"+ 15596 "\3\17\3\17\3\17\7\17\u01c9\n\17\f\17\16\17\u01cc\13\17\3\17\3\17\3\20"+ 15597 "\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"+ 15598 "\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"+ 15599 "\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u01f6\n\20\f\20\16"+ 15600 "\20\u01f9\13\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\21\7\21\u0203\n\21"+ 15601 "\f\21\16\21\u0206\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u020e\n\22"+ 15602 "\f\22\16\22\u0211\13\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3"+ 15603 "\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"+ 15604 "\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"+ 15605 "\23\3\23\3\23\7\23\u023b\n\23\f\23\16\23\u023e\13\23\3\23\3\23\3\24\3"+ 15606 "\24\3\24\3\24\3\24\3\24\7\24\u0248\n\24\f\24\16\24\u024b\13\24\3\24\3"+ 15607 "\24\3\25\3\25\3\25\3\25\7\25\u0253\n\25\f\25\16\25\u0256\13\25\3\25\3"+ 15608 "\25\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"+ 15609 "\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"+ 15610 "\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\7\26\u0280\n\26"+ 15611 "\f\26\16\26\u0283\13\26\3\26\3\26\3\27\3\27\3\27\3\27\3\27\3\27\7\27\u028d"+ 15612 "\n\27\f\27\16\27\u0290\13\27\3\27\3\27\3\30\3\30\3\30\3\30\7\30\u0298"+ 15613 "\n\30\f\30\16\30\u029b\13\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31\3"+ 15614 "\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"+ 15615 "\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"+ 15616 "\31\3\31\3\31\3\31\7\31\u02c5\n\31\f\31\16\31\u02c8\13\31\3\31\3\31\3"+ 15617 "\32\3\32\3\32\3\32\3\32\3\32\7\32\u02d2\n\32\f\32\16\32\u02d5\13\32\3"+ 15618 "\32\3\32\3\33\3\33\3\33\3\33\7\33\u02dd\n\33\f\33\16\33\u02e0\13\33\3"+ 15619 "\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\3\34\3"+ 15620 "\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3"+ 15621 "\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\7\34\u030a"+ 15622 "\n\34\f\34\16\34\u030d\13\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35\3\35\7"+ 15623 "\35\u0317\n\35\f\35\16\35\u031a\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7"+ 15624 "\36\u0322\n\36\f\36\16\36\u0325\13\36\3\36\3\36\3\37\3\37\3\37\3\37\3"+ 15625 "\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"+ 15626 "\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"+ 15627 "\37\3\37\3\37\3\37\3\37\3\37\7\37\u034f\n\37\f\37\16\37\u0352\13\37\3"+ 15628 "\37\3\37\3 \3 \3 \3 \3 \3 \7 \u035c\n \f \16 \u035f\13 \3 \3 \3!\3!\3"+ 15629 "!\3!\7!\u0367\n!\f!\16!\u036a\13!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+ 15630 "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+ 15631 "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u0394\n\"\f\""+ 15632 "\16\"\u0397\13\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u03a1\n#\f#\16#\u03a4\13"+ 15633 "#\3#\3#\3$\3$\3$\3$\7$\u03ac\n$\f$\16$\u03af\13$\3$\3$\3%\3%\3%\3%\3%"+ 15634 "\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%"+ 15635 "\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\7%\u03d9\n%\f%\16%\u03dc\13%\3%\3%\3&\3"+ 15636 "&\3&\3&\3&\3&\7&\u03e6\n&\f&\16&\u03e9\13&\3&\3&\3\'\3\'\3\'\3\'\7\'\u03f1"+ 15637 "\n\'\f\'\16\'\u03f4\13\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3"+ 15638 "(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3"+ 15639 "(\3(\3(\7(\u041e\n(\f(\16(\u0421\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u042b"+ 15640 "\n)\f)\16)\u042e\13)\3)\3)\3*\3*\3*\3*\7*\u0436\n*\f*\16*\u0439\13*\3"+ 15641 "*\3*\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3"+ 15642 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\7+\u0463\n+\f+\16+\u0466"+ 15643 "\13+\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0470\n,\f,\16,\u0473\13,\3,\3,\3-\3-"+ 15644 "\3-\3-\7-\u047b\n-\f-\16-\u047e\13-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3"+ 15645 ".\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3"+ 15646 ".\3.\3.\3.\3.\3.\7.\u04a8\n.\f.\16.\u04ab\13.\3.\3.\3/\3/\3/\3/\3/\3/"+ 15647 "\7/\u04b5\n/\f/\16/\u04b8\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u04c0\n\60"+ 15648 "\f\60\16\60\u04c3\13\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3"+ 15649 "\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\3"+ 15650 "\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\3"+ 15651 "\61\3\61\3\61\7\61\u04ed\n\61\f\61\16\61\u04f0\13\61\3\61\3\61\3\62\3"+ 15652 "\62\3\62\3\62\3\62\3\62\7\62\u04fa\n\62\f\62\16\62\u04fd\13\62\3\62\3"+ 15653 "\62\3\63\3\63\3\63\3\63\7\63\u0505\n\63\f\63\16\63\u0508\13\63\3\63\3"+ 15654 "\63\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"+ 15655 "\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"+ 15656 "\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\7\64\u0532\n\64"+ 15657 "\f\64\16\64\u0535\13\64\3\64\3\64\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3"+ 15658 "\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\5\65\u054d"+ 15659 "\n\65\3\66\3\66\3\66\3\66\3\66\3\66\7\66\u0555\n\66\f\66\16\66\u0558\13"+ 15660 "\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67\3\67\7\67\u0562\n\67\f\67\16\67"+ 15661 "\u0565\13\67\3\67\3\67\38\38\38\38\38\38\78\u056f\n8\f8\168\u0572\138"+ 15662 "\38\38\39\39\39\39\39\39\79\u057c\n9\f9\169\u057f\139\39\39\3:\3:\3:\3"+ 15663 ":\3:\3:\7:\u0589\n:\f:\16:\u058c\13:\3:\3:\3;\3;\3;\3;\3;\3;\7;\u0596"+ 15664 "\n;\f;\16;\u0599\13;\3;\3;\3<\3<\3<\3<\3<\3<\7<\u05a3\n<\f<\16<\u05a6"+ 15665 "\13<\3<\3<\3=\3=\3=\3=\3=\3=\7=\u05b0\n=\f=\16=\u05b3\13=\3=\3=\3>\3>"+ 15666 "\3>\3>\3>\3>\7>\u05bd\n>\f>\16>\u05c0\13>\3>\3>\3?\3?\3?\3?\3?\3?\7?\u05ca"+ 15667 "\n?\f?\16?\u05cd\13?\3?\3?\3@\3@\3@\3@\3@\3@\7@\u05d7\n@\f@\16@\u05da"+ 15668 "\13@\3@\3@\3A\3A\3A\3A\3A\3A\7A\u05e4\nA\fA\16A\u05e7\13A\3A\3A\3B\3B"+ 15669 "\3B\3B\3B\3B\7B\u05f1\nB\fB\16B\u05f4\13B\3B\3B\3C\3C\3C\3C\3C\3C\7C\u05fe"+ 15670 "\nC\fC\16C\u0601\13C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3"+ 15671 "F\3F\6F\u0615\nF\rF\16F\u0616\3G\3G\3G\3G\5G\u061d\nG\5G\u061f\nG\3G\3"+ 15672 "G\3G\5G\u0624\nG\5G\u0626\nG\3H\3H\7H\u062a\nH\fH\16H\u062d\13H\3H\3H"+ 15673 "\3I\3I\6I\u0633\nI\rI\16I\u0634\3I\3I\3I\7I\u063a\nI\fI\16I\u063d\13I"+ 15674 "\3I\3I\5I\u0641\nI\3I\3I\3I\3I\3I\6I\u0648\nI\rI\16I\u0649\3I\3I\7I\u064e"+ 15675 "\nI\fI\16I\u0651\13I\3I\3I\5I\u0655\nI\3I\3I\3I\3I\3I\6I\u065c\nI\rI\16"+ 15676 "I\u065d\3I\3I\7I\u0662\nI\fI\16I\u0665\13I\3I\3I\5I\u0669\nI\3I\3I\6I"+ 15677 "\u066d\nI\rI\16I\u066e\3I\3I\3I\3I\3I\3I\6I\u0677\nI\rI\16I\u0678\3I\3"+ 15678 "I\3I\5I\u067e\nI\3I\7I\u0681\nI\fI\16I\u0684\13I\3I\3I\5I\u0688\nI\3I"+ 15679 "\3I\7I\u068c\nI\fI\16I\u068f\13I\3I\3I\3I\3I\5I\u0695\nI\3I\7I\u0698\n"+ 15680 "I\fI\16I\u069b\13I\3I\3I\7I\u069f\nI\fI\16I\u06a2\13I\3I\3I\5I\u06a6\n"+ 15681 "I\3I\3I\7I\u06aa\nI\fI\16I\u06ad\13I\3I\3I\5I\u06b1\nI\3I\7I\u06b4\nI"+ 15682 "\fI\16I\u06b7\13I\3I\3I\5I\u06bb\nI\3I\7I\u06be\nI\fI\16I\u06c1\13I\3"+ 15683 "I\3I\5I\u06c5\nI\3I\3I\6I\u06c9\nI\rI\16I\u06ca\3I\3I\3I\3I\3I\3I\6I\u06d3"+ 15684 "\nI\rI\16I\u06d4\3I\3I\7I\u06d9\nI\fI\16I\u06dc\13I\3I\3I\5I\u06e0\nI"+ 15685 "\3I\3I\6I\u06e4\nI\rI\16I\u06e5\3I\3I\3I\7I\u06eb\nI\fI\16I\u06ee\13I"+ 15686 "\3I\3I\5I\u06f2\nI\5I\u06f4\nI\3J\3J\3J\3J\3J\3J\7J\u06fc\nJ\fJ\16J\u06ff"+ 15687 "\13J\3J\3J\7J\u0703\nJ\fJ\16J\u0706\13J\3J\3J\7J\u070a\nJ\fJ\16J\u070d"+ 15688 "\13J\3J\3J\6J\u0711\nJ\rJ\16J\u0712\3J\3J\7J\u0717\nJ\fJ\16J\u071a\13"+ 15689 "J\3J\3J\5J\u071e\nJ\3J\3J\6J\u0722\nJ\rJ\16J\u0723\3J\3J\7J\u0728\nJ\f"+ 15690 "J\16J\u072b\13J\3J\3J\5J\u072f\nJ\3J\3J\3J\3J\3J\7J\u0736\nJ\fJ\16J\u0739"+ 15691 "\13J\3J\3J\7J\u073d\nJ\fJ\16J\u0740\13J\3J\3J\5J\u0744\nJ\3J\3J\7J\u0748"+ 15692 "\nJ\fJ\16J\u074b\13J\3J\3J\5J\u074f\nJ\5J\u0751\nJ\3J\3J\3K\3K\3K\3K\7"+ 15693 "K\u0759\nK\fK\16K\u075c\13K\3K\3K\3L\3L\6L\u0762\nL\rL\16L\u0763\3M\3"+ 15694 "M\3M\3M\3M\3M\7M\u076c\nM\fM\16M\u076f\13M\3M\3M\3N\3N\3N\3N\3N\3N\7N"+ 15695 "\u0779\nN\fN\16N\u077c\13N\3N\3N\3O\3O\3O\3O\3O\3O\7O\u0786\nO\fO\16O"+ 15696 "\u0789\13O\3O\3O\3P\3P\3P\3P\3P\3P\7P\u0793\nP\fP\16P\u0796\13P\3P\3P"+ 15697 "\3Q\3Q\3Q\3Q\3Q\3Q\7Q\u07a0\nQ\fQ\16Q\u07a3\13Q\3Q\3Q\3Q\2\2R\2\4\6\b"+ 15698 "\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVX"+ 15699 "Z\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090"+ 15700 "\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\2\t\5\2\3\3\6\6\b\b\4"+ 15701 "\2=Kaa\3\29:\4\2LZ^`\6\2\3\3\6\6\b\b&\'\4\2\6\6\b\b\4\2\6\6\32\32\2\u0ac6"+ 15702 "\2\u00ac\3\2\2\2\4\u00ef\3\2\2\2\6\u00f1\3\2\2\2\b\u00fe\3\2\2\2\n\u0109"+ 15703 "\3\2\2\2\f\u011c\3\2\2\2\16\u012d\3\2\2\2\20\u013a\3\2\2\2\22\u0145\3"+ 15704 "\2\2\2\24\u0172\3\2\2\2\26\u017f\3\2\2\2\30\u018a\3\2\2\2\32\u01b7\3\2"+ 15705 "\2\2\34\u01c4\3\2\2\2\36\u01cf\3\2\2\2 \u01fc\3\2\2\2\"\u0209\3\2\2\2"+ 15706 "$\u0214\3\2\2\2&\u0241\3\2\2\2(\u024e\3\2\2\2*\u0259\3\2\2\2,\u0286\3"+ 15707 "\2\2\2.\u0293\3\2\2\2\60\u029e\3\2\2\2\62\u02cb\3\2\2\2\64\u02d8\3\2\2"+ 15708 "\2\66\u02e3\3\2\2\28\u0310\3\2\2\2:\u031d\3\2\2\2<\u0328\3\2\2\2>\u0355"+ 15709 "\3\2\2\2@\u0362\3\2\2\2B\u036d\3\2\2\2D\u039a\3\2\2\2F\u03a7\3\2\2\2H"+ 15710 "\u03b2\3\2\2\2J\u03df\3\2\2\2L\u03ec\3\2\2\2N\u03f7\3\2\2\2P\u0424\3\2"+ 15711 "\2\2R\u0431\3\2\2\2T\u043c\3\2\2\2V\u0469\3\2\2\2X\u0476\3\2\2\2Z\u0481"+ 15712 "\3\2\2\2\\\u04ae\3\2\2\2^\u04bb\3\2\2\2`\u04c6\3\2\2\2b\u04f3\3\2\2\2"+ 15713 "d\u0500\3\2\2\2f\u050b\3\2\2\2h\u054c\3\2\2\2j\u054e\3\2\2\2l\u055b\3"+ 15714 "\2\2\2n\u0568\3\2\2\2p\u0575\3\2\2\2r\u0582\3\2\2\2t\u058f\3\2\2\2v\u059c"+ 15715 "\3\2\2\2x\u05a9\3\2\2\2z\u05b6\3\2\2\2|\u05c3\3\2\2\2~\u05d0\3\2\2\2\u0080"+ 15716 "\u05dd\3\2\2\2\u0082\u05ea\3\2\2\2\u0084\u05f7\3\2\2\2\u0086\u0604\3\2"+ 15717 "\2\2\u0088\u060a\3\2\2\2\u008a\u0614\3\2\2\2\u008c\u0625\3\2\2\2\u008e"+ 15718 "\u0627\3\2\2\2\u0090\u06f3\3\2\2\2\u0092\u06f5\3\2\2\2\u0094\u0754\3\2"+ 15719 "\2\2\u0096\u0761\3\2\2\2\u0098\u0765\3\2\2\2\u009a\u0772\3\2\2\2\u009c"+ 15720 "\u077f\3\2\2\2\u009e\u078c\3\2\2\2\u00a0\u0799\3\2\2\2\u00a2\u00ab\5\4"+ 15721 "\3\2\u00a3\u00a4\6\2\2\2\u00a4\u00ab\7\3\2\2\u00a5\u00ab\5\u0094K\2\u00a6"+ 15722 "\u00ab\7\5\2\2\u00a7\u00ab\7\b\2\2\u00a8\u00ab\5\u0096L\2\u00a9\u00ab"+ 15723 "\5\u0092J\2\u00aa\u00a2\3\2\2\2\u00aa\u00a3\3\2\2\2\u00aa\u00a5\3\2\2"+ 15724 "\2\u00aa\u00a6\3\2\2\2\u00aa\u00a7\3\2\2\2\u00aa\u00a8\3\2\2\2\u00aa\u00a9"+ 15725 "\3\2\2\2\u00ab\u00ae\3\2\2\2\u00ac\u00aa\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad"+ 15726 "\u00bb\3\2\2\2\u00ae\u00ac\3\2\2\2\u00af\u00b1\7\3\2\2\u00b0\u00af\3\2"+ 15727 "\2\2\u00b0\u00b1\3\2\2\2\u00b1\u00b5\3\2\2\2\u00b2\u00b4\7\6\2\2\u00b3"+ 15728 "\u00b2\3\2\2\2\u00b4\u00b7\3\2\2\2\u00b5\u00b3\3\2\2\2\u00b5\u00b6\3\2"+ 15729 "\2\2\u00b6\u00b8\3\2\2\2\u00b7\u00b5\3\2\2\2\u00b8\u00ba\5\u0090I\2\u00b9"+ 15730 "\u00b0\3\2\2\2\u00ba\u00bd\3\2\2\2\u00bb\u00b9\3\2\2\2\u00bb\u00bc\3\2"+ 15731 "\2\2\u00bc\u00be\3\2\2\2\u00bd\u00bb\3\2\2\2\u00be\u00bf\7\2\2\3\u00bf"+ 15732 "\3\3\2\2\2\u00c0\u00f0\5\f\7\2\u00c1\u00f0\5h\65\2\u00c2\u00f0\5\22\n"+ 15733 "\2\u00c3\u00f0\5\30\r\2\u00c4\u00f0\5\36\20\2\u00c5\u00f0\5$\23\2\u00c6"+ 15734 "\u00f0\5*\26\2\u00c7\u00f0\5\60\31\2\u00c8\u00f0\5\66\34\2\u00c9\u00f0"+ 15735 "\5<\37\2\u00ca\u00f0\5B\"\2\u00cb\u00f0\5H%\2\u00cc\u00f0\5N(\2\u00cd"+ 15736 "\u00f0\5T+\2\u00ce\u00f0\5Z.\2\u00cf\u00f0\5f\64\2\u00d0\u00f0\5`\61\2"+ 15737 "\u00d1\u00f0\5\16\b\2\u00d2\u00f0\5\24\13\2\u00d3\u00f0\5\32\16\2\u00d4"+ 15738 "\u00f0\5 \21\2\u00d5\u00f0\5&\24\2\u00d6\u00f0\5,\27\2\u00d7\u00f0\5\62"+ 15739 "\32\2\u00d8\u00f0\58\35\2\u00d9\u00f0\5> \2\u00da\u00f0\5D#\2\u00db\u00f0"+ 15740 "\5J&\2\u00dc\u00f0\5P)\2\u00dd\u00f0\5V,\2\u00de\u00f0\5b\62\2\u00df\u00f0"+ 15741 "\5\\/\2\u00e0\u00f0\5\20\t\2\u00e1\u00f0\5\26\f\2\u00e2\u00f0\5\34\17"+ 15742 "\2\u00e3\u00f0\5\"\22\2\u00e4\u00f0\5(\25\2\u00e5\u00f0\5.\30\2\u00e6"+ 15743 "\u00f0\5\64\33\2\u00e7\u00f0\5:\36\2\u00e8\u00f0\5@!\2\u00e9\u00f0\5F"+ 15744 "$\2\u00ea\u00f0\5L\'\2\u00eb\u00f0\5R*\2\u00ec\u00f0\5X-\2\u00ed\u00f0"+ 15745 "\5d\63\2\u00ee\u00f0\5^\60\2\u00ef\u00c0\3\2\2\2\u00ef\u00c1\3\2\2\2\u00ef"+ 15746 "\u00c2\3\2\2\2\u00ef\u00c3\3\2\2\2\u00ef\u00c4\3\2\2\2\u00ef\u00c5\3\2"+ 15747 "\2\2\u00ef\u00c6\3\2\2\2\u00ef\u00c7\3\2\2\2\u00ef\u00c8\3\2\2\2\u00ef"+ 15748 "\u00c9\3\2\2\2\u00ef\u00ca\3\2\2\2\u00ef\u00cb\3\2\2\2\u00ef\u00cc\3\2"+ 15749 "\2\2\u00ef\u00cd\3\2\2\2\u00ef\u00ce\3\2\2\2\u00ef\u00cf\3\2\2\2\u00ef"+ 15750 "\u00d0\3\2\2\2\u00ef\u00d1\3\2\2\2\u00ef\u00d2\3\2\2\2\u00ef\u00d3\3\2"+ 15751 "\2\2\u00ef\u00d4\3\2\2\2\u00ef\u00d5\3\2\2\2\u00ef\u00d6\3\2\2\2\u00ef"+ 15752 "\u00d7\3\2\2\2\u00ef\u00d8\3\2\2\2\u00ef\u00d9\3\2\2\2\u00ef\u00da\3\2"+ 15753 "\2\2\u00ef\u00db\3\2\2\2\u00ef\u00dc\3\2\2\2\u00ef\u00dd\3\2\2\2\u00ef"+ 15754 "\u00de\3\2\2\2\u00ef\u00df\3\2\2\2\u00ef\u00e0\3\2\2\2\u00ef\u00e1\3\2"+ 15755 "\2\2\u00ef\u00e2\3\2\2\2\u00ef\u00e3\3\2\2\2\u00ef\u00e4\3\2\2\2\u00ef"+ 15756 "\u00e5\3\2\2\2\u00ef\u00e6\3\2\2\2\u00ef\u00e7\3\2\2\2\u00ef\u00e8\3\2"+ 15757 "\2\2\u00ef\u00e9\3\2\2\2\u00ef\u00ea\3\2\2\2\u00ef\u00eb\3\2\2\2\u00ef"+ 15758 "\u00ec\3\2\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00ee\3\2\2\2\u00f0\5\3\2\2\2"+ 15759 "\u00f1\u00f2\7\7\2\2\u00f2\u00f9\7a\2\2\u00f3\u00f8\5\n\6\2\u00f4\u00f8"+ 15760 "\7\b\2\2\u00f5\u00f8\7\3\2\2\u00f6\u00f8\7\6\2\2\u00f7\u00f3\3\2\2\2\u00f7"+ 15761 "\u00f4\3\2\2\2\u00f7\u00f5\3\2\2\2\u00f7\u00f6\3\2\2\2\u00f8\u00fb\3\2"+ 15762 "\2\2\u00f9\u00f7\3\2\2\2\u00f9\u00fa\3\2\2\2\u00fa\u00fc\3\2\2\2\u00fb"+ 15763 "\u00f9\3\2\2\2\u00fc\u00fd\79\2\2\u00fd\7\3\2\2\2\u00fe\u00ff\7\7\2\2"+ 15764 "\u00ff\u0100\7;\2\2\u0100\u0104\7a\2\2\u0101\u0103\t\2\2\2\u0102\u0101"+ 15765 "\3\2\2\2\u0103\u0106\3\2\2\2\u0104\u0102\3\2\2\2\u0104\u0105\3\2\2\2\u0105"+ 15766 "\u0107\3\2\2\2\u0106\u0104\3\2\2\2\u0107\u0108\79\2\2\u0108\t\3\2\2\2"+ 15767 "\u0109\u010d\7a\2\2\u010a\u010c\t\2\2\2\u010b\u010a\3\2\2\2\u010c\u010f"+ 15768 "\3\2\2\2\u010d\u010b\3\2\2\2\u010d\u010e\3\2\2\2\u010e\u0110\3\2\2\2\u010f"+ 15769 "\u010d\3\2\2\2\u0110\u0114\7<\2\2\u0111\u0113\t\2\2\2\u0112\u0111\3\2"+ 15770 "\2\2\u0113\u0116\3\2\2\2\u0114\u0112\3\2\2\2\u0114\u0115\3\2\2\2\u0115"+ 15771 "\u011a\3\2\2\2\u0116\u0114\3\2\2\2\u0117\u011b\7[\2\2\u0118\u011b\5\u0096"+ 15772 "L\2\u0119\u011b\7a\2\2\u011a\u0117\3\2\2\2\u011a\u0118\3\2\2\2\u011a\u0119"+ 15773 "\3\2\2\2\u011b\13\3\2\2\2\u011c\u0127\5\6\4\2\u011d\u0126\5\4\3\2\u011e"+ 15774 "\u011f\6\7\3\2\u011f\u0126\7\3\2\2\u0120\u0126\5\u0094K\2\u0121\u0126"+ 15775 "\7\5\2\2\u0122\u0126\7\b\2\2\u0123\u0126\5\u0096L\2\u0124\u0126\5\u0092"+ 15776 "J\2\u0125\u011d\3\2\2\2\u0125\u011e\3\2\2\2\u0125\u0120\3\2\2\2\u0125"+ 15777 "\u0121\3\2\2\2\u0125\u0122\3\2\2\2\u0125\u0123\3\2\2\2\u0125\u0124\3\2"+ 15778 "\2\2\u0126\u0129\3\2\2\2\u0127\u0125\3\2\2\2\u0127\u0128\3\2\2\2\u0128"+ 15779 "\u012a\3\2\2\2\u0129\u0127\3\2\2\2\u012a\u012b\5\b\5\2\u012b\u012c\6\7"+ 15780 "\4\3\u012c\r\3\2\2\2\u012d\u012e\7\7\2\2\u012e\u0135\7=\2\2\u012f\u0134"+ 15781 "\5\n\6\2\u0130\u0134\7\b\2\2\u0131\u0134\7\3\2\2\u0132\u0134\7\6\2\2\u0133"+ 15782 "\u012f\3\2\2\2\u0133\u0130\3\2\2\2\u0133\u0131\3\2\2\2\u0133\u0132\3\2"+ 15783 "\2\2\u0134\u0137\3\2\2\2\u0135\u0133\3\2\2\2\u0135\u0136\3\2\2\2\u0136"+ 15784 "\u0138\3\2\2\2\u0137\u0135\3\2\2\2\u0138\u0139\79\2\2\u0139\17\3\2\2\2"+ 15785 "\u013a\u013b\7\7\2\2\u013b\u013c\7;\2\2\u013c\u0140\7=\2\2\u013d\u013f"+ 15786 "\t\2\2\2\u013e\u013d\3\2\2\2\u013f\u0142\3\2\2\2\u0140\u013e\3\2\2\2\u0140"+ 15787 "\u0141\3\2\2\2\u0141\u0143\3\2\2\2\u0142\u0140\3\2\2\2\u0143\u0144\79"+ 15788 "\2\2\u0144\21\3\2\2\2\u0145\u016d\5\16\b\2\u0146\u016c\5\f\7\2\u0147\u016c"+ 15789 "\5h\65\2\u0148\u016c\5\30\r\2\u0149\u016c\5\36\20\2\u014a\u016c\5$\23"+ 15790 "\2\u014b\u016c\5*\26\2\u014c\u016c\5\60\31\2\u014d\u016c\5\66\34\2\u014e"+ 15791 "\u016c\5<\37\2\u014f\u016c\5B\"\2\u0150\u016c\5H%\2\u0151\u016c\5N(\2"+ 15792 "\u0152\u016c\5T+\2\u0153\u016c\5Z.\2\u0154\u016c\5f\64\2\u0155\u016c\5"+ 15793 "`\61\2\u0156\u016c\5\24\13\2\u0157\u016c\5\32\16\2\u0158\u016c\5 \21\2"+ 15794 "\u0159\u016c\5&\24\2\u015a\u016c\5,\27\2\u015b\u016c\5\62\32\2\u015c\u016c"+ 15795 "\58\35\2\u015d\u016c\5> \2\u015e\u016c\5D#\2\u015f\u016c\5J&\2\u0160\u016c"+ 15796 "\5P)\2\u0161\u016c\5V,\2\u0162\u016c\5b\62\2\u0163\u016c\5\\/\2\u0164"+ 15797 "\u0165\6\n\5\2\u0165\u016c\7\3\2\2\u0166\u016c\5\u0094K\2\u0167\u016c"+ 15798 "\7\5\2\2\u0168\u016c\7\b\2\2\u0169\u016c\5\u0096L\2\u016a\u016c\5\u0092"+ 15799 "J\2\u016b\u0146\3\2\2\2\u016b\u0147\3\2\2\2\u016b\u0148\3\2\2\2\u016b"+ 15800 "\u0149\3\2\2\2\u016b\u014a\3\2\2\2\u016b\u014b\3\2\2\2\u016b\u014c\3\2"+ 15801 "\2\2\u016b\u014d\3\2\2\2\u016b\u014e\3\2\2\2\u016b\u014f\3\2\2\2\u016b"+ 15802 "\u0150\3\2\2\2\u016b\u0151\3\2\2\2\u016b\u0152\3\2\2\2\u016b\u0153\3\2"+ 15803 "\2\2\u016b\u0154\3\2\2\2\u016b\u0155\3\2\2\2\u016b\u0156\3\2\2\2\u016b"+ 15804 "\u0157\3\2\2\2\u016b\u0158\3\2\2\2\u016b\u0159\3\2\2\2\u016b\u015a\3\2"+ 15805 "\2\2\u016b\u015b\3\2\2\2\u016b\u015c\3\2\2\2\u016b\u015d\3\2\2\2\u016b"+ 15806 "\u015e\3\2\2\2\u016b\u015f\3\2\2\2\u016b\u0160\3\2\2\2\u016b\u0161\3\2"+ 15807 "\2\2\u016b\u0162\3\2\2\2\u016b\u0163\3\2\2\2\u016b\u0164\3\2\2\2\u016b"+ 15808 "\u0166\3\2\2\2\u016b\u0167\3\2\2\2\u016b\u0168\3\2\2\2\u016b\u0169\3\2"+ 15809 "\2\2\u016b\u016a\3\2\2\2\u016c\u016f\3\2\2\2\u016d\u016b\3\2\2\2\u016d"+ 15810 "\u016e\3\2\2\2\u016e\u0170\3\2\2\2\u016f\u016d\3\2\2\2\u0170\u0171\5\20"+ 15811 "\t\2\u0171\23\3\2\2\2\u0172\u0173\7\7\2\2\u0173\u017a\7>\2\2\u0174\u0179"+ 15812 "\5\n\6\2\u0175\u0179\7\b\2\2\u0176\u0179\7\3\2\2\u0177\u0179\7\6\2\2\u0178"+ 15813 "\u0174\3\2\2\2\u0178\u0175\3\2\2\2\u0178\u0176\3\2\2\2\u0178\u0177\3\2"+ 15814 "\2\2\u0179\u017c\3\2\2\2\u017a\u0178\3\2\2\2\u017a\u017b\3\2\2\2\u017b"+ 15815 "\u017d\3\2\2\2\u017c\u017a\3\2\2\2\u017d\u017e\79\2\2\u017e\25\3\2\2\2"+ 15816 "\u017f\u0180\7\7\2\2\u0180\u0181\7;\2\2\u0181\u0185\7>\2\2\u0182\u0184"+ 15817 "\t\2\2\2\u0183\u0182\3\2\2\2\u0184\u0187\3\2\2\2\u0185\u0183\3\2\2\2\u0185"+ 15818 "\u0186\3\2\2\2\u0186\u0188\3\2\2\2\u0187\u0185\3\2\2\2\u0188\u0189\79"+ 15819 "\2\2\u0189\27\3\2\2\2\u018a\u01b2\5\24\13\2\u018b\u01b1\5\f\7\2\u018c"+ 15820 "\u01b1\5h\65\2\u018d\u01b1\5\22\n\2\u018e\u01b1\5\36\20\2\u018f\u01b1"+ 15821 "\5$\23\2\u0190\u01b1\5*\26\2\u0191\u01b1\5\60\31\2\u0192\u01b1\5\66\34"+ 15822 "\2\u0193\u01b1\5<\37\2\u0194\u01b1\5B\"\2\u0195\u01b1\5H%\2\u0196\u01b1"+ 15823 "\5N(\2\u0197\u01b1\5T+\2\u0198\u01b1\5Z.\2\u0199\u01b1\5f\64\2\u019a\u01b1"+ 15824 "\5`\61\2\u019b\u01b1\5\16\b\2\u019c\u01b1\5\32\16\2\u019d\u01b1\5 \21"+ 15825 "\2\u019e\u01b1\5&\24\2\u019f\u01b1\5,\27\2\u01a0\u01b1\5\62\32\2\u01a1"+ 15826 "\u01b1\58\35\2\u01a2\u01b1\5> \2\u01a3\u01b1\5D#\2\u01a4\u01b1\5J&\2\u01a5"+ 15827 "\u01b1\5P)\2\u01a6\u01b1\5V,\2\u01a7\u01b1\5b\62\2\u01a8\u01b1\5\\/\2"+ 15828 "\u01a9\u01aa\6\r\6\2\u01aa\u01b1\7\3\2\2\u01ab\u01b1\5\u0094K\2\u01ac"+ 15829 "\u01b1\7\5\2\2\u01ad\u01b1\7\b\2\2\u01ae\u01b1\5\u0096L\2\u01af\u01b1"+ 15830 "\5\u0092J\2\u01b0\u018b\3\2\2\2\u01b0\u018c\3\2\2\2\u01b0\u018d\3\2\2"+ 15831 "\2\u01b0\u018e\3\2\2\2\u01b0\u018f\3\2\2\2\u01b0\u0190\3\2\2\2\u01b0\u0191"+ 15832 "\3\2\2\2\u01b0\u0192\3\2\2\2\u01b0\u0193\3\2\2\2\u01b0\u0194\3\2\2\2\u01b0"+ 15833 "\u0195\3\2\2\2\u01b0\u0196\3\2\2\2\u01b0\u0197\3\2\2\2\u01b0\u0198\3\2"+ 15834 "\2\2\u01b0\u0199\3\2\2\2\u01b0\u019a\3\2\2\2\u01b0\u019b\3\2\2\2\u01b0"+ 15835 "\u019c\3\2\2\2\u01b0\u019d\3\2\2\2\u01b0\u019e\3\2\2\2\u01b0\u019f\3\2"+ 15836 "\2\2\u01b0\u01a0\3\2\2\2\u01b0\u01a1\3\2\2\2\u01b0\u01a2\3\2\2\2\u01b0"+ 15837 "\u01a3\3\2\2\2\u01b0\u01a4\3\2\2\2\u01b0\u01a5\3\2\2\2\u01b0\u01a6\3\2"+ 15838 "\2\2\u01b0\u01a7\3\2\2\2\u01b0\u01a8\3\2\2\2\u01b0\u01a9\3\2\2\2\u01b0"+ 15839 "\u01ab\3\2\2\2\u01b0\u01ac\3\2\2\2\u01b0\u01ad\3\2\2\2\u01b0\u01ae\3\2"+ 15840 "\2\2\u01b0\u01af\3\2\2\2\u01b1\u01b4\3\2\2\2\u01b2\u01b0\3\2\2\2\u01b2"+ 15841 "\u01b3\3\2\2\2\u01b3\u01b5\3\2\2\2\u01b4\u01b2\3\2\2\2\u01b5\u01b6\5\26"+ 15842 "\f\2\u01b6\31\3\2\2\2\u01b7\u01b8\7\7\2\2\u01b8\u01bf\7?\2\2\u01b9\u01be"+ 15843 "\5\n\6\2\u01ba\u01be\7\b\2\2\u01bb\u01be\7\3\2\2\u01bc\u01be\7\6\2\2\u01bd"+ 15844 "\u01b9\3\2\2\2\u01bd\u01ba\3\2\2\2\u01bd\u01bb\3\2\2\2\u01bd\u01bc\3\2"+ 15845 "\2\2\u01be\u01c1\3\2\2\2\u01bf\u01bd\3\2\2\2\u01bf\u01c0\3\2\2\2\u01c0"+ 15846 "\u01c2\3\2\2\2\u01c1\u01bf\3\2\2\2\u01c2\u01c3\79\2\2\u01c3\33\3\2\2\2"+ 15847 "\u01c4\u01c5\7\7\2\2\u01c5\u01c6\7;\2\2\u01c6\u01ca\7?\2\2\u01c7\u01c9"+ 15848 "\t\2\2\2\u01c8\u01c7\3\2\2\2\u01c9\u01cc\3\2\2\2\u01ca\u01c8\3\2\2\2\u01ca"+ 15849 "\u01cb\3\2\2\2\u01cb\u01cd\3\2\2\2\u01cc\u01ca\3\2\2\2\u01cd\u01ce\79"+ 15850 "\2\2\u01ce\35\3\2\2\2\u01cf\u01f7\5\32\16\2\u01d0\u01f6\5\f\7\2\u01d1"+ 15851 "\u01f6\5h\65\2\u01d2\u01f6\5\22\n\2\u01d3\u01f6\5\30\r\2\u01d4\u01f6\5"+ 15852 "$\23\2\u01d5\u01f6\5*\26\2\u01d6\u01f6\5\60\31\2\u01d7\u01f6\5\66\34\2"+ 15853 "\u01d8\u01f6\5<\37\2\u01d9\u01f6\5B\"\2\u01da\u01f6\5H%\2\u01db\u01f6"+ 15854 "\5N(\2\u01dc\u01f6\5T+\2\u01dd\u01f6\5Z.\2\u01de\u01f6\5f\64\2\u01df\u01f6"+ 15855 "\5`\61\2\u01e0\u01f6\5\16\b\2\u01e1\u01f6\5\24\13\2\u01e2\u01f6\5 \21"+ 15856 "\2\u01e3\u01f6\5&\24\2\u01e4\u01f6\5,\27\2\u01e5\u01f6\5\62\32\2\u01e6"+ 15857 "\u01f6\58\35\2\u01e7\u01f6\5> \2\u01e8\u01f6\5D#\2\u01e9\u01f6\5J&\2\u01ea"+ 15858 "\u01f6\5P)\2\u01eb\u01f6\5V,\2\u01ec\u01f6\5b\62\2\u01ed\u01f6\5\\/\2"+ 15859 "\u01ee\u01ef\6\20\7\2\u01ef\u01f6\7\3\2\2\u01f0\u01f6\5\u0094K\2\u01f1"+ 15860 "\u01f6\7\5\2\2\u01f2\u01f6\7\b\2\2\u01f3\u01f6\5\u0096L\2\u01f4\u01f6"+ 15861 "\5\u0092J\2\u01f5\u01d0\3\2\2\2\u01f5\u01d1\3\2\2\2\u01f5\u01d2\3\2\2"+ 15862 "\2\u01f5\u01d3\3\2\2\2\u01f5\u01d4\3\2\2\2\u01f5\u01d5\3\2\2\2\u01f5\u01d6"+ 15863 "\3\2\2\2\u01f5\u01d7\3\2\2\2\u01f5\u01d8\3\2\2\2\u01f5\u01d9\3\2\2\2\u01f5"+ 15864 "\u01da\3\2\2\2\u01f5\u01db\3\2\2\2\u01f5\u01dc\3\2\2\2\u01f5\u01dd\3\2"+ 15865 "\2\2\u01f5\u01de\3\2\2\2\u01f5\u01df\3\2\2\2\u01f5\u01e0\3\2\2\2\u01f5"+ 15866 "\u01e1\3\2\2\2\u01f5\u01e2\3\2\2\2\u01f5\u01e3\3\2\2\2\u01f5\u01e4\3\2"+ 15867 "\2\2\u01f5\u01e5\3\2\2\2\u01f5\u01e6\3\2\2\2\u01f5\u01e7\3\2\2\2\u01f5"+ 15868 "\u01e8\3\2\2\2\u01f5\u01e9\3\2\2\2\u01f5\u01ea\3\2\2\2\u01f5\u01eb\3\2"+ 15869 "\2\2\u01f5\u01ec\3\2\2\2\u01f5\u01ed\3\2\2\2\u01f5\u01ee\3\2\2\2\u01f5"+ 15870 "\u01f0\3\2\2\2\u01f5\u01f1\3\2\2\2\u01f5\u01f2\3\2\2\2\u01f5\u01f3\3\2"+ 15871 "\2\2\u01f5\u01f4\3\2\2\2\u01f6\u01f9\3\2\2\2\u01f7\u01f5\3\2\2\2\u01f7"+ 15872 "\u01f8\3\2\2\2\u01f8\u01fa\3\2\2\2\u01f9\u01f7\3\2\2\2\u01fa\u01fb\5\34"+ 15873 "\17\2\u01fb\37\3\2\2\2\u01fc\u01fd\7\7\2\2\u01fd\u0204\7@\2\2\u01fe\u0203"+ 15874 "\5\n\6\2\u01ff\u0203\7\b\2\2\u0200\u0203\7\3\2\2\u0201\u0203\7\6\2\2\u0202"+ 15875 "\u01fe\3\2\2\2\u0202\u01ff\3\2\2\2\u0202\u0200\3\2\2\2\u0202\u0201\3\2"+ 15876 "\2\2\u0203\u0206\3\2\2\2\u0204\u0202\3\2\2\2\u0204\u0205\3\2\2\2\u0205"+ 15877 "\u0207\3\2\2\2\u0206\u0204\3\2\2\2\u0207\u0208\79\2\2\u0208!\3\2\2\2\u0209"+ 15878 "\u020a\7\7\2\2\u020a\u020b\7;\2\2\u020b\u020f\7@\2\2\u020c\u020e\t\2\2"+ 15879 "\2\u020d\u020c\3\2\2\2\u020e\u0211\3\2\2\2\u020f\u020d\3\2\2\2\u020f\u0210"+ 15880 "\3\2\2\2\u0210\u0212\3\2\2\2\u0211\u020f\3\2\2\2\u0212\u0213\79\2\2\u0213"+ 15881 "#\3\2\2\2\u0214\u023c\5 \21\2\u0215\u023b\5\f\7\2\u0216\u023b\5h\65\2"+ 15882 "\u0217\u023b\5\22\n\2\u0218\u023b\5\30\r\2\u0219\u023b\5\36\20\2\u021a"+ 15883 "\u023b\5*\26\2\u021b\u023b\5\60\31\2\u021c\u023b\5\66\34\2\u021d\u023b"+ 15884 "\5<\37\2\u021e\u023b\5B\"\2\u021f\u023b\5H%\2\u0220\u023b\5N(\2\u0221"+ 15885 "\u023b\5T+\2\u0222\u023b\5Z.\2\u0223\u023b\5f\64\2\u0224\u023b\5`\61\2"+ 15886 "\u0225\u023b\5\16\b\2\u0226\u023b\5\24\13\2\u0227\u023b\5 \21\2\u0228"+ 15887 "\u023b\5&\24\2\u0229\u023b\5,\27\2\u022a\u023b\5\62\32\2\u022b\u023b\5"+ 15888 "8\35\2\u022c\u023b\5> \2\u022d\u023b\5D#\2\u022e\u023b\5J&\2\u022f\u023b"+ 15889 "\5P)\2\u0230\u023b\5V,\2\u0231\u023b\5b\62\2\u0232\u023b\5\\/\2\u0233"+ 15890 "\u0234\6\23\b\2\u0234\u023b\7\3\2\2\u0235\u023b\5\u0094K\2\u0236\u023b"+ 15891 "\7\5\2\2\u0237\u023b\7\b\2\2\u0238\u023b\5\u0096L\2\u0239\u023b\5\u0092"+ 15892 "J\2\u023a\u0215\3\2\2\2\u023a\u0216\3\2\2\2\u023a\u0217\3\2\2\2\u023a"+ 15893 "\u0218\3\2\2\2\u023a\u0219\3\2\2\2\u023a\u021a\3\2\2\2\u023a\u021b\3\2"+ 15894 "\2\2\u023a\u021c\3\2\2\2\u023a\u021d\3\2\2\2\u023a\u021e\3\2\2\2\u023a"+ 15895 "\u021f\3\2\2\2\u023a\u0220\3\2\2\2\u023a\u0221\3\2\2\2\u023a\u0222\3\2"+ 15896 "\2\2\u023a\u0223\3\2\2\2\u023a\u0224\3\2\2\2\u023a\u0225\3\2\2\2\u023a"+ 15897 "\u0226\3\2\2\2\u023a\u0227\3\2\2\2\u023a\u0228\3\2\2\2\u023a\u0229\3\2"+ 15898 "\2\2\u023a\u022a\3\2\2\2\u023a\u022b\3\2\2\2\u023a\u022c\3\2\2\2\u023a"+ 15899 "\u022d\3\2\2\2\u023a\u022e\3\2\2\2\u023a\u022f\3\2\2\2\u023a\u0230\3\2"+ 15900 "\2\2\u023a\u0231\3\2\2\2\u023a\u0232\3\2\2\2\u023a\u0233\3\2\2\2\u023a"+ 15901 "\u0235\3\2\2\2\u023a\u0236\3\2\2\2\u023a\u0237\3\2\2\2\u023a\u0238\3\2"+ 15902 "\2\2\u023a\u0239\3\2\2\2\u023b\u023e\3\2\2\2\u023c\u023a\3\2\2\2\u023c"+ 15903 "\u023d\3\2\2\2\u023d\u023f\3\2\2\2\u023e\u023c\3\2\2\2\u023f\u0240\5\""+ 15904 "\22\2\u0240%\3\2\2\2\u0241\u0242\7\7\2\2\u0242\u0249\7A\2\2\u0243\u0248"+ 15905 "\5\n\6\2\u0244\u0248\7\b\2\2\u0245\u0248\7\3\2\2\u0246\u0248\7\6\2\2\u0247"+ 15906 "\u0243\3\2\2\2\u0247\u0244\3\2\2\2\u0247\u0245\3\2\2\2\u0247\u0246\3\2"+ 15907 "\2\2\u0248\u024b\3\2\2\2\u0249\u0247\3\2\2\2\u0249\u024a\3\2\2\2\u024a"+ 15908 "\u024c\3\2\2\2\u024b\u0249\3\2\2\2\u024c\u024d\79\2\2\u024d\'\3\2\2\2"+ 15909 "\u024e\u024f\7\7\2\2\u024f\u0250\7;\2\2\u0250\u0254\7A\2\2\u0251\u0253"+ 15910 "\t\2\2\2\u0252\u0251\3\2\2\2\u0253\u0256\3\2\2\2\u0254\u0252\3\2\2\2\u0254"+ 15911 "\u0255\3\2\2\2\u0255\u0257\3\2\2\2\u0256\u0254\3\2\2\2\u0257\u0258\79"+ 15912 "\2\2\u0258)\3\2\2\2\u0259\u0281\5&\24\2\u025a\u0280\5\f\7\2\u025b\u0280"+ 15913 "\5h\65\2\u025c\u0280\5\22\n\2\u025d\u0280\5\30\r\2\u025e\u0280\5\36\20"+ 15914 "\2\u025f\u0280\5$\23\2\u0260\u0280\5\60\31\2\u0261\u0280\5\66\34\2\u0262"+ 15915 "\u0280\5<\37\2\u0263\u0280\5B\"\2\u0264\u0280\5H%\2\u0265\u0280\5N(\2"+ 15916 "\u0266\u0280\5T+\2\u0267\u0280\5Z.\2\u0268\u0280\5f\64\2\u0269\u0280\5"+ 15917 "`\61\2\u026a\u0280\5\16\b\2\u026b\u0280\5\24\13\2\u026c\u0280\5\32\16"+ 15918 "\2\u026d\u0280\5 \21\2\u026e\u0280\5,\27\2\u026f\u0280\5\62\32\2\u0270"+ 15919 "\u0280\58\35\2\u0271\u0280\5> \2\u0272\u0280\5D#\2\u0273\u0280\5J&\2\u0274"+ 15920 "\u0280\5P)\2\u0275\u0280\5V,\2\u0276\u0280\5b\62\2\u0277\u0280\5\\/\2"+ 15921 "\u0278\u0279\6\26\t\2\u0279\u0280\7\3\2\2\u027a\u0280\5\u0094K\2\u027b"+ 15922 "\u0280\7\5\2\2\u027c\u0280\7\b\2\2\u027d\u0280\5\u0096L\2\u027e\u0280"+ 15923 "\5\u0092J\2\u027f\u025a\3\2\2\2\u027f\u025b\3\2\2\2\u027f\u025c\3\2\2"+ 15924 "\2\u027f\u025d\3\2\2\2\u027f\u025e\3\2\2\2\u027f\u025f\3\2\2\2\u027f\u0260"+ 15925 "\3\2\2\2\u027f\u0261\3\2\2\2\u027f\u0262\3\2\2\2\u027f\u0263\3\2\2\2\u027f"+ 15926 "\u0264\3\2\2\2\u027f\u0265\3\2\2\2\u027f\u0266\3\2\2\2\u027f\u0267\3\2"+ 15927 "\2\2\u027f\u0268\3\2\2\2\u027f\u0269\3\2\2\2\u027f\u026a\3\2\2\2\u027f"+ 15928 "\u026b\3\2\2\2\u027f\u026c\3\2\2\2\u027f\u026d\3\2\2\2\u027f\u026e\3\2"+ 15929 "\2\2\u027f\u026f\3\2\2\2\u027f\u0270\3\2\2\2\u027f\u0271\3\2\2\2\u027f"+ 15930 "\u0272\3\2\2\2\u027f\u0273\3\2\2\2\u027f\u0274\3\2\2\2\u027f\u0275\3\2"+ 15931 "\2\2\u027f\u0276\3\2\2\2\u027f\u0277\3\2\2\2\u027f\u0278\3\2\2\2\u027f"+ 15932 "\u027a\3\2\2\2\u027f\u027b\3\2\2\2\u027f\u027c\3\2\2\2\u027f\u027d\3\2"+ 15933 "\2\2\u027f\u027e\3\2\2\2\u0280\u0283\3\2\2\2\u0281\u027f\3\2\2\2\u0281"+ 15934 "\u0282\3\2\2\2\u0282\u0284\3\2\2\2\u0283\u0281\3\2\2\2\u0284\u0285\5("+ 15935 "\25\2\u0285+\3\2\2\2\u0286\u0287\7\7\2\2\u0287\u028e\7B\2\2\u0288\u028d"+ 15936 "\5\n\6\2\u0289\u028d\7\b\2\2\u028a\u028d\7\3\2\2\u028b\u028d\7\6\2\2\u028c"+ 15937 "\u0288\3\2\2\2\u028c\u0289\3\2\2\2\u028c\u028a\3\2\2\2\u028c\u028b\3\2"+ 15938 "\2\2\u028d\u0290\3\2\2\2\u028e\u028c\3\2\2\2\u028e\u028f\3\2\2\2\u028f"+ 15939 "\u0291\3\2\2\2\u0290\u028e\3\2\2\2\u0291\u0292\79\2\2\u0292-\3\2\2\2\u0293"+ 15940 "\u0294\7\7\2\2\u0294\u0295\7;\2\2\u0295\u0299\7B\2\2\u0296\u0298\t\2\2"+ 15941 "\2\u0297\u0296\3\2\2\2\u0298\u029b\3\2\2\2\u0299\u0297\3\2\2\2\u0299\u029a"+ 15942 "\3\2\2\2\u029a\u029c\3\2\2\2\u029b\u0299\3\2\2\2\u029c\u029d\79\2\2\u029d"+ 15943 "/\3\2\2\2\u029e\u02c6\5,\27\2\u029f\u02c5\5\f\7\2\u02a0\u02c5\5h\65\2"+ 15944 "\u02a1\u02c5\5\22\n\2\u02a2\u02c5\5\30\r\2\u02a3\u02c5\5\36\20\2\u02a4"+ 15945 "\u02c5\5$\23\2\u02a5\u02c5\5*\26\2\u02a6\u02c5\5\66\34\2\u02a7\u02c5\5"+ 15946 "<\37\2\u02a8\u02c5\5B\"\2\u02a9\u02c5\5H%\2\u02aa\u02c5\5N(\2\u02ab\u02c5"+ 15947 "\5T+\2\u02ac\u02c5\5Z.\2\u02ad\u02c5\5f\64\2\u02ae\u02c5\5`\61\2\u02af"+ 15948 "\u02c5\5\16\b\2\u02b0\u02c5\5\24\13\2\u02b1\u02c5\5\32\16\2\u02b2\u02c5"+ 15949 "\5 \21\2\u02b3\u02c5\5&\24\2\u02b4\u02c5\5\62\32\2\u02b5\u02c5\58\35\2"+ 15950 "\u02b6\u02c5\5> \2\u02b7\u02c5\5D#\2\u02b8\u02c5\5J&\2\u02b9\u02c5\5P"+ 15951 ")\2\u02ba\u02c5\5V,\2\u02bb\u02c5\5b\62\2\u02bc\u02c5\5\\/\2\u02bd\u02be"+ 15952 "\6\31\n\2\u02be\u02c5\7\3\2\2\u02bf\u02c5\5\u0094K\2\u02c0\u02c5\7\5\2"+ 15953 "\2\u02c1\u02c5\7\b\2\2\u02c2\u02c5\5\u0096L\2\u02c3\u02c5\5\u0092J\2\u02c4"+ 15954 "\u029f\3\2\2\2\u02c4\u02a0\3\2\2\2\u02c4\u02a1\3\2\2\2\u02c4\u02a2\3\2"+ 15955 "\2\2\u02c4\u02a3\3\2\2\2\u02c4\u02a4\3\2\2\2\u02c4\u02a5\3\2\2\2\u02c4"+ 15956 "\u02a6\3\2\2\2\u02c4\u02a7\3\2\2\2\u02c4\u02a8\3\2\2\2\u02c4\u02a9\3\2"+ 15957 "\2\2\u02c4\u02aa\3\2\2\2\u02c4\u02ab\3\2\2\2\u02c4\u02ac\3\2\2\2\u02c4"+ 15958 "\u02ad\3\2\2\2\u02c4\u02ae\3\2\2\2\u02c4\u02af\3\2\2\2\u02c4\u02b0\3\2"+ 15959 "\2\2\u02c4\u02b1\3\2\2\2\u02c4\u02b2\3\2\2\2\u02c4\u02b3\3\2\2\2\u02c4"+ 15960 "\u02b4\3\2\2\2\u02c4\u02b5\3\2\2\2\u02c4\u02b6\3\2\2\2\u02c4\u02b7\3\2"+ 15961 "\2\2\u02c4\u02b8\3\2\2\2\u02c4\u02b9\3\2\2\2\u02c4\u02ba\3\2\2\2\u02c4"+ 15962 "\u02bb\3\2\2\2\u02c4\u02bc\3\2\2\2\u02c4\u02bd\3\2\2\2\u02c4\u02bf\3\2"+ 15963 "\2\2\u02c4\u02c0\3\2\2\2\u02c4\u02c1\3\2\2\2\u02c4\u02c2\3\2\2\2\u02c4"+ 15964 "\u02c3\3\2\2\2\u02c5\u02c8\3\2\2\2\u02c6\u02c4\3\2\2\2\u02c6\u02c7\3\2"+ 15965 "\2\2\u02c7\u02c9\3\2\2\2\u02c8\u02c6\3\2\2\2\u02c9\u02ca\5.\30\2\u02ca"+ 15966 "\61\3\2\2\2\u02cb\u02cc\7\7\2\2\u02cc\u02d3\7C\2\2\u02cd\u02d2\5\n\6\2"+ 15967 "\u02ce\u02d2\7\b\2\2\u02cf\u02d2\7\3\2\2\u02d0\u02d2\7\6\2\2\u02d1\u02cd"+ 15968 "\3\2\2\2\u02d1\u02ce\3\2\2\2\u02d1\u02cf\3\2\2\2\u02d1\u02d0\3\2\2\2\u02d2"+ 15969 "\u02d5\3\2\2\2\u02d3\u02d1\3\2\2\2\u02d3\u02d4\3\2\2\2\u02d4\u02d6\3\2"+ 15970 "\2\2\u02d5\u02d3\3\2\2\2\u02d6\u02d7\79\2\2\u02d7\63\3\2\2\2\u02d8\u02d9"+ 15971 "\7\7\2\2\u02d9\u02da\7;\2\2\u02da\u02de\7C\2\2\u02db\u02dd\t\2\2\2\u02dc"+ 15972 "\u02db\3\2\2\2\u02dd\u02e0\3\2\2\2\u02de\u02dc\3\2\2\2\u02de\u02df\3\2"+ 15973 "\2\2\u02df\u02e1\3\2\2\2\u02e0\u02de\3\2\2\2\u02e1\u02e2\79\2\2\u02e2"+ 15974 "\65\3\2\2\2\u02e3\u030b\5\62\32\2\u02e4\u030a\5\f\7\2\u02e5\u030a\5h\65"+ 15975 "\2\u02e6\u030a\5\22\n\2\u02e7\u030a\5\30\r\2\u02e8\u030a\5\36\20\2\u02e9"+ 15976 "\u030a\5$\23\2\u02ea\u030a\5*\26\2\u02eb\u030a\5\60\31\2\u02ec\u030a\5"+ 15977 "<\37\2\u02ed\u030a\5B\"\2\u02ee\u030a\5H%\2\u02ef\u030a\5N(\2\u02f0\u030a"+ 15978 "\5T+\2\u02f1\u030a\5Z.\2\u02f2\u030a\5f\64\2\u02f3\u030a\5`\61\2\u02f4"+ 15979 "\u030a\5\16\b\2\u02f5\u030a\5\24\13\2\u02f6\u030a\5\32\16\2\u02f7\u030a"+ 15980 "\5 \21\2\u02f8\u030a\5&\24\2\u02f9\u030a\5,\27\2\u02fa\u030a\58\35\2\u02fb"+ 15981 "\u030a\5> \2\u02fc\u030a\5D#\2\u02fd\u030a\5J&\2\u02fe\u030a\5P)\2\u02ff"+ 15982 "\u030a\5V,\2\u0300\u030a\5b\62\2\u0301\u030a\5\\/\2\u0302\u0303\6\34\13"+ 15983 "\2\u0303\u030a\7\3\2\2\u0304\u030a\5\u0094K\2\u0305\u030a\7\5\2\2\u0306"+ 15984 "\u030a\7\b\2\2\u0307\u030a\5\u0096L\2\u0308\u030a\5\u0092J\2\u0309\u02e4"+ 15985 "\3\2\2\2\u0309\u02e5\3\2\2\2\u0309\u02e6\3\2\2\2\u0309\u02e7\3\2\2\2\u0309"+ 15986 "\u02e8\3\2\2\2\u0309\u02e9\3\2\2\2\u0309\u02ea\3\2\2\2\u0309\u02eb\3\2"+ 15987 "\2\2\u0309\u02ec\3\2\2\2\u0309\u02ed\3\2\2\2\u0309\u02ee\3\2\2\2\u0309"+ 15988 "\u02ef\3\2\2\2\u0309\u02f0\3\2\2\2\u0309\u02f1\3\2\2\2\u0309\u02f2\3\2"+ 15989 "\2\2\u0309\u02f3\3\2\2\2\u0309\u02f4\3\2\2\2\u0309\u02f5\3\2\2\2\u0309"+ 15990 "\u02f6\3\2\2\2\u0309\u02f7\3\2\2\2\u0309\u02f8\3\2\2\2\u0309\u02f9\3\2"+ 15991 "\2\2\u0309\u02fa\3\2\2\2\u0309\u02fb\3\2\2\2\u0309\u02fc\3\2\2\2\u0309"+ 15992 "\u02fd\3\2\2\2\u0309\u02fe\3\2\2\2\u0309\u02ff\3\2\2\2\u0309\u0300\3\2"+ 15993 "\2\2\u0309\u0301\3\2\2\2\u0309\u0302\3\2\2\2\u0309\u0304\3\2\2\2\u0309"+ 15994 "\u0305\3\2\2\2\u0309\u0306\3\2\2\2\u0309\u0307\3\2\2\2\u0309\u0308\3\2"+ 15995 "\2\2\u030a\u030d\3\2\2\2\u030b\u0309\3\2\2\2\u030b\u030c\3\2\2\2\u030c"+ 15996 "\u030e\3\2\2\2\u030d\u030b\3\2\2\2\u030e\u030f\5\64\33\2\u030f\67\3\2"+ 15997 "\2\2\u0310\u0311\7\7\2\2\u0311\u0318\7D\2\2\u0312\u0317\5\n\6\2\u0313"+ 15998 "\u0317\7\b\2\2\u0314\u0317\7\3\2\2\u0315\u0317\7\6\2\2\u0316\u0312\3\2"+ 15999 "\2\2\u0316\u0313\3\2\2\2\u0316\u0314\3\2\2\2\u0316\u0315\3\2\2\2\u0317"+ 16000 "\u031a\3\2\2\2\u0318\u0316\3\2\2\2\u0318\u0319\3\2\2\2\u0319\u031b\3\2"+ 16001 "\2\2\u031a\u0318\3\2\2\2\u031b\u031c\79\2\2\u031c9\3\2\2\2\u031d\u031e"+ 16002 "\7\7\2\2\u031e\u031f\7;\2\2\u031f\u0323\7D\2\2\u0320\u0322\t\2\2\2\u0321"+ 16003 "\u0320\3\2\2\2\u0322\u0325\3\2\2\2\u0323\u0321\3\2\2\2\u0323\u0324\3\2"+ 16004 "\2\2\u0324\u0326\3\2\2\2\u0325\u0323\3\2\2\2\u0326\u0327\79\2\2\u0327"+ 16005 ";\3\2\2\2\u0328\u0350\58\35\2\u0329\u034f\5\f\7\2\u032a\u034f\5h\65\2"+ 16006 "\u032b\u034f\5\22\n\2\u032c\u034f\5\30\r\2\u032d\u034f\5\36\20\2\u032e"+ 16007 "\u034f\5$\23\2\u032f\u034f\5*\26\2\u0330\u034f\5\60\31\2\u0331\u034f\5"+ 16008 "\66\34\2\u0332\u034f\5B\"\2\u0333\u034f\5H%\2\u0334\u034f\5N(\2\u0335"+ 16009 "\u034f\5T+\2\u0336\u034f\5Z.\2\u0337\u034f\5f\64\2\u0338\u034f\5`\61\2"+ 16010 "\u0339\u034f\5\16\b\2\u033a\u034f\5\24\13\2\u033b\u034f\5\32\16\2\u033c"+ 16011 "\u034f\5 \21\2\u033d\u034f\5&\24\2\u033e\u034f\5,\27\2\u033f\u034f\5\62"+ 16012 "\32\2\u0340\u034f\5> \2\u0341\u034f\5D#\2\u0342\u034f\5J&\2\u0343\u034f"+ 16013 "\5P)\2\u0344\u034f\5V,\2\u0345\u034f\5b\62\2\u0346\u034f\5\\/\2\u0347"+ 16014 "\u0348\6\37\f\2\u0348\u034f\7\3\2\2\u0349\u034f\5\u0094K\2\u034a\u034f"+ 16015 "\7\5\2\2\u034b\u034f\7\b\2\2\u034c\u034f\5\u0096L\2\u034d\u034f\5\u0092"+ 16016 "J\2\u034e\u0329\3\2\2\2\u034e\u032a\3\2\2\2\u034e\u032b\3\2\2\2\u034e"+ 16017 "\u032c\3\2\2\2\u034e\u032d\3\2\2\2\u034e\u032e\3\2\2\2\u034e\u032f\3\2"+ 16018 "\2\2\u034e\u0330\3\2\2\2\u034e\u0331\3\2\2\2\u034e\u0332\3\2\2\2\u034e"+ 16019 "\u0333\3\2\2\2\u034e\u0334\3\2\2\2\u034e\u0335\3\2\2\2\u034e\u0336\3\2"+ 16020 "\2\2\u034e\u0337\3\2\2\2\u034e\u0338\3\2\2\2\u034e\u0339\3\2\2\2\u034e"+ 16021 "\u033a\3\2\2\2\u034e\u033b\3\2\2\2\u034e\u033c\3\2\2\2\u034e\u033d\3\2"+ 16022 "\2\2\u034e\u033e\3\2\2\2\u034e\u033f\3\2\2\2\u034e\u0340\3\2\2\2\u034e"+ 16023 "\u0341\3\2\2\2\u034e\u0342\3\2\2\2\u034e\u0343\3\2\2\2\u034e\u0344\3\2"+ 16024 "\2\2\u034e\u0345\3\2\2\2\u034e\u0346\3\2\2\2\u034e\u0347\3\2\2\2\u034e"+ 16025 "\u0349\3\2\2\2\u034e\u034a\3\2\2\2\u034e\u034b\3\2\2\2\u034e\u034c\3\2"+ 16026 "\2\2\u034e\u034d\3\2\2\2\u034f\u0352\3\2\2\2\u0350\u034e\3\2\2\2\u0350"+ 16027 "\u0351\3\2\2\2\u0351\u0353\3\2\2\2\u0352\u0350\3\2\2\2\u0353\u0354\5:"+ 16028 "\36\2\u0354=\3\2\2\2\u0355\u0356\7\7\2\2\u0356\u035d\7E\2\2\u0357\u035c"+ 16029 "\5\n\6\2\u0358\u035c\7\b\2\2\u0359\u035c\7\3\2\2\u035a\u035c\7\6\2\2\u035b"+ 16030 "\u0357\3\2\2\2\u035b\u0358\3\2\2\2\u035b\u0359\3\2\2\2\u035b\u035a\3\2"+ 16031 "\2\2\u035c\u035f\3\2\2\2\u035d\u035b\3\2\2\2\u035d\u035e\3\2\2\2\u035e"+ 16032 "\u0360\3\2\2\2\u035f\u035d\3\2\2\2\u0360\u0361\79\2\2\u0361?\3\2\2\2\u0362"+ 16033 "\u0363\7\7\2\2\u0363\u0364\7;\2\2\u0364\u0368\7E\2\2\u0365\u0367\t\2\2"+ 16034 "\2\u0366\u0365\3\2\2\2\u0367\u036a\3\2\2\2\u0368\u0366\3\2\2\2\u0368\u0369"+ 16035 "\3\2\2\2\u0369\u036b\3\2\2\2\u036a\u0368\3\2\2\2\u036b\u036c\79\2\2\u036c"+ 16036 "A\3\2\2\2\u036d\u0395\5> \2\u036e\u0394\5\f\7\2\u036f\u0394\5h\65\2\u0370"+ 16037 "\u0394\5\22\n\2\u0371\u0394\5\30\r\2\u0372\u0394\5\36\20\2\u0373\u0394"+ 16038 "\5$\23\2\u0374\u0394\5*\26\2\u0375\u0394\5\60\31\2\u0376\u0394\5\66\34"+ 16039 "\2\u0377\u0394\5<\37\2\u0378\u0394\5H%\2\u0379\u0394\5N(\2\u037a\u0394"+ 16040 "\5T+\2\u037b\u0394\5Z.\2\u037c\u0394\5f\64\2\u037d\u0394\5`\61\2\u037e"+ 16041 "\u0394\5\16\b\2\u037f\u0394\5\24\13\2\u0380\u0394\5\32\16\2\u0381\u0394"+ 16042 "\5 \21\2\u0382\u0394\5&\24\2\u0383\u0394\5,\27\2\u0384\u0394\5\62\32\2"+ 16043 "\u0385\u0394\58\35\2\u0386\u0394\5D#\2\u0387\u0394\5J&\2\u0388\u0394\5"+ 16044 "P)\2\u0389\u0394\5V,\2\u038a\u0394\5b\62\2\u038b\u0394\5\\/\2\u038c\u038d"+ 16045 "\6\"\r\2\u038d\u0394\7\3\2\2\u038e\u0394\5\u0094K\2\u038f\u0394\7\5\2"+ 16046 "\2\u0390\u0394\7\b\2\2\u0391\u0394\5\u0096L\2\u0392\u0394\5\u0092J\2\u0393"+ 16047 "\u036e\3\2\2\2\u0393\u036f\3\2\2\2\u0393\u0370\3\2\2\2\u0393\u0371\3\2"+ 16048 "\2\2\u0393\u0372\3\2\2\2\u0393\u0373\3\2\2\2\u0393\u0374\3\2\2\2\u0393"+ 16049 "\u0375\3\2\2\2\u0393\u0376\3\2\2\2\u0393\u0377\3\2\2\2\u0393\u0378\3\2"+ 16050 "\2\2\u0393\u0379\3\2\2\2\u0393\u037a\3\2\2\2\u0393\u037b\3\2\2\2\u0393"+ 16051 "\u037c\3\2\2\2\u0393\u037d\3\2\2\2\u0393\u037e\3\2\2\2\u0393\u037f\3\2"+ 16052 "\2\2\u0393\u0380\3\2\2\2\u0393\u0381\3\2\2\2\u0393\u0382\3\2\2\2\u0393"+ 16053 "\u0383\3\2\2\2\u0393\u0384\3\2\2\2\u0393\u0385\3\2\2\2\u0393\u0386\3\2"+ 16054 "\2\2\u0393\u0387\3\2\2\2\u0393\u0388\3\2\2\2\u0393\u0389\3\2\2\2\u0393"+ 16055 "\u038a\3\2\2\2\u0393\u038b\3\2\2\2\u0393\u038c\3\2\2\2\u0393\u038e\3\2"+ 16056 "\2\2\u0393\u038f\3\2\2\2\u0393\u0390\3\2\2\2\u0393\u0391\3\2\2\2\u0393"+ 16057 "\u0392\3\2\2\2\u0394\u0397\3\2\2\2\u0395\u0393\3\2\2\2\u0395\u0396\3\2"+ 16058 "\2\2\u0396\u0398\3\2\2\2\u0397\u0395\3\2\2\2\u0398\u0399\5@!\2\u0399C"+ 16059 "\3\2\2\2\u039a\u039b\7\7\2\2\u039b\u03a2\7F\2\2\u039c\u03a1\5\n\6\2\u039d"+ 16060 "\u03a1\7\b\2\2\u039e\u03a1\7\3\2\2\u039f\u03a1\7\6\2\2\u03a0\u039c\3\2"+ 16061 "\2\2\u03a0\u039d\3\2\2\2\u03a0\u039e\3\2\2\2\u03a0\u039f\3\2\2\2\u03a1"+ 16062 "\u03a4\3\2\2\2\u03a2\u03a0\3\2\2\2\u03a2\u03a3\3\2\2\2\u03a3\u03a5\3\2"+ 16063 "\2\2\u03a4\u03a2\3\2\2\2\u03a5\u03a6\79\2\2\u03a6E\3\2\2\2\u03a7\u03a8"+ 16064 "\7\7\2\2\u03a8\u03a9\7;\2\2\u03a9\u03ad\7F\2\2\u03aa\u03ac\t\2\2\2\u03ab"+ 16065 "\u03aa\3\2\2\2\u03ac\u03af\3\2\2\2\u03ad\u03ab\3\2\2\2\u03ad\u03ae\3\2"+ 16066 "\2\2\u03ae\u03b0\3\2\2\2\u03af\u03ad\3\2\2\2\u03b0\u03b1\79\2\2\u03b1"+ 16067 "G\3\2\2\2\u03b2\u03da\5D#\2\u03b3\u03d9\5\f\7\2\u03b4\u03d9\5h\65\2\u03b5"+ 16068 "\u03d9\5\22\n\2\u03b6\u03d9\5\30\r\2\u03b7\u03d9\5\36\20\2\u03b8\u03d9"+ 16069 "\5$\23\2\u03b9\u03d9\5*\26\2\u03ba\u03d9\5\60\31\2\u03bb\u03d9\5\66\34"+ 16070 "\2\u03bc\u03d9\5<\37\2\u03bd\u03d9\5B\"\2\u03be\u03d9\5N(\2\u03bf\u03d9"+ 16071 "\5T+\2\u03c0\u03d9\5Z.\2\u03c1\u03d9\5f\64\2\u03c2\u03d9\5`\61\2\u03c3"+ 16072 "\u03d9\5\16\b\2\u03c4\u03d9\5\24\13\2\u03c5\u03d9\5\32\16\2\u03c6\u03d9"+ 16073 "\5 \21\2\u03c7\u03d9\5&\24\2\u03c8\u03d9\5,\27\2\u03c9\u03d9\5\62\32\2"+ 16074 "\u03ca\u03d9\58\35\2\u03cb\u03d9\5> \2\u03cc\u03d9\5J&\2\u03cd\u03d9\5"+ 16075 "P)\2\u03ce\u03d9\5V,\2\u03cf\u03d9\5b\62\2\u03d0\u03d9\5\\/\2\u03d1\u03d2"+ 16076 "\6%\16\2\u03d2\u03d9\7\3\2\2\u03d3\u03d9\5\u0094K\2\u03d4\u03d9\7\5\2"+ 16077 "\2\u03d5\u03d9\7\b\2\2\u03d6\u03d9\5\u0096L\2\u03d7\u03d9\5\u0092J\2\u03d8"+ 16078 "\u03b3\3\2\2\2\u03d8\u03b4\3\2\2\2\u03d8\u03b5\3\2\2\2\u03d8\u03b6\3\2"+ 16079 "\2\2\u03d8\u03b7\3\2\2\2\u03d8\u03b8\3\2\2\2\u03d8\u03b9\3\2\2\2\u03d8"+ 16080 "\u03ba\3\2\2\2\u03d8\u03bb\3\2\2\2\u03d8\u03bc\3\2\2\2\u03d8\u03bd\3\2"+ 16081 "\2\2\u03d8\u03be\3\2\2\2\u03d8\u03bf\3\2\2\2\u03d8\u03c0\3\2\2\2\u03d8"+ 16082 "\u03c1\3\2\2\2\u03d8\u03c2\3\2\2\2\u03d8\u03c3\3\2\2\2\u03d8\u03c4\3\2"+ 16083 "\2\2\u03d8\u03c5\3\2\2\2\u03d8\u03c6\3\2\2\2\u03d8\u03c7\3\2\2\2\u03d8"+ 16084 "\u03c8\3\2\2\2\u03d8\u03c9\3\2\2\2\u03d8\u03ca\3\2\2\2\u03d8\u03cb\3\2"+ 16085 "\2\2\u03d8\u03cc\3\2\2\2\u03d8\u03cd\3\2\2\2\u03d8\u03ce\3\2\2\2\u03d8"+ 16086 "\u03cf\3\2\2\2\u03d8\u03d0\3\2\2\2\u03d8\u03d1\3\2\2\2\u03d8\u03d3\3\2"+ 16087 "\2\2\u03d8\u03d4\3\2\2\2\u03d8\u03d5\3\2\2\2\u03d8\u03d6\3\2\2\2\u03d8"+ 16088 "\u03d7\3\2\2\2\u03d9\u03dc\3\2\2\2\u03da\u03d8\3\2\2\2\u03da\u03db\3\2"+ 16089 "\2\2\u03db\u03dd\3\2\2\2\u03dc\u03da\3\2\2\2\u03dd\u03de\5F$\2\u03deI"+ 16090 "\3\2\2\2\u03df\u03e0\7\7\2\2\u03e0\u03e7\7G\2\2\u03e1\u03e6\5\n\6\2\u03e2"+ 16091 "\u03e6\7\b\2\2\u03e3\u03e6\7\3\2\2\u03e4\u03e6\7\6\2\2\u03e5\u03e1\3\2"+ 16092 "\2\2\u03e5\u03e2\3\2\2\2\u03e5\u03e3\3\2\2\2\u03e5\u03e4\3\2\2\2\u03e6"+ 16093 "\u03e9\3\2\2\2\u03e7\u03e5\3\2\2\2\u03e7\u03e8\3\2\2\2\u03e8\u03ea\3\2"+ 16094 "\2\2\u03e9\u03e7\3\2\2\2\u03ea\u03eb\79\2\2\u03ebK\3\2\2\2\u03ec\u03ed"+ 16095 "\7\7\2\2\u03ed\u03ee\7;\2\2\u03ee\u03f2\7G\2\2\u03ef\u03f1\t\2\2\2\u03f0"+ 16096 "\u03ef\3\2\2\2\u03f1\u03f4\3\2\2\2\u03f2\u03f0\3\2\2\2\u03f2\u03f3\3\2"+ 16097 "\2\2\u03f3\u03f5\3\2\2\2\u03f4\u03f2\3\2\2\2\u03f5\u03f6\79\2\2\u03f6"+ 16098 "M\3\2\2\2\u03f7\u041f\5J&\2\u03f8\u041e\5\f\7\2\u03f9\u041e\5h\65\2\u03fa"+ 16099 "\u041e\5\22\n\2\u03fb\u041e\5\30\r\2\u03fc\u041e\5\36\20\2\u03fd\u041e"+ 16100 "\5$\23\2\u03fe\u041e\5*\26\2\u03ff\u041e\5\60\31\2\u0400\u041e\5\66\34"+ 16101 "\2\u0401\u041e\5<\37\2\u0402\u041e\5B\"\2\u0403\u041e\5H%\2\u0404\u041e"+ 16102 "\5T+\2\u0405\u041e\5Z.\2\u0406\u041e\5f\64\2\u0407\u041e\5`\61\2\u0408"+ 16103 "\u041e\5\16\b\2\u0409\u041e\5\24\13\2\u040a\u041e\5\32\16\2\u040b\u041e"+ 16104 "\5 \21\2\u040c\u041e\5&\24\2\u040d\u041e\5,\27\2\u040e\u041e\5\62\32\2"+ 16105 "\u040f\u041e\58\35\2\u0410\u041e\5> \2\u0411\u041e\5D#\2\u0412\u041e\5"+ 16106 "P)\2\u0413\u041e\5V,\2\u0414\u041e\5b\62\2\u0415\u041e\5\\/\2\u0416\u0417"+ 16107 "\6(\17\2\u0417\u041e\7\3\2\2\u0418\u041e\5\u0094K\2\u0419\u041e\7\5\2"+ 16108 "\2\u041a\u041e\7\b\2\2\u041b\u041e\5\u0096L\2\u041c\u041e\5\u0092J\2\u041d"+ 16109 "\u03f8\3\2\2\2\u041d\u03f9\3\2\2\2\u041d\u03fa\3\2\2\2\u041d\u03fb\3\2"+ 16110 "\2\2\u041d\u03fc\3\2\2\2\u041d\u03fd\3\2\2\2\u041d\u03fe\3\2\2\2\u041d"+ 16111 "\u03ff\3\2\2\2\u041d\u0400\3\2\2\2\u041d\u0401\3\2\2\2\u041d\u0402\3\2"+ 16112 "\2\2\u041d\u0403\3\2\2\2\u041d\u0404\3\2\2\2\u041d\u0405\3\2\2\2\u041d"+ 16113 "\u0406\3\2\2\2\u041d\u0407\3\2\2\2\u041d\u0408\3\2\2\2\u041d\u0409\3\2"+ 16114 "\2\2\u041d\u040a\3\2\2\2\u041d\u040b\3\2\2\2\u041d\u040c\3\2\2\2\u041d"+ 16115 "\u040d\3\2\2\2\u041d\u040e\3\2\2\2\u041d\u040f\3\2\2\2\u041d\u0410\3\2"+ 16116 "\2\2\u041d\u0411\3\2\2\2\u041d\u0412\3\2\2\2\u041d\u0413\3\2\2\2\u041d"+ 16117 "\u0414\3\2\2\2\u041d\u0415\3\2\2\2\u041d\u0416\3\2\2\2\u041d\u0418\3\2"+ 16118 "\2\2\u041d\u0419\3\2\2\2\u041d\u041a\3\2\2\2\u041d\u041b\3\2\2\2\u041d"+ 16119 "\u041c\3\2\2\2\u041e\u0421\3\2\2\2\u041f\u041d\3\2\2\2\u041f\u0420\3\2"+ 16120 "\2\2\u0420\u0422\3\2\2\2\u0421\u041f\3\2\2\2\u0422\u0423\5L\'\2\u0423"+ 16121 "O\3\2\2\2\u0424\u0425\7\7\2\2\u0425\u042c\7H\2\2\u0426\u042b\5\n\6\2\u0427"+ 16122 "\u042b\7\b\2\2\u0428\u042b\7\3\2\2\u0429\u042b\7\6\2\2\u042a\u0426\3\2"+ 16123 "\2\2\u042a\u0427\3\2\2\2\u042a\u0428\3\2\2\2\u042a\u0429\3\2\2\2\u042b"+ 16124 "\u042e\3\2\2\2\u042c\u042a\3\2\2\2\u042c\u042d\3\2\2\2\u042d\u042f\3\2"+ 16125 "\2\2\u042e\u042c\3\2\2\2\u042f\u0430\79\2\2\u0430Q\3\2\2\2\u0431\u0432"+ 16126 "\7\7\2\2\u0432\u0433\7;\2\2\u0433\u0437\7H\2\2\u0434\u0436\t\2\2\2\u0435"+ 16127 "\u0434\3\2\2\2\u0436\u0439\3\2\2\2\u0437\u0435\3\2\2\2\u0437\u0438\3\2"+ 16128 "\2\2\u0438\u043a\3\2\2\2\u0439\u0437\3\2\2\2\u043a\u043b\79\2\2\u043b"+ 16129 "S\3\2\2\2\u043c\u0464\5P)\2\u043d\u0463\5\f\7\2\u043e\u0463\5h\65\2\u043f"+ 16130 "\u0463\5\22\n\2\u0440\u0463\5\30\r\2\u0441\u0463\5\36\20\2\u0442\u0463"+ 16131 "\5$\23\2\u0443\u0463\5*\26\2\u0444\u0463\5\60\31\2\u0445\u0463\5\66\34"+ 16132 "\2\u0446\u0463\5<\37\2\u0447\u0463\5B\"\2\u0448\u0463\5H%\2\u0449\u0463"+ 16133 "\5N(\2\u044a\u0463\5Z.\2\u044b\u0463\5f\64\2\u044c\u0463\5`\61\2\u044d"+ 16134 "\u0463\5\16\b\2\u044e\u0463\5\24\13\2\u044f\u0463\5\32\16\2\u0450\u0463"+ 16135 "\5 \21\2\u0451\u0463\5&\24\2\u0452\u0463\5,\27\2\u0453\u0463\5\62\32\2"+ 16136 "\u0454\u0463\58\35\2\u0455\u0463\5> \2\u0456\u0463\5D#\2\u0457\u0463\5"+ 16137 "J&\2\u0458\u0463\5V,\2\u0459\u0463\5b\62\2\u045a\u0463\5\\/\2\u045b\u045c"+ 16138 "\6+\20\2\u045c\u0463\7\3\2\2\u045d\u0463\5\u0094K\2\u045e\u0463\7\5\2"+ 16139 "\2\u045f\u0463\7\b\2\2\u0460\u0463\5\u0096L\2\u0461\u0463\5\u0092J\2\u0462"+ 16140 "\u043d\3\2\2\2\u0462\u043e\3\2\2\2\u0462\u043f\3\2\2\2\u0462\u0440\3\2"+ 16141 "\2\2\u0462\u0441\3\2\2\2\u0462\u0442\3\2\2\2\u0462\u0443\3\2\2\2\u0462"+ 16142 "\u0444\3\2\2\2\u0462\u0445\3\2\2\2\u0462\u0446\3\2\2\2\u0462\u0447\3\2"+ 16143 "\2\2\u0462\u0448\3\2\2\2\u0462\u0449\3\2\2\2\u0462\u044a\3\2\2\2\u0462"+ 16144 "\u044b\3\2\2\2\u0462\u044c\3\2\2\2\u0462\u044d\3\2\2\2\u0462\u044e\3\2"+ 16145 "\2\2\u0462\u044f\3\2\2\2\u0462\u0450\3\2\2\2\u0462\u0451\3\2\2\2\u0462"+ 16146 "\u0452\3\2\2\2\u0462\u0453\3\2\2\2\u0462\u0454\3\2\2\2\u0462\u0455\3\2"+ 16147 "\2\2\u0462\u0456\3\2\2\2\u0462\u0457\3\2\2\2\u0462\u0458\3\2\2\2\u0462"+ 16148 "\u0459\3\2\2\2\u0462\u045a\3\2\2\2\u0462\u045b\3\2\2\2\u0462\u045d\3\2"+ 16149 "\2\2\u0462\u045e\3\2\2\2\u0462\u045f\3\2\2\2\u0462\u0460\3\2\2\2\u0462"+ 16150 "\u0461\3\2\2\2\u0463\u0466\3\2\2\2\u0464\u0462\3\2\2\2\u0464\u0465\3\2"+ 16151 "\2\2\u0465\u0467\3\2\2\2\u0466\u0464\3\2\2\2\u0467\u0468\5R*\2\u0468U"+ 16152 "\3\2\2\2\u0469\u046a\7\7\2\2\u046a\u0471\7I\2\2\u046b\u0470\5\n\6\2\u046c"+ 16153 "\u0470\7\b\2\2\u046d\u0470\7\3\2\2\u046e\u0470\7\6\2\2\u046f\u046b\3\2"+ 16154 "\2\2\u046f\u046c\3\2\2\2\u046f\u046d\3\2\2\2\u046f\u046e\3\2\2\2\u0470"+ 16155 "\u0473\3\2\2\2\u0471\u046f\3\2\2\2\u0471\u0472\3\2\2\2\u0472\u0474\3\2"+ 16156 "\2\2\u0473\u0471\3\2\2\2\u0474\u0475\79\2\2\u0475W\3\2\2\2\u0476\u0477"+ 16157 "\7\7\2\2\u0477\u0478\7;\2\2\u0478\u047c\7I\2\2\u0479\u047b\t\2\2\2\u047a"+ 16158 "\u0479\3\2\2\2\u047b\u047e\3\2\2\2\u047c\u047a\3\2\2\2\u047c\u047d\3\2"+ 16159 "\2\2\u047d\u047f\3\2\2\2\u047e\u047c\3\2\2\2\u047f\u0480\79\2\2\u0480"+ 16160 "Y\3\2\2\2\u0481\u04a9\5V,\2\u0482\u04a8\5\f\7\2\u0483\u04a8\5h\65\2\u0484"+ 16161 "\u04a8\5\22\n\2\u0485\u04a8\5\30\r\2\u0486\u04a8\5\36\20\2\u0487\u04a8"+ 16162 "\5$\23\2\u0488\u04a8\5*\26\2\u0489\u04a8\5\60\31\2\u048a\u04a8\5\66\34"+ 16163 "\2\u048b\u04a8\5<\37\2\u048c\u04a8\5B\"\2\u048d\u04a8\5H%\2\u048e\u04a8"+ 16164 "\5N(\2\u048f\u04a8\5T+\2\u0490\u04a8\5f\64\2\u0491\u04a8\5`\61\2\u0492"+ 16165 "\u04a8\5\16\b\2\u0493\u04a8\5\24\13\2\u0494\u04a8\5\32\16\2\u0495\u04a8"+ 16166 "\5 \21\2\u0496\u04a8\5&\24\2\u0497\u04a8\5,\27\2\u0498\u04a8\5\62\32\2"+ 16167 "\u0499\u04a8\58\35\2\u049a\u04a8\5> \2\u049b\u04a8\5D#\2\u049c\u04a8\5"+ 16168 "J&\2\u049d\u04a8\5P)\2\u049e\u04a8\5b\62\2\u049f\u04a8\5\\/\2\u04a0\u04a1"+ 16169 "\6.\21\2\u04a1\u04a8\7\3\2\2\u04a2\u04a8\5\u0094K\2\u04a3\u04a8\7\5\2"+ 16170 "\2\u04a4\u04a8\7\b\2\2\u04a5\u04a8\5\u0096L\2\u04a6\u04a8\5\u0092J\2\u04a7"+ 16171 "\u0482\3\2\2\2\u04a7\u0483\3\2\2\2\u04a7\u0484\3\2\2\2\u04a7\u0485\3\2"+ 16172 "\2\2\u04a7\u0486\3\2\2\2\u04a7\u0487\3\2\2\2\u04a7\u0488\3\2\2\2\u04a7"+ 16173 "\u0489\3\2\2\2\u04a7\u048a\3\2\2\2\u04a7\u048b\3\2\2\2\u04a7\u048c\3\2"+ 16174 "\2\2\u04a7\u048d\3\2\2\2\u04a7\u048e\3\2\2\2\u04a7\u048f\3\2\2\2\u04a7"+ 16175 "\u0490\3\2\2\2\u04a7\u0491\3\2\2\2\u04a7\u0492\3\2\2\2\u04a7\u0493\3\2"+ 16176 "\2\2\u04a7\u0494\3\2\2\2\u04a7\u0495\3\2\2\2\u04a7\u0496\3\2\2\2\u04a7"+ 16177 "\u0497\3\2\2\2\u04a7\u0498\3\2\2\2\u04a7\u0499\3\2\2\2\u04a7\u049a\3\2"+ 16178 "\2\2\u04a7\u049b\3\2\2\2\u04a7\u049c\3\2\2\2\u04a7\u049d\3\2\2\2\u04a7"+ 16179 "\u049e\3\2\2\2\u04a7\u049f\3\2\2\2\u04a7\u04a0\3\2\2\2\u04a7\u04a2\3\2"+ 16180 "\2\2\u04a7\u04a3\3\2\2\2\u04a7\u04a4\3\2\2\2\u04a7\u04a5\3\2\2\2\u04a7"+ 16181 "\u04a6\3\2\2\2\u04a8\u04ab\3\2\2\2\u04a9\u04a7\3\2\2\2\u04a9\u04aa\3\2"+ 16182 "\2\2\u04aa\u04ac\3\2\2\2\u04ab\u04a9\3\2\2\2\u04ac\u04ad\5X-\2\u04ad["+ 16183 "\3\2\2\2\u04ae\u04af\7\7\2\2\u04af\u04b6\7J\2\2\u04b0\u04b5\5\n\6\2\u04b1"+ 16184 "\u04b5\7\b\2\2\u04b2\u04b5\7\3\2\2\u04b3\u04b5\7\6\2\2\u04b4\u04b0\3\2"+ 16185 "\2\2\u04b4\u04b1\3\2\2\2\u04b4\u04b2\3\2\2\2\u04b4\u04b3\3\2\2\2\u04b5"+ 16186 "\u04b8\3\2\2\2\u04b6\u04b4\3\2\2\2\u04b6\u04b7\3\2\2\2\u04b7\u04b9\3\2"+ 16187 "\2\2\u04b8\u04b6\3\2\2\2\u04b9\u04ba\79\2\2\u04ba]\3\2\2\2\u04bb\u04bc"+ 16188 "\7\7\2\2\u04bc\u04bd\7;\2\2\u04bd\u04c1\7J\2\2\u04be\u04c0\t\2\2\2\u04bf"+ 16189 "\u04be\3\2\2\2\u04c0\u04c3\3\2\2\2\u04c1\u04bf\3\2\2\2\u04c1\u04c2\3\2"+ 16190 "\2\2\u04c2\u04c4\3\2\2\2\u04c3\u04c1\3\2\2\2\u04c4\u04c5\79\2\2\u04c5"+ 16191 "_\3\2\2\2\u04c6\u04ee\5\\/\2\u04c7\u04ed\5\f\7\2\u04c8\u04ed\5h\65\2\u04c9"+ 16192 "\u04ed\5\22\n\2\u04ca\u04ed\5\30\r\2\u04cb\u04ed\5\36\20\2\u04cc\u04ed"+ 16193 "\5$\23\2\u04cd\u04ed\5*\26\2\u04ce\u04ed\5\60\31\2\u04cf\u04ed\5\66\34"+ 16194 "\2\u04d0\u04ed\5<\37\2\u04d1\u04ed\5B\"\2\u04d2\u04ed\5H%\2\u04d3\u04ed"+ 16195 "\5N(\2\u04d4\u04ed\5T+\2\u04d5\u04ed\5Z.\2\u04d6\u04ed\5f\64\2\u04d7\u04ed"+ 16196 "\5\16\b\2\u04d8\u04ed\5\24\13\2\u04d9\u04ed\5\32\16\2\u04da\u04ed\5 \21"+ 16197 "\2\u04db\u04ed\5&\24\2\u04dc\u04ed\5,\27\2\u04dd\u04ed\5\62\32\2\u04de"+ 16198 "\u04ed\58\35\2\u04df\u04ed\5> \2\u04e0\u04ed\5D#\2\u04e1\u04ed\5J&\2\u04e2"+ 16199 "\u04ed\5P)\2\u04e3\u04ed\5V,\2\u04e4\u04ed\5b\62\2\u04e5\u04e6\6\61\22"+ 16200 "\2\u04e6\u04ed\7\3\2\2\u04e7\u04ed\5\u0094K\2\u04e8\u04ed\7\5\2\2\u04e9"+ 16201 "\u04ed\7\b\2\2\u04ea\u04ed\5\u0096L\2\u04eb\u04ed\5\u0092J\2\u04ec\u04c7"+ 16202 "\3\2\2\2\u04ec\u04c8\3\2\2\2\u04ec\u04c9\3\2\2\2\u04ec\u04ca\3\2\2\2\u04ec"+ 16203 "\u04cb\3\2\2\2\u04ec\u04cc\3\2\2\2\u04ec\u04cd\3\2\2\2\u04ec\u04ce\3\2"+ 16204 "\2\2\u04ec\u04cf\3\2\2\2\u04ec\u04d0\3\2\2\2\u04ec\u04d1\3\2\2\2\u04ec"+ 16205 "\u04d2\3\2\2\2\u04ec\u04d3\3\2\2\2\u04ec\u04d4\3\2\2\2\u04ec\u04d5\3\2"+ 16206 "\2\2\u04ec\u04d6\3\2\2\2\u04ec\u04d7\3\2\2\2\u04ec\u04d8\3\2\2\2\u04ec"+ 16207 "\u04d9\3\2\2\2\u04ec\u04da\3\2\2\2\u04ec\u04db\3\2\2\2\u04ec\u04dc\3\2"+ 16208 "\2\2\u04ec\u04dd\3\2\2\2\u04ec\u04de\3\2\2\2\u04ec\u04df\3\2\2\2\u04ec"+ 16209 "\u04e0\3\2\2\2\u04ec\u04e1\3\2\2\2\u04ec\u04e2\3\2\2\2\u04ec\u04e3\3\2"+ 16210 "\2\2\u04ec\u04e4\3\2\2\2\u04ec\u04e5\3\2\2\2\u04ec\u04e7\3\2\2\2\u04ec"+ 16211 "\u04e8\3\2\2\2\u04ec\u04e9\3\2\2\2\u04ec\u04ea\3\2\2\2\u04ec\u04eb\3\2"+ 16212 "\2\2\u04ed\u04f0\3\2\2\2\u04ee\u04ec\3\2\2\2\u04ee\u04ef\3\2\2\2\u04ef"+ 16213 "\u04f1\3\2\2\2\u04f0\u04ee\3\2\2\2\u04f1\u04f2\5^\60\2\u04f2a\3\2\2\2"+ 16214 "\u04f3\u04f4\7\7\2\2\u04f4\u04fb\7K\2\2\u04f5\u04fa\5\n\6\2\u04f6\u04fa"+ 16215 "\7\b\2\2\u04f7\u04fa\7\3\2\2\u04f8\u04fa\7\6\2\2\u04f9\u04f5\3\2\2\2\u04f9"+ 16216 "\u04f6\3\2\2\2\u04f9\u04f7\3\2\2\2\u04f9\u04f8\3\2\2\2\u04fa\u04fd\3\2"+ 16217 "\2\2\u04fb\u04f9\3\2\2\2\u04fb\u04fc\3\2\2\2\u04fc\u04fe\3\2\2\2\u04fd"+ 16218 "\u04fb\3\2\2\2\u04fe\u04ff\79\2\2\u04ffc\3\2\2\2\u0500\u0501\7\7\2\2\u0501"+ 16219 "\u0502\7;\2\2\u0502\u0506\7K\2\2\u0503\u0505\t\2\2\2\u0504\u0503\3\2\2"+ 16220 "\2\u0505\u0508\3\2\2\2\u0506\u0504\3\2\2\2\u0506\u0507\3\2\2\2\u0507\u0509"+ 16221 "\3\2\2\2\u0508\u0506\3\2\2\2\u0509\u050a\79\2\2\u050ae\3\2\2\2\u050b\u0533"+ 16222 "\5b\62\2\u050c\u0532\5\f\7\2\u050d\u0532\5h\65\2\u050e\u0532\5\22\n\2"+ 16223 "\u050f\u0532\5\30\r\2\u0510\u0532\5\36\20\2\u0511\u0532\5$\23\2\u0512"+ 16224 "\u0532\5*\26\2\u0513\u0532\5\60\31\2\u0514\u0532\5\66\34\2\u0515\u0532"+ 16225 "\5<\37\2\u0516\u0532\5B\"\2\u0517\u0532\5H%\2\u0518\u0532\5N(\2\u0519"+ 16226 "\u0532\5T+\2\u051a\u0532\5Z.\2\u051b\u0532\5`\61\2\u051c\u0532\5\16\b"+ 16227 "\2\u051d\u0532\5\24\13\2\u051e\u0532\5\32\16\2\u051f\u0532\5 \21\2\u0520"+ 16228 "\u0532\5&\24\2\u0521\u0532\5,\27\2\u0522\u0532\5\62\32\2\u0523\u0532\5"+ 16229 "8\35\2\u0524\u0532\5> \2\u0525\u0532\5D#\2\u0526\u0532\5J&\2\u0527\u0532"+ 16230 "\5P)\2\u0528\u0532\5V,\2\u0529\u0532\5\\/\2\u052a\u052b\6\64\23\2\u052b"+ 16231 "\u0532\7\3\2\2\u052c\u0532\5\u0094K\2\u052d\u0532\7\5\2\2\u052e\u0532"+ 16232 "\7\b\2\2\u052f\u0532\5\u0096L\2\u0530\u0532\5\u0092J\2\u0531\u050c\3\2"+ 16233 "\2\2\u0531\u050d\3\2\2\2\u0531\u050e\3\2\2\2\u0531\u050f\3\2\2\2\u0531"+ 16234 "\u0510\3\2\2\2\u0531\u0511\3\2\2\2\u0531\u0512\3\2\2\2\u0531\u0513\3\2"+ 16235 "\2\2\u0531\u0514\3\2\2\2\u0531\u0515\3\2\2\2\u0531\u0516\3\2\2\2\u0531"+ 16236 "\u0517\3\2\2\2\u0531\u0518\3\2\2\2\u0531\u0519\3\2\2\2\u0531\u051a\3\2"+ 16237 "\2\2\u0531\u051b\3\2\2\2\u0531\u051c\3\2\2\2\u0531\u051d\3\2\2\2\u0531"+ 16238 "\u051e\3\2\2\2\u0531\u051f\3\2\2\2\u0531\u0520\3\2\2\2\u0531\u0521\3\2"+ 16239 "\2\2\u0531\u0522\3\2\2\2\u0531\u0523\3\2\2\2\u0531\u0524\3\2\2\2\u0531"+ 16240 "\u0525\3\2\2\2\u0531\u0526\3\2\2\2\u0531\u0527\3\2\2\2\u0531\u0528\3\2"+ 16241 "\2\2\u0531\u0529\3\2\2\2\u0531\u052a\3\2\2\2\u0531\u052c\3\2\2\2\u0531"+ 16242 "\u052d\3\2\2\2\u0531\u052e\3\2\2\2\u0531\u052f\3\2\2\2\u0531\u0530\3\2"+ 16243 "\2\2\u0532\u0535\3\2\2\2\u0533\u0531\3\2\2\2\u0533\u0534\3\2\2\2\u0534"+ 16244 "\u0536\3\2\2\2\u0535\u0533\3\2\2\2\u0536\u0537\5d\63\2\u0537g\3\2\2\2"+ 16245 "\u0538\u054d\5j\66\2\u0539\u054d\5l\67\2\u053a\u054d\5n8\2\u053b\u054d"+ 16246 "\5p9\2\u053c\u054d\5r:\2\u053d\u054d\5t;\2\u053e\u054d\5v<\2\u053f\u054d"+ 16247 "\5x=\2\u0540\u054d\5z>\2\u0541\u054d\5|?\2\u0542\u054d\5~@\2\u0543\u054d"+ 16248 "\5\u0080A\2\u0544\u054d\5\u0082B\2\u0545\u054d\5\u0084C\2\u0546\u054d"+ 16249 "\5\u0098M\2\u0547\u054d\5\u009aN\2\u0548\u054d\5\u009cO\2\u0549\u054d"+ 16250 "\5\u009eP\2\u054a\u054d\5\u00a0Q\2\u054b\u054d\5\u0086D\2\u054c\u0538"+ 16251 "\3\2\2\2\u054c\u0539\3\2\2\2\u054c\u053a\3\2\2\2\u054c\u053b\3\2\2\2\u054c"+ 16252 "\u053c\3\2\2\2\u054c\u053d\3\2\2\2\u054c\u053e\3\2\2\2\u054c\u053f\3\2"+ 16253 "\2\2\u054c\u0540\3\2\2\2\u054c\u0541\3\2\2\2\u054c\u0542\3\2\2\2\u054c"+ 16254 "\u0543\3\2\2\2\u054c\u0544\3\2\2\2\u054c\u0545\3\2\2\2\u054c\u0546\3\2"+ 16255 "\2\2\u054c\u0547\3\2\2\2\u054c\u0548\3\2\2\2\u054c\u0549\3\2\2\2\u054c"+ 16256 "\u054a\3\2\2\2\u054c\u054b\3\2\2\2\u054di\3\2\2\2\u054e\u054f\7\7\2\2"+ 16257 "\u054f\u0556\t\3\2\2\u0550\u0555\5\n\6\2\u0551\u0555\7\b\2\2\u0552\u0555"+ 16258 "\7\3\2\2\u0553\u0555\7\6\2\2\u0554\u0550\3\2\2\2\u0554\u0551\3\2\2\2\u0554"+ 16259 "\u0552\3\2\2\2\u0554\u0553\3\2\2\2\u0555\u0558\3\2\2\2\u0556\u0554\3\2"+ 16260 "\2\2\u0556\u0557\3\2\2\2\u0557\u0559\3\2\2\2\u0558\u0556\3\2\2\2\u0559"+ 16261 "\u055a\7:\2\2\u055ak\3\2\2\2\u055b\u055c\7\7\2\2\u055c\u0563\7L\2\2\u055d"+ 16262 "\u0562\5\n\6\2\u055e\u0562\7\b\2\2\u055f\u0562\7\3\2\2\u0560\u0562\7\6"+ 16263 "\2\2\u0561\u055d\3\2\2\2\u0561\u055e\3\2\2\2\u0561\u055f\3\2\2\2\u0561"+ 16264 "\u0560\3\2\2\2\u0562\u0565\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0564\3\2"+ 16265 "\2\2\u0564\u0566\3\2\2\2\u0565\u0563\3\2\2\2\u0566\u0567\t\4\2\2\u0567"+ 16266 "m\3\2\2\2\u0568\u0569\7\7\2\2\u0569\u0570\7M\2\2\u056a\u056f\5\n\6\2\u056b"+ 16267 "\u056f\7\b\2\2\u056c\u056f\7\3\2\2\u056d\u056f\7\6\2\2\u056e\u056a\3\2"+ 16268 "\2\2\u056e\u056b\3\2\2\2\u056e\u056c\3\2\2\2\u056e\u056d\3\2\2\2\u056f"+ 16269 "\u0572\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u0571\3\2\2\2\u0571\u0573\3\2"+ 16270 "\2\2\u0572\u0570\3\2\2\2\u0573\u0574\t\4\2\2\u0574o\3\2\2\2\u0575\u0576"+ 16271 "\7\7\2\2\u0576\u057d\7N\2\2\u0577\u057c\5\n\6\2\u0578\u057c\7\b\2\2\u0579"+ 16272 "\u057c\7\3\2\2\u057a\u057c\7\6\2\2\u057b\u0577\3\2\2\2\u057b\u0578\3\2"+ 16273 "\2\2\u057b\u0579\3\2\2\2\u057b\u057a\3\2\2\2\u057c\u057f\3\2\2\2\u057d"+ 16274 "\u057b\3\2\2\2\u057d\u057e\3\2\2\2\u057e\u0580\3\2\2\2\u057f\u057d\3\2"+ 16275 "\2\2\u0580\u0581\t\4\2\2\u0581q\3\2\2\2\u0582\u0583\7\7\2\2\u0583\u058a"+ 16276 "\7O\2\2\u0584\u0589\5\n\6\2\u0585\u0589\7\b\2\2\u0586\u0589\7\3\2\2\u0587"+ 16277 "\u0589\7\6\2\2\u0588\u0584\3\2\2\2\u0588\u0585\3\2\2\2\u0588\u0586\3\2"+ 16278 "\2\2\u0588\u0587\3\2\2\2\u0589\u058c\3\2\2\2\u058a\u0588\3\2\2\2\u058a"+ 16279 "\u058b\3\2\2\2\u058b\u058d\3\2\2\2\u058c\u058a\3\2\2\2\u058d\u058e\t\4"+ 16280 "\2\2\u058es\3\2\2\2\u058f\u0590\7\7\2\2\u0590\u0597\7P\2\2\u0591\u0596"+ 16281 "\5\n\6\2\u0592\u0596\7\b\2\2\u0593\u0596\7\3\2\2\u0594\u0596\7\6\2\2\u0595"+ 16282 "\u0591\3\2\2\2\u0595\u0592\3\2\2\2\u0595\u0593\3\2\2\2\u0595\u0594\3\2"+ 16283 "\2\2\u0596\u0599\3\2\2\2\u0597\u0595\3\2\2\2\u0597\u0598\3\2\2\2\u0598"+ 16284 "\u059a\3\2\2\2\u0599\u0597\3\2\2\2\u059a\u059b\t\4\2\2\u059bu\3\2\2\2"+ 16285 "\u059c\u059d\7\7\2\2\u059d\u05a4\7Q\2\2\u059e\u05a3\5\n\6\2\u059f\u05a3"+ 16286 "\7\b\2\2\u05a0\u05a3\7\3\2\2\u05a1\u05a3\7\6\2\2\u05a2\u059e\3\2\2\2\u05a2"+ 16287 "\u059f\3\2\2\2\u05a2\u05a0\3\2\2\2\u05a2\u05a1\3\2\2\2\u05a3\u05a6\3\2"+ 16288 "\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a5\3\2\2\2\u05a5\u05a7\3\2\2\2\u05a6"+ 16289 "\u05a4\3\2\2\2\u05a7\u05a8\t\4\2\2\u05a8w\3\2\2\2\u05a9\u05aa\7\7\2\2"+ 16290 "\u05aa\u05b1\7R\2\2\u05ab\u05b0\5\n\6\2\u05ac\u05b0\7\b\2\2\u05ad\u05b0"+ 16291 "\7\3\2\2\u05ae\u05b0\7\6\2\2\u05af\u05ab\3\2\2\2\u05af\u05ac\3\2\2\2\u05af"+ 16292 "\u05ad\3\2\2\2\u05af\u05ae\3\2\2\2\u05b0\u05b3\3\2\2\2\u05b1\u05af\3\2"+ 16293 "\2\2\u05b1\u05b2\3\2\2\2\u05b2\u05b4\3\2\2\2\u05b3\u05b1\3\2\2\2\u05b4"+ 16294 "\u05b5\t\4\2\2\u05b5y\3\2\2\2\u05b6\u05b7\7\7\2\2\u05b7\u05be\7S\2\2\u05b8"+ 16295 "\u05bd\5\n\6\2\u05b9\u05bd\7\b\2\2\u05ba\u05bd\7\3\2\2\u05bb\u05bd\7\6"+ 16296 "\2\2\u05bc\u05b8\3\2\2\2\u05bc\u05b9\3\2\2\2\u05bc\u05ba\3\2\2\2\u05bc"+ 16297 "\u05bb\3\2\2\2\u05bd\u05c0\3\2\2\2\u05be\u05bc\3\2\2\2\u05be\u05bf\3\2"+ 16298 "\2\2\u05bf\u05c1\3\2\2\2\u05c0\u05be\3\2\2\2\u05c1\u05c2\t\4\2\2\u05c2"+ 16299 "{\3\2\2\2\u05c3\u05c4\7\7\2\2\u05c4\u05cb\7T\2\2\u05c5\u05ca\5\n\6\2\u05c6"+ 16300 "\u05ca\7\b\2\2\u05c7\u05ca\7\3\2\2\u05c8\u05ca\7\6\2\2\u05c9\u05c5\3\2"+ 16301 "\2\2\u05c9\u05c6\3\2\2\2\u05c9\u05c7\3\2\2\2\u05c9\u05c8\3\2\2\2\u05ca"+ 16302 "\u05cd\3\2\2\2\u05cb\u05c9\3\2\2\2\u05cb\u05cc\3\2\2\2\u05cc\u05ce\3\2"+ 16303 "\2\2\u05cd\u05cb\3\2\2\2\u05ce\u05cf\t\4\2\2\u05cf}\3\2\2\2\u05d0\u05d1"+ 16304 "\7\7\2\2\u05d1\u05d8\7U\2\2\u05d2\u05d7\5\n\6\2\u05d3\u05d7\7\b\2\2\u05d4"+ 16305 "\u05d7\7\3\2\2\u05d5\u05d7\7\6\2\2\u05d6\u05d2\3\2\2\2\u05d6\u05d3\3\2"+ 16306 "\2\2\u05d6\u05d4\3\2\2\2\u05d6\u05d5\3\2\2\2\u05d7\u05da\3\2\2\2\u05d8"+ 16307 "\u05d6\3\2\2\2\u05d8\u05d9\3\2\2\2\u05d9\u05db\3\2\2\2\u05da\u05d8\3\2"+ 16308 "\2\2\u05db\u05dc\t\4\2\2\u05dc\177\3\2\2\2\u05dd\u05de\7\7\2\2\u05de\u05e5"+ 16309 "\7V\2\2\u05df\u05e4\5\n\6\2\u05e0\u05e4\7\b\2\2\u05e1\u05e4\7\3\2\2\u05e2"+ 16310 "\u05e4\7\6\2\2\u05e3\u05df\3\2\2\2\u05e3\u05e0\3\2\2\2\u05e3\u05e1\3\2"+ 16311 "\2\2\u05e3\u05e2\3\2\2\2\u05e4\u05e7\3\2\2\2\u05e5\u05e3\3\2\2\2\u05e5"+ 16312 "\u05e6\3\2\2\2\u05e6\u05e8\3\2\2\2\u05e7\u05e5\3\2\2\2\u05e8\u05e9\t\4"+ 16313 "\2\2\u05e9\u0081\3\2\2\2\u05ea\u05eb\7\7\2\2\u05eb\u05f2\7W\2\2\u05ec"+ 16314 "\u05f1\5\n\6\2\u05ed\u05f1\7\b\2\2\u05ee\u05f1\7\3\2\2\u05ef\u05f1\7\6"+ 16315 "\2\2\u05f0\u05ec\3\2\2\2\u05f0\u05ed\3\2\2\2\u05f0\u05ee\3\2\2\2\u05f0"+ 16316 "\u05ef\3\2\2\2\u05f1\u05f4\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f2\u05f3\3\2"+ 16317 "\2\2\u05f3\u05f5\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f5\u05f6\t\4\2\2\u05f6"+ 16318 "\u0083\3\2\2\2\u05f7\u05f8\7\7\2\2\u05f8\u05ff\7X\2\2\u05f9\u05fe\5\n"+ 16319 "\6\2\u05fa\u05fe\7\b\2\2\u05fb\u05fe\7\3\2\2\u05fc\u05fe\7\6\2\2\u05fd"+ 16320 "\u05f9\3\2\2\2\u05fd\u05fa\3\2\2\2\u05fd\u05fb\3\2\2\2\u05fd\u05fc\3\2"+ 16321 "\2\2\u05fe\u0601\3\2\2\2\u05ff\u05fd\3\2\2\2\u05ff\u0600\3\2\2\2\u0600"+ 16322 "\u0602\3\2\2\2\u0601\u05ff\3\2\2\2\u0602\u0603\t\4\2\2\u0603\u0085\3\2"+ 16323 "\2\2\u0604\u0605\7\7\2\2\u0605\u0606\7;\2\2\u0606\u0607\5\u0088E\2\u0607"+ 16324 "\u0608\79\2\2\u0608\u0609\bD\1\2\u0609\u0087\3\2\2\2\u060a\u060b\t\5\2"+ 16325 "\2\u060b\u0089\3\2\2\2\u060c\u060d\6F\24\2\u060d\u0615\7\3\2\2\u060e\u0615"+ 16326 "\5\u0094K\2\u060f\u0615\7\5\2\2\u0610\u0615\7\b\2\2\u0611\u0615\5\u0096"+ 16327 "L\2\u0612\u0615\5\u0092J\2\u0613\u0615\5\4\3\2\u0614\u060c\3\2\2\2\u0614"+ 16328 "\u060e\3\2\2\2\u0614\u060f\3\2\2\2\u0614\u0610\3\2\2\2\u0614\u0611\3\2"+ 16329 "\2\2\u0614\u0612\3\2\2\2\u0614\u0613\3\2\2\2\u0615\u0616\3\2\2\2\u0616"+ 16330 "\u0614\3\2\2\2\u0616\u0617\3\2\2\2\u0617\u008b\3\2\2\2\u0618\u061e\7\36"+ 16331 "\2\2\u0619\u061a\7 \2\2\u061a\u061c\7#\2\2\u061b\u061d\5\u008eH\2\u061c"+ 16332 "\u061b\3\2\2\2\u061c\u061d\3\2\2\2\u061d\u061f\3\2\2\2\u061e\u0619\3\2"+ 16333 "\2\2\u061e\u061f\3\2\2\2\u061f\u0626\3\2\2\2\u0620\u0621\7 \2\2\u0621"+ 16334 "\u0623\7#\2\2\u0622\u0624\5\u008eH\2\u0623\u0622\3\2\2\2\u0623\u0624\3"+ 16335 "\2\2\2\u0624\u0626\3\2\2\2\u0625\u0618\3\2\2\2\u0625\u0620\3\2\2\2\u0626"+ 16336 "\u008d\3\2\2\2\u0627\u062b\7$\2\2\u0628\u062a\t\6\2\2\u0629\u0628\3\2"+ 16337 "\2\2\u062a\u062d\3\2\2\2\u062b\u0629\3\2\2\2\u062b\u062c\3\2\2\2\u062c"+ 16338 "\u062e\3\2\2\2\u062d\u062b\3\2\2\2\u062e\u062f\7%\2\2\u062f\u008f\3\2"+ 16339 "\2\2\u0630\u0632\7\t\2\2\u0631\u0633\t\7\2\2\u0632\u0631\3\2\2\2\u0633"+ 16340 "\u0634\3\2\2\2\u0634\u0632\3\2\2\2\u0634\u0635\3\2\2\2\u0635\u0636\3\2"+ 16341 "\2\2\u0636\u06f4\5\u008aF\2\u0637\u063b\7\n\2\2\u0638\u063a\t\7\2\2\u0639"+ 16342 "\u0638\3\2\2\2\u063a\u063d\3\2\2\2\u063b\u0639\3\2\2\2\u063b\u063c\3\2"+ 16343 "\2\2\u063c\u0640\3\2\2\2\u063d\u063b\3\2\2\2\u063e\u063f\t\7\2\2\u063f"+ 16344 "\u0641\5\u008aF\2\u0640\u063e\3\2\2\2\u0640\u0641\3\2\2\2\u0641\u06f4"+ 16345 "\3\2\2\2\u0642\u0647\7\13\2\2\u0643\u0648\7\6\2\2\u0644\u0648\7\b\2\2"+ 16346 "\u0645\u0646\6I\25\2\u0646\u0648\7\3\2\2\u0647\u0643\3\2\2\2\u0647\u0644"+ 16347 "\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649\3\2\2\2\u0649\u0647\3\2\2\2\u0649"+ 16348 "\u064a\3\2\2\2\u064a\u064b\3\2\2\2\u064b\u064f\7-\2\2\u064c\u064e\t\7"+ 16349 "\2\2\u064d\u064c\3\2\2\2\u064e\u0651\3\2\2\2\u064f\u064d\3\2\2\2\u064f"+ 16350 "\u0650\3\2\2\2\u0650\u0654\3\2\2\2\u0651\u064f\3\2\2\2\u0652\u0653\t\7"+ 16351 "\2\2\u0653\u0655\5\u008aF\2\u0654\u0652\3\2\2\2\u0654\u0655\3\2\2\2\u0655"+ 16352 "\u06f4\3\2\2\2\u0656\u065b\7\f\2\2\u0657\u065c\7\6\2\2\u0658\u065c\7\b"+ 16353 "\2\2\u0659\u065a\6I\26\2\u065a\u065c\7\3\2\2\u065b\u0657\3\2\2\2\u065b"+ 16354 "\u0658\3\2\2\2\u065b\u0659\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u065b\3\2"+ 16355 "\2\2\u065d\u065e\3\2\2\2\u065e\u065f\3\2\2\2\u065f\u0663\7\33\2\2\u0660"+ 16356 "\u0662\t\7\2\2\u0661\u0660\3\2\2\2\u0662\u0665\3\2\2\2\u0663\u0661\3\2"+ 16357 "\2\2\u0663\u0664\3\2\2\2\u0664\u0668\3\2\2\2\u0665\u0663\3\2\2\2\u0666"+ 16358 "\u0667\t\7\2\2\u0667\u0669\5\u008aF\2\u0668\u0666\3\2\2\2\u0668\u0669"+ 16359 "\3\2\2\2\u0669\u06f4\3\2\2\2\u066a\u066c\7\r\2\2\u066b\u066d\t\7\2\2\u066c"+ 16360 "\u066b\3\2\2\2\u066d\u066e\3\2\2\2\u066e\u066c\3\2\2\2\u066e\u066f\3\2"+ 16361 "\2\2\u066f\u0670\3\2\2\2\u0670\u06f4\5\u008aF\2\u0671\u0676\7\16\2\2\u0672"+ 16362 "\u0677\7\6\2\2\u0673\u0677\7\b\2\2\u0674\u0675\6I\27\2\u0675\u0677\7\3"+ 16363 "\2\2\u0676\u0672\3\2\2\2\u0676\u0673\3\2\2\2\u0676\u0674\3\2\2\2\u0677"+ 16364 "\u0678\3\2\2\2\u0678\u0676\3\2\2\2\u0678\u0679\3\2\2\2\u0679\u067d\3\2"+ 16365 "\2\2\u067a\u067e\5\u008cG\2\u067b\u067e\7\35\2\2\u067c\u067e\5\4\3\2\u067d"+ 16366 "\u067a\3\2\2\2\u067d\u067b\3\2\2\2\u067d\u067c\3\2\2\2\u067e\u0682\3\2"+ 16367 "\2\2\u067f\u0681\t\7\2\2\u0680\u067f\3\2\2\2\u0681\u0684\3\2\2\2\u0682"+ 16368 "\u0680\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u0687\3\2\2\2\u0684\u0682\3\2"+ 16369 "\2\2\u0685\u0686\t\7\2\2\u0686\u0688\5\u008aF\2\u0687\u0685\3\2\2\2\u0687"+ 16370 "\u0688\3\2\2\2\u0688\u06f4\3\2\2\2\u0689\u068d\7\17\2\2\u068a\u068c\t"+ 16371 "\7\2\2\u068b\u068a\3\2\2\2\u068c\u068f\3\2\2\2\u068d\u068b\3\2\2\2\u068d"+ 16372 "\u068e\3\2\2\2\u068e\u0694\3\2\2\2\u068f\u068d\3\2\2\2\u0690\u0691\t\7"+ 16373 "\2\2\u0691\u0695\5\u008aF\2\u0692\u0695\7\30\2\2\u0693\u0695\7\31\2\2"+ 16374 "\u0694\u0690\3\2\2\2\u0694\u0692\3\2\2\2\u0694\u0693\3\2\2\2\u0694\u0695"+ 16375 "\3\2\2\2\u0695\u0699\3\2\2\2\u0696\u0698\t\7\2\2\u0697\u0696\3\2\2\2\u0698"+ 16376 "\u069b\3\2\2\2\u0699\u0697\3\2\2\2\u0699\u069a\3\2\2\2\u069a\u06f4\3\2"+ 16377 "\2\2\u069b\u0699\3\2\2\2\u069c\u06a0\7\21\2\2\u069d\u069f\t\7\2\2\u069e"+ 16378 "\u069d\3\2\2\2\u069f\u06a2\3\2\2\2\u06a0\u069e\3\2\2\2\u06a0\u06a1\3\2"+ 16379 "\2\2\u06a1\u06a5\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a3\u06a4\t\7\2\2\u06a4"+ 16380 "\u06a6\5\u008aF\2\u06a5\u06a3\3\2\2\2\u06a5\u06a6\3\2\2\2\u06a6\u06f4"+ 16381 "\3\2\2\2\u06a7\u06ab\7\20\2\2\u06a8\u06aa\t\7\2\2\u06a9\u06a8\3\2\2\2"+ 16382 "\u06aa\u06ad\3\2\2\2\u06ab\u06a9\3\2\2\2\u06ab\u06ac\3\2\2\2\u06ac\u06b0"+ 16383 "\3\2\2\2\u06ad\u06ab\3\2\2\2\u06ae\u06af\t\7\2\2\u06af\u06b1\7)\2\2\u06b0"+ 16384 "\u06ae\3\2\2\2\u06b0\u06b1\3\2\2\2\u06b1\u06b5\3\2\2\2\u06b2\u06b4\t\7"+ 16385 "\2\2\u06b3\u06b2\3\2\2\2\u06b4\u06b7\3\2\2\2\u06b5\u06b3\3\2\2\2\u06b5"+ 16386 "\u06b6\3\2\2\2\u06b6\u06ba\3\2\2\2\u06b7\u06b5\3\2\2\2\u06b8\u06b9\t\7"+ 16387 "\2\2\u06b9\u06bb\7+\2\2\u06ba\u06b8\3\2\2\2\u06ba\u06bb\3\2\2\2\u06bb"+ 16388 "\u06bf\3\2\2\2\u06bc\u06be\t\7\2\2\u06bd\u06bc\3\2\2\2\u06be\u06c1\3\2"+ 16389 "\2\2\u06bf\u06bd\3\2\2\2\u06bf\u06c0\3\2\2\2\u06c0\u06c4\3\2\2\2\u06c1"+ 16390 "\u06bf\3\2\2\2\u06c2\u06c3\t\7\2\2\u06c3\u06c5\5\u008aF\2\u06c4\u06c2"+ 16391 "\3\2\2\2\u06c4\u06c5\3\2\2\2\u06c5\u06f4\3\2\2\2\u06c6\u06c8\7\22\2\2"+ 16392 "\u06c7\u06c9\t\7\2\2\u06c8\u06c7\3\2\2\2\u06c9\u06ca\3\2\2\2\u06ca\u06c8"+ 16393 "\3\2\2\2\u06ca\u06cb\3\2\2\2\u06cb\u06cc\3\2\2\2\u06cc\u06f4\5\u008aF"+ 16394 "\2\u06cd\u06d2\7\23\2\2\u06ce\u06d3\7\6\2\2\u06cf\u06d3\7\b\2\2\u06d0"+ 16395 "\u06d1\6I\30\2\u06d1\u06d3\7\3\2\2\u06d2\u06ce\3\2\2\2\u06d2\u06cf\3\2"+ 16396 "\2\2\u06d2\u06d0\3\2\2\2\u06d3\u06d4\3\2\2\2\u06d4\u06d2\3\2\2\2\u06d4"+ 16397 "\u06d5\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06da\7-\2\2\u06d7\u06d9\t\7"+ 16398 "\2\2\u06d8\u06d7\3\2\2\2\u06d9\u06dc\3\2\2\2\u06da\u06d8\3\2\2\2\u06da"+ 16399 "\u06db\3\2\2\2\u06db\u06df\3\2\2\2\u06dc\u06da\3\2\2\2\u06dd\u06de\t\7"+ 16400 "\2\2\u06de\u06e0\5\u008aF\2\u06df\u06dd\3\2\2\2\u06df\u06e0\3\2\2\2\u06e0"+ 16401 "\u06f4\3\2\2\2\u06e1\u06e3\7\24\2\2\u06e2\u06e4\t\7\2\2\u06e3\u06e2\3"+ 16402 "\2\2\2\u06e4\u06e5\3\2\2\2\u06e5\u06e3\3\2\2\2\u06e5\u06e6\3\2\2\2\u06e6"+ 16403 "\u06e7\3\2\2\2\u06e7\u06f4\5\u008aF\2\u06e8\u06ec\7\27\2\2\u06e9\u06eb"+ 16404 "\t\7\2\2\u06ea\u06e9\3\2\2\2\u06eb\u06ee\3\2\2\2\u06ec\u06ea\3\2\2\2\u06ec"+ 16405 "\u06ed\3\2\2\2\u06ed\u06f1\3\2\2\2\u06ee\u06ec\3\2\2\2\u06ef\u06f0\t\7"+ 16406 "\2\2\u06f0\u06f2\5\u008aF\2\u06f1\u06ef\3\2\2\2\u06f1\u06f2\3\2\2\2\u06f2"+ 16407 "\u06f4\3\2\2\2\u06f3\u0630\3\2\2\2\u06f3\u0637\3\2\2\2\u06f3\u0642\3\2"+ 16408 "\2\2\u06f3\u0656\3\2\2\2\u06f3\u066a\3\2\2\2\u06f3\u0671\3\2\2\2\u06f3"+ 16409 "\u0689\3\2\2\2\u06f3\u069c\3\2\2\2\u06f3\u06a7\3\2\2\2\u06f3\u06c6\3\2"+ 16410 "\2\2\u06f3\u06cd\3\2\2\2\u06f3\u06e1\3\2\2\2\u06f3\u06e8\3\2\2\2\u06f4"+ 16411 "\u0091\3\2\2\2\u06f5\u0750\7\25\2\2\u06f6\u06fd\7/\2\2\u06f7\u06fc\7\6"+ 16412 "\2\2\u06f8\u06fc\7\b\2\2\u06f9\u06fc\7\3\2\2\u06fa\u06fc\5\u0096L\2\u06fb"+ 16413 "\u06f7\3\2\2\2\u06fb\u06f8\3\2\2\2\u06fb\u06f9\3\2\2\2\u06fb\u06fa\3\2"+ 16414 "\2\2\u06fc\u06ff\3\2\2\2\u06fd\u06fb\3\2\2\2\u06fd\u06fe\3\2\2\2\u06fe"+ 16415 "\u0751\3\2\2\2\u06ff\u06fd\3\2\2\2\u0700\u0704\7\60\2\2\u0701\u0703\t"+ 16416 "\2\2\2\u0702\u0701\3\2\2\2\u0703\u0706\3\2\2\2\u0704\u0702\3\2\2\2\u0704"+ 16417 "\u0705\3\2\2\2\u0705\u0751\3\2\2\2\u0706\u0704\3\2\2\2\u0707\u070b\7\61"+ 16418 "\2\2\u0708\u070a\t\2\2\2\u0709\u0708\3\2\2\2\u070a\u070d\3\2\2\2\u070b"+ 16419 "\u0709\3\2\2\2\u070b\u070c\3\2\2\2\u070c\u0751\3\2\2\2\u070d\u070b\3\2"+ 16420 "\2\2\u070e\u0710\7\62\2\2\u070f\u0711\t\2\2\2\u0710\u070f\3\2\2\2\u0711"+ 16421 "\u0712\3\2\2\2\u0712\u0710\3\2\2\2\u0712\u0713\3\2\2\2\u0713\u0714\3\2"+ 16422 "\2\2\u0714\u0718\5\u008cG\2\u0715\u0717\t\7\2\2\u0716\u0715\3\2\2\2\u0717"+ 16423 "\u071a\3\2\2\2\u0718\u0716\3\2\2\2\u0718\u0719\3\2\2\2\u0719\u071d\3\2"+ 16424 "\2\2\u071a\u0718\3\2\2\2\u071b\u071c\t\7\2\2\u071c\u071e\5\u008aF\2\u071d"+ 16425 "\u071b\3\2\2\2\u071d\u071e\3\2\2\2\u071e\u0751\3\2\2\2\u071f\u0721\7\63"+ 16426 "\2\2\u0720\u0722\t\2\2\2\u0721\u0720\3\2\2\2\u0722\u0723\3\2\2\2\u0723"+ 16427 "\u0721\3\2\2\2\u0723\u0724\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u0729\5\u008c"+ 16428 "G\2\u0726\u0728\t\7\2\2\u0727\u0726\3\2\2\2\u0728\u072b\3\2\2\2\u0729"+ 16429 "\u0727\3\2\2\2\u0729\u072a\3\2\2\2\u072a\u072e\3\2\2\2\u072b\u0729\3\2"+ 16430 "\2\2\u072c\u072d\t\7\2\2\u072d\u072f\5\u008aF\2\u072e\u072c\3\2\2\2\u072e"+ 16431 "\u072f\3\2\2\2\u072f\u0751\3\2\2\2\u0730\u0737\7\64\2\2\u0731\u0736\7"+ 16432 "\6\2\2\u0732\u0736\7\b\2\2\u0733\u0736\7\3\2\2\u0734\u0736\5\u0096L\2"+ 16433 "\u0735\u0731\3\2\2\2\u0735\u0732\3\2\2\2\u0735\u0733\3\2\2\2\u0735\u0734"+ 16434 "\3\2\2\2\u0736\u0739\3\2\2\2\u0737\u0735\3\2\2\2\u0737\u0738\3\2\2\2\u0738"+ 16435 "\u0751\3\2\2\2\u0739\u0737\3\2\2\2\u073a\u073e\7\65\2\2\u073b\u073d\t"+ 16436 "\2\2\2\u073c\u073b\3\2\2\2\u073d\u0740\3\2\2\2\u073e\u073c\3\2\2\2\u073e"+ 16437 "\u073f\3\2\2\2\u073f\u0743\3\2\2\2\u0740\u073e\3\2\2\2\u0741\u0742\t\7"+ 16438 "\2\2\u0742\u0744\5\u008cG\2\u0743\u0741\3\2\2\2\u0743\u0744\3\2\2\2\u0744"+ 16439 "\u0751\3\2\2\2\u0745\u0749\7\27\2\2\u0746\u0748\t\2\2\2\u0747\u0746\3"+ 16440 "\2\2\2\u0748\u074b\3\2\2\2\u0749\u0747\3\2\2\2\u0749\u074a\3\2\2\2\u074a"+ 16441 "\u074e\3\2\2\2\u074b\u0749\3\2\2\2\u074c\u074d\t\7\2\2\u074d\u074f\5\u008a"+ 16442 "F\2\u074e\u074c\3\2\2\2\u074e\u074f\3\2\2\2\u074f\u0751\3\2\2\2\u0750"+ 16443 "\u06f6\3\2\2\2\u0750\u0700\3\2\2\2\u0750\u0707\3\2\2\2\u0750\u070e\3\2"+ 16444 "\2\2\u0750\u071f\3\2\2\2\u0750\u0730\3\2\2\2\u0750\u073a\3\2\2\2\u0750"+ 16445 "\u0745\3\2\2\2\u0751\u0752\3\2\2\2\u0752\u0753\7\26\2\2\u0753\u0093\3"+ 16446 "\2\2\2\u0754\u075a\7\4\2\2\u0755\u0759\5\u0096L\2\u0756\u0759\7\b\2\2"+ 16447 "\u0757\u0759\7\3\2\2\u0758\u0755\3\2\2\2\u0758\u0756\3\2\2\2\u0758\u0757"+ 16448 "\3\2\2\2\u0759\u075c\3\2\2\2\u075a\u0758\3\2\2\2\u075a\u075b\3\2\2\2\u075b"+ 16449 "\u075d\3\2\2\2\u075c\u075a\3\2\2\2\u075d\u075e\7]\2\2\u075e\u0095\3\2"+ 16450 "\2\2\u075f\u0760\t\b\2\2\u0760\u0762\bL\1\2\u0761\u075f\3\2\2\2\u0762"+ 16451 "\u0763\3\2\2\2\u0763\u0761\3\2\2\2\u0763\u0764\3\2\2\2\u0764\u0097\3\2"+ 16452 "\2\2\u0765\u0766\7\7\2\2\u0766\u076d\7Y\2\2\u0767\u076c\5\n\6\2\u0768"+ 16453 "\u076c\7\b\2\2\u0769\u076c\7\3\2\2\u076a\u076c\7\6\2\2\u076b\u0767\3\2"+ 16454 "\2\2\u076b\u0768\3\2\2\2\u076b\u0769\3\2\2\2\u076b\u076a\3\2\2\2\u076c"+ 16455 "\u076f\3\2\2\2\u076d\u076b\3\2\2\2\u076d\u076e\3\2\2\2\u076e\u0770\3\2"+ 16456 "\2\2\u076f\u076d\3\2\2\2\u0770\u0771\t\4\2\2\u0771\u0099\3\2\2\2\u0772"+ 16457 "\u0773\7\7\2\2\u0773\u077a\7Z\2\2\u0774\u0779\5\n\6\2\u0775\u0779\7\b"+ 16458 "\2\2\u0776\u0779\7\3\2\2\u0777\u0779\7\6\2\2\u0778\u0774\3\2\2\2\u0778"+ 16459 "\u0775\3\2\2\2\u0778\u0776\3\2\2\2\u0778\u0777\3\2\2\2\u0779\u077c\3\2"+ 16460 "\2\2\u077a\u0778\3\2\2\2\u077a\u077b\3\2\2\2\u077b\u077d\3\2\2\2\u077c"+ 16461 "\u077a\3\2\2\2\u077d\u077e\t\4\2\2\u077e\u009b\3\2\2\2\u077f\u0780\7\7"+ 16462 "\2\2\u0780\u0787\7^\2\2\u0781\u0786\5\n\6\2\u0782\u0786\7\b\2\2\u0783"+ 16463 "\u0786\7\3\2\2\u0784\u0786\7\6\2\2\u0785\u0781\3\2\2\2\u0785\u0782\3\2"+ 16464 "\2\2\u0785\u0783\3\2\2\2\u0785\u0784\3\2\2\2\u0786\u0789\3\2\2\2\u0787"+ 16465 "\u0785\3\2\2\2\u0787\u0788\3\2\2\2\u0788\u078a\3\2\2\2\u0789\u0787\3\2"+ 16466 "\2\2\u078a\u078b\t\4\2\2\u078b\u009d\3\2\2\2\u078c\u078d\7\7\2\2\u078d"+ 16467 "\u0794\7_\2\2\u078e\u0793\5\n\6\2\u078f\u0793\7\b\2\2\u0790\u0793\7\3"+ 16468 "\2\2\u0791\u0793\7\6\2\2\u0792\u078e\3\2\2\2\u0792\u078f\3\2\2\2\u0792"+ 16469 "\u0790\3\2\2\2\u0792\u0791\3\2\2\2\u0793\u0796\3\2\2\2\u0794\u0792\3\2"+ 16470 "\2\2\u0794\u0795\3\2\2\2\u0795\u0797\3\2\2\2\u0796\u0794\3\2\2\2\u0797"+ 16471 "\u0798\t\4\2\2\u0798\u009f\3\2\2\2\u0799\u079a\7\7\2\2\u079a\u07a1\7`"+ 16472 "\2\2\u079b\u07a0\5\n\6\2\u079c\u07a0\7\b\2\2\u079d\u07a0\7\3\2\2\u079e"+ 16473 "\u07a0\7\6\2\2\u079f\u079b\3\2\2\2\u079f\u079c\3\2\2\2\u079f\u079d\3\2"+ 16474 "\2\2\u079f\u079e\3\2\2\2\u07a0\u07a3\3\2\2\2\u07a1\u079f\3\2\2\2\u07a1"+ 16475 "\u07a2\3\2\2\2\u07a2\u07a4\3\2\2\2\u07a3\u07a1\3\2\2\2\u07a4\u07a5\t\4"+ 16476 "\2\2\u07a5\u00a1\3\2\2\2\u00c2\u00aa\u00ac\u00b0\u00b5\u00bb\u00ef\u00f7"+ 16477 "\u00f9\u0104\u010d\u0114\u011a\u0125\u0127\u0133\u0135\u0140\u016b\u016d"+ 16478 "\u0178\u017a\u0185\u01b0\u01b2\u01bd\u01bf\u01ca\u01f5\u01f7\u0202\u0204"+ 16479 "\u020f\u023a\u023c\u0247\u0249\u0254\u027f\u0281\u028c\u028e\u0299\u02c4"+ 16480 "\u02c6\u02d1\u02d3\u02de\u0309\u030b\u0316\u0318\u0323\u034e\u0350\u035b"+ 16481 "\u035d\u0368\u0393\u0395\u03a0\u03a2\u03ad\u03d8\u03da\u03e5\u03e7\u03f2"+ 16482 "\u041d\u041f\u042a\u042c\u0437\u0462\u0464\u046f\u0471\u047c\u04a7\u04a9"+ 16483 "\u04b4\u04b6\u04c1\u04ec\u04ee\u04f9\u04fb\u0506\u0531\u0533\u054c\u0554"+ 16484 "\u0556\u0561\u0563\u056e\u0570\u057b\u057d\u0588\u058a\u0595\u0597\u05a2"+ 16485 "\u05a4\u05af\u05b1\u05bc\u05be\u05c9\u05cb\u05d6\u05d8\u05e3\u05e5\u05f0"+ 16486 "\u05f2\u05fd\u05ff\u0614\u0616\u061c\u061e\u0623\u0625\u062b\u0634\u063b"+ 16487 "\u0640\u0647\u0649\u064f\u0654\u065b\u065d\u0663\u0668\u066e\u0676\u0678"+ 16488 "\u067d\u0682\u0687\u068d\u0694\u0699\u06a0\u06a5\u06ab\u06b0\u06b5\u06ba"+ 16489 "\u06bf\u06c4\u06ca\u06d2\u06d4\u06da\u06df\u06e5\u06ec\u06f1\u06f3\u06fb"+ 16490 "\u06fd\u0704\u070b\u0712\u0718\u071d\u0723\u0729\u072e\u0735\u0737\u073e"+ 16491 "\u0743\u0749\u074e\u0750\u0758\u075a\u0763\u076b\u076d\u0778\u077a\u0785"+ 16492 "\u0787\u0792\u0794\u079f\u07a1"; 16493 public static final ATN _ATN = 16494 new ATNDeserializer().deserialize(_serializedATN.toCharArray()); 16495 static { 16496 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; 16497 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { 16498 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); 16499 } 16500 } 16501}