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