1 // Generated from XMLParser.g4 by ANTLR 4.5.3 2 package android.databinding.parser; 3 import org.antlr.v4.runtime.atn.*; 4 import org.antlr.v4.runtime.dfa.DFA; 5 import org.antlr.v4.runtime.*; 6 import org.antlr.v4.runtime.misc.*; 7 import org.antlr.v4.runtime.tree.*; 8 import java.util.List; 9 import java.util.Iterator; 10 import java.util.ArrayList; 11 12 @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) 13 public class XMLParser extends Parser { 14 static { RuntimeMetaData.checkVersion("4.5.3", RuntimeMetaData.VERSION); } 15 16 protected static final DFA[] _decisionToDFA; 17 protected static final PredictionContextCache _sharedContextCache = 18 new PredictionContextCache(); 19 public static final int 20 COMMENT=1, CDATA=2, DTD=3, EntityRef=4, CharRef=5, SEA_WS=6, OPEN=7, XMLDeclOpen=8, 21 TEXT=9, CLOSE=10, SPECIAL_CLOSE=11, SLASH_CLOSE=12, SLASH=13, EQUALS=14, 22 STRING=15, Name=16, S=17, PI=18; 23 public static final int 24 RULE_document = 0, RULE_prolog = 1, RULE_content = 2, RULE_element = 3, 25 RULE_reference = 4, RULE_attribute = 5, RULE_chardata = 6, RULE_misc = 7; 26 public static final String[] ruleNames = { 27 "document", "prolog", "content", "element", "reference", "attribute", 28 "chardata", "misc" 29 }; 30 31 private static final String[] _LITERAL_NAMES = { 32 null, null, null, null, null, null, null, "'<'", null, null, "'>'", null, 33 "'/>'", "'/'", "'='" 34 }; 35 private static final String[] _SYMBOLIC_NAMES = { 36 null, "COMMENT", "CDATA", "DTD", "EntityRef", "CharRef", "SEA_WS", "OPEN", 37 "XMLDeclOpen", "TEXT", "CLOSE", "SPECIAL_CLOSE", "SLASH_CLOSE", "SLASH", 38 "EQUALS", "STRING", "Name", "S", "PI" 39 }; 40 public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); 41 42 /** 43 * @deprecated Use {@link #VOCABULARY} instead. 44 */ 45 @Deprecated 46 public static final String[] tokenNames; 47 static { 48 tokenNames = new String[_SYMBOLIC_NAMES.length]; 49 for (int i = 0; i < tokenNames.length; i++) { 50 tokenNames[i] = VOCABULARY.getLiteralName(i); 51 if (tokenNames[i] == null) { 52 tokenNames[i] = VOCABULARY.getSymbolicName(i); 53 } 54 55 if (tokenNames[i] == null) { 56 tokenNames[i] = "<INVALID>"; 57 } 58 } 59 } 60 61 @Override 62 @Deprecated 63 public String[] getTokenNames() { 64 return tokenNames; 65 } 66 67 @Override 68 69 public Vocabulary getVocabulary() { 70 return VOCABULARY; 71 } 72 73 @Override 74 public String getGrammarFileName() { return "XMLParser.g4"; } 75 76 @Override 77 public String[] getRuleNames() { return ruleNames; } 78 79 @Override 80 public String getSerializedATN() { return _serializedATN; } 81 82 @Override 83 public ATN getATN() { return _ATN; } 84 85 public XMLParser(TokenStream input) { 86 super(input); 87 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); 88 } 89 public static class DocumentContext extends ParserRuleContext { 90 public ElementContext element() { 91 return getRuleContext(ElementContext.class,0); 92 } 93 public PrologContext prolog() { 94 return getRuleContext(PrologContext.class,0); 95 } 96 public List<MiscContext> misc() { 97 return getRuleContexts(MiscContext.class); 98 } 99 public MiscContext misc(int i) { 100 return getRuleContext(MiscContext.class,i); 101 } 102 public DocumentContext(ParserRuleContext parent, int invokingState) { 103 super(parent, invokingState); 104 } 105 @Override public int getRuleIndex() { return RULE_document; } 106 @Override 107 public void enterRule(ParseTreeListener listener) { 108 if ( listener instanceof XMLParserListener ) ((XMLParserListener)listener).enterDocument(this); 109 } 110 @Override 111 public void exitRule(ParseTreeListener listener) { 112 if ( listener instanceof XMLParserListener ) ((XMLParserListener)listener).exitDocument(this); 113 } 114 @Override 115 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 116 if ( visitor instanceof XMLParserVisitor ) return ((XMLParserVisitor<? extends T>)visitor).visitDocument(this); 117 else return visitor.visitChildren(this); 118 } 119 } 120 121 public final DocumentContext document() throws RecognitionException { 122 DocumentContext _localctx = new DocumentContext(_ctx, getState()); 123 enterRule(_localctx, 0, RULE_document); 124 int _la; 125 try { 126 enterOuterAlt(_localctx, 1); 127 { 128 setState(17); 129 _la = _input.LA(1); 130 if (_la==XMLDeclOpen) { 131 { 132 setState(16); 133 prolog(); 134 } 135 } 136 137 setState(22); 138 _errHandler.sync(this); 139 _la = _input.LA(1); 140 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << COMMENT) | (1L << SEA_WS) | (1L << PI))) != 0)) { 141 { 142 { 143 setState(19); 144 misc(); 145 } 146 } 147 setState(24); 148 _errHandler.sync(this); 149 _la = _input.LA(1); 150 } 151 setState(25); 152 element(); 153 setState(29); 154 _errHandler.sync(this); 155 _la = _input.LA(1); 156 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << COMMENT) | (1L << SEA_WS) | (1L << PI))) != 0)) { 157 { 158 { 159 setState(26); 160 misc(); 161 } 162 } 163 setState(31); 164 _errHandler.sync(this); 165 _la = _input.LA(1); 166 } 167 } 168 } 169 catch (RecognitionException re) { 170 _localctx.exception = re; 171 _errHandler.reportError(this, re); 172 _errHandler.recover(this, re); 173 } 174 finally { 175 exitRule(); 176 } 177 return _localctx; 178 } 179 180 public static class PrologContext extends ParserRuleContext { 181 public TerminalNode XMLDeclOpen() { return getToken(XMLParser.XMLDeclOpen, 0); } 182 public TerminalNode SPECIAL_CLOSE() { return getToken(XMLParser.SPECIAL_CLOSE, 0); } 183 public List<AttributeContext> attribute() { 184 return getRuleContexts(AttributeContext.class); 185 } 186 public AttributeContext attribute(int i) { 187 return getRuleContext(AttributeContext.class,i); 188 } 189 public PrologContext(ParserRuleContext parent, int invokingState) { 190 super(parent, invokingState); 191 } 192 @Override public int getRuleIndex() { return RULE_prolog; } 193 @Override 194 public void enterRule(ParseTreeListener listener) { 195 if ( listener instanceof XMLParserListener ) ((XMLParserListener)listener).enterProlog(this); 196 } 197 @Override 198 public void exitRule(ParseTreeListener listener) { 199 if ( listener instanceof XMLParserListener ) ((XMLParserListener)listener).exitProlog(this); 200 } 201 @Override 202 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 203 if ( visitor instanceof XMLParserVisitor ) return ((XMLParserVisitor<? extends T>)visitor).visitProlog(this); 204 else return visitor.visitChildren(this); 205 } 206 } 207 208 public final PrologContext prolog() throws RecognitionException { 209 PrologContext _localctx = new PrologContext(_ctx, getState()); 210 enterRule(_localctx, 2, RULE_prolog); 211 int _la; 212 try { 213 enterOuterAlt(_localctx, 1); 214 { 215 setState(32); 216 match(XMLDeclOpen); 217 setState(36); 218 _errHandler.sync(this); 219 _la = _input.LA(1); 220 while (_la==Name) { 221 { 222 { 223 setState(33); 224 attribute(); 225 } 226 } 227 setState(38); 228 _errHandler.sync(this); 229 _la = _input.LA(1); 230 } 231 setState(39); 232 match(SPECIAL_CLOSE); 233 } 234 } 235 catch (RecognitionException re) { 236 _localctx.exception = re; 237 _errHandler.reportError(this, re); 238 _errHandler.recover(this, re); 239 } 240 finally { 241 exitRule(); 242 } 243 return _localctx; 244 } 245 246 public static class ContentContext extends ParserRuleContext { 247 public List<ChardataContext> chardata() { 248 return getRuleContexts(ChardataContext.class); 249 } 250 public ChardataContext chardata(int i) { 251 return getRuleContext(ChardataContext.class,i); 252 } 253 public List<ElementContext> element() { 254 return getRuleContexts(ElementContext.class); 255 } 256 public ElementContext element(int i) { 257 return getRuleContext(ElementContext.class,i); 258 } 259 public List<ReferenceContext> reference() { 260 return getRuleContexts(ReferenceContext.class); 261 } 262 public ReferenceContext reference(int i) { 263 return getRuleContext(ReferenceContext.class,i); 264 } 265 public List<TerminalNode> CDATA() { return getTokens(XMLParser.CDATA); } 266 public TerminalNode CDATA(int i) { 267 return getToken(XMLParser.CDATA, i); 268 } 269 public List<TerminalNode> PI() { return getTokens(XMLParser.PI); } 270 public TerminalNode PI(int i) { 271 return getToken(XMLParser.PI, i); 272 } 273 public List<TerminalNode> COMMENT() { return getTokens(XMLParser.COMMENT); } 274 public TerminalNode COMMENT(int i) { 275 return getToken(XMLParser.COMMENT, i); 276 } 277 public ContentContext(ParserRuleContext parent, int invokingState) { 278 super(parent, invokingState); 279 } 280 @Override public int getRuleIndex() { return RULE_content; } 281 @Override 282 public void enterRule(ParseTreeListener listener) { 283 if ( listener instanceof XMLParserListener ) ((XMLParserListener)listener).enterContent(this); 284 } 285 @Override 286 public void exitRule(ParseTreeListener listener) { 287 if ( listener instanceof XMLParserListener ) ((XMLParserListener)listener).exitContent(this); 288 } 289 @Override 290 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 291 if ( visitor instanceof XMLParserVisitor ) return ((XMLParserVisitor<? extends T>)visitor).visitContent(this); 292 else return visitor.visitChildren(this); 293 } 294 } 295 296 public final ContentContext content() throws RecognitionException { 297 ContentContext _localctx = new ContentContext(_ctx, getState()); 298 enterRule(_localctx, 4, RULE_content); 299 int _la; 300 try { 301 int _alt; 302 enterOuterAlt(_localctx, 1); 303 { 304 setState(42); 305 _la = _input.LA(1); 306 if (_la==SEA_WS || _la==TEXT) { 307 { 308 setState(41); 309 chardata(); 310 } 311 } 312 313 setState(56); 314 _errHandler.sync(this); 315 _alt = getInterpreter().adaptivePredict(_input,7,_ctx); 316 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 317 if ( _alt==1 ) { 318 { 319 { 320 setState(49); 321 switch (_input.LA(1)) { 322 case OPEN: 323 { 324 setState(44); 325 element(); 326 } 327 break; 328 case EntityRef: 329 case CharRef: 330 { 331 setState(45); 332 reference(); 333 } 334 break; 335 case CDATA: 336 { 337 setState(46); 338 match(CDATA); 339 } 340 break; 341 case PI: 342 { 343 setState(47); 344 match(PI); 345 } 346 break; 347 case COMMENT: 348 { 349 setState(48); 350 match(COMMENT); 351 } 352 break; 353 default: 354 throw new NoViableAltException(this); 355 } 356 setState(52); 357 _la = _input.LA(1); 358 if (_la==SEA_WS || _la==TEXT) { 359 { 360 setState(51); 361 chardata(); 362 } 363 } 364 365 } 366 } 367 } 368 setState(58); 369 _errHandler.sync(this); 370 _alt = getInterpreter().adaptivePredict(_input,7,_ctx); 371 } 372 } 373 } 374 catch (RecognitionException re) { 375 _localctx.exception = re; 376 _errHandler.reportError(this, re); 377 _errHandler.recover(this, re); 378 } 379 finally { 380 exitRule(); 381 } 382 return _localctx; 383 } 384 385 public static class ElementContext extends ParserRuleContext { 386 public Token elmName; 387 public ContentContext content() { 388 return getRuleContext(ContentContext.class,0); 389 } 390 public List<TerminalNode> Name() { return getTokens(XMLParser.Name); } 391 public TerminalNode Name(int i) { 392 return getToken(XMLParser.Name, i); 393 } 394 public List<AttributeContext> attribute() { 395 return getRuleContexts(AttributeContext.class); 396 } 397 public AttributeContext attribute(int i) { 398 return getRuleContext(AttributeContext.class,i); 399 } 400 public ElementContext(ParserRuleContext parent, int invokingState) { 401 super(parent, invokingState); 402 } 403 @Override public int getRuleIndex() { return RULE_element; } 404 @Override 405 public void enterRule(ParseTreeListener listener) { 406 if ( listener instanceof XMLParserListener ) ((XMLParserListener)listener).enterElement(this); 407 } 408 @Override 409 public void exitRule(ParseTreeListener listener) { 410 if ( listener instanceof XMLParserListener ) ((XMLParserListener)listener).exitElement(this); 411 } 412 @Override 413 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 414 if ( visitor instanceof XMLParserVisitor ) return ((XMLParserVisitor<? extends T>)visitor).visitElement(this); 415 else return visitor.visitChildren(this); 416 } 417 } 418 419 public final ElementContext element() throws RecognitionException { 420 ElementContext _localctx = new ElementContext(_ctx, getState()); 421 enterRule(_localctx, 6, RULE_element); 422 int _la; 423 try { 424 setState(83); 425 _errHandler.sync(this); 426 switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) { 427 case 1: 428 enterOuterAlt(_localctx, 1); 429 { 430 setState(59); 431 match(OPEN); 432 setState(60); 433 ((ElementContext)_localctx).elmName = match(Name); 434 setState(64); 435 _errHandler.sync(this); 436 _la = _input.LA(1); 437 while (_la==Name) { 438 { 439 { 440 setState(61); 441 attribute(); 442 } 443 } 444 setState(66); 445 _errHandler.sync(this); 446 _la = _input.LA(1); 447 } 448 setState(67); 449 match(CLOSE); 450 setState(68); 451 content(); 452 setState(69); 453 match(OPEN); 454 setState(70); 455 match(SLASH); 456 setState(71); 457 match(Name); 458 setState(72); 459 match(CLOSE); 460 } 461 break; 462 case 2: 463 enterOuterAlt(_localctx, 2); 464 { 465 setState(74); 466 match(OPEN); 467 setState(75); 468 ((ElementContext)_localctx).elmName = match(Name); 469 setState(79); 470 _errHandler.sync(this); 471 _la = _input.LA(1); 472 while (_la==Name) { 473 { 474 { 475 setState(76); 476 attribute(); 477 } 478 } 479 setState(81); 480 _errHandler.sync(this); 481 _la = _input.LA(1); 482 } 483 setState(82); 484 match(SLASH_CLOSE); 485 } 486 break; 487 } 488 } 489 catch (RecognitionException re) { 490 _localctx.exception = re; 491 _errHandler.reportError(this, re); 492 _errHandler.recover(this, re); 493 } 494 finally { 495 exitRule(); 496 } 497 return _localctx; 498 } 499 500 public static class ReferenceContext extends ParserRuleContext { 501 public TerminalNode EntityRef() { return getToken(XMLParser.EntityRef, 0); } 502 public TerminalNode CharRef() { return getToken(XMLParser.CharRef, 0); } 503 public ReferenceContext(ParserRuleContext parent, int invokingState) { 504 super(parent, invokingState); 505 } 506 @Override public int getRuleIndex() { return RULE_reference; } 507 @Override 508 public void enterRule(ParseTreeListener listener) { 509 if ( listener instanceof XMLParserListener ) ((XMLParserListener)listener).enterReference(this); 510 } 511 @Override 512 public void exitRule(ParseTreeListener listener) { 513 if ( listener instanceof XMLParserListener ) ((XMLParserListener)listener).exitReference(this); 514 } 515 @Override 516 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 517 if ( visitor instanceof XMLParserVisitor ) return ((XMLParserVisitor<? extends T>)visitor).visitReference(this); 518 else return visitor.visitChildren(this); 519 } 520 } 521 522 public final ReferenceContext reference() throws RecognitionException { 523 ReferenceContext _localctx = new ReferenceContext(_ctx, getState()); 524 enterRule(_localctx, 8, RULE_reference); 525 int _la; 526 try { 527 enterOuterAlt(_localctx, 1); 528 { 529 setState(85); 530 _la = _input.LA(1); 531 if ( !(_la==EntityRef || _la==CharRef) ) { 532 _errHandler.recoverInline(this); 533 } else { 534 consume(); 535 } 536 } 537 } 538 catch (RecognitionException re) { 539 _localctx.exception = re; 540 _errHandler.reportError(this, re); 541 _errHandler.recover(this, re); 542 } 543 finally { 544 exitRule(); 545 } 546 return _localctx; 547 } 548 549 public static class AttributeContext extends ParserRuleContext { 550 public Token attrName; 551 public Token attrValue; 552 public TerminalNode Name() { return getToken(XMLParser.Name, 0); } 553 public TerminalNode STRING() { return getToken(XMLParser.STRING, 0); } 554 public AttributeContext(ParserRuleContext parent, int invokingState) { 555 super(parent, invokingState); 556 } 557 @Override public int getRuleIndex() { return RULE_attribute; } 558 @Override 559 public void enterRule(ParseTreeListener listener) { 560 if ( listener instanceof XMLParserListener ) ((XMLParserListener)listener).enterAttribute(this); 561 } 562 @Override 563 public void exitRule(ParseTreeListener listener) { 564 if ( listener instanceof XMLParserListener ) ((XMLParserListener)listener).exitAttribute(this); 565 } 566 @Override 567 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 568 if ( visitor instanceof XMLParserVisitor ) return ((XMLParserVisitor<? extends T>)visitor).visitAttribute(this); 569 else return visitor.visitChildren(this); 570 } 571 } 572 573 public final AttributeContext attribute() throws RecognitionException { 574 AttributeContext _localctx = new AttributeContext(_ctx, getState()); 575 enterRule(_localctx, 10, RULE_attribute); 576 try { 577 enterOuterAlt(_localctx, 1); 578 { 579 setState(87); 580 ((AttributeContext)_localctx).attrName = match(Name); 581 setState(88); 582 match(EQUALS); 583 setState(89); 584 ((AttributeContext)_localctx).attrValue = match(STRING); 585 } 586 } 587 catch (RecognitionException re) { 588 _localctx.exception = re; 589 _errHandler.reportError(this, re); 590 _errHandler.recover(this, re); 591 } 592 finally { 593 exitRule(); 594 } 595 return _localctx; 596 } 597 598 public static class ChardataContext extends ParserRuleContext { 599 public TerminalNode TEXT() { return getToken(XMLParser.TEXT, 0); } 600 public TerminalNode SEA_WS() { return getToken(XMLParser.SEA_WS, 0); } 601 public ChardataContext(ParserRuleContext parent, int invokingState) { 602 super(parent, invokingState); 603 } 604 @Override public int getRuleIndex() { return RULE_chardata; } 605 @Override 606 public void enterRule(ParseTreeListener listener) { 607 if ( listener instanceof XMLParserListener ) ((XMLParserListener)listener).enterChardata(this); 608 } 609 @Override 610 public void exitRule(ParseTreeListener listener) { 611 if ( listener instanceof XMLParserListener ) ((XMLParserListener)listener).exitChardata(this); 612 } 613 @Override 614 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 615 if ( visitor instanceof XMLParserVisitor ) return ((XMLParserVisitor<? extends T>)visitor).visitChardata(this); 616 else return visitor.visitChildren(this); 617 } 618 } 619 620 public final ChardataContext chardata() throws RecognitionException { 621 ChardataContext _localctx = new ChardataContext(_ctx, getState()); 622 enterRule(_localctx, 12, RULE_chardata); 623 int _la; 624 try { 625 enterOuterAlt(_localctx, 1); 626 { 627 setState(91); 628 _la = _input.LA(1); 629 if ( !(_la==SEA_WS || _la==TEXT) ) { 630 _errHandler.recoverInline(this); 631 } else { 632 consume(); 633 } 634 } 635 } 636 catch (RecognitionException re) { 637 _localctx.exception = re; 638 _errHandler.reportError(this, re); 639 _errHandler.recover(this, re); 640 } 641 finally { 642 exitRule(); 643 } 644 return _localctx; 645 } 646 647 public static class MiscContext extends ParserRuleContext { 648 public TerminalNode COMMENT() { return getToken(XMLParser.COMMENT, 0); } 649 public TerminalNode PI() { return getToken(XMLParser.PI, 0); } 650 public TerminalNode SEA_WS() { return getToken(XMLParser.SEA_WS, 0); } 651 public MiscContext(ParserRuleContext parent, int invokingState) { 652 super(parent, invokingState); 653 } 654 @Override public int getRuleIndex() { return RULE_misc; } 655 @Override 656 public void enterRule(ParseTreeListener listener) { 657 if ( listener instanceof XMLParserListener ) ((XMLParserListener)listener).enterMisc(this); 658 } 659 @Override 660 public void exitRule(ParseTreeListener listener) { 661 if ( listener instanceof XMLParserListener ) ((XMLParserListener)listener).exitMisc(this); 662 } 663 @Override 664 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 665 if ( visitor instanceof XMLParserVisitor ) return ((XMLParserVisitor<? extends T>)visitor).visitMisc(this); 666 else return visitor.visitChildren(this); 667 } 668 } 669 670 public final MiscContext misc() throws RecognitionException { 671 MiscContext _localctx = new MiscContext(_ctx, getState()); 672 enterRule(_localctx, 14, RULE_misc); 673 int _la; 674 try { 675 enterOuterAlt(_localctx, 1); 676 { 677 setState(93); 678 _la = _input.LA(1); 679 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << COMMENT) | (1L << SEA_WS) | (1L << PI))) != 0)) ) { 680 _errHandler.recoverInline(this); 681 } else { 682 consume(); 683 } 684 } 685 } 686 catch (RecognitionException re) { 687 _localctx.exception = re; 688 _errHandler.reportError(this, re); 689 _errHandler.recover(this, re); 690 } 691 finally { 692 exitRule(); 693 } 694 return _localctx; 695 } 696 697 public static final String _serializedATN = 698 "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\24b\4\2\t\2\4\3\t"+ 699 "\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\3\2\5\2\24\n\2\3\2"+ 700 "\7\2\27\n\2\f\2\16\2\32\13\2\3\2\3\2\7\2\36\n\2\f\2\16\2!\13\2\3\3\3\3"+ 701 "\7\3%\n\3\f\3\16\3(\13\3\3\3\3\3\3\4\5\4-\n\4\3\4\3\4\3\4\3\4\3\4\5\4"+ 702 "\64\n\4\3\4\5\4\67\n\4\7\49\n\4\f\4\16\4<\13\4\3\5\3\5\3\5\7\5A\n\5\f"+ 703 "\5\16\5D\13\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\7\5P\n\5\f\5\16"+ 704 "\5S\13\5\3\5\5\5V\n\5\3\6\3\6\3\7\3\7\3\7\3\7\3\b\3\b\3\t\3\t\3\t\2\2"+ 705 "\n\2\4\6\b\n\f\16\20\2\5\3\2\6\7\4\2\b\b\13\13\5\2\3\3\b\b\24\24g\2\23"+ 706 "\3\2\2\2\4\"\3\2\2\2\6,\3\2\2\2\bU\3\2\2\2\nW\3\2\2\2\fY\3\2\2\2\16]\3"+ 707 "\2\2\2\20_\3\2\2\2\22\24\5\4\3\2\23\22\3\2\2\2\23\24\3\2\2\2\24\30\3\2"+ 708 "\2\2\25\27\5\20\t\2\26\25\3\2\2\2\27\32\3\2\2\2\30\26\3\2\2\2\30\31\3"+ 709 "\2\2\2\31\33\3\2\2\2\32\30\3\2\2\2\33\37\5\b\5\2\34\36\5\20\t\2\35\34"+ 710 "\3\2\2\2\36!\3\2\2\2\37\35\3\2\2\2\37 \3\2\2\2 \3\3\2\2\2!\37\3\2\2\2"+ 711 "\"&\7\n\2\2#%\5\f\7\2$#\3\2\2\2%(\3\2\2\2&$\3\2\2\2&\'\3\2\2\2\')\3\2"+ 712 "\2\2(&\3\2\2\2)*\7\r\2\2*\5\3\2\2\2+-\5\16\b\2,+\3\2\2\2,-\3\2\2\2-:\3"+ 713 "\2\2\2.\64\5\b\5\2/\64\5\n\6\2\60\64\7\4\2\2\61\64\7\24\2\2\62\64\7\3"+ 714 "\2\2\63.\3\2\2\2\63/\3\2\2\2\63\60\3\2\2\2\63\61\3\2\2\2\63\62\3\2\2\2"+ 715 "\64\66\3\2\2\2\65\67\5\16\b\2\66\65\3\2\2\2\66\67\3\2\2\2\679\3\2\2\2"+ 716 "8\63\3\2\2\29<\3\2\2\2:8\3\2\2\2:;\3\2\2\2;\7\3\2\2\2<:\3\2\2\2=>\7\t"+ 717 "\2\2>B\7\22\2\2?A\5\f\7\2@?\3\2\2\2AD\3\2\2\2B@\3\2\2\2BC\3\2\2\2CE\3"+ 718 "\2\2\2DB\3\2\2\2EF\7\f\2\2FG\5\6\4\2GH\7\t\2\2HI\7\17\2\2IJ\7\22\2\2J"+ 719 "K\7\f\2\2KV\3\2\2\2LM\7\t\2\2MQ\7\22\2\2NP\5\f\7\2ON\3\2\2\2PS\3\2\2\2"+ 720 "QO\3\2\2\2QR\3\2\2\2RT\3\2\2\2SQ\3\2\2\2TV\7\16\2\2U=\3\2\2\2UL\3\2\2"+ 721 "\2V\t\3\2\2\2WX\t\2\2\2X\13\3\2\2\2YZ\7\22\2\2Z[\7\20\2\2[\\\7\21\2\2"+ 722 "\\\r\3\2\2\2]^\t\3\2\2^\17\3\2\2\2_`\t\4\2\2`\21\3\2\2\2\r\23\30\37&,"+ 723 "\63\66:BQU"; 724 public static final ATN _ATN = 725 new ATNDeserializer().deserialize(_serializedATN.toCharArray()); 726 static { 727 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; 728 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { 729 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); 730 } 731 } 732 }
