14 #pragma warning disable 0162
16 #pragma warning disable 0219
18 #pragma warning disable 1591
20 #pragma warning disable 419
25 using System.Diagnostics;
26 using System.Collections.Generic;
28 using Antlr4.Runtime.Atn;
29 using Antlr4.Runtime.Misc;
30 using Antlr4.Runtime.Tree;
31 using DFA = Antlr4.Runtime.Dfa.DFA;
33 [System.CodeDom.Compiler.GeneratedCode(
"ANTLR",
"4.7")]
34 [System.CLSCompliant(
false)]
35 public partial class DLVHEXParser : Parser {
36 protected static DFA[] decisionToDFA;
37 protected static PredictionContextCache sharedContextCache =
new PredictionContextCache();
39 HEADER=1, WHITE_SPACE=2, COLON=3, COMMA=4, COST_BEGIN=5, COST_END=6, INTEGER=7,
40 LEVEL_BEGIN=8, LEVEL_END=9, GROUND_QUERY_BEGIN=10, ANSWER_SET_BEGIN=11,
41 ANSWER_SET_END=12, IDENTIFIER=13, STRING_CONSTANT=14, TERMS_BEGIN=15,
42 TERMS_END=16, REASONING=17, DOT=18, BOOLEAN=19, WHITESPACE_IN_GROUND_QUERY=20,
45 RULE_answer_set = 0, RULE_atoms = 1, RULE_cost = 2, RULE_level = 3, RULE_output = 4,
46 RULE_predicate_atom = 5, RULE_term = 6, RULE_witness = 7;
47 public static readonly
string[] ruleNames = {
48 "answer_set",
"atoms",
"cost",
"level",
"output",
"predicate_atom",
"term",
52 private static readonly
string[] _LiteralNames = {
53 null,
null,
null,
"':'",
"','",
"'<'",
"'>'",
null,
"'['",
"']'",
"' is '",
54 "'{'",
"'}'",
null,
null,
"'('",
"')'",
null,
"'.'",
null,
null,
"', evidenced by'"
56 private static readonly
string[] _SymbolicNames = {
57 null,
"HEADER",
"WHITE_SPACE",
"COLON",
"COMMA",
"COST_BEGIN",
"COST_END",
58 "INTEGER",
"LEVEL_BEGIN",
"LEVEL_END",
"GROUND_QUERY_BEGIN",
"ANSWER_SET_BEGIN",
59 "ANSWER_SET_END",
"IDENTIFIER",
"STRING_CONSTANT",
"TERMS_BEGIN",
"TERMS_END",
60 "REASONING",
"DOT",
"BOOLEAN",
"WHITESPACE_IN_GROUND_QUERY",
"WITNESS_LABEL"
62 public static readonly IVocabulary DefaultVocabulary =
new Vocabulary(_LiteralNames, _SymbolicNames);
65 public override IVocabulary Vocabulary
69 return DefaultVocabulary;
73 public override string GrammarFileName {
get {
return "DLVHEXParser.g4"; } }
75 public override string[] RuleNames {
get {
return ruleNames; } }
77 public override string SerializedAtn {
get {
return new string(_serializedATN); } }
79 static DLVHEXParser() {
80 decisionToDFA =
new DFA[_ATN.NumberOfDecisions];
81 for (
int i = 0; i < _ATN.NumberOfDecisions; i++) {
82 decisionToDFA[i] =
new DFA(_ATN.GetDecisionState(i), i);
86 public DLVHEXParser(ITokenStream input) : this(input, Console.Out, Console.Error) { }
88 public DLVHEXParser(ITokenStream input, TextWriter output, TextWriter errorOutput)
89 :
base(input, output, errorOutput)
91 Interpreter =
new ParserATNSimulator(
this, _ATN, decisionToDFA, sharedContextCache);
93 public partial class Answer_setContext : ParserRuleContext {
94 public Answer_setContext(ParserRuleContext parent,
int invokingState)
95 :
base(parent, invokingState)
98 public override int RuleIndex {
get {
return RULE_answer_set; } }
100 public Answer_setContext() { }
101 public virtual void CopyFrom(Answer_setContext context) {
102 base.CopyFrom(context);
105 public partial class GroundQueryContext : Answer_setContext {
106 public ITerminalNode[] IDENTIFIER() {
return GetTokens(DLVHEXParser.IDENTIFIER); }
107 public ITerminalNode IDENTIFIER(
int i) {
108 return GetToken(DLVHEXParser.IDENTIFIER, i);
110 public ITerminalNode GROUND_QUERY_BEGIN() {
return GetToken(DLVHEXParser.GROUND_QUERY_BEGIN, 0); }
111 public ITerminalNode REASONING() {
return GetToken(DLVHEXParser.REASONING, 0); }
112 public ITerminalNode BOOLEAN() {
return GetToken(DLVHEXParser.BOOLEAN, 0); }
113 public ITerminalNode DOT() {
return GetToken(DLVHEXParser.DOT, 0); }
114 public WitnessContext witness() {
115 return GetRuleContext<WitnessContext>(0);
117 public ITerminalNode[] COMMA() {
return GetTokens(DLVHEXParser.COMMA); }
118 public ITerminalNode COMMA(
int i) {
119 return GetToken(DLVHEXParser.COMMA, i);
121 public GroundQueryContext(Answer_setContext context) { CopyFrom(context); }
122 public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
125 else return visitor.VisitChildren(
this);
128 public partial class ModelContext : Answer_setContext {
129 public AtomsContext atoms() {
130 return GetRuleContext<AtomsContext>(0);
132 public ModelContext(Answer_setContext context) { CopyFrom(context); }
133 public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
135 if (typedVisitor !=
null)
return typedVisitor.
VisitModel(
this);
136 else return visitor.VisitChildren(
this);
141 public Answer_setContext answer_set() {
142 Answer_setContext _localctx =
new Answer_setContext(Context, State);
143 EnterRule(_localctx, 0, RULE_answer_set);
147 ErrorHandler.Sync(
this);
148 switch (TokenStream.LA(1)) {
150 _localctx =
new GroundQueryContext(_localctx);
151 EnterOuterAlt(_localctx, 1);
153 State = 16; Match(IDENTIFIER);
155 ErrorHandler.Sync(
this);
156 _la = TokenStream.LA(1);
160 State = 17; Match(COMMA);
161 State = 18; Match(IDENTIFIER);
165 ErrorHandler.Sync(
this);
166 _la = TokenStream.LA(1);
168 State = 24; Match(GROUND_QUERY_BEGIN);
169 State = 25; Match(REASONING);
170 State = 26; Match(BOOLEAN);
172 ErrorHandler.Sync(
this);
173 switch (TokenStream.LA(1)) {
176 State = 27; Match(DOT);
181 State = 28; witness();
185 throw new NoViableAltException(
this);
189 case ANSWER_SET_BEGIN:
190 _localctx =
new ModelContext(_localctx);
191 EnterOuterAlt(_localctx, 2);
197 throw new NoViableAltException(
this);
200 catch (RecognitionException re) {
201 _localctx.exception = re;
202 ErrorHandler.ReportError(
this, re);
203 ErrorHandler.Recover(
this, re);
211 public partial class AtomsContext : ParserRuleContext {
212 public ITerminalNode ANSWER_SET_BEGIN() {
return GetToken(DLVHEXParser.ANSWER_SET_BEGIN, 0); }
213 public ITerminalNode ANSWER_SET_END() {
return GetToken(DLVHEXParser.ANSWER_SET_END, 0); }
214 public Predicate_atomContext[] predicate_atom() {
215 return GetRuleContexts<Predicate_atomContext>();
217 public Predicate_atomContext predicate_atom(
int i) {
218 return GetRuleContext<Predicate_atomContext>(i);
220 public CostContext cost() {
221 return GetRuleContext<CostContext>(0);
223 public ITerminalNode[] COMMA() {
return GetTokens(DLVHEXParser.COMMA); }
224 public ITerminalNode COMMA(
int i) {
225 return GetToken(DLVHEXParser.COMMA, i);
227 public AtomsContext(ParserRuleContext parent,
int invokingState)
228 :
base(parent, invokingState)
231 public override int RuleIndex {
get {
return RULE_atoms; } }
232 public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
234 if (typedVisitor !=
null)
return typedVisitor.
VisitAtoms(
this);
235 else return visitor.VisitChildren(
this);
240 public AtomsContext atoms() {
241 AtomsContext _localctx =
new AtomsContext(Context, State);
242 EnterRule(_localctx, 2, RULE_atoms);
245 EnterOuterAlt(_localctx, 1);
247 State = 34; Match(ANSWER_SET_BEGIN);
249 ErrorHandler.Sync(
this);
250 _la = TokenStream.LA(1);
251 if (_la==IDENTIFIER) {
253 State = 35; predicate_atom();
255 ErrorHandler.Sync(
this);
256 _la = TokenStream.LA(1);
260 State = 36; Match(COMMA);
261 State = 37; predicate_atom();
265 ErrorHandler.Sync(
this);
266 _la = TokenStream.LA(1);
271 State = 45; Match(ANSWER_SET_END);
273 ErrorHandler.Sync(
this);
274 _la = TokenStream.LA(1);
275 if (_la==COST_BEGIN) {
283 catch (RecognitionException re) {
284 _localctx.exception = re;
285 ErrorHandler.ReportError(
this, re);
286 ErrorHandler.Recover(
this, re);
294 public partial class CostContext : ParserRuleContext {
295 public ITerminalNode COST_BEGIN() {
return GetToken(DLVHEXParser.COST_BEGIN, 0); }
296 public LevelContext[] level() {
297 return GetRuleContexts<LevelContext>();
299 public LevelContext level(
int i) {
300 return GetRuleContext<LevelContext>(i);
302 public ITerminalNode COST_END() {
return GetToken(DLVHEXParser.COST_END, 0); }
303 public ITerminalNode[] COMMA() {
return GetTokens(DLVHEXParser.COMMA); }
304 public ITerminalNode COMMA(
int i) {
305 return GetToken(DLVHEXParser.COMMA, i);
307 public CostContext(ParserRuleContext parent,
int invokingState)
308 :
base(parent, invokingState)
311 public override int RuleIndex {
get {
return RULE_cost; } }
312 public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
314 if (typedVisitor !=
null)
return typedVisitor.
VisitCost(
this);
315 else return visitor.VisitChildren(
this);
320 public CostContext cost() {
321 CostContext _localctx =
new CostContext(Context, State);
322 EnterRule(_localctx, 4, RULE_cost);
325 EnterOuterAlt(_localctx, 1);
327 State = 49; Match(COST_BEGIN);
330 ErrorHandler.Sync(
this);
331 _la = TokenStream.LA(1);
335 State = 51; Match(COMMA);
340 ErrorHandler.Sync(
this);
341 _la = TokenStream.LA(1);
343 State = 58; Match(COST_END);
346 catch (RecognitionException re) {
347 _localctx.exception = re;
348 ErrorHandler.ReportError(
this, re);
349 ErrorHandler.Recover(
this, re);
357 public partial class LevelContext : ParserRuleContext {
358 public ITerminalNode LEVEL_BEGIN() {
return GetToken(DLVHEXParser.LEVEL_BEGIN, 0); }
359 public ITerminalNode[] INTEGER() {
return GetTokens(DLVHEXParser.INTEGER); }
360 public ITerminalNode INTEGER(
int i) {
361 return GetToken(DLVHEXParser.INTEGER, i);
363 public ITerminalNode COLON() {
return GetToken(DLVHEXParser.COLON, 0); }
364 public ITerminalNode LEVEL_END() {
return GetToken(DLVHEXParser.LEVEL_END, 0); }
365 public LevelContext(ParserRuleContext parent,
int invokingState)
366 :
base(parent, invokingState)
369 public override int RuleIndex {
get {
return RULE_level; } }
370 public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
372 if (typedVisitor !=
null)
return typedVisitor.
VisitLevel(
this);
373 else return visitor.VisitChildren(
this);
378 public LevelContext level() {
379 LevelContext _localctx =
new LevelContext(Context, State);
380 EnterRule(_localctx, 6, RULE_level);
382 EnterOuterAlt(_localctx, 1);
384 State = 60; Match(LEVEL_BEGIN);
385 State = 61; Match(INTEGER);
386 State = 62; Match(COLON);
387 State = 63; Match(INTEGER);
388 State = 64; Match(LEVEL_END);
391 catch (RecognitionException re) {
392 _localctx.exception = re;
393 ErrorHandler.ReportError(
this, re);
394 ErrorHandler.Recover(
this, re);
402 public partial class OutputContext : ParserRuleContext {
403 public Answer_setContext[] answer_set() {
404 return GetRuleContexts<Answer_setContext>();
406 public Answer_setContext answer_set(
int i) {
407 return GetRuleContext<Answer_setContext>(i);
409 public OutputContext(ParserRuleContext parent,
int invokingState)
410 :
base(parent, invokingState)
413 public override int RuleIndex {
get {
return RULE_output; } }
414 public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
416 if (typedVisitor !=
null)
return typedVisitor.
VisitOutput(
this);
417 else return visitor.VisitChildren(
this);
422 public OutputContext output() {
423 OutputContext _localctx =
new OutputContext(Context, State);
424 EnterRule(_localctx, 8, RULE_output);
427 EnterOuterAlt(_localctx, 1);
430 ErrorHandler.Sync(
this);
431 _la = TokenStream.LA(1);
432 while (_la==ANSWER_SET_BEGIN || _la==IDENTIFIER) {
435 State = 66; answer_set();
439 ErrorHandler.Sync(
this);
440 _la = TokenStream.LA(1);
444 catch (RecognitionException re) {
445 _localctx.exception = re;
446 ErrorHandler.ReportError(
this, re);
447 ErrorHandler.Recover(
this, re);
455 public partial class Predicate_atomContext : ParserRuleContext {
456 public ITerminalNode IDENTIFIER() {
return GetToken(DLVHEXParser.IDENTIFIER, 0); }
457 public ITerminalNode TERMS_BEGIN() {
return GetToken(DLVHEXParser.TERMS_BEGIN, 0); }
458 public TermContext[] term() {
459 return GetRuleContexts<TermContext>();
461 public TermContext term(
int i) {
462 return GetRuleContext<TermContext>(i);
464 public ITerminalNode TERMS_END() {
return GetToken(DLVHEXParser.TERMS_END, 0); }
465 public ITerminalNode[] COMMA() {
return GetTokens(DLVHEXParser.COMMA); }
466 public ITerminalNode COMMA(
int i) {
467 return GetToken(DLVHEXParser.COMMA, i);
469 public Predicate_atomContext(ParserRuleContext parent,
int invokingState)
470 :
base(parent, invokingState)
473 public override int RuleIndex {
get {
return RULE_predicate_atom; } }
474 public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
477 else return visitor.VisitChildren(
this);
482 public Predicate_atomContext predicate_atom() {
483 Predicate_atomContext _localctx =
new Predicate_atomContext(Context, State);
484 EnterRule(_localctx, 10, RULE_predicate_atom);
487 EnterOuterAlt(_localctx, 1);
489 State = 72; Match(IDENTIFIER);
491 ErrorHandler.Sync(
this);
492 _la = TokenStream.LA(1);
493 if (_la==TERMS_BEGIN) {
495 State = 73; Match(TERMS_BEGIN);
498 ErrorHandler.Sync(
this);
499 _la = TokenStream.LA(1);
503 State = 75; Match(COMMA);
508 ErrorHandler.Sync(
this);
509 _la = TokenStream.LA(1);
511 State = 82; Match(TERMS_END);
517 catch (RecognitionException re) {
518 _localctx.exception = re;
519 ErrorHandler.ReportError(
this, re);
520 ErrorHandler.Recover(
this, re);
528 public partial class TermContext : ParserRuleContext {
529 public ITerminalNode IDENTIFIER() {
return GetToken(DLVHEXParser.IDENTIFIER, 0); }
530 public ITerminalNode INTEGER() {
return GetToken(DLVHEXParser.INTEGER, 0); }
531 public Predicate_atomContext predicate_atom() {
532 return GetRuleContext<Predicate_atomContext>(0);
534 public ITerminalNode STRING_CONSTANT() {
return GetToken(DLVHEXParser.STRING_CONSTANT, 0); }
535 public TermContext(ParserRuleContext parent,
int invokingState)
536 :
base(parent, invokingState)
539 public override int RuleIndex {
get {
return RULE_term; } }
540 public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
542 if (typedVisitor !=
null)
return typedVisitor.
VisitTerm(
this);
543 else return visitor.VisitChildren(
this);
548 public TermContext term() {
549 TermContext _localctx =
new TermContext(Context, State);
550 EnterRule(_localctx, 12, RULE_term);
553 ErrorHandler.Sync(
this);
554 switch ( Interpreter.AdaptivePredict(TokenStream,10,Context) ) {
556 EnterOuterAlt(_localctx, 1);
558 State = 86; Match(IDENTIFIER);
562 EnterOuterAlt(_localctx, 2);
564 State = 87; Match(INTEGER);
568 EnterOuterAlt(_localctx, 3);
570 State = 88; predicate_atom();
574 EnterOuterAlt(_localctx, 4);
576 State = 89; Match(STRING_CONSTANT);
581 catch (RecognitionException re) {
582 _localctx.exception = re;
583 ErrorHandler.ReportError(
this, re);
584 ErrorHandler.Recover(
this, re);
592 public partial class WitnessContext : ParserRuleContext {
593 public ITerminalNode WITNESS_LABEL() {
return GetToken(DLVHEXParser.WITNESS_LABEL, 0); }
594 public AtomsContext atoms() {
595 return GetRuleContext<AtomsContext>(0);
597 public WitnessContext(ParserRuleContext parent,
int invokingState)
598 :
base(parent, invokingState)
601 public override int RuleIndex {
get {
return RULE_witness; } }
602 public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
604 if (typedVisitor !=
null)
return typedVisitor.
VisitWitness(
this);
605 else return visitor.VisitChildren(
this);
610 public WitnessContext witness() {
611 WitnessContext _localctx =
new WitnessContext(Context, State);
612 EnterRule(_localctx, 14, RULE_witness);
614 EnterOuterAlt(_localctx, 1);
616 State = 92; Match(WITNESS_LABEL);
620 catch (RecognitionException re) {
621 _localctx.exception = re;
622 ErrorHandler.ReportError(
this, re);
623 ErrorHandler.Recover(
this, re);
631 private static char[] _serializedATN = {
632 '\x3',
'\x608B',
'\xA72A',
'\x8133',
'\xB9ED',
'\x417C',
'\x3BE7',
'\x7786',
633 '\x5964',
'\x3',
'\x17',
'\x62',
'\x4',
'\x2',
'\t',
'\x2',
'\x4',
'\x3',
634 '\t',
'\x3',
'\x4',
'\x4',
'\t',
'\x4',
'\x4',
'\x5',
'\t',
'\x5',
'\x4',
635 '\x6',
'\t',
'\x6',
'\x4',
'\a',
'\t',
'\a',
'\x4',
'\b',
'\t',
'\b',
636 '\x4',
'\t',
'\t',
'\t',
'\x3',
'\x2',
'\x3',
'\x2',
'\x3',
'\x2',
'\a',
637 '\x2',
'\x16',
'\n',
'\x2',
'\f',
'\x2',
'\xE',
'\x2',
'\x19',
'\v',
'\x2',
638 '\x3',
'\x2',
'\x3',
'\x2',
'\x3',
'\x2',
'\x3',
'\x2',
'\x3',
'\x2',
639 '\x5',
'\x2',
' ',
'\n',
'\x2',
'\x3',
'\x2',
'\x5',
'\x2',
'#',
'\n',
640 '\x2',
'\x3',
'\x3',
'\x3',
'\x3',
'\x3',
'\x3',
'\x3',
'\x3',
'\a',
'\x3',
641 ')',
'\n',
'\x3',
'\f',
'\x3',
'\xE',
'\x3',
',',
'\v',
'\x3',
'\x5',
642 '\x3',
'.',
'\n',
'\x3',
'\x3',
'\x3',
'\x3',
'\x3',
'\x5',
'\x3',
'\x32',
643 '\n',
'\x3',
'\x3',
'\x4',
'\x3',
'\x4',
'\x3',
'\x4',
'\x3',
'\x4',
'\a',
644 '\x4',
'\x38',
'\n',
'\x4',
'\f',
'\x4',
'\xE',
'\x4',
';',
'\v',
'\x4',
645 '\x3',
'\x4',
'\x3',
'\x4',
'\x3',
'\x5',
'\x3',
'\x5',
'\x3',
'\x5',
646 '\x3',
'\x5',
'\x3',
'\x5',
'\x3',
'\x5',
'\x3',
'\x6',
'\a',
'\x6',
'\x46',
647 '\n',
'\x6',
'\f',
'\x6',
'\xE',
'\x6',
'I',
'\v',
'\x6',
'\x3',
'\a',
648 '\x3',
'\a',
'\x3',
'\a',
'\x3',
'\a',
'\x3',
'\a',
'\a',
'\a',
'P',
'\n',
649 '\a',
'\f',
'\a',
'\xE',
'\a',
'S',
'\v',
'\a',
'\x3',
'\a',
'\x3',
'\a',
650 '\x5',
'\a',
'W',
'\n',
'\a',
'\x3',
'\b',
'\x3',
'\b',
'\x3',
'\b',
'\x3',
651 '\b',
'\x5',
'\b',
']',
'\n',
'\b',
'\x3',
'\t',
'\x3',
'\t',
'\x3',
'\t',
652 '\x3',
'\t',
'\x2',
'\x2',
'\n',
'\x2',
'\x4',
'\x6',
'\b',
'\n',
'\f',
653 '\xE',
'\x10',
'\x2',
'\x2',
'\x2',
'\x66',
'\x2',
'\"',
'\x3',
'\x2',
654 '\x2',
'\x2',
'\x4',
'$',
'\x3',
'\x2',
'\x2',
'\x2',
'\x6',
'\x33',
'\x3',
655 '\x2',
'\x2',
'\x2',
'\b',
'>',
'\x3',
'\x2',
'\x2',
'\x2',
'\n',
'G',
656 '\x3',
'\x2',
'\x2',
'\x2',
'\f',
'J',
'\x3',
'\x2',
'\x2',
'\x2',
'\xE',
657 '\\',
'\x3',
'\x2',
'\x2',
'\x2',
'\x10',
'^',
'\x3',
'\x2',
'\x2',
'\x2',
658 '\x12',
'\x17',
'\a',
'\xF',
'\x2',
'\x2',
'\x13',
'\x14',
'\a',
'\x6',
659 '\x2',
'\x2',
'\x14',
'\x16',
'\a',
'\xF',
'\x2',
'\x2',
'\x15',
'\x13',
660 '\x3',
'\x2',
'\x2',
'\x2',
'\x16',
'\x19',
'\x3',
'\x2',
'\x2',
'\x2',
661 '\x17',
'\x15',
'\x3',
'\x2',
'\x2',
'\x2',
'\x17',
'\x18',
'\x3',
'\x2',
662 '\x2',
'\x2',
'\x18',
'\x1A',
'\x3',
'\x2',
'\x2',
'\x2',
'\x19',
'\x17',
663 '\x3',
'\x2',
'\x2',
'\x2',
'\x1A',
'\x1B',
'\a',
'\f',
'\x2',
'\x2',
664 '\x1B',
'\x1C',
'\a',
'\x13',
'\x2',
'\x2',
'\x1C',
'\x1F',
'\a',
'\x15',
665 '\x2',
'\x2',
'\x1D',
' ',
'\a',
'\x14',
'\x2',
'\x2',
'\x1E',
' ',
'\x5',
666 '\x10',
'\t',
'\x2',
'\x1F',
'\x1D',
'\x3',
'\x2',
'\x2',
'\x2',
'\x1F',
667 '\x1E',
'\x3',
'\x2',
'\x2',
'\x2',
' ',
'#',
'\x3',
'\x2',
'\x2',
'\x2',
668 '!',
'#',
'\x5',
'\x4',
'\x3',
'\x2',
'\"',
'\x12',
'\x3',
'\x2',
'\x2',
669 '\x2',
'\"',
'!',
'\x3',
'\x2',
'\x2',
'\x2',
'#',
'\x3',
'\x3',
'\x2',
670 '\x2',
'\x2',
'$',
'-',
'\a',
'\r',
'\x2',
'\x2',
'%',
'*',
'\x5',
'\f',
671 '\a',
'\x2',
'&',
'\'',
'\a',
'\x6',
'\x2',
'\x2',
'\'',
')',
'\x5',
'\f',
672 '\a',
'\x2',
'(',
'&',
'\x3',
'\x2',
'\x2',
'\x2',
')',
',',
'\x3',
'\x2',
673 '\x2',
'\x2',
'*',
'(',
'\x3',
'\x2',
'\x2',
'\x2',
'*',
'+',
'\x3',
'\x2',
674 '\x2',
'\x2',
'+',
'.',
'\x3',
'\x2',
'\x2',
'\x2',
',',
'*',
'\x3',
'\x2',
675 '\x2',
'\x2',
'-',
'%',
'\x3',
'\x2',
'\x2',
'\x2',
'-',
'.',
'\x3',
'\x2',
676 '\x2',
'\x2',
'.',
'/',
'\x3',
'\x2',
'\x2',
'\x2',
'/',
'\x31',
'\a',
677 '\xE',
'\x2',
'\x2',
'\x30',
'\x32',
'\x5',
'\x6',
'\x4',
'\x2',
'\x31',
678 '\x30',
'\x3',
'\x2',
'\x2',
'\x2',
'\x31',
'\x32',
'\x3',
'\x2',
'\x2',
679 '\x2',
'\x32',
'\x5',
'\x3',
'\x2',
'\x2',
'\x2',
'\x33',
'\x34',
'\a',
680 '\a',
'\x2',
'\x2',
'\x34',
'\x39',
'\x5',
'\b',
'\x5',
'\x2',
'\x35',
681 '\x36',
'\a',
'\x6',
'\x2',
'\x2',
'\x36',
'\x38',
'\x5',
'\b',
'\x5',
682 '\x2',
'\x37',
'\x35',
'\x3',
'\x2',
'\x2',
'\x2',
'\x38',
';',
'\x3',
683 '\x2',
'\x2',
'\x2',
'\x39',
'\x37',
'\x3',
'\x2',
'\x2',
'\x2',
'\x39',
684 ':',
'\x3',
'\x2',
'\x2',
'\x2',
':',
'<',
'\x3',
'\x2',
'\x2',
'\x2',
685 ';',
'\x39',
'\x3',
'\x2',
'\x2',
'\x2',
'<',
'=',
'\a',
'\b',
'\x2',
686 '\x2',
'=',
'\a',
'\x3',
'\x2',
'\x2',
'\x2',
'>',
'?',
'\a',
'\n',
'\x2',
687 '\x2',
'?',
'@',
'\a',
'\t',
'\x2',
'\x2',
'@',
'\x41',
'\a',
'\x5',
'\x2',
688 '\x2',
'\x41',
'\x42',
'\a',
'\t',
'\x2',
'\x2',
'\x42',
'\x43',
'\a',
689 '\v',
'\x2',
'\x2',
'\x43',
'\t',
'\x3',
'\x2',
'\x2',
'\x2',
'\x44',
690 '\x46',
'\x5',
'\x2',
'\x2',
'\x2',
'\x45',
'\x44',
'\x3',
'\x2',
'\x2',
691 '\x2',
'\x46',
'I',
'\x3',
'\x2',
'\x2',
'\x2',
'G',
'\x45',
'\x3',
'\x2',
692 '\x2',
'\x2',
'G',
'H',
'\x3',
'\x2',
'\x2',
'\x2',
'H',
'\v',
'\x3',
693 '\x2',
'\x2',
'\x2',
'I',
'G',
'\x3',
'\x2',
'\x2',
'\x2',
'J',
'V',
'\a',
694 '\xF',
'\x2',
'\x2',
'K',
'L',
'\a',
'\x11',
'\x2',
'\x2',
'L',
'Q',
'\x5',
695 '\xE',
'\b',
'\x2',
'M',
'N',
'\a',
'\x6',
'\x2',
'\x2',
'N',
'P',
'\x5',
696 '\xE',
'\b',
'\x2',
'O',
'M',
'\x3',
'\x2',
'\x2',
'\x2',
'P',
'S',
'\x3',
697 '\x2',
'\x2',
'\x2',
'Q',
'O',
'\x3',
'\x2',
'\x2',
'\x2',
'Q',
'R',
'\x3',
698 '\x2',
'\x2',
'\x2',
'R',
'T',
'\x3',
'\x2',
'\x2',
'\x2',
'S',
'Q',
'\x3',
699 '\x2',
'\x2',
'\x2',
'T',
'U',
'\a',
'\x12',
'\x2',
'\x2',
'U',
'W',
'\x3',
700 '\x2',
'\x2',
'\x2',
'V',
'K',
'\x3',
'\x2',
'\x2',
'\x2',
'V',
'W',
'\x3',
701 '\x2',
'\x2',
'\x2',
'W',
'\r',
'\x3',
'\x2',
'\x2',
'\x2',
'X',
']',
702 '\a',
'\xF',
'\x2',
'\x2',
'Y',
']',
'\a',
'\t',
'\x2',
'\x2',
'Z',
']',
703 '\x5',
'\f',
'\a',
'\x2',
'[',
']',
'\a',
'\x10',
'\x2',
'\x2',
'\\',
704 'X',
'\x3',
'\x2',
'\x2',
'\x2',
'\\',
'Y',
'\x3',
'\x2',
'\x2',
'\x2',
705 '\\',
'Z',
'\x3',
'\x2',
'\x2',
'\x2',
'\\',
'[',
'\x3',
'\x2',
'\x2',
706 '\x2',
']',
'\xF',
'\x3',
'\x2',
'\x2',
'\x2',
'^',
'_',
'\a',
'\x17',
707 '\x2',
'\x2',
'_',
'`',
'\x5',
'\x4',
'\x3',
'\x2',
'`',
'\x11',
'\x3',
708 '\x2',
'\x2',
'\x2',
'\r',
'\x17',
'\x1F',
'\"',
'*',
'-',
'\x31',
'\x39',
712 public static readonly ATN _ATN =
713 new ATNDeserializer().Deserialize(_serializedATN);