aboutsummaryrefslogtreecommitdiffstats
path: root/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ide/src-gen/ca/mcgill/ecse/dslreasoner/ide/contentassist/antlr/internal/InternalVampireLanguageParser.java
diff options
context:
space:
mode:
Diffstat (limited to 'Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ide/src-gen/ca/mcgill/ecse/dslreasoner/ide/contentassist/antlr/internal/InternalVampireLanguageParser.java')
-rw-r--r--Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ide/src-gen/ca/mcgill/ecse/dslreasoner/ide/contentassist/antlr/internal/InternalVampireLanguageParser.java17577
1 files changed, 17577 insertions, 0 deletions
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ide/src-gen/ca/mcgill/ecse/dslreasoner/ide/contentassist/antlr/internal/InternalVampireLanguageParser.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ide/src-gen/ca/mcgill/ecse/dslreasoner/ide/contentassist/antlr/internal/InternalVampireLanguageParser.java
new file mode 100644
index 00000000..8d39bf4b
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ide/src-gen/ca/mcgill/ecse/dslreasoner/ide/contentassist/antlr/internal/InternalVampireLanguageParser.java
@@ -0,0 +1,17577 @@
1package ca.mcgill.ecse.dslreasoner.ide.contentassist.antlr.internal;
2
3import java.io.InputStream;
4import org.eclipse.xtext.*;
5import org.eclipse.xtext.parser.*;
6import org.eclipse.xtext.parser.impl.*;
7import org.eclipse.emf.ecore.util.EcoreUtil;
8import org.eclipse.emf.ecore.EObject;
9import org.eclipse.xtext.parser.antlr.XtextTokenStream;
10import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
11import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
12import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA;
13import ca.mcgill.ecse.dslreasoner.services.VampireLanguageGrammarAccess;
14
15
16
17import org.antlr.runtime.*;
18import java.util.Stack;
19import java.util.List;
20import java.util.ArrayList;
21
22@SuppressWarnings("all")
23public class InternalVampireLanguageParser extends AbstractInternalContentAssistParser {
24 public static final String[] tokenNames = new String[] {
25 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_LOWER_WORD_ID", "RULE_SINGLE_QUOTE", "RULE_LITERAL", "RULE_SIGNED_LITERAL", "RULE_DOLLAR_ID", "RULE_DOUBLE_DOLLAR_ID", "RULE_SINGLE_COMMENT", "RULE_UPPER_WORD_ID", "RULE_SIGNED_REAL_ID", "RULE_SIGNED_RAT_ID", "RULE_DOUBLE_QUOTE", "RULE_ALPHA_NUMERIC", "RULE_SIGN", "RULE_INT", "RULE_UNSIGNED_REAL_FRAC_ID", "RULE_UNSIGNED_REAL_EXP_ID", "RULE_UNSIGNED_RAT_ID", "RULE_ANY_OTHER", "RULE_ID", "RULE_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "'axiom'", "'conjecture'", "'hypothesis'", "'definition'", "'assumption'", "'lemma'", "'theorem'", "'corollary'", "'negated_conjecture'", "'plain'", "'type'", "'fi_domain'", "'fi_functors'", "'fi_predicates'", "'unknown'", "'include('", "',['", "']'", "','", "'fof'", "'('", "')'", "'.'", "'['", "'<=>'", "'=>'", "'<='", "'<~>'", "'~|'", "'~&'", "'&'", "'|'", "'!'", "':'", "'?'", "'~'", "'!='", "'='", "':='", "'$true'", "'$false'", "'$less'"
26 };
27 public static final int RULE_UNSIGNED_RAT_ID=20;
28 public static final int T__50=50;
29 public static final int RULE_SIGN=16;
30 public static final int T__59=59;
31 public static final int RULE_SIGNED_LITERAL=7;
32 public static final int T__55=55;
33 public static final int T__56=56;
34 public static final int T__57=57;
35 public static final int T__58=58;
36 public static final int T__51=51;
37 public static final int RULE_DOUBLE_QUOTE=14;
38 public static final int T__52=52;
39 public static final int RULE_LITERAL=6;
40 public static final int T__53=53;
41 public static final int RULE_UNSIGNED_REAL_FRAC_ID=18;
42 public static final int T__54=54;
43 public static final int T__60=60;
44 public static final int T__61=61;
45 public static final int RULE_ID=22;
46 public static final int RULE_SINGLE_QUOTE=5;
47 public static final int RULE_SINGLE_COMMENT=10;
48 public static final int T__27=27;
49 public static final int T__28=28;
50 public static final int RULE_INT=17;
51 public static final int T__29=29;
52 public static final int T__66=66;
53 public static final int RULE_ML_COMMENT=24;
54 public static final int T__67=67;
55 public static final int RULE_SIGNED_RAT_ID=13;
56 public static final int T__68=68;
57 public static final int T__62=62;
58 public static final int T__63=63;
59 public static final int T__64=64;
60 public static final int T__65=65;
61 public static final int RULE_LOWER_WORD_ID=4;
62 public static final int RULE_STRING=23;
63 public static final int RULE_SL_COMMENT=25;
64 public static final int T__37=37;
65 public static final int T__38=38;
66 public static final int T__39=39;
67 public static final int T__33=33;
68 public static final int T__34=34;
69 public static final int T__35=35;
70 public static final int T__36=36;
71 public static final int EOF=-1;
72 public static final int T__30=30;
73 public static final int RULE_UNSIGNED_REAL_EXP_ID=19;
74 public static final int T__31=31;
75 public static final int T__32=32;
76 public static final int RULE_UPPER_WORD_ID=11;
77 public static final int RULE_WS=26;
78 public static final int RULE_DOLLAR_ID=8;
79 public static final int RULE_ALPHA_NUMERIC=15;
80 public static final int RULE_ANY_OTHER=21;
81 public static final int RULE_DOUBLE_DOLLAR_ID=9;
82 public static final int T__48=48;
83 public static final int T__49=49;
84 public static final int T__44=44;
85 public static final int T__45=45;
86 public static final int RULE_SIGNED_REAL_ID=12;
87 public static final int T__46=46;
88 public static final int T__47=47;
89 public static final int T__40=40;
90 public static final int T__41=41;
91 public static final int T__42=42;
92 public static final int T__43=43;
93
94 // delegates
95 // delegators
96
97
98 public InternalVampireLanguageParser(TokenStream input) {
99 this(input, new RecognizerSharedState());
100 }
101 public InternalVampireLanguageParser(TokenStream input, RecognizerSharedState state) {
102 super(input, state);
103
104 }
105
106
107 public String[] getTokenNames() { return InternalVampireLanguageParser.tokenNames; }
108 public String getGrammarFileName() { return "InternalVampireLanguage.g"; }
109
110
111 private VampireLanguageGrammarAccess grammarAccess;
112
113 public void setGrammarAccess(VampireLanguageGrammarAccess grammarAccess) {
114 this.grammarAccess = grammarAccess;
115 }
116
117 @Override
118 protected Grammar getGrammar() {
119 return grammarAccess.getGrammar();
120 }
121
122 @Override
123 protected String getValueForTokenName(String tokenName) {
124 return tokenName;
125 }
126
127
128
129 // $ANTLR start "entryRuleVampireModel"
130 // InternalVampireLanguage.g:53:1: entryRuleVampireModel : ruleVampireModel EOF ;
131 public final void entryRuleVampireModel() throws RecognitionException {
132 try {
133 // InternalVampireLanguage.g:54:1: ( ruleVampireModel EOF )
134 // InternalVampireLanguage.g:55:1: ruleVampireModel EOF
135 {
136 before(grammarAccess.getVampireModelRule());
137 pushFollow(FOLLOW_1);
138 ruleVampireModel();
139
140 state._fsp--;
141
142 after(grammarAccess.getVampireModelRule());
143 match(input,EOF,FOLLOW_2);
144
145 }
146
147 }
148 catch (RecognitionException re) {
149 reportError(re);
150 recover(input,re);
151 }
152 finally {
153 }
154 return ;
155 }
156 // $ANTLR end "entryRuleVampireModel"
157
158
159 // $ANTLR start "ruleVampireModel"
160 // InternalVampireLanguage.g:62:1: ruleVampireModel : ( ( rule__VampireModel__Alternatives )* ) ;
161 public final void ruleVampireModel() throws RecognitionException {
162
163 int stackSize = keepStackSize();
164
165 try {
166 // InternalVampireLanguage.g:66:2: ( ( ( rule__VampireModel__Alternatives )* ) )
167 // InternalVampireLanguage.g:67:2: ( ( rule__VampireModel__Alternatives )* )
168 {
169 // InternalVampireLanguage.g:67:2: ( ( rule__VampireModel__Alternatives )* )
170 // InternalVampireLanguage.g:68:3: ( rule__VampireModel__Alternatives )*
171 {
172 before(grammarAccess.getVampireModelAccess().getAlternatives());
173 // InternalVampireLanguage.g:69:3: ( rule__VampireModel__Alternatives )*
174 loop1:
175 do {
176 int alt1=2;
177 int LA1_0 = input.LA(1);
178
179 if ( (LA1_0==RULE_SINGLE_COMMENT||LA1_0==42||LA1_0==46) ) {
180 alt1=1;
181 }
182
183
184 switch (alt1) {
185 case 1 :
186 // InternalVampireLanguage.g:69:4: rule__VampireModel__Alternatives
187 {
188 pushFollow(FOLLOW_3);
189 rule__VampireModel__Alternatives();
190
191 state._fsp--;
192
193
194 }
195 break;
196
197 default :
198 break loop1;
199 }
200 } while (true);
201
202 after(grammarAccess.getVampireModelAccess().getAlternatives());
203
204 }
205
206
207 }
208
209 }
210 catch (RecognitionException re) {
211 reportError(re);
212 recover(input,re);
213 }
214 finally {
215
216 restoreStackSize(stackSize);
217
218 }
219 return ;
220 }
221 // $ANTLR end "ruleVampireModel"
222
223
224 // $ANTLR start "entryRuleVLSInclude"
225 // InternalVampireLanguage.g:78:1: entryRuleVLSInclude : ruleVLSInclude EOF ;
226 public final void entryRuleVLSInclude() throws RecognitionException {
227 try {
228 // InternalVampireLanguage.g:79:1: ( ruleVLSInclude EOF )
229 // InternalVampireLanguage.g:80:1: ruleVLSInclude EOF
230 {
231 before(grammarAccess.getVLSIncludeRule());
232 pushFollow(FOLLOW_1);
233 ruleVLSInclude();
234
235 state._fsp--;
236
237 after(grammarAccess.getVLSIncludeRule());
238 match(input,EOF,FOLLOW_2);
239
240 }
241
242 }
243 catch (RecognitionException re) {
244 reportError(re);
245 recover(input,re);
246 }
247 finally {
248 }
249 return ;
250 }
251 // $ANTLR end "entryRuleVLSInclude"
252
253
254 // $ANTLR start "ruleVLSInclude"
255 // InternalVampireLanguage.g:87:1: ruleVLSInclude : ( ( rule__VLSInclude__Group__0 ) ) ;
256 public final void ruleVLSInclude() throws RecognitionException {
257
258 int stackSize = keepStackSize();
259
260 try {
261 // InternalVampireLanguage.g:91:2: ( ( ( rule__VLSInclude__Group__0 ) ) )
262 // InternalVampireLanguage.g:92:2: ( ( rule__VLSInclude__Group__0 ) )
263 {
264 // InternalVampireLanguage.g:92:2: ( ( rule__VLSInclude__Group__0 ) )
265 // InternalVampireLanguage.g:93:3: ( rule__VLSInclude__Group__0 )
266 {
267 before(grammarAccess.getVLSIncludeAccess().getGroup());
268 // InternalVampireLanguage.g:94:3: ( rule__VLSInclude__Group__0 )
269 // InternalVampireLanguage.g:94:4: rule__VLSInclude__Group__0
270 {
271 pushFollow(FOLLOW_2);
272 rule__VLSInclude__Group__0();
273
274 state._fsp--;
275
276
277 }
278
279 after(grammarAccess.getVLSIncludeAccess().getGroup());
280
281 }
282
283
284 }
285
286 }
287 catch (RecognitionException re) {
288 reportError(re);
289 recover(input,re);
290 }
291 finally {
292
293 restoreStackSize(stackSize);
294
295 }
296 return ;
297 }
298 // $ANTLR end "ruleVLSInclude"
299
300
301 // $ANTLR start "entryRuleVLSName"
302 // InternalVampireLanguage.g:103:1: entryRuleVLSName : ruleVLSName EOF ;
303 public final void entryRuleVLSName() throws RecognitionException {
304 try {
305 // InternalVampireLanguage.g:104:1: ( ruleVLSName EOF )
306 // InternalVampireLanguage.g:105:1: ruleVLSName EOF
307 {
308 before(grammarAccess.getVLSNameRule());
309 pushFollow(FOLLOW_1);
310 ruleVLSName();
311
312 state._fsp--;
313
314 after(grammarAccess.getVLSNameRule());
315 match(input,EOF,FOLLOW_2);
316
317 }
318
319 }
320 catch (RecognitionException re) {
321 reportError(re);
322 recover(input,re);
323 }
324 finally {
325 }
326 return ;
327 }
328 // $ANTLR end "entryRuleVLSName"
329
330
331 // $ANTLR start "ruleVLSName"
332 // InternalVampireLanguage.g:112:1: ruleVLSName : ( ( rule__VLSName__NameAssignment ) ) ;
333 public final void ruleVLSName() throws RecognitionException {
334
335 int stackSize = keepStackSize();
336
337 try {
338 // InternalVampireLanguage.g:116:2: ( ( ( rule__VLSName__NameAssignment ) ) )
339 // InternalVampireLanguage.g:117:2: ( ( rule__VLSName__NameAssignment ) )
340 {
341 // InternalVampireLanguage.g:117:2: ( ( rule__VLSName__NameAssignment ) )
342 // InternalVampireLanguage.g:118:3: ( rule__VLSName__NameAssignment )
343 {
344 before(grammarAccess.getVLSNameAccess().getNameAssignment());
345 // InternalVampireLanguage.g:119:3: ( rule__VLSName__NameAssignment )
346 // InternalVampireLanguage.g:119:4: rule__VLSName__NameAssignment
347 {
348 pushFollow(FOLLOW_2);
349 rule__VLSName__NameAssignment();
350
351 state._fsp--;
352
353
354 }
355
356 after(grammarAccess.getVLSNameAccess().getNameAssignment());
357
358 }
359
360
361 }
362
363 }
364 catch (RecognitionException re) {
365 reportError(re);
366 recover(input,re);
367 }
368 finally {
369
370 restoreStackSize(stackSize);
371
372 }
373 return ;
374 }
375 // $ANTLR end "ruleVLSName"
376
377
378 // $ANTLR start "entryRuleVLSComment"
379 // InternalVampireLanguage.g:128:1: entryRuleVLSComment : ruleVLSComment EOF ;
380 public final void entryRuleVLSComment() throws RecognitionException {
381 try {
382 // InternalVampireLanguage.g:129:1: ( ruleVLSComment EOF )
383 // InternalVampireLanguage.g:130:1: ruleVLSComment EOF
384 {
385 before(grammarAccess.getVLSCommentRule());
386 pushFollow(FOLLOW_1);
387 ruleVLSComment();
388
389 state._fsp--;
390
391 after(grammarAccess.getVLSCommentRule());
392 match(input,EOF,FOLLOW_2);
393
394 }
395
396 }
397 catch (RecognitionException re) {
398 reportError(re);
399 recover(input,re);
400 }
401 finally {
402 }
403 return ;
404 }
405 // $ANTLR end "entryRuleVLSComment"
406
407
408 // $ANTLR start "ruleVLSComment"
409 // InternalVampireLanguage.g:137:1: ruleVLSComment : ( ( rule__VLSComment__CommentAssignment ) ) ;
410 public final void ruleVLSComment() throws RecognitionException {
411
412 int stackSize = keepStackSize();
413
414 try {
415 // InternalVampireLanguage.g:141:2: ( ( ( rule__VLSComment__CommentAssignment ) ) )
416 // InternalVampireLanguage.g:142:2: ( ( rule__VLSComment__CommentAssignment ) )
417 {
418 // InternalVampireLanguage.g:142:2: ( ( rule__VLSComment__CommentAssignment ) )
419 // InternalVampireLanguage.g:143:3: ( rule__VLSComment__CommentAssignment )
420 {
421 before(grammarAccess.getVLSCommentAccess().getCommentAssignment());
422 // InternalVampireLanguage.g:144:3: ( rule__VLSComment__CommentAssignment )
423 // InternalVampireLanguage.g:144:4: rule__VLSComment__CommentAssignment
424 {
425 pushFollow(FOLLOW_2);
426 rule__VLSComment__CommentAssignment();
427
428 state._fsp--;
429
430
431 }
432
433 after(grammarAccess.getVLSCommentAccess().getCommentAssignment());
434
435 }
436
437
438 }
439
440 }
441 catch (RecognitionException re) {
442 reportError(re);
443 recover(input,re);
444 }
445 finally {
446
447 restoreStackSize(stackSize);
448
449 }
450 return ;
451 }
452 // $ANTLR end "ruleVLSComment"
453
454
455 // $ANTLR start "entryRuleVLSFofFormula"
456 // InternalVampireLanguage.g:153:1: entryRuleVLSFofFormula : ruleVLSFofFormula EOF ;
457 public final void entryRuleVLSFofFormula() throws RecognitionException {
458 try {
459 // InternalVampireLanguage.g:154:1: ( ruleVLSFofFormula EOF )
460 // InternalVampireLanguage.g:155:1: ruleVLSFofFormula EOF
461 {
462 before(grammarAccess.getVLSFofFormulaRule());
463 pushFollow(FOLLOW_1);
464 ruleVLSFofFormula();
465
466 state._fsp--;
467
468 after(grammarAccess.getVLSFofFormulaRule());
469 match(input,EOF,FOLLOW_2);
470
471 }
472
473 }
474 catch (RecognitionException re) {
475 reportError(re);
476 recover(input,re);
477 }
478 finally {
479 }
480 return ;
481 }
482 // $ANTLR end "entryRuleVLSFofFormula"
483
484
485 // $ANTLR start "ruleVLSFofFormula"
486 // InternalVampireLanguage.g:162:1: ruleVLSFofFormula : ( ( rule__VLSFofFormula__Group__0 ) ) ;
487 public final void ruleVLSFofFormula() throws RecognitionException {
488
489 int stackSize = keepStackSize();
490
491 try {
492 // InternalVampireLanguage.g:166:2: ( ( ( rule__VLSFofFormula__Group__0 ) ) )
493 // InternalVampireLanguage.g:167:2: ( ( rule__VLSFofFormula__Group__0 ) )
494 {
495 // InternalVampireLanguage.g:167:2: ( ( rule__VLSFofFormula__Group__0 ) )
496 // InternalVampireLanguage.g:168:3: ( rule__VLSFofFormula__Group__0 )
497 {
498 before(grammarAccess.getVLSFofFormulaAccess().getGroup());
499 // InternalVampireLanguage.g:169:3: ( rule__VLSFofFormula__Group__0 )
500 // InternalVampireLanguage.g:169:4: rule__VLSFofFormula__Group__0
501 {
502 pushFollow(FOLLOW_2);
503 rule__VLSFofFormula__Group__0();
504
505 state._fsp--;
506
507
508 }
509
510 after(grammarAccess.getVLSFofFormulaAccess().getGroup());
511
512 }
513
514
515 }
516
517 }
518 catch (RecognitionException re) {
519 reportError(re);
520 recover(input,re);
521 }
522 finally {
523
524 restoreStackSize(stackSize);
525
526 }
527 return ;
528 }
529 // $ANTLR end "ruleVLSFofFormula"
530
531
532 // $ANTLR start "entryRuleVLSRole"
533 // InternalVampireLanguage.g:178:1: entryRuleVLSRole : ruleVLSRole EOF ;
534 public final void entryRuleVLSRole() throws RecognitionException {
535 try {
536 // InternalVampireLanguage.g:179:1: ( ruleVLSRole EOF )
537 // InternalVampireLanguage.g:180:1: ruleVLSRole EOF
538 {
539 before(grammarAccess.getVLSRoleRule());
540 pushFollow(FOLLOW_1);
541 ruleVLSRole();
542
543 state._fsp--;
544
545 after(grammarAccess.getVLSRoleRule());
546 match(input,EOF,FOLLOW_2);
547
548 }
549
550 }
551 catch (RecognitionException re) {
552 reportError(re);
553 recover(input,re);
554 }
555 finally {
556 }
557 return ;
558 }
559 // $ANTLR end "entryRuleVLSRole"
560
561
562 // $ANTLR start "ruleVLSRole"
563 // InternalVampireLanguage.g:187:1: ruleVLSRole : ( ( rule__VLSRole__Alternatives ) ) ;
564 public final void ruleVLSRole() throws RecognitionException {
565
566 int stackSize = keepStackSize();
567
568 try {
569 // InternalVampireLanguage.g:191:2: ( ( ( rule__VLSRole__Alternatives ) ) )
570 // InternalVampireLanguage.g:192:2: ( ( rule__VLSRole__Alternatives ) )
571 {
572 // InternalVampireLanguage.g:192:2: ( ( rule__VLSRole__Alternatives ) )
573 // InternalVampireLanguage.g:193:3: ( rule__VLSRole__Alternatives )
574 {
575 before(grammarAccess.getVLSRoleAccess().getAlternatives());
576 // InternalVampireLanguage.g:194:3: ( rule__VLSRole__Alternatives )
577 // InternalVampireLanguage.g:194:4: rule__VLSRole__Alternatives
578 {
579 pushFollow(FOLLOW_2);
580 rule__VLSRole__Alternatives();
581
582 state._fsp--;
583
584
585 }
586
587 after(grammarAccess.getVLSRoleAccess().getAlternatives());
588
589 }
590
591
592 }
593
594 }
595 catch (RecognitionException re) {
596 reportError(re);
597 recover(input,re);
598 }
599 finally {
600
601 restoreStackSize(stackSize);
602
603 }
604 return ;
605 }
606 // $ANTLR end "ruleVLSRole"
607
608
609 // $ANTLR start "entryRuleVLSAxiom"
610 // InternalVampireLanguage.g:203:1: entryRuleVLSAxiom : ruleVLSAxiom EOF ;
611 public final void entryRuleVLSAxiom() throws RecognitionException {
612 try {
613 // InternalVampireLanguage.g:204:1: ( ruleVLSAxiom EOF )
614 // InternalVampireLanguage.g:205:1: ruleVLSAxiom EOF
615 {
616 before(grammarAccess.getVLSAxiomRule());
617 pushFollow(FOLLOW_1);
618 ruleVLSAxiom();
619
620 state._fsp--;
621
622 after(grammarAccess.getVLSAxiomRule());
623 match(input,EOF,FOLLOW_2);
624
625 }
626
627 }
628 catch (RecognitionException re) {
629 reportError(re);
630 recover(input,re);
631 }
632 finally {
633 }
634 return ;
635 }
636 // $ANTLR end "entryRuleVLSAxiom"
637
638
639 // $ANTLR start "ruleVLSAxiom"
640 // InternalVampireLanguage.g:212:1: ruleVLSAxiom : ( 'axiom' ) ;
641 public final void ruleVLSAxiom() throws RecognitionException {
642
643 int stackSize = keepStackSize();
644
645 try {
646 // InternalVampireLanguage.g:216:2: ( ( 'axiom' ) )
647 // InternalVampireLanguage.g:217:2: ( 'axiom' )
648 {
649 // InternalVampireLanguage.g:217:2: ( 'axiom' )
650 // InternalVampireLanguage.g:218:3: 'axiom'
651 {
652 before(grammarAccess.getVLSAxiomAccess().getAxiomKeyword());
653 match(input,27,FOLLOW_2);
654 after(grammarAccess.getVLSAxiomAccess().getAxiomKeyword());
655
656 }
657
658
659 }
660
661 }
662 catch (RecognitionException re) {
663 reportError(re);
664 recover(input,re);
665 }
666 finally {
667
668 restoreStackSize(stackSize);
669
670 }
671 return ;
672 }
673 // $ANTLR end "ruleVLSAxiom"
674
675
676 // $ANTLR start "entryRuleVLSConjecture"
677 // InternalVampireLanguage.g:228:1: entryRuleVLSConjecture : ruleVLSConjecture EOF ;
678 public final void entryRuleVLSConjecture() throws RecognitionException {
679 try {
680 // InternalVampireLanguage.g:229:1: ( ruleVLSConjecture EOF )
681 // InternalVampireLanguage.g:230:1: ruleVLSConjecture EOF
682 {
683 before(grammarAccess.getVLSConjectureRule());
684 pushFollow(FOLLOW_1);
685 ruleVLSConjecture();
686
687 state._fsp--;
688
689 after(grammarAccess.getVLSConjectureRule());
690 match(input,EOF,FOLLOW_2);
691
692 }
693
694 }
695 catch (RecognitionException re) {
696 reportError(re);
697 recover(input,re);
698 }
699 finally {
700 }
701 return ;
702 }
703 // $ANTLR end "entryRuleVLSConjecture"
704
705
706 // $ANTLR start "ruleVLSConjecture"
707 // InternalVampireLanguage.g:237:1: ruleVLSConjecture : ( 'conjecture' ) ;
708 public final void ruleVLSConjecture() throws RecognitionException {
709
710 int stackSize = keepStackSize();
711
712 try {
713 // InternalVampireLanguage.g:241:2: ( ( 'conjecture' ) )
714 // InternalVampireLanguage.g:242:2: ( 'conjecture' )
715 {
716 // InternalVampireLanguage.g:242:2: ( 'conjecture' )
717 // InternalVampireLanguage.g:243:3: 'conjecture'
718 {
719 before(grammarAccess.getVLSConjectureAccess().getConjectureKeyword());
720 match(input,28,FOLLOW_2);
721 after(grammarAccess.getVLSConjectureAccess().getConjectureKeyword());
722
723 }
724
725
726 }
727
728 }
729 catch (RecognitionException re) {
730 reportError(re);
731 recover(input,re);
732 }
733 finally {
734
735 restoreStackSize(stackSize);
736
737 }
738 return ;
739 }
740 // $ANTLR end "ruleVLSConjecture"
741
742
743 // $ANTLR start "entryRuleVLSHypothesis"
744 // InternalVampireLanguage.g:253:1: entryRuleVLSHypothesis : ruleVLSHypothesis EOF ;
745 public final void entryRuleVLSHypothesis() throws RecognitionException {
746 try {
747 // InternalVampireLanguage.g:254:1: ( ruleVLSHypothesis EOF )
748 // InternalVampireLanguage.g:255:1: ruleVLSHypothesis EOF
749 {
750 before(grammarAccess.getVLSHypothesisRule());
751 pushFollow(FOLLOW_1);
752 ruleVLSHypothesis();
753
754 state._fsp--;
755
756 after(grammarAccess.getVLSHypothesisRule());
757 match(input,EOF,FOLLOW_2);
758
759 }
760
761 }
762 catch (RecognitionException re) {
763 reportError(re);
764 recover(input,re);
765 }
766 finally {
767 }
768 return ;
769 }
770 // $ANTLR end "entryRuleVLSHypothesis"
771
772
773 // $ANTLR start "ruleVLSHypothesis"
774 // InternalVampireLanguage.g:262:1: ruleVLSHypothesis : ( 'hypothesis' ) ;
775 public final void ruleVLSHypothesis() throws RecognitionException {
776
777 int stackSize = keepStackSize();
778
779 try {
780 // InternalVampireLanguage.g:266:2: ( ( 'hypothesis' ) )
781 // InternalVampireLanguage.g:267:2: ( 'hypothesis' )
782 {
783 // InternalVampireLanguage.g:267:2: ( 'hypothesis' )
784 // InternalVampireLanguage.g:268:3: 'hypothesis'
785 {
786 before(grammarAccess.getVLSHypothesisAccess().getHypothesisKeyword());
787 match(input,29,FOLLOW_2);
788 after(grammarAccess.getVLSHypothesisAccess().getHypothesisKeyword());
789
790 }
791
792
793 }
794
795 }
796 catch (RecognitionException re) {
797 reportError(re);
798 recover(input,re);
799 }
800 finally {
801
802 restoreStackSize(stackSize);
803
804 }
805 return ;
806 }
807 // $ANTLR end "ruleVLSHypothesis"
808
809
810 // $ANTLR start "entryRuleVLSDefinition"
811 // InternalVampireLanguage.g:278:1: entryRuleVLSDefinition : ruleVLSDefinition EOF ;
812 public final void entryRuleVLSDefinition() throws RecognitionException {
813 try {
814 // InternalVampireLanguage.g:279:1: ( ruleVLSDefinition EOF )
815 // InternalVampireLanguage.g:280:1: ruleVLSDefinition EOF
816 {
817 before(grammarAccess.getVLSDefinitionRule());
818 pushFollow(FOLLOW_1);
819 ruleVLSDefinition();
820
821 state._fsp--;
822
823 after(grammarAccess.getVLSDefinitionRule());
824 match(input,EOF,FOLLOW_2);
825
826 }
827
828 }
829 catch (RecognitionException re) {
830 reportError(re);
831 recover(input,re);
832 }
833 finally {
834 }
835 return ;
836 }
837 // $ANTLR end "entryRuleVLSDefinition"
838
839
840 // $ANTLR start "ruleVLSDefinition"
841 // InternalVampireLanguage.g:287:1: ruleVLSDefinition : ( 'definition' ) ;
842 public final void ruleVLSDefinition() throws RecognitionException {
843
844 int stackSize = keepStackSize();
845
846 try {
847 // InternalVampireLanguage.g:291:2: ( ( 'definition' ) )
848 // InternalVampireLanguage.g:292:2: ( 'definition' )
849 {
850 // InternalVampireLanguage.g:292:2: ( 'definition' )
851 // InternalVampireLanguage.g:293:3: 'definition'
852 {
853 before(grammarAccess.getVLSDefinitionAccess().getDefinitionKeyword());
854 match(input,30,FOLLOW_2);
855 after(grammarAccess.getVLSDefinitionAccess().getDefinitionKeyword());
856
857 }
858
859
860 }
861
862 }
863 catch (RecognitionException re) {
864 reportError(re);
865 recover(input,re);
866 }
867 finally {
868
869 restoreStackSize(stackSize);
870
871 }
872 return ;
873 }
874 // $ANTLR end "ruleVLSDefinition"
875
876
877 // $ANTLR start "entryRuleVLSAssumption"
878 // InternalVampireLanguage.g:303:1: entryRuleVLSAssumption : ruleVLSAssumption EOF ;
879 public final void entryRuleVLSAssumption() throws RecognitionException {
880 try {
881 // InternalVampireLanguage.g:304:1: ( ruleVLSAssumption EOF )
882 // InternalVampireLanguage.g:305:1: ruleVLSAssumption EOF
883 {
884 before(grammarAccess.getVLSAssumptionRule());
885 pushFollow(FOLLOW_1);
886 ruleVLSAssumption();
887
888 state._fsp--;
889
890 after(grammarAccess.getVLSAssumptionRule());
891 match(input,EOF,FOLLOW_2);
892
893 }
894
895 }
896 catch (RecognitionException re) {
897 reportError(re);
898 recover(input,re);
899 }
900 finally {
901 }
902 return ;
903 }
904 // $ANTLR end "entryRuleVLSAssumption"
905
906
907 // $ANTLR start "ruleVLSAssumption"
908 // InternalVampireLanguage.g:312:1: ruleVLSAssumption : ( 'assumption' ) ;
909 public final void ruleVLSAssumption() throws RecognitionException {
910
911 int stackSize = keepStackSize();
912
913 try {
914 // InternalVampireLanguage.g:316:2: ( ( 'assumption' ) )
915 // InternalVampireLanguage.g:317:2: ( 'assumption' )
916 {
917 // InternalVampireLanguage.g:317:2: ( 'assumption' )
918 // InternalVampireLanguage.g:318:3: 'assumption'
919 {
920 before(grammarAccess.getVLSAssumptionAccess().getAssumptionKeyword());
921 match(input,31,FOLLOW_2);
922 after(grammarAccess.getVLSAssumptionAccess().getAssumptionKeyword());
923
924 }
925
926
927 }
928
929 }
930 catch (RecognitionException re) {
931 reportError(re);
932 recover(input,re);
933 }
934 finally {
935
936 restoreStackSize(stackSize);
937
938 }
939 return ;
940 }
941 // $ANTLR end "ruleVLSAssumption"
942
943
944 // $ANTLR start "entryRuleVLSLemma"
945 // InternalVampireLanguage.g:328:1: entryRuleVLSLemma : ruleVLSLemma EOF ;
946 public final void entryRuleVLSLemma() throws RecognitionException {
947 try {
948 // InternalVampireLanguage.g:329:1: ( ruleVLSLemma EOF )
949 // InternalVampireLanguage.g:330:1: ruleVLSLemma EOF
950 {
951 before(grammarAccess.getVLSLemmaRule());
952 pushFollow(FOLLOW_1);
953 ruleVLSLemma();
954
955 state._fsp--;
956
957 after(grammarAccess.getVLSLemmaRule());
958 match(input,EOF,FOLLOW_2);
959
960 }
961
962 }
963 catch (RecognitionException re) {
964 reportError(re);
965 recover(input,re);
966 }
967 finally {
968 }
969 return ;
970 }
971 // $ANTLR end "entryRuleVLSLemma"
972
973
974 // $ANTLR start "ruleVLSLemma"
975 // InternalVampireLanguage.g:337:1: ruleVLSLemma : ( 'lemma' ) ;
976 public final void ruleVLSLemma() throws RecognitionException {
977
978 int stackSize = keepStackSize();
979
980 try {
981 // InternalVampireLanguage.g:341:2: ( ( 'lemma' ) )
982 // InternalVampireLanguage.g:342:2: ( 'lemma' )
983 {
984 // InternalVampireLanguage.g:342:2: ( 'lemma' )
985 // InternalVampireLanguage.g:343:3: 'lemma'
986 {
987 before(grammarAccess.getVLSLemmaAccess().getLemmaKeyword());
988 match(input,32,FOLLOW_2);
989 after(grammarAccess.getVLSLemmaAccess().getLemmaKeyword());
990
991 }
992
993
994 }
995
996 }
997 catch (RecognitionException re) {
998 reportError(re);
999 recover(input,re);
1000 }
1001 finally {
1002
1003 restoreStackSize(stackSize);
1004
1005 }
1006 return ;
1007 }
1008 // $ANTLR end "ruleVLSLemma"
1009
1010
1011 // $ANTLR start "entryRuleVLSTheorem"
1012 // InternalVampireLanguage.g:353:1: entryRuleVLSTheorem : ruleVLSTheorem EOF ;
1013 public final void entryRuleVLSTheorem() throws RecognitionException {
1014 try {
1015 // InternalVampireLanguage.g:354:1: ( ruleVLSTheorem EOF )
1016 // InternalVampireLanguage.g:355:1: ruleVLSTheorem EOF
1017 {
1018 before(grammarAccess.getVLSTheoremRule());
1019 pushFollow(FOLLOW_1);
1020 ruleVLSTheorem();
1021
1022 state._fsp--;
1023
1024 after(grammarAccess.getVLSTheoremRule());
1025 match(input,EOF,FOLLOW_2);
1026
1027 }
1028
1029 }
1030 catch (RecognitionException re) {
1031 reportError(re);
1032 recover(input,re);
1033 }
1034 finally {
1035 }
1036 return ;
1037 }
1038 // $ANTLR end "entryRuleVLSTheorem"
1039
1040
1041 // $ANTLR start "ruleVLSTheorem"
1042 // InternalVampireLanguage.g:362:1: ruleVLSTheorem : ( 'theorem' ) ;
1043 public final void ruleVLSTheorem() throws RecognitionException {
1044
1045 int stackSize = keepStackSize();
1046
1047 try {
1048 // InternalVampireLanguage.g:366:2: ( ( 'theorem' ) )
1049 // InternalVampireLanguage.g:367:2: ( 'theorem' )
1050 {
1051 // InternalVampireLanguage.g:367:2: ( 'theorem' )
1052 // InternalVampireLanguage.g:368:3: 'theorem'
1053 {
1054 before(grammarAccess.getVLSTheoremAccess().getTheoremKeyword());
1055 match(input,33,FOLLOW_2);
1056 after(grammarAccess.getVLSTheoremAccess().getTheoremKeyword());
1057
1058 }
1059
1060
1061 }
1062
1063 }
1064 catch (RecognitionException re) {
1065 reportError(re);
1066 recover(input,re);
1067 }
1068 finally {
1069
1070 restoreStackSize(stackSize);
1071
1072 }
1073 return ;
1074 }
1075 // $ANTLR end "ruleVLSTheorem"
1076
1077
1078 // $ANTLR start "entryRuleVLSCorollary"
1079 // InternalVampireLanguage.g:378:1: entryRuleVLSCorollary : ruleVLSCorollary EOF ;
1080 public final void entryRuleVLSCorollary() throws RecognitionException {
1081 try {
1082 // InternalVampireLanguage.g:379:1: ( ruleVLSCorollary EOF )
1083 // InternalVampireLanguage.g:380:1: ruleVLSCorollary EOF
1084 {
1085 before(grammarAccess.getVLSCorollaryRule());
1086 pushFollow(FOLLOW_1);
1087 ruleVLSCorollary();
1088
1089 state._fsp--;
1090
1091 after(grammarAccess.getVLSCorollaryRule());
1092 match(input,EOF,FOLLOW_2);
1093
1094 }
1095
1096 }
1097 catch (RecognitionException re) {
1098 reportError(re);
1099 recover(input,re);
1100 }
1101 finally {
1102 }
1103 return ;
1104 }
1105 // $ANTLR end "entryRuleVLSCorollary"
1106
1107
1108 // $ANTLR start "ruleVLSCorollary"
1109 // InternalVampireLanguage.g:387:1: ruleVLSCorollary : ( 'corollary' ) ;
1110 public final void ruleVLSCorollary() throws RecognitionException {
1111
1112 int stackSize = keepStackSize();
1113
1114 try {
1115 // InternalVampireLanguage.g:391:2: ( ( 'corollary' ) )
1116 // InternalVampireLanguage.g:392:2: ( 'corollary' )
1117 {
1118 // InternalVampireLanguage.g:392:2: ( 'corollary' )
1119 // InternalVampireLanguage.g:393:3: 'corollary'
1120 {
1121 before(grammarAccess.getVLSCorollaryAccess().getCorollaryKeyword());
1122 match(input,34,FOLLOW_2);
1123 after(grammarAccess.getVLSCorollaryAccess().getCorollaryKeyword());
1124
1125 }
1126
1127
1128 }
1129
1130 }
1131 catch (RecognitionException re) {
1132 reportError(re);
1133 recover(input,re);
1134 }
1135 finally {
1136
1137 restoreStackSize(stackSize);
1138
1139 }
1140 return ;
1141 }
1142 // $ANTLR end "ruleVLSCorollary"
1143
1144
1145 // $ANTLR start "entryRuleVLSNegated_Conjecture"
1146 // InternalVampireLanguage.g:403:1: entryRuleVLSNegated_Conjecture : ruleVLSNegated_Conjecture EOF ;
1147 public final void entryRuleVLSNegated_Conjecture() throws RecognitionException {
1148 try {
1149 // InternalVampireLanguage.g:404:1: ( ruleVLSNegated_Conjecture EOF )
1150 // InternalVampireLanguage.g:405:1: ruleVLSNegated_Conjecture EOF
1151 {
1152 before(grammarAccess.getVLSNegated_ConjectureRule());
1153 pushFollow(FOLLOW_1);
1154 ruleVLSNegated_Conjecture();
1155
1156 state._fsp--;
1157
1158 after(grammarAccess.getVLSNegated_ConjectureRule());
1159 match(input,EOF,FOLLOW_2);
1160
1161 }
1162
1163 }
1164 catch (RecognitionException re) {
1165 reportError(re);
1166 recover(input,re);
1167 }
1168 finally {
1169 }
1170 return ;
1171 }
1172 // $ANTLR end "entryRuleVLSNegated_Conjecture"
1173
1174
1175 // $ANTLR start "ruleVLSNegated_Conjecture"
1176 // InternalVampireLanguage.g:412:1: ruleVLSNegated_Conjecture : ( 'negated_conjecture' ) ;
1177 public final void ruleVLSNegated_Conjecture() throws RecognitionException {
1178
1179 int stackSize = keepStackSize();
1180
1181 try {
1182 // InternalVampireLanguage.g:416:2: ( ( 'negated_conjecture' ) )
1183 // InternalVampireLanguage.g:417:2: ( 'negated_conjecture' )
1184 {
1185 // InternalVampireLanguage.g:417:2: ( 'negated_conjecture' )
1186 // InternalVampireLanguage.g:418:3: 'negated_conjecture'
1187 {
1188 before(grammarAccess.getVLSNegated_ConjectureAccess().getNegated_conjectureKeyword());
1189 match(input,35,FOLLOW_2);
1190 after(grammarAccess.getVLSNegated_ConjectureAccess().getNegated_conjectureKeyword());
1191
1192 }
1193
1194
1195 }
1196
1197 }
1198 catch (RecognitionException re) {
1199 reportError(re);
1200 recover(input,re);
1201 }
1202 finally {
1203
1204 restoreStackSize(stackSize);
1205
1206 }
1207 return ;
1208 }
1209 // $ANTLR end "ruleVLSNegated_Conjecture"
1210
1211
1212 // $ANTLR start "entryRuleVLSPlain"
1213 // InternalVampireLanguage.g:428:1: entryRuleVLSPlain : ruleVLSPlain EOF ;
1214 public final void entryRuleVLSPlain() throws RecognitionException {
1215 try {
1216 // InternalVampireLanguage.g:429:1: ( ruleVLSPlain EOF )
1217 // InternalVampireLanguage.g:430:1: ruleVLSPlain EOF
1218 {
1219 before(grammarAccess.getVLSPlainRule());
1220 pushFollow(FOLLOW_1);
1221 ruleVLSPlain();
1222
1223 state._fsp--;
1224
1225 after(grammarAccess.getVLSPlainRule());
1226 match(input,EOF,FOLLOW_2);
1227
1228 }
1229
1230 }
1231 catch (RecognitionException re) {
1232 reportError(re);
1233 recover(input,re);
1234 }
1235 finally {
1236 }
1237 return ;
1238 }
1239 // $ANTLR end "entryRuleVLSPlain"
1240
1241
1242 // $ANTLR start "ruleVLSPlain"
1243 // InternalVampireLanguage.g:437:1: ruleVLSPlain : ( 'plain' ) ;
1244 public final void ruleVLSPlain() throws RecognitionException {
1245
1246 int stackSize = keepStackSize();
1247
1248 try {
1249 // InternalVampireLanguage.g:441:2: ( ( 'plain' ) )
1250 // InternalVampireLanguage.g:442:2: ( 'plain' )
1251 {
1252 // InternalVampireLanguage.g:442:2: ( 'plain' )
1253 // InternalVampireLanguage.g:443:3: 'plain'
1254 {
1255 before(grammarAccess.getVLSPlainAccess().getPlainKeyword());
1256 match(input,36,FOLLOW_2);
1257 after(grammarAccess.getVLSPlainAccess().getPlainKeyword());
1258
1259 }
1260
1261
1262 }
1263
1264 }
1265 catch (RecognitionException re) {
1266 reportError(re);
1267 recover(input,re);
1268 }
1269 finally {
1270
1271 restoreStackSize(stackSize);
1272
1273 }
1274 return ;
1275 }
1276 // $ANTLR end "ruleVLSPlain"
1277
1278
1279 // $ANTLR start "entryRuleVLSType"
1280 // InternalVampireLanguage.g:453:1: entryRuleVLSType : ruleVLSType EOF ;
1281 public final void entryRuleVLSType() throws RecognitionException {
1282 try {
1283 // InternalVampireLanguage.g:454:1: ( ruleVLSType EOF )
1284 // InternalVampireLanguage.g:455:1: ruleVLSType EOF
1285 {
1286 before(grammarAccess.getVLSTypeRule());
1287 pushFollow(FOLLOW_1);
1288 ruleVLSType();
1289
1290 state._fsp--;
1291
1292 after(grammarAccess.getVLSTypeRule());
1293 match(input,EOF,FOLLOW_2);
1294
1295 }
1296
1297 }
1298 catch (RecognitionException re) {
1299 reportError(re);
1300 recover(input,re);
1301 }
1302 finally {
1303 }
1304 return ;
1305 }
1306 // $ANTLR end "entryRuleVLSType"
1307
1308
1309 // $ANTLR start "ruleVLSType"
1310 // InternalVampireLanguage.g:462:1: ruleVLSType : ( 'type' ) ;
1311 public final void ruleVLSType() throws RecognitionException {
1312
1313 int stackSize = keepStackSize();
1314
1315 try {
1316 // InternalVampireLanguage.g:466:2: ( ( 'type' ) )
1317 // InternalVampireLanguage.g:467:2: ( 'type' )
1318 {
1319 // InternalVampireLanguage.g:467:2: ( 'type' )
1320 // InternalVampireLanguage.g:468:3: 'type'
1321 {
1322 before(grammarAccess.getVLSTypeAccess().getTypeKeyword());
1323 match(input,37,FOLLOW_2);
1324 after(grammarAccess.getVLSTypeAccess().getTypeKeyword());
1325
1326 }
1327
1328
1329 }
1330
1331 }
1332 catch (RecognitionException re) {
1333 reportError(re);
1334 recover(input,re);
1335 }
1336 finally {
1337
1338 restoreStackSize(stackSize);
1339
1340 }
1341 return ;
1342 }
1343 // $ANTLR end "ruleVLSType"
1344
1345
1346 // $ANTLR start "entryRuleVLSFi_Domain"
1347 // InternalVampireLanguage.g:478:1: entryRuleVLSFi_Domain : ruleVLSFi_Domain EOF ;
1348 public final void entryRuleVLSFi_Domain() throws RecognitionException {
1349 try {
1350 // InternalVampireLanguage.g:479:1: ( ruleVLSFi_Domain EOF )
1351 // InternalVampireLanguage.g:480:1: ruleVLSFi_Domain EOF
1352 {
1353 before(grammarAccess.getVLSFi_DomainRule());
1354 pushFollow(FOLLOW_1);
1355 ruleVLSFi_Domain();
1356
1357 state._fsp--;
1358
1359 after(grammarAccess.getVLSFi_DomainRule());
1360 match(input,EOF,FOLLOW_2);
1361
1362 }
1363
1364 }
1365 catch (RecognitionException re) {
1366 reportError(re);
1367 recover(input,re);
1368 }
1369 finally {
1370 }
1371 return ;
1372 }
1373 // $ANTLR end "entryRuleVLSFi_Domain"
1374
1375
1376 // $ANTLR start "ruleVLSFi_Domain"
1377 // InternalVampireLanguage.g:487:1: ruleVLSFi_Domain : ( 'fi_domain' ) ;
1378 public final void ruleVLSFi_Domain() throws RecognitionException {
1379
1380 int stackSize = keepStackSize();
1381
1382 try {
1383 // InternalVampireLanguage.g:491:2: ( ( 'fi_domain' ) )
1384 // InternalVampireLanguage.g:492:2: ( 'fi_domain' )
1385 {
1386 // InternalVampireLanguage.g:492:2: ( 'fi_domain' )
1387 // InternalVampireLanguage.g:493:3: 'fi_domain'
1388 {
1389 before(grammarAccess.getVLSFi_DomainAccess().getFi_domainKeyword());
1390 match(input,38,FOLLOW_2);
1391 after(grammarAccess.getVLSFi_DomainAccess().getFi_domainKeyword());
1392
1393 }
1394
1395
1396 }
1397
1398 }
1399 catch (RecognitionException re) {
1400 reportError(re);
1401 recover(input,re);
1402 }
1403 finally {
1404
1405 restoreStackSize(stackSize);
1406
1407 }
1408 return ;
1409 }
1410 // $ANTLR end "ruleVLSFi_Domain"
1411
1412
1413 // $ANTLR start "entryRuleVLSFi_Functors"
1414 // InternalVampireLanguage.g:503:1: entryRuleVLSFi_Functors : ruleVLSFi_Functors EOF ;
1415 public final void entryRuleVLSFi_Functors() throws RecognitionException {
1416 try {
1417 // InternalVampireLanguage.g:504:1: ( ruleVLSFi_Functors EOF )
1418 // InternalVampireLanguage.g:505:1: ruleVLSFi_Functors EOF
1419 {
1420 before(grammarAccess.getVLSFi_FunctorsRule());
1421 pushFollow(FOLLOW_1);
1422 ruleVLSFi_Functors();
1423
1424 state._fsp--;
1425
1426 after(grammarAccess.getVLSFi_FunctorsRule());
1427 match(input,EOF,FOLLOW_2);
1428
1429 }
1430
1431 }
1432 catch (RecognitionException re) {
1433 reportError(re);
1434 recover(input,re);
1435 }
1436 finally {
1437 }
1438 return ;
1439 }
1440 // $ANTLR end "entryRuleVLSFi_Functors"
1441
1442
1443 // $ANTLR start "ruleVLSFi_Functors"
1444 // InternalVampireLanguage.g:512:1: ruleVLSFi_Functors : ( 'fi_functors' ) ;
1445 public final void ruleVLSFi_Functors() throws RecognitionException {
1446
1447 int stackSize = keepStackSize();
1448
1449 try {
1450 // InternalVampireLanguage.g:516:2: ( ( 'fi_functors' ) )
1451 // InternalVampireLanguage.g:517:2: ( 'fi_functors' )
1452 {
1453 // InternalVampireLanguage.g:517:2: ( 'fi_functors' )
1454 // InternalVampireLanguage.g:518:3: 'fi_functors'
1455 {
1456 before(grammarAccess.getVLSFi_FunctorsAccess().getFi_functorsKeyword());
1457 match(input,39,FOLLOW_2);
1458 after(grammarAccess.getVLSFi_FunctorsAccess().getFi_functorsKeyword());
1459
1460 }
1461
1462
1463 }
1464
1465 }
1466 catch (RecognitionException re) {
1467 reportError(re);
1468 recover(input,re);
1469 }
1470 finally {
1471
1472 restoreStackSize(stackSize);
1473
1474 }
1475 return ;
1476 }
1477 // $ANTLR end "ruleVLSFi_Functors"
1478
1479
1480 // $ANTLR start "entryRuleVLSFi_Predicates"
1481 // InternalVampireLanguage.g:528:1: entryRuleVLSFi_Predicates : ruleVLSFi_Predicates EOF ;
1482 public final void entryRuleVLSFi_Predicates() throws RecognitionException {
1483 try {
1484 // InternalVampireLanguage.g:529:1: ( ruleVLSFi_Predicates EOF )
1485 // InternalVampireLanguage.g:530:1: ruleVLSFi_Predicates EOF
1486 {
1487 before(grammarAccess.getVLSFi_PredicatesRule());
1488 pushFollow(FOLLOW_1);
1489 ruleVLSFi_Predicates();
1490
1491 state._fsp--;
1492
1493 after(grammarAccess.getVLSFi_PredicatesRule());
1494 match(input,EOF,FOLLOW_2);
1495
1496 }
1497
1498 }
1499 catch (RecognitionException re) {
1500 reportError(re);
1501 recover(input,re);
1502 }
1503 finally {
1504 }
1505 return ;
1506 }
1507 // $ANTLR end "entryRuleVLSFi_Predicates"
1508
1509
1510 // $ANTLR start "ruleVLSFi_Predicates"
1511 // InternalVampireLanguage.g:537:1: ruleVLSFi_Predicates : ( 'fi_predicates' ) ;
1512 public final void ruleVLSFi_Predicates() throws RecognitionException {
1513
1514 int stackSize = keepStackSize();
1515
1516 try {
1517 // InternalVampireLanguage.g:541:2: ( ( 'fi_predicates' ) )
1518 // InternalVampireLanguage.g:542:2: ( 'fi_predicates' )
1519 {
1520 // InternalVampireLanguage.g:542:2: ( 'fi_predicates' )
1521 // InternalVampireLanguage.g:543:3: 'fi_predicates'
1522 {
1523 before(grammarAccess.getVLSFi_PredicatesAccess().getFi_predicatesKeyword());
1524 match(input,40,FOLLOW_2);
1525 after(grammarAccess.getVLSFi_PredicatesAccess().getFi_predicatesKeyword());
1526
1527 }
1528
1529
1530 }
1531
1532 }
1533 catch (RecognitionException re) {
1534 reportError(re);
1535 recover(input,re);
1536 }
1537 finally {
1538
1539 restoreStackSize(stackSize);
1540
1541 }
1542 return ;
1543 }
1544 // $ANTLR end "ruleVLSFi_Predicates"
1545
1546
1547 // $ANTLR start "entryRuleVLSUnknown"
1548 // InternalVampireLanguage.g:553:1: entryRuleVLSUnknown : ruleVLSUnknown EOF ;
1549 public final void entryRuleVLSUnknown() throws RecognitionException {
1550 try {
1551 // InternalVampireLanguage.g:554:1: ( ruleVLSUnknown EOF )
1552 // InternalVampireLanguage.g:555:1: ruleVLSUnknown EOF
1553 {
1554 before(grammarAccess.getVLSUnknownRule());
1555 pushFollow(FOLLOW_1);
1556 ruleVLSUnknown();
1557
1558 state._fsp--;
1559
1560 after(grammarAccess.getVLSUnknownRule());
1561 match(input,EOF,FOLLOW_2);
1562
1563 }
1564
1565 }
1566 catch (RecognitionException re) {
1567 reportError(re);
1568 recover(input,re);
1569 }
1570 finally {
1571 }
1572 return ;
1573 }
1574 // $ANTLR end "entryRuleVLSUnknown"
1575
1576
1577 // $ANTLR start "ruleVLSUnknown"
1578 // InternalVampireLanguage.g:562:1: ruleVLSUnknown : ( 'unknown' ) ;
1579 public final void ruleVLSUnknown() throws RecognitionException {
1580
1581 int stackSize = keepStackSize();
1582
1583 try {
1584 // InternalVampireLanguage.g:566:2: ( ( 'unknown' ) )
1585 // InternalVampireLanguage.g:567:2: ( 'unknown' )
1586 {
1587 // InternalVampireLanguage.g:567:2: ( 'unknown' )
1588 // InternalVampireLanguage.g:568:3: 'unknown'
1589 {
1590 before(grammarAccess.getVLSUnknownAccess().getUnknownKeyword());
1591 match(input,41,FOLLOW_2);
1592 after(grammarAccess.getVLSUnknownAccess().getUnknownKeyword());
1593
1594 }
1595
1596
1597 }
1598
1599 }
1600 catch (RecognitionException re) {
1601 reportError(re);
1602 recover(input,re);
1603 }
1604 finally {
1605
1606 restoreStackSize(stackSize);
1607
1608 }
1609 return ;
1610 }
1611 // $ANTLR end "ruleVLSUnknown"
1612
1613
1614 // $ANTLR start "entryRuleVLSAnnotation"
1615 // InternalVampireLanguage.g:578:1: entryRuleVLSAnnotation : ruleVLSAnnotation EOF ;
1616 public final void entryRuleVLSAnnotation() throws RecognitionException {
1617 try {
1618 // InternalVampireLanguage.g:579:1: ( ruleVLSAnnotation EOF )
1619 // InternalVampireLanguage.g:580:1: ruleVLSAnnotation EOF
1620 {
1621 before(grammarAccess.getVLSAnnotationRule());
1622 pushFollow(FOLLOW_1);
1623 ruleVLSAnnotation();
1624
1625 state._fsp--;
1626
1627 after(grammarAccess.getVLSAnnotationRule());
1628 match(input,EOF,FOLLOW_2);
1629
1630 }
1631
1632 }
1633 catch (RecognitionException re) {
1634 reportError(re);
1635 recover(input,re);
1636 }
1637 finally {
1638 }
1639 return ;
1640 }
1641 // $ANTLR end "entryRuleVLSAnnotation"
1642
1643
1644 // $ANTLR start "ruleVLSAnnotation"
1645 // InternalVampireLanguage.g:587:1: ruleVLSAnnotation : ( ( rule__VLSAnnotation__Group__0 ) ) ;
1646 public final void ruleVLSAnnotation() throws RecognitionException {
1647
1648 int stackSize = keepStackSize();
1649
1650 try {
1651 // InternalVampireLanguage.g:591:2: ( ( ( rule__VLSAnnotation__Group__0 ) ) )
1652 // InternalVampireLanguage.g:592:2: ( ( rule__VLSAnnotation__Group__0 ) )
1653 {
1654 // InternalVampireLanguage.g:592:2: ( ( rule__VLSAnnotation__Group__0 ) )
1655 // InternalVampireLanguage.g:593:3: ( rule__VLSAnnotation__Group__0 )
1656 {
1657 before(grammarAccess.getVLSAnnotationAccess().getGroup());
1658 // InternalVampireLanguage.g:594:3: ( rule__VLSAnnotation__Group__0 )
1659 // InternalVampireLanguage.g:594:4: rule__VLSAnnotation__Group__0
1660 {
1661 pushFollow(FOLLOW_2);
1662 rule__VLSAnnotation__Group__0();
1663
1664 state._fsp--;
1665
1666
1667 }
1668
1669 after(grammarAccess.getVLSAnnotationAccess().getGroup());
1670
1671 }
1672
1673
1674 }
1675
1676 }
1677 catch (RecognitionException re) {
1678 reportError(re);
1679 recover(input,re);
1680 }
1681 finally {
1682
1683 restoreStackSize(stackSize);
1684
1685 }
1686 return ;
1687 }
1688 // $ANTLR end "ruleVLSAnnotation"
1689
1690
1691 // $ANTLR start "entryRuleVLSAnnotationTerms"
1692 // InternalVampireLanguage.g:603:1: entryRuleVLSAnnotationTerms : ruleVLSAnnotationTerms EOF ;
1693 public final void entryRuleVLSAnnotationTerms() throws RecognitionException {
1694 try {
1695 // InternalVampireLanguage.g:604:1: ( ruleVLSAnnotationTerms EOF )
1696 // InternalVampireLanguage.g:605:1: ruleVLSAnnotationTerms EOF
1697 {
1698 before(grammarAccess.getVLSAnnotationTermsRule());
1699 pushFollow(FOLLOW_1);
1700 ruleVLSAnnotationTerms();
1701
1702 state._fsp--;
1703
1704 after(grammarAccess.getVLSAnnotationTermsRule());
1705 match(input,EOF,FOLLOW_2);
1706
1707 }
1708
1709 }
1710 catch (RecognitionException re) {
1711 reportError(re);
1712 recover(input,re);
1713 }
1714 finally {
1715 }
1716 return ;
1717 }
1718 // $ANTLR end "entryRuleVLSAnnotationTerms"
1719
1720
1721 // $ANTLR start "ruleVLSAnnotationTerms"
1722 // InternalVampireLanguage.g:612:1: ruleVLSAnnotationTerms : ( ( rule__VLSAnnotationTerms__Group__0 ) ) ;
1723 public final void ruleVLSAnnotationTerms() throws RecognitionException {
1724
1725 int stackSize = keepStackSize();
1726
1727 try {
1728 // InternalVampireLanguage.g:616:2: ( ( ( rule__VLSAnnotationTerms__Group__0 ) ) )
1729 // InternalVampireLanguage.g:617:2: ( ( rule__VLSAnnotationTerms__Group__0 ) )
1730 {
1731 // InternalVampireLanguage.g:617:2: ( ( rule__VLSAnnotationTerms__Group__0 ) )
1732 // InternalVampireLanguage.g:618:3: ( rule__VLSAnnotationTerms__Group__0 )
1733 {
1734 before(grammarAccess.getVLSAnnotationTermsAccess().getGroup());
1735 // InternalVampireLanguage.g:619:3: ( rule__VLSAnnotationTerms__Group__0 )
1736 // InternalVampireLanguage.g:619:4: rule__VLSAnnotationTerms__Group__0
1737 {
1738 pushFollow(FOLLOW_2);
1739 rule__VLSAnnotationTerms__Group__0();
1740
1741 state._fsp--;
1742
1743
1744 }
1745
1746 after(grammarAccess.getVLSAnnotationTermsAccess().getGroup());
1747
1748 }
1749
1750
1751 }
1752
1753 }
1754 catch (RecognitionException re) {
1755 reportError(re);
1756 recover(input,re);
1757 }
1758 finally {
1759
1760 restoreStackSize(stackSize);
1761
1762 }
1763 return ;
1764 }
1765 // $ANTLR end "ruleVLSAnnotationTerms"
1766
1767
1768 // $ANTLR start "entryRuleVLSTerm"
1769 // InternalVampireLanguage.g:628:1: entryRuleVLSTerm : ruleVLSTerm EOF ;
1770 public final void entryRuleVLSTerm() throws RecognitionException {
1771 try {
1772 // InternalVampireLanguage.g:629:1: ( ruleVLSTerm EOF )
1773 // InternalVampireLanguage.g:630:1: ruleVLSTerm EOF
1774 {
1775 before(grammarAccess.getVLSTermRule());
1776 pushFollow(FOLLOW_1);
1777 ruleVLSTerm();
1778
1779 state._fsp--;
1780
1781 after(grammarAccess.getVLSTermRule());
1782 match(input,EOF,FOLLOW_2);
1783
1784 }
1785
1786 }
1787 catch (RecognitionException re) {
1788 reportError(re);
1789 recover(input,re);
1790 }
1791 finally {
1792 }
1793 return ;
1794 }
1795 // $ANTLR end "entryRuleVLSTerm"
1796
1797
1798 // $ANTLR start "ruleVLSTerm"
1799 // InternalVampireLanguage.g:637:1: ruleVLSTerm : ( ruleVLSBinary ) ;
1800 public final void ruleVLSTerm() throws RecognitionException {
1801
1802 int stackSize = keepStackSize();
1803
1804 try {
1805 // InternalVampireLanguage.g:641:2: ( ( ruleVLSBinary ) )
1806 // InternalVampireLanguage.g:642:2: ( ruleVLSBinary )
1807 {
1808 // InternalVampireLanguage.g:642:2: ( ruleVLSBinary )
1809 // InternalVampireLanguage.g:643:3: ruleVLSBinary
1810 {
1811 before(grammarAccess.getVLSTermAccess().getVLSBinaryParserRuleCall());
1812 pushFollow(FOLLOW_2);
1813 ruleVLSBinary();
1814
1815 state._fsp--;
1816
1817 after(grammarAccess.getVLSTermAccess().getVLSBinaryParserRuleCall());
1818
1819 }
1820
1821
1822 }
1823
1824 }
1825 catch (RecognitionException re) {
1826 reportError(re);
1827 recover(input,re);
1828 }
1829 finally {
1830
1831 restoreStackSize(stackSize);
1832
1833 }
1834 return ;
1835 }
1836 // $ANTLR end "ruleVLSTerm"
1837
1838
1839 // $ANTLR start "entryRuleVLSBinary"
1840 // InternalVampireLanguage.g:653:1: entryRuleVLSBinary : ruleVLSBinary EOF ;
1841 public final void entryRuleVLSBinary() throws RecognitionException {
1842 try {
1843 // InternalVampireLanguage.g:654:1: ( ruleVLSBinary EOF )
1844 // InternalVampireLanguage.g:655:1: ruleVLSBinary EOF
1845 {
1846 before(grammarAccess.getVLSBinaryRule());
1847 pushFollow(FOLLOW_1);
1848 ruleVLSBinary();
1849
1850 state._fsp--;
1851
1852 after(grammarAccess.getVLSBinaryRule());
1853 match(input,EOF,FOLLOW_2);
1854
1855 }
1856
1857 }
1858 catch (RecognitionException re) {
1859 reportError(re);
1860 recover(input,re);
1861 }
1862 finally {
1863 }
1864 return ;
1865 }
1866 // $ANTLR end "entryRuleVLSBinary"
1867
1868
1869 // $ANTLR start "ruleVLSBinary"
1870 // InternalVampireLanguage.g:662:1: ruleVLSBinary : ( ( rule__VLSBinary__Group__0 ) ) ;
1871 public final void ruleVLSBinary() throws RecognitionException {
1872
1873 int stackSize = keepStackSize();
1874
1875 try {
1876 // InternalVampireLanguage.g:666:2: ( ( ( rule__VLSBinary__Group__0 ) ) )
1877 // InternalVampireLanguage.g:667:2: ( ( rule__VLSBinary__Group__0 ) )
1878 {
1879 // InternalVampireLanguage.g:667:2: ( ( rule__VLSBinary__Group__0 ) )
1880 // InternalVampireLanguage.g:668:3: ( rule__VLSBinary__Group__0 )
1881 {
1882 before(grammarAccess.getVLSBinaryAccess().getGroup());
1883 // InternalVampireLanguage.g:669:3: ( rule__VLSBinary__Group__0 )
1884 // InternalVampireLanguage.g:669:4: rule__VLSBinary__Group__0
1885 {
1886 pushFollow(FOLLOW_2);
1887 rule__VLSBinary__Group__0();
1888
1889 state._fsp--;
1890
1891
1892 }
1893
1894 after(grammarAccess.getVLSBinaryAccess().getGroup());
1895
1896 }
1897
1898
1899 }
1900
1901 }
1902 catch (RecognitionException re) {
1903 reportError(re);
1904 recover(input,re);
1905 }
1906 finally {
1907
1908 restoreStackSize(stackSize);
1909
1910 }
1911 return ;
1912 }
1913 // $ANTLR end "ruleVLSBinary"
1914
1915
1916 // $ANTLR start "entryRuleVLSUnitaryFormula"
1917 // InternalVampireLanguage.g:678:1: entryRuleVLSUnitaryFormula : ruleVLSUnitaryFormula EOF ;
1918 public final void entryRuleVLSUnitaryFormula() throws RecognitionException {
1919 try {
1920 // InternalVampireLanguage.g:679:1: ( ruleVLSUnitaryFormula EOF )
1921 // InternalVampireLanguage.g:680:1: ruleVLSUnitaryFormula EOF
1922 {
1923 before(grammarAccess.getVLSUnitaryFormulaRule());
1924 pushFollow(FOLLOW_1);
1925 ruleVLSUnitaryFormula();
1926
1927 state._fsp--;
1928
1929 after(grammarAccess.getVLSUnitaryFormulaRule());
1930 match(input,EOF,FOLLOW_2);
1931
1932 }
1933
1934 }
1935 catch (RecognitionException re) {
1936 reportError(re);
1937 recover(input,re);
1938 }
1939 finally {
1940 }
1941 return ;
1942 }
1943 // $ANTLR end "entryRuleVLSUnitaryFormula"
1944
1945
1946 // $ANTLR start "ruleVLSUnitaryFormula"
1947 // InternalVampireLanguage.g:687:1: ruleVLSUnitaryFormula : ( ( rule__VLSUnitaryFormula__Alternatives ) ) ;
1948 public final void ruleVLSUnitaryFormula() throws RecognitionException {
1949
1950 int stackSize = keepStackSize();
1951
1952 try {
1953 // InternalVampireLanguage.g:691:2: ( ( ( rule__VLSUnitaryFormula__Alternatives ) ) )
1954 // InternalVampireLanguage.g:692:2: ( ( rule__VLSUnitaryFormula__Alternatives ) )
1955 {
1956 // InternalVampireLanguage.g:692:2: ( ( rule__VLSUnitaryFormula__Alternatives ) )
1957 // InternalVampireLanguage.g:693:3: ( rule__VLSUnitaryFormula__Alternatives )
1958 {
1959 before(grammarAccess.getVLSUnitaryFormulaAccess().getAlternatives());
1960 // InternalVampireLanguage.g:694:3: ( rule__VLSUnitaryFormula__Alternatives )
1961 // InternalVampireLanguage.g:694:4: rule__VLSUnitaryFormula__Alternatives
1962 {
1963 pushFollow(FOLLOW_2);
1964 rule__VLSUnitaryFormula__Alternatives();
1965
1966 state._fsp--;
1967
1968
1969 }
1970
1971 after(grammarAccess.getVLSUnitaryFormulaAccess().getAlternatives());
1972
1973 }
1974
1975
1976 }
1977
1978 }
1979 catch (RecognitionException re) {
1980 reportError(re);
1981 recover(input,re);
1982 }
1983 finally {
1984
1985 restoreStackSize(stackSize);
1986
1987 }
1988 return ;
1989 }
1990 // $ANTLR end "ruleVLSUnitaryFormula"
1991
1992
1993 // $ANTLR start "entryRuleVLSUniversalQuantifier"
1994 // InternalVampireLanguage.g:703:1: entryRuleVLSUniversalQuantifier : ruleVLSUniversalQuantifier EOF ;
1995 public final void entryRuleVLSUniversalQuantifier() throws RecognitionException {
1996 try {
1997 // InternalVampireLanguage.g:704:1: ( ruleVLSUniversalQuantifier EOF )
1998 // InternalVampireLanguage.g:705:1: ruleVLSUniversalQuantifier EOF
1999 {
2000 before(grammarAccess.getVLSUniversalQuantifierRule());
2001 pushFollow(FOLLOW_1);
2002 ruleVLSUniversalQuantifier();
2003
2004 state._fsp--;
2005
2006 after(grammarAccess.getVLSUniversalQuantifierRule());
2007 match(input,EOF,FOLLOW_2);
2008
2009 }
2010
2011 }
2012 catch (RecognitionException re) {
2013 reportError(re);
2014 recover(input,re);
2015 }
2016 finally {
2017 }
2018 return ;
2019 }
2020 // $ANTLR end "entryRuleVLSUniversalQuantifier"
2021
2022
2023 // $ANTLR start "ruleVLSUniversalQuantifier"
2024 // InternalVampireLanguage.g:712:1: ruleVLSUniversalQuantifier : ( ( rule__VLSUniversalQuantifier__Group__0 ) ) ;
2025 public final void ruleVLSUniversalQuantifier() throws RecognitionException {
2026
2027 int stackSize = keepStackSize();
2028
2029 try {
2030 // InternalVampireLanguage.g:716:2: ( ( ( rule__VLSUniversalQuantifier__Group__0 ) ) )
2031 // InternalVampireLanguage.g:717:2: ( ( rule__VLSUniversalQuantifier__Group__0 ) )
2032 {
2033 // InternalVampireLanguage.g:717:2: ( ( rule__VLSUniversalQuantifier__Group__0 ) )
2034 // InternalVampireLanguage.g:718:3: ( rule__VLSUniversalQuantifier__Group__0 )
2035 {
2036 before(grammarAccess.getVLSUniversalQuantifierAccess().getGroup());
2037 // InternalVampireLanguage.g:719:3: ( rule__VLSUniversalQuantifier__Group__0 )
2038 // InternalVampireLanguage.g:719:4: rule__VLSUniversalQuantifier__Group__0
2039 {
2040 pushFollow(FOLLOW_2);
2041 rule__VLSUniversalQuantifier__Group__0();
2042
2043 state._fsp--;
2044
2045
2046 }
2047
2048 after(grammarAccess.getVLSUniversalQuantifierAccess().getGroup());
2049
2050 }
2051
2052
2053 }
2054
2055 }
2056 catch (RecognitionException re) {
2057 reportError(re);
2058 recover(input,re);
2059 }
2060 finally {
2061
2062 restoreStackSize(stackSize);
2063
2064 }
2065 return ;
2066 }
2067 // $ANTLR end "ruleVLSUniversalQuantifier"
2068
2069
2070 // $ANTLR start "entryRuleVLSExistentialQuantifier"
2071 // InternalVampireLanguage.g:728:1: entryRuleVLSExistentialQuantifier : ruleVLSExistentialQuantifier EOF ;
2072 public final void entryRuleVLSExistentialQuantifier() throws RecognitionException {
2073 try {
2074 // InternalVampireLanguage.g:729:1: ( ruleVLSExistentialQuantifier EOF )
2075 // InternalVampireLanguage.g:730:1: ruleVLSExistentialQuantifier EOF
2076 {
2077 before(grammarAccess.getVLSExistentialQuantifierRule());
2078 pushFollow(FOLLOW_1);
2079 ruleVLSExistentialQuantifier();
2080
2081 state._fsp--;
2082
2083 after(grammarAccess.getVLSExistentialQuantifierRule());
2084 match(input,EOF,FOLLOW_2);
2085
2086 }
2087
2088 }
2089 catch (RecognitionException re) {
2090 reportError(re);
2091 recover(input,re);
2092 }
2093 finally {
2094 }
2095 return ;
2096 }
2097 // $ANTLR end "entryRuleVLSExistentialQuantifier"
2098
2099
2100 // $ANTLR start "ruleVLSExistentialQuantifier"
2101 // InternalVampireLanguage.g:737:1: ruleVLSExistentialQuantifier : ( ( rule__VLSExistentialQuantifier__Group__0 ) ) ;
2102 public final void ruleVLSExistentialQuantifier() throws RecognitionException {
2103
2104 int stackSize = keepStackSize();
2105
2106 try {
2107 // InternalVampireLanguage.g:741:2: ( ( ( rule__VLSExistentialQuantifier__Group__0 ) ) )
2108 // InternalVampireLanguage.g:742:2: ( ( rule__VLSExistentialQuantifier__Group__0 ) )
2109 {
2110 // InternalVampireLanguage.g:742:2: ( ( rule__VLSExistentialQuantifier__Group__0 ) )
2111 // InternalVampireLanguage.g:743:3: ( rule__VLSExistentialQuantifier__Group__0 )
2112 {
2113 before(grammarAccess.getVLSExistentialQuantifierAccess().getGroup());
2114 // InternalVampireLanguage.g:744:3: ( rule__VLSExistentialQuantifier__Group__0 )
2115 // InternalVampireLanguage.g:744:4: rule__VLSExistentialQuantifier__Group__0
2116 {
2117 pushFollow(FOLLOW_2);
2118 rule__VLSExistentialQuantifier__Group__0();
2119
2120 state._fsp--;
2121
2122
2123 }
2124
2125 after(grammarAccess.getVLSExistentialQuantifierAccess().getGroup());
2126
2127 }
2128
2129
2130 }
2131
2132 }
2133 catch (RecognitionException re) {
2134 reportError(re);
2135 recover(input,re);
2136 }
2137 finally {
2138
2139 restoreStackSize(stackSize);
2140
2141 }
2142 return ;
2143 }
2144 // $ANTLR end "ruleVLSExistentialQuantifier"
2145
2146
2147 // $ANTLR start "entryRuleVLSUnaryNegation"
2148 // InternalVampireLanguage.g:753:1: entryRuleVLSUnaryNegation : ruleVLSUnaryNegation EOF ;
2149 public final void entryRuleVLSUnaryNegation() throws RecognitionException {
2150 try {
2151 // InternalVampireLanguage.g:754:1: ( ruleVLSUnaryNegation EOF )
2152 // InternalVampireLanguage.g:755:1: ruleVLSUnaryNegation EOF
2153 {
2154 before(grammarAccess.getVLSUnaryNegationRule());
2155 pushFollow(FOLLOW_1);
2156 ruleVLSUnaryNegation();
2157
2158 state._fsp--;
2159
2160 after(grammarAccess.getVLSUnaryNegationRule());
2161 match(input,EOF,FOLLOW_2);
2162
2163 }
2164
2165 }
2166 catch (RecognitionException re) {
2167 reportError(re);
2168 recover(input,re);
2169 }
2170 finally {
2171 }
2172 return ;
2173 }
2174 // $ANTLR end "entryRuleVLSUnaryNegation"
2175
2176
2177 // $ANTLR start "ruleVLSUnaryNegation"
2178 // InternalVampireLanguage.g:762:1: ruleVLSUnaryNegation : ( ( rule__VLSUnaryNegation__Group__0 ) ) ;
2179 public final void ruleVLSUnaryNegation() throws RecognitionException {
2180
2181 int stackSize = keepStackSize();
2182
2183 try {
2184 // InternalVampireLanguage.g:766:2: ( ( ( rule__VLSUnaryNegation__Group__0 ) ) )
2185 // InternalVampireLanguage.g:767:2: ( ( rule__VLSUnaryNegation__Group__0 ) )
2186 {
2187 // InternalVampireLanguage.g:767:2: ( ( rule__VLSUnaryNegation__Group__0 ) )
2188 // InternalVampireLanguage.g:768:3: ( rule__VLSUnaryNegation__Group__0 )
2189 {
2190 before(grammarAccess.getVLSUnaryNegationAccess().getGroup());
2191 // InternalVampireLanguage.g:769:3: ( rule__VLSUnaryNegation__Group__0 )
2192 // InternalVampireLanguage.g:769:4: rule__VLSUnaryNegation__Group__0
2193 {
2194 pushFollow(FOLLOW_2);
2195 rule__VLSUnaryNegation__Group__0();
2196
2197 state._fsp--;
2198
2199
2200 }
2201
2202 after(grammarAccess.getVLSUnaryNegationAccess().getGroup());
2203
2204 }
2205
2206
2207 }
2208
2209 }
2210 catch (RecognitionException re) {
2211 reportError(re);
2212 recover(input,re);
2213 }
2214 finally {
2215
2216 restoreStackSize(stackSize);
2217
2218 }
2219 return ;
2220 }
2221 // $ANTLR end "ruleVLSUnaryNegation"
2222
2223
2224 // $ANTLR start "entryRuleVLSUnaryInfix"
2225 // InternalVampireLanguage.g:778:1: entryRuleVLSUnaryInfix : ruleVLSUnaryInfix EOF ;
2226 public final void entryRuleVLSUnaryInfix() throws RecognitionException {
2227 try {
2228 // InternalVampireLanguage.g:779:1: ( ruleVLSUnaryInfix EOF )
2229 // InternalVampireLanguage.g:780:1: ruleVLSUnaryInfix EOF
2230 {
2231 before(grammarAccess.getVLSUnaryInfixRule());
2232 pushFollow(FOLLOW_1);
2233 ruleVLSUnaryInfix();
2234
2235 state._fsp--;
2236
2237 after(grammarAccess.getVLSUnaryInfixRule());
2238 match(input,EOF,FOLLOW_2);
2239
2240 }
2241
2242 }
2243 catch (RecognitionException re) {
2244 reportError(re);
2245 recover(input,re);
2246 }
2247 finally {
2248 }
2249 return ;
2250 }
2251 // $ANTLR end "entryRuleVLSUnaryInfix"
2252
2253
2254 // $ANTLR start "ruleVLSUnaryInfix"
2255 // InternalVampireLanguage.g:787:1: ruleVLSUnaryInfix : ( ( rule__VLSUnaryInfix__Group__0 ) ) ;
2256 public final void ruleVLSUnaryInfix() throws RecognitionException {
2257
2258 int stackSize = keepStackSize();
2259
2260 try {
2261 // InternalVampireLanguage.g:791:2: ( ( ( rule__VLSUnaryInfix__Group__0 ) ) )
2262 // InternalVampireLanguage.g:792:2: ( ( rule__VLSUnaryInfix__Group__0 ) )
2263 {
2264 // InternalVampireLanguage.g:792:2: ( ( rule__VLSUnaryInfix__Group__0 ) )
2265 // InternalVampireLanguage.g:793:3: ( rule__VLSUnaryInfix__Group__0 )
2266 {
2267 before(grammarAccess.getVLSUnaryInfixAccess().getGroup());
2268 // InternalVampireLanguage.g:794:3: ( rule__VLSUnaryInfix__Group__0 )
2269 // InternalVampireLanguage.g:794:4: rule__VLSUnaryInfix__Group__0
2270 {
2271 pushFollow(FOLLOW_2);
2272 rule__VLSUnaryInfix__Group__0();
2273
2274 state._fsp--;
2275
2276
2277 }
2278
2279 after(grammarAccess.getVLSUnaryInfixAccess().getGroup());
2280
2281 }
2282
2283
2284 }
2285
2286 }
2287 catch (RecognitionException re) {
2288 reportError(re);
2289 recover(input,re);
2290 }
2291 finally {
2292
2293 restoreStackSize(stackSize);
2294
2295 }
2296 return ;
2297 }
2298 // $ANTLR end "ruleVLSUnaryInfix"
2299
2300
2301 // $ANTLR start "entryRuleVLSAtomic"
2302 // InternalVampireLanguage.g:803:1: entryRuleVLSAtomic : ruleVLSAtomic EOF ;
2303 public final void entryRuleVLSAtomic() throws RecognitionException {
2304 try {
2305 // InternalVampireLanguage.g:804:1: ( ruleVLSAtomic EOF )
2306 // InternalVampireLanguage.g:805:1: ruleVLSAtomic EOF
2307 {
2308 before(grammarAccess.getVLSAtomicRule());
2309 pushFollow(FOLLOW_1);
2310 ruleVLSAtomic();
2311
2312 state._fsp--;
2313
2314 after(grammarAccess.getVLSAtomicRule());
2315 match(input,EOF,FOLLOW_2);
2316
2317 }
2318
2319 }
2320 catch (RecognitionException re) {
2321 reportError(re);
2322 recover(input,re);
2323 }
2324 finally {
2325 }
2326 return ;
2327 }
2328 // $ANTLR end "entryRuleVLSAtomic"
2329
2330
2331 // $ANTLR start "ruleVLSAtomic"
2332 // InternalVampireLanguage.g:812:1: ruleVLSAtomic : ( ( rule__VLSAtomic__Alternatives ) ) ;
2333 public final void ruleVLSAtomic() throws RecognitionException {
2334
2335 int stackSize = keepStackSize();
2336
2337 try {
2338 // InternalVampireLanguage.g:816:2: ( ( ( rule__VLSAtomic__Alternatives ) ) )
2339 // InternalVampireLanguage.g:817:2: ( ( rule__VLSAtomic__Alternatives ) )
2340 {
2341 // InternalVampireLanguage.g:817:2: ( ( rule__VLSAtomic__Alternatives ) )
2342 // InternalVampireLanguage.g:818:3: ( rule__VLSAtomic__Alternatives )
2343 {
2344 before(grammarAccess.getVLSAtomicAccess().getAlternatives());
2345 // InternalVampireLanguage.g:819:3: ( rule__VLSAtomic__Alternatives )
2346 // InternalVampireLanguage.g:819:4: rule__VLSAtomic__Alternatives
2347 {
2348 pushFollow(FOLLOW_2);
2349 rule__VLSAtomic__Alternatives();
2350
2351 state._fsp--;
2352
2353
2354 }
2355
2356 after(grammarAccess.getVLSAtomicAccess().getAlternatives());
2357
2358 }
2359
2360
2361 }
2362
2363 }
2364 catch (RecognitionException re) {
2365 reportError(re);
2366 recover(input,re);
2367 }
2368 finally {
2369
2370 restoreStackSize(stackSize);
2371
2372 }
2373 return ;
2374 }
2375 // $ANTLR end "ruleVLSAtomic"
2376
2377
2378 // $ANTLR start "entryRuleVLSAtomicConstant"
2379 // InternalVampireLanguage.g:828:1: entryRuleVLSAtomicConstant : ruleVLSAtomicConstant EOF ;
2380 public final void entryRuleVLSAtomicConstant() throws RecognitionException {
2381 try {
2382 // InternalVampireLanguage.g:829:1: ( ruleVLSAtomicConstant EOF )
2383 // InternalVampireLanguage.g:830:1: ruleVLSAtomicConstant EOF
2384 {
2385 before(grammarAccess.getVLSAtomicConstantRule());
2386 pushFollow(FOLLOW_1);
2387 ruleVLSAtomicConstant();
2388
2389 state._fsp--;
2390
2391 after(grammarAccess.getVLSAtomicConstantRule());
2392 match(input,EOF,FOLLOW_2);
2393
2394 }
2395
2396 }
2397 catch (RecognitionException re) {
2398 reportError(re);
2399 recover(input,re);
2400 }
2401 finally {
2402 }
2403 return ;
2404 }
2405 // $ANTLR end "entryRuleVLSAtomicConstant"
2406
2407
2408 // $ANTLR start "ruleVLSAtomicConstant"
2409 // InternalVampireLanguage.g:837:1: ruleVLSAtomicConstant : ( ( rule__VLSAtomicConstant__Alternatives ) ) ;
2410 public final void ruleVLSAtomicConstant() throws RecognitionException {
2411
2412 int stackSize = keepStackSize();
2413
2414 try {
2415 // InternalVampireLanguage.g:841:2: ( ( ( rule__VLSAtomicConstant__Alternatives ) ) )
2416 // InternalVampireLanguage.g:842:2: ( ( rule__VLSAtomicConstant__Alternatives ) )
2417 {
2418 // InternalVampireLanguage.g:842:2: ( ( rule__VLSAtomicConstant__Alternatives ) )
2419 // InternalVampireLanguage.g:843:3: ( rule__VLSAtomicConstant__Alternatives )
2420 {
2421 before(grammarAccess.getVLSAtomicConstantAccess().getAlternatives());
2422 // InternalVampireLanguage.g:844:3: ( rule__VLSAtomicConstant__Alternatives )
2423 // InternalVampireLanguage.g:844:4: rule__VLSAtomicConstant__Alternatives
2424 {
2425 pushFollow(FOLLOW_2);
2426 rule__VLSAtomicConstant__Alternatives();
2427
2428 state._fsp--;
2429
2430
2431 }
2432
2433 after(grammarAccess.getVLSAtomicConstantAccess().getAlternatives());
2434
2435 }
2436
2437
2438 }
2439
2440 }
2441 catch (RecognitionException re) {
2442 reportError(re);
2443 recover(input,re);
2444 }
2445 finally {
2446
2447 restoreStackSize(stackSize);
2448
2449 }
2450 return ;
2451 }
2452 // $ANTLR end "ruleVLSAtomicConstant"
2453
2454
2455 // $ANTLR start "entryRuleVLSAtomicFunction"
2456 // InternalVampireLanguage.g:853:1: entryRuleVLSAtomicFunction : ruleVLSAtomicFunction EOF ;
2457 public final void entryRuleVLSAtomicFunction() throws RecognitionException {
2458 try {
2459 // InternalVampireLanguage.g:854:1: ( ruleVLSAtomicFunction EOF )
2460 // InternalVampireLanguage.g:855:1: ruleVLSAtomicFunction EOF
2461 {
2462 before(grammarAccess.getVLSAtomicFunctionRule());
2463 pushFollow(FOLLOW_1);
2464 ruleVLSAtomicFunction();
2465
2466 state._fsp--;
2467
2468 after(grammarAccess.getVLSAtomicFunctionRule());
2469 match(input,EOF,FOLLOW_2);
2470
2471 }
2472
2473 }
2474 catch (RecognitionException re) {
2475 reportError(re);
2476 recover(input,re);
2477 }
2478 finally {
2479 }
2480 return ;
2481 }
2482 // $ANTLR end "entryRuleVLSAtomicFunction"
2483
2484
2485 // $ANTLR start "ruleVLSAtomicFunction"
2486 // InternalVampireLanguage.g:862:1: ruleVLSAtomicFunction : ( ( rule__VLSAtomicFunction__Alternatives ) ) ;
2487 public final void ruleVLSAtomicFunction() throws RecognitionException {
2488
2489 int stackSize = keepStackSize();
2490
2491 try {
2492 // InternalVampireLanguage.g:866:2: ( ( ( rule__VLSAtomicFunction__Alternatives ) ) )
2493 // InternalVampireLanguage.g:867:2: ( ( rule__VLSAtomicFunction__Alternatives ) )
2494 {
2495 // InternalVampireLanguage.g:867:2: ( ( rule__VLSAtomicFunction__Alternatives ) )
2496 // InternalVampireLanguage.g:868:3: ( rule__VLSAtomicFunction__Alternatives )
2497 {
2498 before(grammarAccess.getVLSAtomicFunctionAccess().getAlternatives());
2499 // InternalVampireLanguage.g:869:3: ( rule__VLSAtomicFunction__Alternatives )
2500 // InternalVampireLanguage.g:869:4: rule__VLSAtomicFunction__Alternatives
2501 {
2502 pushFollow(FOLLOW_2);
2503 rule__VLSAtomicFunction__Alternatives();
2504
2505 state._fsp--;
2506
2507
2508 }
2509
2510 after(grammarAccess.getVLSAtomicFunctionAccess().getAlternatives());
2511
2512 }
2513
2514
2515 }
2516
2517 }
2518 catch (RecognitionException re) {
2519 reportError(re);
2520 recover(input,re);
2521 }
2522 finally {
2523
2524 restoreStackSize(stackSize);
2525
2526 }
2527 return ;
2528 }
2529 // $ANTLR end "ruleVLSAtomicFunction"
2530
2531
2532 // $ANTLR start "entryRuleVLSVariable"
2533 // InternalVampireLanguage.g:878:1: entryRuleVLSVariable : ruleVLSVariable EOF ;
2534 public final void entryRuleVLSVariable() throws RecognitionException {
2535 try {
2536 // InternalVampireLanguage.g:879:1: ( ruleVLSVariable EOF )
2537 // InternalVampireLanguage.g:880:1: ruleVLSVariable EOF
2538 {
2539 before(grammarAccess.getVLSVariableRule());
2540 pushFollow(FOLLOW_1);
2541 ruleVLSVariable();
2542
2543 state._fsp--;
2544
2545 after(grammarAccess.getVLSVariableRule());
2546 match(input,EOF,FOLLOW_2);
2547
2548 }
2549
2550 }
2551 catch (RecognitionException re) {
2552 reportError(re);
2553 recover(input,re);
2554 }
2555 finally {
2556 }
2557 return ;
2558 }
2559 // $ANTLR end "entryRuleVLSVariable"
2560
2561
2562 // $ANTLR start "ruleVLSVariable"
2563 // InternalVampireLanguage.g:887:1: ruleVLSVariable : ( ( rule__VLSVariable__NameAssignment ) ) ;
2564 public final void ruleVLSVariable() throws RecognitionException {
2565
2566 int stackSize = keepStackSize();
2567
2568 try {
2569 // InternalVampireLanguage.g:891:2: ( ( ( rule__VLSVariable__NameAssignment ) ) )
2570 // InternalVampireLanguage.g:892:2: ( ( rule__VLSVariable__NameAssignment ) )
2571 {
2572 // InternalVampireLanguage.g:892:2: ( ( rule__VLSVariable__NameAssignment ) )
2573 // InternalVampireLanguage.g:893:3: ( rule__VLSVariable__NameAssignment )
2574 {
2575 before(grammarAccess.getVLSVariableAccess().getNameAssignment());
2576 // InternalVampireLanguage.g:894:3: ( rule__VLSVariable__NameAssignment )
2577 // InternalVampireLanguage.g:894:4: rule__VLSVariable__NameAssignment
2578 {
2579 pushFollow(FOLLOW_2);
2580 rule__VLSVariable__NameAssignment();
2581
2582 state._fsp--;
2583
2584
2585 }
2586
2587 after(grammarAccess.getVLSVariableAccess().getNameAssignment());
2588
2589 }
2590
2591
2592 }
2593
2594 }
2595 catch (RecognitionException re) {
2596 reportError(re);
2597 recover(input,re);
2598 }
2599 finally {
2600
2601 restoreStackSize(stackSize);
2602
2603 }
2604 return ;
2605 }
2606 // $ANTLR end "ruleVLSVariable"
2607
2608
2609 // $ANTLR start "entryRuleVLSFofTerm"
2610 // InternalVampireLanguage.g:903:1: entryRuleVLSFofTerm : ruleVLSFofTerm EOF ;
2611 public final void entryRuleVLSFofTerm() throws RecognitionException {
2612 try {
2613 // InternalVampireLanguage.g:904:1: ( ruleVLSFofTerm EOF )
2614 // InternalVampireLanguage.g:905:1: ruleVLSFofTerm EOF
2615 {
2616 before(grammarAccess.getVLSFofTermRule());
2617 pushFollow(FOLLOW_1);
2618 ruleVLSFofTerm();
2619
2620 state._fsp--;
2621
2622 after(grammarAccess.getVLSFofTermRule());
2623 match(input,EOF,FOLLOW_2);
2624
2625 }
2626
2627 }
2628 catch (RecognitionException re) {
2629 reportError(re);
2630 recover(input,re);
2631 }
2632 finally {
2633 }
2634 return ;
2635 }
2636 // $ANTLR end "entryRuleVLSFofTerm"
2637
2638
2639 // $ANTLR start "ruleVLSFofTerm"
2640 // InternalVampireLanguage.g:912:1: ruleVLSFofTerm : ( ( rule__VLSFofTerm__Alternatives ) ) ;
2641 public final void ruleVLSFofTerm() throws RecognitionException {
2642
2643 int stackSize = keepStackSize();
2644
2645 try {
2646 // InternalVampireLanguage.g:916:2: ( ( ( rule__VLSFofTerm__Alternatives ) ) )
2647 // InternalVampireLanguage.g:917:2: ( ( rule__VLSFofTerm__Alternatives ) )
2648 {
2649 // InternalVampireLanguage.g:917:2: ( ( rule__VLSFofTerm__Alternatives ) )
2650 // InternalVampireLanguage.g:918:3: ( rule__VLSFofTerm__Alternatives )
2651 {
2652 before(grammarAccess.getVLSFofTermAccess().getAlternatives());
2653 // InternalVampireLanguage.g:919:3: ( rule__VLSFofTerm__Alternatives )
2654 // InternalVampireLanguage.g:919:4: rule__VLSFofTerm__Alternatives
2655 {
2656 pushFollow(FOLLOW_2);
2657 rule__VLSFofTerm__Alternatives();
2658
2659 state._fsp--;
2660
2661
2662 }
2663
2664 after(grammarAccess.getVLSFofTermAccess().getAlternatives());
2665
2666 }
2667
2668
2669 }
2670
2671 }
2672 catch (RecognitionException re) {
2673 reportError(re);
2674 recover(input,re);
2675 }
2676 finally {
2677
2678 restoreStackSize(stackSize);
2679
2680 }
2681 return ;
2682 }
2683 // $ANTLR end "ruleVLSFofTerm"
2684
2685
2686 // $ANTLR start "entryRuleVLSFunctionFof"
2687 // InternalVampireLanguage.g:928:1: entryRuleVLSFunctionFof : ruleVLSFunctionFof EOF ;
2688 public final void entryRuleVLSFunctionFof() throws RecognitionException {
2689 try {
2690 // InternalVampireLanguage.g:929:1: ( ruleVLSFunctionFof EOF )
2691 // InternalVampireLanguage.g:930:1: ruleVLSFunctionFof EOF
2692 {
2693 before(grammarAccess.getVLSFunctionFofRule());
2694 pushFollow(FOLLOW_1);
2695 ruleVLSFunctionFof();
2696
2697 state._fsp--;
2698
2699 after(grammarAccess.getVLSFunctionFofRule());
2700 match(input,EOF,FOLLOW_2);
2701
2702 }
2703
2704 }
2705 catch (RecognitionException re) {
2706 reportError(re);
2707 recover(input,re);
2708 }
2709 finally {
2710 }
2711 return ;
2712 }
2713 // $ANTLR end "entryRuleVLSFunctionFof"
2714
2715
2716 // $ANTLR start "ruleVLSFunctionFof"
2717 // InternalVampireLanguage.g:937:1: ruleVLSFunctionFof : ( ( rule__VLSFunctionFof__Group__0 ) ) ;
2718 public final void ruleVLSFunctionFof() throws RecognitionException {
2719
2720 int stackSize = keepStackSize();
2721
2722 try {
2723 // InternalVampireLanguage.g:941:2: ( ( ( rule__VLSFunctionFof__Group__0 ) ) )
2724 // InternalVampireLanguage.g:942:2: ( ( rule__VLSFunctionFof__Group__0 ) )
2725 {
2726 // InternalVampireLanguage.g:942:2: ( ( rule__VLSFunctionFof__Group__0 ) )
2727 // InternalVampireLanguage.g:943:3: ( rule__VLSFunctionFof__Group__0 )
2728 {
2729 before(grammarAccess.getVLSFunctionFofAccess().getGroup());
2730 // InternalVampireLanguage.g:944:3: ( rule__VLSFunctionFof__Group__0 )
2731 // InternalVampireLanguage.g:944:4: rule__VLSFunctionFof__Group__0
2732 {
2733 pushFollow(FOLLOW_2);
2734 rule__VLSFunctionFof__Group__0();
2735
2736 state._fsp--;
2737
2738
2739 }
2740
2741 after(grammarAccess.getVLSFunctionFofAccess().getGroup());
2742
2743 }
2744
2745
2746 }
2747
2748 }
2749 catch (RecognitionException re) {
2750 reportError(re);
2751 recover(input,re);
2752 }
2753 finally {
2754
2755 restoreStackSize(stackSize);
2756
2757 }
2758 return ;
2759 }
2760 // $ANTLR end "ruleVLSFunctionFof"
2761
2762
2763 // $ANTLR start "entryRuleVLSDefinedTerm"
2764 // InternalVampireLanguage.g:953:1: entryRuleVLSDefinedTerm : ruleVLSDefinedTerm EOF ;
2765 public final void entryRuleVLSDefinedTerm() throws RecognitionException {
2766 try {
2767 // InternalVampireLanguage.g:954:1: ( ruleVLSDefinedTerm EOF )
2768 // InternalVampireLanguage.g:955:1: ruleVLSDefinedTerm EOF
2769 {
2770 before(grammarAccess.getVLSDefinedTermRule());
2771 pushFollow(FOLLOW_1);
2772 ruleVLSDefinedTerm();
2773
2774 state._fsp--;
2775
2776 after(grammarAccess.getVLSDefinedTermRule());
2777 match(input,EOF,FOLLOW_2);
2778
2779 }
2780
2781 }
2782 catch (RecognitionException re) {
2783 reportError(re);
2784 recover(input,re);
2785 }
2786 finally {
2787 }
2788 return ;
2789 }
2790 // $ANTLR end "entryRuleVLSDefinedTerm"
2791
2792
2793 // $ANTLR start "ruleVLSDefinedTerm"
2794 // InternalVampireLanguage.g:962:1: ruleVLSDefinedTerm : ( ( rule__VLSDefinedTerm__Alternatives ) ) ;
2795 public final void ruleVLSDefinedTerm() throws RecognitionException {
2796
2797 int stackSize = keepStackSize();
2798
2799 try {
2800 // InternalVampireLanguage.g:966:2: ( ( ( rule__VLSDefinedTerm__Alternatives ) ) )
2801 // InternalVampireLanguage.g:967:2: ( ( rule__VLSDefinedTerm__Alternatives ) )
2802 {
2803 // InternalVampireLanguage.g:967:2: ( ( rule__VLSDefinedTerm__Alternatives ) )
2804 // InternalVampireLanguage.g:968:3: ( rule__VLSDefinedTerm__Alternatives )
2805 {
2806 before(grammarAccess.getVLSDefinedTermAccess().getAlternatives());
2807 // InternalVampireLanguage.g:969:3: ( rule__VLSDefinedTerm__Alternatives )
2808 // InternalVampireLanguage.g:969:4: rule__VLSDefinedTerm__Alternatives
2809 {
2810 pushFollow(FOLLOW_2);
2811 rule__VLSDefinedTerm__Alternatives();
2812
2813 state._fsp--;
2814
2815
2816 }
2817
2818 after(grammarAccess.getVLSDefinedTermAccess().getAlternatives());
2819
2820 }
2821
2822
2823 }
2824
2825 }
2826 catch (RecognitionException re) {
2827 reportError(re);
2828 recover(input,re);
2829 }
2830 finally {
2831
2832 restoreStackSize(stackSize);
2833
2834 }
2835 return ;
2836 }
2837 // $ANTLR end "ruleVLSDefinedTerm"
2838
2839
2840 // $ANTLR start "rule__VampireModel__Alternatives"
2841 // InternalVampireLanguage.g:977:1: rule__VampireModel__Alternatives : ( ( ( rule__VampireModel__IncludesAssignment_0 ) ) | ( ( rule__VampireModel__CommentsAssignment_1 ) ) | ( ( rule__VampireModel__FormulasAssignment_2 ) ) );
2842 public final void rule__VampireModel__Alternatives() throws RecognitionException {
2843
2844 int stackSize = keepStackSize();
2845
2846 try {
2847 // InternalVampireLanguage.g:981:1: ( ( ( rule__VampireModel__IncludesAssignment_0 ) ) | ( ( rule__VampireModel__CommentsAssignment_1 ) ) | ( ( rule__VampireModel__FormulasAssignment_2 ) ) )
2848 int alt2=3;
2849 switch ( input.LA(1) ) {
2850 case 42:
2851 {
2852 alt2=1;
2853 }
2854 break;
2855 case RULE_SINGLE_COMMENT:
2856 {
2857 alt2=2;
2858 }
2859 break;
2860 case 46:
2861 {
2862 alt2=3;
2863 }
2864 break;
2865 default:
2866 NoViableAltException nvae =
2867 new NoViableAltException("", 2, 0, input);
2868
2869 throw nvae;
2870 }
2871
2872 switch (alt2) {
2873 case 1 :
2874 // InternalVampireLanguage.g:982:2: ( ( rule__VampireModel__IncludesAssignment_0 ) )
2875 {
2876 // InternalVampireLanguage.g:982:2: ( ( rule__VampireModel__IncludesAssignment_0 ) )
2877 // InternalVampireLanguage.g:983:3: ( rule__VampireModel__IncludesAssignment_0 )
2878 {
2879 before(grammarAccess.getVampireModelAccess().getIncludesAssignment_0());
2880 // InternalVampireLanguage.g:984:3: ( rule__VampireModel__IncludesAssignment_0 )
2881 // InternalVampireLanguage.g:984:4: rule__VampireModel__IncludesAssignment_0
2882 {
2883 pushFollow(FOLLOW_2);
2884 rule__VampireModel__IncludesAssignment_0();
2885
2886 state._fsp--;
2887
2888
2889 }
2890
2891 after(grammarAccess.getVampireModelAccess().getIncludesAssignment_0());
2892
2893 }
2894
2895
2896 }
2897 break;
2898 case 2 :
2899 // InternalVampireLanguage.g:988:2: ( ( rule__VampireModel__CommentsAssignment_1 ) )
2900 {
2901 // InternalVampireLanguage.g:988:2: ( ( rule__VampireModel__CommentsAssignment_1 ) )
2902 // InternalVampireLanguage.g:989:3: ( rule__VampireModel__CommentsAssignment_1 )
2903 {
2904 before(grammarAccess.getVampireModelAccess().getCommentsAssignment_1());
2905 // InternalVampireLanguage.g:990:3: ( rule__VampireModel__CommentsAssignment_1 )
2906 // InternalVampireLanguage.g:990:4: rule__VampireModel__CommentsAssignment_1
2907 {
2908 pushFollow(FOLLOW_2);
2909 rule__VampireModel__CommentsAssignment_1();
2910
2911 state._fsp--;
2912
2913
2914 }
2915
2916 after(grammarAccess.getVampireModelAccess().getCommentsAssignment_1());
2917
2918 }
2919
2920
2921 }
2922 break;
2923 case 3 :
2924 // InternalVampireLanguage.g:994:2: ( ( rule__VampireModel__FormulasAssignment_2 ) )
2925 {
2926 // InternalVampireLanguage.g:994:2: ( ( rule__VampireModel__FormulasAssignment_2 ) )
2927 // InternalVampireLanguage.g:995:3: ( rule__VampireModel__FormulasAssignment_2 )
2928 {
2929 before(grammarAccess.getVampireModelAccess().getFormulasAssignment_2());
2930 // InternalVampireLanguage.g:996:3: ( rule__VampireModel__FormulasAssignment_2 )
2931 // InternalVampireLanguage.g:996:4: rule__VampireModel__FormulasAssignment_2
2932 {
2933 pushFollow(FOLLOW_2);
2934 rule__VampireModel__FormulasAssignment_2();
2935
2936 state._fsp--;
2937
2938
2939 }
2940
2941 after(grammarAccess.getVampireModelAccess().getFormulasAssignment_2());
2942
2943 }
2944
2945
2946 }
2947 break;
2948
2949 }
2950 }
2951 catch (RecognitionException re) {
2952 reportError(re);
2953 recover(input,re);
2954 }
2955 finally {
2956
2957 restoreStackSize(stackSize);
2958
2959 }
2960 return ;
2961 }
2962 // $ANTLR end "rule__VampireModel__Alternatives"
2963
2964
2965 // $ANTLR start "rule__VLSName__NameAlternatives_0"
2966 // InternalVampireLanguage.g:1004:1: rule__VLSName__NameAlternatives_0 : ( ( RULE_LOWER_WORD_ID ) | ( RULE_SINGLE_QUOTE ) | ( RULE_LITERAL ) | ( RULE_SIGNED_LITERAL ) );
2967 public final void rule__VLSName__NameAlternatives_0() throws RecognitionException {
2968
2969 int stackSize = keepStackSize();
2970
2971 try {
2972 // InternalVampireLanguage.g:1008:1: ( ( RULE_LOWER_WORD_ID ) | ( RULE_SINGLE_QUOTE ) | ( RULE_LITERAL ) | ( RULE_SIGNED_LITERAL ) )
2973 int alt3=4;
2974 switch ( input.LA(1) ) {
2975 case RULE_LOWER_WORD_ID:
2976 {
2977 alt3=1;
2978 }
2979 break;
2980 case RULE_SINGLE_QUOTE:
2981 {
2982 alt3=2;
2983 }
2984 break;
2985 case RULE_LITERAL:
2986 {
2987 alt3=3;
2988 }
2989 break;
2990 case RULE_SIGNED_LITERAL:
2991 {
2992 alt3=4;
2993 }
2994 break;
2995 default:
2996 NoViableAltException nvae =
2997 new NoViableAltException("", 3, 0, input);
2998
2999 throw nvae;
3000 }
3001
3002 switch (alt3) {
3003 case 1 :
3004 // InternalVampireLanguage.g:1009:2: ( RULE_LOWER_WORD_ID )
3005 {
3006 // InternalVampireLanguage.g:1009:2: ( RULE_LOWER_WORD_ID )
3007 // InternalVampireLanguage.g:1010:3: RULE_LOWER_WORD_ID
3008 {
3009 before(grammarAccess.getVLSNameAccess().getNameLOWER_WORD_IDTerminalRuleCall_0_0());
3010 match(input,RULE_LOWER_WORD_ID,FOLLOW_2);
3011 after(grammarAccess.getVLSNameAccess().getNameLOWER_WORD_IDTerminalRuleCall_0_0());
3012
3013 }
3014
3015
3016 }
3017 break;
3018 case 2 :
3019 // InternalVampireLanguage.g:1015:2: ( RULE_SINGLE_QUOTE )
3020 {
3021 // InternalVampireLanguage.g:1015:2: ( RULE_SINGLE_QUOTE )
3022 // InternalVampireLanguage.g:1016:3: RULE_SINGLE_QUOTE
3023 {
3024 before(grammarAccess.getVLSNameAccess().getNameSINGLE_QUOTETerminalRuleCall_0_1());
3025 match(input,RULE_SINGLE_QUOTE,FOLLOW_2);
3026 after(grammarAccess.getVLSNameAccess().getNameSINGLE_QUOTETerminalRuleCall_0_1());
3027
3028 }
3029
3030
3031 }
3032 break;
3033 case 3 :
3034 // InternalVampireLanguage.g:1021:2: ( RULE_LITERAL )
3035 {
3036 // InternalVampireLanguage.g:1021:2: ( RULE_LITERAL )
3037 // InternalVampireLanguage.g:1022:3: RULE_LITERAL
3038 {
3039 before(grammarAccess.getVLSNameAccess().getNameLITERALTerminalRuleCall_0_2());
3040 match(input,RULE_LITERAL,FOLLOW_2);
3041 after(grammarAccess.getVLSNameAccess().getNameLITERALTerminalRuleCall_0_2());
3042
3043 }
3044
3045
3046 }
3047 break;
3048 case 4 :
3049 // InternalVampireLanguage.g:1027:2: ( RULE_SIGNED_LITERAL )
3050 {
3051 // InternalVampireLanguage.g:1027:2: ( RULE_SIGNED_LITERAL )
3052 // InternalVampireLanguage.g:1028:3: RULE_SIGNED_LITERAL
3053 {
3054 before(grammarAccess.getVLSNameAccess().getNameSIGNED_LITERALTerminalRuleCall_0_3());
3055 match(input,RULE_SIGNED_LITERAL,FOLLOW_2);
3056 after(grammarAccess.getVLSNameAccess().getNameSIGNED_LITERALTerminalRuleCall_0_3());
3057
3058 }
3059
3060
3061 }
3062 break;
3063
3064 }
3065 }
3066 catch (RecognitionException re) {
3067 reportError(re);
3068 recover(input,re);
3069 }
3070 finally {
3071
3072 restoreStackSize(stackSize);
3073
3074 }
3075 return ;
3076 }
3077 // $ANTLR end "rule__VLSName__NameAlternatives_0"
3078
3079
3080 // $ANTLR start "rule__VLSFofFormula__NameAlternatives_2_0"
3081 // InternalVampireLanguage.g:1037:1: rule__VLSFofFormula__NameAlternatives_2_0 : ( ( RULE_LOWER_WORD_ID ) | ( RULE_SIGNED_LITERAL ) | ( RULE_SINGLE_QUOTE ) );
3082 public final void rule__VLSFofFormula__NameAlternatives_2_0() throws RecognitionException {
3083
3084 int stackSize = keepStackSize();
3085
3086 try {
3087 // InternalVampireLanguage.g:1041:1: ( ( RULE_LOWER_WORD_ID ) | ( RULE_SIGNED_LITERAL ) | ( RULE_SINGLE_QUOTE ) )
3088 int alt4=3;
3089 switch ( input.LA(1) ) {
3090 case RULE_LOWER_WORD_ID:
3091 {
3092 alt4=1;
3093 }
3094 break;
3095 case RULE_SIGNED_LITERAL:
3096 {
3097 alt4=2;
3098 }
3099 break;
3100 case RULE_SINGLE_QUOTE:
3101 {
3102 alt4=3;
3103 }
3104 break;
3105 default:
3106 NoViableAltException nvae =
3107 new NoViableAltException("", 4, 0, input);
3108
3109 throw nvae;
3110 }
3111
3112 switch (alt4) {
3113 case 1 :
3114 // InternalVampireLanguage.g:1042:2: ( RULE_LOWER_WORD_ID )
3115 {
3116 // InternalVampireLanguage.g:1042:2: ( RULE_LOWER_WORD_ID )
3117 // InternalVampireLanguage.g:1043:3: RULE_LOWER_WORD_ID
3118 {
3119 before(grammarAccess.getVLSFofFormulaAccess().getNameLOWER_WORD_IDTerminalRuleCall_2_0_0());
3120 match(input,RULE_LOWER_WORD_ID,FOLLOW_2);
3121 after(grammarAccess.getVLSFofFormulaAccess().getNameLOWER_WORD_IDTerminalRuleCall_2_0_0());
3122
3123 }
3124
3125
3126 }
3127 break;
3128 case 2 :
3129 // InternalVampireLanguage.g:1048:2: ( RULE_SIGNED_LITERAL )
3130 {
3131 // InternalVampireLanguage.g:1048:2: ( RULE_SIGNED_LITERAL )
3132 // InternalVampireLanguage.g:1049:3: RULE_SIGNED_LITERAL
3133 {
3134 before(grammarAccess.getVLSFofFormulaAccess().getNameSIGNED_LITERALTerminalRuleCall_2_0_1());
3135 match(input,RULE_SIGNED_LITERAL,FOLLOW_2);
3136 after(grammarAccess.getVLSFofFormulaAccess().getNameSIGNED_LITERALTerminalRuleCall_2_0_1());
3137
3138 }
3139
3140
3141 }
3142 break;
3143 case 3 :
3144 // InternalVampireLanguage.g:1054:2: ( RULE_SINGLE_QUOTE )
3145 {
3146 // InternalVampireLanguage.g:1054:2: ( RULE_SINGLE_QUOTE )
3147 // InternalVampireLanguage.g:1055:3: RULE_SINGLE_QUOTE
3148 {
3149 before(grammarAccess.getVLSFofFormulaAccess().getNameSINGLE_QUOTETerminalRuleCall_2_0_2());
3150 match(input,RULE_SINGLE_QUOTE,FOLLOW_2);
3151 after(grammarAccess.getVLSFofFormulaAccess().getNameSINGLE_QUOTETerminalRuleCall_2_0_2());
3152
3153 }
3154
3155
3156 }
3157 break;
3158
3159 }
3160 }
3161 catch (RecognitionException re) {
3162 reportError(re);
3163 recover(input,re);
3164 }
3165 finally {
3166
3167 restoreStackSize(stackSize);
3168
3169 }
3170 return ;
3171 }
3172 // $ANTLR end "rule__VLSFofFormula__NameAlternatives_2_0"
3173
3174
3175 // $ANTLR start "rule__VLSRole__Alternatives"
3176 // InternalVampireLanguage.g:1064:1: rule__VLSRole__Alternatives : ( ( ruleVLSAxiom ) | ( ruleVLSConjecture ) | ( ruleVLSHypothesis ) | ( ruleVLSDefinition ) | ( ruleVLSAssumption ) | ( ruleVLSLemma ) | ( ruleVLSTheorem ) | ( ruleVLSCorollary ) | ( ruleVLSNegated_Conjecture ) | ( ruleVLSPlain ) | ( ruleVLSType ) | ( ruleVLSFi_Domain ) | ( ruleVLSFi_Functors ) | ( ruleVLSFi_Predicates ) | ( ruleVLSUnknown ) );
3177 public final void rule__VLSRole__Alternatives() throws RecognitionException {
3178
3179 int stackSize = keepStackSize();
3180
3181 try {
3182 // InternalVampireLanguage.g:1068:1: ( ( ruleVLSAxiom ) | ( ruleVLSConjecture ) | ( ruleVLSHypothesis ) | ( ruleVLSDefinition ) | ( ruleVLSAssumption ) | ( ruleVLSLemma ) | ( ruleVLSTheorem ) | ( ruleVLSCorollary ) | ( ruleVLSNegated_Conjecture ) | ( ruleVLSPlain ) | ( ruleVLSType ) | ( ruleVLSFi_Domain ) | ( ruleVLSFi_Functors ) | ( ruleVLSFi_Predicates ) | ( ruleVLSUnknown ) )
3183 int alt5=15;
3184 switch ( input.LA(1) ) {
3185 case 27:
3186 {
3187 alt5=1;
3188 }
3189 break;
3190 case 28:
3191 {
3192 alt5=2;
3193 }
3194 break;
3195 case 29:
3196 {
3197 alt5=3;
3198 }
3199 break;
3200 case 30:
3201 {
3202 alt5=4;
3203 }
3204 break;
3205 case 31:
3206 {
3207 alt5=5;
3208 }
3209 break;
3210 case 32:
3211 {
3212 alt5=6;
3213 }
3214 break;
3215 case 33:
3216 {
3217 alt5=7;
3218 }
3219 break;
3220 case 34:
3221 {
3222 alt5=8;
3223 }
3224 break;
3225 case 35:
3226 {
3227 alt5=9;
3228 }
3229 break;
3230 case 36:
3231 {
3232 alt5=10;
3233 }
3234 break;
3235 case 37:
3236 {
3237 alt5=11;
3238 }
3239 break;
3240 case 38:
3241 {
3242 alt5=12;
3243 }
3244 break;
3245 case 39:
3246 {
3247 alt5=13;
3248 }
3249 break;
3250 case 40:
3251 {
3252 alt5=14;
3253 }
3254 break;
3255 case 41:
3256 {
3257 alt5=15;
3258 }
3259 break;
3260 default:
3261 NoViableAltException nvae =
3262 new NoViableAltException("", 5, 0, input);
3263
3264 throw nvae;
3265 }
3266
3267 switch (alt5) {
3268 case 1 :
3269 // InternalVampireLanguage.g:1069:2: ( ruleVLSAxiom )
3270 {
3271 // InternalVampireLanguage.g:1069:2: ( ruleVLSAxiom )
3272 // InternalVampireLanguage.g:1070:3: ruleVLSAxiom
3273 {
3274 before(grammarAccess.getVLSRoleAccess().getVLSAxiomParserRuleCall_0());
3275 pushFollow(FOLLOW_2);
3276 ruleVLSAxiom();
3277
3278 state._fsp--;
3279
3280 after(grammarAccess.getVLSRoleAccess().getVLSAxiomParserRuleCall_0());
3281
3282 }
3283
3284
3285 }
3286 break;
3287 case 2 :
3288 // InternalVampireLanguage.g:1075:2: ( ruleVLSConjecture )
3289 {
3290 // InternalVampireLanguage.g:1075:2: ( ruleVLSConjecture )
3291 // InternalVampireLanguage.g:1076:3: ruleVLSConjecture
3292 {
3293 before(grammarAccess.getVLSRoleAccess().getVLSConjectureParserRuleCall_1());
3294 pushFollow(FOLLOW_2);
3295 ruleVLSConjecture();
3296
3297 state._fsp--;
3298
3299 after(grammarAccess.getVLSRoleAccess().getVLSConjectureParserRuleCall_1());
3300
3301 }
3302
3303
3304 }
3305 break;
3306 case 3 :
3307 // InternalVampireLanguage.g:1081:2: ( ruleVLSHypothesis )
3308 {
3309 // InternalVampireLanguage.g:1081:2: ( ruleVLSHypothesis )
3310 // InternalVampireLanguage.g:1082:3: ruleVLSHypothesis
3311 {
3312 before(grammarAccess.getVLSRoleAccess().getVLSHypothesisParserRuleCall_2());
3313 pushFollow(FOLLOW_2);
3314 ruleVLSHypothesis();
3315
3316 state._fsp--;
3317
3318 after(grammarAccess.getVLSRoleAccess().getVLSHypothesisParserRuleCall_2());
3319
3320 }
3321
3322
3323 }
3324 break;
3325 case 4 :
3326 // InternalVampireLanguage.g:1087:2: ( ruleVLSDefinition )
3327 {
3328 // InternalVampireLanguage.g:1087:2: ( ruleVLSDefinition )
3329 // InternalVampireLanguage.g:1088:3: ruleVLSDefinition
3330 {
3331 before(grammarAccess.getVLSRoleAccess().getVLSDefinitionParserRuleCall_3());
3332 pushFollow(FOLLOW_2);
3333 ruleVLSDefinition();
3334
3335 state._fsp--;
3336
3337 after(grammarAccess.getVLSRoleAccess().getVLSDefinitionParserRuleCall_3());
3338
3339 }
3340
3341
3342 }
3343 break;
3344 case 5 :
3345 // InternalVampireLanguage.g:1093:2: ( ruleVLSAssumption )
3346 {
3347 // InternalVampireLanguage.g:1093:2: ( ruleVLSAssumption )
3348 // InternalVampireLanguage.g:1094:3: ruleVLSAssumption
3349 {
3350 before(grammarAccess.getVLSRoleAccess().getVLSAssumptionParserRuleCall_4());
3351 pushFollow(FOLLOW_2);
3352 ruleVLSAssumption();
3353
3354 state._fsp--;
3355
3356 after(grammarAccess.getVLSRoleAccess().getVLSAssumptionParserRuleCall_4());
3357
3358 }
3359
3360
3361 }
3362 break;
3363 case 6 :
3364 // InternalVampireLanguage.g:1099:2: ( ruleVLSLemma )
3365 {
3366 // InternalVampireLanguage.g:1099:2: ( ruleVLSLemma )
3367 // InternalVampireLanguage.g:1100:3: ruleVLSLemma
3368 {
3369 before(grammarAccess.getVLSRoleAccess().getVLSLemmaParserRuleCall_5());
3370 pushFollow(FOLLOW_2);
3371 ruleVLSLemma();
3372
3373 state._fsp--;
3374
3375 after(grammarAccess.getVLSRoleAccess().getVLSLemmaParserRuleCall_5());
3376
3377 }
3378
3379
3380 }
3381 break;
3382 case 7 :
3383 // InternalVampireLanguage.g:1105:2: ( ruleVLSTheorem )
3384 {
3385 // InternalVampireLanguage.g:1105:2: ( ruleVLSTheorem )
3386 // InternalVampireLanguage.g:1106:3: ruleVLSTheorem
3387 {
3388 before(grammarAccess.getVLSRoleAccess().getVLSTheoremParserRuleCall_6());
3389 pushFollow(FOLLOW_2);
3390 ruleVLSTheorem();
3391
3392 state._fsp--;
3393
3394 after(grammarAccess.getVLSRoleAccess().getVLSTheoremParserRuleCall_6());
3395
3396 }
3397
3398
3399 }
3400 break;
3401 case 8 :
3402 // InternalVampireLanguage.g:1111:2: ( ruleVLSCorollary )
3403 {
3404 // InternalVampireLanguage.g:1111:2: ( ruleVLSCorollary )
3405 // InternalVampireLanguage.g:1112:3: ruleVLSCorollary
3406 {
3407 before(grammarAccess.getVLSRoleAccess().getVLSCorollaryParserRuleCall_7());
3408 pushFollow(FOLLOW_2);
3409 ruleVLSCorollary();
3410
3411 state._fsp--;
3412
3413 after(grammarAccess.getVLSRoleAccess().getVLSCorollaryParserRuleCall_7());
3414
3415 }
3416
3417
3418 }
3419 break;
3420 case 9 :
3421 // InternalVampireLanguage.g:1117:2: ( ruleVLSNegated_Conjecture )
3422 {
3423 // InternalVampireLanguage.g:1117:2: ( ruleVLSNegated_Conjecture )
3424 // InternalVampireLanguage.g:1118:3: ruleVLSNegated_Conjecture
3425 {
3426 before(grammarAccess.getVLSRoleAccess().getVLSNegated_ConjectureParserRuleCall_8());
3427 pushFollow(FOLLOW_2);
3428 ruleVLSNegated_Conjecture();
3429
3430 state._fsp--;
3431
3432 after(grammarAccess.getVLSRoleAccess().getVLSNegated_ConjectureParserRuleCall_8());
3433
3434 }
3435
3436
3437 }
3438 break;
3439 case 10 :
3440 // InternalVampireLanguage.g:1123:2: ( ruleVLSPlain )
3441 {
3442 // InternalVampireLanguage.g:1123:2: ( ruleVLSPlain )
3443 // InternalVampireLanguage.g:1124:3: ruleVLSPlain
3444 {
3445 before(grammarAccess.getVLSRoleAccess().getVLSPlainParserRuleCall_9());
3446 pushFollow(FOLLOW_2);
3447 ruleVLSPlain();
3448
3449 state._fsp--;
3450
3451 after(grammarAccess.getVLSRoleAccess().getVLSPlainParserRuleCall_9());
3452
3453 }
3454
3455
3456 }
3457 break;
3458 case 11 :
3459 // InternalVampireLanguage.g:1129:2: ( ruleVLSType )
3460 {
3461 // InternalVampireLanguage.g:1129:2: ( ruleVLSType )
3462 // InternalVampireLanguage.g:1130:3: ruleVLSType
3463 {
3464 before(grammarAccess.getVLSRoleAccess().getVLSTypeParserRuleCall_10());
3465 pushFollow(FOLLOW_2);
3466 ruleVLSType();
3467
3468 state._fsp--;
3469
3470 after(grammarAccess.getVLSRoleAccess().getVLSTypeParserRuleCall_10());
3471
3472 }
3473
3474
3475 }
3476 break;
3477 case 12 :
3478 // InternalVampireLanguage.g:1135:2: ( ruleVLSFi_Domain )
3479 {
3480 // InternalVampireLanguage.g:1135:2: ( ruleVLSFi_Domain )
3481 // InternalVampireLanguage.g:1136:3: ruleVLSFi_Domain
3482 {
3483 before(grammarAccess.getVLSRoleAccess().getVLSFi_DomainParserRuleCall_11());
3484 pushFollow(FOLLOW_2);
3485 ruleVLSFi_Domain();
3486
3487 state._fsp--;
3488
3489 after(grammarAccess.getVLSRoleAccess().getVLSFi_DomainParserRuleCall_11());
3490
3491 }
3492
3493
3494 }
3495 break;
3496 case 13 :
3497 // InternalVampireLanguage.g:1141:2: ( ruleVLSFi_Functors )
3498 {
3499 // InternalVampireLanguage.g:1141:2: ( ruleVLSFi_Functors )
3500 // InternalVampireLanguage.g:1142:3: ruleVLSFi_Functors
3501 {
3502 before(grammarAccess.getVLSRoleAccess().getVLSFi_FunctorsParserRuleCall_12());
3503 pushFollow(FOLLOW_2);
3504 ruleVLSFi_Functors();
3505
3506 state._fsp--;
3507
3508 after(grammarAccess.getVLSRoleAccess().getVLSFi_FunctorsParserRuleCall_12());
3509
3510 }
3511
3512
3513 }
3514 break;
3515 case 14 :
3516 // InternalVampireLanguage.g:1147:2: ( ruleVLSFi_Predicates )
3517 {
3518 // InternalVampireLanguage.g:1147:2: ( ruleVLSFi_Predicates )
3519 // InternalVampireLanguage.g:1148:3: ruleVLSFi_Predicates
3520 {
3521 before(grammarAccess.getVLSRoleAccess().getVLSFi_PredicatesParserRuleCall_13());
3522 pushFollow(FOLLOW_2);
3523 ruleVLSFi_Predicates();
3524
3525 state._fsp--;
3526
3527 after(grammarAccess.getVLSRoleAccess().getVLSFi_PredicatesParserRuleCall_13());
3528
3529 }
3530
3531
3532 }
3533 break;
3534 case 15 :
3535 // InternalVampireLanguage.g:1153:2: ( ruleVLSUnknown )
3536 {
3537 // InternalVampireLanguage.g:1153:2: ( ruleVLSUnknown )
3538 // InternalVampireLanguage.g:1154:3: ruleVLSUnknown
3539 {
3540 before(grammarAccess.getVLSRoleAccess().getVLSUnknownParserRuleCall_14());
3541 pushFollow(FOLLOW_2);
3542 ruleVLSUnknown();
3543
3544 state._fsp--;
3545
3546 after(grammarAccess.getVLSRoleAccess().getVLSUnknownParserRuleCall_14());
3547
3548 }
3549
3550
3551 }
3552 break;
3553
3554 }
3555 }
3556 catch (RecognitionException re) {
3557 reportError(re);
3558 recover(input,re);
3559 }
3560 finally {
3561
3562 restoreStackSize(stackSize);
3563
3564 }
3565 return ;
3566 }
3567 // $ANTLR end "rule__VLSRole__Alternatives"
3568
3569
3570 // $ANTLR start "rule__VLSAnnotation__NameAlternatives_1_0"
3571 // InternalVampireLanguage.g:1163:1: rule__VLSAnnotation__NameAlternatives_1_0 : ( ( RULE_LOWER_WORD_ID ) | ( RULE_SINGLE_QUOTE ) | ( ruleVLSRole ) );
3572 public final void rule__VLSAnnotation__NameAlternatives_1_0() throws RecognitionException {
3573
3574 int stackSize = keepStackSize();
3575
3576 try {
3577 // InternalVampireLanguage.g:1167:1: ( ( RULE_LOWER_WORD_ID ) | ( RULE_SINGLE_QUOTE ) | ( ruleVLSRole ) )
3578 int alt6=3;
3579 switch ( input.LA(1) ) {
3580 case RULE_LOWER_WORD_ID:
3581 {
3582 alt6=1;
3583 }
3584 break;
3585 case RULE_SINGLE_QUOTE:
3586 {
3587 alt6=2;
3588 }
3589 break;
3590 case 27:
3591 case 28:
3592 case 29:
3593 case 30:
3594 case 31:
3595 case 32:
3596 case 33:
3597 case 34:
3598 case 35:
3599 case 36:
3600 case 37:
3601 case 38:
3602 case 39:
3603 case 40:
3604 case 41:
3605 {
3606 alt6=3;
3607 }
3608 break;
3609 default:
3610 NoViableAltException nvae =
3611 new NoViableAltException("", 6, 0, input);
3612
3613 throw nvae;
3614 }
3615
3616 switch (alt6) {
3617 case 1 :
3618 // InternalVampireLanguage.g:1168:2: ( RULE_LOWER_WORD_ID )
3619 {
3620 // InternalVampireLanguage.g:1168:2: ( RULE_LOWER_WORD_ID )
3621 // InternalVampireLanguage.g:1169:3: RULE_LOWER_WORD_ID
3622 {
3623 before(grammarAccess.getVLSAnnotationAccess().getNameLOWER_WORD_IDTerminalRuleCall_1_0_0());
3624 match(input,RULE_LOWER_WORD_ID,FOLLOW_2);
3625 after(grammarAccess.getVLSAnnotationAccess().getNameLOWER_WORD_IDTerminalRuleCall_1_0_0());
3626
3627 }
3628
3629
3630 }
3631 break;
3632 case 2 :
3633 // InternalVampireLanguage.g:1174:2: ( RULE_SINGLE_QUOTE )
3634 {
3635 // InternalVampireLanguage.g:1174:2: ( RULE_SINGLE_QUOTE )
3636 // InternalVampireLanguage.g:1175:3: RULE_SINGLE_QUOTE
3637 {
3638 before(grammarAccess.getVLSAnnotationAccess().getNameSINGLE_QUOTETerminalRuleCall_1_0_1());
3639 match(input,RULE_SINGLE_QUOTE,FOLLOW_2);
3640 after(grammarAccess.getVLSAnnotationAccess().getNameSINGLE_QUOTETerminalRuleCall_1_0_1());
3641
3642 }
3643
3644
3645 }
3646 break;
3647 case 3 :
3648 // InternalVampireLanguage.g:1180:2: ( ruleVLSRole )
3649 {
3650 // InternalVampireLanguage.g:1180:2: ( ruleVLSRole )
3651 // InternalVampireLanguage.g:1181:3: ruleVLSRole
3652 {
3653 before(grammarAccess.getVLSAnnotationAccess().getNameVLSRoleParserRuleCall_1_0_2());
3654 pushFollow(FOLLOW_2);
3655 ruleVLSRole();
3656
3657 state._fsp--;
3658
3659 after(grammarAccess.getVLSAnnotationAccess().getNameVLSRoleParserRuleCall_1_0_2());
3660
3661 }
3662
3663
3664 }
3665 break;
3666
3667 }
3668 }
3669 catch (RecognitionException re) {
3670 reportError(re);
3671 recover(input,re);
3672 }
3673 finally {
3674
3675 restoreStackSize(stackSize);
3676
3677 }
3678 return ;
3679 }
3680 // $ANTLR end "rule__VLSAnnotation__NameAlternatives_1_0"
3681
3682
3683 // $ANTLR start "rule__VLSBinary__Alternatives_1"
3684 // InternalVampireLanguage.g:1190:1: rule__VLSBinary__Alternatives_1 : ( ( ( rule__VLSBinary__Group_1_0__0 ) ) | ( ( ( rule__VLSBinary__Group_1_1__0 ) ) ( ( rule__VLSBinary__Group_1_1__0 )* ) ) | ( ( ( rule__VLSBinary__Group_1_2__0 ) ) ( ( rule__VLSBinary__Group_1_2__0 )* ) ) );
3685 public final void rule__VLSBinary__Alternatives_1() throws RecognitionException {
3686
3687 int stackSize = keepStackSize();
3688
3689 try {
3690 // InternalVampireLanguage.g:1194:1: ( ( ( rule__VLSBinary__Group_1_0__0 ) ) | ( ( ( rule__VLSBinary__Group_1_1__0 ) ) ( ( rule__VLSBinary__Group_1_1__0 )* ) ) | ( ( ( rule__VLSBinary__Group_1_2__0 ) ) ( ( rule__VLSBinary__Group_1_2__0 )* ) ) )
3691 int alt9=3;
3692 switch ( input.LA(1) ) {
3693 case 51:
3694 case 52:
3695 case 53:
3696 case 54:
3697 case 55:
3698 case 56:
3699 {
3700 alt9=1;
3701 }
3702 break;
3703 case 57:
3704 {
3705 alt9=2;
3706 }
3707 break;
3708 case 58:
3709 {
3710 alt9=3;
3711 }
3712 break;
3713 default:
3714 NoViableAltException nvae =
3715 new NoViableAltException("", 9, 0, input);
3716
3717 throw nvae;
3718 }
3719
3720 switch (alt9) {
3721 case 1 :
3722 // InternalVampireLanguage.g:1195:2: ( ( rule__VLSBinary__Group_1_0__0 ) )
3723 {
3724 // InternalVampireLanguage.g:1195:2: ( ( rule__VLSBinary__Group_1_0__0 ) )
3725 // InternalVampireLanguage.g:1196:3: ( rule__VLSBinary__Group_1_0__0 )
3726 {
3727 before(grammarAccess.getVLSBinaryAccess().getGroup_1_0());
3728 // InternalVampireLanguage.g:1197:3: ( rule__VLSBinary__Group_1_0__0 )
3729 // InternalVampireLanguage.g:1197:4: rule__VLSBinary__Group_1_0__0
3730 {
3731 pushFollow(FOLLOW_2);
3732 rule__VLSBinary__Group_1_0__0();
3733
3734 state._fsp--;
3735
3736
3737 }
3738
3739 after(grammarAccess.getVLSBinaryAccess().getGroup_1_0());
3740
3741 }
3742
3743
3744 }
3745 break;
3746 case 2 :
3747 // InternalVampireLanguage.g:1201:2: ( ( ( rule__VLSBinary__Group_1_1__0 ) ) ( ( rule__VLSBinary__Group_1_1__0 )* ) )
3748 {
3749 // InternalVampireLanguage.g:1201:2: ( ( ( rule__VLSBinary__Group_1_1__0 ) ) ( ( rule__VLSBinary__Group_1_1__0 )* ) )
3750 // InternalVampireLanguage.g:1202:3: ( ( rule__VLSBinary__Group_1_1__0 ) ) ( ( rule__VLSBinary__Group_1_1__0 )* )
3751 {
3752 // InternalVampireLanguage.g:1202:3: ( ( rule__VLSBinary__Group_1_1__0 ) )
3753 // InternalVampireLanguage.g:1203:4: ( rule__VLSBinary__Group_1_1__0 )
3754 {
3755 before(grammarAccess.getVLSBinaryAccess().getGroup_1_1());
3756 // InternalVampireLanguage.g:1204:4: ( rule__VLSBinary__Group_1_1__0 )
3757 // InternalVampireLanguage.g:1204:5: rule__VLSBinary__Group_1_1__0
3758 {
3759 pushFollow(FOLLOW_4);
3760 rule__VLSBinary__Group_1_1__0();
3761
3762 state._fsp--;
3763
3764
3765 }
3766
3767 after(grammarAccess.getVLSBinaryAccess().getGroup_1_1());
3768
3769 }
3770
3771 // InternalVampireLanguage.g:1207:3: ( ( rule__VLSBinary__Group_1_1__0 )* )
3772 // InternalVampireLanguage.g:1208:4: ( rule__VLSBinary__Group_1_1__0 )*
3773 {
3774 before(grammarAccess.getVLSBinaryAccess().getGroup_1_1());
3775 // InternalVampireLanguage.g:1209:4: ( rule__VLSBinary__Group_1_1__0 )*
3776 loop7:
3777 do {
3778 int alt7=2;
3779 int LA7_0 = input.LA(1);
3780
3781 if ( (LA7_0==57) ) {
3782 alt7=1;
3783 }
3784
3785
3786 switch (alt7) {
3787 case 1 :
3788 // InternalVampireLanguage.g:1209:5: rule__VLSBinary__Group_1_1__0
3789 {
3790 pushFollow(FOLLOW_4);
3791 rule__VLSBinary__Group_1_1__0();
3792
3793 state._fsp--;
3794
3795
3796 }
3797 break;
3798
3799 default :
3800 break loop7;
3801 }
3802 } while (true);
3803
3804 after(grammarAccess.getVLSBinaryAccess().getGroup_1_1());
3805
3806 }
3807
3808
3809 }
3810
3811
3812 }
3813 break;
3814 case 3 :
3815 // InternalVampireLanguage.g:1214:2: ( ( ( rule__VLSBinary__Group_1_2__0 ) ) ( ( rule__VLSBinary__Group_1_2__0 )* ) )
3816 {
3817 // InternalVampireLanguage.g:1214:2: ( ( ( rule__VLSBinary__Group_1_2__0 ) ) ( ( rule__VLSBinary__Group_1_2__0 )* ) )
3818 // InternalVampireLanguage.g:1215:3: ( ( rule__VLSBinary__Group_1_2__0 ) ) ( ( rule__VLSBinary__Group_1_2__0 )* )
3819 {
3820 // InternalVampireLanguage.g:1215:3: ( ( rule__VLSBinary__Group_1_2__0 ) )
3821 // InternalVampireLanguage.g:1216:4: ( rule__VLSBinary__Group_1_2__0 )
3822 {
3823 before(grammarAccess.getVLSBinaryAccess().getGroup_1_2());
3824 // InternalVampireLanguage.g:1217:4: ( rule__VLSBinary__Group_1_2__0 )
3825 // InternalVampireLanguage.g:1217:5: rule__VLSBinary__Group_1_2__0
3826 {
3827 pushFollow(FOLLOW_5);
3828 rule__VLSBinary__Group_1_2__0();
3829
3830 state._fsp--;
3831
3832
3833 }
3834
3835 after(grammarAccess.getVLSBinaryAccess().getGroup_1_2());
3836
3837 }
3838
3839 // InternalVampireLanguage.g:1220:3: ( ( rule__VLSBinary__Group_1_2__0 )* )
3840 // InternalVampireLanguage.g:1221:4: ( rule__VLSBinary__Group_1_2__0 )*
3841 {
3842 before(grammarAccess.getVLSBinaryAccess().getGroup_1_2());
3843 // InternalVampireLanguage.g:1222:4: ( rule__VLSBinary__Group_1_2__0 )*
3844 loop8:
3845 do {
3846 int alt8=2;
3847 int LA8_0 = input.LA(1);
3848
3849 if ( (LA8_0==58) ) {
3850 alt8=1;
3851 }
3852
3853
3854 switch (alt8) {
3855 case 1 :
3856 // InternalVampireLanguage.g:1222:5: rule__VLSBinary__Group_1_2__0
3857 {
3858 pushFollow(FOLLOW_5);
3859 rule__VLSBinary__Group_1_2__0();
3860
3861 state._fsp--;
3862
3863
3864 }
3865 break;
3866
3867 default :
3868 break loop8;
3869 }
3870 } while (true);
3871
3872 after(grammarAccess.getVLSBinaryAccess().getGroup_1_2());
3873
3874 }
3875
3876
3877 }
3878
3879
3880 }
3881 break;
3882
3883 }
3884 }
3885 catch (RecognitionException re) {
3886 reportError(re);
3887 recover(input,re);
3888 }
3889 finally {
3890
3891 restoreStackSize(stackSize);
3892
3893 }
3894 return ;
3895 }
3896 // $ANTLR end "rule__VLSBinary__Alternatives_1"
3897
3898
3899 // $ANTLR start "rule__VLSBinary__Alternatives_1_0_0"
3900 // InternalVampireLanguage.g:1231:1: rule__VLSBinary__Alternatives_1_0_0 : ( ( ( rule__VLSBinary__Group_1_0_0_0__0 ) ) | ( ( rule__VLSBinary__Group_1_0_0_1__0 ) ) | ( ( rule__VLSBinary__Group_1_0_0_2__0 ) ) | ( ( rule__VLSBinary__Group_1_0_0_3__0 ) ) | ( ( rule__VLSBinary__Group_1_0_0_4__0 ) ) | ( ( rule__VLSBinary__Group_1_0_0_5__0 ) ) );
3901 public final void rule__VLSBinary__Alternatives_1_0_0() throws RecognitionException {
3902
3903 int stackSize = keepStackSize();
3904
3905 try {
3906 // InternalVampireLanguage.g:1235:1: ( ( ( rule__VLSBinary__Group_1_0_0_0__0 ) ) | ( ( rule__VLSBinary__Group_1_0_0_1__0 ) ) | ( ( rule__VLSBinary__Group_1_0_0_2__0 ) ) | ( ( rule__VLSBinary__Group_1_0_0_3__0 ) ) | ( ( rule__VLSBinary__Group_1_0_0_4__0 ) ) | ( ( rule__VLSBinary__Group_1_0_0_5__0 ) ) )
3907 int alt10=6;
3908 switch ( input.LA(1) ) {
3909 case 51:
3910 {
3911 alt10=1;
3912 }
3913 break;
3914 case 52:
3915 {
3916 alt10=2;
3917 }
3918 break;
3919 case 53:
3920 {
3921 alt10=3;
3922 }
3923 break;
3924 case 54:
3925 {
3926 alt10=4;
3927 }
3928 break;
3929 case 55:
3930 {
3931 alt10=5;
3932 }
3933 break;
3934 case 56:
3935 {
3936 alt10=6;
3937 }
3938 break;
3939 default:
3940 NoViableAltException nvae =
3941 new NoViableAltException("", 10, 0, input);
3942
3943 throw nvae;
3944 }
3945
3946 switch (alt10) {
3947 case 1 :
3948 // InternalVampireLanguage.g:1236:2: ( ( rule__VLSBinary__Group_1_0_0_0__0 ) )
3949 {
3950 // InternalVampireLanguage.g:1236:2: ( ( rule__VLSBinary__Group_1_0_0_0__0 ) )
3951 // InternalVampireLanguage.g:1237:3: ( rule__VLSBinary__Group_1_0_0_0__0 )
3952 {
3953 before(grammarAccess.getVLSBinaryAccess().getGroup_1_0_0_0());
3954 // InternalVampireLanguage.g:1238:3: ( rule__VLSBinary__Group_1_0_0_0__0 )
3955 // InternalVampireLanguage.g:1238:4: rule__VLSBinary__Group_1_0_0_0__0
3956 {
3957 pushFollow(FOLLOW_2);
3958 rule__VLSBinary__Group_1_0_0_0__0();
3959
3960 state._fsp--;
3961
3962
3963 }
3964
3965 after(grammarAccess.getVLSBinaryAccess().getGroup_1_0_0_0());
3966
3967 }
3968
3969
3970 }
3971 break;
3972 case 2 :
3973 // InternalVampireLanguage.g:1242:2: ( ( rule__VLSBinary__Group_1_0_0_1__0 ) )
3974 {
3975 // InternalVampireLanguage.g:1242:2: ( ( rule__VLSBinary__Group_1_0_0_1__0 ) )
3976 // InternalVampireLanguage.g:1243:3: ( rule__VLSBinary__Group_1_0_0_1__0 )
3977 {
3978 before(grammarAccess.getVLSBinaryAccess().getGroup_1_0_0_1());
3979 // InternalVampireLanguage.g:1244:3: ( rule__VLSBinary__Group_1_0_0_1__0 )
3980 // InternalVampireLanguage.g:1244:4: rule__VLSBinary__Group_1_0_0_1__0
3981 {
3982 pushFollow(FOLLOW_2);
3983 rule__VLSBinary__Group_1_0_0_1__0();
3984
3985 state._fsp--;
3986
3987
3988 }
3989
3990 after(grammarAccess.getVLSBinaryAccess().getGroup_1_0_0_1());
3991
3992 }
3993
3994
3995 }
3996 break;
3997 case 3 :
3998 // InternalVampireLanguage.g:1248:2: ( ( rule__VLSBinary__Group_1_0_0_2__0 ) )
3999 {
4000 // InternalVampireLanguage.g:1248:2: ( ( rule__VLSBinary__Group_1_0_0_2__0 ) )
4001 // InternalVampireLanguage.g:1249:3: ( rule__VLSBinary__Group_1_0_0_2__0 )
4002 {
4003 before(grammarAccess.getVLSBinaryAccess().getGroup_1_0_0_2());
4004 // InternalVampireLanguage.g:1250:3: ( rule__VLSBinary__Group_1_0_0_2__0 )
4005 // InternalVampireLanguage.g:1250:4: rule__VLSBinary__Group_1_0_0_2__0
4006 {
4007 pushFollow(FOLLOW_2);
4008 rule__VLSBinary__Group_1_0_0_2__0();
4009
4010 state._fsp--;
4011
4012
4013 }
4014
4015 after(grammarAccess.getVLSBinaryAccess().getGroup_1_0_0_2());
4016
4017 }
4018
4019
4020 }
4021 break;
4022 case 4 :
4023 // InternalVampireLanguage.g:1254:2: ( ( rule__VLSBinary__Group_1_0_0_3__0 ) )
4024 {
4025 // InternalVampireLanguage.g:1254:2: ( ( rule__VLSBinary__Group_1_0_0_3__0 ) )
4026 // InternalVampireLanguage.g:1255:3: ( rule__VLSBinary__Group_1_0_0_3__0 )
4027 {
4028 before(grammarAccess.getVLSBinaryAccess().getGroup_1_0_0_3());
4029 // InternalVampireLanguage.g:1256:3: ( rule__VLSBinary__Group_1_0_0_3__0 )
4030 // InternalVampireLanguage.g:1256:4: rule__VLSBinary__Group_1_0_0_3__0
4031 {
4032 pushFollow(FOLLOW_2);
4033 rule__VLSBinary__Group_1_0_0_3__0();
4034
4035 state._fsp--;
4036
4037
4038 }
4039
4040 after(grammarAccess.getVLSBinaryAccess().getGroup_1_0_0_3());
4041
4042 }
4043
4044
4045 }
4046 break;
4047 case 5 :
4048 // InternalVampireLanguage.g:1260:2: ( ( rule__VLSBinary__Group_1_0_0_4__0 ) )
4049 {
4050 // InternalVampireLanguage.g:1260:2: ( ( rule__VLSBinary__Group_1_0_0_4__0 ) )
4051 // InternalVampireLanguage.g:1261:3: ( rule__VLSBinary__Group_1_0_0_4__0 )
4052 {
4053 before(grammarAccess.getVLSBinaryAccess().getGroup_1_0_0_4());
4054 // InternalVampireLanguage.g:1262:3: ( rule__VLSBinary__Group_1_0_0_4__0 )
4055 // InternalVampireLanguage.g:1262:4: rule__VLSBinary__Group_1_0_0_4__0
4056 {
4057 pushFollow(FOLLOW_2);
4058 rule__VLSBinary__Group_1_0_0_4__0();
4059
4060 state._fsp--;
4061
4062
4063 }
4064
4065 after(grammarAccess.getVLSBinaryAccess().getGroup_1_0_0_4());
4066
4067 }
4068
4069
4070 }
4071 break;
4072 case 6 :
4073 // InternalVampireLanguage.g:1266:2: ( ( rule__VLSBinary__Group_1_0_0_5__0 ) )
4074 {
4075 // InternalVampireLanguage.g:1266:2: ( ( rule__VLSBinary__Group_1_0_0_5__0 ) )
4076 // InternalVampireLanguage.g:1267:3: ( rule__VLSBinary__Group_1_0_0_5__0 )
4077 {
4078 before(grammarAccess.getVLSBinaryAccess().getGroup_1_0_0_5());
4079 // InternalVampireLanguage.g:1268:3: ( rule__VLSBinary__Group_1_0_0_5__0 )
4080 // InternalVampireLanguage.g:1268:4: rule__VLSBinary__Group_1_0_0_5__0
4081 {
4082 pushFollow(FOLLOW_2);
4083 rule__VLSBinary__Group_1_0_0_5__0();
4084
4085 state._fsp--;
4086
4087
4088 }
4089
4090 after(grammarAccess.getVLSBinaryAccess().getGroup_1_0_0_5());
4091
4092 }
4093
4094
4095 }
4096 break;
4097
4098 }
4099 }
4100 catch (RecognitionException re) {
4101 reportError(re);
4102 recover(input,re);
4103 }
4104 finally {
4105
4106 restoreStackSize(stackSize);
4107
4108 }
4109 return ;
4110 }
4111 // $ANTLR end "rule__VLSBinary__Alternatives_1_0_0"
4112
4113
4114 // $ANTLR start "rule__VLSUnitaryFormula__Alternatives"
4115 // InternalVampireLanguage.g:1276:1: rule__VLSUnitaryFormula__Alternatives : ( ( ruleVLSUniversalQuantifier ) | ( ruleVLSExistentialQuantifier ) | ( ruleVLSUnaryNegation ) | ( ruleVLSUnaryInfix ) | ( ( rule__VLSUnitaryFormula__Group_4__0 ) ) );
4116 public final void rule__VLSUnitaryFormula__Alternatives() throws RecognitionException {
4117
4118 int stackSize = keepStackSize();
4119
4120 try {
4121 // InternalVampireLanguage.g:1280:1: ( ( ruleVLSUniversalQuantifier ) | ( ruleVLSExistentialQuantifier ) | ( ruleVLSUnaryNegation ) | ( ruleVLSUnaryInfix ) | ( ( rule__VLSUnitaryFormula__Group_4__0 ) ) )
4122 int alt11=5;
4123 switch ( input.LA(1) ) {
4124 case 59:
4125 {
4126 alt11=1;
4127 }
4128 break;
4129 case 61:
4130 {
4131 alt11=2;
4132 }
4133 break;
4134 case 62:
4135 {
4136 alt11=3;
4137 }
4138 break;
4139 case RULE_LOWER_WORD_ID:
4140 case RULE_SINGLE_QUOTE:
4141 case RULE_SIGNED_LITERAL:
4142 case RULE_DOLLAR_ID:
4143 case RULE_DOUBLE_DOLLAR_ID:
4144 case RULE_UPPER_WORD_ID:
4145 case RULE_SIGNED_REAL_ID:
4146 case RULE_SIGNED_RAT_ID:
4147 case RULE_DOUBLE_QUOTE:
4148 case 27:
4149 case 28:
4150 case 29:
4151 case 30:
4152 case 31:
4153 case 32:
4154 case 33:
4155 case 34:
4156 case 35:
4157 case 36:
4158 case 37:
4159 case 38:
4160 case 39:
4161 case 40:
4162 case 41:
4163 case 66:
4164 case 67:
4165 case 68:
4166 {
4167 alt11=4;
4168 }
4169 break;
4170 case 47:
4171 {
4172 alt11=5;
4173 }
4174 break;
4175 default:
4176 NoViableAltException nvae =
4177 new NoViableAltException("", 11, 0, input);
4178
4179 throw nvae;
4180 }
4181
4182 switch (alt11) {
4183 case 1 :
4184 // InternalVampireLanguage.g:1281:2: ( ruleVLSUniversalQuantifier )
4185 {
4186 // InternalVampireLanguage.g:1281:2: ( ruleVLSUniversalQuantifier )
4187 // InternalVampireLanguage.g:1282:3: ruleVLSUniversalQuantifier
4188 {
4189 before(grammarAccess.getVLSUnitaryFormulaAccess().getVLSUniversalQuantifierParserRuleCall_0());
4190 pushFollow(FOLLOW_2);
4191 ruleVLSUniversalQuantifier();
4192
4193 state._fsp--;
4194
4195 after(grammarAccess.getVLSUnitaryFormulaAccess().getVLSUniversalQuantifierParserRuleCall_0());
4196
4197 }
4198
4199
4200 }
4201 break;
4202 case 2 :
4203 // InternalVampireLanguage.g:1287:2: ( ruleVLSExistentialQuantifier )
4204 {
4205 // InternalVampireLanguage.g:1287:2: ( ruleVLSExistentialQuantifier )
4206 // InternalVampireLanguage.g:1288:3: ruleVLSExistentialQuantifier
4207 {
4208 before(grammarAccess.getVLSUnitaryFormulaAccess().getVLSExistentialQuantifierParserRuleCall_1());
4209 pushFollow(FOLLOW_2);
4210 ruleVLSExistentialQuantifier();
4211
4212 state._fsp--;
4213
4214 after(grammarAccess.getVLSUnitaryFormulaAccess().getVLSExistentialQuantifierParserRuleCall_1());
4215
4216 }
4217
4218
4219 }
4220 break;
4221 case 3 :
4222 // InternalVampireLanguage.g:1293:2: ( ruleVLSUnaryNegation )
4223 {
4224 // InternalVampireLanguage.g:1293:2: ( ruleVLSUnaryNegation )
4225 // InternalVampireLanguage.g:1294:3: ruleVLSUnaryNegation
4226 {
4227 before(grammarAccess.getVLSUnitaryFormulaAccess().getVLSUnaryNegationParserRuleCall_2());
4228 pushFollow(FOLLOW_2);
4229 ruleVLSUnaryNegation();
4230
4231 state._fsp--;
4232
4233 after(grammarAccess.getVLSUnitaryFormulaAccess().getVLSUnaryNegationParserRuleCall_2());
4234
4235 }
4236
4237
4238 }
4239 break;
4240 case 4 :
4241 // InternalVampireLanguage.g:1299:2: ( ruleVLSUnaryInfix )
4242 {
4243 // InternalVampireLanguage.g:1299:2: ( ruleVLSUnaryInfix )
4244 // InternalVampireLanguage.g:1300:3: ruleVLSUnaryInfix
4245 {
4246 before(grammarAccess.getVLSUnitaryFormulaAccess().getVLSUnaryInfixParserRuleCall_3());
4247 pushFollow(FOLLOW_2);
4248 ruleVLSUnaryInfix();
4249
4250 state._fsp--;
4251
4252 after(grammarAccess.getVLSUnitaryFormulaAccess().getVLSUnaryInfixParserRuleCall_3());
4253
4254 }
4255
4256
4257 }
4258 break;
4259 case 5 :
4260 // InternalVampireLanguage.g:1305:2: ( ( rule__VLSUnitaryFormula__Group_4__0 ) )
4261 {
4262 // InternalVampireLanguage.g:1305:2: ( ( rule__VLSUnitaryFormula__Group_4__0 ) )
4263 // InternalVampireLanguage.g:1306:3: ( rule__VLSUnitaryFormula__Group_4__0 )
4264 {
4265 before(grammarAccess.getVLSUnitaryFormulaAccess().getGroup_4());
4266 // InternalVampireLanguage.g:1307:3: ( rule__VLSUnitaryFormula__Group_4__0 )
4267 // InternalVampireLanguage.g:1307:4: rule__VLSUnitaryFormula__Group_4__0
4268 {
4269 pushFollow(FOLLOW_2);
4270 rule__VLSUnitaryFormula__Group_4__0();
4271
4272 state._fsp--;
4273
4274
4275 }
4276
4277 after(grammarAccess.getVLSUnitaryFormulaAccess().getGroup_4());
4278
4279 }
4280
4281
4282 }
4283 break;
4284
4285 }
4286 }
4287 catch (RecognitionException re) {
4288 reportError(re);
4289 recover(input,re);
4290 }
4291 finally {
4292
4293 restoreStackSize(stackSize);
4294
4295 }
4296 return ;
4297 }
4298 // $ANTLR end "rule__VLSUnitaryFormula__Alternatives"
4299
4300
4301 // $ANTLR start "rule__VLSUnaryInfix__Alternatives_1_0"
4302 // InternalVampireLanguage.g:1315:1: rule__VLSUnaryInfix__Alternatives_1_0 : ( ( ( rule__VLSUnaryInfix__Group_1_0_0__0 ) ) | ( ( rule__VLSUnaryInfix__Group_1_0_1__0 ) ) | ( ( rule__VLSUnaryInfix__Group_1_0_2__0 ) ) );
4303 public final void rule__VLSUnaryInfix__Alternatives_1_0() throws RecognitionException {
4304
4305 int stackSize = keepStackSize();
4306
4307 try {
4308 // InternalVampireLanguage.g:1319:1: ( ( ( rule__VLSUnaryInfix__Group_1_0_0__0 ) ) | ( ( rule__VLSUnaryInfix__Group_1_0_1__0 ) ) | ( ( rule__VLSUnaryInfix__Group_1_0_2__0 ) ) )
4309 int alt12=3;
4310 switch ( input.LA(1) ) {
4311 case 63:
4312 {
4313 alt12=1;
4314 }
4315 break;
4316 case 64:
4317 {
4318 alt12=2;
4319 }
4320 break;
4321 case 65:
4322 {
4323 alt12=3;
4324 }
4325 break;
4326 default:
4327 NoViableAltException nvae =
4328 new NoViableAltException("", 12, 0, input);
4329
4330 throw nvae;
4331 }
4332
4333 switch (alt12) {
4334 case 1 :
4335 // InternalVampireLanguage.g:1320:2: ( ( rule__VLSUnaryInfix__Group_1_0_0__0 ) )
4336 {
4337 // InternalVampireLanguage.g:1320:2: ( ( rule__VLSUnaryInfix__Group_1_0_0__0 ) )
4338 // InternalVampireLanguage.g:1321:3: ( rule__VLSUnaryInfix__Group_1_0_0__0 )
4339 {
4340 before(grammarAccess.getVLSUnaryInfixAccess().getGroup_1_0_0());
4341 // InternalVampireLanguage.g:1322:3: ( rule__VLSUnaryInfix__Group_1_0_0__0 )
4342 // InternalVampireLanguage.g:1322:4: rule__VLSUnaryInfix__Group_1_0_0__0
4343 {
4344 pushFollow(FOLLOW_2);
4345 rule__VLSUnaryInfix__Group_1_0_0__0();
4346
4347 state._fsp--;
4348
4349
4350 }
4351
4352 after(grammarAccess.getVLSUnaryInfixAccess().getGroup_1_0_0());
4353
4354 }
4355
4356
4357 }
4358 break;
4359 case 2 :
4360 // InternalVampireLanguage.g:1326:2: ( ( rule__VLSUnaryInfix__Group_1_0_1__0 ) )
4361 {
4362 // InternalVampireLanguage.g:1326:2: ( ( rule__VLSUnaryInfix__Group_1_0_1__0 ) )
4363 // InternalVampireLanguage.g:1327:3: ( rule__VLSUnaryInfix__Group_1_0_1__0 )
4364 {
4365 before(grammarAccess.getVLSUnaryInfixAccess().getGroup_1_0_1());
4366 // InternalVampireLanguage.g:1328:3: ( rule__VLSUnaryInfix__Group_1_0_1__0 )
4367 // InternalVampireLanguage.g:1328:4: rule__VLSUnaryInfix__Group_1_0_1__0
4368 {
4369 pushFollow(FOLLOW_2);
4370 rule__VLSUnaryInfix__Group_1_0_1__0();
4371
4372 state._fsp--;
4373
4374
4375 }
4376
4377 after(grammarAccess.getVLSUnaryInfixAccess().getGroup_1_0_1());
4378
4379 }
4380
4381
4382 }
4383 break;
4384 case 3 :
4385 // InternalVampireLanguage.g:1332:2: ( ( rule__VLSUnaryInfix__Group_1_0_2__0 ) )
4386 {
4387 // InternalVampireLanguage.g:1332:2: ( ( rule__VLSUnaryInfix__Group_1_0_2__0 ) )
4388 // InternalVampireLanguage.g:1333:3: ( rule__VLSUnaryInfix__Group_1_0_2__0 )
4389 {
4390 before(grammarAccess.getVLSUnaryInfixAccess().getGroup_1_0_2());
4391 // InternalVampireLanguage.g:1334:3: ( rule__VLSUnaryInfix__Group_1_0_2__0 )
4392 // InternalVampireLanguage.g:1334:4: rule__VLSUnaryInfix__Group_1_0_2__0
4393 {
4394 pushFollow(FOLLOW_2);
4395 rule__VLSUnaryInfix__Group_1_0_2__0();
4396
4397 state._fsp--;
4398
4399
4400 }
4401
4402 after(grammarAccess.getVLSUnaryInfixAccess().getGroup_1_0_2());
4403
4404 }
4405
4406
4407 }
4408 break;
4409
4410 }
4411 }
4412 catch (RecognitionException re) {
4413 reportError(re);
4414 recover(input,re);
4415 }
4416 finally {
4417
4418 restoreStackSize(stackSize);
4419
4420 }
4421 return ;
4422 }
4423 // $ANTLR end "rule__VLSUnaryInfix__Alternatives_1_0"
4424
4425
4426 // $ANTLR start "rule__VLSAtomic__Alternatives"
4427 // InternalVampireLanguage.g:1342:1: rule__VLSAtomic__Alternatives : ( ( ruleVLSAtomicConstant ) | ( ruleVLSAtomicFunction ) | ( ruleVLSVariable ) | ( ruleVLSDefinedTerm ) );
4428 public final void rule__VLSAtomic__Alternatives() throws RecognitionException {
4429
4430 int stackSize = keepStackSize();
4431
4432 try {
4433 // InternalVampireLanguage.g:1346:1: ( ( ruleVLSAtomicConstant ) | ( ruleVLSAtomicFunction ) | ( ruleVLSVariable ) | ( ruleVLSDefinedTerm ) )
4434 int alt13=4;
4435 alt13 = dfa13.predict(input);
4436 switch (alt13) {
4437 case 1 :
4438 // InternalVampireLanguage.g:1347:2: ( ruleVLSAtomicConstant )
4439 {
4440 // InternalVampireLanguage.g:1347:2: ( ruleVLSAtomicConstant )
4441 // InternalVampireLanguage.g:1348:3: ruleVLSAtomicConstant
4442 {
4443 before(grammarAccess.getVLSAtomicAccess().getVLSAtomicConstantParserRuleCall_0());
4444 pushFollow(FOLLOW_2);
4445 ruleVLSAtomicConstant();
4446
4447 state._fsp--;
4448
4449 after(grammarAccess.getVLSAtomicAccess().getVLSAtomicConstantParserRuleCall_0());
4450
4451 }
4452
4453
4454 }
4455 break;
4456 case 2 :
4457 // InternalVampireLanguage.g:1353:2: ( ruleVLSAtomicFunction )
4458 {
4459 // InternalVampireLanguage.g:1353:2: ( ruleVLSAtomicFunction )
4460 // InternalVampireLanguage.g:1354:3: ruleVLSAtomicFunction
4461 {
4462 before(grammarAccess.getVLSAtomicAccess().getVLSAtomicFunctionParserRuleCall_1());
4463 pushFollow(FOLLOW_2);
4464 ruleVLSAtomicFunction();
4465
4466 state._fsp--;
4467
4468 after(grammarAccess.getVLSAtomicAccess().getVLSAtomicFunctionParserRuleCall_1());
4469
4470 }
4471
4472
4473 }
4474 break;
4475 case 3 :
4476 // InternalVampireLanguage.g:1359:2: ( ruleVLSVariable )
4477 {
4478 // InternalVampireLanguage.g:1359:2: ( ruleVLSVariable )
4479 // InternalVampireLanguage.g:1360:3: ruleVLSVariable
4480 {
4481 before(grammarAccess.getVLSAtomicAccess().getVLSVariableParserRuleCall_2());
4482 pushFollow(FOLLOW_2);
4483 ruleVLSVariable();
4484
4485 state._fsp--;
4486
4487 after(grammarAccess.getVLSAtomicAccess().getVLSVariableParserRuleCall_2());
4488
4489 }
4490
4491
4492 }
4493 break;
4494 case 4 :
4495 // InternalVampireLanguage.g:1365:2: ( ruleVLSDefinedTerm )
4496 {
4497 // InternalVampireLanguage.g:1365:2: ( ruleVLSDefinedTerm )
4498 // InternalVampireLanguage.g:1366:3: ruleVLSDefinedTerm
4499 {
4500 before(grammarAccess.getVLSAtomicAccess().getVLSDefinedTermParserRuleCall_3());
4501 pushFollow(FOLLOW_2);
4502 ruleVLSDefinedTerm();
4503
4504 state._fsp--;
4505
4506 after(grammarAccess.getVLSAtomicAccess().getVLSDefinedTermParserRuleCall_3());
4507
4508 }
4509
4510
4511 }
4512 break;
4513
4514 }
4515 }
4516 catch (RecognitionException re) {
4517 reportError(re);
4518 recover(input,re);
4519 }
4520 finally {
4521
4522 restoreStackSize(stackSize);
4523
4524 }
4525 return ;
4526 }
4527 // $ANTLR end "rule__VLSAtomic__Alternatives"
4528
4529
4530 // $ANTLR start "rule__VLSAtomicConstant__Alternatives"
4531 // InternalVampireLanguage.g:1375:1: rule__VLSAtomicConstant__Alternatives : ( ( ( rule__VLSAtomicConstant__Group_0__0 ) ) | ( ( rule__VLSAtomicConstant__Group_1__0 ) ) | ( ( rule__VLSAtomicConstant__Group_2__0 ) ) );
4532 public final void rule__VLSAtomicConstant__Alternatives() throws RecognitionException {
4533
4534 int stackSize = keepStackSize();
4535
4536 try {
4537 // InternalVampireLanguage.g:1379:1: ( ( ( rule__VLSAtomicConstant__Group_0__0 ) ) | ( ( rule__VLSAtomicConstant__Group_1__0 ) ) | ( ( rule__VLSAtomicConstant__Group_2__0 ) ) )
4538 int alt14=3;
4539 switch ( input.LA(1) ) {
4540 case RULE_LOWER_WORD_ID:
4541 case RULE_SINGLE_QUOTE:
4542 case RULE_DOLLAR_ID:
4543 case RULE_DOUBLE_DOLLAR_ID:
4544 case 27:
4545 case 28:
4546 case 29:
4547 case 30:
4548 case 31:
4549 case 32:
4550 case 33:
4551 case 34:
4552 case 35:
4553 case 36:
4554 case 37:
4555 case 38:
4556 case 39:
4557 case 40:
4558 case 41:
4559 {
4560 alt14=1;
4561 }
4562 break;
4563 case 66:
4564 {
4565 alt14=2;
4566 }
4567 break;
4568 case 67:
4569 {
4570 alt14=3;
4571 }
4572 break;
4573 default:
4574 NoViableAltException nvae =
4575 new NoViableAltException("", 14, 0, input);
4576
4577 throw nvae;
4578 }
4579
4580 switch (alt14) {
4581 case 1 :
4582 // InternalVampireLanguage.g:1380:2: ( ( rule__VLSAtomicConstant__Group_0__0 ) )
4583 {
4584 // InternalVampireLanguage.g:1380:2: ( ( rule__VLSAtomicConstant__Group_0__0 ) )
4585 // InternalVampireLanguage.g:1381:3: ( rule__VLSAtomicConstant__Group_0__0 )
4586 {
4587 before(grammarAccess.getVLSAtomicConstantAccess().getGroup_0());
4588 // InternalVampireLanguage.g:1382:3: ( rule__VLSAtomicConstant__Group_0__0 )
4589 // InternalVampireLanguage.g:1382:4: rule__VLSAtomicConstant__Group_0__0
4590 {
4591 pushFollow(FOLLOW_2);
4592 rule__VLSAtomicConstant__Group_0__0();
4593
4594 state._fsp--;
4595
4596
4597 }
4598
4599 after(grammarAccess.getVLSAtomicConstantAccess().getGroup_0());
4600
4601 }
4602
4603
4604 }
4605 break;
4606 case 2 :
4607 // InternalVampireLanguage.g:1386:2: ( ( rule__VLSAtomicConstant__Group_1__0 ) )
4608 {
4609 // InternalVampireLanguage.g:1386:2: ( ( rule__VLSAtomicConstant__Group_1__0 ) )
4610 // InternalVampireLanguage.g:1387:3: ( rule__VLSAtomicConstant__Group_1__0 )
4611 {
4612 before(grammarAccess.getVLSAtomicConstantAccess().getGroup_1());
4613 // InternalVampireLanguage.g:1388:3: ( rule__VLSAtomicConstant__Group_1__0 )
4614 // InternalVampireLanguage.g:1388:4: rule__VLSAtomicConstant__Group_1__0
4615 {
4616 pushFollow(FOLLOW_2);
4617 rule__VLSAtomicConstant__Group_1__0();
4618
4619 state._fsp--;
4620
4621
4622 }
4623
4624 after(grammarAccess.getVLSAtomicConstantAccess().getGroup_1());
4625
4626 }
4627
4628
4629 }
4630 break;
4631 case 3 :
4632 // InternalVampireLanguage.g:1392:2: ( ( rule__VLSAtomicConstant__Group_2__0 ) )
4633 {
4634 // InternalVampireLanguage.g:1392:2: ( ( rule__VLSAtomicConstant__Group_2__0 ) )
4635 // InternalVampireLanguage.g:1393:3: ( rule__VLSAtomicConstant__Group_2__0 )
4636 {
4637 before(grammarAccess.getVLSAtomicConstantAccess().getGroup_2());
4638 // InternalVampireLanguage.g:1394:3: ( rule__VLSAtomicConstant__Group_2__0 )
4639 // InternalVampireLanguage.g:1394:4: rule__VLSAtomicConstant__Group_2__0
4640 {
4641 pushFollow(FOLLOW_2);
4642 rule__VLSAtomicConstant__Group_2__0();
4643
4644 state._fsp--;
4645
4646
4647 }
4648
4649 after(grammarAccess.getVLSAtomicConstantAccess().getGroup_2());
4650
4651 }
4652
4653
4654 }
4655 break;
4656
4657 }
4658 }
4659 catch (RecognitionException re) {
4660 reportError(re);
4661 recover(input,re);
4662 }
4663 finally {
4664
4665 restoreStackSize(stackSize);
4666
4667 }
4668 return ;
4669 }
4670 // $ANTLR end "rule__VLSAtomicConstant__Alternatives"
4671
4672
4673 // $ANTLR start "rule__VLSAtomicConstant__NameAlternatives_0_1_0"
4674 // InternalVampireLanguage.g:1402:1: rule__VLSAtomicConstant__NameAlternatives_0_1_0 : ( ( RULE_LOWER_WORD_ID ) | ( RULE_SINGLE_QUOTE ) | ( RULE_DOLLAR_ID ) | ( RULE_DOUBLE_DOLLAR_ID ) | ( ruleVLSRole ) );
4675 public final void rule__VLSAtomicConstant__NameAlternatives_0_1_0() throws RecognitionException {
4676
4677 int stackSize = keepStackSize();
4678
4679 try {
4680 // InternalVampireLanguage.g:1406:1: ( ( RULE_LOWER_WORD_ID ) | ( RULE_SINGLE_QUOTE ) | ( RULE_DOLLAR_ID ) | ( RULE_DOUBLE_DOLLAR_ID ) | ( ruleVLSRole ) )
4681 int alt15=5;
4682 switch ( input.LA(1) ) {
4683 case RULE_LOWER_WORD_ID:
4684 {
4685 alt15=1;
4686 }
4687 break;
4688 case RULE_SINGLE_QUOTE:
4689 {
4690 alt15=2;
4691 }
4692 break;
4693 case RULE_DOLLAR_ID:
4694 {
4695 alt15=3;
4696 }
4697 break;
4698 case RULE_DOUBLE_DOLLAR_ID:
4699 {
4700 alt15=4;
4701 }
4702 break;
4703 case 27:
4704 case 28:
4705 case 29:
4706 case 30:
4707 case 31:
4708 case 32:
4709 case 33:
4710 case 34:
4711 case 35:
4712 case 36:
4713 case 37:
4714 case 38:
4715 case 39:
4716 case 40:
4717 case 41:
4718 {
4719 alt15=5;
4720 }
4721 break;
4722 default:
4723 NoViableAltException nvae =
4724 new NoViableAltException("", 15, 0, input);
4725
4726 throw nvae;
4727 }
4728
4729 switch (alt15) {
4730 case 1 :
4731 // InternalVampireLanguage.g:1407:2: ( RULE_LOWER_WORD_ID )
4732 {
4733 // InternalVampireLanguage.g:1407:2: ( RULE_LOWER_WORD_ID )
4734 // InternalVampireLanguage.g:1408:3: RULE_LOWER_WORD_ID
4735 {
4736 before(grammarAccess.getVLSAtomicConstantAccess().getNameLOWER_WORD_IDTerminalRuleCall_0_1_0_0());
4737 match(input,RULE_LOWER_WORD_ID,FOLLOW_2);
4738 after(grammarAccess.getVLSAtomicConstantAccess().getNameLOWER_WORD_IDTerminalRuleCall_0_1_0_0());
4739
4740 }
4741
4742
4743 }
4744 break;
4745 case 2 :
4746 // InternalVampireLanguage.g:1413:2: ( RULE_SINGLE_QUOTE )
4747 {
4748 // InternalVampireLanguage.g:1413:2: ( RULE_SINGLE_QUOTE )
4749 // InternalVampireLanguage.g:1414:3: RULE_SINGLE_QUOTE
4750 {
4751 before(grammarAccess.getVLSAtomicConstantAccess().getNameSINGLE_QUOTETerminalRuleCall_0_1_0_1());
4752 match(input,RULE_SINGLE_QUOTE,FOLLOW_2);
4753 after(grammarAccess.getVLSAtomicConstantAccess().getNameSINGLE_QUOTETerminalRuleCall_0_1_0_1());
4754
4755 }
4756
4757
4758 }
4759 break;
4760 case 3 :
4761 // InternalVampireLanguage.g:1419:2: ( RULE_DOLLAR_ID )
4762 {
4763 // InternalVampireLanguage.g:1419:2: ( RULE_DOLLAR_ID )
4764 // InternalVampireLanguage.g:1420:3: RULE_DOLLAR_ID
4765 {
4766 before(grammarAccess.getVLSAtomicConstantAccess().getNameDOLLAR_IDTerminalRuleCall_0_1_0_2());
4767 match(input,RULE_DOLLAR_ID,FOLLOW_2);
4768 after(grammarAccess.getVLSAtomicConstantAccess().getNameDOLLAR_IDTerminalRuleCall_0_1_0_2());
4769
4770 }
4771
4772
4773 }
4774 break;
4775 case 4 :
4776 // InternalVampireLanguage.g:1425:2: ( RULE_DOUBLE_DOLLAR_ID )
4777 {
4778 // InternalVampireLanguage.g:1425:2: ( RULE_DOUBLE_DOLLAR_ID )
4779 // InternalVampireLanguage.g:1426:3: RULE_DOUBLE_DOLLAR_ID
4780 {
4781 before(grammarAccess.getVLSAtomicConstantAccess().getNameDOUBLE_DOLLAR_IDTerminalRuleCall_0_1_0_3());
4782 match(input,RULE_DOUBLE_DOLLAR_ID,FOLLOW_2);
4783 after(grammarAccess.getVLSAtomicConstantAccess().getNameDOUBLE_DOLLAR_IDTerminalRuleCall_0_1_0_3());
4784
4785 }
4786
4787
4788 }
4789 break;
4790 case 5 :
4791 // InternalVampireLanguage.g:1431:2: ( ruleVLSRole )
4792 {
4793 // InternalVampireLanguage.g:1431:2: ( ruleVLSRole )
4794 // InternalVampireLanguage.g:1432:3: ruleVLSRole
4795 {
4796 before(grammarAccess.getVLSAtomicConstantAccess().getNameVLSRoleParserRuleCall_0_1_0_4());
4797 pushFollow(FOLLOW_2);
4798 ruleVLSRole();
4799
4800 state._fsp--;
4801
4802 after(grammarAccess.getVLSAtomicConstantAccess().getNameVLSRoleParserRuleCall_0_1_0_4());
4803
4804 }
4805
4806
4807 }
4808 break;
4809
4810 }
4811 }
4812 catch (RecognitionException re) {
4813 reportError(re);
4814 recover(input,re);
4815 }
4816 finally {
4817
4818 restoreStackSize(stackSize);
4819
4820 }
4821 return ;
4822 }
4823 // $ANTLR end "rule__VLSAtomicConstant__NameAlternatives_0_1_0"
4824
4825
4826 // $ANTLR start "rule__VLSAtomicFunction__Alternatives"
4827 // InternalVampireLanguage.g:1441:1: rule__VLSAtomicFunction__Alternatives : ( ( ( rule__VLSAtomicFunction__Group_0__0 ) ) | ( ( rule__VLSAtomicFunction__Group_1__0 ) ) );
4828 public final void rule__VLSAtomicFunction__Alternatives() throws RecognitionException {
4829
4830 int stackSize = keepStackSize();
4831
4832 try {
4833 // InternalVampireLanguage.g:1445:1: ( ( ( rule__VLSAtomicFunction__Group_0__0 ) ) | ( ( rule__VLSAtomicFunction__Group_1__0 ) ) )
4834 int alt16=2;
4835 int LA16_0 = input.LA(1);
4836
4837 if ( ((LA16_0>=RULE_LOWER_WORD_ID && LA16_0<=RULE_SINGLE_QUOTE)||(LA16_0>=RULE_DOLLAR_ID && LA16_0<=RULE_DOUBLE_DOLLAR_ID)||(LA16_0>=27 && LA16_0<=41)) ) {
4838 alt16=1;
4839 }
4840 else if ( (LA16_0==68) ) {
4841 alt16=2;
4842 }
4843 else {
4844 NoViableAltException nvae =
4845 new NoViableAltException("", 16, 0, input);
4846
4847 throw nvae;
4848 }
4849 switch (alt16) {
4850 case 1 :
4851 // InternalVampireLanguage.g:1446:2: ( ( rule__VLSAtomicFunction__Group_0__0 ) )
4852 {
4853 // InternalVampireLanguage.g:1446:2: ( ( rule__VLSAtomicFunction__Group_0__0 ) )
4854 // InternalVampireLanguage.g:1447:3: ( rule__VLSAtomicFunction__Group_0__0 )
4855 {
4856 before(grammarAccess.getVLSAtomicFunctionAccess().getGroup_0());
4857 // InternalVampireLanguage.g:1448:3: ( rule__VLSAtomicFunction__Group_0__0 )
4858 // InternalVampireLanguage.g:1448:4: rule__VLSAtomicFunction__Group_0__0
4859 {
4860 pushFollow(FOLLOW_2);
4861 rule__VLSAtomicFunction__Group_0__0();
4862
4863 state._fsp--;
4864
4865
4866 }
4867
4868 after(grammarAccess.getVLSAtomicFunctionAccess().getGroup_0());
4869
4870 }
4871
4872
4873 }
4874 break;
4875 case 2 :
4876 // InternalVampireLanguage.g:1452:2: ( ( rule__VLSAtomicFunction__Group_1__0 ) )
4877 {
4878 // InternalVampireLanguage.g:1452:2: ( ( rule__VLSAtomicFunction__Group_1__0 ) )
4879 // InternalVampireLanguage.g:1453:3: ( rule__VLSAtomicFunction__Group_1__0 )
4880 {
4881 before(grammarAccess.getVLSAtomicFunctionAccess().getGroup_1());
4882 // InternalVampireLanguage.g:1454:3: ( rule__VLSAtomicFunction__Group_1__0 )
4883 // InternalVampireLanguage.g:1454:4: rule__VLSAtomicFunction__Group_1__0
4884 {
4885 pushFollow(FOLLOW_2);
4886 rule__VLSAtomicFunction__Group_1__0();
4887
4888 state._fsp--;
4889
4890
4891 }
4892
4893 after(grammarAccess.getVLSAtomicFunctionAccess().getGroup_1());
4894
4895 }
4896
4897
4898 }
4899 break;
4900
4901 }
4902 }
4903 catch (RecognitionException re) {
4904 reportError(re);
4905 recover(input,re);
4906 }
4907 finally {
4908
4909 restoreStackSize(stackSize);
4910
4911 }
4912 return ;
4913 }
4914 // $ANTLR end "rule__VLSAtomicFunction__Alternatives"
4915
4916
4917 // $ANTLR start "rule__VLSAtomicFunction__ConstantAlternatives_0_1_0"
4918 // InternalVampireLanguage.g:1462:1: rule__VLSAtomicFunction__ConstantAlternatives_0_1_0 : ( ( RULE_LOWER_WORD_ID ) | ( RULE_SINGLE_QUOTE ) | ( RULE_DOLLAR_ID ) | ( RULE_DOUBLE_DOLLAR_ID ) | ( ruleVLSRole ) );
4919 public final void rule__VLSAtomicFunction__ConstantAlternatives_0_1_0() throws RecognitionException {
4920
4921 int stackSize = keepStackSize();
4922
4923 try {
4924 // InternalVampireLanguage.g:1466:1: ( ( RULE_LOWER_WORD_ID ) | ( RULE_SINGLE_QUOTE ) | ( RULE_DOLLAR_ID ) | ( RULE_DOUBLE_DOLLAR_ID ) | ( ruleVLSRole ) )
4925 int alt17=5;
4926 switch ( input.LA(1) ) {
4927 case RULE_LOWER_WORD_ID:
4928 {
4929 alt17=1;
4930 }
4931 break;
4932 case RULE_SINGLE_QUOTE:
4933 {
4934 alt17=2;
4935 }
4936 break;
4937 case RULE_DOLLAR_ID:
4938 {
4939 alt17=3;
4940 }
4941 break;
4942 case RULE_DOUBLE_DOLLAR_ID:
4943 {
4944 alt17=4;
4945 }
4946 break;
4947 case 27:
4948 case 28:
4949 case 29:
4950 case 30:
4951 case 31:
4952 case 32:
4953 case 33:
4954 case 34:
4955 case 35:
4956 case 36:
4957 case 37:
4958 case 38:
4959 case 39:
4960 case 40:
4961 case 41:
4962 {
4963 alt17=5;
4964 }
4965 break;
4966 default:
4967 NoViableAltException nvae =
4968 new NoViableAltException("", 17, 0, input);
4969
4970 throw nvae;
4971 }
4972
4973 switch (alt17) {
4974 case 1 :
4975 // InternalVampireLanguage.g:1467:2: ( RULE_LOWER_WORD_ID )
4976 {
4977 // InternalVampireLanguage.g:1467:2: ( RULE_LOWER_WORD_ID )
4978 // InternalVampireLanguage.g:1468:3: RULE_LOWER_WORD_ID
4979 {
4980 before(grammarAccess.getVLSAtomicFunctionAccess().getConstantLOWER_WORD_IDTerminalRuleCall_0_1_0_0());
4981 match(input,RULE_LOWER_WORD_ID,FOLLOW_2);
4982 after(grammarAccess.getVLSAtomicFunctionAccess().getConstantLOWER_WORD_IDTerminalRuleCall_0_1_0_0());
4983
4984 }
4985
4986
4987 }
4988 break;
4989 case 2 :
4990 // InternalVampireLanguage.g:1473:2: ( RULE_SINGLE_QUOTE )
4991 {
4992 // InternalVampireLanguage.g:1473:2: ( RULE_SINGLE_QUOTE )
4993 // InternalVampireLanguage.g:1474:3: RULE_SINGLE_QUOTE
4994 {
4995 before(grammarAccess.getVLSAtomicFunctionAccess().getConstantSINGLE_QUOTETerminalRuleCall_0_1_0_1());
4996 match(input,RULE_SINGLE_QUOTE,FOLLOW_2);
4997 after(grammarAccess.getVLSAtomicFunctionAccess().getConstantSINGLE_QUOTETerminalRuleCall_0_1_0_1());
4998
4999 }
5000
5001
5002 }
5003 break;
5004 case 3 :
5005 // InternalVampireLanguage.g:1479:2: ( RULE_DOLLAR_ID )
5006 {
5007 // InternalVampireLanguage.g:1479:2: ( RULE_DOLLAR_ID )
5008 // InternalVampireLanguage.g:1480:3: RULE_DOLLAR_ID
5009 {
5010 before(grammarAccess.getVLSAtomicFunctionAccess().getConstantDOLLAR_IDTerminalRuleCall_0_1_0_2());
5011 match(input,RULE_DOLLAR_ID,FOLLOW_2);
5012 after(grammarAccess.getVLSAtomicFunctionAccess().getConstantDOLLAR_IDTerminalRuleCall_0_1_0_2());
5013
5014 }
5015
5016
5017 }
5018 break;
5019 case 4 :
5020 // InternalVampireLanguage.g:1485:2: ( RULE_DOUBLE_DOLLAR_ID )
5021 {
5022 // InternalVampireLanguage.g:1485:2: ( RULE_DOUBLE_DOLLAR_ID )
5023 // InternalVampireLanguage.g:1486:3: RULE_DOUBLE_DOLLAR_ID
5024 {
5025 before(grammarAccess.getVLSAtomicFunctionAccess().getConstantDOUBLE_DOLLAR_IDTerminalRuleCall_0_1_0_3());
5026 match(input,RULE_DOUBLE_DOLLAR_ID,FOLLOW_2);
5027 after(grammarAccess.getVLSAtomicFunctionAccess().getConstantDOUBLE_DOLLAR_IDTerminalRuleCall_0_1_0_3());
5028
5029 }
5030
5031
5032 }
5033 break;
5034 case 5 :
5035 // InternalVampireLanguage.g:1491:2: ( ruleVLSRole )
5036 {
5037 // InternalVampireLanguage.g:1491:2: ( ruleVLSRole )
5038 // InternalVampireLanguage.g:1492:3: ruleVLSRole
5039 {
5040 before(grammarAccess.getVLSAtomicFunctionAccess().getConstantVLSRoleParserRuleCall_0_1_0_4());
5041 pushFollow(FOLLOW_2);
5042 ruleVLSRole();
5043
5044 state._fsp--;
5045
5046 after(grammarAccess.getVLSAtomicFunctionAccess().getConstantVLSRoleParserRuleCall_0_1_0_4());
5047
5048 }
5049
5050
5051 }
5052 break;
5053
5054 }
5055 }
5056 catch (RecognitionException re) {
5057 reportError(re);
5058 recover(input,re);
5059 }
5060 finally {
5061
5062 restoreStackSize(stackSize);
5063
5064 }
5065 return ;
5066 }
5067 // $ANTLR end "rule__VLSAtomicFunction__ConstantAlternatives_0_1_0"
5068
5069
5070 // $ANTLR start "rule__VLSFofTerm__Alternatives"
5071 // InternalVampireLanguage.g:1501:1: rule__VLSFofTerm__Alternatives : ( ( ruleVLSVariable ) | ( ruleVLSFunctionFof ) | ( ruleVLSDefinedTerm ) );
5072 public final void rule__VLSFofTerm__Alternatives() throws RecognitionException {
5073
5074 int stackSize = keepStackSize();
5075
5076 try {
5077 // InternalVampireLanguage.g:1505:1: ( ( ruleVLSVariable ) | ( ruleVLSFunctionFof ) | ( ruleVLSDefinedTerm ) )
5078 int alt18=3;
5079 switch ( input.LA(1) ) {
5080 case RULE_UPPER_WORD_ID:
5081 {
5082 alt18=1;
5083 }
5084 break;
5085 case RULE_LOWER_WORD_ID:
5086 case RULE_SINGLE_QUOTE:
5087 case RULE_DOLLAR_ID:
5088 case RULE_DOUBLE_DOLLAR_ID:
5089 {
5090 alt18=2;
5091 }
5092 break;
5093 case RULE_SIGNED_LITERAL:
5094 case RULE_SIGNED_REAL_ID:
5095 case RULE_SIGNED_RAT_ID:
5096 case RULE_DOUBLE_QUOTE:
5097 {
5098 alt18=3;
5099 }
5100 break;
5101 default:
5102 NoViableAltException nvae =
5103 new NoViableAltException("", 18, 0, input);
5104
5105 throw nvae;
5106 }
5107
5108 switch (alt18) {
5109 case 1 :
5110 // InternalVampireLanguage.g:1506:2: ( ruleVLSVariable )
5111 {
5112 // InternalVampireLanguage.g:1506:2: ( ruleVLSVariable )
5113 // InternalVampireLanguage.g:1507:3: ruleVLSVariable
5114 {
5115 before(grammarAccess.getVLSFofTermAccess().getVLSVariableParserRuleCall_0());
5116 pushFollow(FOLLOW_2);
5117 ruleVLSVariable();
5118
5119 state._fsp--;
5120
5121 after(grammarAccess.getVLSFofTermAccess().getVLSVariableParserRuleCall_0());
5122
5123 }
5124
5125
5126 }
5127 break;
5128 case 2 :
5129 // InternalVampireLanguage.g:1512:2: ( ruleVLSFunctionFof )
5130 {
5131 // InternalVampireLanguage.g:1512:2: ( ruleVLSFunctionFof )
5132 // InternalVampireLanguage.g:1513:3: ruleVLSFunctionFof
5133 {
5134 before(grammarAccess.getVLSFofTermAccess().getVLSFunctionFofParserRuleCall_1());
5135 pushFollow(FOLLOW_2);
5136 ruleVLSFunctionFof();
5137
5138 state._fsp--;
5139
5140 after(grammarAccess.getVLSFofTermAccess().getVLSFunctionFofParserRuleCall_1());
5141
5142 }
5143
5144
5145 }
5146 break;
5147 case 3 :
5148 // InternalVampireLanguage.g:1518:2: ( ruleVLSDefinedTerm )
5149 {
5150 // InternalVampireLanguage.g:1518:2: ( ruleVLSDefinedTerm )
5151 // InternalVampireLanguage.g:1519:3: ruleVLSDefinedTerm
5152 {
5153 before(grammarAccess.getVLSFofTermAccess().getVLSDefinedTermParserRuleCall_2());
5154 pushFollow(FOLLOW_2);
5155 ruleVLSDefinedTerm();
5156
5157 state._fsp--;
5158
5159 after(grammarAccess.getVLSFofTermAccess().getVLSDefinedTermParserRuleCall_2());
5160
5161 }
5162
5163
5164 }
5165 break;
5166
5167 }
5168 }
5169 catch (RecognitionException re) {
5170 reportError(re);
5171 recover(input,re);
5172 }
5173 finally {
5174
5175 restoreStackSize(stackSize);
5176
5177 }
5178 return ;
5179 }
5180 // $ANTLR end "rule__VLSFofTerm__Alternatives"
5181
5182
5183 // $ANTLR start "rule__VLSFunctionFof__FunctorAlternatives_0_0"
5184 // InternalVampireLanguage.g:1528:1: rule__VLSFunctionFof__FunctorAlternatives_0_0 : ( ( RULE_LOWER_WORD_ID ) | ( RULE_SINGLE_QUOTE ) | ( RULE_DOLLAR_ID ) | ( RULE_DOUBLE_DOLLAR_ID ) );
5185 public final void rule__VLSFunctionFof__FunctorAlternatives_0_0() throws RecognitionException {
5186
5187 int stackSize = keepStackSize();
5188
5189 try {
5190 // InternalVampireLanguage.g:1532:1: ( ( RULE_LOWER_WORD_ID ) | ( RULE_SINGLE_QUOTE ) | ( RULE_DOLLAR_ID ) | ( RULE_DOUBLE_DOLLAR_ID ) )
5191 int alt19=4;
5192 switch ( input.LA(1) ) {
5193 case RULE_LOWER_WORD_ID:
5194 {
5195 alt19=1;
5196 }
5197 break;
5198 case RULE_SINGLE_QUOTE:
5199 {
5200 alt19=2;
5201 }
5202 break;
5203 case RULE_DOLLAR_ID:
5204 {
5205 alt19=3;
5206 }
5207 break;
5208 case RULE_DOUBLE_DOLLAR_ID:
5209 {
5210 alt19=4;
5211 }
5212 break;
5213 default:
5214 NoViableAltException nvae =
5215 new NoViableAltException("", 19, 0, input);
5216
5217 throw nvae;
5218 }
5219
5220 switch (alt19) {
5221 case 1 :
5222 // InternalVampireLanguage.g:1533:2: ( RULE_LOWER_WORD_ID )
5223 {
5224 // InternalVampireLanguage.g:1533:2: ( RULE_LOWER_WORD_ID )
5225 // InternalVampireLanguage.g:1534:3: RULE_LOWER_WORD_ID
5226 {
5227 before(grammarAccess.getVLSFunctionFofAccess().getFunctorLOWER_WORD_IDTerminalRuleCall_0_0_0());
5228 match(input,RULE_LOWER_WORD_ID,FOLLOW_2);
5229 after(grammarAccess.getVLSFunctionFofAccess().getFunctorLOWER_WORD_IDTerminalRuleCall_0_0_0());
5230
5231 }
5232
5233
5234 }
5235 break;
5236 case 2 :
5237 // InternalVampireLanguage.g:1539:2: ( RULE_SINGLE_QUOTE )
5238 {
5239 // InternalVampireLanguage.g:1539:2: ( RULE_SINGLE_QUOTE )
5240 // InternalVampireLanguage.g:1540:3: RULE_SINGLE_QUOTE
5241 {
5242 before(grammarAccess.getVLSFunctionFofAccess().getFunctorSINGLE_QUOTETerminalRuleCall_0_0_1());
5243 match(input,RULE_SINGLE_QUOTE,FOLLOW_2);
5244 after(grammarAccess.getVLSFunctionFofAccess().getFunctorSINGLE_QUOTETerminalRuleCall_0_0_1());
5245
5246 }
5247
5248
5249 }
5250 break;
5251 case 3 :
5252 // InternalVampireLanguage.g:1545:2: ( RULE_DOLLAR_ID )
5253 {
5254 // InternalVampireLanguage.g:1545:2: ( RULE_DOLLAR_ID )
5255 // InternalVampireLanguage.g:1546:3: RULE_DOLLAR_ID
5256 {
5257 before(grammarAccess.getVLSFunctionFofAccess().getFunctorDOLLAR_IDTerminalRuleCall_0_0_2());
5258 match(input,RULE_DOLLAR_ID,FOLLOW_2);
5259 after(grammarAccess.getVLSFunctionFofAccess().getFunctorDOLLAR_IDTerminalRuleCall_0_0_2());
5260
5261 }
5262
5263
5264 }
5265 break;
5266 case 4 :
5267 // InternalVampireLanguage.g:1551:2: ( RULE_DOUBLE_DOLLAR_ID )
5268 {
5269 // InternalVampireLanguage.g:1551:2: ( RULE_DOUBLE_DOLLAR_ID )
5270 // InternalVampireLanguage.g:1552:3: RULE_DOUBLE_DOLLAR_ID
5271 {
5272 before(grammarAccess.getVLSFunctionFofAccess().getFunctorDOUBLE_DOLLAR_IDTerminalRuleCall_0_0_3());
5273 match(input,RULE_DOUBLE_DOLLAR_ID,FOLLOW_2);
5274 after(grammarAccess.getVLSFunctionFofAccess().getFunctorDOUBLE_DOLLAR_IDTerminalRuleCall_0_0_3());
5275
5276 }
5277
5278
5279 }
5280 break;
5281
5282 }
5283 }
5284 catch (RecognitionException re) {
5285 reportError(re);
5286 recover(input,re);
5287 }
5288 finally {
5289
5290 restoreStackSize(stackSize);
5291
5292 }
5293 return ;
5294 }
5295 // $ANTLR end "rule__VLSFunctionFof__FunctorAlternatives_0_0"
5296
5297
5298 // $ANTLR start "rule__VLSDefinedTerm__Alternatives"
5299 // InternalVampireLanguage.g:1561:1: rule__VLSDefinedTerm__Alternatives : ( ( ( rule__VLSDefinedTerm__Group_0__0 ) ) | ( ( rule__VLSDefinedTerm__Group_1__0 ) ) | ( ( rule__VLSDefinedTerm__Group_2__0 ) ) | ( ( rule__VLSDefinedTerm__Group_3__0 ) ) );
5300 public final void rule__VLSDefinedTerm__Alternatives() throws RecognitionException {
5301
5302 int stackSize = keepStackSize();
5303
5304 try {
5305 // InternalVampireLanguage.g:1565:1: ( ( ( rule__VLSDefinedTerm__Group_0__0 ) ) | ( ( rule__VLSDefinedTerm__Group_1__0 ) ) | ( ( rule__VLSDefinedTerm__Group_2__0 ) ) | ( ( rule__VLSDefinedTerm__Group_3__0 ) ) )
5306 int alt20=4;
5307 switch ( input.LA(1) ) {
5308 case RULE_SIGNED_LITERAL:
5309 {
5310 alt20=1;
5311 }
5312 break;
5313 case RULE_SIGNED_REAL_ID:
5314 {
5315 alt20=2;
5316 }
5317 break;
5318 case RULE_SIGNED_RAT_ID:
5319 {
5320 alt20=3;
5321 }
5322 break;
5323 case RULE_DOUBLE_QUOTE:
5324 {
5325 alt20=4;
5326 }
5327 break;
5328 default:
5329 NoViableAltException nvae =
5330 new NoViableAltException("", 20, 0, input);
5331
5332 throw nvae;
5333 }
5334
5335 switch (alt20) {
5336 case 1 :
5337 // InternalVampireLanguage.g:1566:2: ( ( rule__VLSDefinedTerm__Group_0__0 ) )
5338 {
5339 // InternalVampireLanguage.g:1566:2: ( ( rule__VLSDefinedTerm__Group_0__0 ) )
5340 // InternalVampireLanguage.g:1567:3: ( rule__VLSDefinedTerm__Group_0__0 )
5341 {
5342 before(grammarAccess.getVLSDefinedTermAccess().getGroup_0());
5343 // InternalVampireLanguage.g:1568:3: ( rule__VLSDefinedTerm__Group_0__0 )
5344 // InternalVampireLanguage.g:1568:4: rule__VLSDefinedTerm__Group_0__0
5345 {
5346 pushFollow(FOLLOW_2);
5347 rule__VLSDefinedTerm__Group_0__0();
5348
5349 state._fsp--;
5350
5351
5352 }
5353
5354 after(grammarAccess.getVLSDefinedTermAccess().getGroup_0());
5355
5356 }
5357
5358
5359 }
5360 break;
5361 case 2 :
5362 // InternalVampireLanguage.g:1572:2: ( ( rule__VLSDefinedTerm__Group_1__0 ) )
5363 {
5364 // InternalVampireLanguage.g:1572:2: ( ( rule__VLSDefinedTerm__Group_1__0 ) )
5365 // InternalVampireLanguage.g:1573:3: ( rule__VLSDefinedTerm__Group_1__0 )
5366 {
5367 before(grammarAccess.getVLSDefinedTermAccess().getGroup_1());
5368 // InternalVampireLanguage.g:1574:3: ( rule__VLSDefinedTerm__Group_1__0 )
5369 // InternalVampireLanguage.g:1574:4: rule__VLSDefinedTerm__Group_1__0
5370 {
5371 pushFollow(FOLLOW_2);
5372 rule__VLSDefinedTerm__Group_1__0();
5373
5374 state._fsp--;
5375
5376
5377 }
5378
5379 after(grammarAccess.getVLSDefinedTermAccess().getGroup_1());
5380
5381 }
5382
5383
5384 }
5385 break;
5386 case 3 :
5387 // InternalVampireLanguage.g:1578:2: ( ( rule__VLSDefinedTerm__Group_2__0 ) )
5388 {
5389 // InternalVampireLanguage.g:1578:2: ( ( rule__VLSDefinedTerm__Group_2__0 ) )
5390 // InternalVampireLanguage.g:1579:3: ( rule__VLSDefinedTerm__Group_2__0 )
5391 {
5392 before(grammarAccess.getVLSDefinedTermAccess().getGroup_2());
5393 // InternalVampireLanguage.g:1580:3: ( rule__VLSDefinedTerm__Group_2__0 )
5394 // InternalVampireLanguage.g:1580:4: rule__VLSDefinedTerm__Group_2__0
5395 {
5396 pushFollow(FOLLOW_2);
5397 rule__VLSDefinedTerm__Group_2__0();
5398
5399 state._fsp--;
5400
5401
5402 }
5403
5404 after(grammarAccess.getVLSDefinedTermAccess().getGroup_2());
5405
5406 }
5407
5408
5409 }
5410 break;
5411 case 4 :
5412 // InternalVampireLanguage.g:1584:2: ( ( rule__VLSDefinedTerm__Group_3__0 ) )
5413 {
5414 // InternalVampireLanguage.g:1584:2: ( ( rule__VLSDefinedTerm__Group_3__0 ) )
5415 // InternalVampireLanguage.g:1585:3: ( rule__VLSDefinedTerm__Group_3__0 )
5416 {
5417 before(grammarAccess.getVLSDefinedTermAccess().getGroup_3());
5418 // InternalVampireLanguage.g:1586:3: ( rule__VLSDefinedTerm__Group_3__0 )
5419 // InternalVampireLanguage.g:1586:4: rule__VLSDefinedTerm__Group_3__0
5420 {
5421 pushFollow(FOLLOW_2);
5422 rule__VLSDefinedTerm__Group_3__0();
5423
5424 state._fsp--;
5425
5426
5427 }
5428
5429 after(grammarAccess.getVLSDefinedTermAccess().getGroup_3());
5430
5431 }
5432
5433
5434 }
5435 break;
5436
5437 }
5438 }
5439 catch (RecognitionException re) {
5440 reportError(re);
5441 recover(input,re);
5442 }
5443 finally {
5444
5445 restoreStackSize(stackSize);
5446
5447 }
5448 return ;
5449 }
5450 // $ANTLR end "rule__VLSDefinedTerm__Alternatives"
5451
5452
5453 // $ANTLR start "rule__VLSInclude__Group__0"
5454 // InternalVampireLanguage.g:1594:1: rule__VLSInclude__Group__0 : rule__VLSInclude__Group__0__Impl rule__VLSInclude__Group__1 ;
5455 public final void rule__VLSInclude__Group__0() throws RecognitionException {
5456
5457 int stackSize = keepStackSize();
5458
5459 try {
5460 // InternalVampireLanguage.g:1598:1: ( rule__VLSInclude__Group__0__Impl rule__VLSInclude__Group__1 )
5461 // InternalVampireLanguage.g:1599:2: rule__VLSInclude__Group__0__Impl rule__VLSInclude__Group__1
5462 {
5463 pushFollow(FOLLOW_6);
5464 rule__VLSInclude__Group__0__Impl();
5465
5466 state._fsp--;
5467
5468 pushFollow(FOLLOW_2);
5469 rule__VLSInclude__Group__1();
5470
5471 state._fsp--;
5472
5473
5474 }
5475
5476 }
5477 catch (RecognitionException re) {
5478 reportError(re);
5479 recover(input,re);
5480 }
5481 finally {
5482
5483 restoreStackSize(stackSize);
5484
5485 }
5486 return ;
5487 }
5488 // $ANTLR end "rule__VLSInclude__Group__0"
5489
5490
5491 // $ANTLR start "rule__VLSInclude__Group__0__Impl"
5492 // InternalVampireLanguage.g:1606:1: rule__VLSInclude__Group__0__Impl : ( 'include(' ) ;
5493 public final void rule__VLSInclude__Group__0__Impl() throws RecognitionException {
5494
5495 int stackSize = keepStackSize();
5496
5497 try {
5498 // InternalVampireLanguage.g:1610:1: ( ( 'include(' ) )
5499 // InternalVampireLanguage.g:1611:1: ( 'include(' )
5500 {
5501 // InternalVampireLanguage.g:1611:1: ( 'include(' )
5502 // InternalVampireLanguage.g:1612:2: 'include('
5503 {
5504 before(grammarAccess.getVLSIncludeAccess().getIncludeKeyword_0());
5505 match(input,42,FOLLOW_2);
5506 after(grammarAccess.getVLSIncludeAccess().getIncludeKeyword_0());
5507
5508 }
5509
5510
5511 }
5512
5513 }
5514 catch (RecognitionException re) {
5515 reportError(re);
5516 recover(input,re);
5517 }
5518 finally {
5519
5520 restoreStackSize(stackSize);
5521
5522 }
5523 return ;
5524 }
5525 // $ANTLR end "rule__VLSInclude__Group__0__Impl"
5526
5527
5528 // $ANTLR start "rule__VLSInclude__Group__1"
5529 // InternalVampireLanguage.g:1621:1: rule__VLSInclude__Group__1 : rule__VLSInclude__Group__1__Impl rule__VLSInclude__Group__2 ;
5530 public final void rule__VLSInclude__Group__1() throws RecognitionException {
5531
5532 int stackSize = keepStackSize();
5533
5534 try {
5535 // InternalVampireLanguage.g:1625:1: ( rule__VLSInclude__Group__1__Impl rule__VLSInclude__Group__2 )
5536 // InternalVampireLanguage.g:1626:2: rule__VLSInclude__Group__1__Impl rule__VLSInclude__Group__2
5537 {
5538 pushFollow(FOLLOW_7);
5539 rule__VLSInclude__Group__1__Impl();
5540
5541 state._fsp--;
5542
5543 pushFollow(FOLLOW_2);
5544 rule__VLSInclude__Group__2();
5545
5546 state._fsp--;
5547
5548
5549 }
5550
5551 }
5552 catch (RecognitionException re) {
5553 reportError(re);
5554 recover(input,re);
5555 }
5556 finally {
5557
5558 restoreStackSize(stackSize);
5559
5560 }
5561 return ;
5562 }
5563 // $ANTLR end "rule__VLSInclude__Group__1"
5564
5565
5566 // $ANTLR start "rule__VLSInclude__Group__1__Impl"
5567 // InternalVampireLanguage.g:1633:1: rule__VLSInclude__Group__1__Impl : ( ( rule__VLSInclude__FileNameAssignment_1 ) ) ;
5568 public final void rule__VLSInclude__Group__1__Impl() throws RecognitionException {
5569
5570 int stackSize = keepStackSize();
5571
5572 try {
5573 // InternalVampireLanguage.g:1637:1: ( ( ( rule__VLSInclude__FileNameAssignment_1 ) ) )
5574 // InternalVampireLanguage.g:1638:1: ( ( rule__VLSInclude__FileNameAssignment_1 ) )
5575 {
5576 // InternalVampireLanguage.g:1638:1: ( ( rule__VLSInclude__FileNameAssignment_1 ) )
5577 // InternalVampireLanguage.g:1639:2: ( rule__VLSInclude__FileNameAssignment_1 )
5578 {
5579 before(grammarAccess.getVLSIncludeAccess().getFileNameAssignment_1());
5580 // InternalVampireLanguage.g:1640:2: ( rule__VLSInclude__FileNameAssignment_1 )
5581 // InternalVampireLanguage.g:1640:3: rule__VLSInclude__FileNameAssignment_1
5582 {
5583 pushFollow(FOLLOW_2);
5584 rule__VLSInclude__FileNameAssignment_1();
5585
5586 state._fsp--;
5587
5588
5589 }
5590
5591 after(grammarAccess.getVLSIncludeAccess().getFileNameAssignment_1());
5592
5593 }
5594
5595
5596 }
5597
5598 }
5599 catch (RecognitionException re) {
5600 reportError(re);
5601 recover(input,re);
5602 }
5603 finally {
5604
5605 restoreStackSize(stackSize);
5606
5607 }
5608 return ;
5609 }
5610 // $ANTLR end "rule__VLSInclude__Group__1__Impl"
5611
5612
5613 // $ANTLR start "rule__VLSInclude__Group__2"
5614 // InternalVampireLanguage.g:1648:1: rule__VLSInclude__Group__2 : rule__VLSInclude__Group__2__Impl ;
5615 public final void rule__VLSInclude__Group__2() throws RecognitionException {
5616
5617 int stackSize = keepStackSize();
5618
5619 try {
5620 // InternalVampireLanguage.g:1652:1: ( rule__VLSInclude__Group__2__Impl )
5621 // InternalVampireLanguage.g:1653:2: rule__VLSInclude__Group__2__Impl
5622 {
5623 pushFollow(FOLLOW_2);
5624 rule__VLSInclude__Group__2__Impl();
5625
5626 state._fsp--;
5627
5628
5629 }
5630
5631 }
5632 catch (RecognitionException re) {
5633 reportError(re);
5634 recover(input,re);
5635 }
5636 finally {
5637
5638 restoreStackSize(stackSize);
5639
5640 }
5641 return ;
5642 }
5643 // $ANTLR end "rule__VLSInclude__Group__2"
5644
5645
5646 // $ANTLR start "rule__VLSInclude__Group__2__Impl"
5647 // InternalVampireLanguage.g:1659:1: rule__VLSInclude__Group__2__Impl : ( ( rule__VLSInclude__Group_2__0 )? ) ;
5648 public final void rule__VLSInclude__Group__2__Impl() throws RecognitionException {
5649
5650 int stackSize = keepStackSize();
5651
5652 try {
5653 // InternalVampireLanguage.g:1663:1: ( ( ( rule__VLSInclude__Group_2__0 )? ) )
5654 // InternalVampireLanguage.g:1664:1: ( ( rule__VLSInclude__Group_2__0 )? )
5655 {
5656 // InternalVampireLanguage.g:1664:1: ( ( rule__VLSInclude__Group_2__0 )? )
5657 // InternalVampireLanguage.g:1665:2: ( rule__VLSInclude__Group_2__0 )?
5658 {
5659 before(grammarAccess.getVLSIncludeAccess().getGroup_2());
5660 // InternalVampireLanguage.g:1666:2: ( rule__VLSInclude__Group_2__0 )?
5661 int alt21=2;
5662 int LA21_0 = input.LA(1);
5663
5664 if ( (LA21_0==43) ) {
5665 alt21=1;
5666 }
5667 switch (alt21) {
5668 case 1 :
5669 // InternalVampireLanguage.g:1666:3: rule__VLSInclude__Group_2__0
5670 {
5671 pushFollow(FOLLOW_2);
5672 rule__VLSInclude__Group_2__0();
5673
5674 state._fsp--;
5675
5676
5677 }
5678 break;
5679
5680 }
5681
5682 after(grammarAccess.getVLSIncludeAccess().getGroup_2());
5683
5684 }
5685
5686
5687 }
5688
5689 }
5690 catch (RecognitionException re) {
5691 reportError(re);
5692 recover(input,re);
5693 }
5694 finally {
5695
5696 restoreStackSize(stackSize);
5697
5698 }
5699 return ;
5700 }
5701 // $ANTLR end "rule__VLSInclude__Group__2__Impl"
5702
5703
5704 // $ANTLR start "rule__VLSInclude__Group_2__0"
5705 // InternalVampireLanguage.g:1675:1: rule__VLSInclude__Group_2__0 : rule__VLSInclude__Group_2__0__Impl rule__VLSInclude__Group_2__1 ;
5706 public final void rule__VLSInclude__Group_2__0() throws RecognitionException {
5707
5708 int stackSize = keepStackSize();
5709
5710 try {
5711 // InternalVampireLanguage.g:1679:1: ( rule__VLSInclude__Group_2__0__Impl rule__VLSInclude__Group_2__1 )
5712 // InternalVampireLanguage.g:1680:2: rule__VLSInclude__Group_2__0__Impl rule__VLSInclude__Group_2__1
5713 {
5714 pushFollow(FOLLOW_8);
5715 rule__VLSInclude__Group_2__0__Impl();
5716
5717 state._fsp--;
5718
5719 pushFollow(FOLLOW_2);
5720 rule__VLSInclude__Group_2__1();
5721
5722 state._fsp--;
5723
5724
5725 }
5726
5727 }
5728 catch (RecognitionException re) {
5729 reportError(re);
5730 recover(input,re);
5731 }
5732 finally {
5733
5734 restoreStackSize(stackSize);
5735
5736 }
5737 return ;
5738 }
5739 // $ANTLR end "rule__VLSInclude__Group_2__0"
5740
5741
5742 // $ANTLR start "rule__VLSInclude__Group_2__0__Impl"
5743 // InternalVampireLanguage.g:1687:1: rule__VLSInclude__Group_2__0__Impl : ( ',[' ) ;
5744 public final void rule__VLSInclude__Group_2__0__Impl() throws RecognitionException {
5745
5746 int stackSize = keepStackSize();
5747
5748 try {
5749 // InternalVampireLanguage.g:1691:1: ( ( ',[' ) )
5750 // InternalVampireLanguage.g:1692:1: ( ',[' )
5751 {
5752 // InternalVampireLanguage.g:1692:1: ( ',[' )
5753 // InternalVampireLanguage.g:1693:2: ',['
5754 {
5755 before(grammarAccess.getVLSIncludeAccess().getCommaLeftSquareBracketKeyword_2_0());
5756 match(input,43,FOLLOW_2);
5757 after(grammarAccess.getVLSIncludeAccess().getCommaLeftSquareBracketKeyword_2_0());
5758
5759 }
5760
5761
5762 }
5763
5764 }
5765 catch (RecognitionException re) {
5766 reportError(re);
5767 recover(input,re);
5768 }
5769 finally {
5770
5771 restoreStackSize(stackSize);
5772
5773 }
5774 return ;
5775 }
5776 // $ANTLR end "rule__VLSInclude__Group_2__0__Impl"
5777
5778
5779 // $ANTLR start "rule__VLSInclude__Group_2__1"
5780 // InternalVampireLanguage.g:1702:1: rule__VLSInclude__Group_2__1 : rule__VLSInclude__Group_2__1__Impl rule__VLSInclude__Group_2__2 ;
5781 public final void rule__VLSInclude__Group_2__1() throws RecognitionException {
5782
5783 int stackSize = keepStackSize();
5784
5785 try {
5786 // InternalVampireLanguage.g:1706:1: ( rule__VLSInclude__Group_2__1__Impl rule__VLSInclude__Group_2__2 )
5787 // InternalVampireLanguage.g:1707:2: rule__VLSInclude__Group_2__1__Impl rule__VLSInclude__Group_2__2
5788 {
5789 pushFollow(FOLLOW_9);
5790 rule__VLSInclude__Group_2__1__Impl();
5791
5792 state._fsp--;
5793
5794 pushFollow(FOLLOW_2);
5795 rule__VLSInclude__Group_2__2();
5796
5797 state._fsp--;
5798
5799
5800 }
5801
5802 }
5803 catch (RecognitionException re) {
5804 reportError(re);
5805 recover(input,re);
5806 }
5807 finally {
5808
5809 restoreStackSize(stackSize);
5810
5811 }
5812 return ;
5813 }
5814 // $ANTLR end "rule__VLSInclude__Group_2__1"
5815
5816
5817 // $ANTLR start "rule__VLSInclude__Group_2__1__Impl"
5818 // InternalVampireLanguage.g:1714:1: rule__VLSInclude__Group_2__1__Impl : ( ( rule__VLSInclude__NamesAssignment_2_1 ) ) ;
5819 public final void rule__VLSInclude__Group_2__1__Impl() throws RecognitionException {
5820
5821 int stackSize = keepStackSize();
5822
5823 try {
5824 // InternalVampireLanguage.g:1718:1: ( ( ( rule__VLSInclude__NamesAssignment_2_1 ) ) )
5825 // InternalVampireLanguage.g:1719:1: ( ( rule__VLSInclude__NamesAssignment_2_1 ) )
5826 {
5827 // InternalVampireLanguage.g:1719:1: ( ( rule__VLSInclude__NamesAssignment_2_1 ) )
5828 // InternalVampireLanguage.g:1720:2: ( rule__VLSInclude__NamesAssignment_2_1 )
5829 {
5830 before(grammarAccess.getVLSIncludeAccess().getNamesAssignment_2_1());
5831 // InternalVampireLanguage.g:1721:2: ( rule__VLSInclude__NamesAssignment_2_1 )
5832 // InternalVampireLanguage.g:1721:3: rule__VLSInclude__NamesAssignment_2_1
5833 {
5834 pushFollow(FOLLOW_2);
5835 rule__VLSInclude__NamesAssignment_2_1();
5836
5837 state._fsp--;
5838
5839
5840 }
5841
5842 after(grammarAccess.getVLSIncludeAccess().getNamesAssignment_2_1());
5843
5844 }
5845
5846
5847 }
5848
5849 }
5850 catch (RecognitionException re) {
5851 reportError(re);
5852 recover(input,re);
5853 }
5854 finally {
5855
5856 restoreStackSize(stackSize);
5857
5858 }
5859 return ;
5860 }
5861 // $ANTLR end "rule__VLSInclude__Group_2__1__Impl"
5862
5863
5864 // $ANTLR start "rule__VLSInclude__Group_2__2"
5865 // InternalVampireLanguage.g:1729:1: rule__VLSInclude__Group_2__2 : rule__VLSInclude__Group_2__2__Impl rule__VLSInclude__Group_2__3 ;
5866 public final void rule__VLSInclude__Group_2__2() throws RecognitionException {
5867
5868 int stackSize = keepStackSize();
5869
5870 try {
5871 // InternalVampireLanguage.g:1733:1: ( rule__VLSInclude__Group_2__2__Impl rule__VLSInclude__Group_2__3 )
5872 // InternalVampireLanguage.g:1734:2: rule__VLSInclude__Group_2__2__Impl rule__VLSInclude__Group_2__3
5873 {
5874 pushFollow(FOLLOW_9);
5875 rule__VLSInclude__Group_2__2__Impl();
5876
5877 state._fsp--;
5878
5879 pushFollow(FOLLOW_2);
5880 rule__VLSInclude__Group_2__3();
5881
5882 state._fsp--;
5883
5884
5885 }
5886
5887 }
5888 catch (RecognitionException re) {
5889 reportError(re);
5890 recover(input,re);
5891 }
5892 finally {
5893
5894 restoreStackSize(stackSize);
5895
5896 }
5897 return ;
5898 }
5899 // $ANTLR end "rule__VLSInclude__Group_2__2"
5900
5901
5902 // $ANTLR start "rule__VLSInclude__Group_2__2__Impl"
5903 // InternalVampireLanguage.g:1741:1: rule__VLSInclude__Group_2__2__Impl : ( ( rule__VLSInclude__Group_2_2__0 )* ) ;
5904 public final void rule__VLSInclude__Group_2__2__Impl() throws RecognitionException {
5905
5906 int stackSize = keepStackSize();
5907
5908 try {
5909 // InternalVampireLanguage.g:1745:1: ( ( ( rule__VLSInclude__Group_2_2__0 )* ) )
5910 // InternalVampireLanguage.g:1746:1: ( ( rule__VLSInclude__Group_2_2__0 )* )
5911 {
5912 // InternalVampireLanguage.g:1746:1: ( ( rule__VLSInclude__Group_2_2__0 )* )
5913 // InternalVampireLanguage.g:1747:2: ( rule__VLSInclude__Group_2_2__0 )*
5914 {
5915 before(grammarAccess.getVLSIncludeAccess().getGroup_2_2());
5916 // InternalVampireLanguage.g:1748:2: ( rule__VLSInclude__Group_2_2__0 )*
5917 loop22:
5918 do {
5919 int alt22=2;
5920 int LA22_0 = input.LA(1);
5921
5922 if ( (LA22_0==45) ) {
5923 alt22=1;
5924 }
5925
5926
5927 switch (alt22) {
5928 case 1 :
5929 // InternalVampireLanguage.g:1748:3: rule__VLSInclude__Group_2_2__0
5930 {
5931 pushFollow(FOLLOW_10);
5932 rule__VLSInclude__Group_2_2__0();
5933
5934 state._fsp--;
5935
5936
5937 }
5938 break;
5939
5940 default :
5941 break loop22;
5942 }
5943 } while (true);
5944
5945 after(grammarAccess.getVLSIncludeAccess().getGroup_2_2());
5946
5947 }
5948
5949
5950 }
5951
5952 }
5953 catch (RecognitionException re) {
5954 reportError(re);
5955 recover(input,re);
5956 }
5957 finally {
5958
5959 restoreStackSize(stackSize);
5960
5961 }
5962 return ;
5963 }
5964 // $ANTLR end "rule__VLSInclude__Group_2__2__Impl"
5965
5966
5967 // $ANTLR start "rule__VLSInclude__Group_2__3"
5968 // InternalVampireLanguage.g:1756:1: rule__VLSInclude__Group_2__3 : rule__VLSInclude__Group_2__3__Impl ;
5969 public final void rule__VLSInclude__Group_2__3() throws RecognitionException {
5970
5971 int stackSize = keepStackSize();
5972
5973 try {
5974 // InternalVampireLanguage.g:1760:1: ( rule__VLSInclude__Group_2__3__Impl )
5975 // InternalVampireLanguage.g:1761:2: rule__VLSInclude__Group_2__3__Impl
5976 {
5977 pushFollow(FOLLOW_2);
5978 rule__VLSInclude__Group_2__3__Impl();
5979
5980 state._fsp--;
5981
5982
5983 }
5984
5985 }
5986 catch (RecognitionException re) {
5987 reportError(re);
5988 recover(input,re);
5989 }
5990 finally {
5991
5992 restoreStackSize(stackSize);
5993
5994 }
5995 return ;
5996 }
5997 // $ANTLR end "rule__VLSInclude__Group_2__3"
5998
5999
6000 // $ANTLR start "rule__VLSInclude__Group_2__3__Impl"
6001 // InternalVampireLanguage.g:1767:1: rule__VLSInclude__Group_2__3__Impl : ( ']' ) ;
6002 public final void rule__VLSInclude__Group_2__3__Impl() throws RecognitionException {
6003
6004 int stackSize = keepStackSize();
6005
6006 try {
6007 // InternalVampireLanguage.g:1771:1: ( ( ']' ) )
6008 // InternalVampireLanguage.g:1772:1: ( ']' )
6009 {
6010 // InternalVampireLanguage.g:1772:1: ( ']' )
6011 // InternalVampireLanguage.g:1773:2: ']'
6012 {
6013 before(grammarAccess.getVLSIncludeAccess().getRightSquareBracketKeyword_2_3());
6014 match(input,44,FOLLOW_2);
6015 after(grammarAccess.getVLSIncludeAccess().getRightSquareBracketKeyword_2_3());
6016
6017 }
6018
6019
6020 }
6021
6022 }
6023 catch (RecognitionException re) {
6024 reportError(re);
6025 recover(input,re);
6026 }
6027 finally {
6028
6029 restoreStackSize(stackSize);
6030
6031 }
6032 return ;
6033 }
6034 // $ANTLR end "rule__VLSInclude__Group_2__3__Impl"
6035
6036
6037 // $ANTLR start "rule__VLSInclude__Group_2_2__0"
6038 // InternalVampireLanguage.g:1783:1: rule__VLSInclude__Group_2_2__0 : rule__VLSInclude__Group_2_2__0__Impl rule__VLSInclude__Group_2_2__1 ;
6039 public final void rule__VLSInclude__Group_2_2__0() throws RecognitionException {
6040
6041 int stackSize = keepStackSize();
6042
6043 try {
6044 // InternalVampireLanguage.g:1787:1: ( rule__VLSInclude__Group_2_2__0__Impl rule__VLSInclude__Group_2_2__1 )
6045 // InternalVampireLanguage.g:1788:2: rule__VLSInclude__Group_2_2__0__Impl rule__VLSInclude__Group_2_2__1
6046 {
6047 pushFollow(FOLLOW_8);
6048 rule__VLSInclude__Group_2_2__0__Impl();
6049
6050 state._fsp--;
6051
6052 pushFollow(FOLLOW_2);
6053 rule__VLSInclude__Group_2_2__1();
6054
6055 state._fsp--;
6056
6057
6058 }
6059
6060 }
6061 catch (RecognitionException re) {
6062 reportError(re);
6063 recover(input,re);
6064 }
6065 finally {
6066
6067 restoreStackSize(stackSize);
6068
6069 }
6070 return ;
6071 }
6072 // $ANTLR end "rule__VLSInclude__Group_2_2__0"
6073
6074
6075 // $ANTLR start "rule__VLSInclude__Group_2_2__0__Impl"
6076 // InternalVampireLanguage.g:1795:1: rule__VLSInclude__Group_2_2__0__Impl : ( ',' ) ;
6077 public final void rule__VLSInclude__Group_2_2__0__Impl() throws RecognitionException {
6078
6079 int stackSize = keepStackSize();
6080
6081 try {
6082 // InternalVampireLanguage.g:1799:1: ( ( ',' ) )
6083 // InternalVampireLanguage.g:1800:1: ( ',' )
6084 {
6085 // InternalVampireLanguage.g:1800:1: ( ',' )
6086 // InternalVampireLanguage.g:1801:2: ','
6087 {
6088 before(grammarAccess.getVLSIncludeAccess().getCommaKeyword_2_2_0());
6089 match(input,45,FOLLOW_2);
6090 after(grammarAccess.getVLSIncludeAccess().getCommaKeyword_2_2_0());
6091
6092 }
6093
6094
6095 }
6096
6097 }
6098 catch (RecognitionException re) {
6099 reportError(re);
6100 recover(input,re);
6101 }
6102 finally {
6103
6104 restoreStackSize(stackSize);
6105
6106 }
6107 return ;
6108 }
6109 // $ANTLR end "rule__VLSInclude__Group_2_2__0__Impl"
6110
6111
6112 // $ANTLR start "rule__VLSInclude__Group_2_2__1"
6113 // InternalVampireLanguage.g:1810:1: rule__VLSInclude__Group_2_2__1 : rule__VLSInclude__Group_2_2__1__Impl ;
6114 public final void rule__VLSInclude__Group_2_2__1() throws RecognitionException {
6115
6116 int stackSize = keepStackSize();
6117
6118 try {
6119 // InternalVampireLanguage.g:1814:1: ( rule__VLSInclude__Group_2_2__1__Impl )
6120 // InternalVampireLanguage.g:1815:2: rule__VLSInclude__Group_2_2__1__Impl
6121 {
6122 pushFollow(FOLLOW_2);
6123 rule__VLSInclude__Group_2_2__1__Impl();
6124
6125 state._fsp--;
6126
6127
6128 }
6129
6130 }
6131 catch (RecognitionException re) {
6132 reportError(re);
6133 recover(input,re);
6134 }
6135 finally {
6136
6137 restoreStackSize(stackSize);
6138
6139 }
6140 return ;
6141 }
6142 // $ANTLR end "rule__VLSInclude__Group_2_2__1"
6143
6144
6145 // $ANTLR start "rule__VLSInclude__Group_2_2__1__Impl"
6146 // InternalVampireLanguage.g:1821:1: rule__VLSInclude__Group_2_2__1__Impl : ( ( rule__VLSInclude__NamesAssignment_2_2_1 ) ) ;
6147 public final void rule__VLSInclude__Group_2_2__1__Impl() throws RecognitionException {
6148
6149 int stackSize = keepStackSize();
6150
6151 try {
6152 // InternalVampireLanguage.g:1825:1: ( ( ( rule__VLSInclude__NamesAssignment_2_2_1 ) ) )
6153 // InternalVampireLanguage.g:1826:1: ( ( rule__VLSInclude__NamesAssignment_2_2_1 ) )
6154 {
6155 // InternalVampireLanguage.g:1826:1: ( ( rule__VLSInclude__NamesAssignment_2_2_1 ) )
6156 // InternalVampireLanguage.g:1827:2: ( rule__VLSInclude__NamesAssignment_2_2_1 )
6157 {
6158 before(grammarAccess.getVLSIncludeAccess().getNamesAssignment_2_2_1());
6159 // InternalVampireLanguage.g:1828:2: ( rule__VLSInclude__NamesAssignment_2_2_1 )
6160 // InternalVampireLanguage.g:1828:3: rule__VLSInclude__NamesAssignment_2_2_1
6161 {
6162 pushFollow(FOLLOW_2);
6163 rule__VLSInclude__NamesAssignment_2_2_1();
6164
6165 state._fsp--;
6166
6167
6168 }
6169
6170 after(grammarAccess.getVLSIncludeAccess().getNamesAssignment_2_2_1());
6171
6172 }
6173
6174
6175 }
6176
6177 }
6178 catch (RecognitionException re) {
6179 reportError(re);
6180 recover(input,re);
6181 }
6182 finally {
6183
6184 restoreStackSize(stackSize);
6185
6186 }
6187 return ;
6188 }
6189 // $ANTLR end "rule__VLSInclude__Group_2_2__1__Impl"
6190
6191
6192 // $ANTLR start "rule__VLSFofFormula__Group__0"
6193 // InternalVampireLanguage.g:1837:1: rule__VLSFofFormula__Group__0 : rule__VLSFofFormula__Group__0__Impl rule__VLSFofFormula__Group__1 ;
6194 public final void rule__VLSFofFormula__Group__0() throws RecognitionException {
6195
6196 int stackSize = keepStackSize();
6197
6198 try {
6199 // InternalVampireLanguage.g:1841:1: ( rule__VLSFofFormula__Group__0__Impl rule__VLSFofFormula__Group__1 )
6200 // InternalVampireLanguage.g:1842:2: rule__VLSFofFormula__Group__0__Impl rule__VLSFofFormula__Group__1
6201 {
6202 pushFollow(FOLLOW_11);
6203 rule__VLSFofFormula__Group__0__Impl();
6204
6205 state._fsp--;
6206
6207 pushFollow(FOLLOW_2);
6208 rule__VLSFofFormula__Group__1();
6209
6210 state._fsp--;
6211
6212
6213 }
6214
6215 }
6216 catch (RecognitionException re) {
6217 reportError(re);
6218 recover(input,re);
6219 }
6220 finally {
6221
6222 restoreStackSize(stackSize);
6223
6224 }
6225 return ;
6226 }
6227 // $ANTLR end "rule__VLSFofFormula__Group__0"
6228
6229
6230 // $ANTLR start "rule__VLSFofFormula__Group__0__Impl"
6231 // InternalVampireLanguage.g:1849:1: rule__VLSFofFormula__Group__0__Impl : ( 'fof' ) ;
6232 public final void rule__VLSFofFormula__Group__0__Impl() throws RecognitionException {
6233
6234 int stackSize = keepStackSize();
6235
6236 try {
6237 // InternalVampireLanguage.g:1853:1: ( ( 'fof' ) )
6238 // InternalVampireLanguage.g:1854:1: ( 'fof' )
6239 {
6240 // InternalVampireLanguage.g:1854:1: ( 'fof' )
6241 // InternalVampireLanguage.g:1855:2: 'fof'
6242 {
6243 before(grammarAccess.getVLSFofFormulaAccess().getFofKeyword_0());
6244 match(input,46,FOLLOW_2);
6245 after(grammarAccess.getVLSFofFormulaAccess().getFofKeyword_0());
6246
6247 }
6248
6249
6250 }
6251
6252 }
6253 catch (RecognitionException re) {
6254 reportError(re);
6255 recover(input,re);
6256 }
6257 finally {
6258
6259 restoreStackSize(stackSize);
6260
6261 }
6262 return ;
6263 }
6264 // $ANTLR end "rule__VLSFofFormula__Group__0__Impl"
6265
6266
6267 // $ANTLR start "rule__VLSFofFormula__Group__1"
6268 // InternalVampireLanguage.g:1864:1: rule__VLSFofFormula__Group__1 : rule__VLSFofFormula__Group__1__Impl rule__VLSFofFormula__Group__2 ;
6269 public final void rule__VLSFofFormula__Group__1() throws RecognitionException {
6270
6271 int stackSize = keepStackSize();
6272
6273 try {
6274 // InternalVampireLanguage.g:1868:1: ( rule__VLSFofFormula__Group__1__Impl rule__VLSFofFormula__Group__2 )
6275 // InternalVampireLanguage.g:1869:2: rule__VLSFofFormula__Group__1__Impl rule__VLSFofFormula__Group__2
6276 {
6277 pushFollow(FOLLOW_12);
6278 rule__VLSFofFormula__Group__1__Impl();
6279
6280 state._fsp--;
6281
6282 pushFollow(FOLLOW_2);
6283 rule__VLSFofFormula__Group__2();
6284
6285 state._fsp--;
6286
6287
6288 }
6289
6290 }
6291 catch (RecognitionException re) {
6292 reportError(re);
6293 recover(input,re);
6294 }
6295 finally {
6296
6297 restoreStackSize(stackSize);
6298
6299 }
6300 return ;
6301 }
6302 // $ANTLR end "rule__VLSFofFormula__Group__1"
6303
6304
6305 // $ANTLR start "rule__VLSFofFormula__Group__1__Impl"
6306 // InternalVampireLanguage.g:1876:1: rule__VLSFofFormula__Group__1__Impl : ( '(' ) ;
6307 public final void rule__VLSFofFormula__Group__1__Impl() throws RecognitionException {
6308
6309 int stackSize = keepStackSize();
6310
6311 try {
6312 // InternalVampireLanguage.g:1880:1: ( ( '(' ) )
6313 // InternalVampireLanguage.g:1881:1: ( '(' )
6314 {
6315 // InternalVampireLanguage.g:1881:1: ( '(' )
6316 // InternalVampireLanguage.g:1882:2: '('
6317 {
6318 before(grammarAccess.getVLSFofFormulaAccess().getLeftParenthesisKeyword_1());
6319 match(input,47,FOLLOW_2);
6320 after(grammarAccess.getVLSFofFormulaAccess().getLeftParenthesisKeyword_1());
6321
6322 }
6323
6324
6325 }
6326
6327 }
6328 catch (RecognitionException re) {
6329 reportError(re);
6330 recover(input,re);
6331 }
6332 finally {
6333
6334 restoreStackSize(stackSize);
6335
6336 }
6337 return ;
6338 }
6339 // $ANTLR end "rule__VLSFofFormula__Group__1__Impl"
6340
6341
6342 // $ANTLR start "rule__VLSFofFormula__Group__2"
6343 // InternalVampireLanguage.g:1891:1: rule__VLSFofFormula__Group__2 : rule__VLSFofFormula__Group__2__Impl rule__VLSFofFormula__Group__3 ;
6344 public final void rule__VLSFofFormula__Group__2() throws RecognitionException {
6345
6346 int stackSize = keepStackSize();
6347
6348 try {
6349 // InternalVampireLanguage.g:1895:1: ( rule__VLSFofFormula__Group__2__Impl rule__VLSFofFormula__Group__3 )
6350 // InternalVampireLanguage.g:1896:2: rule__VLSFofFormula__Group__2__Impl rule__VLSFofFormula__Group__3
6351 {
6352 pushFollow(FOLLOW_13);
6353 rule__VLSFofFormula__Group__2__Impl();
6354
6355 state._fsp--;
6356
6357 pushFollow(FOLLOW_2);
6358 rule__VLSFofFormula__Group__3();
6359
6360 state._fsp--;
6361
6362
6363 }
6364
6365 }
6366 catch (RecognitionException re) {
6367 reportError(re);
6368 recover(input,re);
6369 }
6370 finally {
6371
6372 restoreStackSize(stackSize);
6373
6374 }
6375 return ;
6376 }
6377 // $ANTLR end "rule__VLSFofFormula__Group__2"
6378
6379
6380 // $ANTLR start "rule__VLSFofFormula__Group__2__Impl"
6381 // InternalVampireLanguage.g:1903:1: rule__VLSFofFormula__Group__2__Impl : ( ( rule__VLSFofFormula__NameAssignment_2 ) ) ;
6382 public final void rule__VLSFofFormula__Group__2__Impl() throws RecognitionException {
6383
6384 int stackSize = keepStackSize();
6385
6386 try {
6387 // InternalVampireLanguage.g:1907:1: ( ( ( rule__VLSFofFormula__NameAssignment_2 ) ) )
6388 // InternalVampireLanguage.g:1908:1: ( ( rule__VLSFofFormula__NameAssignment_2 ) )
6389 {
6390 // InternalVampireLanguage.g:1908:1: ( ( rule__VLSFofFormula__NameAssignment_2 ) )
6391 // InternalVampireLanguage.g:1909:2: ( rule__VLSFofFormula__NameAssignment_2 )
6392 {
6393 before(grammarAccess.getVLSFofFormulaAccess().getNameAssignment_2());
6394 // InternalVampireLanguage.g:1910:2: ( rule__VLSFofFormula__NameAssignment_2 )
6395 // InternalVampireLanguage.g:1910:3: rule__VLSFofFormula__NameAssignment_2
6396 {
6397 pushFollow(FOLLOW_2);
6398 rule__VLSFofFormula__NameAssignment_2();
6399
6400 state._fsp--;
6401
6402
6403 }
6404
6405 after(grammarAccess.getVLSFofFormulaAccess().getNameAssignment_2());
6406
6407 }
6408
6409
6410 }
6411
6412 }
6413 catch (RecognitionException re) {
6414 reportError(re);
6415 recover(input,re);
6416 }
6417 finally {
6418
6419 restoreStackSize(stackSize);
6420
6421 }
6422 return ;
6423 }
6424 // $ANTLR end "rule__VLSFofFormula__Group__2__Impl"
6425
6426
6427 // $ANTLR start "rule__VLSFofFormula__Group__3"
6428 // InternalVampireLanguage.g:1918:1: rule__VLSFofFormula__Group__3 : rule__VLSFofFormula__Group__3__Impl rule__VLSFofFormula__Group__4 ;
6429 public final void rule__VLSFofFormula__Group__3() throws RecognitionException {
6430
6431 int stackSize = keepStackSize();
6432
6433 try {
6434 // InternalVampireLanguage.g:1922:1: ( rule__VLSFofFormula__Group__3__Impl rule__VLSFofFormula__Group__4 )
6435 // InternalVampireLanguage.g:1923:2: rule__VLSFofFormula__Group__3__Impl rule__VLSFofFormula__Group__4
6436 {
6437 pushFollow(FOLLOW_14);
6438 rule__VLSFofFormula__Group__3__Impl();
6439
6440 state._fsp--;
6441
6442 pushFollow(FOLLOW_2);
6443 rule__VLSFofFormula__Group__4();
6444
6445 state._fsp--;
6446
6447
6448 }
6449
6450 }
6451 catch (RecognitionException re) {
6452 reportError(re);
6453 recover(input,re);
6454 }
6455 finally {
6456
6457 restoreStackSize(stackSize);
6458
6459 }
6460 return ;
6461 }
6462 // $ANTLR end "rule__VLSFofFormula__Group__3"
6463
6464
6465 // $ANTLR start "rule__VLSFofFormula__Group__3__Impl"
6466 // InternalVampireLanguage.g:1930:1: rule__VLSFofFormula__Group__3__Impl : ( ',' ) ;
6467 public final void rule__VLSFofFormula__Group__3__Impl() throws RecognitionException {
6468
6469 int stackSize = keepStackSize();
6470
6471 try {
6472 // InternalVampireLanguage.g:1934:1: ( ( ',' ) )
6473 // InternalVampireLanguage.g:1935:1: ( ',' )
6474 {
6475 // InternalVampireLanguage.g:1935:1: ( ',' )
6476 // InternalVampireLanguage.g:1936:2: ','
6477 {
6478 before(grammarAccess.getVLSFofFormulaAccess().getCommaKeyword_3());
6479 match(input,45,FOLLOW_2);
6480 after(grammarAccess.getVLSFofFormulaAccess().getCommaKeyword_3());
6481
6482 }
6483
6484
6485 }
6486
6487 }
6488 catch (RecognitionException re) {
6489 reportError(re);
6490 recover(input,re);
6491 }
6492 finally {
6493
6494 restoreStackSize(stackSize);
6495
6496 }
6497 return ;
6498 }
6499 // $ANTLR end "rule__VLSFofFormula__Group__3__Impl"
6500
6501
6502 // $ANTLR start "rule__VLSFofFormula__Group__4"
6503 // InternalVampireLanguage.g:1945:1: rule__VLSFofFormula__Group__4 : rule__VLSFofFormula__Group__4__Impl rule__VLSFofFormula__Group__5 ;
6504 public final void rule__VLSFofFormula__Group__4() throws RecognitionException {
6505
6506 int stackSize = keepStackSize();
6507
6508 try {
6509 // InternalVampireLanguage.g:1949:1: ( rule__VLSFofFormula__Group__4__Impl rule__VLSFofFormula__Group__5 )
6510 // InternalVampireLanguage.g:1950:2: rule__VLSFofFormula__Group__4__Impl rule__VLSFofFormula__Group__5
6511 {
6512 pushFollow(FOLLOW_13);
6513 rule__VLSFofFormula__Group__4__Impl();
6514
6515 state._fsp--;
6516
6517 pushFollow(FOLLOW_2);
6518 rule__VLSFofFormula__Group__5();
6519
6520 state._fsp--;
6521
6522
6523 }
6524
6525 }
6526 catch (RecognitionException re) {
6527 reportError(re);
6528 recover(input,re);
6529 }
6530 finally {
6531
6532 restoreStackSize(stackSize);
6533
6534 }
6535 return ;
6536 }
6537 // $ANTLR end "rule__VLSFofFormula__Group__4"
6538
6539
6540 // $ANTLR start "rule__VLSFofFormula__Group__4__Impl"
6541 // InternalVampireLanguage.g:1957:1: rule__VLSFofFormula__Group__4__Impl : ( ( rule__VLSFofFormula__FofRoleAssignment_4 ) ) ;
6542 public final void rule__VLSFofFormula__Group__4__Impl() throws RecognitionException {
6543
6544 int stackSize = keepStackSize();
6545
6546 try {
6547 // InternalVampireLanguage.g:1961:1: ( ( ( rule__VLSFofFormula__FofRoleAssignment_4 ) ) )
6548 // InternalVampireLanguage.g:1962:1: ( ( rule__VLSFofFormula__FofRoleAssignment_4 ) )
6549 {
6550 // InternalVampireLanguage.g:1962:1: ( ( rule__VLSFofFormula__FofRoleAssignment_4 ) )
6551 // InternalVampireLanguage.g:1963:2: ( rule__VLSFofFormula__FofRoleAssignment_4 )
6552 {
6553 before(grammarAccess.getVLSFofFormulaAccess().getFofRoleAssignment_4());
6554 // InternalVampireLanguage.g:1964:2: ( rule__VLSFofFormula__FofRoleAssignment_4 )
6555 // InternalVampireLanguage.g:1964:3: rule__VLSFofFormula__FofRoleAssignment_4
6556 {
6557 pushFollow(FOLLOW_2);
6558 rule__VLSFofFormula__FofRoleAssignment_4();
6559
6560 state._fsp--;
6561
6562
6563 }
6564
6565 after(grammarAccess.getVLSFofFormulaAccess().getFofRoleAssignment_4());
6566
6567 }
6568
6569
6570 }
6571
6572 }
6573 catch (RecognitionException re) {
6574 reportError(re);
6575 recover(input,re);
6576 }
6577 finally {
6578
6579 restoreStackSize(stackSize);
6580
6581 }
6582 return ;
6583 }
6584 // $ANTLR end "rule__VLSFofFormula__Group__4__Impl"
6585
6586
6587 // $ANTLR start "rule__VLSFofFormula__Group__5"
6588 // InternalVampireLanguage.g:1972:1: rule__VLSFofFormula__Group__5 : rule__VLSFofFormula__Group__5__Impl rule__VLSFofFormula__Group__6 ;
6589 public final void rule__VLSFofFormula__Group__5() throws RecognitionException {
6590
6591 int stackSize = keepStackSize();
6592
6593 try {
6594 // InternalVampireLanguage.g:1976:1: ( rule__VLSFofFormula__Group__5__Impl rule__VLSFofFormula__Group__6 )
6595 // InternalVampireLanguage.g:1977:2: rule__VLSFofFormula__Group__5__Impl rule__VLSFofFormula__Group__6
6596 {
6597 pushFollow(FOLLOW_15);
6598 rule__VLSFofFormula__Group__5__Impl();
6599
6600 state._fsp--;
6601
6602 pushFollow(FOLLOW_2);
6603 rule__VLSFofFormula__Group__6();
6604
6605 state._fsp--;
6606
6607
6608 }
6609
6610 }
6611 catch (RecognitionException re) {
6612 reportError(re);
6613 recover(input,re);
6614 }
6615 finally {
6616
6617 restoreStackSize(stackSize);
6618
6619 }
6620 return ;
6621 }
6622 // $ANTLR end "rule__VLSFofFormula__Group__5"
6623
6624
6625 // $ANTLR start "rule__VLSFofFormula__Group__5__Impl"
6626 // InternalVampireLanguage.g:1984:1: rule__VLSFofFormula__Group__5__Impl : ( ',' ) ;
6627 public final void rule__VLSFofFormula__Group__5__Impl() throws RecognitionException {
6628
6629 int stackSize = keepStackSize();
6630
6631 try {
6632 // InternalVampireLanguage.g:1988:1: ( ( ',' ) )
6633 // InternalVampireLanguage.g:1989:1: ( ',' )
6634 {
6635 // InternalVampireLanguage.g:1989:1: ( ',' )
6636 // InternalVampireLanguage.g:1990:2: ','
6637 {
6638 before(grammarAccess.getVLSFofFormulaAccess().getCommaKeyword_5());
6639 match(input,45,FOLLOW_2);
6640 after(grammarAccess.getVLSFofFormulaAccess().getCommaKeyword_5());
6641
6642 }
6643
6644
6645 }
6646
6647 }
6648 catch (RecognitionException re) {
6649 reportError(re);
6650 recover(input,re);
6651 }
6652 finally {
6653
6654 restoreStackSize(stackSize);
6655
6656 }
6657 return ;
6658 }
6659 // $ANTLR end "rule__VLSFofFormula__Group__5__Impl"
6660
6661
6662 // $ANTLR start "rule__VLSFofFormula__Group__6"
6663 // InternalVampireLanguage.g:1999:1: rule__VLSFofFormula__Group__6 : rule__VLSFofFormula__Group__6__Impl rule__VLSFofFormula__Group__7 ;
6664 public final void rule__VLSFofFormula__Group__6() throws RecognitionException {
6665
6666 int stackSize = keepStackSize();
6667
6668 try {
6669 // InternalVampireLanguage.g:2003:1: ( rule__VLSFofFormula__Group__6__Impl rule__VLSFofFormula__Group__7 )
6670 // InternalVampireLanguage.g:2004:2: rule__VLSFofFormula__Group__6__Impl rule__VLSFofFormula__Group__7
6671 {
6672 pushFollow(FOLLOW_16);
6673 rule__VLSFofFormula__Group__6__Impl();
6674
6675 state._fsp--;
6676
6677 pushFollow(FOLLOW_2);
6678 rule__VLSFofFormula__Group__7();
6679
6680 state._fsp--;
6681
6682
6683 }
6684
6685 }
6686 catch (RecognitionException re) {
6687 reportError(re);
6688 recover(input,re);
6689 }
6690 finally {
6691
6692 restoreStackSize(stackSize);
6693
6694 }
6695 return ;
6696 }
6697 // $ANTLR end "rule__VLSFofFormula__Group__6"
6698
6699
6700 // $ANTLR start "rule__VLSFofFormula__Group__6__Impl"
6701 // InternalVampireLanguage.g:2011:1: rule__VLSFofFormula__Group__6__Impl : ( ( rule__VLSFofFormula__FofFormulaAssignment_6 ) ) ;
6702 public final void rule__VLSFofFormula__Group__6__Impl() throws RecognitionException {
6703
6704 int stackSize = keepStackSize();
6705
6706 try {
6707 // InternalVampireLanguage.g:2015:1: ( ( ( rule__VLSFofFormula__FofFormulaAssignment_6 ) ) )
6708 // InternalVampireLanguage.g:2016:1: ( ( rule__VLSFofFormula__FofFormulaAssignment_6 ) )
6709 {
6710 // InternalVampireLanguage.g:2016:1: ( ( rule__VLSFofFormula__FofFormulaAssignment_6 ) )
6711 // InternalVampireLanguage.g:2017:2: ( rule__VLSFofFormula__FofFormulaAssignment_6 )
6712 {
6713 before(grammarAccess.getVLSFofFormulaAccess().getFofFormulaAssignment_6());
6714 // InternalVampireLanguage.g:2018:2: ( rule__VLSFofFormula__FofFormulaAssignment_6 )
6715 // InternalVampireLanguage.g:2018:3: rule__VLSFofFormula__FofFormulaAssignment_6
6716 {
6717 pushFollow(FOLLOW_2);
6718 rule__VLSFofFormula__FofFormulaAssignment_6();
6719
6720 state._fsp--;
6721
6722
6723 }
6724
6725 after(grammarAccess.getVLSFofFormulaAccess().getFofFormulaAssignment_6());
6726
6727 }
6728
6729
6730 }
6731
6732 }
6733 catch (RecognitionException re) {
6734 reportError(re);
6735 recover(input,re);
6736 }
6737 finally {
6738
6739 restoreStackSize(stackSize);
6740
6741 }
6742 return ;
6743 }
6744 // $ANTLR end "rule__VLSFofFormula__Group__6__Impl"
6745
6746
6747 // $ANTLR start "rule__VLSFofFormula__Group__7"
6748 // InternalVampireLanguage.g:2026:1: rule__VLSFofFormula__Group__7 : rule__VLSFofFormula__Group__7__Impl rule__VLSFofFormula__Group__8 ;
6749 public final void rule__VLSFofFormula__Group__7() throws RecognitionException {
6750
6751 int stackSize = keepStackSize();
6752
6753 try {
6754 // InternalVampireLanguage.g:2030:1: ( rule__VLSFofFormula__Group__7__Impl rule__VLSFofFormula__Group__8 )
6755 // InternalVampireLanguage.g:2031:2: rule__VLSFofFormula__Group__7__Impl rule__VLSFofFormula__Group__8
6756 {
6757 pushFollow(FOLLOW_16);
6758 rule__VLSFofFormula__Group__7__Impl();
6759
6760 state._fsp--;
6761
6762 pushFollow(FOLLOW_2);
6763 rule__VLSFofFormula__Group__8();
6764
6765 state._fsp--;
6766
6767
6768 }
6769
6770 }
6771 catch (RecognitionException re) {
6772 reportError(re);
6773 recover(input,re);
6774 }
6775 finally {
6776
6777 restoreStackSize(stackSize);
6778
6779 }
6780 return ;
6781 }
6782 // $ANTLR end "rule__VLSFofFormula__Group__7"
6783
6784
6785 // $ANTLR start "rule__VLSFofFormula__Group__7__Impl"
6786 // InternalVampireLanguage.g:2038:1: rule__VLSFofFormula__Group__7__Impl : ( ( rule__VLSFofFormula__Group_7__0 )? ) ;
6787 public final void rule__VLSFofFormula__Group__7__Impl() throws RecognitionException {
6788
6789 int stackSize = keepStackSize();
6790
6791 try {
6792 // InternalVampireLanguage.g:2042:1: ( ( ( rule__VLSFofFormula__Group_7__0 )? ) )
6793 // InternalVampireLanguage.g:2043:1: ( ( rule__VLSFofFormula__Group_7__0 )? )
6794 {
6795 // InternalVampireLanguage.g:2043:1: ( ( rule__VLSFofFormula__Group_7__0 )? )
6796 // InternalVampireLanguage.g:2044:2: ( rule__VLSFofFormula__Group_7__0 )?
6797 {
6798 before(grammarAccess.getVLSFofFormulaAccess().getGroup_7());
6799 // InternalVampireLanguage.g:2045:2: ( rule__VLSFofFormula__Group_7__0 )?
6800 int alt23=2;
6801 int LA23_0 = input.LA(1);
6802
6803 if ( (LA23_0==45) ) {
6804 alt23=1;
6805 }
6806 switch (alt23) {
6807 case 1 :
6808 // InternalVampireLanguage.g:2045:3: rule__VLSFofFormula__Group_7__0
6809 {
6810 pushFollow(FOLLOW_2);
6811 rule__VLSFofFormula__Group_7__0();
6812
6813 state._fsp--;
6814
6815
6816 }
6817 break;
6818
6819 }
6820
6821 after(grammarAccess.getVLSFofFormulaAccess().getGroup_7());
6822
6823 }
6824
6825
6826 }
6827
6828 }
6829 catch (RecognitionException re) {
6830 reportError(re);
6831 recover(input,re);
6832 }
6833 finally {
6834
6835 restoreStackSize(stackSize);
6836
6837 }
6838 return ;
6839 }
6840 // $ANTLR end "rule__VLSFofFormula__Group__7__Impl"
6841
6842
6843 // $ANTLR start "rule__VLSFofFormula__Group__8"
6844 // InternalVampireLanguage.g:2053:1: rule__VLSFofFormula__Group__8 : rule__VLSFofFormula__Group__8__Impl rule__VLSFofFormula__Group__9 ;
6845 public final void rule__VLSFofFormula__Group__8() throws RecognitionException {
6846
6847 int stackSize = keepStackSize();
6848
6849 try {
6850 // InternalVampireLanguage.g:2057:1: ( rule__VLSFofFormula__Group__8__Impl rule__VLSFofFormula__Group__9 )
6851 // InternalVampireLanguage.g:2058:2: rule__VLSFofFormula__Group__8__Impl rule__VLSFofFormula__Group__9
6852 {
6853 pushFollow(FOLLOW_17);
6854 rule__VLSFofFormula__Group__8__Impl();
6855
6856 state._fsp--;
6857
6858 pushFollow(FOLLOW_2);
6859 rule__VLSFofFormula__Group__9();
6860
6861 state._fsp--;
6862
6863
6864 }
6865
6866 }
6867 catch (RecognitionException re) {
6868 reportError(re);
6869 recover(input,re);
6870 }
6871 finally {
6872
6873 restoreStackSize(stackSize);
6874
6875 }
6876 return ;
6877 }
6878 // $ANTLR end "rule__VLSFofFormula__Group__8"
6879
6880
6881 // $ANTLR start "rule__VLSFofFormula__Group__8__Impl"
6882 // InternalVampireLanguage.g:2065:1: rule__VLSFofFormula__Group__8__Impl : ( ')' ) ;
6883 public final void rule__VLSFofFormula__Group__8__Impl() throws RecognitionException {
6884
6885 int stackSize = keepStackSize();
6886
6887 try {
6888 // InternalVampireLanguage.g:2069:1: ( ( ')' ) )
6889 // InternalVampireLanguage.g:2070:1: ( ')' )
6890 {
6891 // InternalVampireLanguage.g:2070:1: ( ')' )
6892 // InternalVampireLanguage.g:2071:2: ')'
6893 {
6894 before(grammarAccess.getVLSFofFormulaAccess().getRightParenthesisKeyword_8());
6895 match(input,48,FOLLOW_2);
6896 after(grammarAccess.getVLSFofFormulaAccess().getRightParenthesisKeyword_8());
6897
6898 }
6899
6900
6901 }
6902
6903 }
6904 catch (RecognitionException re) {
6905 reportError(re);
6906 recover(input,re);
6907 }
6908 finally {
6909
6910 restoreStackSize(stackSize);
6911
6912 }
6913 return ;
6914 }
6915 // $ANTLR end "rule__VLSFofFormula__Group__8__Impl"
6916
6917
6918 // $ANTLR start "rule__VLSFofFormula__Group__9"
6919 // InternalVampireLanguage.g:2080:1: rule__VLSFofFormula__Group__9 : rule__VLSFofFormula__Group__9__Impl ;
6920 public final void rule__VLSFofFormula__Group__9() throws RecognitionException {
6921
6922 int stackSize = keepStackSize();
6923
6924 try {
6925 // InternalVampireLanguage.g:2084:1: ( rule__VLSFofFormula__Group__9__Impl )
6926 // InternalVampireLanguage.g:2085:2: rule__VLSFofFormula__Group__9__Impl
6927 {
6928 pushFollow(FOLLOW_2);
6929 rule__VLSFofFormula__Group__9__Impl();
6930
6931 state._fsp--;
6932
6933
6934 }
6935
6936 }
6937 catch (RecognitionException re) {
6938 reportError(re);
6939 recover(input,re);
6940 }
6941 finally {
6942
6943 restoreStackSize(stackSize);
6944
6945 }
6946 return ;
6947 }
6948 // $ANTLR end "rule__VLSFofFormula__Group__9"
6949
6950
6951 // $ANTLR start "rule__VLSFofFormula__Group__9__Impl"
6952 // InternalVampireLanguage.g:2091:1: rule__VLSFofFormula__Group__9__Impl : ( '.' ) ;
6953 public final void rule__VLSFofFormula__Group__9__Impl() throws RecognitionException {
6954
6955 int stackSize = keepStackSize();
6956
6957 try {
6958 // InternalVampireLanguage.g:2095:1: ( ( '.' ) )
6959 // InternalVampireLanguage.g:2096:1: ( '.' )
6960 {
6961 // InternalVampireLanguage.g:2096:1: ( '.' )
6962 // InternalVampireLanguage.g:2097:2: '.'
6963 {
6964 before(grammarAccess.getVLSFofFormulaAccess().getFullStopKeyword_9());
6965 match(input,49,FOLLOW_2);
6966 after(grammarAccess.getVLSFofFormulaAccess().getFullStopKeyword_9());
6967
6968 }
6969
6970
6971 }
6972
6973 }
6974 catch (RecognitionException re) {
6975 reportError(re);
6976 recover(input,re);
6977 }
6978 finally {
6979
6980 restoreStackSize(stackSize);
6981
6982 }
6983 return ;
6984 }
6985 // $ANTLR end "rule__VLSFofFormula__Group__9__Impl"
6986
6987
6988 // $ANTLR start "rule__VLSFofFormula__Group_7__0"
6989 // InternalVampireLanguage.g:2107:1: rule__VLSFofFormula__Group_7__0 : rule__VLSFofFormula__Group_7__0__Impl rule__VLSFofFormula__Group_7__1 ;
6990 public final void rule__VLSFofFormula__Group_7__0() throws RecognitionException {
6991
6992 int stackSize = keepStackSize();
6993
6994 try {
6995 // InternalVampireLanguage.g:2111:1: ( rule__VLSFofFormula__Group_7__0__Impl rule__VLSFofFormula__Group_7__1 )
6996 // InternalVampireLanguage.g:2112:2: rule__VLSFofFormula__Group_7__0__Impl rule__VLSFofFormula__Group_7__1
6997 {
6998 pushFollow(FOLLOW_18);
6999 rule__VLSFofFormula__Group_7__0__Impl();
7000
7001 state._fsp--;
7002
7003 pushFollow(FOLLOW_2);
7004 rule__VLSFofFormula__Group_7__1();
7005
7006 state._fsp--;
7007
7008
7009 }
7010
7011 }
7012 catch (RecognitionException re) {
7013 reportError(re);
7014 recover(input,re);
7015 }
7016 finally {
7017
7018 restoreStackSize(stackSize);
7019
7020 }
7021 return ;
7022 }
7023 // $ANTLR end "rule__VLSFofFormula__Group_7__0"
7024
7025
7026 // $ANTLR start "rule__VLSFofFormula__Group_7__0__Impl"
7027 // InternalVampireLanguage.g:2119:1: rule__VLSFofFormula__Group_7__0__Impl : ( ',' ) ;
7028 public final void rule__VLSFofFormula__Group_7__0__Impl() throws RecognitionException {
7029
7030 int stackSize = keepStackSize();
7031
7032 try {
7033 // InternalVampireLanguage.g:2123:1: ( ( ',' ) )
7034 // InternalVampireLanguage.g:2124:1: ( ',' )
7035 {
7036 // InternalVampireLanguage.g:2124:1: ( ',' )
7037 // InternalVampireLanguage.g:2125:2: ','
7038 {
7039 before(grammarAccess.getVLSFofFormulaAccess().getCommaKeyword_7_0());
7040 match(input,45,FOLLOW_2);
7041 after(grammarAccess.getVLSFofFormulaAccess().getCommaKeyword_7_0());
7042
7043 }
7044
7045
7046 }
7047
7048 }
7049 catch (RecognitionException re) {
7050 reportError(re);
7051 recover(input,re);
7052 }
7053 finally {
7054
7055 restoreStackSize(stackSize);
7056
7057 }
7058 return ;
7059 }
7060 // $ANTLR end "rule__VLSFofFormula__Group_7__0__Impl"
7061
7062
7063 // $ANTLR start "rule__VLSFofFormula__Group_7__1"
7064 // InternalVampireLanguage.g:2134:1: rule__VLSFofFormula__Group_7__1 : rule__VLSFofFormula__Group_7__1__Impl ;
7065 public final void rule__VLSFofFormula__Group_7__1() throws RecognitionException {
7066
7067 int stackSize = keepStackSize();
7068
7069 try {
7070 // InternalVampireLanguage.g:2138:1: ( rule__VLSFofFormula__Group_7__1__Impl )
7071 // InternalVampireLanguage.g:2139:2: rule__VLSFofFormula__Group_7__1__Impl
7072 {
7073 pushFollow(FOLLOW_2);
7074 rule__VLSFofFormula__Group_7__1__Impl();
7075
7076 state._fsp--;
7077
7078
7079 }
7080
7081 }
7082 catch (RecognitionException re) {
7083 reportError(re);
7084 recover(input,re);
7085 }
7086 finally {
7087
7088 restoreStackSize(stackSize);
7089
7090 }
7091 return ;
7092 }
7093 // $ANTLR end "rule__VLSFofFormula__Group_7__1"
7094
7095
7096 // $ANTLR start "rule__VLSFofFormula__Group_7__1__Impl"
7097 // InternalVampireLanguage.g:2145:1: rule__VLSFofFormula__Group_7__1__Impl : ( ( rule__VLSFofFormula__AnnotationsAssignment_7_1 ) ) ;
7098 public final void rule__VLSFofFormula__Group_7__1__Impl() throws RecognitionException {
7099
7100 int stackSize = keepStackSize();
7101
7102 try {
7103 // InternalVampireLanguage.g:2149:1: ( ( ( rule__VLSFofFormula__AnnotationsAssignment_7_1 ) ) )
7104 // InternalVampireLanguage.g:2150:1: ( ( rule__VLSFofFormula__AnnotationsAssignment_7_1 ) )
7105 {
7106 // InternalVampireLanguage.g:2150:1: ( ( rule__VLSFofFormula__AnnotationsAssignment_7_1 ) )
7107 // InternalVampireLanguage.g:2151:2: ( rule__VLSFofFormula__AnnotationsAssignment_7_1 )
7108 {
7109 before(grammarAccess.getVLSFofFormulaAccess().getAnnotationsAssignment_7_1());
7110 // InternalVampireLanguage.g:2152:2: ( rule__VLSFofFormula__AnnotationsAssignment_7_1 )
7111 // InternalVampireLanguage.g:2152:3: rule__VLSFofFormula__AnnotationsAssignment_7_1
7112 {
7113 pushFollow(FOLLOW_2);
7114 rule__VLSFofFormula__AnnotationsAssignment_7_1();
7115
7116 state._fsp--;
7117
7118
7119 }
7120
7121 after(grammarAccess.getVLSFofFormulaAccess().getAnnotationsAssignment_7_1());
7122
7123 }
7124
7125
7126 }
7127
7128 }
7129 catch (RecognitionException re) {
7130 reportError(re);
7131 recover(input,re);
7132 }
7133 finally {
7134
7135 restoreStackSize(stackSize);
7136
7137 }
7138 return ;
7139 }
7140 // $ANTLR end "rule__VLSFofFormula__Group_7__1__Impl"
7141
7142
7143 // $ANTLR start "rule__VLSAnnotation__Group__0"
7144 // InternalVampireLanguage.g:2161:1: rule__VLSAnnotation__Group__0 : rule__VLSAnnotation__Group__0__Impl rule__VLSAnnotation__Group__1 ;
7145 public final void rule__VLSAnnotation__Group__0() throws RecognitionException {
7146
7147 int stackSize = keepStackSize();
7148
7149 try {
7150 // InternalVampireLanguage.g:2165:1: ( rule__VLSAnnotation__Group__0__Impl rule__VLSAnnotation__Group__1 )
7151 // InternalVampireLanguage.g:2166:2: rule__VLSAnnotation__Group__0__Impl rule__VLSAnnotation__Group__1
7152 {
7153 pushFollow(FOLLOW_18);
7154 rule__VLSAnnotation__Group__0__Impl();
7155
7156 state._fsp--;
7157
7158 pushFollow(FOLLOW_2);
7159 rule__VLSAnnotation__Group__1();
7160
7161 state._fsp--;
7162
7163
7164 }
7165
7166 }
7167 catch (RecognitionException re) {
7168 reportError(re);
7169 recover(input,re);
7170 }
7171 finally {
7172
7173 restoreStackSize(stackSize);
7174
7175 }
7176 return ;
7177 }
7178 // $ANTLR end "rule__VLSAnnotation__Group__0"
7179
7180
7181 // $ANTLR start "rule__VLSAnnotation__Group__0__Impl"
7182 // InternalVampireLanguage.g:2173:1: rule__VLSAnnotation__Group__0__Impl : ( ( '[' )? ) ;
7183 public final void rule__VLSAnnotation__Group__0__Impl() throws RecognitionException {
7184
7185 int stackSize = keepStackSize();
7186
7187 try {
7188 // InternalVampireLanguage.g:2177:1: ( ( ( '[' )? ) )
7189 // InternalVampireLanguage.g:2178:1: ( ( '[' )? )
7190 {
7191 // InternalVampireLanguage.g:2178:1: ( ( '[' )? )
7192 // InternalVampireLanguage.g:2179:2: ( '[' )?
7193 {
7194 before(grammarAccess.getVLSAnnotationAccess().getLeftSquareBracketKeyword_0());
7195 // InternalVampireLanguage.g:2180:2: ( '[' )?
7196 int alt24=2;
7197 int LA24_0 = input.LA(1);
7198
7199 if ( (LA24_0==50) ) {
7200 alt24=1;
7201 }
7202 switch (alt24) {
7203 case 1 :
7204 // InternalVampireLanguage.g:2180:3: '['
7205 {
7206 match(input,50,FOLLOW_2);
7207
7208 }
7209 break;
7210
7211 }
7212
7213 after(grammarAccess.getVLSAnnotationAccess().getLeftSquareBracketKeyword_0());
7214
7215 }
7216
7217
7218 }
7219
7220 }
7221 catch (RecognitionException re) {
7222 reportError(re);
7223 recover(input,re);
7224 }
7225 finally {
7226
7227 restoreStackSize(stackSize);
7228
7229 }
7230 return ;
7231 }
7232 // $ANTLR end "rule__VLSAnnotation__Group__0__Impl"
7233
7234
7235 // $ANTLR start "rule__VLSAnnotation__Group__1"
7236 // InternalVampireLanguage.g:2188:1: rule__VLSAnnotation__Group__1 : rule__VLSAnnotation__Group__1__Impl rule__VLSAnnotation__Group__2 ;
7237 public final void rule__VLSAnnotation__Group__1() throws RecognitionException {
7238
7239 int stackSize = keepStackSize();
7240
7241 try {
7242 // InternalVampireLanguage.g:2192:1: ( rule__VLSAnnotation__Group__1__Impl rule__VLSAnnotation__Group__2 )
7243 // InternalVampireLanguage.g:2193:2: rule__VLSAnnotation__Group__1__Impl rule__VLSAnnotation__Group__2
7244 {
7245 pushFollow(FOLLOW_18);
7246 rule__VLSAnnotation__Group__1__Impl();
7247
7248 state._fsp--;
7249
7250 pushFollow(FOLLOW_2);
7251 rule__VLSAnnotation__Group__2();
7252
7253 state._fsp--;
7254
7255
7256 }
7257
7258 }
7259 catch (RecognitionException re) {
7260 reportError(re);
7261 recover(input,re);
7262 }
7263 finally {
7264
7265 restoreStackSize(stackSize);
7266
7267 }
7268 return ;
7269 }
7270 // $ANTLR end "rule__VLSAnnotation__Group__1"
7271
7272
7273 // $ANTLR start "rule__VLSAnnotation__Group__1__Impl"
7274 // InternalVampireLanguage.g:2200:1: rule__VLSAnnotation__Group__1__Impl : ( ( rule__VLSAnnotation__NameAssignment_1 )? ) ;
7275 public final void rule__VLSAnnotation__Group__1__Impl() throws RecognitionException {
7276
7277 int stackSize = keepStackSize();
7278
7279 try {
7280 // InternalVampireLanguage.g:2204:1: ( ( ( rule__VLSAnnotation__NameAssignment_1 )? ) )
7281 // InternalVampireLanguage.g:2205:1: ( ( rule__VLSAnnotation__NameAssignment_1 )? )
7282 {
7283 // InternalVampireLanguage.g:2205:1: ( ( rule__VLSAnnotation__NameAssignment_1 )? )
7284 // InternalVampireLanguage.g:2206:2: ( rule__VLSAnnotation__NameAssignment_1 )?
7285 {
7286 before(grammarAccess.getVLSAnnotationAccess().getNameAssignment_1());
7287 // InternalVampireLanguage.g:2207:2: ( rule__VLSAnnotation__NameAssignment_1 )?
7288 int alt25=2;
7289 int LA25_0 = input.LA(1);
7290
7291 if ( ((LA25_0>=RULE_LOWER_WORD_ID && LA25_0<=RULE_SINGLE_QUOTE)||(LA25_0>=27 && LA25_0<=41)) ) {
7292 alt25=1;
7293 }
7294 switch (alt25) {
7295 case 1 :
7296 // InternalVampireLanguage.g:2207:3: rule__VLSAnnotation__NameAssignment_1
7297 {
7298 pushFollow(FOLLOW_2);
7299 rule__VLSAnnotation__NameAssignment_1();
7300
7301 state._fsp--;
7302
7303
7304 }
7305 break;
7306
7307 }
7308
7309 after(grammarAccess.getVLSAnnotationAccess().getNameAssignment_1());
7310
7311 }
7312
7313
7314 }
7315
7316 }
7317 catch (RecognitionException re) {
7318 reportError(re);
7319 recover(input,re);
7320 }
7321 finally {
7322
7323 restoreStackSize(stackSize);
7324
7325 }
7326 return ;
7327 }
7328 // $ANTLR end "rule__VLSAnnotation__Group__1__Impl"
7329
7330
7331 // $ANTLR start "rule__VLSAnnotation__Group__2"
7332 // InternalVampireLanguage.g:2215:1: rule__VLSAnnotation__Group__2 : rule__VLSAnnotation__Group__2__Impl rule__VLSAnnotation__Group__3 ;
7333 public final void rule__VLSAnnotation__Group__2() throws RecognitionException {
7334
7335 int stackSize = keepStackSize();
7336
7337 try {
7338 // InternalVampireLanguage.g:2219:1: ( rule__VLSAnnotation__Group__2__Impl rule__VLSAnnotation__Group__3 )
7339 // InternalVampireLanguage.g:2220:2: rule__VLSAnnotation__Group__2__Impl rule__VLSAnnotation__Group__3
7340 {
7341 pushFollow(FOLLOW_18);
7342 rule__VLSAnnotation__Group__2__Impl();
7343
7344 state._fsp--;
7345
7346 pushFollow(FOLLOW_2);
7347 rule__VLSAnnotation__Group__3();
7348
7349 state._fsp--;
7350
7351
7352 }
7353
7354 }
7355 catch (RecognitionException re) {
7356 reportError(re);
7357 recover(input,re);
7358 }
7359 finally {
7360
7361 restoreStackSize(stackSize);
7362
7363 }
7364 return ;
7365 }
7366 // $ANTLR end "rule__VLSAnnotation__Group__2"
7367
7368
7369 // $ANTLR start "rule__VLSAnnotation__Group__2__Impl"
7370 // InternalVampireLanguage.g:2227:1: rule__VLSAnnotation__Group__2__Impl : ( ( rule__VLSAnnotation__Group_2__0 )? ) ;
7371 public final void rule__VLSAnnotation__Group__2__Impl() throws RecognitionException {
7372
7373 int stackSize = keepStackSize();
7374
7375 try {
7376 // InternalVampireLanguage.g:2231:1: ( ( ( rule__VLSAnnotation__Group_2__0 )? ) )
7377 // InternalVampireLanguage.g:2232:1: ( ( rule__VLSAnnotation__Group_2__0 )? )
7378 {
7379 // InternalVampireLanguage.g:2232:1: ( ( rule__VLSAnnotation__Group_2__0 )? )
7380 // InternalVampireLanguage.g:2233:2: ( rule__VLSAnnotation__Group_2__0 )?
7381 {
7382 before(grammarAccess.getVLSAnnotationAccess().getGroup_2());
7383 // InternalVampireLanguage.g:2234:2: ( rule__VLSAnnotation__Group_2__0 )?
7384 int alt26=2;
7385 int LA26_0 = input.LA(1);
7386
7387 if ( (LA26_0==47) ) {
7388 alt26=1;
7389 }
7390 switch (alt26) {
7391 case 1 :
7392 // InternalVampireLanguage.g:2234:3: rule__VLSAnnotation__Group_2__0
7393 {
7394 pushFollow(FOLLOW_2);
7395 rule__VLSAnnotation__Group_2__0();
7396
7397 state._fsp--;
7398
7399
7400 }
7401 break;
7402
7403 }
7404
7405 after(grammarAccess.getVLSAnnotationAccess().getGroup_2());
7406
7407 }
7408
7409
7410 }
7411
7412 }
7413 catch (RecognitionException re) {
7414 reportError(re);
7415 recover(input,re);
7416 }
7417 finally {
7418
7419 restoreStackSize(stackSize);
7420
7421 }
7422 return ;
7423 }
7424 // $ANTLR end "rule__VLSAnnotation__Group__2__Impl"
7425
7426
7427 // $ANTLR start "rule__VLSAnnotation__Group__3"
7428 // InternalVampireLanguage.g:2242:1: rule__VLSAnnotation__Group__3 : rule__VLSAnnotation__Group__3__Impl ;
7429 public final void rule__VLSAnnotation__Group__3() throws RecognitionException {
7430
7431 int stackSize = keepStackSize();
7432
7433 try {
7434 // InternalVampireLanguage.g:2246:1: ( rule__VLSAnnotation__Group__3__Impl )
7435 // InternalVampireLanguage.g:2247:2: rule__VLSAnnotation__Group__3__Impl
7436 {
7437 pushFollow(FOLLOW_2);
7438 rule__VLSAnnotation__Group__3__Impl();
7439
7440 state._fsp--;
7441
7442
7443 }
7444
7445 }
7446 catch (RecognitionException re) {
7447 reportError(re);
7448 recover(input,re);
7449 }
7450 finally {
7451
7452 restoreStackSize(stackSize);
7453
7454 }
7455 return ;
7456 }
7457 // $ANTLR end "rule__VLSAnnotation__Group__3"
7458
7459
7460 // $ANTLR start "rule__VLSAnnotation__Group__3__Impl"
7461 // InternalVampireLanguage.g:2253:1: rule__VLSAnnotation__Group__3__Impl : ( ( ']' )? ) ;
7462 public final void rule__VLSAnnotation__Group__3__Impl() throws RecognitionException {
7463
7464 int stackSize = keepStackSize();
7465
7466 try {
7467 // InternalVampireLanguage.g:2257:1: ( ( ( ']' )? ) )
7468 // InternalVampireLanguage.g:2258:1: ( ( ']' )? )
7469 {
7470 // InternalVampireLanguage.g:2258:1: ( ( ']' )? )
7471 // InternalVampireLanguage.g:2259:2: ( ']' )?
7472 {
7473 before(grammarAccess.getVLSAnnotationAccess().getRightSquareBracketKeyword_3());
7474 // InternalVampireLanguage.g:2260:2: ( ']' )?
7475 int alt27=2;
7476 int LA27_0 = input.LA(1);
7477
7478 if ( (LA27_0==44) ) {
7479 alt27=1;
7480 }
7481 switch (alt27) {
7482 case 1 :
7483 // InternalVampireLanguage.g:2260:3: ']'
7484 {
7485 match(input,44,FOLLOW_2);
7486
7487 }
7488 break;
7489
7490 }
7491
7492 after(grammarAccess.getVLSAnnotationAccess().getRightSquareBracketKeyword_3());
7493
7494 }
7495
7496
7497 }
7498
7499 }
7500 catch (RecognitionException re) {
7501 reportError(re);
7502 recover(input,re);
7503 }
7504 finally {
7505
7506 restoreStackSize(stackSize);
7507
7508 }
7509 return ;
7510 }
7511 // $ANTLR end "rule__VLSAnnotation__Group__3__Impl"
7512
7513
7514 // $ANTLR start "rule__VLSAnnotation__Group_2__0"
7515 // InternalVampireLanguage.g:2269:1: rule__VLSAnnotation__Group_2__0 : rule__VLSAnnotation__Group_2__0__Impl rule__VLSAnnotation__Group_2__1 ;
7516 public final void rule__VLSAnnotation__Group_2__0() throws RecognitionException {
7517
7518 int stackSize = keepStackSize();
7519
7520 try {
7521 // InternalVampireLanguage.g:2273:1: ( rule__VLSAnnotation__Group_2__0__Impl rule__VLSAnnotation__Group_2__1 )
7522 // InternalVampireLanguage.g:2274:2: rule__VLSAnnotation__Group_2__0__Impl rule__VLSAnnotation__Group_2__1
7523 {
7524 pushFollow(FOLLOW_18);
7525 rule__VLSAnnotation__Group_2__0__Impl();
7526
7527 state._fsp--;
7528
7529 pushFollow(FOLLOW_2);
7530 rule__VLSAnnotation__Group_2__1();
7531
7532 state._fsp--;
7533
7534
7535 }
7536
7537 }
7538 catch (RecognitionException re) {
7539 reportError(re);
7540 recover(input,re);
7541 }
7542 finally {
7543
7544 restoreStackSize(stackSize);
7545
7546 }
7547 return ;
7548 }
7549 // $ANTLR end "rule__VLSAnnotation__Group_2__0"
7550
7551
7552 // $ANTLR start "rule__VLSAnnotation__Group_2__0__Impl"
7553 // InternalVampireLanguage.g:2281:1: rule__VLSAnnotation__Group_2__0__Impl : ( '(' ) ;
7554 public final void rule__VLSAnnotation__Group_2__0__Impl() throws RecognitionException {
7555
7556 int stackSize = keepStackSize();
7557
7558 try {
7559 // InternalVampireLanguage.g:2285:1: ( ( '(' ) )
7560 // InternalVampireLanguage.g:2286:1: ( '(' )
7561 {
7562 // InternalVampireLanguage.g:2286:1: ( '(' )
7563 // InternalVampireLanguage.g:2287:2: '('
7564 {
7565 before(grammarAccess.getVLSAnnotationAccess().getLeftParenthesisKeyword_2_0());
7566 match(input,47,FOLLOW_2);
7567 after(grammarAccess.getVLSAnnotationAccess().getLeftParenthesisKeyword_2_0());
7568
7569 }
7570
7571
7572 }
7573
7574 }
7575 catch (RecognitionException re) {
7576 reportError(re);
7577 recover(input,re);
7578 }
7579 finally {
7580
7581 restoreStackSize(stackSize);
7582
7583 }
7584 return ;
7585 }
7586 // $ANTLR end "rule__VLSAnnotation__Group_2__0__Impl"
7587
7588
7589 // $ANTLR start "rule__VLSAnnotation__Group_2__1"
7590 // InternalVampireLanguage.g:2296:1: rule__VLSAnnotation__Group_2__1 : rule__VLSAnnotation__Group_2__1__Impl rule__VLSAnnotation__Group_2__2 ;
7591 public final void rule__VLSAnnotation__Group_2__1() throws RecognitionException {
7592
7593 int stackSize = keepStackSize();
7594
7595 try {
7596 // InternalVampireLanguage.g:2300:1: ( rule__VLSAnnotation__Group_2__1__Impl rule__VLSAnnotation__Group_2__2 )
7597 // InternalVampireLanguage.g:2301:2: rule__VLSAnnotation__Group_2__1__Impl rule__VLSAnnotation__Group_2__2
7598 {
7599 pushFollow(FOLLOW_19);
7600 rule__VLSAnnotation__Group_2__1__Impl();
7601
7602 state._fsp--;
7603
7604 pushFollow(FOLLOW_2);
7605 rule__VLSAnnotation__Group_2__2();
7606
7607 state._fsp--;
7608
7609
7610 }
7611
7612 }
7613 catch (RecognitionException re) {
7614 reportError(re);
7615 recover(input,re);
7616 }
7617 finally {
7618
7619 restoreStackSize(stackSize);
7620
7621 }
7622 return ;
7623 }
7624 // $ANTLR end "rule__VLSAnnotation__Group_2__1"
7625
7626
7627 // $ANTLR start "rule__VLSAnnotation__Group_2__1__Impl"
7628 // InternalVampireLanguage.g:2308:1: rule__VLSAnnotation__Group_2__1__Impl : ( ( rule__VLSAnnotation__FollowupAssignment_2_1 ) ) ;
7629 public final void rule__VLSAnnotation__Group_2__1__Impl() throws RecognitionException {
7630
7631 int stackSize = keepStackSize();
7632
7633 try {
7634 // InternalVampireLanguage.g:2312:1: ( ( ( rule__VLSAnnotation__FollowupAssignment_2_1 ) ) )
7635 // InternalVampireLanguage.g:2313:1: ( ( rule__VLSAnnotation__FollowupAssignment_2_1 ) )
7636 {
7637 // InternalVampireLanguage.g:2313:1: ( ( rule__VLSAnnotation__FollowupAssignment_2_1 ) )
7638 // InternalVampireLanguage.g:2314:2: ( rule__VLSAnnotation__FollowupAssignment_2_1 )
7639 {
7640 before(grammarAccess.getVLSAnnotationAccess().getFollowupAssignment_2_1());
7641 // InternalVampireLanguage.g:2315:2: ( rule__VLSAnnotation__FollowupAssignment_2_1 )
7642 // InternalVampireLanguage.g:2315:3: rule__VLSAnnotation__FollowupAssignment_2_1
7643 {
7644 pushFollow(FOLLOW_2);
7645 rule__VLSAnnotation__FollowupAssignment_2_1();
7646
7647 state._fsp--;
7648
7649
7650 }
7651
7652 after(grammarAccess.getVLSAnnotationAccess().getFollowupAssignment_2_1());
7653
7654 }
7655
7656
7657 }
7658
7659 }
7660 catch (RecognitionException re) {
7661 reportError(re);
7662 recover(input,re);
7663 }
7664 finally {
7665
7666 restoreStackSize(stackSize);
7667
7668 }
7669 return ;
7670 }
7671 // $ANTLR end "rule__VLSAnnotation__Group_2__1__Impl"
7672
7673
7674 // $ANTLR start "rule__VLSAnnotation__Group_2__2"
7675 // InternalVampireLanguage.g:2323:1: rule__VLSAnnotation__Group_2__2 : rule__VLSAnnotation__Group_2__2__Impl ;
7676 public final void rule__VLSAnnotation__Group_2__2() throws RecognitionException {
7677
7678 int stackSize = keepStackSize();
7679
7680 try {
7681 // InternalVampireLanguage.g:2327:1: ( rule__VLSAnnotation__Group_2__2__Impl )
7682 // InternalVampireLanguage.g:2328:2: rule__VLSAnnotation__Group_2__2__Impl
7683 {
7684 pushFollow(FOLLOW_2);
7685 rule__VLSAnnotation__Group_2__2__Impl();
7686
7687 state._fsp--;
7688
7689
7690 }
7691
7692 }
7693 catch (RecognitionException re) {
7694 reportError(re);
7695 recover(input,re);
7696 }
7697 finally {
7698
7699 restoreStackSize(stackSize);
7700
7701 }
7702 return ;
7703 }
7704 // $ANTLR end "rule__VLSAnnotation__Group_2__2"
7705
7706
7707 // $ANTLR start "rule__VLSAnnotation__Group_2__2__Impl"
7708 // InternalVampireLanguage.g:2334:1: rule__VLSAnnotation__Group_2__2__Impl : ( ')' ) ;
7709 public final void rule__VLSAnnotation__Group_2__2__Impl() throws RecognitionException {
7710
7711 int stackSize = keepStackSize();
7712
7713 try {
7714 // InternalVampireLanguage.g:2338:1: ( ( ')' ) )
7715 // InternalVampireLanguage.g:2339:1: ( ')' )
7716 {
7717 // InternalVampireLanguage.g:2339:1: ( ')' )
7718 // InternalVampireLanguage.g:2340:2: ')'
7719 {
7720 before(grammarAccess.getVLSAnnotationAccess().getRightParenthesisKeyword_2_2());
7721 match(input,48,FOLLOW_2);
7722 after(grammarAccess.getVLSAnnotationAccess().getRightParenthesisKeyword_2_2());
7723
7724 }
7725
7726
7727 }
7728
7729 }
7730 catch (RecognitionException re) {
7731 reportError(re);
7732 recover(input,re);
7733 }
7734 finally {
7735
7736 restoreStackSize(stackSize);
7737
7738 }
7739 return ;
7740 }
7741 // $ANTLR end "rule__VLSAnnotation__Group_2__2__Impl"
7742
7743
7744 // $ANTLR start "rule__VLSAnnotationTerms__Group__0"
7745 // InternalVampireLanguage.g:2350:1: rule__VLSAnnotationTerms__Group__0 : rule__VLSAnnotationTerms__Group__0__Impl rule__VLSAnnotationTerms__Group__1 ;
7746 public final void rule__VLSAnnotationTerms__Group__0() throws RecognitionException {
7747
7748 int stackSize = keepStackSize();
7749
7750 try {
7751 // InternalVampireLanguage.g:2354:1: ( rule__VLSAnnotationTerms__Group__0__Impl rule__VLSAnnotationTerms__Group__1 )
7752 // InternalVampireLanguage.g:2355:2: rule__VLSAnnotationTerms__Group__0__Impl rule__VLSAnnotationTerms__Group__1
7753 {
7754 pushFollow(FOLLOW_13);
7755 rule__VLSAnnotationTerms__Group__0__Impl();
7756
7757 state._fsp--;
7758
7759 pushFollow(FOLLOW_2);
7760 rule__VLSAnnotationTerms__Group__1();
7761
7762 state._fsp--;
7763
7764
7765 }
7766
7767 }
7768 catch (RecognitionException re) {
7769 reportError(re);
7770 recover(input,re);
7771 }
7772 finally {
7773
7774 restoreStackSize(stackSize);
7775
7776 }
7777 return ;
7778 }
7779 // $ANTLR end "rule__VLSAnnotationTerms__Group__0"
7780
7781
7782 // $ANTLR start "rule__VLSAnnotationTerms__Group__0__Impl"
7783 // InternalVampireLanguage.g:2362:1: rule__VLSAnnotationTerms__Group__0__Impl : ( ( rule__VLSAnnotationTerms__TermsAssignment_0 ) ) ;
7784 public final void rule__VLSAnnotationTerms__Group__0__Impl() throws RecognitionException {
7785
7786 int stackSize = keepStackSize();
7787
7788 try {
7789 // InternalVampireLanguage.g:2366:1: ( ( ( rule__VLSAnnotationTerms__TermsAssignment_0 ) ) )
7790 // InternalVampireLanguage.g:2367:1: ( ( rule__VLSAnnotationTerms__TermsAssignment_0 ) )
7791 {
7792 // InternalVampireLanguage.g:2367:1: ( ( rule__VLSAnnotationTerms__TermsAssignment_0 ) )
7793 // InternalVampireLanguage.g:2368:2: ( rule__VLSAnnotationTerms__TermsAssignment_0 )
7794 {
7795 before(grammarAccess.getVLSAnnotationTermsAccess().getTermsAssignment_0());
7796 // InternalVampireLanguage.g:2369:2: ( rule__VLSAnnotationTerms__TermsAssignment_0 )
7797 // InternalVampireLanguage.g:2369:3: rule__VLSAnnotationTerms__TermsAssignment_0
7798 {
7799 pushFollow(FOLLOW_2);
7800 rule__VLSAnnotationTerms__TermsAssignment_0();
7801
7802 state._fsp--;
7803
7804
7805 }
7806
7807 after(grammarAccess.getVLSAnnotationTermsAccess().getTermsAssignment_0());
7808
7809 }
7810
7811
7812 }
7813
7814 }
7815 catch (RecognitionException re) {
7816 reportError(re);
7817 recover(input,re);
7818 }
7819 finally {
7820
7821 restoreStackSize(stackSize);
7822
7823 }
7824 return ;
7825 }
7826 // $ANTLR end "rule__VLSAnnotationTerms__Group__0__Impl"
7827
7828
7829 // $ANTLR start "rule__VLSAnnotationTerms__Group__1"
7830 // InternalVampireLanguage.g:2377:1: rule__VLSAnnotationTerms__Group__1 : rule__VLSAnnotationTerms__Group__1__Impl ;
7831 public final void rule__VLSAnnotationTerms__Group__1() throws RecognitionException {
7832
7833 int stackSize = keepStackSize();
7834
7835 try {
7836 // InternalVampireLanguage.g:2381:1: ( rule__VLSAnnotationTerms__Group__1__Impl )
7837 // InternalVampireLanguage.g:2382:2: rule__VLSAnnotationTerms__Group__1__Impl
7838 {
7839 pushFollow(FOLLOW_2);
7840 rule__VLSAnnotationTerms__Group__1__Impl();
7841
7842 state._fsp--;
7843
7844
7845 }
7846
7847 }
7848 catch (RecognitionException re) {
7849 reportError(re);
7850 recover(input,re);
7851 }
7852 finally {
7853
7854 restoreStackSize(stackSize);
7855
7856 }
7857 return ;
7858 }
7859 // $ANTLR end "rule__VLSAnnotationTerms__Group__1"
7860
7861
7862 // $ANTLR start "rule__VLSAnnotationTerms__Group__1__Impl"
7863 // InternalVampireLanguage.g:2388:1: rule__VLSAnnotationTerms__Group__1__Impl : ( ( rule__VLSAnnotationTerms__Group_1__0 )* ) ;
7864 public final void rule__VLSAnnotationTerms__Group__1__Impl() throws RecognitionException {
7865
7866 int stackSize = keepStackSize();
7867
7868 try {
7869 // InternalVampireLanguage.g:2392:1: ( ( ( rule__VLSAnnotationTerms__Group_1__0 )* ) )
7870 // InternalVampireLanguage.g:2393:1: ( ( rule__VLSAnnotationTerms__Group_1__0 )* )
7871 {
7872 // InternalVampireLanguage.g:2393:1: ( ( rule__VLSAnnotationTerms__Group_1__0 )* )
7873 // InternalVampireLanguage.g:2394:2: ( rule__VLSAnnotationTerms__Group_1__0 )*
7874 {
7875 before(grammarAccess.getVLSAnnotationTermsAccess().getGroup_1());
7876 // InternalVampireLanguage.g:2395:2: ( rule__VLSAnnotationTerms__Group_1__0 )*
7877 loop28:
7878 do {
7879 int alt28=2;
7880 int LA28_0 = input.LA(1);
7881
7882 if ( (LA28_0==45) ) {
7883 alt28=1;
7884 }
7885
7886
7887 switch (alt28) {
7888 case 1 :
7889 // InternalVampireLanguage.g:2395:3: rule__VLSAnnotationTerms__Group_1__0
7890 {
7891 pushFollow(FOLLOW_10);
7892 rule__VLSAnnotationTerms__Group_1__0();
7893
7894 state._fsp--;
7895
7896
7897 }
7898 break;
7899
7900 default :
7901 break loop28;
7902 }
7903 } while (true);
7904
7905 after(grammarAccess.getVLSAnnotationTermsAccess().getGroup_1());
7906
7907 }
7908
7909
7910 }
7911
7912 }
7913 catch (RecognitionException re) {
7914 reportError(re);
7915 recover(input,re);
7916 }
7917 finally {
7918
7919 restoreStackSize(stackSize);
7920
7921 }
7922 return ;
7923 }
7924 // $ANTLR end "rule__VLSAnnotationTerms__Group__1__Impl"
7925
7926
7927 // $ANTLR start "rule__VLSAnnotationTerms__Group_1__0"
7928 // InternalVampireLanguage.g:2404:1: rule__VLSAnnotationTerms__Group_1__0 : rule__VLSAnnotationTerms__Group_1__0__Impl rule__VLSAnnotationTerms__Group_1__1 ;
7929 public final void rule__VLSAnnotationTerms__Group_1__0() throws RecognitionException {
7930
7931 int stackSize = keepStackSize();
7932
7933 try {
7934 // InternalVampireLanguage.g:2408:1: ( rule__VLSAnnotationTerms__Group_1__0__Impl rule__VLSAnnotationTerms__Group_1__1 )
7935 // InternalVampireLanguage.g:2409:2: rule__VLSAnnotationTerms__Group_1__0__Impl rule__VLSAnnotationTerms__Group_1__1
7936 {
7937 pushFollow(FOLLOW_18);
7938 rule__VLSAnnotationTerms__Group_1__0__Impl();
7939
7940 state._fsp--;
7941
7942 pushFollow(FOLLOW_2);
7943 rule__VLSAnnotationTerms__Group_1__1();
7944
7945 state._fsp--;
7946
7947
7948 }
7949
7950 }
7951 catch (RecognitionException re) {
7952 reportError(re);
7953 recover(input,re);
7954 }
7955 finally {
7956
7957 restoreStackSize(stackSize);
7958
7959 }
7960 return ;
7961 }
7962 // $ANTLR end "rule__VLSAnnotationTerms__Group_1__0"
7963
7964
7965 // $ANTLR start "rule__VLSAnnotationTerms__Group_1__0__Impl"
7966 // InternalVampireLanguage.g:2416:1: rule__VLSAnnotationTerms__Group_1__0__Impl : ( ',' ) ;
7967 public final void rule__VLSAnnotationTerms__Group_1__0__Impl() throws RecognitionException {
7968
7969 int stackSize = keepStackSize();
7970
7971 try {
7972 // InternalVampireLanguage.g:2420:1: ( ( ',' ) )
7973 // InternalVampireLanguage.g:2421:1: ( ',' )
7974 {
7975 // InternalVampireLanguage.g:2421:1: ( ',' )
7976 // InternalVampireLanguage.g:2422:2: ','
7977 {
7978 before(grammarAccess.getVLSAnnotationTermsAccess().getCommaKeyword_1_0());
7979 match(input,45,FOLLOW_2);
7980 after(grammarAccess.getVLSAnnotationTermsAccess().getCommaKeyword_1_0());
7981
7982 }
7983
7984
7985 }
7986
7987 }
7988 catch (RecognitionException re) {
7989 reportError(re);
7990 recover(input,re);
7991 }
7992 finally {
7993
7994 restoreStackSize(stackSize);
7995
7996 }
7997 return ;
7998 }
7999 // $ANTLR end "rule__VLSAnnotationTerms__Group_1__0__Impl"
8000
8001
8002 // $ANTLR start "rule__VLSAnnotationTerms__Group_1__1"
8003 // InternalVampireLanguage.g:2431:1: rule__VLSAnnotationTerms__Group_1__1 : rule__VLSAnnotationTerms__Group_1__1__Impl ;
8004 public final void rule__VLSAnnotationTerms__Group_1__1() throws RecognitionException {
8005
8006 int stackSize = keepStackSize();
8007
8008 try {
8009 // InternalVampireLanguage.g:2435:1: ( rule__VLSAnnotationTerms__Group_1__1__Impl )
8010 // InternalVampireLanguage.g:2436:2: rule__VLSAnnotationTerms__Group_1__1__Impl
8011 {
8012 pushFollow(FOLLOW_2);
8013 rule__VLSAnnotationTerms__Group_1__1__Impl();
8014
8015 state._fsp--;
8016
8017
8018 }
8019
8020 }
8021 catch (RecognitionException re) {
8022 reportError(re);
8023 recover(input,re);
8024 }
8025 finally {
8026
8027 restoreStackSize(stackSize);
8028
8029 }
8030 return ;
8031 }
8032 // $ANTLR end "rule__VLSAnnotationTerms__Group_1__1"
8033
8034
8035 // $ANTLR start "rule__VLSAnnotationTerms__Group_1__1__Impl"
8036 // InternalVampireLanguage.g:2442:1: rule__VLSAnnotationTerms__Group_1__1__Impl : ( ( rule__VLSAnnotationTerms__TermsAssignment_1_1 ) ) ;
8037 public final void rule__VLSAnnotationTerms__Group_1__1__Impl() throws RecognitionException {
8038
8039 int stackSize = keepStackSize();
8040
8041 try {
8042 // InternalVampireLanguage.g:2446:1: ( ( ( rule__VLSAnnotationTerms__TermsAssignment_1_1 ) ) )
8043 // InternalVampireLanguage.g:2447:1: ( ( rule__VLSAnnotationTerms__TermsAssignment_1_1 ) )
8044 {
8045 // InternalVampireLanguage.g:2447:1: ( ( rule__VLSAnnotationTerms__TermsAssignment_1_1 ) )
8046 // InternalVampireLanguage.g:2448:2: ( rule__VLSAnnotationTerms__TermsAssignment_1_1 )
8047 {
8048 before(grammarAccess.getVLSAnnotationTermsAccess().getTermsAssignment_1_1());
8049 // InternalVampireLanguage.g:2449:2: ( rule__VLSAnnotationTerms__TermsAssignment_1_1 )
8050 // InternalVampireLanguage.g:2449:3: rule__VLSAnnotationTerms__TermsAssignment_1_1
8051 {
8052 pushFollow(FOLLOW_2);
8053 rule__VLSAnnotationTerms__TermsAssignment_1_1();
8054
8055 state._fsp--;
8056
8057
8058 }
8059
8060 after(grammarAccess.getVLSAnnotationTermsAccess().getTermsAssignment_1_1());
8061
8062 }
8063
8064
8065 }
8066
8067 }
8068 catch (RecognitionException re) {
8069 reportError(re);
8070 recover(input,re);
8071 }
8072 finally {
8073
8074 restoreStackSize(stackSize);
8075
8076 }
8077 return ;
8078 }
8079 // $ANTLR end "rule__VLSAnnotationTerms__Group_1__1__Impl"
8080
8081
8082 // $ANTLR start "rule__VLSBinary__Group__0"
8083 // InternalVampireLanguage.g:2458:1: rule__VLSBinary__Group__0 : rule__VLSBinary__Group__0__Impl rule__VLSBinary__Group__1 ;
8084 public final void rule__VLSBinary__Group__0() throws RecognitionException {
8085
8086 int stackSize = keepStackSize();
8087
8088 try {
8089 // InternalVampireLanguage.g:2462:1: ( rule__VLSBinary__Group__0__Impl rule__VLSBinary__Group__1 )
8090 // InternalVampireLanguage.g:2463:2: rule__VLSBinary__Group__0__Impl rule__VLSBinary__Group__1
8091 {
8092 pushFollow(FOLLOW_20);
8093 rule__VLSBinary__Group__0__Impl();
8094
8095 state._fsp--;
8096
8097 pushFollow(FOLLOW_2);
8098 rule__VLSBinary__Group__1();
8099
8100 state._fsp--;
8101
8102
8103 }
8104
8105 }
8106 catch (RecognitionException re) {
8107 reportError(re);
8108 recover(input,re);
8109 }
8110 finally {
8111
8112 restoreStackSize(stackSize);
8113
8114 }
8115 return ;
8116 }
8117 // $ANTLR end "rule__VLSBinary__Group__0"
8118
8119
8120 // $ANTLR start "rule__VLSBinary__Group__0__Impl"
8121 // InternalVampireLanguage.g:2470:1: rule__VLSBinary__Group__0__Impl : ( ruleVLSUnitaryFormula ) ;
8122 public final void rule__VLSBinary__Group__0__Impl() throws RecognitionException {
8123
8124 int stackSize = keepStackSize();
8125
8126 try {
8127 // InternalVampireLanguage.g:2474:1: ( ( ruleVLSUnitaryFormula ) )
8128 // InternalVampireLanguage.g:2475:1: ( ruleVLSUnitaryFormula )
8129 {
8130 // InternalVampireLanguage.g:2475:1: ( ruleVLSUnitaryFormula )
8131 // InternalVampireLanguage.g:2476:2: ruleVLSUnitaryFormula
8132 {
8133 before(grammarAccess.getVLSBinaryAccess().getVLSUnitaryFormulaParserRuleCall_0());
8134 pushFollow(FOLLOW_2);
8135 ruleVLSUnitaryFormula();
8136
8137 state._fsp--;
8138
8139 after(grammarAccess.getVLSBinaryAccess().getVLSUnitaryFormulaParserRuleCall_0());
8140
8141 }
8142
8143
8144 }
8145
8146 }
8147 catch (RecognitionException re) {
8148 reportError(re);
8149 recover(input,re);
8150 }
8151 finally {
8152
8153 restoreStackSize(stackSize);
8154
8155 }
8156 return ;
8157 }
8158 // $ANTLR end "rule__VLSBinary__Group__0__Impl"
8159
8160
8161 // $ANTLR start "rule__VLSBinary__Group__1"
8162 // InternalVampireLanguage.g:2485:1: rule__VLSBinary__Group__1 : rule__VLSBinary__Group__1__Impl ;
8163 public final void rule__VLSBinary__Group__1() throws RecognitionException {
8164
8165 int stackSize = keepStackSize();
8166
8167 try {
8168 // InternalVampireLanguage.g:2489:1: ( rule__VLSBinary__Group__1__Impl )
8169 // InternalVampireLanguage.g:2490:2: rule__VLSBinary__Group__1__Impl
8170 {
8171 pushFollow(FOLLOW_2);
8172 rule__VLSBinary__Group__1__Impl();
8173
8174 state._fsp--;
8175
8176
8177 }
8178
8179 }
8180 catch (RecognitionException re) {
8181 reportError(re);
8182 recover(input,re);
8183 }
8184 finally {
8185
8186 restoreStackSize(stackSize);
8187
8188 }
8189 return ;
8190 }
8191 // $ANTLR end "rule__VLSBinary__Group__1"
8192
8193
8194 // $ANTLR start "rule__VLSBinary__Group__1__Impl"
8195 // InternalVampireLanguage.g:2496:1: rule__VLSBinary__Group__1__Impl : ( ( rule__VLSBinary__Alternatives_1 )? ) ;
8196 public final void rule__VLSBinary__Group__1__Impl() throws RecognitionException {
8197
8198 int stackSize = keepStackSize();
8199
8200 try {
8201 // InternalVampireLanguage.g:2500:1: ( ( ( rule__VLSBinary__Alternatives_1 )? ) )
8202 // InternalVampireLanguage.g:2501:1: ( ( rule__VLSBinary__Alternatives_1 )? )
8203 {
8204 // InternalVampireLanguage.g:2501:1: ( ( rule__VLSBinary__Alternatives_1 )? )
8205 // InternalVampireLanguage.g:2502:2: ( rule__VLSBinary__Alternatives_1 )?
8206 {
8207 before(grammarAccess.getVLSBinaryAccess().getAlternatives_1());
8208 // InternalVampireLanguage.g:2503:2: ( rule__VLSBinary__Alternatives_1 )?
8209 int alt29=2;
8210 int LA29_0 = input.LA(1);
8211
8212 if ( ((LA29_0>=51 && LA29_0<=58)) ) {
8213 alt29=1;
8214 }
8215 switch (alt29) {
8216 case 1 :
8217 // InternalVampireLanguage.g:2503:3: rule__VLSBinary__Alternatives_1
8218 {
8219 pushFollow(FOLLOW_2);
8220 rule__VLSBinary__Alternatives_1();
8221
8222 state._fsp--;
8223
8224
8225 }
8226 break;
8227
8228 }
8229
8230 after(grammarAccess.getVLSBinaryAccess().getAlternatives_1());
8231
8232 }
8233
8234
8235 }
8236
8237 }
8238 catch (RecognitionException re) {
8239 reportError(re);
8240 recover(input,re);
8241 }
8242 finally {
8243
8244 restoreStackSize(stackSize);
8245
8246 }
8247 return ;
8248 }
8249 // $ANTLR end "rule__VLSBinary__Group__1__Impl"
8250
8251
8252 // $ANTLR start "rule__VLSBinary__Group_1_0__0"
8253 // InternalVampireLanguage.g:2512:1: rule__VLSBinary__Group_1_0__0 : rule__VLSBinary__Group_1_0__0__Impl rule__VLSBinary__Group_1_0__1 ;
8254 public final void rule__VLSBinary__Group_1_0__0() throws RecognitionException {
8255
8256 int stackSize = keepStackSize();
8257
8258 try {
8259 // InternalVampireLanguage.g:2516:1: ( rule__VLSBinary__Group_1_0__0__Impl rule__VLSBinary__Group_1_0__1 )
8260 // InternalVampireLanguage.g:2517:2: rule__VLSBinary__Group_1_0__0__Impl rule__VLSBinary__Group_1_0__1
8261 {
8262 pushFollow(FOLLOW_15);
8263 rule__VLSBinary__Group_1_0__0__Impl();
8264
8265 state._fsp--;
8266
8267 pushFollow(FOLLOW_2);
8268 rule__VLSBinary__Group_1_0__1();
8269
8270 state._fsp--;
8271
8272
8273 }
8274
8275 }
8276 catch (RecognitionException re) {
8277 reportError(re);
8278 recover(input,re);
8279 }
8280 finally {
8281
8282 restoreStackSize(stackSize);
8283
8284 }
8285 return ;
8286 }
8287 // $ANTLR end "rule__VLSBinary__Group_1_0__0"
8288
8289
8290 // $ANTLR start "rule__VLSBinary__Group_1_0__0__Impl"
8291 // InternalVampireLanguage.g:2524:1: rule__VLSBinary__Group_1_0__0__Impl : ( ( rule__VLSBinary__Alternatives_1_0_0 ) ) ;
8292 public final void rule__VLSBinary__Group_1_0__0__Impl() throws RecognitionException {
8293
8294 int stackSize = keepStackSize();
8295
8296 try {
8297 // InternalVampireLanguage.g:2528:1: ( ( ( rule__VLSBinary__Alternatives_1_0_0 ) ) )
8298 // InternalVampireLanguage.g:2529:1: ( ( rule__VLSBinary__Alternatives_1_0_0 ) )
8299 {
8300 // InternalVampireLanguage.g:2529:1: ( ( rule__VLSBinary__Alternatives_1_0_0 ) )
8301 // InternalVampireLanguage.g:2530:2: ( rule__VLSBinary__Alternatives_1_0_0 )
8302 {
8303 before(grammarAccess.getVLSBinaryAccess().getAlternatives_1_0_0());
8304 // InternalVampireLanguage.g:2531:2: ( rule__VLSBinary__Alternatives_1_0_0 )
8305 // InternalVampireLanguage.g:2531:3: rule__VLSBinary__Alternatives_1_0_0
8306 {
8307 pushFollow(FOLLOW_2);
8308 rule__VLSBinary__Alternatives_1_0_0();
8309
8310 state._fsp--;
8311
8312
8313 }
8314
8315 after(grammarAccess.getVLSBinaryAccess().getAlternatives_1_0_0());
8316
8317 }
8318
8319
8320 }
8321
8322 }
8323 catch (RecognitionException re) {
8324 reportError(re);
8325 recover(input,re);
8326 }
8327 finally {
8328
8329 restoreStackSize(stackSize);
8330
8331 }
8332 return ;
8333 }
8334 // $ANTLR end "rule__VLSBinary__Group_1_0__0__Impl"
8335
8336
8337 // $ANTLR start "rule__VLSBinary__Group_1_0__1"
8338 // InternalVampireLanguage.g:2539:1: rule__VLSBinary__Group_1_0__1 : rule__VLSBinary__Group_1_0__1__Impl ;
8339 public final void rule__VLSBinary__Group_1_0__1() throws RecognitionException {
8340
8341 int stackSize = keepStackSize();
8342
8343 try {
8344 // InternalVampireLanguage.g:2543:1: ( rule__VLSBinary__Group_1_0__1__Impl )
8345 // InternalVampireLanguage.g:2544:2: rule__VLSBinary__Group_1_0__1__Impl
8346 {
8347 pushFollow(FOLLOW_2);
8348 rule__VLSBinary__Group_1_0__1__Impl();
8349
8350 state._fsp--;
8351
8352
8353 }
8354
8355 }
8356 catch (RecognitionException re) {
8357 reportError(re);
8358 recover(input,re);
8359 }
8360 finally {
8361
8362 restoreStackSize(stackSize);
8363
8364 }
8365 return ;
8366 }
8367 // $ANTLR end "rule__VLSBinary__Group_1_0__1"
8368
8369
8370 // $ANTLR start "rule__VLSBinary__Group_1_0__1__Impl"
8371 // InternalVampireLanguage.g:2550:1: rule__VLSBinary__Group_1_0__1__Impl : ( ( rule__VLSBinary__RightAssignment_1_0_1 ) ) ;
8372 public final void rule__VLSBinary__Group_1_0__1__Impl() throws RecognitionException {
8373
8374 int stackSize = keepStackSize();
8375
8376 try {
8377 // InternalVampireLanguage.g:2554:1: ( ( ( rule__VLSBinary__RightAssignment_1_0_1 ) ) )
8378 // InternalVampireLanguage.g:2555:1: ( ( rule__VLSBinary__RightAssignment_1_0_1 ) )
8379 {
8380 // InternalVampireLanguage.g:2555:1: ( ( rule__VLSBinary__RightAssignment_1_0_1 ) )
8381 // InternalVampireLanguage.g:2556:2: ( rule__VLSBinary__RightAssignment_1_0_1 )
8382 {
8383 before(grammarAccess.getVLSBinaryAccess().getRightAssignment_1_0_1());
8384 // InternalVampireLanguage.g:2557:2: ( rule__VLSBinary__RightAssignment_1_0_1 )
8385 // InternalVampireLanguage.g:2557:3: rule__VLSBinary__RightAssignment_1_0_1
8386 {
8387 pushFollow(FOLLOW_2);
8388 rule__VLSBinary__RightAssignment_1_0_1();
8389
8390 state._fsp--;
8391
8392
8393 }
8394
8395 after(grammarAccess.getVLSBinaryAccess().getRightAssignment_1_0_1());
8396
8397 }
8398
8399
8400 }
8401
8402 }
8403 catch (RecognitionException re) {
8404 reportError(re);
8405 recover(input,re);
8406 }
8407 finally {
8408
8409 restoreStackSize(stackSize);
8410
8411 }
8412 return ;
8413 }
8414 // $ANTLR end "rule__VLSBinary__Group_1_0__1__Impl"
8415
8416
8417 // $ANTLR start "rule__VLSBinary__Group_1_0_0_0__0"
8418 // InternalVampireLanguage.g:2566:1: rule__VLSBinary__Group_1_0_0_0__0 : rule__VLSBinary__Group_1_0_0_0__0__Impl rule__VLSBinary__Group_1_0_0_0__1 ;
8419 public final void rule__VLSBinary__Group_1_0_0_0__0() throws RecognitionException {
8420
8421 int stackSize = keepStackSize();
8422
8423 try {
8424 // InternalVampireLanguage.g:2570:1: ( rule__VLSBinary__Group_1_0_0_0__0__Impl rule__VLSBinary__Group_1_0_0_0__1 )
8425 // InternalVampireLanguage.g:2571:2: rule__VLSBinary__Group_1_0_0_0__0__Impl rule__VLSBinary__Group_1_0_0_0__1
8426 {
8427 pushFollow(FOLLOW_21);
8428 rule__VLSBinary__Group_1_0_0_0__0__Impl();
8429
8430 state._fsp--;
8431
8432 pushFollow(FOLLOW_2);
8433 rule__VLSBinary__Group_1_0_0_0__1();
8434
8435 state._fsp--;
8436
8437
8438 }
8439
8440 }
8441 catch (RecognitionException re) {
8442 reportError(re);
8443 recover(input,re);
8444 }
8445 finally {
8446
8447 restoreStackSize(stackSize);
8448
8449 }
8450 return ;
8451 }
8452 // $ANTLR end "rule__VLSBinary__Group_1_0_0_0__0"
8453
8454
8455 // $ANTLR start "rule__VLSBinary__Group_1_0_0_0__0__Impl"
8456 // InternalVampireLanguage.g:2578:1: rule__VLSBinary__Group_1_0_0_0__0__Impl : ( () ) ;
8457 public final void rule__VLSBinary__Group_1_0_0_0__0__Impl() throws RecognitionException {
8458
8459 int stackSize = keepStackSize();
8460
8461 try {
8462 // InternalVampireLanguage.g:2582:1: ( ( () ) )
8463 // InternalVampireLanguage.g:2583:1: ( () )
8464 {
8465 // InternalVampireLanguage.g:2583:1: ( () )
8466 // InternalVampireLanguage.g:2584:2: ()
8467 {
8468 before(grammarAccess.getVLSBinaryAccess().getVLSEquivalentLeftAction_1_0_0_0_0());
8469 // InternalVampireLanguage.g:2585:2: ()
8470 // InternalVampireLanguage.g:2585:3:
8471 {
8472 }
8473
8474 after(grammarAccess.getVLSBinaryAccess().getVLSEquivalentLeftAction_1_0_0_0_0());
8475
8476 }
8477
8478
8479 }
8480
8481 }
8482 finally {
8483
8484 restoreStackSize(stackSize);
8485
8486 }
8487 return ;
8488 }
8489 // $ANTLR end "rule__VLSBinary__Group_1_0_0_0__0__Impl"
8490
8491
8492 // $ANTLR start "rule__VLSBinary__Group_1_0_0_0__1"
8493 // InternalVampireLanguage.g:2593:1: rule__VLSBinary__Group_1_0_0_0__1 : rule__VLSBinary__Group_1_0_0_0__1__Impl ;
8494 public final void rule__VLSBinary__Group_1_0_0_0__1() throws RecognitionException {
8495
8496 int stackSize = keepStackSize();
8497
8498 try {
8499 // InternalVampireLanguage.g:2597:1: ( rule__VLSBinary__Group_1_0_0_0__1__Impl )
8500 // InternalVampireLanguage.g:2598:2: rule__VLSBinary__Group_1_0_0_0__1__Impl
8501 {
8502 pushFollow(FOLLOW_2);
8503 rule__VLSBinary__Group_1_0_0_0__1__Impl();
8504
8505 state._fsp--;
8506
8507
8508 }
8509
8510 }
8511 catch (RecognitionException re) {
8512 reportError(re);
8513 recover(input,re);
8514 }
8515 finally {
8516
8517 restoreStackSize(stackSize);
8518
8519 }
8520 return ;
8521 }
8522 // $ANTLR end "rule__VLSBinary__Group_1_0_0_0__1"
8523
8524
8525 // $ANTLR start "rule__VLSBinary__Group_1_0_0_0__1__Impl"
8526 // InternalVampireLanguage.g:2604:1: rule__VLSBinary__Group_1_0_0_0__1__Impl : ( '<=>' ) ;
8527 public final void rule__VLSBinary__Group_1_0_0_0__1__Impl() throws RecognitionException {
8528
8529 int stackSize = keepStackSize();
8530
8531 try {
8532 // InternalVampireLanguage.g:2608:1: ( ( '<=>' ) )
8533 // InternalVampireLanguage.g:2609:1: ( '<=>' )
8534 {
8535 // InternalVampireLanguage.g:2609:1: ( '<=>' )
8536 // InternalVampireLanguage.g:2610:2: '<=>'
8537 {
8538 before(grammarAccess.getVLSBinaryAccess().getLessThanSignEqualsSignGreaterThanSignKeyword_1_0_0_0_1());
8539 match(input,51,FOLLOW_2);
8540 after(grammarAccess.getVLSBinaryAccess().getLessThanSignEqualsSignGreaterThanSignKeyword_1_0_0_0_1());
8541
8542 }
8543
8544
8545 }
8546
8547 }
8548 catch (RecognitionException re) {
8549 reportError(re);
8550 recover(input,re);
8551 }
8552 finally {
8553
8554 restoreStackSize(stackSize);
8555
8556 }
8557 return ;
8558 }
8559 // $ANTLR end "rule__VLSBinary__Group_1_0_0_0__1__Impl"
8560
8561
8562 // $ANTLR start "rule__VLSBinary__Group_1_0_0_1__0"
8563 // InternalVampireLanguage.g:2620:1: rule__VLSBinary__Group_1_0_0_1__0 : rule__VLSBinary__Group_1_0_0_1__0__Impl rule__VLSBinary__Group_1_0_0_1__1 ;
8564 public final void rule__VLSBinary__Group_1_0_0_1__0() throws RecognitionException {
8565
8566 int stackSize = keepStackSize();
8567
8568 try {
8569 // InternalVampireLanguage.g:2624:1: ( rule__VLSBinary__Group_1_0_0_1__0__Impl rule__VLSBinary__Group_1_0_0_1__1 )
8570 // InternalVampireLanguage.g:2625:2: rule__VLSBinary__Group_1_0_0_1__0__Impl rule__VLSBinary__Group_1_0_0_1__1
8571 {
8572 pushFollow(FOLLOW_22);
8573 rule__VLSBinary__Group_1_0_0_1__0__Impl();
8574
8575 state._fsp--;
8576
8577 pushFollow(FOLLOW_2);
8578 rule__VLSBinary__Group_1_0_0_1__1();
8579
8580 state._fsp--;
8581
8582
8583 }
8584
8585 }
8586 catch (RecognitionException re) {
8587 reportError(re);
8588 recover(input,re);
8589 }
8590 finally {
8591
8592 restoreStackSize(stackSize);
8593
8594 }
8595 return ;
8596 }
8597 // $ANTLR end "rule__VLSBinary__Group_1_0_0_1__0"
8598
8599
8600 // $ANTLR start "rule__VLSBinary__Group_1_0_0_1__0__Impl"
8601 // InternalVampireLanguage.g:2632:1: rule__VLSBinary__Group_1_0_0_1__0__Impl : ( () ) ;
8602 public final void rule__VLSBinary__Group_1_0_0_1__0__Impl() throws RecognitionException {
8603
8604 int stackSize = keepStackSize();
8605
8606 try {
8607 // InternalVampireLanguage.g:2636:1: ( ( () ) )
8608 // InternalVampireLanguage.g:2637:1: ( () )
8609 {
8610 // InternalVampireLanguage.g:2637:1: ( () )
8611 // InternalVampireLanguage.g:2638:2: ()
8612 {
8613 before(grammarAccess.getVLSBinaryAccess().getVLSImpliesLeftAction_1_0_0_1_0());
8614 // InternalVampireLanguage.g:2639:2: ()
8615 // InternalVampireLanguage.g:2639:3:
8616 {
8617 }
8618
8619 after(grammarAccess.getVLSBinaryAccess().getVLSImpliesLeftAction_1_0_0_1_0());
8620
8621 }
8622
8623
8624 }
8625
8626 }
8627 finally {
8628
8629 restoreStackSize(stackSize);
8630
8631 }
8632 return ;
8633 }
8634 // $ANTLR end "rule__VLSBinary__Group_1_0_0_1__0__Impl"
8635
8636
8637 // $ANTLR start "rule__VLSBinary__Group_1_0_0_1__1"
8638 // InternalVampireLanguage.g:2647:1: rule__VLSBinary__Group_1_0_0_1__1 : rule__VLSBinary__Group_1_0_0_1__1__Impl ;
8639 public final void rule__VLSBinary__Group_1_0_0_1__1() throws RecognitionException {
8640
8641 int stackSize = keepStackSize();
8642
8643 try {
8644 // InternalVampireLanguage.g:2651:1: ( rule__VLSBinary__Group_1_0_0_1__1__Impl )
8645 // InternalVampireLanguage.g:2652:2: rule__VLSBinary__Group_1_0_0_1__1__Impl
8646 {
8647 pushFollow(FOLLOW_2);
8648 rule__VLSBinary__Group_1_0_0_1__1__Impl();
8649
8650 state._fsp--;
8651
8652
8653 }
8654
8655 }
8656 catch (RecognitionException re) {
8657 reportError(re);
8658 recover(input,re);
8659 }
8660 finally {
8661
8662 restoreStackSize(stackSize);
8663
8664 }
8665 return ;
8666 }
8667 // $ANTLR end "rule__VLSBinary__Group_1_0_0_1__1"
8668
8669
8670 // $ANTLR start "rule__VLSBinary__Group_1_0_0_1__1__Impl"
8671 // InternalVampireLanguage.g:2658:1: rule__VLSBinary__Group_1_0_0_1__1__Impl : ( '=>' ) ;
8672 public final void rule__VLSBinary__Group_1_0_0_1__1__Impl() throws RecognitionException {
8673
8674 int stackSize = keepStackSize();
8675
8676 try {
8677 // InternalVampireLanguage.g:2662:1: ( ( '=>' ) )
8678 // InternalVampireLanguage.g:2663:1: ( '=>' )
8679 {
8680 // InternalVampireLanguage.g:2663:1: ( '=>' )
8681 // InternalVampireLanguage.g:2664:2: '=>'
8682 {
8683 before(grammarAccess.getVLSBinaryAccess().getEqualsSignGreaterThanSignKeyword_1_0_0_1_1());
8684 match(input,52,FOLLOW_2);
8685 after(grammarAccess.getVLSBinaryAccess().getEqualsSignGreaterThanSignKeyword_1_0_0_1_1());
8686
8687 }
8688
8689
8690 }
8691
8692 }
8693 catch (RecognitionException re) {
8694 reportError(re);
8695 recover(input,re);
8696 }
8697 finally {
8698
8699 restoreStackSize(stackSize);
8700
8701 }
8702 return ;
8703 }
8704 // $ANTLR end "rule__VLSBinary__Group_1_0_0_1__1__Impl"
8705
8706
8707 // $ANTLR start "rule__VLSBinary__Group_1_0_0_2__0"
8708 // InternalVampireLanguage.g:2674:1: rule__VLSBinary__Group_1_0_0_2__0 : rule__VLSBinary__Group_1_0_0_2__0__Impl rule__VLSBinary__Group_1_0_0_2__1 ;
8709 public final void rule__VLSBinary__Group_1_0_0_2__0() throws RecognitionException {
8710
8711 int stackSize = keepStackSize();
8712
8713 try {
8714 // InternalVampireLanguage.g:2678:1: ( rule__VLSBinary__Group_1_0_0_2__0__Impl rule__VLSBinary__Group_1_0_0_2__1 )
8715 // InternalVampireLanguage.g:2679:2: rule__VLSBinary__Group_1_0_0_2__0__Impl rule__VLSBinary__Group_1_0_0_2__1
8716 {
8717 pushFollow(FOLLOW_23);
8718 rule__VLSBinary__Group_1_0_0_2__0__Impl();
8719
8720 state._fsp--;
8721
8722 pushFollow(FOLLOW_2);
8723 rule__VLSBinary__Group_1_0_0_2__1();
8724
8725 state._fsp--;
8726
8727
8728 }
8729
8730 }
8731 catch (RecognitionException re) {
8732 reportError(re);
8733 recover(input,re);
8734 }
8735 finally {
8736
8737 restoreStackSize(stackSize);
8738
8739 }
8740 return ;
8741 }
8742 // $ANTLR end "rule__VLSBinary__Group_1_0_0_2__0"
8743
8744
8745 // $ANTLR start "rule__VLSBinary__Group_1_0_0_2__0__Impl"
8746 // InternalVampireLanguage.g:2686:1: rule__VLSBinary__Group_1_0_0_2__0__Impl : ( () ) ;
8747 public final void rule__VLSBinary__Group_1_0_0_2__0__Impl() throws RecognitionException {
8748
8749 int stackSize = keepStackSize();
8750
8751 try {
8752 // InternalVampireLanguage.g:2690:1: ( ( () ) )
8753 // InternalVampireLanguage.g:2691:1: ( () )
8754 {
8755 // InternalVampireLanguage.g:2691:1: ( () )
8756 // InternalVampireLanguage.g:2692:2: ()
8757 {
8758 before(grammarAccess.getVLSBinaryAccess().getVLSRevImpliesLeftAction_1_0_0_2_0());
8759 // InternalVampireLanguage.g:2693:2: ()
8760 // InternalVampireLanguage.g:2693:3:
8761 {
8762 }
8763
8764 after(grammarAccess.getVLSBinaryAccess().getVLSRevImpliesLeftAction_1_0_0_2_0());
8765
8766 }
8767
8768
8769 }
8770
8771 }
8772 finally {
8773
8774 restoreStackSize(stackSize);
8775
8776 }
8777 return ;
8778 }
8779 // $ANTLR end "rule__VLSBinary__Group_1_0_0_2__0__Impl"
8780
8781
8782 // $ANTLR start "rule__VLSBinary__Group_1_0_0_2__1"
8783 // InternalVampireLanguage.g:2701:1: rule__VLSBinary__Group_1_0_0_2__1 : rule__VLSBinary__Group_1_0_0_2__1__Impl ;
8784 public final void rule__VLSBinary__Group_1_0_0_2__1() throws RecognitionException {
8785
8786 int stackSize = keepStackSize();
8787
8788 try {
8789 // InternalVampireLanguage.g:2705:1: ( rule__VLSBinary__Group_1_0_0_2__1__Impl )
8790 // InternalVampireLanguage.g:2706:2: rule__VLSBinary__Group_1_0_0_2__1__Impl
8791 {
8792 pushFollow(FOLLOW_2);
8793 rule__VLSBinary__Group_1_0_0_2__1__Impl();
8794
8795 state._fsp--;
8796
8797
8798 }
8799
8800 }
8801 catch (RecognitionException re) {
8802 reportError(re);
8803 recover(input,re);
8804 }
8805 finally {
8806
8807 restoreStackSize(stackSize);
8808
8809 }
8810 return ;
8811 }
8812 // $ANTLR end "rule__VLSBinary__Group_1_0_0_2__1"
8813
8814
8815 // $ANTLR start "rule__VLSBinary__Group_1_0_0_2__1__Impl"
8816 // InternalVampireLanguage.g:2712:1: rule__VLSBinary__Group_1_0_0_2__1__Impl : ( '<=' ) ;
8817 public final void rule__VLSBinary__Group_1_0_0_2__1__Impl() throws RecognitionException {
8818
8819 int stackSize = keepStackSize();
8820
8821 try {
8822 // InternalVampireLanguage.g:2716:1: ( ( '<=' ) )
8823 // InternalVampireLanguage.g:2717:1: ( '<=' )
8824 {
8825 // InternalVampireLanguage.g:2717:1: ( '<=' )
8826 // InternalVampireLanguage.g:2718:2: '<='
8827 {
8828 before(grammarAccess.getVLSBinaryAccess().getLessThanSignEqualsSignKeyword_1_0_0_2_1());
8829 match(input,53,FOLLOW_2);
8830 after(grammarAccess.getVLSBinaryAccess().getLessThanSignEqualsSignKeyword_1_0_0_2_1());
8831
8832 }
8833
8834
8835 }
8836
8837 }
8838 catch (RecognitionException re) {
8839 reportError(re);
8840 recover(input,re);
8841 }
8842 finally {
8843
8844 restoreStackSize(stackSize);
8845
8846 }
8847 return ;
8848 }
8849 // $ANTLR end "rule__VLSBinary__Group_1_0_0_2__1__Impl"
8850
8851
8852 // $ANTLR start "rule__VLSBinary__Group_1_0_0_3__0"
8853 // InternalVampireLanguage.g:2728:1: rule__VLSBinary__Group_1_0_0_3__0 : rule__VLSBinary__Group_1_0_0_3__0__Impl rule__VLSBinary__Group_1_0_0_3__1 ;
8854 public final void rule__VLSBinary__Group_1_0_0_3__0() throws RecognitionException {
8855
8856 int stackSize = keepStackSize();
8857
8858 try {
8859 // InternalVampireLanguage.g:2732:1: ( rule__VLSBinary__Group_1_0_0_3__0__Impl rule__VLSBinary__Group_1_0_0_3__1 )
8860 // InternalVampireLanguage.g:2733:2: rule__VLSBinary__Group_1_0_0_3__0__Impl rule__VLSBinary__Group_1_0_0_3__1
8861 {
8862 pushFollow(FOLLOW_24);
8863 rule__VLSBinary__Group_1_0_0_3__0__Impl();
8864
8865 state._fsp--;
8866
8867 pushFollow(FOLLOW_2);
8868 rule__VLSBinary__Group_1_0_0_3__1();
8869
8870 state._fsp--;
8871
8872
8873 }
8874
8875 }
8876 catch (RecognitionException re) {
8877 reportError(re);
8878 recover(input,re);
8879 }
8880 finally {
8881
8882 restoreStackSize(stackSize);
8883
8884 }
8885 return ;
8886 }
8887 // $ANTLR end "rule__VLSBinary__Group_1_0_0_3__0"
8888
8889
8890 // $ANTLR start "rule__VLSBinary__Group_1_0_0_3__0__Impl"
8891 // InternalVampireLanguage.g:2740:1: rule__VLSBinary__Group_1_0_0_3__0__Impl : ( () ) ;
8892 public final void rule__VLSBinary__Group_1_0_0_3__0__Impl() throws RecognitionException {
8893
8894 int stackSize = keepStackSize();
8895
8896 try {
8897 // InternalVampireLanguage.g:2744:1: ( ( () ) )
8898 // InternalVampireLanguage.g:2745:1: ( () )
8899 {
8900 // InternalVampireLanguage.g:2745:1: ( () )
8901 // InternalVampireLanguage.g:2746:2: ()
8902 {
8903 before(grammarAccess.getVLSBinaryAccess().getVLSXnorLeftAction_1_0_0_3_0());
8904 // InternalVampireLanguage.g:2747:2: ()
8905 // InternalVampireLanguage.g:2747:3:
8906 {
8907 }
8908
8909 after(grammarAccess.getVLSBinaryAccess().getVLSXnorLeftAction_1_0_0_3_0());
8910
8911 }
8912
8913
8914 }
8915
8916 }
8917 finally {
8918
8919 restoreStackSize(stackSize);
8920
8921 }
8922 return ;
8923 }
8924 // $ANTLR end "rule__VLSBinary__Group_1_0_0_3__0__Impl"
8925
8926
8927 // $ANTLR start "rule__VLSBinary__Group_1_0_0_3__1"
8928 // InternalVampireLanguage.g:2755:1: rule__VLSBinary__Group_1_0_0_3__1 : rule__VLSBinary__Group_1_0_0_3__1__Impl ;
8929 public final void rule__VLSBinary__Group_1_0_0_3__1() throws RecognitionException {
8930
8931 int stackSize = keepStackSize();
8932
8933 try {
8934 // InternalVampireLanguage.g:2759:1: ( rule__VLSBinary__Group_1_0_0_3__1__Impl )
8935 // InternalVampireLanguage.g:2760:2: rule__VLSBinary__Group_1_0_0_3__1__Impl
8936 {
8937 pushFollow(FOLLOW_2);
8938 rule__VLSBinary__Group_1_0_0_3__1__Impl();
8939
8940 state._fsp--;
8941
8942
8943 }
8944
8945 }
8946 catch (RecognitionException re) {
8947 reportError(re);
8948 recover(input,re);
8949 }
8950 finally {
8951
8952 restoreStackSize(stackSize);
8953
8954 }
8955 return ;
8956 }
8957 // $ANTLR end "rule__VLSBinary__Group_1_0_0_3__1"
8958
8959
8960 // $ANTLR start "rule__VLSBinary__Group_1_0_0_3__1__Impl"
8961 // InternalVampireLanguage.g:2766:1: rule__VLSBinary__Group_1_0_0_3__1__Impl : ( '<~>' ) ;
8962 public final void rule__VLSBinary__Group_1_0_0_3__1__Impl() throws RecognitionException {
8963
8964 int stackSize = keepStackSize();
8965
8966 try {
8967 // InternalVampireLanguage.g:2770:1: ( ( '<~>' ) )
8968 // InternalVampireLanguage.g:2771:1: ( '<~>' )
8969 {
8970 // InternalVampireLanguage.g:2771:1: ( '<~>' )
8971 // InternalVampireLanguage.g:2772:2: '<~>'
8972 {
8973 before(grammarAccess.getVLSBinaryAccess().getLessThanSignTildeGreaterThanSignKeyword_1_0_0_3_1());
8974 match(input,54,FOLLOW_2);
8975 after(grammarAccess.getVLSBinaryAccess().getLessThanSignTildeGreaterThanSignKeyword_1_0_0_3_1());
8976
8977 }
8978
8979
8980 }
8981
8982 }
8983 catch (RecognitionException re) {
8984 reportError(re);
8985 recover(input,re);
8986 }
8987 finally {
8988
8989 restoreStackSize(stackSize);
8990
8991 }
8992 return ;
8993 }
8994 // $ANTLR end "rule__VLSBinary__Group_1_0_0_3__1__Impl"
8995
8996
8997 // $ANTLR start "rule__VLSBinary__Group_1_0_0_4__0"
8998 // InternalVampireLanguage.g:2782:1: rule__VLSBinary__Group_1_0_0_4__0 : rule__VLSBinary__Group_1_0_0_4__0__Impl rule__VLSBinary__Group_1_0_0_4__1 ;
8999 public final void rule__VLSBinary__Group_1_0_0_4__0() throws RecognitionException {
9000
9001 int stackSize = keepStackSize();
9002
9003 try {
9004 // InternalVampireLanguage.g:2786:1: ( rule__VLSBinary__Group_1_0_0_4__0__Impl rule__VLSBinary__Group_1_0_0_4__1 )
9005 // InternalVampireLanguage.g:2787:2: rule__VLSBinary__Group_1_0_0_4__0__Impl rule__VLSBinary__Group_1_0_0_4__1
9006 {
9007 pushFollow(FOLLOW_25);
9008 rule__VLSBinary__Group_1_0_0_4__0__Impl();
9009
9010 state._fsp--;
9011
9012 pushFollow(FOLLOW_2);
9013 rule__VLSBinary__Group_1_0_0_4__1();
9014
9015 state._fsp--;
9016
9017
9018 }
9019
9020 }
9021 catch (RecognitionException re) {
9022 reportError(re);
9023 recover(input,re);
9024 }
9025 finally {
9026
9027 restoreStackSize(stackSize);
9028
9029 }
9030 return ;
9031 }
9032 // $ANTLR end "rule__VLSBinary__Group_1_0_0_4__0"
9033
9034
9035 // $ANTLR start "rule__VLSBinary__Group_1_0_0_4__0__Impl"
9036 // InternalVampireLanguage.g:2794:1: rule__VLSBinary__Group_1_0_0_4__0__Impl : ( () ) ;
9037 public final void rule__VLSBinary__Group_1_0_0_4__0__Impl() throws RecognitionException {
9038
9039 int stackSize = keepStackSize();
9040
9041 try {
9042 // InternalVampireLanguage.g:2798:1: ( ( () ) )
9043 // InternalVampireLanguage.g:2799:1: ( () )
9044 {
9045 // InternalVampireLanguage.g:2799:1: ( () )
9046 // InternalVampireLanguage.g:2800:2: ()
9047 {
9048 before(grammarAccess.getVLSBinaryAccess().getVLSNorLeftAction_1_0_0_4_0());
9049 // InternalVampireLanguage.g:2801:2: ()
9050 // InternalVampireLanguage.g:2801:3:
9051 {
9052 }
9053
9054 after(grammarAccess.getVLSBinaryAccess().getVLSNorLeftAction_1_0_0_4_0());
9055
9056 }
9057
9058
9059 }
9060
9061 }
9062 finally {
9063
9064 restoreStackSize(stackSize);
9065
9066 }
9067 return ;
9068 }
9069 // $ANTLR end "rule__VLSBinary__Group_1_0_0_4__0__Impl"
9070
9071
9072 // $ANTLR start "rule__VLSBinary__Group_1_0_0_4__1"
9073 // InternalVampireLanguage.g:2809:1: rule__VLSBinary__Group_1_0_0_4__1 : rule__VLSBinary__Group_1_0_0_4__1__Impl ;
9074 public final void rule__VLSBinary__Group_1_0_0_4__1() throws RecognitionException {
9075
9076 int stackSize = keepStackSize();
9077
9078 try {
9079 // InternalVampireLanguage.g:2813:1: ( rule__VLSBinary__Group_1_0_0_4__1__Impl )
9080 // InternalVampireLanguage.g:2814:2: rule__VLSBinary__Group_1_0_0_4__1__Impl
9081 {
9082 pushFollow(FOLLOW_2);
9083 rule__VLSBinary__Group_1_0_0_4__1__Impl();
9084
9085 state._fsp--;
9086
9087
9088 }
9089
9090 }
9091 catch (RecognitionException re) {
9092 reportError(re);
9093 recover(input,re);
9094 }
9095 finally {
9096
9097 restoreStackSize(stackSize);
9098
9099 }
9100 return ;
9101 }
9102 // $ANTLR end "rule__VLSBinary__Group_1_0_0_4__1"
9103
9104
9105 // $ANTLR start "rule__VLSBinary__Group_1_0_0_4__1__Impl"
9106 // InternalVampireLanguage.g:2820:1: rule__VLSBinary__Group_1_0_0_4__1__Impl : ( '~|' ) ;
9107 public final void rule__VLSBinary__Group_1_0_0_4__1__Impl() throws RecognitionException {
9108
9109 int stackSize = keepStackSize();
9110
9111 try {
9112 // InternalVampireLanguage.g:2824:1: ( ( '~|' ) )
9113 // InternalVampireLanguage.g:2825:1: ( '~|' )
9114 {
9115 // InternalVampireLanguage.g:2825:1: ( '~|' )
9116 // InternalVampireLanguage.g:2826:2: '~|'
9117 {
9118 before(grammarAccess.getVLSBinaryAccess().getTildeVerticalLineKeyword_1_0_0_4_1());
9119 match(input,55,FOLLOW_2);
9120 after(grammarAccess.getVLSBinaryAccess().getTildeVerticalLineKeyword_1_0_0_4_1());
9121
9122 }
9123
9124
9125 }
9126
9127 }
9128 catch (RecognitionException re) {
9129 reportError(re);
9130 recover(input,re);
9131 }
9132 finally {
9133
9134 restoreStackSize(stackSize);
9135
9136 }
9137 return ;
9138 }
9139 // $ANTLR end "rule__VLSBinary__Group_1_0_0_4__1__Impl"
9140
9141
9142 // $ANTLR start "rule__VLSBinary__Group_1_0_0_5__0"
9143 // InternalVampireLanguage.g:2836:1: rule__VLSBinary__Group_1_0_0_5__0 : rule__VLSBinary__Group_1_0_0_5__0__Impl rule__VLSBinary__Group_1_0_0_5__1 ;
9144 public final void rule__VLSBinary__Group_1_0_0_5__0() throws RecognitionException {
9145
9146 int stackSize = keepStackSize();
9147
9148 try {
9149 // InternalVampireLanguage.g:2840:1: ( rule__VLSBinary__Group_1_0_0_5__0__Impl rule__VLSBinary__Group_1_0_0_5__1 )
9150 // InternalVampireLanguage.g:2841:2: rule__VLSBinary__Group_1_0_0_5__0__Impl rule__VLSBinary__Group_1_0_0_5__1
9151 {
9152 pushFollow(FOLLOW_26);
9153 rule__VLSBinary__Group_1_0_0_5__0__Impl();
9154
9155 state._fsp--;
9156
9157 pushFollow(FOLLOW_2);
9158 rule__VLSBinary__Group_1_0_0_5__1();
9159
9160 state._fsp--;
9161
9162
9163 }
9164
9165 }
9166 catch (RecognitionException re) {
9167 reportError(re);
9168 recover(input,re);
9169 }
9170 finally {
9171
9172 restoreStackSize(stackSize);
9173
9174 }
9175 return ;
9176 }
9177 // $ANTLR end "rule__VLSBinary__Group_1_0_0_5__0"
9178
9179
9180 // $ANTLR start "rule__VLSBinary__Group_1_0_0_5__0__Impl"
9181 // InternalVampireLanguage.g:2848:1: rule__VLSBinary__Group_1_0_0_5__0__Impl : ( () ) ;
9182 public final void rule__VLSBinary__Group_1_0_0_5__0__Impl() throws RecognitionException {
9183
9184 int stackSize = keepStackSize();
9185
9186 try {
9187 // InternalVampireLanguage.g:2852:1: ( ( () ) )
9188 // InternalVampireLanguage.g:2853:1: ( () )
9189 {
9190 // InternalVampireLanguage.g:2853:1: ( () )
9191 // InternalVampireLanguage.g:2854:2: ()
9192 {
9193 before(grammarAccess.getVLSBinaryAccess().getVLSNandLeftAction_1_0_0_5_0());
9194 // InternalVampireLanguage.g:2855:2: ()
9195 // InternalVampireLanguage.g:2855:3:
9196 {
9197 }
9198
9199 after(grammarAccess.getVLSBinaryAccess().getVLSNandLeftAction_1_0_0_5_0());
9200
9201 }
9202
9203
9204 }
9205
9206 }
9207 finally {
9208
9209 restoreStackSize(stackSize);
9210
9211 }
9212 return ;
9213 }
9214 // $ANTLR end "rule__VLSBinary__Group_1_0_0_5__0__Impl"
9215
9216
9217 // $ANTLR start "rule__VLSBinary__Group_1_0_0_5__1"
9218 // InternalVampireLanguage.g:2863:1: rule__VLSBinary__Group_1_0_0_5__1 : rule__VLSBinary__Group_1_0_0_5__1__Impl ;
9219 public final void rule__VLSBinary__Group_1_0_0_5__1() throws RecognitionException {
9220
9221 int stackSize = keepStackSize();
9222
9223 try {
9224 // InternalVampireLanguage.g:2867:1: ( rule__VLSBinary__Group_1_0_0_5__1__Impl )
9225 // InternalVampireLanguage.g:2868:2: rule__VLSBinary__Group_1_0_0_5__1__Impl
9226 {
9227 pushFollow(FOLLOW_2);
9228 rule__VLSBinary__Group_1_0_0_5__1__Impl();
9229
9230 state._fsp--;
9231
9232
9233 }
9234
9235 }
9236 catch (RecognitionException re) {
9237 reportError(re);
9238 recover(input,re);
9239 }
9240 finally {
9241
9242 restoreStackSize(stackSize);
9243
9244 }
9245 return ;
9246 }
9247 // $ANTLR end "rule__VLSBinary__Group_1_0_0_5__1"
9248
9249
9250 // $ANTLR start "rule__VLSBinary__Group_1_0_0_5__1__Impl"
9251 // InternalVampireLanguage.g:2874:1: rule__VLSBinary__Group_1_0_0_5__1__Impl : ( '~&' ) ;
9252 public final void rule__VLSBinary__Group_1_0_0_5__1__Impl() throws RecognitionException {
9253
9254 int stackSize = keepStackSize();
9255
9256 try {
9257 // InternalVampireLanguage.g:2878:1: ( ( '~&' ) )
9258 // InternalVampireLanguage.g:2879:1: ( '~&' )
9259 {
9260 // InternalVampireLanguage.g:2879:1: ( '~&' )
9261 // InternalVampireLanguage.g:2880:2: '~&'
9262 {
9263 before(grammarAccess.getVLSBinaryAccess().getTildeAmpersandKeyword_1_0_0_5_1());
9264 match(input,56,FOLLOW_2);
9265 after(grammarAccess.getVLSBinaryAccess().getTildeAmpersandKeyword_1_0_0_5_1());
9266
9267 }
9268
9269
9270 }
9271
9272 }
9273 catch (RecognitionException re) {
9274 reportError(re);
9275 recover(input,re);
9276 }
9277 finally {
9278
9279 restoreStackSize(stackSize);
9280
9281 }
9282 return ;
9283 }
9284 // $ANTLR end "rule__VLSBinary__Group_1_0_0_5__1__Impl"
9285
9286
9287 // $ANTLR start "rule__VLSBinary__Group_1_1__0"
9288 // InternalVampireLanguage.g:2890:1: rule__VLSBinary__Group_1_1__0 : rule__VLSBinary__Group_1_1__0__Impl rule__VLSBinary__Group_1_1__1 ;
9289 public final void rule__VLSBinary__Group_1_1__0() throws RecognitionException {
9290
9291 int stackSize = keepStackSize();
9292
9293 try {
9294 // InternalVampireLanguage.g:2894:1: ( rule__VLSBinary__Group_1_1__0__Impl rule__VLSBinary__Group_1_1__1 )
9295 // InternalVampireLanguage.g:2895:2: rule__VLSBinary__Group_1_1__0__Impl rule__VLSBinary__Group_1_1__1
9296 {
9297 pushFollow(FOLLOW_27);
9298 rule__VLSBinary__Group_1_1__0__Impl();
9299
9300 state._fsp--;
9301
9302 pushFollow(FOLLOW_2);
9303 rule__VLSBinary__Group_1_1__1();
9304
9305 state._fsp--;
9306
9307
9308 }
9309
9310 }
9311 catch (RecognitionException re) {
9312 reportError(re);
9313 recover(input,re);
9314 }
9315 finally {
9316
9317 restoreStackSize(stackSize);
9318
9319 }
9320 return ;
9321 }
9322 // $ANTLR end "rule__VLSBinary__Group_1_1__0"
9323
9324
9325 // $ANTLR start "rule__VLSBinary__Group_1_1__0__Impl"
9326 // InternalVampireLanguage.g:2902:1: rule__VLSBinary__Group_1_1__0__Impl : ( () ) ;
9327 public final void rule__VLSBinary__Group_1_1__0__Impl() throws RecognitionException {
9328
9329 int stackSize = keepStackSize();
9330
9331 try {
9332 // InternalVampireLanguage.g:2906:1: ( ( () ) )
9333 // InternalVampireLanguage.g:2907:1: ( () )
9334 {
9335 // InternalVampireLanguage.g:2907:1: ( () )
9336 // InternalVampireLanguage.g:2908:2: ()
9337 {
9338 before(grammarAccess.getVLSBinaryAccess().getVLSAndLeftAction_1_1_0());
9339 // InternalVampireLanguage.g:2909:2: ()
9340 // InternalVampireLanguage.g:2909:3:
9341 {
9342 }
9343
9344 after(grammarAccess.getVLSBinaryAccess().getVLSAndLeftAction_1_1_0());
9345
9346 }
9347
9348
9349 }
9350
9351 }
9352 finally {
9353
9354 restoreStackSize(stackSize);
9355
9356 }
9357 return ;
9358 }
9359 // $ANTLR end "rule__VLSBinary__Group_1_1__0__Impl"
9360
9361
9362 // $ANTLR start "rule__VLSBinary__Group_1_1__1"
9363 // InternalVampireLanguage.g:2917:1: rule__VLSBinary__Group_1_1__1 : rule__VLSBinary__Group_1_1__1__Impl rule__VLSBinary__Group_1_1__2 ;
9364 public final void rule__VLSBinary__Group_1_1__1() throws RecognitionException {
9365
9366 int stackSize = keepStackSize();
9367
9368 try {
9369 // InternalVampireLanguage.g:2921:1: ( rule__VLSBinary__Group_1_1__1__Impl rule__VLSBinary__Group_1_1__2 )
9370 // InternalVampireLanguage.g:2922:2: rule__VLSBinary__Group_1_1__1__Impl rule__VLSBinary__Group_1_1__2
9371 {
9372 pushFollow(FOLLOW_15);
9373 rule__VLSBinary__Group_1_1__1__Impl();
9374
9375 state._fsp--;
9376
9377 pushFollow(FOLLOW_2);
9378 rule__VLSBinary__Group_1_1__2();
9379
9380 state._fsp--;
9381
9382
9383 }
9384
9385 }
9386 catch (RecognitionException re) {
9387 reportError(re);
9388 recover(input,re);
9389 }
9390 finally {
9391
9392 restoreStackSize(stackSize);
9393
9394 }
9395 return ;
9396 }
9397 // $ANTLR end "rule__VLSBinary__Group_1_1__1"
9398
9399
9400 // $ANTLR start "rule__VLSBinary__Group_1_1__1__Impl"
9401 // InternalVampireLanguage.g:2929:1: rule__VLSBinary__Group_1_1__1__Impl : ( '&' ) ;
9402 public final void rule__VLSBinary__Group_1_1__1__Impl() throws RecognitionException {
9403
9404 int stackSize = keepStackSize();
9405
9406 try {
9407 // InternalVampireLanguage.g:2933:1: ( ( '&' ) )
9408 // InternalVampireLanguage.g:2934:1: ( '&' )
9409 {
9410 // InternalVampireLanguage.g:2934:1: ( '&' )
9411 // InternalVampireLanguage.g:2935:2: '&'
9412 {
9413 before(grammarAccess.getVLSBinaryAccess().getAmpersandKeyword_1_1_1());
9414 match(input,57,FOLLOW_2);
9415 after(grammarAccess.getVLSBinaryAccess().getAmpersandKeyword_1_1_1());
9416
9417 }
9418
9419
9420 }
9421
9422 }
9423 catch (RecognitionException re) {
9424 reportError(re);
9425 recover(input,re);
9426 }
9427 finally {
9428
9429 restoreStackSize(stackSize);
9430
9431 }
9432 return ;
9433 }
9434 // $ANTLR end "rule__VLSBinary__Group_1_1__1__Impl"
9435
9436
9437 // $ANTLR start "rule__VLSBinary__Group_1_1__2"
9438 // InternalVampireLanguage.g:2944:1: rule__VLSBinary__Group_1_1__2 : rule__VLSBinary__Group_1_1__2__Impl ;
9439 public final void rule__VLSBinary__Group_1_1__2() throws RecognitionException {
9440
9441 int stackSize = keepStackSize();
9442
9443 try {
9444 // InternalVampireLanguage.g:2948:1: ( rule__VLSBinary__Group_1_1__2__Impl )
9445 // InternalVampireLanguage.g:2949:2: rule__VLSBinary__Group_1_1__2__Impl
9446 {
9447 pushFollow(FOLLOW_2);
9448 rule__VLSBinary__Group_1_1__2__Impl();
9449
9450 state._fsp--;
9451
9452
9453 }
9454
9455 }
9456 catch (RecognitionException re) {
9457 reportError(re);
9458 recover(input,re);
9459 }
9460 finally {
9461
9462 restoreStackSize(stackSize);
9463
9464 }
9465 return ;
9466 }
9467 // $ANTLR end "rule__VLSBinary__Group_1_1__2"
9468
9469
9470 // $ANTLR start "rule__VLSBinary__Group_1_1__2__Impl"
9471 // InternalVampireLanguage.g:2955:1: rule__VLSBinary__Group_1_1__2__Impl : ( ( rule__VLSBinary__RightAssignment_1_1_2 ) ) ;
9472 public final void rule__VLSBinary__Group_1_1__2__Impl() throws RecognitionException {
9473
9474 int stackSize = keepStackSize();
9475
9476 try {
9477 // InternalVampireLanguage.g:2959:1: ( ( ( rule__VLSBinary__RightAssignment_1_1_2 ) ) )
9478 // InternalVampireLanguage.g:2960:1: ( ( rule__VLSBinary__RightAssignment_1_1_2 ) )
9479 {
9480 // InternalVampireLanguage.g:2960:1: ( ( rule__VLSBinary__RightAssignment_1_1_2 ) )
9481 // InternalVampireLanguage.g:2961:2: ( rule__VLSBinary__RightAssignment_1_1_2 )
9482 {
9483 before(grammarAccess.getVLSBinaryAccess().getRightAssignment_1_1_2());
9484 // InternalVampireLanguage.g:2962:2: ( rule__VLSBinary__RightAssignment_1_1_2 )
9485 // InternalVampireLanguage.g:2962:3: rule__VLSBinary__RightAssignment_1_1_2
9486 {
9487 pushFollow(FOLLOW_2);
9488 rule__VLSBinary__RightAssignment_1_1_2();
9489
9490 state._fsp--;
9491
9492
9493 }
9494
9495 after(grammarAccess.getVLSBinaryAccess().getRightAssignment_1_1_2());
9496
9497 }
9498
9499
9500 }
9501
9502 }
9503 catch (RecognitionException re) {
9504 reportError(re);
9505 recover(input,re);
9506 }
9507 finally {
9508
9509 restoreStackSize(stackSize);
9510
9511 }
9512 return ;
9513 }
9514 // $ANTLR end "rule__VLSBinary__Group_1_1__2__Impl"
9515
9516
9517 // $ANTLR start "rule__VLSBinary__Group_1_2__0"
9518 // InternalVampireLanguage.g:2971:1: rule__VLSBinary__Group_1_2__0 : rule__VLSBinary__Group_1_2__0__Impl rule__VLSBinary__Group_1_2__1 ;
9519 public final void rule__VLSBinary__Group_1_2__0() throws RecognitionException {
9520
9521 int stackSize = keepStackSize();
9522
9523 try {
9524 // InternalVampireLanguage.g:2975:1: ( rule__VLSBinary__Group_1_2__0__Impl rule__VLSBinary__Group_1_2__1 )
9525 // InternalVampireLanguage.g:2976:2: rule__VLSBinary__Group_1_2__0__Impl rule__VLSBinary__Group_1_2__1
9526 {
9527 pushFollow(FOLLOW_28);
9528 rule__VLSBinary__Group_1_2__0__Impl();
9529
9530 state._fsp--;
9531
9532 pushFollow(FOLLOW_2);
9533 rule__VLSBinary__Group_1_2__1();
9534
9535 state._fsp--;
9536
9537
9538 }
9539
9540 }
9541 catch (RecognitionException re) {
9542 reportError(re);
9543 recover(input,re);
9544 }
9545 finally {
9546
9547 restoreStackSize(stackSize);
9548
9549 }
9550 return ;
9551 }
9552 // $ANTLR end "rule__VLSBinary__Group_1_2__0"
9553
9554
9555 // $ANTLR start "rule__VLSBinary__Group_1_2__0__Impl"
9556 // InternalVampireLanguage.g:2983:1: rule__VLSBinary__Group_1_2__0__Impl : ( () ) ;
9557 public final void rule__VLSBinary__Group_1_2__0__Impl() throws RecognitionException {
9558
9559 int stackSize = keepStackSize();
9560
9561 try {
9562 // InternalVampireLanguage.g:2987:1: ( ( () ) )
9563 // InternalVampireLanguage.g:2988:1: ( () )
9564 {
9565 // InternalVampireLanguage.g:2988:1: ( () )
9566 // InternalVampireLanguage.g:2989:2: ()
9567 {
9568 before(grammarAccess.getVLSBinaryAccess().getVLSOrLeftAction_1_2_0());
9569 // InternalVampireLanguage.g:2990:2: ()
9570 // InternalVampireLanguage.g:2990:3:
9571 {
9572 }
9573
9574 after(grammarAccess.getVLSBinaryAccess().getVLSOrLeftAction_1_2_0());
9575
9576 }
9577
9578
9579 }
9580
9581 }
9582 finally {
9583
9584 restoreStackSize(stackSize);
9585
9586 }
9587 return ;
9588 }
9589 // $ANTLR end "rule__VLSBinary__Group_1_2__0__Impl"
9590
9591
9592 // $ANTLR start "rule__VLSBinary__Group_1_2__1"
9593 // InternalVampireLanguage.g:2998:1: rule__VLSBinary__Group_1_2__1 : rule__VLSBinary__Group_1_2__1__Impl rule__VLSBinary__Group_1_2__2 ;
9594 public final void rule__VLSBinary__Group_1_2__1() throws RecognitionException {
9595
9596 int stackSize = keepStackSize();
9597
9598 try {
9599 // InternalVampireLanguage.g:3002:1: ( rule__VLSBinary__Group_1_2__1__Impl rule__VLSBinary__Group_1_2__2 )
9600 // InternalVampireLanguage.g:3003:2: rule__VLSBinary__Group_1_2__1__Impl rule__VLSBinary__Group_1_2__2
9601 {
9602 pushFollow(FOLLOW_15);
9603 rule__VLSBinary__Group_1_2__1__Impl();
9604
9605 state._fsp--;
9606
9607 pushFollow(FOLLOW_2);
9608 rule__VLSBinary__Group_1_2__2();
9609
9610 state._fsp--;
9611
9612
9613 }
9614
9615 }
9616 catch (RecognitionException re) {
9617 reportError(re);
9618 recover(input,re);
9619 }
9620 finally {
9621
9622 restoreStackSize(stackSize);
9623
9624 }
9625 return ;
9626 }
9627 // $ANTLR end "rule__VLSBinary__Group_1_2__1"
9628
9629
9630 // $ANTLR start "rule__VLSBinary__Group_1_2__1__Impl"
9631 // InternalVampireLanguage.g:3010:1: rule__VLSBinary__Group_1_2__1__Impl : ( '|' ) ;
9632 public final void rule__VLSBinary__Group_1_2__1__Impl() throws RecognitionException {
9633
9634 int stackSize = keepStackSize();
9635
9636 try {
9637 // InternalVampireLanguage.g:3014:1: ( ( '|' ) )
9638 // InternalVampireLanguage.g:3015:1: ( '|' )
9639 {
9640 // InternalVampireLanguage.g:3015:1: ( '|' )
9641 // InternalVampireLanguage.g:3016:2: '|'
9642 {
9643 before(grammarAccess.getVLSBinaryAccess().getVerticalLineKeyword_1_2_1());
9644 match(input,58,FOLLOW_2);
9645 after(grammarAccess.getVLSBinaryAccess().getVerticalLineKeyword_1_2_1());
9646
9647 }
9648
9649
9650 }
9651
9652 }
9653 catch (RecognitionException re) {
9654 reportError(re);
9655 recover(input,re);
9656 }
9657 finally {
9658
9659 restoreStackSize(stackSize);
9660
9661 }
9662 return ;
9663 }
9664 // $ANTLR end "rule__VLSBinary__Group_1_2__1__Impl"
9665
9666
9667 // $ANTLR start "rule__VLSBinary__Group_1_2__2"
9668 // InternalVampireLanguage.g:3025:1: rule__VLSBinary__Group_1_2__2 : rule__VLSBinary__Group_1_2__2__Impl ;
9669 public final void rule__VLSBinary__Group_1_2__2() throws RecognitionException {
9670
9671 int stackSize = keepStackSize();
9672
9673 try {
9674 // InternalVampireLanguage.g:3029:1: ( rule__VLSBinary__Group_1_2__2__Impl )
9675 // InternalVampireLanguage.g:3030:2: rule__VLSBinary__Group_1_2__2__Impl
9676 {
9677 pushFollow(FOLLOW_2);
9678 rule__VLSBinary__Group_1_2__2__Impl();
9679
9680 state._fsp--;
9681
9682
9683 }
9684
9685 }
9686 catch (RecognitionException re) {
9687 reportError(re);
9688 recover(input,re);
9689 }
9690 finally {
9691
9692 restoreStackSize(stackSize);
9693
9694 }
9695 return ;
9696 }
9697 // $ANTLR end "rule__VLSBinary__Group_1_2__2"
9698
9699
9700 // $ANTLR start "rule__VLSBinary__Group_1_2__2__Impl"
9701 // InternalVampireLanguage.g:3036:1: rule__VLSBinary__Group_1_2__2__Impl : ( ( rule__VLSBinary__RightAssignment_1_2_2 ) ) ;
9702 public final void rule__VLSBinary__Group_1_2__2__Impl() throws RecognitionException {
9703
9704 int stackSize = keepStackSize();
9705
9706 try {
9707 // InternalVampireLanguage.g:3040:1: ( ( ( rule__VLSBinary__RightAssignment_1_2_2 ) ) )
9708 // InternalVampireLanguage.g:3041:1: ( ( rule__VLSBinary__RightAssignment_1_2_2 ) )
9709 {
9710 // InternalVampireLanguage.g:3041:1: ( ( rule__VLSBinary__RightAssignment_1_2_2 ) )
9711 // InternalVampireLanguage.g:3042:2: ( rule__VLSBinary__RightAssignment_1_2_2 )
9712 {
9713 before(grammarAccess.getVLSBinaryAccess().getRightAssignment_1_2_2());
9714 // InternalVampireLanguage.g:3043:2: ( rule__VLSBinary__RightAssignment_1_2_2 )
9715 // InternalVampireLanguage.g:3043:3: rule__VLSBinary__RightAssignment_1_2_2
9716 {
9717 pushFollow(FOLLOW_2);
9718 rule__VLSBinary__RightAssignment_1_2_2();
9719
9720 state._fsp--;
9721
9722
9723 }
9724
9725 after(grammarAccess.getVLSBinaryAccess().getRightAssignment_1_2_2());
9726
9727 }
9728
9729
9730 }
9731
9732 }
9733 catch (RecognitionException re) {
9734 reportError(re);
9735 recover(input,re);
9736 }
9737 finally {
9738
9739 restoreStackSize(stackSize);
9740
9741 }
9742 return ;
9743 }
9744 // $ANTLR end "rule__VLSBinary__Group_1_2__2__Impl"
9745
9746
9747 // $ANTLR start "rule__VLSUnitaryFormula__Group_4__0"
9748 // InternalVampireLanguage.g:3052:1: rule__VLSUnitaryFormula__Group_4__0 : rule__VLSUnitaryFormula__Group_4__0__Impl rule__VLSUnitaryFormula__Group_4__1 ;
9749 public final void rule__VLSUnitaryFormula__Group_4__0() throws RecognitionException {
9750
9751 int stackSize = keepStackSize();
9752
9753 try {
9754 // InternalVampireLanguage.g:3056:1: ( rule__VLSUnitaryFormula__Group_4__0__Impl rule__VLSUnitaryFormula__Group_4__1 )
9755 // InternalVampireLanguage.g:3057:2: rule__VLSUnitaryFormula__Group_4__0__Impl rule__VLSUnitaryFormula__Group_4__1
9756 {
9757 pushFollow(FOLLOW_15);
9758 rule__VLSUnitaryFormula__Group_4__0__Impl();
9759
9760 state._fsp--;
9761
9762 pushFollow(FOLLOW_2);
9763 rule__VLSUnitaryFormula__Group_4__1();
9764
9765 state._fsp--;
9766
9767
9768 }
9769
9770 }
9771 catch (RecognitionException re) {
9772 reportError(re);
9773 recover(input,re);
9774 }
9775 finally {
9776
9777 restoreStackSize(stackSize);
9778
9779 }
9780 return ;
9781 }
9782 // $ANTLR end "rule__VLSUnitaryFormula__Group_4__0"
9783
9784
9785 // $ANTLR start "rule__VLSUnitaryFormula__Group_4__0__Impl"
9786 // InternalVampireLanguage.g:3064:1: rule__VLSUnitaryFormula__Group_4__0__Impl : ( '(' ) ;
9787 public final void rule__VLSUnitaryFormula__Group_4__0__Impl() throws RecognitionException {
9788
9789 int stackSize = keepStackSize();
9790
9791 try {
9792 // InternalVampireLanguage.g:3068:1: ( ( '(' ) )
9793 // InternalVampireLanguage.g:3069:1: ( '(' )
9794 {
9795 // InternalVampireLanguage.g:3069:1: ( '(' )
9796 // InternalVampireLanguage.g:3070:2: '('
9797 {
9798 before(grammarAccess.getVLSUnitaryFormulaAccess().getLeftParenthesisKeyword_4_0());
9799 match(input,47,FOLLOW_2);
9800 after(grammarAccess.getVLSUnitaryFormulaAccess().getLeftParenthesisKeyword_4_0());
9801
9802 }
9803
9804
9805 }
9806
9807 }
9808 catch (RecognitionException re) {
9809 reportError(re);
9810 recover(input,re);
9811 }
9812 finally {
9813
9814 restoreStackSize(stackSize);
9815
9816 }
9817 return ;
9818 }
9819 // $ANTLR end "rule__VLSUnitaryFormula__Group_4__0__Impl"
9820
9821
9822 // $ANTLR start "rule__VLSUnitaryFormula__Group_4__1"
9823 // InternalVampireLanguage.g:3079:1: rule__VLSUnitaryFormula__Group_4__1 : rule__VLSUnitaryFormula__Group_4__1__Impl rule__VLSUnitaryFormula__Group_4__2 ;
9824 public final void rule__VLSUnitaryFormula__Group_4__1() throws RecognitionException {
9825
9826 int stackSize = keepStackSize();
9827
9828 try {
9829 // InternalVampireLanguage.g:3083:1: ( rule__VLSUnitaryFormula__Group_4__1__Impl rule__VLSUnitaryFormula__Group_4__2 )
9830 // InternalVampireLanguage.g:3084:2: rule__VLSUnitaryFormula__Group_4__1__Impl rule__VLSUnitaryFormula__Group_4__2
9831 {
9832 pushFollow(FOLLOW_19);
9833 rule__VLSUnitaryFormula__Group_4__1__Impl();
9834
9835 state._fsp--;
9836
9837 pushFollow(FOLLOW_2);
9838 rule__VLSUnitaryFormula__Group_4__2();
9839
9840 state._fsp--;
9841
9842
9843 }
9844
9845 }
9846 catch (RecognitionException re) {
9847 reportError(re);
9848 recover(input,re);
9849 }
9850 finally {
9851
9852 restoreStackSize(stackSize);
9853
9854 }
9855 return ;
9856 }
9857 // $ANTLR end "rule__VLSUnitaryFormula__Group_4__1"
9858
9859
9860 // $ANTLR start "rule__VLSUnitaryFormula__Group_4__1__Impl"
9861 // InternalVampireLanguage.g:3091:1: rule__VLSUnitaryFormula__Group_4__1__Impl : ( ruleVLSTerm ) ;
9862 public final void rule__VLSUnitaryFormula__Group_4__1__Impl() throws RecognitionException {
9863
9864 int stackSize = keepStackSize();
9865
9866 try {
9867 // InternalVampireLanguage.g:3095:1: ( ( ruleVLSTerm ) )
9868 // InternalVampireLanguage.g:3096:1: ( ruleVLSTerm )
9869 {
9870 // InternalVampireLanguage.g:3096:1: ( ruleVLSTerm )
9871 // InternalVampireLanguage.g:3097:2: ruleVLSTerm
9872 {
9873 before(grammarAccess.getVLSUnitaryFormulaAccess().getVLSTermParserRuleCall_4_1());
9874 pushFollow(FOLLOW_2);
9875 ruleVLSTerm();
9876
9877 state._fsp--;
9878
9879 after(grammarAccess.getVLSUnitaryFormulaAccess().getVLSTermParserRuleCall_4_1());
9880
9881 }
9882
9883
9884 }
9885
9886 }
9887 catch (RecognitionException re) {
9888 reportError(re);
9889 recover(input,re);
9890 }
9891 finally {
9892
9893 restoreStackSize(stackSize);
9894
9895 }
9896 return ;
9897 }
9898 // $ANTLR end "rule__VLSUnitaryFormula__Group_4__1__Impl"
9899
9900
9901 // $ANTLR start "rule__VLSUnitaryFormula__Group_4__2"
9902 // InternalVampireLanguage.g:3106:1: rule__VLSUnitaryFormula__Group_4__2 : rule__VLSUnitaryFormula__Group_4__2__Impl ;
9903 public final void rule__VLSUnitaryFormula__Group_4__2() throws RecognitionException {
9904
9905 int stackSize = keepStackSize();
9906
9907 try {
9908 // InternalVampireLanguage.g:3110:1: ( rule__VLSUnitaryFormula__Group_4__2__Impl )
9909 // InternalVampireLanguage.g:3111:2: rule__VLSUnitaryFormula__Group_4__2__Impl
9910 {
9911 pushFollow(FOLLOW_2);
9912 rule__VLSUnitaryFormula__Group_4__2__Impl();
9913
9914 state._fsp--;
9915
9916
9917 }
9918
9919 }
9920 catch (RecognitionException re) {
9921 reportError(re);
9922 recover(input,re);
9923 }
9924 finally {
9925
9926 restoreStackSize(stackSize);
9927
9928 }
9929 return ;
9930 }
9931 // $ANTLR end "rule__VLSUnitaryFormula__Group_4__2"
9932
9933
9934 // $ANTLR start "rule__VLSUnitaryFormula__Group_4__2__Impl"
9935 // InternalVampireLanguage.g:3117:1: rule__VLSUnitaryFormula__Group_4__2__Impl : ( ')' ) ;
9936 public final void rule__VLSUnitaryFormula__Group_4__2__Impl() throws RecognitionException {
9937
9938 int stackSize = keepStackSize();
9939
9940 try {
9941 // InternalVampireLanguage.g:3121:1: ( ( ')' ) )
9942 // InternalVampireLanguage.g:3122:1: ( ')' )
9943 {
9944 // InternalVampireLanguage.g:3122:1: ( ')' )
9945 // InternalVampireLanguage.g:3123:2: ')'
9946 {
9947 before(grammarAccess.getVLSUnitaryFormulaAccess().getRightParenthesisKeyword_4_2());
9948 match(input,48,FOLLOW_2);
9949 after(grammarAccess.getVLSUnitaryFormulaAccess().getRightParenthesisKeyword_4_2());
9950
9951 }
9952
9953
9954 }
9955
9956 }
9957 catch (RecognitionException re) {
9958 reportError(re);
9959 recover(input,re);
9960 }
9961 finally {
9962
9963 restoreStackSize(stackSize);
9964
9965 }
9966 return ;
9967 }
9968 // $ANTLR end "rule__VLSUnitaryFormula__Group_4__2__Impl"
9969
9970
9971 // $ANTLR start "rule__VLSUniversalQuantifier__Group__0"
9972 // InternalVampireLanguage.g:3133:1: rule__VLSUniversalQuantifier__Group__0 : rule__VLSUniversalQuantifier__Group__0__Impl rule__VLSUniversalQuantifier__Group__1 ;
9973 public final void rule__VLSUniversalQuantifier__Group__0() throws RecognitionException {
9974
9975 int stackSize = keepStackSize();
9976
9977 try {
9978 // InternalVampireLanguage.g:3137:1: ( rule__VLSUniversalQuantifier__Group__0__Impl rule__VLSUniversalQuantifier__Group__1 )
9979 // InternalVampireLanguage.g:3138:2: rule__VLSUniversalQuantifier__Group__0__Impl rule__VLSUniversalQuantifier__Group__1
9980 {
9981 pushFollow(FOLLOW_29);
9982 rule__VLSUniversalQuantifier__Group__0__Impl();
9983
9984 state._fsp--;
9985
9986 pushFollow(FOLLOW_2);
9987 rule__VLSUniversalQuantifier__Group__1();
9988
9989 state._fsp--;
9990
9991
9992 }
9993
9994 }
9995 catch (RecognitionException re) {
9996 reportError(re);
9997 recover(input,re);
9998 }
9999 finally {
10000
10001 restoreStackSize(stackSize);
10002
10003 }
10004 return ;
10005 }
10006 // $ANTLR end "rule__VLSUniversalQuantifier__Group__0"
10007
10008
10009 // $ANTLR start "rule__VLSUniversalQuantifier__Group__0__Impl"
10010 // InternalVampireLanguage.g:3145:1: rule__VLSUniversalQuantifier__Group__0__Impl : ( () ) ;
10011 public final void rule__VLSUniversalQuantifier__Group__0__Impl() throws RecognitionException {
10012
10013 int stackSize = keepStackSize();
10014
10015 try {
10016 // InternalVampireLanguage.g:3149:1: ( ( () ) )
10017 // InternalVampireLanguage.g:3150:1: ( () )
10018 {
10019 // InternalVampireLanguage.g:3150:1: ( () )
10020 // InternalVampireLanguage.g:3151:2: ()
10021 {
10022 before(grammarAccess.getVLSUniversalQuantifierAccess().getVLSUniversalQuantifierAction_0());
10023 // InternalVampireLanguage.g:3152:2: ()
10024 // InternalVampireLanguage.g:3152:3:
10025 {
10026 }
10027
10028 after(grammarAccess.getVLSUniversalQuantifierAccess().getVLSUniversalQuantifierAction_0());
10029
10030 }
10031
10032
10033 }
10034
10035 }
10036 finally {
10037
10038 restoreStackSize(stackSize);
10039
10040 }
10041 return ;
10042 }
10043 // $ANTLR end "rule__VLSUniversalQuantifier__Group__0__Impl"
10044
10045
10046 // $ANTLR start "rule__VLSUniversalQuantifier__Group__1"
10047 // InternalVampireLanguage.g:3160:1: rule__VLSUniversalQuantifier__Group__1 : rule__VLSUniversalQuantifier__Group__1__Impl rule__VLSUniversalQuantifier__Group__2 ;
10048 public final void rule__VLSUniversalQuantifier__Group__1() throws RecognitionException {
10049
10050 int stackSize = keepStackSize();
10051
10052 try {
10053 // InternalVampireLanguage.g:3164:1: ( rule__VLSUniversalQuantifier__Group__1__Impl rule__VLSUniversalQuantifier__Group__2 )
10054 // InternalVampireLanguage.g:3165:2: rule__VLSUniversalQuantifier__Group__1__Impl rule__VLSUniversalQuantifier__Group__2
10055 {
10056 pushFollow(FOLLOW_15);
10057 rule__VLSUniversalQuantifier__Group__1__Impl();
10058
10059 state._fsp--;
10060
10061 pushFollow(FOLLOW_2);
10062 rule__VLSUniversalQuantifier__Group__2();
10063
10064 state._fsp--;
10065
10066
10067 }
10068
10069 }
10070 catch (RecognitionException re) {
10071 reportError(re);
10072 recover(input,re);
10073 }
10074 finally {
10075
10076 restoreStackSize(stackSize);
10077
10078 }
10079 return ;
10080 }
10081 // $ANTLR end "rule__VLSUniversalQuantifier__Group__1"
10082
10083
10084 // $ANTLR start "rule__VLSUniversalQuantifier__Group__1__Impl"
10085 // InternalVampireLanguage.g:3172:1: rule__VLSUniversalQuantifier__Group__1__Impl : ( ( rule__VLSUniversalQuantifier__Group_1__0 ) ) ;
10086 public final void rule__VLSUniversalQuantifier__Group__1__Impl() throws RecognitionException {
10087
10088 int stackSize = keepStackSize();
10089
10090 try {
10091 // InternalVampireLanguage.g:3176:1: ( ( ( rule__VLSUniversalQuantifier__Group_1__0 ) ) )
10092 // InternalVampireLanguage.g:3177:1: ( ( rule__VLSUniversalQuantifier__Group_1__0 ) )
10093 {
10094 // InternalVampireLanguage.g:3177:1: ( ( rule__VLSUniversalQuantifier__Group_1__0 ) )
10095 // InternalVampireLanguage.g:3178:2: ( rule__VLSUniversalQuantifier__Group_1__0 )
10096 {
10097 before(grammarAccess.getVLSUniversalQuantifierAccess().getGroup_1());
10098 // InternalVampireLanguage.g:3179:2: ( rule__VLSUniversalQuantifier__Group_1__0 )
10099 // InternalVampireLanguage.g:3179:3: rule__VLSUniversalQuantifier__Group_1__0
10100 {
10101 pushFollow(FOLLOW_2);
10102 rule__VLSUniversalQuantifier__Group_1__0();
10103
10104 state._fsp--;
10105
10106
10107 }
10108
10109 after(grammarAccess.getVLSUniversalQuantifierAccess().getGroup_1());
10110
10111 }
10112
10113
10114 }
10115
10116 }
10117 catch (RecognitionException re) {
10118 reportError(re);
10119 recover(input,re);
10120 }
10121 finally {
10122
10123 restoreStackSize(stackSize);
10124
10125 }
10126 return ;
10127 }
10128 // $ANTLR end "rule__VLSUniversalQuantifier__Group__1__Impl"
10129
10130
10131 // $ANTLR start "rule__VLSUniversalQuantifier__Group__2"
10132 // InternalVampireLanguage.g:3187:1: rule__VLSUniversalQuantifier__Group__2 : rule__VLSUniversalQuantifier__Group__2__Impl ;
10133 public final void rule__VLSUniversalQuantifier__Group__2() throws RecognitionException {
10134
10135 int stackSize = keepStackSize();
10136
10137 try {
10138 // InternalVampireLanguage.g:3191:1: ( rule__VLSUniversalQuantifier__Group__2__Impl )
10139 // InternalVampireLanguage.g:3192:2: rule__VLSUniversalQuantifier__Group__2__Impl
10140 {
10141 pushFollow(FOLLOW_2);
10142 rule__VLSUniversalQuantifier__Group__2__Impl();
10143
10144 state._fsp--;
10145
10146
10147 }
10148
10149 }
10150 catch (RecognitionException re) {
10151 reportError(re);
10152 recover(input,re);
10153 }
10154 finally {
10155
10156 restoreStackSize(stackSize);
10157
10158 }
10159 return ;
10160 }
10161 // $ANTLR end "rule__VLSUniversalQuantifier__Group__2"
10162
10163
10164 // $ANTLR start "rule__VLSUniversalQuantifier__Group__2__Impl"
10165 // InternalVampireLanguage.g:3198:1: rule__VLSUniversalQuantifier__Group__2__Impl : ( ( rule__VLSUniversalQuantifier__OperandAssignment_2 ) ) ;
10166 public final void rule__VLSUniversalQuantifier__Group__2__Impl() throws RecognitionException {
10167
10168 int stackSize = keepStackSize();
10169
10170 try {
10171 // InternalVampireLanguage.g:3202:1: ( ( ( rule__VLSUniversalQuantifier__OperandAssignment_2 ) ) )
10172 // InternalVampireLanguage.g:3203:1: ( ( rule__VLSUniversalQuantifier__OperandAssignment_2 ) )
10173 {
10174 // InternalVampireLanguage.g:3203:1: ( ( rule__VLSUniversalQuantifier__OperandAssignment_2 ) )
10175 // InternalVampireLanguage.g:3204:2: ( rule__VLSUniversalQuantifier__OperandAssignment_2 )
10176 {
10177 before(grammarAccess.getVLSUniversalQuantifierAccess().getOperandAssignment_2());
10178 // InternalVampireLanguage.g:3205:2: ( rule__VLSUniversalQuantifier__OperandAssignment_2 )
10179 // InternalVampireLanguage.g:3205:3: rule__VLSUniversalQuantifier__OperandAssignment_2
10180 {
10181 pushFollow(FOLLOW_2);
10182 rule__VLSUniversalQuantifier__OperandAssignment_2();
10183
10184 state._fsp--;
10185
10186
10187 }
10188
10189 after(grammarAccess.getVLSUniversalQuantifierAccess().getOperandAssignment_2());
10190
10191 }
10192
10193
10194 }
10195
10196 }
10197 catch (RecognitionException re) {
10198 reportError(re);
10199 recover(input,re);
10200 }
10201 finally {
10202
10203 restoreStackSize(stackSize);
10204
10205 }
10206 return ;
10207 }
10208 // $ANTLR end "rule__VLSUniversalQuantifier__Group__2__Impl"
10209
10210
10211 // $ANTLR start "rule__VLSUniversalQuantifier__Group_1__0"
10212 // InternalVampireLanguage.g:3214:1: rule__VLSUniversalQuantifier__Group_1__0 : rule__VLSUniversalQuantifier__Group_1__0__Impl rule__VLSUniversalQuantifier__Group_1__1 ;
10213 public final void rule__VLSUniversalQuantifier__Group_1__0() throws RecognitionException {
10214
10215 int stackSize = keepStackSize();
10216
10217 try {
10218 // InternalVampireLanguage.g:3218:1: ( rule__VLSUniversalQuantifier__Group_1__0__Impl rule__VLSUniversalQuantifier__Group_1__1 )
10219 // InternalVampireLanguage.g:3219:2: rule__VLSUniversalQuantifier__Group_1__0__Impl rule__VLSUniversalQuantifier__Group_1__1
10220 {
10221 pushFollow(FOLLOW_30);
10222 rule__VLSUniversalQuantifier__Group_1__0__Impl();
10223
10224 state._fsp--;
10225
10226 pushFollow(FOLLOW_2);
10227 rule__VLSUniversalQuantifier__Group_1__1();
10228
10229 state._fsp--;
10230
10231
10232 }
10233
10234 }
10235 catch (RecognitionException re) {
10236 reportError(re);
10237 recover(input,re);
10238 }
10239 finally {
10240
10241 restoreStackSize(stackSize);
10242
10243 }
10244 return ;
10245 }
10246 // $ANTLR end "rule__VLSUniversalQuantifier__Group_1__0"
10247
10248
10249 // $ANTLR start "rule__VLSUniversalQuantifier__Group_1__0__Impl"
10250 // InternalVampireLanguage.g:3226:1: rule__VLSUniversalQuantifier__Group_1__0__Impl : ( '!' ) ;
10251 public final void rule__VLSUniversalQuantifier__Group_1__0__Impl() throws RecognitionException {
10252
10253 int stackSize = keepStackSize();
10254
10255 try {
10256 // InternalVampireLanguage.g:3230:1: ( ( '!' ) )
10257 // InternalVampireLanguage.g:3231:1: ( '!' )
10258 {
10259 // InternalVampireLanguage.g:3231:1: ( '!' )
10260 // InternalVampireLanguage.g:3232:2: '!'
10261 {
10262 before(grammarAccess.getVLSUniversalQuantifierAccess().getExclamationMarkKeyword_1_0());
10263 match(input,59,FOLLOW_2);
10264 after(grammarAccess.getVLSUniversalQuantifierAccess().getExclamationMarkKeyword_1_0());
10265
10266 }
10267
10268
10269 }
10270
10271 }
10272 catch (RecognitionException re) {
10273 reportError(re);
10274 recover(input,re);
10275 }
10276 finally {
10277
10278 restoreStackSize(stackSize);
10279
10280 }
10281 return ;
10282 }
10283 // $ANTLR end "rule__VLSUniversalQuantifier__Group_1__0__Impl"
10284
10285
10286 // $ANTLR start "rule__VLSUniversalQuantifier__Group_1__1"
10287 // InternalVampireLanguage.g:3241:1: rule__VLSUniversalQuantifier__Group_1__1 : rule__VLSUniversalQuantifier__Group_1__1__Impl rule__VLSUniversalQuantifier__Group_1__2 ;
10288 public final void rule__VLSUniversalQuantifier__Group_1__1() throws RecognitionException {
10289
10290 int stackSize = keepStackSize();
10291
10292 try {
10293 // InternalVampireLanguage.g:3245:1: ( rule__VLSUniversalQuantifier__Group_1__1__Impl rule__VLSUniversalQuantifier__Group_1__2 )
10294 // InternalVampireLanguage.g:3246:2: rule__VLSUniversalQuantifier__Group_1__1__Impl rule__VLSUniversalQuantifier__Group_1__2
10295 {
10296 pushFollow(FOLLOW_31);
10297 rule__VLSUniversalQuantifier__Group_1__1__Impl();
10298
10299 state._fsp--;
10300
10301 pushFollow(FOLLOW_2);
10302 rule__VLSUniversalQuantifier__Group_1__2();
10303
10304 state._fsp--;
10305
10306
10307 }
10308
10309 }
10310 catch (RecognitionException re) {
10311 reportError(re);
10312 recover(input,re);
10313 }
10314 finally {
10315
10316 restoreStackSize(stackSize);
10317
10318 }
10319 return ;
10320 }
10321 // $ANTLR end "rule__VLSUniversalQuantifier__Group_1__1"
10322
10323
10324 // $ANTLR start "rule__VLSUniversalQuantifier__Group_1__1__Impl"
10325 // InternalVampireLanguage.g:3253:1: rule__VLSUniversalQuantifier__Group_1__1__Impl : ( '[' ) ;
10326 public final void rule__VLSUniversalQuantifier__Group_1__1__Impl() throws RecognitionException {
10327
10328 int stackSize = keepStackSize();
10329
10330 try {
10331 // InternalVampireLanguage.g:3257:1: ( ( '[' ) )
10332 // InternalVampireLanguage.g:3258:1: ( '[' )
10333 {
10334 // InternalVampireLanguage.g:3258:1: ( '[' )
10335 // InternalVampireLanguage.g:3259:2: '['
10336 {
10337 before(grammarAccess.getVLSUniversalQuantifierAccess().getLeftSquareBracketKeyword_1_1());
10338 match(input,50,FOLLOW_2);
10339 after(grammarAccess.getVLSUniversalQuantifierAccess().getLeftSquareBracketKeyword_1_1());
10340
10341 }
10342
10343
10344 }
10345
10346 }
10347 catch (RecognitionException re) {
10348 reportError(re);
10349 recover(input,re);
10350 }
10351 finally {
10352
10353 restoreStackSize(stackSize);
10354
10355 }
10356 return ;
10357 }
10358 // $ANTLR end "rule__VLSUniversalQuantifier__Group_1__1__Impl"
10359
10360
10361 // $ANTLR start "rule__VLSUniversalQuantifier__Group_1__2"
10362 // InternalVampireLanguage.g:3268:1: rule__VLSUniversalQuantifier__Group_1__2 : rule__VLSUniversalQuantifier__Group_1__2__Impl rule__VLSUniversalQuantifier__Group_1__3 ;
10363 public final void rule__VLSUniversalQuantifier__Group_1__2() throws RecognitionException {
10364
10365 int stackSize = keepStackSize();
10366
10367 try {
10368 // InternalVampireLanguage.g:3272:1: ( rule__VLSUniversalQuantifier__Group_1__2__Impl rule__VLSUniversalQuantifier__Group_1__3 )
10369 // InternalVampireLanguage.g:3273:2: rule__VLSUniversalQuantifier__Group_1__2__Impl rule__VLSUniversalQuantifier__Group_1__3
10370 {
10371 pushFollow(FOLLOW_9);
10372 rule__VLSUniversalQuantifier__Group_1__2__Impl();
10373
10374 state._fsp--;
10375
10376 pushFollow(FOLLOW_2);
10377 rule__VLSUniversalQuantifier__Group_1__3();
10378
10379 state._fsp--;
10380
10381
10382 }
10383
10384 }
10385 catch (RecognitionException re) {
10386 reportError(re);
10387 recover(input,re);
10388 }
10389 finally {
10390
10391 restoreStackSize(stackSize);
10392
10393 }
10394 return ;
10395 }
10396 // $ANTLR end "rule__VLSUniversalQuantifier__Group_1__2"
10397
10398
10399 // $ANTLR start "rule__VLSUniversalQuantifier__Group_1__2__Impl"
10400 // InternalVampireLanguage.g:3280:1: rule__VLSUniversalQuantifier__Group_1__2__Impl : ( ( rule__VLSUniversalQuantifier__VariablesAssignment_1_2 ) ) ;
10401 public final void rule__VLSUniversalQuantifier__Group_1__2__Impl() throws RecognitionException {
10402
10403 int stackSize = keepStackSize();
10404
10405 try {
10406 // InternalVampireLanguage.g:3284:1: ( ( ( rule__VLSUniversalQuantifier__VariablesAssignment_1_2 ) ) )
10407 // InternalVampireLanguage.g:3285:1: ( ( rule__VLSUniversalQuantifier__VariablesAssignment_1_2 ) )
10408 {
10409 // InternalVampireLanguage.g:3285:1: ( ( rule__VLSUniversalQuantifier__VariablesAssignment_1_2 ) )
10410 // InternalVampireLanguage.g:3286:2: ( rule__VLSUniversalQuantifier__VariablesAssignment_1_2 )
10411 {
10412 before(grammarAccess.getVLSUniversalQuantifierAccess().getVariablesAssignment_1_2());
10413 // InternalVampireLanguage.g:3287:2: ( rule__VLSUniversalQuantifier__VariablesAssignment_1_2 )
10414 // InternalVampireLanguage.g:3287:3: rule__VLSUniversalQuantifier__VariablesAssignment_1_2
10415 {
10416 pushFollow(FOLLOW_2);
10417 rule__VLSUniversalQuantifier__VariablesAssignment_1_2();
10418
10419 state._fsp--;
10420
10421
10422 }
10423
10424 after(grammarAccess.getVLSUniversalQuantifierAccess().getVariablesAssignment_1_2());
10425
10426 }
10427
10428
10429 }
10430
10431 }
10432 catch (RecognitionException re) {
10433 reportError(re);
10434 recover(input,re);
10435 }
10436 finally {
10437
10438 restoreStackSize(stackSize);
10439
10440 }
10441 return ;
10442 }
10443 // $ANTLR end "rule__VLSUniversalQuantifier__Group_1__2__Impl"
10444
10445
10446 // $ANTLR start "rule__VLSUniversalQuantifier__Group_1__3"
10447 // InternalVampireLanguage.g:3295:1: rule__VLSUniversalQuantifier__Group_1__3 : rule__VLSUniversalQuantifier__Group_1__3__Impl rule__VLSUniversalQuantifier__Group_1__4 ;
10448 public final void rule__VLSUniversalQuantifier__Group_1__3() throws RecognitionException {
10449
10450 int stackSize = keepStackSize();
10451
10452 try {
10453 // InternalVampireLanguage.g:3299:1: ( rule__VLSUniversalQuantifier__Group_1__3__Impl rule__VLSUniversalQuantifier__Group_1__4 )
10454 // InternalVampireLanguage.g:3300:2: rule__VLSUniversalQuantifier__Group_1__3__Impl rule__VLSUniversalQuantifier__Group_1__4
10455 {
10456 pushFollow(FOLLOW_9);
10457 rule__VLSUniversalQuantifier__Group_1__3__Impl();
10458
10459 state._fsp--;
10460
10461 pushFollow(FOLLOW_2);
10462 rule__VLSUniversalQuantifier__Group_1__4();
10463
10464 state._fsp--;
10465
10466
10467 }
10468
10469 }
10470 catch (RecognitionException re) {
10471 reportError(re);
10472 recover(input,re);
10473 }
10474 finally {
10475
10476 restoreStackSize(stackSize);
10477
10478 }
10479 return ;
10480 }
10481 // $ANTLR end "rule__VLSUniversalQuantifier__Group_1__3"
10482
10483
10484 // $ANTLR start "rule__VLSUniversalQuantifier__Group_1__3__Impl"
10485 // InternalVampireLanguage.g:3307:1: rule__VLSUniversalQuantifier__Group_1__3__Impl : ( ( rule__VLSUniversalQuantifier__Group_1_3__0 )* ) ;
10486 public final void rule__VLSUniversalQuantifier__Group_1__3__Impl() throws RecognitionException {
10487
10488 int stackSize = keepStackSize();
10489
10490 try {
10491 // InternalVampireLanguage.g:3311:1: ( ( ( rule__VLSUniversalQuantifier__Group_1_3__0 )* ) )
10492 // InternalVampireLanguage.g:3312:1: ( ( rule__VLSUniversalQuantifier__Group_1_3__0 )* )
10493 {
10494 // InternalVampireLanguage.g:3312:1: ( ( rule__VLSUniversalQuantifier__Group_1_3__0 )* )
10495 // InternalVampireLanguage.g:3313:2: ( rule__VLSUniversalQuantifier__Group_1_3__0 )*
10496 {
10497 before(grammarAccess.getVLSUniversalQuantifierAccess().getGroup_1_3());
10498 // InternalVampireLanguage.g:3314:2: ( rule__VLSUniversalQuantifier__Group_1_3__0 )*
10499 loop30:
10500 do {
10501 int alt30=2;
10502 int LA30_0 = input.LA(1);
10503
10504 if ( (LA30_0==45) ) {
10505 alt30=1;
10506 }
10507
10508
10509 switch (alt30) {
10510 case 1 :
10511 // InternalVampireLanguage.g:3314:3: rule__VLSUniversalQuantifier__Group_1_3__0
10512 {
10513 pushFollow(FOLLOW_10);
10514 rule__VLSUniversalQuantifier__Group_1_3__0();
10515
10516 state._fsp--;
10517
10518
10519 }
10520 break;
10521
10522 default :
10523 break loop30;
10524 }
10525 } while (true);
10526
10527 after(grammarAccess.getVLSUniversalQuantifierAccess().getGroup_1_3());
10528
10529 }
10530
10531
10532 }
10533
10534 }
10535 catch (RecognitionException re) {
10536 reportError(re);
10537 recover(input,re);
10538 }
10539 finally {
10540
10541 restoreStackSize(stackSize);
10542
10543 }
10544 return ;
10545 }
10546 // $ANTLR end "rule__VLSUniversalQuantifier__Group_1__3__Impl"
10547
10548
10549 // $ANTLR start "rule__VLSUniversalQuantifier__Group_1__4"
10550 // InternalVampireLanguage.g:3322:1: rule__VLSUniversalQuantifier__Group_1__4 : rule__VLSUniversalQuantifier__Group_1__4__Impl rule__VLSUniversalQuantifier__Group_1__5 ;
10551 public final void rule__VLSUniversalQuantifier__Group_1__4() throws RecognitionException {
10552
10553 int stackSize = keepStackSize();
10554
10555 try {
10556 // InternalVampireLanguage.g:3326:1: ( rule__VLSUniversalQuantifier__Group_1__4__Impl rule__VLSUniversalQuantifier__Group_1__5 )
10557 // InternalVampireLanguage.g:3327:2: rule__VLSUniversalQuantifier__Group_1__4__Impl rule__VLSUniversalQuantifier__Group_1__5
10558 {
10559 pushFollow(FOLLOW_32);
10560 rule__VLSUniversalQuantifier__Group_1__4__Impl();
10561
10562 state._fsp--;
10563
10564 pushFollow(FOLLOW_2);
10565 rule__VLSUniversalQuantifier__Group_1__5();
10566
10567 state._fsp--;
10568
10569
10570 }
10571
10572 }
10573 catch (RecognitionException re) {
10574 reportError(re);
10575 recover(input,re);
10576 }
10577 finally {
10578
10579 restoreStackSize(stackSize);
10580
10581 }
10582 return ;
10583 }
10584 // $ANTLR end "rule__VLSUniversalQuantifier__Group_1__4"
10585
10586
10587 // $ANTLR start "rule__VLSUniversalQuantifier__Group_1__4__Impl"
10588 // InternalVampireLanguage.g:3334:1: rule__VLSUniversalQuantifier__Group_1__4__Impl : ( ']' ) ;
10589 public final void rule__VLSUniversalQuantifier__Group_1__4__Impl() throws RecognitionException {
10590
10591 int stackSize = keepStackSize();
10592
10593 try {
10594 // InternalVampireLanguage.g:3338:1: ( ( ']' ) )
10595 // InternalVampireLanguage.g:3339:1: ( ']' )
10596 {
10597 // InternalVampireLanguage.g:3339:1: ( ']' )
10598 // InternalVampireLanguage.g:3340:2: ']'
10599 {
10600 before(grammarAccess.getVLSUniversalQuantifierAccess().getRightSquareBracketKeyword_1_4());
10601 match(input,44,FOLLOW_2);
10602 after(grammarAccess.getVLSUniversalQuantifierAccess().getRightSquareBracketKeyword_1_4());
10603
10604 }
10605
10606
10607 }
10608
10609 }
10610 catch (RecognitionException re) {
10611 reportError(re);
10612 recover(input,re);
10613 }
10614 finally {
10615
10616 restoreStackSize(stackSize);
10617
10618 }
10619 return ;
10620 }
10621 // $ANTLR end "rule__VLSUniversalQuantifier__Group_1__4__Impl"
10622
10623
10624 // $ANTLR start "rule__VLSUniversalQuantifier__Group_1__5"
10625 // InternalVampireLanguage.g:3349:1: rule__VLSUniversalQuantifier__Group_1__5 : rule__VLSUniversalQuantifier__Group_1__5__Impl ;
10626 public final void rule__VLSUniversalQuantifier__Group_1__5() throws RecognitionException {
10627
10628 int stackSize = keepStackSize();
10629
10630 try {
10631 // InternalVampireLanguage.g:3353:1: ( rule__VLSUniversalQuantifier__Group_1__5__Impl )
10632 // InternalVampireLanguage.g:3354:2: rule__VLSUniversalQuantifier__Group_1__5__Impl
10633 {
10634 pushFollow(FOLLOW_2);
10635 rule__VLSUniversalQuantifier__Group_1__5__Impl();
10636
10637 state._fsp--;
10638
10639
10640 }
10641
10642 }
10643 catch (RecognitionException re) {
10644 reportError(re);
10645 recover(input,re);
10646 }
10647 finally {
10648
10649 restoreStackSize(stackSize);
10650
10651 }
10652 return ;
10653 }
10654 // $ANTLR end "rule__VLSUniversalQuantifier__Group_1__5"
10655
10656
10657 // $ANTLR start "rule__VLSUniversalQuantifier__Group_1__5__Impl"
10658 // InternalVampireLanguage.g:3360:1: rule__VLSUniversalQuantifier__Group_1__5__Impl : ( ':' ) ;
10659 public final void rule__VLSUniversalQuantifier__Group_1__5__Impl() throws RecognitionException {
10660
10661 int stackSize = keepStackSize();
10662
10663 try {
10664 // InternalVampireLanguage.g:3364:1: ( ( ':' ) )
10665 // InternalVampireLanguage.g:3365:1: ( ':' )
10666 {
10667 // InternalVampireLanguage.g:3365:1: ( ':' )
10668 // InternalVampireLanguage.g:3366:2: ':'
10669 {
10670 before(grammarAccess.getVLSUniversalQuantifierAccess().getColonKeyword_1_5());
10671 match(input,60,FOLLOW_2);
10672 after(grammarAccess.getVLSUniversalQuantifierAccess().getColonKeyword_1_5());
10673
10674 }
10675
10676
10677 }
10678
10679 }
10680 catch (RecognitionException re) {
10681 reportError(re);
10682 recover(input,re);
10683 }
10684 finally {
10685
10686 restoreStackSize(stackSize);
10687
10688 }
10689 return ;
10690 }
10691 // $ANTLR end "rule__VLSUniversalQuantifier__Group_1__5__Impl"
10692
10693
10694 // $ANTLR start "rule__VLSUniversalQuantifier__Group_1_3__0"
10695 // InternalVampireLanguage.g:3376:1: rule__VLSUniversalQuantifier__Group_1_3__0 : rule__VLSUniversalQuantifier__Group_1_3__0__Impl rule__VLSUniversalQuantifier__Group_1_3__1 ;
10696 public final void rule__VLSUniversalQuantifier__Group_1_3__0() throws RecognitionException {
10697
10698 int stackSize = keepStackSize();
10699
10700 try {
10701 // InternalVampireLanguage.g:3380:1: ( rule__VLSUniversalQuantifier__Group_1_3__0__Impl rule__VLSUniversalQuantifier__Group_1_3__1 )
10702 // InternalVampireLanguage.g:3381:2: rule__VLSUniversalQuantifier__Group_1_3__0__Impl rule__VLSUniversalQuantifier__Group_1_3__1
10703 {
10704 pushFollow(FOLLOW_31);
10705 rule__VLSUniversalQuantifier__Group_1_3__0__Impl();
10706
10707 state._fsp--;
10708
10709 pushFollow(FOLLOW_2);
10710 rule__VLSUniversalQuantifier__Group_1_3__1();
10711
10712 state._fsp--;
10713
10714
10715 }
10716
10717 }
10718 catch (RecognitionException re) {
10719 reportError(re);
10720 recover(input,re);
10721 }
10722 finally {
10723
10724 restoreStackSize(stackSize);
10725
10726 }
10727 return ;
10728 }
10729 // $ANTLR end "rule__VLSUniversalQuantifier__Group_1_3__0"
10730
10731
10732 // $ANTLR start "rule__VLSUniversalQuantifier__Group_1_3__0__Impl"
10733 // InternalVampireLanguage.g:3388:1: rule__VLSUniversalQuantifier__Group_1_3__0__Impl : ( ',' ) ;
10734 public final void rule__VLSUniversalQuantifier__Group_1_3__0__Impl() throws RecognitionException {
10735
10736 int stackSize = keepStackSize();
10737
10738 try {
10739 // InternalVampireLanguage.g:3392:1: ( ( ',' ) )
10740 // InternalVampireLanguage.g:3393:1: ( ',' )
10741 {
10742 // InternalVampireLanguage.g:3393:1: ( ',' )
10743 // InternalVampireLanguage.g:3394:2: ','
10744 {
10745 before(grammarAccess.getVLSUniversalQuantifierAccess().getCommaKeyword_1_3_0());
10746 match(input,45,FOLLOW_2);
10747 after(grammarAccess.getVLSUniversalQuantifierAccess().getCommaKeyword_1_3_0());
10748
10749 }
10750
10751
10752 }
10753
10754 }
10755 catch (RecognitionException re) {
10756 reportError(re);
10757 recover(input,re);
10758 }
10759 finally {
10760
10761 restoreStackSize(stackSize);
10762
10763 }
10764 return ;
10765 }
10766 // $ANTLR end "rule__VLSUniversalQuantifier__Group_1_3__0__Impl"
10767
10768
10769 // $ANTLR start "rule__VLSUniversalQuantifier__Group_1_3__1"
10770 // InternalVampireLanguage.g:3403:1: rule__VLSUniversalQuantifier__Group_1_3__1 : rule__VLSUniversalQuantifier__Group_1_3__1__Impl ;
10771 public final void rule__VLSUniversalQuantifier__Group_1_3__1() throws RecognitionException {
10772
10773 int stackSize = keepStackSize();
10774
10775 try {
10776 // InternalVampireLanguage.g:3407:1: ( rule__VLSUniversalQuantifier__Group_1_3__1__Impl )
10777 // InternalVampireLanguage.g:3408:2: rule__VLSUniversalQuantifier__Group_1_3__1__Impl
10778 {
10779 pushFollow(FOLLOW_2);
10780 rule__VLSUniversalQuantifier__Group_1_3__1__Impl();
10781
10782 state._fsp--;
10783
10784
10785 }
10786
10787 }
10788 catch (RecognitionException re) {
10789 reportError(re);
10790 recover(input,re);
10791 }
10792 finally {
10793
10794 restoreStackSize(stackSize);
10795
10796 }
10797 return ;
10798 }
10799 // $ANTLR end "rule__VLSUniversalQuantifier__Group_1_3__1"
10800
10801
10802 // $ANTLR start "rule__VLSUniversalQuantifier__Group_1_3__1__Impl"
10803 // InternalVampireLanguage.g:3414:1: rule__VLSUniversalQuantifier__Group_1_3__1__Impl : ( ( rule__VLSUniversalQuantifier__VariablesAssignment_1_3_1 ) ) ;
10804 public final void rule__VLSUniversalQuantifier__Group_1_3__1__Impl() throws RecognitionException {
10805
10806 int stackSize = keepStackSize();
10807
10808 try {
10809 // InternalVampireLanguage.g:3418:1: ( ( ( rule__VLSUniversalQuantifier__VariablesAssignment_1_3_1 ) ) )
10810 // InternalVampireLanguage.g:3419:1: ( ( rule__VLSUniversalQuantifier__VariablesAssignment_1_3_1 ) )
10811 {
10812 // InternalVampireLanguage.g:3419:1: ( ( rule__VLSUniversalQuantifier__VariablesAssignment_1_3_1 ) )
10813 // InternalVampireLanguage.g:3420:2: ( rule__VLSUniversalQuantifier__VariablesAssignment_1_3_1 )
10814 {
10815 before(grammarAccess.getVLSUniversalQuantifierAccess().getVariablesAssignment_1_3_1());
10816 // InternalVampireLanguage.g:3421:2: ( rule__VLSUniversalQuantifier__VariablesAssignment_1_3_1 )
10817 // InternalVampireLanguage.g:3421:3: rule__VLSUniversalQuantifier__VariablesAssignment_1_3_1
10818 {
10819 pushFollow(FOLLOW_2);
10820 rule__VLSUniversalQuantifier__VariablesAssignment_1_3_1();
10821
10822 state._fsp--;
10823
10824
10825 }
10826
10827 after(grammarAccess.getVLSUniversalQuantifierAccess().getVariablesAssignment_1_3_1());
10828
10829 }
10830
10831
10832 }
10833
10834 }
10835 catch (RecognitionException re) {
10836 reportError(re);
10837 recover(input,re);
10838 }
10839 finally {
10840
10841 restoreStackSize(stackSize);
10842
10843 }
10844 return ;
10845 }
10846 // $ANTLR end "rule__VLSUniversalQuantifier__Group_1_3__1__Impl"
10847
10848
10849 // $ANTLR start "rule__VLSExistentialQuantifier__Group__0"
10850 // InternalVampireLanguage.g:3430:1: rule__VLSExistentialQuantifier__Group__0 : rule__VLSExistentialQuantifier__Group__0__Impl rule__VLSExistentialQuantifier__Group__1 ;
10851 public final void rule__VLSExistentialQuantifier__Group__0() throws RecognitionException {
10852
10853 int stackSize = keepStackSize();
10854
10855 try {
10856 // InternalVampireLanguage.g:3434:1: ( rule__VLSExistentialQuantifier__Group__0__Impl rule__VLSExistentialQuantifier__Group__1 )
10857 // InternalVampireLanguage.g:3435:2: rule__VLSExistentialQuantifier__Group__0__Impl rule__VLSExistentialQuantifier__Group__1
10858 {
10859 pushFollow(FOLLOW_33);
10860 rule__VLSExistentialQuantifier__Group__0__Impl();
10861
10862 state._fsp--;
10863
10864 pushFollow(FOLLOW_2);
10865 rule__VLSExistentialQuantifier__Group__1();
10866
10867 state._fsp--;
10868
10869
10870 }
10871
10872 }
10873 catch (RecognitionException re) {
10874 reportError(re);
10875 recover(input,re);
10876 }
10877 finally {
10878
10879 restoreStackSize(stackSize);
10880
10881 }
10882 return ;
10883 }
10884 // $ANTLR end "rule__VLSExistentialQuantifier__Group__0"
10885
10886
10887 // $ANTLR start "rule__VLSExistentialQuantifier__Group__0__Impl"
10888 // InternalVampireLanguage.g:3442:1: rule__VLSExistentialQuantifier__Group__0__Impl : ( () ) ;
10889 public final void rule__VLSExistentialQuantifier__Group__0__Impl() throws RecognitionException {
10890
10891 int stackSize = keepStackSize();
10892
10893 try {
10894 // InternalVampireLanguage.g:3446:1: ( ( () ) )
10895 // InternalVampireLanguage.g:3447:1: ( () )
10896 {
10897 // InternalVampireLanguage.g:3447:1: ( () )
10898 // InternalVampireLanguage.g:3448:2: ()
10899 {
10900 before(grammarAccess.getVLSExistentialQuantifierAccess().getVLSExistentialQuantifierAction_0());
10901 // InternalVampireLanguage.g:3449:2: ()
10902 // InternalVampireLanguage.g:3449:3:
10903 {
10904 }
10905
10906 after(grammarAccess.getVLSExistentialQuantifierAccess().getVLSExistentialQuantifierAction_0());
10907
10908 }
10909
10910
10911 }
10912
10913 }
10914 finally {
10915
10916 restoreStackSize(stackSize);
10917
10918 }
10919 return ;
10920 }
10921 // $ANTLR end "rule__VLSExistentialQuantifier__Group__0__Impl"
10922
10923
10924 // $ANTLR start "rule__VLSExistentialQuantifier__Group__1"
10925 // InternalVampireLanguage.g:3457:1: rule__VLSExistentialQuantifier__Group__1 : rule__VLSExistentialQuantifier__Group__1__Impl rule__VLSExistentialQuantifier__Group__2 ;
10926 public final void rule__VLSExistentialQuantifier__Group__1() throws RecognitionException {
10927
10928 int stackSize = keepStackSize();
10929
10930 try {
10931 // InternalVampireLanguage.g:3461:1: ( rule__VLSExistentialQuantifier__Group__1__Impl rule__VLSExistentialQuantifier__Group__2 )
10932 // InternalVampireLanguage.g:3462:2: rule__VLSExistentialQuantifier__Group__1__Impl rule__VLSExistentialQuantifier__Group__2
10933 {
10934 pushFollow(FOLLOW_15);
10935 rule__VLSExistentialQuantifier__Group__1__Impl();
10936
10937 state._fsp--;
10938
10939 pushFollow(FOLLOW_2);
10940 rule__VLSExistentialQuantifier__Group__2();
10941
10942 state._fsp--;
10943
10944
10945 }
10946
10947 }
10948 catch (RecognitionException re) {
10949 reportError(re);
10950 recover(input,re);
10951 }
10952 finally {
10953
10954 restoreStackSize(stackSize);
10955
10956 }
10957 return ;
10958 }
10959 // $ANTLR end "rule__VLSExistentialQuantifier__Group__1"
10960
10961
10962 // $ANTLR start "rule__VLSExistentialQuantifier__Group__1__Impl"
10963 // InternalVampireLanguage.g:3469:1: rule__VLSExistentialQuantifier__Group__1__Impl : ( ( rule__VLSExistentialQuantifier__Group_1__0 ) ) ;
10964 public final void rule__VLSExistentialQuantifier__Group__1__Impl() throws RecognitionException {
10965
10966 int stackSize = keepStackSize();
10967
10968 try {
10969 // InternalVampireLanguage.g:3473:1: ( ( ( rule__VLSExistentialQuantifier__Group_1__0 ) ) )
10970 // InternalVampireLanguage.g:3474:1: ( ( rule__VLSExistentialQuantifier__Group_1__0 ) )
10971 {
10972 // InternalVampireLanguage.g:3474:1: ( ( rule__VLSExistentialQuantifier__Group_1__0 ) )
10973 // InternalVampireLanguage.g:3475:2: ( rule__VLSExistentialQuantifier__Group_1__0 )
10974 {
10975 before(grammarAccess.getVLSExistentialQuantifierAccess().getGroup_1());
10976 // InternalVampireLanguage.g:3476:2: ( rule__VLSExistentialQuantifier__Group_1__0 )
10977 // InternalVampireLanguage.g:3476:3: rule__VLSExistentialQuantifier__Group_1__0
10978 {
10979 pushFollow(FOLLOW_2);
10980 rule__VLSExistentialQuantifier__Group_1__0();
10981
10982 state._fsp--;
10983
10984
10985 }
10986
10987 after(grammarAccess.getVLSExistentialQuantifierAccess().getGroup_1());
10988
10989 }
10990
10991
10992 }
10993
10994 }
10995 catch (RecognitionException re) {
10996 reportError(re);
10997 recover(input,re);
10998 }
10999 finally {
11000
11001 restoreStackSize(stackSize);
11002
11003 }
11004 return ;
11005 }
11006 // $ANTLR end "rule__VLSExistentialQuantifier__Group__1__Impl"
11007
11008
11009 // $ANTLR start "rule__VLSExistentialQuantifier__Group__2"
11010 // InternalVampireLanguage.g:3484:1: rule__VLSExistentialQuantifier__Group__2 : rule__VLSExistentialQuantifier__Group__2__Impl ;
11011 public final void rule__VLSExistentialQuantifier__Group__2() throws RecognitionException {
11012
11013 int stackSize = keepStackSize();
11014
11015 try {
11016 // InternalVampireLanguage.g:3488:1: ( rule__VLSExistentialQuantifier__Group__2__Impl )
11017 // InternalVampireLanguage.g:3489:2: rule__VLSExistentialQuantifier__Group__2__Impl
11018 {
11019 pushFollow(FOLLOW_2);
11020 rule__VLSExistentialQuantifier__Group__2__Impl();
11021
11022 state._fsp--;
11023
11024
11025 }
11026
11027 }
11028 catch (RecognitionException re) {
11029 reportError(re);
11030 recover(input,re);
11031 }
11032 finally {
11033
11034 restoreStackSize(stackSize);
11035
11036 }
11037 return ;
11038 }
11039 // $ANTLR end "rule__VLSExistentialQuantifier__Group__2"
11040
11041
11042 // $ANTLR start "rule__VLSExistentialQuantifier__Group__2__Impl"
11043 // InternalVampireLanguage.g:3495:1: rule__VLSExistentialQuantifier__Group__2__Impl : ( ( rule__VLSExistentialQuantifier__OperandAssignment_2 ) ) ;
11044 public final void rule__VLSExistentialQuantifier__Group__2__Impl() throws RecognitionException {
11045
11046 int stackSize = keepStackSize();
11047
11048 try {
11049 // InternalVampireLanguage.g:3499:1: ( ( ( rule__VLSExistentialQuantifier__OperandAssignment_2 ) ) )
11050 // InternalVampireLanguage.g:3500:1: ( ( rule__VLSExistentialQuantifier__OperandAssignment_2 ) )
11051 {
11052 // InternalVampireLanguage.g:3500:1: ( ( rule__VLSExistentialQuantifier__OperandAssignment_2 ) )
11053 // InternalVampireLanguage.g:3501:2: ( rule__VLSExistentialQuantifier__OperandAssignment_2 )
11054 {
11055 before(grammarAccess.getVLSExistentialQuantifierAccess().getOperandAssignment_2());
11056 // InternalVampireLanguage.g:3502:2: ( rule__VLSExistentialQuantifier__OperandAssignment_2 )
11057 // InternalVampireLanguage.g:3502:3: rule__VLSExistentialQuantifier__OperandAssignment_2
11058 {
11059 pushFollow(FOLLOW_2);
11060 rule__VLSExistentialQuantifier__OperandAssignment_2();
11061
11062 state._fsp--;
11063
11064
11065 }
11066
11067 after(grammarAccess.getVLSExistentialQuantifierAccess().getOperandAssignment_2());
11068
11069 }
11070
11071
11072 }
11073
11074 }
11075 catch (RecognitionException re) {
11076 reportError(re);
11077 recover(input,re);
11078 }
11079 finally {
11080
11081 restoreStackSize(stackSize);
11082
11083 }
11084 return ;
11085 }
11086 // $ANTLR end "rule__VLSExistentialQuantifier__Group__2__Impl"
11087
11088
11089 // $ANTLR start "rule__VLSExistentialQuantifier__Group_1__0"
11090 // InternalVampireLanguage.g:3511:1: rule__VLSExistentialQuantifier__Group_1__0 : rule__VLSExistentialQuantifier__Group_1__0__Impl rule__VLSExistentialQuantifier__Group_1__1 ;
11091 public final void rule__VLSExistentialQuantifier__Group_1__0() throws RecognitionException {
11092
11093 int stackSize = keepStackSize();
11094
11095 try {
11096 // InternalVampireLanguage.g:3515:1: ( rule__VLSExistentialQuantifier__Group_1__0__Impl rule__VLSExistentialQuantifier__Group_1__1 )
11097 // InternalVampireLanguage.g:3516:2: rule__VLSExistentialQuantifier__Group_1__0__Impl rule__VLSExistentialQuantifier__Group_1__1
11098 {
11099 pushFollow(FOLLOW_30);
11100 rule__VLSExistentialQuantifier__Group_1__0__Impl();
11101
11102 state._fsp--;
11103
11104 pushFollow(FOLLOW_2);
11105 rule__VLSExistentialQuantifier__Group_1__1();
11106
11107 state._fsp--;
11108
11109
11110 }
11111
11112 }
11113 catch (RecognitionException re) {
11114 reportError(re);
11115 recover(input,re);
11116 }
11117 finally {
11118
11119 restoreStackSize(stackSize);
11120
11121 }
11122 return ;
11123 }
11124 // $ANTLR end "rule__VLSExistentialQuantifier__Group_1__0"
11125
11126
11127 // $ANTLR start "rule__VLSExistentialQuantifier__Group_1__0__Impl"
11128 // InternalVampireLanguage.g:3523:1: rule__VLSExistentialQuantifier__Group_1__0__Impl : ( '?' ) ;
11129 public final void rule__VLSExistentialQuantifier__Group_1__0__Impl() throws RecognitionException {
11130
11131 int stackSize = keepStackSize();
11132
11133 try {
11134 // InternalVampireLanguage.g:3527:1: ( ( '?' ) )
11135 // InternalVampireLanguage.g:3528:1: ( '?' )
11136 {
11137 // InternalVampireLanguage.g:3528:1: ( '?' )
11138 // InternalVampireLanguage.g:3529:2: '?'
11139 {
11140 before(grammarAccess.getVLSExistentialQuantifierAccess().getQuestionMarkKeyword_1_0());
11141 match(input,61,FOLLOW_2);
11142 after(grammarAccess.getVLSExistentialQuantifierAccess().getQuestionMarkKeyword_1_0());
11143
11144 }
11145
11146
11147 }
11148
11149 }
11150 catch (RecognitionException re) {
11151 reportError(re);
11152 recover(input,re);
11153 }
11154 finally {
11155
11156 restoreStackSize(stackSize);
11157
11158 }
11159 return ;
11160 }
11161 // $ANTLR end "rule__VLSExistentialQuantifier__Group_1__0__Impl"
11162
11163
11164 // $ANTLR start "rule__VLSExistentialQuantifier__Group_1__1"
11165 // InternalVampireLanguage.g:3538:1: rule__VLSExistentialQuantifier__Group_1__1 : rule__VLSExistentialQuantifier__Group_1__1__Impl rule__VLSExistentialQuantifier__Group_1__2 ;
11166 public final void rule__VLSExistentialQuantifier__Group_1__1() throws RecognitionException {
11167
11168 int stackSize = keepStackSize();
11169
11170 try {
11171 // InternalVampireLanguage.g:3542:1: ( rule__VLSExistentialQuantifier__Group_1__1__Impl rule__VLSExistentialQuantifier__Group_1__2 )
11172 // InternalVampireLanguage.g:3543:2: rule__VLSExistentialQuantifier__Group_1__1__Impl rule__VLSExistentialQuantifier__Group_1__2
11173 {
11174 pushFollow(FOLLOW_31);
11175 rule__VLSExistentialQuantifier__Group_1__1__Impl();
11176
11177 state._fsp--;
11178
11179 pushFollow(FOLLOW_2);
11180 rule__VLSExistentialQuantifier__Group_1__2();
11181
11182 state._fsp--;
11183
11184
11185 }
11186
11187 }
11188 catch (RecognitionException re) {
11189 reportError(re);
11190 recover(input,re);
11191 }
11192 finally {
11193
11194 restoreStackSize(stackSize);
11195
11196 }
11197 return ;
11198 }
11199 // $ANTLR end "rule__VLSExistentialQuantifier__Group_1__1"
11200
11201
11202 // $ANTLR start "rule__VLSExistentialQuantifier__Group_1__1__Impl"
11203 // InternalVampireLanguage.g:3550:1: rule__VLSExistentialQuantifier__Group_1__1__Impl : ( '[' ) ;
11204 public final void rule__VLSExistentialQuantifier__Group_1__1__Impl() throws RecognitionException {
11205
11206 int stackSize = keepStackSize();
11207
11208 try {
11209 // InternalVampireLanguage.g:3554:1: ( ( '[' ) )
11210 // InternalVampireLanguage.g:3555:1: ( '[' )
11211 {
11212 // InternalVampireLanguage.g:3555:1: ( '[' )
11213 // InternalVampireLanguage.g:3556:2: '['
11214 {
11215 before(grammarAccess.getVLSExistentialQuantifierAccess().getLeftSquareBracketKeyword_1_1());
11216 match(input,50,FOLLOW_2);
11217 after(grammarAccess.getVLSExistentialQuantifierAccess().getLeftSquareBracketKeyword_1_1());
11218
11219 }
11220
11221
11222 }
11223
11224 }
11225 catch (RecognitionException re) {
11226 reportError(re);
11227 recover(input,re);
11228 }
11229 finally {
11230
11231 restoreStackSize(stackSize);
11232
11233 }
11234 return ;
11235 }
11236 // $ANTLR end "rule__VLSExistentialQuantifier__Group_1__1__Impl"
11237
11238
11239 // $ANTLR start "rule__VLSExistentialQuantifier__Group_1__2"
11240 // InternalVampireLanguage.g:3565:1: rule__VLSExistentialQuantifier__Group_1__2 : rule__VLSExistentialQuantifier__Group_1__2__Impl rule__VLSExistentialQuantifier__Group_1__3 ;
11241 public final void rule__VLSExistentialQuantifier__Group_1__2() throws RecognitionException {
11242
11243 int stackSize = keepStackSize();
11244
11245 try {
11246 // InternalVampireLanguage.g:3569:1: ( rule__VLSExistentialQuantifier__Group_1__2__Impl rule__VLSExistentialQuantifier__Group_1__3 )
11247 // InternalVampireLanguage.g:3570:2: rule__VLSExistentialQuantifier__Group_1__2__Impl rule__VLSExistentialQuantifier__Group_1__3
11248 {
11249 pushFollow(FOLLOW_9);
11250 rule__VLSExistentialQuantifier__Group_1__2__Impl();
11251
11252 state._fsp--;
11253
11254 pushFollow(FOLLOW_2);
11255 rule__VLSExistentialQuantifier__Group_1__3();
11256
11257 state._fsp--;
11258
11259
11260 }
11261
11262 }
11263 catch (RecognitionException re) {
11264 reportError(re);
11265 recover(input,re);
11266 }
11267 finally {
11268
11269 restoreStackSize(stackSize);
11270
11271 }
11272 return ;
11273 }
11274 // $ANTLR end "rule__VLSExistentialQuantifier__Group_1__2"
11275
11276
11277 // $ANTLR start "rule__VLSExistentialQuantifier__Group_1__2__Impl"
11278 // InternalVampireLanguage.g:3577:1: rule__VLSExistentialQuantifier__Group_1__2__Impl : ( ( rule__VLSExistentialQuantifier__VariablesAssignment_1_2 ) ) ;
11279 public final void rule__VLSExistentialQuantifier__Group_1__2__Impl() throws RecognitionException {
11280
11281 int stackSize = keepStackSize();
11282
11283 try {
11284 // InternalVampireLanguage.g:3581:1: ( ( ( rule__VLSExistentialQuantifier__VariablesAssignment_1_2 ) ) )
11285 // InternalVampireLanguage.g:3582:1: ( ( rule__VLSExistentialQuantifier__VariablesAssignment_1_2 ) )
11286 {
11287 // InternalVampireLanguage.g:3582:1: ( ( rule__VLSExistentialQuantifier__VariablesAssignment_1_2 ) )
11288 // InternalVampireLanguage.g:3583:2: ( rule__VLSExistentialQuantifier__VariablesAssignment_1_2 )
11289 {
11290 before(grammarAccess.getVLSExistentialQuantifierAccess().getVariablesAssignment_1_2());
11291 // InternalVampireLanguage.g:3584:2: ( rule__VLSExistentialQuantifier__VariablesAssignment_1_2 )
11292 // InternalVampireLanguage.g:3584:3: rule__VLSExistentialQuantifier__VariablesAssignment_1_2
11293 {
11294 pushFollow(FOLLOW_2);
11295 rule__VLSExistentialQuantifier__VariablesAssignment_1_2();
11296
11297 state._fsp--;
11298
11299
11300 }
11301
11302 after(grammarAccess.getVLSExistentialQuantifierAccess().getVariablesAssignment_1_2());
11303
11304 }
11305
11306
11307 }
11308
11309 }
11310 catch (RecognitionException re) {
11311 reportError(re);
11312 recover(input,re);
11313 }
11314 finally {
11315
11316 restoreStackSize(stackSize);
11317
11318 }
11319 return ;
11320 }
11321 // $ANTLR end "rule__VLSExistentialQuantifier__Group_1__2__Impl"
11322
11323
11324 // $ANTLR start "rule__VLSExistentialQuantifier__Group_1__3"
11325 // InternalVampireLanguage.g:3592:1: rule__VLSExistentialQuantifier__Group_1__3 : rule__VLSExistentialQuantifier__Group_1__3__Impl rule__VLSExistentialQuantifier__Group_1__4 ;
11326 public final void rule__VLSExistentialQuantifier__Group_1__3() throws RecognitionException {
11327
11328 int stackSize = keepStackSize();
11329
11330 try {
11331 // InternalVampireLanguage.g:3596:1: ( rule__VLSExistentialQuantifier__Group_1__3__Impl rule__VLSExistentialQuantifier__Group_1__4 )
11332 // InternalVampireLanguage.g:3597:2: rule__VLSExistentialQuantifier__Group_1__3__Impl rule__VLSExistentialQuantifier__Group_1__4
11333 {
11334 pushFollow(FOLLOW_9);
11335 rule__VLSExistentialQuantifier__Group_1__3__Impl();
11336
11337 state._fsp--;
11338
11339 pushFollow(FOLLOW_2);
11340 rule__VLSExistentialQuantifier__Group_1__4();
11341
11342 state._fsp--;
11343
11344
11345 }
11346
11347 }
11348 catch (RecognitionException re) {
11349 reportError(re);
11350 recover(input,re);
11351 }
11352 finally {
11353
11354 restoreStackSize(stackSize);
11355
11356 }
11357 return ;
11358 }
11359 // $ANTLR end "rule__VLSExistentialQuantifier__Group_1__3"
11360
11361
11362 // $ANTLR start "rule__VLSExistentialQuantifier__Group_1__3__Impl"
11363 // InternalVampireLanguage.g:3604:1: rule__VLSExistentialQuantifier__Group_1__3__Impl : ( ( rule__VLSExistentialQuantifier__Group_1_3__0 )* ) ;
11364 public final void rule__VLSExistentialQuantifier__Group_1__3__Impl() throws RecognitionException {
11365
11366 int stackSize = keepStackSize();
11367
11368 try {
11369 // InternalVampireLanguage.g:3608:1: ( ( ( rule__VLSExistentialQuantifier__Group_1_3__0 )* ) )
11370 // InternalVampireLanguage.g:3609:1: ( ( rule__VLSExistentialQuantifier__Group_1_3__0 )* )
11371 {
11372 // InternalVampireLanguage.g:3609:1: ( ( rule__VLSExistentialQuantifier__Group_1_3__0 )* )
11373 // InternalVampireLanguage.g:3610:2: ( rule__VLSExistentialQuantifier__Group_1_3__0 )*
11374 {
11375 before(grammarAccess.getVLSExistentialQuantifierAccess().getGroup_1_3());
11376 // InternalVampireLanguage.g:3611:2: ( rule__VLSExistentialQuantifier__Group_1_3__0 )*
11377 loop31:
11378 do {
11379 int alt31=2;
11380 int LA31_0 = input.LA(1);
11381
11382 if ( (LA31_0==45) ) {
11383 alt31=1;
11384 }
11385
11386
11387 switch (alt31) {
11388 case 1 :
11389 // InternalVampireLanguage.g:3611:3: rule__VLSExistentialQuantifier__Group_1_3__0
11390 {
11391 pushFollow(FOLLOW_10);
11392 rule__VLSExistentialQuantifier__Group_1_3__0();
11393
11394 state._fsp--;
11395
11396
11397 }
11398 break;
11399
11400 default :
11401 break loop31;
11402 }
11403 } while (true);
11404
11405 after(grammarAccess.getVLSExistentialQuantifierAccess().getGroup_1_3());
11406
11407 }
11408
11409
11410 }
11411
11412 }
11413 catch (RecognitionException re) {
11414 reportError(re);
11415 recover(input,re);
11416 }
11417 finally {
11418
11419 restoreStackSize(stackSize);
11420
11421 }
11422 return ;
11423 }
11424 // $ANTLR end "rule__VLSExistentialQuantifier__Group_1__3__Impl"
11425
11426
11427 // $ANTLR start "rule__VLSExistentialQuantifier__Group_1__4"
11428 // InternalVampireLanguage.g:3619:1: rule__VLSExistentialQuantifier__Group_1__4 : rule__VLSExistentialQuantifier__Group_1__4__Impl rule__VLSExistentialQuantifier__Group_1__5 ;
11429 public final void rule__VLSExistentialQuantifier__Group_1__4() throws RecognitionException {
11430
11431 int stackSize = keepStackSize();
11432
11433 try {
11434 // InternalVampireLanguage.g:3623:1: ( rule__VLSExistentialQuantifier__Group_1__4__Impl rule__VLSExistentialQuantifier__Group_1__5 )
11435 // InternalVampireLanguage.g:3624:2: rule__VLSExistentialQuantifier__Group_1__4__Impl rule__VLSExistentialQuantifier__Group_1__5
11436 {
11437 pushFollow(FOLLOW_32);
11438 rule__VLSExistentialQuantifier__Group_1__4__Impl();
11439
11440 state._fsp--;
11441
11442 pushFollow(FOLLOW_2);
11443 rule__VLSExistentialQuantifier__Group_1__5();
11444
11445 state._fsp--;
11446
11447
11448 }
11449
11450 }
11451 catch (RecognitionException re) {
11452 reportError(re);
11453 recover(input,re);
11454 }
11455 finally {
11456
11457 restoreStackSize(stackSize);
11458
11459 }
11460 return ;
11461 }
11462 // $ANTLR end "rule__VLSExistentialQuantifier__Group_1__4"
11463
11464
11465 // $ANTLR start "rule__VLSExistentialQuantifier__Group_1__4__Impl"
11466 // InternalVampireLanguage.g:3631:1: rule__VLSExistentialQuantifier__Group_1__4__Impl : ( ']' ) ;
11467 public final void rule__VLSExistentialQuantifier__Group_1__4__Impl() throws RecognitionException {
11468
11469 int stackSize = keepStackSize();
11470
11471 try {
11472 // InternalVampireLanguage.g:3635:1: ( ( ']' ) )
11473 // InternalVampireLanguage.g:3636:1: ( ']' )
11474 {
11475 // InternalVampireLanguage.g:3636:1: ( ']' )
11476 // InternalVampireLanguage.g:3637:2: ']'
11477 {
11478 before(grammarAccess.getVLSExistentialQuantifierAccess().getRightSquareBracketKeyword_1_4());
11479 match(input,44,FOLLOW_2);
11480 after(grammarAccess.getVLSExistentialQuantifierAccess().getRightSquareBracketKeyword_1_4());
11481
11482 }
11483
11484
11485 }
11486
11487 }
11488 catch (RecognitionException re) {
11489 reportError(re);
11490 recover(input,re);
11491 }
11492 finally {
11493
11494 restoreStackSize(stackSize);
11495
11496 }
11497 return ;
11498 }
11499 // $ANTLR end "rule__VLSExistentialQuantifier__Group_1__4__Impl"
11500
11501
11502 // $ANTLR start "rule__VLSExistentialQuantifier__Group_1__5"
11503 // InternalVampireLanguage.g:3646:1: rule__VLSExistentialQuantifier__Group_1__5 : rule__VLSExistentialQuantifier__Group_1__5__Impl ;
11504 public final void rule__VLSExistentialQuantifier__Group_1__5() throws RecognitionException {
11505
11506 int stackSize = keepStackSize();
11507
11508 try {
11509 // InternalVampireLanguage.g:3650:1: ( rule__VLSExistentialQuantifier__Group_1__5__Impl )
11510 // InternalVampireLanguage.g:3651:2: rule__VLSExistentialQuantifier__Group_1__5__Impl
11511 {
11512 pushFollow(FOLLOW_2);
11513 rule__VLSExistentialQuantifier__Group_1__5__Impl();
11514
11515 state._fsp--;
11516
11517
11518 }
11519
11520 }
11521 catch (RecognitionException re) {
11522 reportError(re);
11523 recover(input,re);
11524 }
11525 finally {
11526
11527 restoreStackSize(stackSize);
11528
11529 }
11530 return ;
11531 }
11532 // $ANTLR end "rule__VLSExistentialQuantifier__Group_1__5"
11533
11534
11535 // $ANTLR start "rule__VLSExistentialQuantifier__Group_1__5__Impl"
11536 // InternalVampireLanguage.g:3657:1: rule__VLSExistentialQuantifier__Group_1__5__Impl : ( ':' ) ;
11537 public final void rule__VLSExistentialQuantifier__Group_1__5__Impl() throws RecognitionException {
11538
11539 int stackSize = keepStackSize();
11540
11541 try {
11542 // InternalVampireLanguage.g:3661:1: ( ( ':' ) )
11543 // InternalVampireLanguage.g:3662:1: ( ':' )
11544 {
11545 // InternalVampireLanguage.g:3662:1: ( ':' )
11546 // InternalVampireLanguage.g:3663:2: ':'
11547 {
11548 before(grammarAccess.getVLSExistentialQuantifierAccess().getColonKeyword_1_5());
11549 match(input,60,FOLLOW_2);
11550 after(grammarAccess.getVLSExistentialQuantifierAccess().getColonKeyword_1_5());
11551
11552 }
11553
11554
11555 }
11556
11557 }
11558 catch (RecognitionException re) {
11559 reportError(re);
11560 recover(input,re);
11561 }
11562 finally {
11563
11564 restoreStackSize(stackSize);
11565
11566 }
11567 return ;
11568 }
11569 // $ANTLR end "rule__VLSExistentialQuantifier__Group_1__5__Impl"
11570
11571
11572 // $ANTLR start "rule__VLSExistentialQuantifier__Group_1_3__0"
11573 // InternalVampireLanguage.g:3673:1: rule__VLSExistentialQuantifier__Group_1_3__0 : rule__VLSExistentialQuantifier__Group_1_3__0__Impl rule__VLSExistentialQuantifier__Group_1_3__1 ;
11574 public final void rule__VLSExistentialQuantifier__Group_1_3__0() throws RecognitionException {
11575
11576 int stackSize = keepStackSize();
11577
11578 try {
11579 // InternalVampireLanguage.g:3677:1: ( rule__VLSExistentialQuantifier__Group_1_3__0__Impl rule__VLSExistentialQuantifier__Group_1_3__1 )
11580 // InternalVampireLanguage.g:3678:2: rule__VLSExistentialQuantifier__Group_1_3__0__Impl rule__VLSExistentialQuantifier__Group_1_3__1
11581 {
11582 pushFollow(FOLLOW_31);
11583 rule__VLSExistentialQuantifier__Group_1_3__0__Impl();
11584
11585 state._fsp--;
11586
11587 pushFollow(FOLLOW_2);
11588 rule__VLSExistentialQuantifier__Group_1_3__1();
11589
11590 state._fsp--;
11591
11592
11593 }
11594
11595 }
11596 catch (RecognitionException re) {
11597 reportError(re);
11598 recover(input,re);
11599 }
11600 finally {
11601
11602 restoreStackSize(stackSize);
11603
11604 }
11605 return ;
11606 }
11607 // $ANTLR end "rule__VLSExistentialQuantifier__Group_1_3__0"
11608
11609
11610 // $ANTLR start "rule__VLSExistentialQuantifier__Group_1_3__0__Impl"
11611 // InternalVampireLanguage.g:3685:1: rule__VLSExistentialQuantifier__Group_1_3__0__Impl : ( ',' ) ;
11612 public final void rule__VLSExistentialQuantifier__Group_1_3__0__Impl() throws RecognitionException {
11613
11614 int stackSize = keepStackSize();
11615
11616 try {
11617 // InternalVampireLanguage.g:3689:1: ( ( ',' ) )
11618 // InternalVampireLanguage.g:3690:1: ( ',' )
11619 {
11620 // InternalVampireLanguage.g:3690:1: ( ',' )
11621 // InternalVampireLanguage.g:3691:2: ','
11622 {
11623 before(grammarAccess.getVLSExistentialQuantifierAccess().getCommaKeyword_1_3_0());
11624 match(input,45,FOLLOW_2);
11625 after(grammarAccess.getVLSExistentialQuantifierAccess().getCommaKeyword_1_3_0());
11626
11627 }
11628
11629
11630 }
11631
11632 }
11633 catch (RecognitionException re) {
11634 reportError(re);
11635 recover(input,re);
11636 }
11637 finally {
11638
11639 restoreStackSize(stackSize);
11640
11641 }
11642 return ;
11643 }
11644 // $ANTLR end "rule__VLSExistentialQuantifier__Group_1_3__0__Impl"
11645
11646
11647 // $ANTLR start "rule__VLSExistentialQuantifier__Group_1_3__1"
11648 // InternalVampireLanguage.g:3700:1: rule__VLSExistentialQuantifier__Group_1_3__1 : rule__VLSExistentialQuantifier__Group_1_3__1__Impl ;
11649 public final void rule__VLSExistentialQuantifier__Group_1_3__1() throws RecognitionException {
11650
11651 int stackSize = keepStackSize();
11652
11653 try {
11654 // InternalVampireLanguage.g:3704:1: ( rule__VLSExistentialQuantifier__Group_1_3__1__Impl )
11655 // InternalVampireLanguage.g:3705:2: rule__VLSExistentialQuantifier__Group_1_3__1__Impl
11656 {
11657 pushFollow(FOLLOW_2);
11658 rule__VLSExistentialQuantifier__Group_1_3__1__Impl();
11659
11660 state._fsp--;
11661
11662
11663 }
11664
11665 }
11666 catch (RecognitionException re) {
11667 reportError(re);
11668 recover(input,re);
11669 }
11670 finally {
11671
11672 restoreStackSize(stackSize);
11673
11674 }
11675 return ;
11676 }
11677 // $ANTLR end "rule__VLSExistentialQuantifier__Group_1_3__1"
11678
11679
11680 // $ANTLR start "rule__VLSExistentialQuantifier__Group_1_3__1__Impl"
11681 // InternalVampireLanguage.g:3711:1: rule__VLSExistentialQuantifier__Group_1_3__1__Impl : ( ( rule__VLSExistentialQuantifier__VariablesAssignment_1_3_1 ) ) ;
11682 public final void rule__VLSExistentialQuantifier__Group_1_3__1__Impl() throws RecognitionException {
11683
11684 int stackSize = keepStackSize();
11685
11686 try {
11687 // InternalVampireLanguage.g:3715:1: ( ( ( rule__VLSExistentialQuantifier__VariablesAssignment_1_3_1 ) ) )
11688 // InternalVampireLanguage.g:3716:1: ( ( rule__VLSExistentialQuantifier__VariablesAssignment_1_3_1 ) )
11689 {
11690 // InternalVampireLanguage.g:3716:1: ( ( rule__VLSExistentialQuantifier__VariablesAssignment_1_3_1 ) )
11691 // InternalVampireLanguage.g:3717:2: ( rule__VLSExistentialQuantifier__VariablesAssignment_1_3_1 )
11692 {
11693 before(grammarAccess.getVLSExistentialQuantifierAccess().getVariablesAssignment_1_3_1());
11694 // InternalVampireLanguage.g:3718:2: ( rule__VLSExistentialQuantifier__VariablesAssignment_1_3_1 )
11695 // InternalVampireLanguage.g:3718:3: rule__VLSExistentialQuantifier__VariablesAssignment_1_3_1
11696 {
11697 pushFollow(FOLLOW_2);
11698 rule__VLSExistentialQuantifier__VariablesAssignment_1_3_1();
11699
11700 state._fsp--;
11701
11702
11703 }
11704
11705 after(grammarAccess.getVLSExistentialQuantifierAccess().getVariablesAssignment_1_3_1());
11706
11707 }
11708
11709
11710 }
11711
11712 }
11713 catch (RecognitionException re) {
11714 reportError(re);
11715 recover(input,re);
11716 }
11717 finally {
11718
11719 restoreStackSize(stackSize);
11720
11721 }
11722 return ;
11723 }
11724 // $ANTLR end "rule__VLSExistentialQuantifier__Group_1_3__1__Impl"
11725
11726
11727 // $ANTLR start "rule__VLSUnaryNegation__Group__0"
11728 // InternalVampireLanguage.g:3727:1: rule__VLSUnaryNegation__Group__0 : rule__VLSUnaryNegation__Group__0__Impl rule__VLSUnaryNegation__Group__1 ;
11729 public final void rule__VLSUnaryNegation__Group__0() throws RecognitionException {
11730
11731 int stackSize = keepStackSize();
11732
11733 try {
11734 // InternalVampireLanguage.g:3731:1: ( rule__VLSUnaryNegation__Group__0__Impl rule__VLSUnaryNegation__Group__1 )
11735 // InternalVampireLanguage.g:3732:2: rule__VLSUnaryNegation__Group__0__Impl rule__VLSUnaryNegation__Group__1
11736 {
11737 pushFollow(FOLLOW_34);
11738 rule__VLSUnaryNegation__Group__0__Impl();
11739
11740 state._fsp--;
11741
11742 pushFollow(FOLLOW_2);
11743 rule__VLSUnaryNegation__Group__1();
11744
11745 state._fsp--;
11746
11747
11748 }
11749
11750 }
11751 catch (RecognitionException re) {
11752 reportError(re);
11753 recover(input,re);
11754 }
11755 finally {
11756
11757 restoreStackSize(stackSize);
11758
11759 }
11760 return ;
11761 }
11762 // $ANTLR end "rule__VLSUnaryNegation__Group__0"
11763
11764
11765 // $ANTLR start "rule__VLSUnaryNegation__Group__0__Impl"
11766 // InternalVampireLanguage.g:3739:1: rule__VLSUnaryNegation__Group__0__Impl : ( () ) ;
11767 public final void rule__VLSUnaryNegation__Group__0__Impl() throws RecognitionException {
11768
11769 int stackSize = keepStackSize();
11770
11771 try {
11772 // InternalVampireLanguage.g:3743:1: ( ( () ) )
11773 // InternalVampireLanguage.g:3744:1: ( () )
11774 {
11775 // InternalVampireLanguage.g:3744:1: ( () )
11776 // InternalVampireLanguage.g:3745:2: ()
11777 {
11778 before(grammarAccess.getVLSUnaryNegationAccess().getVLSUnaryNegationAction_0());
11779 // InternalVampireLanguage.g:3746:2: ()
11780 // InternalVampireLanguage.g:3746:3:
11781 {
11782 }
11783
11784 after(grammarAccess.getVLSUnaryNegationAccess().getVLSUnaryNegationAction_0());
11785
11786 }
11787
11788
11789 }
11790
11791 }
11792 finally {
11793
11794 restoreStackSize(stackSize);
11795
11796 }
11797 return ;
11798 }
11799 // $ANTLR end "rule__VLSUnaryNegation__Group__0__Impl"
11800
11801
11802 // $ANTLR start "rule__VLSUnaryNegation__Group__1"
11803 // InternalVampireLanguage.g:3754:1: rule__VLSUnaryNegation__Group__1 : rule__VLSUnaryNegation__Group__1__Impl rule__VLSUnaryNegation__Group__2 ;
11804 public final void rule__VLSUnaryNegation__Group__1() throws RecognitionException {
11805
11806 int stackSize = keepStackSize();
11807
11808 try {
11809 // InternalVampireLanguage.g:3758:1: ( rule__VLSUnaryNegation__Group__1__Impl rule__VLSUnaryNegation__Group__2 )
11810 // InternalVampireLanguage.g:3759:2: rule__VLSUnaryNegation__Group__1__Impl rule__VLSUnaryNegation__Group__2
11811 {
11812 pushFollow(FOLLOW_15);
11813 rule__VLSUnaryNegation__Group__1__Impl();
11814
11815 state._fsp--;
11816
11817 pushFollow(FOLLOW_2);
11818 rule__VLSUnaryNegation__Group__2();
11819
11820 state._fsp--;
11821
11822
11823 }
11824
11825 }
11826 catch (RecognitionException re) {
11827 reportError(re);
11828 recover(input,re);
11829 }
11830 finally {
11831
11832 restoreStackSize(stackSize);
11833
11834 }
11835 return ;
11836 }
11837 // $ANTLR end "rule__VLSUnaryNegation__Group__1"
11838
11839
11840 // $ANTLR start "rule__VLSUnaryNegation__Group__1__Impl"
11841 // InternalVampireLanguage.g:3766:1: rule__VLSUnaryNegation__Group__1__Impl : ( '~' ) ;
11842 public final void rule__VLSUnaryNegation__Group__1__Impl() throws RecognitionException {
11843
11844 int stackSize = keepStackSize();
11845
11846 try {
11847 // InternalVampireLanguage.g:3770:1: ( ( '~' ) )
11848 // InternalVampireLanguage.g:3771:1: ( '~' )
11849 {
11850 // InternalVampireLanguage.g:3771:1: ( '~' )
11851 // InternalVampireLanguage.g:3772:2: '~'
11852 {
11853 before(grammarAccess.getVLSUnaryNegationAccess().getTildeKeyword_1());
11854 match(input,62,FOLLOW_2);
11855 after(grammarAccess.getVLSUnaryNegationAccess().getTildeKeyword_1());
11856
11857 }
11858
11859
11860 }
11861
11862 }
11863 catch (RecognitionException re) {
11864 reportError(re);
11865 recover(input,re);
11866 }
11867 finally {
11868
11869 restoreStackSize(stackSize);
11870
11871 }
11872 return ;
11873 }
11874 // $ANTLR end "rule__VLSUnaryNegation__Group__1__Impl"
11875
11876
11877 // $ANTLR start "rule__VLSUnaryNegation__Group__2"
11878 // InternalVampireLanguage.g:3781:1: rule__VLSUnaryNegation__Group__2 : rule__VLSUnaryNegation__Group__2__Impl ;
11879 public final void rule__VLSUnaryNegation__Group__2() throws RecognitionException {
11880
11881 int stackSize = keepStackSize();
11882
11883 try {
11884 // InternalVampireLanguage.g:3785:1: ( rule__VLSUnaryNegation__Group__2__Impl )
11885 // InternalVampireLanguage.g:3786:2: rule__VLSUnaryNegation__Group__2__Impl
11886 {
11887 pushFollow(FOLLOW_2);
11888 rule__VLSUnaryNegation__Group__2__Impl();
11889
11890 state._fsp--;
11891
11892
11893 }
11894
11895 }
11896 catch (RecognitionException re) {
11897 reportError(re);
11898 recover(input,re);
11899 }
11900 finally {
11901
11902 restoreStackSize(stackSize);
11903
11904 }
11905 return ;
11906 }
11907 // $ANTLR end "rule__VLSUnaryNegation__Group__2"
11908
11909
11910 // $ANTLR start "rule__VLSUnaryNegation__Group__2__Impl"
11911 // InternalVampireLanguage.g:3792:1: rule__VLSUnaryNegation__Group__2__Impl : ( ( rule__VLSUnaryNegation__OperandAssignment_2 ) ) ;
11912 public final void rule__VLSUnaryNegation__Group__2__Impl() throws RecognitionException {
11913
11914 int stackSize = keepStackSize();
11915
11916 try {
11917 // InternalVampireLanguage.g:3796:1: ( ( ( rule__VLSUnaryNegation__OperandAssignment_2 ) ) )
11918 // InternalVampireLanguage.g:3797:1: ( ( rule__VLSUnaryNegation__OperandAssignment_2 ) )
11919 {
11920 // InternalVampireLanguage.g:3797:1: ( ( rule__VLSUnaryNegation__OperandAssignment_2 ) )
11921 // InternalVampireLanguage.g:3798:2: ( rule__VLSUnaryNegation__OperandAssignment_2 )
11922 {
11923 before(grammarAccess.getVLSUnaryNegationAccess().getOperandAssignment_2());
11924 // InternalVampireLanguage.g:3799:2: ( rule__VLSUnaryNegation__OperandAssignment_2 )
11925 // InternalVampireLanguage.g:3799:3: rule__VLSUnaryNegation__OperandAssignment_2
11926 {
11927 pushFollow(FOLLOW_2);
11928 rule__VLSUnaryNegation__OperandAssignment_2();
11929
11930 state._fsp--;
11931
11932
11933 }
11934
11935 after(grammarAccess.getVLSUnaryNegationAccess().getOperandAssignment_2());
11936
11937 }
11938
11939
11940 }
11941
11942 }
11943 catch (RecognitionException re) {
11944 reportError(re);
11945 recover(input,re);
11946 }
11947 finally {
11948
11949 restoreStackSize(stackSize);
11950
11951 }
11952 return ;
11953 }
11954 // $ANTLR end "rule__VLSUnaryNegation__Group__2__Impl"
11955
11956
11957 // $ANTLR start "rule__VLSUnaryInfix__Group__0"
11958 // InternalVampireLanguage.g:3808:1: rule__VLSUnaryInfix__Group__0 : rule__VLSUnaryInfix__Group__0__Impl rule__VLSUnaryInfix__Group__1 ;
11959 public final void rule__VLSUnaryInfix__Group__0() throws RecognitionException {
11960
11961 int stackSize = keepStackSize();
11962
11963 try {
11964 // InternalVampireLanguage.g:3812:1: ( rule__VLSUnaryInfix__Group__0__Impl rule__VLSUnaryInfix__Group__1 )
11965 // InternalVampireLanguage.g:3813:2: rule__VLSUnaryInfix__Group__0__Impl rule__VLSUnaryInfix__Group__1
11966 {
11967 pushFollow(FOLLOW_35);
11968 rule__VLSUnaryInfix__Group__0__Impl();
11969
11970 state._fsp--;
11971
11972 pushFollow(FOLLOW_2);
11973 rule__VLSUnaryInfix__Group__1();
11974
11975 state._fsp--;
11976
11977
11978 }
11979
11980 }
11981 catch (RecognitionException re) {
11982 reportError(re);
11983 recover(input,re);
11984 }
11985 finally {
11986
11987 restoreStackSize(stackSize);
11988
11989 }
11990 return ;
11991 }
11992 // $ANTLR end "rule__VLSUnaryInfix__Group__0"
11993
11994
11995 // $ANTLR start "rule__VLSUnaryInfix__Group__0__Impl"
11996 // InternalVampireLanguage.g:3820:1: rule__VLSUnaryInfix__Group__0__Impl : ( ruleVLSAtomic ) ;
11997 public final void rule__VLSUnaryInfix__Group__0__Impl() throws RecognitionException {
11998
11999 int stackSize = keepStackSize();
12000
12001 try {
12002 // InternalVampireLanguage.g:3824:1: ( ( ruleVLSAtomic ) )
12003 // InternalVampireLanguage.g:3825:1: ( ruleVLSAtomic )
12004 {
12005 // InternalVampireLanguage.g:3825:1: ( ruleVLSAtomic )
12006 // InternalVampireLanguage.g:3826:2: ruleVLSAtomic
12007 {
12008 before(grammarAccess.getVLSUnaryInfixAccess().getVLSAtomicParserRuleCall_0());
12009 pushFollow(FOLLOW_2);
12010 ruleVLSAtomic();
12011
12012 state._fsp--;
12013
12014 after(grammarAccess.getVLSUnaryInfixAccess().getVLSAtomicParserRuleCall_0());
12015
12016 }
12017
12018
12019 }
12020
12021 }
12022 catch (RecognitionException re) {
12023 reportError(re);
12024 recover(input,re);
12025 }
12026 finally {
12027
12028 restoreStackSize(stackSize);
12029
12030 }
12031 return ;
12032 }
12033 // $ANTLR end "rule__VLSUnaryInfix__Group__0__Impl"
12034
12035
12036 // $ANTLR start "rule__VLSUnaryInfix__Group__1"
12037 // InternalVampireLanguage.g:3835:1: rule__VLSUnaryInfix__Group__1 : rule__VLSUnaryInfix__Group__1__Impl ;
12038 public final void rule__VLSUnaryInfix__Group__1() throws RecognitionException {
12039
12040 int stackSize = keepStackSize();
12041
12042 try {
12043 // InternalVampireLanguage.g:3839:1: ( rule__VLSUnaryInfix__Group__1__Impl )
12044 // InternalVampireLanguage.g:3840:2: rule__VLSUnaryInfix__Group__1__Impl
12045 {
12046 pushFollow(FOLLOW_2);
12047 rule__VLSUnaryInfix__Group__1__Impl();
12048
12049 state._fsp--;
12050
12051
12052 }
12053
12054 }
12055 catch (RecognitionException re) {
12056 reportError(re);
12057 recover(input,re);
12058 }
12059 finally {
12060
12061 restoreStackSize(stackSize);
12062
12063 }
12064 return ;
12065 }
12066 // $ANTLR end "rule__VLSUnaryInfix__Group__1"
12067
12068
12069 // $ANTLR start "rule__VLSUnaryInfix__Group__1__Impl"
12070 // InternalVampireLanguage.g:3846:1: rule__VLSUnaryInfix__Group__1__Impl : ( ( rule__VLSUnaryInfix__Group_1__0 )? ) ;
12071 public final void rule__VLSUnaryInfix__Group__1__Impl() throws RecognitionException {
12072
12073 int stackSize = keepStackSize();
12074
12075 try {
12076 // InternalVampireLanguage.g:3850:1: ( ( ( rule__VLSUnaryInfix__Group_1__0 )? ) )
12077 // InternalVampireLanguage.g:3851:1: ( ( rule__VLSUnaryInfix__Group_1__0 )? )
12078 {
12079 // InternalVampireLanguage.g:3851:1: ( ( rule__VLSUnaryInfix__Group_1__0 )? )
12080 // InternalVampireLanguage.g:3852:2: ( rule__VLSUnaryInfix__Group_1__0 )?
12081 {
12082 before(grammarAccess.getVLSUnaryInfixAccess().getGroup_1());
12083 // InternalVampireLanguage.g:3853:2: ( rule__VLSUnaryInfix__Group_1__0 )?
12084 int alt32=2;
12085 int LA32_0 = input.LA(1);
12086
12087 if ( ((LA32_0>=63 && LA32_0<=65)) ) {
12088 alt32=1;
12089 }
12090 switch (alt32) {
12091 case 1 :
12092 // InternalVampireLanguage.g:3853:3: rule__VLSUnaryInfix__Group_1__0
12093 {
12094 pushFollow(FOLLOW_2);
12095 rule__VLSUnaryInfix__Group_1__0();
12096
12097 state._fsp--;
12098
12099
12100 }
12101 break;
12102
12103 }
12104
12105 after(grammarAccess.getVLSUnaryInfixAccess().getGroup_1());
12106
12107 }
12108
12109
12110 }
12111
12112 }
12113 catch (RecognitionException re) {
12114 reportError(re);
12115 recover(input,re);
12116 }
12117 finally {
12118
12119 restoreStackSize(stackSize);
12120
12121 }
12122 return ;
12123 }
12124 // $ANTLR end "rule__VLSUnaryInfix__Group__1__Impl"
12125
12126
12127 // $ANTLR start "rule__VLSUnaryInfix__Group_1__0"
12128 // InternalVampireLanguage.g:3862:1: rule__VLSUnaryInfix__Group_1__0 : rule__VLSUnaryInfix__Group_1__0__Impl rule__VLSUnaryInfix__Group_1__1 ;
12129 public final void rule__VLSUnaryInfix__Group_1__0() throws RecognitionException {
12130
12131 int stackSize = keepStackSize();
12132
12133 try {
12134 // InternalVampireLanguage.g:3866:1: ( rule__VLSUnaryInfix__Group_1__0__Impl rule__VLSUnaryInfix__Group_1__1 )
12135 // InternalVampireLanguage.g:3867:2: rule__VLSUnaryInfix__Group_1__0__Impl rule__VLSUnaryInfix__Group_1__1
12136 {
12137 pushFollow(FOLLOW_36);
12138 rule__VLSUnaryInfix__Group_1__0__Impl();
12139
12140 state._fsp--;
12141
12142 pushFollow(FOLLOW_2);
12143 rule__VLSUnaryInfix__Group_1__1();
12144
12145 state._fsp--;
12146
12147
12148 }
12149
12150 }
12151 catch (RecognitionException re) {
12152 reportError(re);
12153 recover(input,re);
12154 }
12155 finally {
12156
12157 restoreStackSize(stackSize);
12158
12159 }
12160 return ;
12161 }
12162 // $ANTLR end "rule__VLSUnaryInfix__Group_1__0"
12163
12164
12165 // $ANTLR start "rule__VLSUnaryInfix__Group_1__0__Impl"
12166 // InternalVampireLanguage.g:3874:1: rule__VLSUnaryInfix__Group_1__0__Impl : ( ( rule__VLSUnaryInfix__Alternatives_1_0 ) ) ;
12167 public final void rule__VLSUnaryInfix__Group_1__0__Impl() throws RecognitionException {
12168
12169 int stackSize = keepStackSize();
12170
12171 try {
12172 // InternalVampireLanguage.g:3878:1: ( ( ( rule__VLSUnaryInfix__Alternatives_1_0 ) ) )
12173 // InternalVampireLanguage.g:3879:1: ( ( rule__VLSUnaryInfix__Alternatives_1_0 ) )
12174 {
12175 // InternalVampireLanguage.g:3879:1: ( ( rule__VLSUnaryInfix__Alternatives_1_0 ) )
12176 // InternalVampireLanguage.g:3880:2: ( rule__VLSUnaryInfix__Alternatives_1_0 )
12177 {
12178 before(grammarAccess.getVLSUnaryInfixAccess().getAlternatives_1_0());
12179 // InternalVampireLanguage.g:3881:2: ( rule__VLSUnaryInfix__Alternatives_1_0 )
12180 // InternalVampireLanguage.g:3881:3: rule__VLSUnaryInfix__Alternatives_1_0
12181 {
12182 pushFollow(FOLLOW_2);
12183 rule__VLSUnaryInfix__Alternatives_1_0();
12184
12185 state._fsp--;
12186
12187
12188 }
12189
12190 after(grammarAccess.getVLSUnaryInfixAccess().getAlternatives_1_0());
12191
12192 }
12193
12194
12195 }
12196
12197 }
12198 catch (RecognitionException re) {
12199 reportError(re);
12200 recover(input,re);
12201 }
12202 finally {
12203
12204 restoreStackSize(stackSize);
12205
12206 }
12207 return ;
12208 }
12209 // $ANTLR end "rule__VLSUnaryInfix__Group_1__0__Impl"
12210
12211
12212 // $ANTLR start "rule__VLSUnaryInfix__Group_1__1"
12213 // InternalVampireLanguage.g:3889:1: rule__VLSUnaryInfix__Group_1__1 : rule__VLSUnaryInfix__Group_1__1__Impl ;
12214 public final void rule__VLSUnaryInfix__Group_1__1() throws RecognitionException {
12215
12216 int stackSize = keepStackSize();
12217
12218 try {
12219 // InternalVampireLanguage.g:3893:1: ( rule__VLSUnaryInfix__Group_1__1__Impl )
12220 // InternalVampireLanguage.g:3894:2: rule__VLSUnaryInfix__Group_1__1__Impl
12221 {
12222 pushFollow(FOLLOW_2);
12223 rule__VLSUnaryInfix__Group_1__1__Impl();
12224
12225 state._fsp--;
12226
12227
12228 }
12229
12230 }
12231 catch (RecognitionException re) {
12232 reportError(re);
12233 recover(input,re);
12234 }
12235 finally {
12236
12237 restoreStackSize(stackSize);
12238
12239 }
12240 return ;
12241 }
12242 // $ANTLR end "rule__VLSUnaryInfix__Group_1__1"
12243
12244
12245 // $ANTLR start "rule__VLSUnaryInfix__Group_1__1__Impl"
12246 // InternalVampireLanguage.g:3900:1: rule__VLSUnaryInfix__Group_1__1__Impl : ( ( rule__VLSUnaryInfix__RightAssignment_1_1 ) ) ;
12247 public final void rule__VLSUnaryInfix__Group_1__1__Impl() throws RecognitionException {
12248
12249 int stackSize = keepStackSize();
12250
12251 try {
12252 // InternalVampireLanguage.g:3904:1: ( ( ( rule__VLSUnaryInfix__RightAssignment_1_1 ) ) )
12253 // InternalVampireLanguage.g:3905:1: ( ( rule__VLSUnaryInfix__RightAssignment_1_1 ) )
12254 {
12255 // InternalVampireLanguage.g:3905:1: ( ( rule__VLSUnaryInfix__RightAssignment_1_1 ) )
12256 // InternalVampireLanguage.g:3906:2: ( rule__VLSUnaryInfix__RightAssignment_1_1 )
12257 {
12258 before(grammarAccess.getVLSUnaryInfixAccess().getRightAssignment_1_1());
12259 // InternalVampireLanguage.g:3907:2: ( rule__VLSUnaryInfix__RightAssignment_1_1 )
12260 // InternalVampireLanguage.g:3907:3: rule__VLSUnaryInfix__RightAssignment_1_1
12261 {
12262 pushFollow(FOLLOW_2);
12263 rule__VLSUnaryInfix__RightAssignment_1_1();
12264
12265 state._fsp--;
12266
12267
12268 }
12269
12270 after(grammarAccess.getVLSUnaryInfixAccess().getRightAssignment_1_1());
12271
12272 }
12273
12274
12275 }
12276
12277 }
12278 catch (RecognitionException re) {
12279 reportError(re);
12280 recover(input,re);
12281 }
12282 finally {
12283
12284 restoreStackSize(stackSize);
12285
12286 }
12287 return ;
12288 }
12289 // $ANTLR end "rule__VLSUnaryInfix__Group_1__1__Impl"
12290
12291
12292 // $ANTLR start "rule__VLSUnaryInfix__Group_1_0_0__0"
12293 // InternalVampireLanguage.g:3916:1: rule__VLSUnaryInfix__Group_1_0_0__0 : rule__VLSUnaryInfix__Group_1_0_0__0__Impl rule__VLSUnaryInfix__Group_1_0_0__1 ;
12294 public final void rule__VLSUnaryInfix__Group_1_0_0__0() throws RecognitionException {
12295
12296 int stackSize = keepStackSize();
12297
12298 try {
12299 // InternalVampireLanguage.g:3920:1: ( rule__VLSUnaryInfix__Group_1_0_0__0__Impl rule__VLSUnaryInfix__Group_1_0_0__1 )
12300 // InternalVampireLanguage.g:3921:2: rule__VLSUnaryInfix__Group_1_0_0__0__Impl rule__VLSUnaryInfix__Group_1_0_0__1
12301 {
12302 pushFollow(FOLLOW_37);
12303 rule__VLSUnaryInfix__Group_1_0_0__0__Impl();
12304
12305 state._fsp--;
12306
12307 pushFollow(FOLLOW_2);
12308 rule__VLSUnaryInfix__Group_1_0_0__1();
12309
12310 state._fsp--;
12311
12312
12313 }
12314
12315 }
12316 catch (RecognitionException re) {
12317 reportError(re);
12318 recover(input,re);
12319 }
12320 finally {
12321
12322 restoreStackSize(stackSize);
12323
12324 }
12325 return ;
12326 }
12327 // $ANTLR end "rule__VLSUnaryInfix__Group_1_0_0__0"
12328
12329
12330 // $ANTLR start "rule__VLSUnaryInfix__Group_1_0_0__0__Impl"
12331 // InternalVampireLanguage.g:3928:1: rule__VLSUnaryInfix__Group_1_0_0__0__Impl : ( () ) ;
12332 public final void rule__VLSUnaryInfix__Group_1_0_0__0__Impl() throws RecognitionException {
12333
12334 int stackSize = keepStackSize();
12335
12336 try {
12337 // InternalVampireLanguage.g:3932:1: ( ( () ) )
12338 // InternalVampireLanguage.g:3933:1: ( () )
12339 {
12340 // InternalVampireLanguage.g:3933:1: ( () )
12341 // InternalVampireLanguage.g:3934:2: ()
12342 {
12343 before(grammarAccess.getVLSUnaryInfixAccess().getVLSInequalityLeftAction_1_0_0_0());
12344 // InternalVampireLanguage.g:3935:2: ()
12345 // InternalVampireLanguage.g:3935:3:
12346 {
12347 }
12348
12349 after(grammarAccess.getVLSUnaryInfixAccess().getVLSInequalityLeftAction_1_0_0_0());
12350
12351 }
12352
12353
12354 }
12355
12356 }
12357 finally {
12358
12359 restoreStackSize(stackSize);
12360
12361 }
12362 return ;
12363 }
12364 // $ANTLR end "rule__VLSUnaryInfix__Group_1_0_0__0__Impl"
12365
12366
12367 // $ANTLR start "rule__VLSUnaryInfix__Group_1_0_0__1"
12368 // InternalVampireLanguage.g:3943:1: rule__VLSUnaryInfix__Group_1_0_0__1 : rule__VLSUnaryInfix__Group_1_0_0__1__Impl ;
12369 public final void rule__VLSUnaryInfix__Group_1_0_0__1() throws RecognitionException {
12370
12371 int stackSize = keepStackSize();
12372
12373 try {
12374 // InternalVampireLanguage.g:3947:1: ( rule__VLSUnaryInfix__Group_1_0_0__1__Impl )
12375 // InternalVampireLanguage.g:3948:2: rule__VLSUnaryInfix__Group_1_0_0__1__Impl
12376 {
12377 pushFollow(FOLLOW_2);
12378 rule__VLSUnaryInfix__Group_1_0_0__1__Impl();
12379
12380 state._fsp--;
12381
12382
12383 }
12384
12385 }
12386 catch (RecognitionException re) {
12387 reportError(re);
12388 recover(input,re);
12389 }
12390 finally {
12391
12392 restoreStackSize(stackSize);
12393
12394 }
12395 return ;
12396 }
12397 // $ANTLR end "rule__VLSUnaryInfix__Group_1_0_0__1"
12398
12399
12400 // $ANTLR start "rule__VLSUnaryInfix__Group_1_0_0__1__Impl"
12401 // InternalVampireLanguage.g:3954:1: rule__VLSUnaryInfix__Group_1_0_0__1__Impl : ( '!=' ) ;
12402 public final void rule__VLSUnaryInfix__Group_1_0_0__1__Impl() throws RecognitionException {
12403
12404 int stackSize = keepStackSize();
12405
12406 try {
12407 // InternalVampireLanguage.g:3958:1: ( ( '!=' ) )
12408 // InternalVampireLanguage.g:3959:1: ( '!=' )
12409 {
12410 // InternalVampireLanguage.g:3959:1: ( '!=' )
12411 // InternalVampireLanguage.g:3960:2: '!='
12412 {
12413 before(grammarAccess.getVLSUnaryInfixAccess().getExclamationMarkEqualsSignKeyword_1_0_0_1());
12414 match(input,63,FOLLOW_2);
12415 after(grammarAccess.getVLSUnaryInfixAccess().getExclamationMarkEqualsSignKeyword_1_0_0_1());
12416
12417 }
12418
12419
12420 }
12421
12422 }
12423 catch (RecognitionException re) {
12424 reportError(re);
12425 recover(input,re);
12426 }
12427 finally {
12428
12429 restoreStackSize(stackSize);
12430
12431 }
12432 return ;
12433 }
12434 // $ANTLR end "rule__VLSUnaryInfix__Group_1_0_0__1__Impl"
12435
12436
12437 // $ANTLR start "rule__VLSUnaryInfix__Group_1_0_1__0"
12438 // InternalVampireLanguage.g:3970:1: rule__VLSUnaryInfix__Group_1_0_1__0 : rule__VLSUnaryInfix__Group_1_0_1__0__Impl rule__VLSUnaryInfix__Group_1_0_1__1 ;
12439 public final void rule__VLSUnaryInfix__Group_1_0_1__0() throws RecognitionException {
12440
12441 int stackSize = keepStackSize();
12442
12443 try {
12444 // InternalVampireLanguage.g:3974:1: ( rule__VLSUnaryInfix__Group_1_0_1__0__Impl rule__VLSUnaryInfix__Group_1_0_1__1 )
12445 // InternalVampireLanguage.g:3975:2: rule__VLSUnaryInfix__Group_1_0_1__0__Impl rule__VLSUnaryInfix__Group_1_0_1__1
12446 {
12447 pushFollow(FOLLOW_38);
12448 rule__VLSUnaryInfix__Group_1_0_1__0__Impl();
12449
12450 state._fsp--;
12451
12452 pushFollow(FOLLOW_2);
12453 rule__VLSUnaryInfix__Group_1_0_1__1();
12454
12455 state._fsp--;
12456
12457
12458 }
12459
12460 }
12461 catch (RecognitionException re) {
12462 reportError(re);
12463 recover(input,re);
12464 }
12465 finally {
12466
12467 restoreStackSize(stackSize);
12468
12469 }
12470 return ;
12471 }
12472 // $ANTLR end "rule__VLSUnaryInfix__Group_1_0_1__0"
12473
12474
12475 // $ANTLR start "rule__VLSUnaryInfix__Group_1_0_1__0__Impl"
12476 // InternalVampireLanguage.g:3982:1: rule__VLSUnaryInfix__Group_1_0_1__0__Impl : ( () ) ;
12477 public final void rule__VLSUnaryInfix__Group_1_0_1__0__Impl() throws RecognitionException {
12478
12479 int stackSize = keepStackSize();
12480
12481 try {
12482 // InternalVampireLanguage.g:3986:1: ( ( () ) )
12483 // InternalVampireLanguage.g:3987:1: ( () )
12484 {
12485 // InternalVampireLanguage.g:3987:1: ( () )
12486 // InternalVampireLanguage.g:3988:2: ()
12487 {
12488 before(grammarAccess.getVLSUnaryInfixAccess().getVLSEqualityLeftAction_1_0_1_0());
12489 // InternalVampireLanguage.g:3989:2: ()
12490 // InternalVampireLanguage.g:3989:3:
12491 {
12492 }
12493
12494 after(grammarAccess.getVLSUnaryInfixAccess().getVLSEqualityLeftAction_1_0_1_0());
12495
12496 }
12497
12498
12499 }
12500
12501 }
12502 finally {
12503
12504 restoreStackSize(stackSize);
12505
12506 }
12507 return ;
12508 }
12509 // $ANTLR end "rule__VLSUnaryInfix__Group_1_0_1__0__Impl"
12510
12511
12512 // $ANTLR start "rule__VLSUnaryInfix__Group_1_0_1__1"
12513 // InternalVampireLanguage.g:3997:1: rule__VLSUnaryInfix__Group_1_0_1__1 : rule__VLSUnaryInfix__Group_1_0_1__1__Impl ;
12514 public final void rule__VLSUnaryInfix__Group_1_0_1__1() throws RecognitionException {
12515
12516 int stackSize = keepStackSize();
12517
12518 try {
12519 // InternalVampireLanguage.g:4001:1: ( rule__VLSUnaryInfix__Group_1_0_1__1__Impl )
12520 // InternalVampireLanguage.g:4002:2: rule__VLSUnaryInfix__Group_1_0_1__1__Impl
12521 {
12522 pushFollow(FOLLOW_2);
12523 rule__VLSUnaryInfix__Group_1_0_1__1__Impl();
12524
12525 state._fsp--;
12526
12527
12528 }
12529
12530 }
12531 catch (RecognitionException re) {
12532 reportError(re);
12533 recover(input,re);
12534 }
12535 finally {
12536
12537 restoreStackSize(stackSize);
12538
12539 }
12540 return ;
12541 }
12542 // $ANTLR end "rule__VLSUnaryInfix__Group_1_0_1__1"
12543
12544
12545 // $ANTLR start "rule__VLSUnaryInfix__Group_1_0_1__1__Impl"
12546 // InternalVampireLanguage.g:4008:1: rule__VLSUnaryInfix__Group_1_0_1__1__Impl : ( '=' ) ;
12547 public final void rule__VLSUnaryInfix__Group_1_0_1__1__Impl() throws RecognitionException {
12548
12549 int stackSize = keepStackSize();
12550
12551 try {
12552 // InternalVampireLanguage.g:4012:1: ( ( '=' ) )
12553 // InternalVampireLanguage.g:4013:1: ( '=' )
12554 {
12555 // InternalVampireLanguage.g:4013:1: ( '=' )
12556 // InternalVampireLanguage.g:4014:2: '='
12557 {
12558 before(grammarAccess.getVLSUnaryInfixAccess().getEqualsSignKeyword_1_0_1_1());
12559 match(input,64,FOLLOW_2);
12560 after(grammarAccess.getVLSUnaryInfixAccess().getEqualsSignKeyword_1_0_1_1());
12561
12562 }
12563
12564
12565 }
12566
12567 }
12568 catch (RecognitionException re) {
12569 reportError(re);
12570 recover(input,re);
12571 }
12572 finally {
12573
12574 restoreStackSize(stackSize);
12575
12576 }
12577 return ;
12578 }
12579 // $ANTLR end "rule__VLSUnaryInfix__Group_1_0_1__1__Impl"
12580
12581
12582 // $ANTLR start "rule__VLSUnaryInfix__Group_1_0_2__0"
12583 // InternalVampireLanguage.g:4024:1: rule__VLSUnaryInfix__Group_1_0_2__0 : rule__VLSUnaryInfix__Group_1_0_2__0__Impl rule__VLSUnaryInfix__Group_1_0_2__1 ;
12584 public final void rule__VLSUnaryInfix__Group_1_0_2__0() throws RecognitionException {
12585
12586 int stackSize = keepStackSize();
12587
12588 try {
12589 // InternalVampireLanguage.g:4028:1: ( rule__VLSUnaryInfix__Group_1_0_2__0__Impl rule__VLSUnaryInfix__Group_1_0_2__1 )
12590 // InternalVampireLanguage.g:4029:2: rule__VLSUnaryInfix__Group_1_0_2__0__Impl rule__VLSUnaryInfix__Group_1_0_2__1
12591 {
12592 pushFollow(FOLLOW_35);
12593 rule__VLSUnaryInfix__Group_1_0_2__0__Impl();
12594
12595 state._fsp--;
12596
12597 pushFollow(FOLLOW_2);
12598 rule__VLSUnaryInfix__Group_1_0_2__1();
12599
12600 state._fsp--;
12601
12602
12603 }
12604
12605 }
12606 catch (RecognitionException re) {
12607 reportError(re);
12608 recover(input,re);
12609 }
12610 finally {
12611
12612 restoreStackSize(stackSize);
12613
12614 }
12615 return ;
12616 }
12617 // $ANTLR end "rule__VLSUnaryInfix__Group_1_0_2__0"
12618
12619
12620 // $ANTLR start "rule__VLSUnaryInfix__Group_1_0_2__0__Impl"
12621 // InternalVampireLanguage.g:4036:1: rule__VLSUnaryInfix__Group_1_0_2__0__Impl : ( () ) ;
12622 public final void rule__VLSUnaryInfix__Group_1_0_2__0__Impl() throws RecognitionException {
12623
12624 int stackSize = keepStackSize();
12625
12626 try {
12627 // InternalVampireLanguage.g:4040:1: ( ( () ) )
12628 // InternalVampireLanguage.g:4041:1: ( () )
12629 {
12630 // InternalVampireLanguage.g:4041:1: ( () )
12631 // InternalVampireLanguage.g:4042:2: ()
12632 {
12633 before(grammarAccess.getVLSUnaryInfixAccess().getVLSAssignmentLeftAction_1_0_2_0());
12634 // InternalVampireLanguage.g:4043:2: ()
12635 // InternalVampireLanguage.g:4043:3:
12636 {
12637 }
12638
12639 after(grammarAccess.getVLSUnaryInfixAccess().getVLSAssignmentLeftAction_1_0_2_0());
12640
12641 }
12642
12643
12644 }
12645
12646 }
12647 finally {
12648
12649 restoreStackSize(stackSize);
12650
12651 }
12652 return ;
12653 }
12654 // $ANTLR end "rule__VLSUnaryInfix__Group_1_0_2__0__Impl"
12655
12656
12657 // $ANTLR start "rule__VLSUnaryInfix__Group_1_0_2__1"
12658 // InternalVampireLanguage.g:4051:1: rule__VLSUnaryInfix__Group_1_0_2__1 : rule__VLSUnaryInfix__Group_1_0_2__1__Impl ;
12659 public final void rule__VLSUnaryInfix__Group_1_0_2__1() throws RecognitionException {
12660
12661 int stackSize = keepStackSize();
12662
12663 try {
12664 // InternalVampireLanguage.g:4055:1: ( rule__VLSUnaryInfix__Group_1_0_2__1__Impl )
12665 // InternalVampireLanguage.g:4056:2: rule__VLSUnaryInfix__Group_1_0_2__1__Impl
12666 {
12667 pushFollow(FOLLOW_2);
12668 rule__VLSUnaryInfix__Group_1_0_2__1__Impl();
12669
12670 state._fsp--;
12671
12672
12673 }
12674
12675 }
12676 catch (RecognitionException re) {
12677 reportError(re);
12678 recover(input,re);
12679 }
12680 finally {
12681
12682 restoreStackSize(stackSize);
12683
12684 }
12685 return ;
12686 }
12687 // $ANTLR end "rule__VLSUnaryInfix__Group_1_0_2__1"
12688
12689
12690 // $ANTLR start "rule__VLSUnaryInfix__Group_1_0_2__1__Impl"
12691 // InternalVampireLanguage.g:4062:1: rule__VLSUnaryInfix__Group_1_0_2__1__Impl : ( ':=' ) ;
12692 public final void rule__VLSUnaryInfix__Group_1_0_2__1__Impl() throws RecognitionException {
12693
12694 int stackSize = keepStackSize();
12695
12696 try {
12697 // InternalVampireLanguage.g:4066:1: ( ( ':=' ) )
12698 // InternalVampireLanguage.g:4067:1: ( ':=' )
12699 {
12700 // InternalVampireLanguage.g:4067:1: ( ':=' )
12701 // InternalVampireLanguage.g:4068:2: ':='
12702 {
12703 before(grammarAccess.getVLSUnaryInfixAccess().getColonEqualsSignKeyword_1_0_2_1());
12704 match(input,65,FOLLOW_2);
12705 after(grammarAccess.getVLSUnaryInfixAccess().getColonEqualsSignKeyword_1_0_2_1());
12706
12707 }
12708
12709
12710 }
12711
12712 }
12713 catch (RecognitionException re) {
12714 reportError(re);
12715 recover(input,re);
12716 }
12717 finally {
12718
12719 restoreStackSize(stackSize);
12720
12721 }
12722 return ;
12723 }
12724 // $ANTLR end "rule__VLSUnaryInfix__Group_1_0_2__1__Impl"
12725
12726
12727 // $ANTLR start "rule__VLSAtomicConstant__Group_0__0"
12728 // InternalVampireLanguage.g:4078:1: rule__VLSAtomicConstant__Group_0__0 : rule__VLSAtomicConstant__Group_0__0__Impl rule__VLSAtomicConstant__Group_0__1 ;
12729 public final void rule__VLSAtomicConstant__Group_0__0() throws RecognitionException {
12730
12731 int stackSize = keepStackSize();
12732
12733 try {
12734 // InternalVampireLanguage.g:4082:1: ( rule__VLSAtomicConstant__Group_0__0__Impl rule__VLSAtomicConstant__Group_0__1 )
12735 // InternalVampireLanguage.g:4083:2: rule__VLSAtomicConstant__Group_0__0__Impl rule__VLSAtomicConstant__Group_0__1
12736 {
12737 pushFollow(FOLLOW_39);
12738 rule__VLSAtomicConstant__Group_0__0__Impl();
12739
12740 state._fsp--;
12741
12742 pushFollow(FOLLOW_2);
12743 rule__VLSAtomicConstant__Group_0__1();
12744
12745 state._fsp--;
12746
12747
12748 }
12749
12750 }
12751 catch (RecognitionException re) {
12752 reportError(re);
12753 recover(input,re);
12754 }
12755 finally {
12756
12757 restoreStackSize(stackSize);
12758
12759 }
12760 return ;
12761 }
12762 // $ANTLR end "rule__VLSAtomicConstant__Group_0__0"
12763
12764
12765 // $ANTLR start "rule__VLSAtomicConstant__Group_0__0__Impl"
12766 // InternalVampireLanguage.g:4090:1: rule__VLSAtomicConstant__Group_0__0__Impl : ( () ) ;
12767 public final void rule__VLSAtomicConstant__Group_0__0__Impl() throws RecognitionException {
12768
12769 int stackSize = keepStackSize();
12770
12771 try {
12772 // InternalVampireLanguage.g:4094:1: ( ( () ) )
12773 // InternalVampireLanguage.g:4095:1: ( () )
12774 {
12775 // InternalVampireLanguage.g:4095:1: ( () )
12776 // InternalVampireLanguage.g:4096:2: ()
12777 {
12778 before(grammarAccess.getVLSAtomicConstantAccess().getVLSConstantAction_0_0());
12779 // InternalVampireLanguage.g:4097:2: ()
12780 // InternalVampireLanguage.g:4097:3:
12781 {
12782 }
12783
12784 after(grammarAccess.getVLSAtomicConstantAccess().getVLSConstantAction_0_0());
12785
12786 }
12787
12788
12789 }
12790
12791 }
12792 finally {
12793
12794 restoreStackSize(stackSize);
12795
12796 }
12797 return ;
12798 }
12799 // $ANTLR end "rule__VLSAtomicConstant__Group_0__0__Impl"
12800
12801
12802 // $ANTLR start "rule__VLSAtomicConstant__Group_0__1"
12803 // InternalVampireLanguage.g:4105:1: rule__VLSAtomicConstant__Group_0__1 : rule__VLSAtomicConstant__Group_0__1__Impl ;
12804 public final void rule__VLSAtomicConstant__Group_0__1() throws RecognitionException {
12805
12806 int stackSize = keepStackSize();
12807
12808 try {
12809 // InternalVampireLanguage.g:4109:1: ( rule__VLSAtomicConstant__Group_0__1__Impl )
12810 // InternalVampireLanguage.g:4110:2: rule__VLSAtomicConstant__Group_0__1__Impl
12811 {
12812 pushFollow(FOLLOW_2);
12813 rule__VLSAtomicConstant__Group_0__1__Impl();
12814
12815 state._fsp--;
12816
12817
12818 }
12819
12820 }
12821 catch (RecognitionException re) {
12822 reportError(re);
12823 recover(input,re);
12824 }
12825 finally {
12826
12827 restoreStackSize(stackSize);
12828
12829 }
12830 return ;
12831 }
12832 // $ANTLR end "rule__VLSAtomicConstant__Group_0__1"
12833
12834
12835 // $ANTLR start "rule__VLSAtomicConstant__Group_0__1__Impl"
12836 // InternalVampireLanguage.g:4116:1: rule__VLSAtomicConstant__Group_0__1__Impl : ( ( rule__VLSAtomicConstant__NameAssignment_0_1 ) ) ;
12837 public final void rule__VLSAtomicConstant__Group_0__1__Impl() throws RecognitionException {
12838
12839 int stackSize = keepStackSize();
12840
12841 try {
12842 // InternalVampireLanguage.g:4120:1: ( ( ( rule__VLSAtomicConstant__NameAssignment_0_1 ) ) )
12843 // InternalVampireLanguage.g:4121:1: ( ( rule__VLSAtomicConstant__NameAssignment_0_1 ) )
12844 {
12845 // InternalVampireLanguage.g:4121:1: ( ( rule__VLSAtomicConstant__NameAssignment_0_1 ) )
12846 // InternalVampireLanguage.g:4122:2: ( rule__VLSAtomicConstant__NameAssignment_0_1 )
12847 {
12848 before(grammarAccess.getVLSAtomicConstantAccess().getNameAssignment_0_1());
12849 // InternalVampireLanguage.g:4123:2: ( rule__VLSAtomicConstant__NameAssignment_0_1 )
12850 // InternalVampireLanguage.g:4123:3: rule__VLSAtomicConstant__NameAssignment_0_1
12851 {
12852 pushFollow(FOLLOW_2);
12853 rule__VLSAtomicConstant__NameAssignment_0_1();
12854
12855 state._fsp--;
12856
12857
12858 }
12859
12860 after(grammarAccess.getVLSAtomicConstantAccess().getNameAssignment_0_1());
12861
12862 }
12863
12864
12865 }
12866
12867 }
12868 catch (RecognitionException re) {
12869 reportError(re);
12870 recover(input,re);
12871 }
12872 finally {
12873
12874 restoreStackSize(stackSize);
12875
12876 }
12877 return ;
12878 }
12879 // $ANTLR end "rule__VLSAtomicConstant__Group_0__1__Impl"
12880
12881
12882 // $ANTLR start "rule__VLSAtomicConstant__Group_1__0"
12883 // InternalVampireLanguage.g:4132:1: rule__VLSAtomicConstant__Group_1__0 : rule__VLSAtomicConstant__Group_1__0__Impl rule__VLSAtomicConstant__Group_1__1 ;
12884 public final void rule__VLSAtomicConstant__Group_1__0() throws RecognitionException {
12885
12886 int stackSize = keepStackSize();
12887
12888 try {
12889 // InternalVampireLanguage.g:4136:1: ( rule__VLSAtomicConstant__Group_1__0__Impl rule__VLSAtomicConstant__Group_1__1 )
12890 // InternalVampireLanguage.g:4137:2: rule__VLSAtomicConstant__Group_1__0__Impl rule__VLSAtomicConstant__Group_1__1
12891 {
12892 pushFollow(FOLLOW_40);
12893 rule__VLSAtomicConstant__Group_1__0__Impl();
12894
12895 state._fsp--;
12896
12897 pushFollow(FOLLOW_2);
12898 rule__VLSAtomicConstant__Group_1__1();
12899
12900 state._fsp--;
12901
12902
12903 }
12904
12905 }
12906 catch (RecognitionException re) {
12907 reportError(re);
12908 recover(input,re);
12909 }
12910 finally {
12911
12912 restoreStackSize(stackSize);
12913
12914 }
12915 return ;
12916 }
12917 // $ANTLR end "rule__VLSAtomicConstant__Group_1__0"
12918
12919
12920 // $ANTLR start "rule__VLSAtomicConstant__Group_1__0__Impl"
12921 // InternalVampireLanguage.g:4144:1: rule__VLSAtomicConstant__Group_1__0__Impl : ( () ) ;
12922 public final void rule__VLSAtomicConstant__Group_1__0__Impl() throws RecognitionException {
12923
12924 int stackSize = keepStackSize();
12925
12926 try {
12927 // InternalVampireLanguage.g:4148:1: ( ( () ) )
12928 // InternalVampireLanguage.g:4149:1: ( () )
12929 {
12930 // InternalVampireLanguage.g:4149:1: ( () )
12931 // InternalVampireLanguage.g:4150:2: ()
12932 {
12933 before(grammarAccess.getVLSAtomicConstantAccess().getVLSTrueAction_1_0());
12934 // InternalVampireLanguage.g:4151:2: ()
12935 // InternalVampireLanguage.g:4151:3:
12936 {
12937 }
12938
12939 after(grammarAccess.getVLSAtomicConstantAccess().getVLSTrueAction_1_0());
12940
12941 }
12942
12943
12944 }
12945
12946 }
12947 finally {
12948
12949 restoreStackSize(stackSize);
12950
12951 }
12952 return ;
12953 }
12954 // $ANTLR end "rule__VLSAtomicConstant__Group_1__0__Impl"
12955
12956
12957 // $ANTLR start "rule__VLSAtomicConstant__Group_1__1"
12958 // InternalVampireLanguage.g:4159:1: rule__VLSAtomicConstant__Group_1__1 : rule__VLSAtomicConstant__Group_1__1__Impl ;
12959 public final void rule__VLSAtomicConstant__Group_1__1() throws RecognitionException {
12960
12961 int stackSize = keepStackSize();
12962
12963 try {
12964 // InternalVampireLanguage.g:4163:1: ( rule__VLSAtomicConstant__Group_1__1__Impl )
12965 // InternalVampireLanguage.g:4164:2: rule__VLSAtomicConstant__Group_1__1__Impl
12966 {
12967 pushFollow(FOLLOW_2);
12968 rule__VLSAtomicConstant__Group_1__1__Impl();
12969
12970 state._fsp--;
12971
12972
12973 }
12974
12975 }
12976 catch (RecognitionException re) {
12977 reportError(re);
12978 recover(input,re);
12979 }
12980 finally {
12981
12982 restoreStackSize(stackSize);
12983
12984 }
12985 return ;
12986 }
12987 // $ANTLR end "rule__VLSAtomicConstant__Group_1__1"
12988
12989
12990 // $ANTLR start "rule__VLSAtomicConstant__Group_1__1__Impl"
12991 // InternalVampireLanguage.g:4170:1: rule__VLSAtomicConstant__Group_1__1__Impl : ( '$true' ) ;
12992 public final void rule__VLSAtomicConstant__Group_1__1__Impl() throws RecognitionException {
12993
12994 int stackSize = keepStackSize();
12995
12996 try {
12997 // InternalVampireLanguage.g:4174:1: ( ( '$true' ) )
12998 // InternalVampireLanguage.g:4175:1: ( '$true' )
12999 {
13000 // InternalVampireLanguage.g:4175:1: ( '$true' )
13001 // InternalVampireLanguage.g:4176:2: '$true'
13002 {
13003 before(grammarAccess.getVLSAtomicConstantAccess().getTrueKeyword_1_1());
13004 match(input,66,FOLLOW_2);
13005 after(grammarAccess.getVLSAtomicConstantAccess().getTrueKeyword_1_1());
13006
13007 }
13008
13009
13010 }
13011
13012 }
13013 catch (RecognitionException re) {
13014 reportError(re);
13015 recover(input,re);
13016 }
13017 finally {
13018
13019 restoreStackSize(stackSize);
13020
13021 }
13022 return ;
13023 }
13024 // $ANTLR end "rule__VLSAtomicConstant__Group_1__1__Impl"
13025
13026
13027 // $ANTLR start "rule__VLSAtomicConstant__Group_2__0"
13028 // InternalVampireLanguage.g:4186:1: rule__VLSAtomicConstant__Group_2__0 : rule__VLSAtomicConstant__Group_2__0__Impl rule__VLSAtomicConstant__Group_2__1 ;
13029 public final void rule__VLSAtomicConstant__Group_2__0() throws RecognitionException {
13030
13031 int stackSize = keepStackSize();
13032
13033 try {
13034 // InternalVampireLanguage.g:4190:1: ( rule__VLSAtomicConstant__Group_2__0__Impl rule__VLSAtomicConstant__Group_2__1 )
13035 // InternalVampireLanguage.g:4191:2: rule__VLSAtomicConstant__Group_2__0__Impl rule__VLSAtomicConstant__Group_2__1
13036 {
13037 pushFollow(FOLLOW_41);
13038 rule__VLSAtomicConstant__Group_2__0__Impl();
13039
13040 state._fsp--;
13041
13042 pushFollow(FOLLOW_2);
13043 rule__VLSAtomicConstant__Group_2__1();
13044
13045 state._fsp--;
13046
13047
13048 }
13049
13050 }
13051 catch (RecognitionException re) {
13052 reportError(re);
13053 recover(input,re);
13054 }
13055 finally {
13056
13057 restoreStackSize(stackSize);
13058
13059 }
13060 return ;
13061 }
13062 // $ANTLR end "rule__VLSAtomicConstant__Group_2__0"
13063
13064
13065 // $ANTLR start "rule__VLSAtomicConstant__Group_2__0__Impl"
13066 // InternalVampireLanguage.g:4198:1: rule__VLSAtomicConstant__Group_2__0__Impl : ( () ) ;
13067 public final void rule__VLSAtomicConstant__Group_2__0__Impl() throws RecognitionException {
13068
13069 int stackSize = keepStackSize();
13070
13071 try {
13072 // InternalVampireLanguage.g:4202:1: ( ( () ) )
13073 // InternalVampireLanguage.g:4203:1: ( () )
13074 {
13075 // InternalVampireLanguage.g:4203:1: ( () )
13076 // InternalVampireLanguage.g:4204:2: ()
13077 {
13078 before(grammarAccess.getVLSAtomicConstantAccess().getVLSFalseAction_2_0());
13079 // InternalVampireLanguage.g:4205:2: ()
13080 // InternalVampireLanguage.g:4205:3:
13081 {
13082 }
13083
13084 after(grammarAccess.getVLSAtomicConstantAccess().getVLSFalseAction_2_0());
13085
13086 }
13087
13088
13089 }
13090
13091 }
13092 finally {
13093
13094 restoreStackSize(stackSize);
13095
13096 }
13097 return ;
13098 }
13099 // $ANTLR end "rule__VLSAtomicConstant__Group_2__0__Impl"
13100
13101
13102 // $ANTLR start "rule__VLSAtomicConstant__Group_2__1"
13103 // InternalVampireLanguage.g:4213:1: rule__VLSAtomicConstant__Group_2__1 : rule__VLSAtomicConstant__Group_2__1__Impl ;
13104 public final void rule__VLSAtomicConstant__Group_2__1() throws RecognitionException {
13105
13106 int stackSize = keepStackSize();
13107
13108 try {
13109 // InternalVampireLanguage.g:4217:1: ( rule__VLSAtomicConstant__Group_2__1__Impl )
13110 // InternalVampireLanguage.g:4218:2: rule__VLSAtomicConstant__Group_2__1__Impl
13111 {
13112 pushFollow(FOLLOW_2);
13113 rule__VLSAtomicConstant__Group_2__1__Impl();
13114
13115 state._fsp--;
13116
13117
13118 }
13119
13120 }
13121 catch (RecognitionException re) {
13122 reportError(re);
13123 recover(input,re);
13124 }
13125 finally {
13126
13127 restoreStackSize(stackSize);
13128
13129 }
13130 return ;
13131 }
13132 // $ANTLR end "rule__VLSAtomicConstant__Group_2__1"
13133
13134
13135 // $ANTLR start "rule__VLSAtomicConstant__Group_2__1__Impl"
13136 // InternalVampireLanguage.g:4224:1: rule__VLSAtomicConstant__Group_2__1__Impl : ( '$false' ) ;
13137 public final void rule__VLSAtomicConstant__Group_2__1__Impl() throws RecognitionException {
13138
13139 int stackSize = keepStackSize();
13140
13141 try {
13142 // InternalVampireLanguage.g:4228:1: ( ( '$false' ) )
13143 // InternalVampireLanguage.g:4229:1: ( '$false' )
13144 {
13145 // InternalVampireLanguage.g:4229:1: ( '$false' )
13146 // InternalVampireLanguage.g:4230:2: '$false'
13147 {
13148 before(grammarAccess.getVLSAtomicConstantAccess().getFalseKeyword_2_1());
13149 match(input,67,FOLLOW_2);
13150 after(grammarAccess.getVLSAtomicConstantAccess().getFalseKeyword_2_1());
13151
13152 }
13153
13154
13155 }
13156
13157 }
13158 catch (RecognitionException re) {
13159 reportError(re);
13160 recover(input,re);
13161 }
13162 finally {
13163
13164 restoreStackSize(stackSize);
13165
13166 }
13167 return ;
13168 }
13169 // $ANTLR end "rule__VLSAtomicConstant__Group_2__1__Impl"
13170
13171
13172 // $ANTLR start "rule__VLSAtomicFunction__Group_0__0"
13173 // InternalVampireLanguage.g:4240:1: rule__VLSAtomicFunction__Group_0__0 : rule__VLSAtomicFunction__Group_0__0__Impl rule__VLSAtomicFunction__Group_0__1 ;
13174 public final void rule__VLSAtomicFunction__Group_0__0() throws RecognitionException {
13175
13176 int stackSize = keepStackSize();
13177
13178 try {
13179 // InternalVampireLanguage.g:4244:1: ( rule__VLSAtomicFunction__Group_0__0__Impl rule__VLSAtomicFunction__Group_0__1 )
13180 // InternalVampireLanguage.g:4245:2: rule__VLSAtomicFunction__Group_0__0__Impl rule__VLSAtomicFunction__Group_0__1
13181 {
13182 pushFollow(FOLLOW_39);
13183 rule__VLSAtomicFunction__Group_0__0__Impl();
13184
13185 state._fsp--;
13186
13187 pushFollow(FOLLOW_2);
13188 rule__VLSAtomicFunction__Group_0__1();
13189
13190 state._fsp--;
13191
13192
13193 }
13194
13195 }
13196 catch (RecognitionException re) {
13197 reportError(re);
13198 recover(input,re);
13199 }
13200 finally {
13201
13202 restoreStackSize(stackSize);
13203
13204 }
13205 return ;
13206 }
13207 // $ANTLR end "rule__VLSAtomicFunction__Group_0__0"
13208
13209
13210 // $ANTLR start "rule__VLSAtomicFunction__Group_0__0__Impl"
13211 // InternalVampireLanguage.g:4252:1: rule__VLSAtomicFunction__Group_0__0__Impl : ( () ) ;
13212 public final void rule__VLSAtomicFunction__Group_0__0__Impl() throws RecognitionException {
13213
13214 int stackSize = keepStackSize();
13215
13216 try {
13217 // InternalVampireLanguage.g:4256:1: ( ( () ) )
13218 // InternalVampireLanguage.g:4257:1: ( () )
13219 {
13220 // InternalVampireLanguage.g:4257:1: ( () )
13221 // InternalVampireLanguage.g:4258:2: ()
13222 {
13223 before(grammarAccess.getVLSAtomicFunctionAccess().getVLSFunctionAction_0_0());
13224 // InternalVampireLanguage.g:4259:2: ()
13225 // InternalVampireLanguage.g:4259:3:
13226 {
13227 }
13228
13229 after(grammarAccess.getVLSAtomicFunctionAccess().getVLSFunctionAction_0_0());
13230
13231 }
13232
13233
13234 }
13235
13236 }
13237 finally {
13238
13239 restoreStackSize(stackSize);
13240
13241 }
13242 return ;
13243 }
13244 // $ANTLR end "rule__VLSAtomicFunction__Group_0__0__Impl"
13245
13246
13247 // $ANTLR start "rule__VLSAtomicFunction__Group_0__1"
13248 // InternalVampireLanguage.g:4267:1: rule__VLSAtomicFunction__Group_0__1 : rule__VLSAtomicFunction__Group_0__1__Impl rule__VLSAtomicFunction__Group_0__2 ;
13249 public final void rule__VLSAtomicFunction__Group_0__1() throws RecognitionException {
13250
13251 int stackSize = keepStackSize();
13252
13253 try {
13254 // InternalVampireLanguage.g:4271:1: ( rule__VLSAtomicFunction__Group_0__1__Impl rule__VLSAtomicFunction__Group_0__2 )
13255 // InternalVampireLanguage.g:4272:2: rule__VLSAtomicFunction__Group_0__1__Impl rule__VLSAtomicFunction__Group_0__2
13256 {
13257 pushFollow(FOLLOW_11);
13258 rule__VLSAtomicFunction__Group_0__1__Impl();
13259
13260 state._fsp--;
13261
13262 pushFollow(FOLLOW_2);
13263 rule__VLSAtomicFunction__Group_0__2();
13264
13265 state._fsp--;
13266
13267
13268 }
13269
13270 }
13271 catch (RecognitionException re) {
13272 reportError(re);
13273 recover(input,re);
13274 }
13275 finally {
13276
13277 restoreStackSize(stackSize);
13278
13279 }
13280 return ;
13281 }
13282 // $ANTLR end "rule__VLSAtomicFunction__Group_0__1"
13283
13284
13285 // $ANTLR start "rule__VLSAtomicFunction__Group_0__1__Impl"
13286 // InternalVampireLanguage.g:4279:1: rule__VLSAtomicFunction__Group_0__1__Impl : ( ( rule__VLSAtomicFunction__ConstantAssignment_0_1 ) ) ;
13287 public final void rule__VLSAtomicFunction__Group_0__1__Impl() throws RecognitionException {
13288
13289 int stackSize = keepStackSize();
13290
13291 try {
13292 // InternalVampireLanguage.g:4283:1: ( ( ( rule__VLSAtomicFunction__ConstantAssignment_0_1 ) ) )
13293 // InternalVampireLanguage.g:4284:1: ( ( rule__VLSAtomicFunction__ConstantAssignment_0_1 ) )
13294 {
13295 // InternalVampireLanguage.g:4284:1: ( ( rule__VLSAtomicFunction__ConstantAssignment_0_1 ) )
13296 // InternalVampireLanguage.g:4285:2: ( rule__VLSAtomicFunction__ConstantAssignment_0_1 )
13297 {
13298 before(grammarAccess.getVLSAtomicFunctionAccess().getConstantAssignment_0_1());
13299 // InternalVampireLanguage.g:4286:2: ( rule__VLSAtomicFunction__ConstantAssignment_0_1 )
13300 // InternalVampireLanguage.g:4286:3: rule__VLSAtomicFunction__ConstantAssignment_0_1
13301 {
13302 pushFollow(FOLLOW_2);
13303 rule__VLSAtomicFunction__ConstantAssignment_0_1();
13304
13305 state._fsp--;
13306
13307
13308 }
13309
13310 after(grammarAccess.getVLSAtomicFunctionAccess().getConstantAssignment_0_1());
13311
13312 }
13313
13314
13315 }
13316
13317 }
13318 catch (RecognitionException re) {
13319 reportError(re);
13320 recover(input,re);
13321 }
13322 finally {
13323
13324 restoreStackSize(stackSize);
13325
13326 }
13327 return ;
13328 }
13329 // $ANTLR end "rule__VLSAtomicFunction__Group_0__1__Impl"
13330
13331
13332 // $ANTLR start "rule__VLSAtomicFunction__Group_0__2"
13333 // InternalVampireLanguage.g:4294:1: rule__VLSAtomicFunction__Group_0__2 : rule__VLSAtomicFunction__Group_0__2__Impl ;
13334 public final void rule__VLSAtomicFunction__Group_0__2() throws RecognitionException {
13335
13336 int stackSize = keepStackSize();
13337
13338 try {
13339 // InternalVampireLanguage.g:4298:1: ( rule__VLSAtomicFunction__Group_0__2__Impl )
13340 // InternalVampireLanguage.g:4299:2: rule__VLSAtomicFunction__Group_0__2__Impl
13341 {
13342 pushFollow(FOLLOW_2);
13343 rule__VLSAtomicFunction__Group_0__2__Impl();
13344
13345 state._fsp--;
13346
13347
13348 }
13349
13350 }
13351 catch (RecognitionException re) {
13352 reportError(re);
13353 recover(input,re);
13354 }
13355 finally {
13356
13357 restoreStackSize(stackSize);
13358
13359 }
13360 return ;
13361 }
13362 // $ANTLR end "rule__VLSAtomicFunction__Group_0__2"
13363
13364
13365 // $ANTLR start "rule__VLSAtomicFunction__Group_0__2__Impl"
13366 // InternalVampireLanguage.g:4305:1: rule__VLSAtomicFunction__Group_0__2__Impl : ( ( rule__VLSAtomicFunction__Group_0_2__0 ) ) ;
13367 public final void rule__VLSAtomicFunction__Group_0__2__Impl() throws RecognitionException {
13368
13369 int stackSize = keepStackSize();
13370
13371 try {
13372 // InternalVampireLanguage.g:4309:1: ( ( ( rule__VLSAtomicFunction__Group_0_2__0 ) ) )
13373 // InternalVampireLanguage.g:4310:1: ( ( rule__VLSAtomicFunction__Group_0_2__0 ) )
13374 {
13375 // InternalVampireLanguage.g:4310:1: ( ( rule__VLSAtomicFunction__Group_0_2__0 ) )
13376 // InternalVampireLanguage.g:4311:2: ( rule__VLSAtomicFunction__Group_0_2__0 )
13377 {
13378 before(grammarAccess.getVLSAtomicFunctionAccess().getGroup_0_2());
13379 // InternalVampireLanguage.g:4312:2: ( rule__VLSAtomicFunction__Group_0_2__0 )
13380 // InternalVampireLanguage.g:4312:3: rule__VLSAtomicFunction__Group_0_2__0
13381 {
13382 pushFollow(FOLLOW_2);
13383 rule__VLSAtomicFunction__Group_0_2__0();
13384
13385 state._fsp--;
13386
13387
13388 }
13389
13390 after(grammarAccess.getVLSAtomicFunctionAccess().getGroup_0_2());
13391
13392 }
13393
13394
13395 }
13396
13397 }
13398 catch (RecognitionException re) {
13399 reportError(re);
13400 recover(input,re);
13401 }
13402 finally {
13403
13404 restoreStackSize(stackSize);
13405
13406 }
13407 return ;
13408 }
13409 // $ANTLR end "rule__VLSAtomicFunction__Group_0__2__Impl"
13410
13411
13412 // $ANTLR start "rule__VLSAtomicFunction__Group_0_2__0"
13413 // InternalVampireLanguage.g:4321:1: rule__VLSAtomicFunction__Group_0_2__0 : rule__VLSAtomicFunction__Group_0_2__0__Impl rule__VLSAtomicFunction__Group_0_2__1 ;
13414 public final void rule__VLSAtomicFunction__Group_0_2__0() throws RecognitionException {
13415
13416 int stackSize = keepStackSize();
13417
13418 try {
13419 // InternalVampireLanguage.g:4325:1: ( rule__VLSAtomicFunction__Group_0_2__0__Impl rule__VLSAtomicFunction__Group_0_2__1 )
13420 // InternalVampireLanguage.g:4326:2: rule__VLSAtomicFunction__Group_0_2__0__Impl rule__VLSAtomicFunction__Group_0_2__1
13421 {
13422 pushFollow(FOLLOW_36);
13423 rule__VLSAtomicFunction__Group_0_2__0__Impl();
13424
13425 state._fsp--;
13426
13427 pushFollow(FOLLOW_2);
13428 rule__VLSAtomicFunction__Group_0_2__1();
13429
13430 state._fsp--;
13431
13432
13433 }
13434
13435 }
13436 catch (RecognitionException re) {
13437 reportError(re);
13438 recover(input,re);
13439 }
13440 finally {
13441
13442 restoreStackSize(stackSize);
13443
13444 }
13445 return ;
13446 }
13447 // $ANTLR end "rule__VLSAtomicFunction__Group_0_2__0"
13448
13449
13450 // $ANTLR start "rule__VLSAtomicFunction__Group_0_2__0__Impl"
13451 // InternalVampireLanguage.g:4333:1: rule__VLSAtomicFunction__Group_0_2__0__Impl : ( '(' ) ;
13452 public final void rule__VLSAtomicFunction__Group_0_2__0__Impl() throws RecognitionException {
13453
13454 int stackSize = keepStackSize();
13455
13456 try {
13457 // InternalVampireLanguage.g:4337:1: ( ( '(' ) )
13458 // InternalVampireLanguage.g:4338:1: ( '(' )
13459 {
13460 // InternalVampireLanguage.g:4338:1: ( '(' )
13461 // InternalVampireLanguage.g:4339:2: '('
13462 {
13463 before(grammarAccess.getVLSAtomicFunctionAccess().getLeftParenthesisKeyword_0_2_0());
13464 match(input,47,FOLLOW_2);
13465 after(grammarAccess.getVLSAtomicFunctionAccess().getLeftParenthesisKeyword_0_2_0());
13466
13467 }
13468
13469
13470 }
13471
13472 }
13473 catch (RecognitionException re) {
13474 reportError(re);
13475 recover(input,re);
13476 }
13477 finally {
13478
13479 restoreStackSize(stackSize);
13480
13481 }
13482 return ;
13483 }
13484 // $ANTLR end "rule__VLSAtomicFunction__Group_0_2__0__Impl"
13485
13486
13487 // $ANTLR start "rule__VLSAtomicFunction__Group_0_2__1"
13488 // InternalVampireLanguage.g:4348:1: rule__VLSAtomicFunction__Group_0_2__1 : rule__VLSAtomicFunction__Group_0_2__1__Impl rule__VLSAtomicFunction__Group_0_2__2 ;
13489 public final void rule__VLSAtomicFunction__Group_0_2__1() throws RecognitionException {
13490
13491 int stackSize = keepStackSize();
13492
13493 try {
13494 // InternalVampireLanguage.g:4352:1: ( rule__VLSAtomicFunction__Group_0_2__1__Impl rule__VLSAtomicFunction__Group_0_2__2 )
13495 // InternalVampireLanguage.g:4353:2: rule__VLSAtomicFunction__Group_0_2__1__Impl rule__VLSAtomicFunction__Group_0_2__2
13496 {
13497 pushFollow(FOLLOW_16);
13498 rule__VLSAtomicFunction__Group_0_2__1__Impl();
13499
13500 state._fsp--;
13501
13502 pushFollow(FOLLOW_2);
13503 rule__VLSAtomicFunction__Group_0_2__2();
13504
13505 state._fsp--;
13506
13507
13508 }
13509
13510 }
13511 catch (RecognitionException re) {
13512 reportError(re);
13513 recover(input,re);
13514 }
13515 finally {
13516
13517 restoreStackSize(stackSize);
13518
13519 }
13520 return ;
13521 }
13522 // $ANTLR end "rule__VLSAtomicFunction__Group_0_2__1"
13523
13524
13525 // $ANTLR start "rule__VLSAtomicFunction__Group_0_2__1__Impl"
13526 // InternalVampireLanguage.g:4360:1: rule__VLSAtomicFunction__Group_0_2__1__Impl : ( ( rule__VLSAtomicFunction__TermsAssignment_0_2_1 ) ) ;
13527 public final void rule__VLSAtomicFunction__Group_0_2__1__Impl() throws RecognitionException {
13528
13529 int stackSize = keepStackSize();
13530
13531 try {
13532 // InternalVampireLanguage.g:4364:1: ( ( ( rule__VLSAtomicFunction__TermsAssignment_0_2_1 ) ) )
13533 // InternalVampireLanguage.g:4365:1: ( ( rule__VLSAtomicFunction__TermsAssignment_0_2_1 ) )
13534 {
13535 // InternalVampireLanguage.g:4365:1: ( ( rule__VLSAtomicFunction__TermsAssignment_0_2_1 ) )
13536 // InternalVampireLanguage.g:4366:2: ( rule__VLSAtomicFunction__TermsAssignment_0_2_1 )
13537 {
13538 before(grammarAccess.getVLSAtomicFunctionAccess().getTermsAssignment_0_2_1());
13539 // InternalVampireLanguage.g:4367:2: ( rule__VLSAtomicFunction__TermsAssignment_0_2_1 )
13540 // InternalVampireLanguage.g:4367:3: rule__VLSAtomicFunction__TermsAssignment_0_2_1
13541 {
13542 pushFollow(FOLLOW_2);
13543 rule__VLSAtomicFunction__TermsAssignment_0_2_1();
13544
13545 state._fsp--;
13546
13547
13548 }
13549
13550 after(grammarAccess.getVLSAtomicFunctionAccess().getTermsAssignment_0_2_1());
13551
13552 }
13553
13554
13555 }
13556
13557 }
13558 catch (RecognitionException re) {
13559 reportError(re);
13560 recover(input,re);
13561 }
13562 finally {
13563
13564 restoreStackSize(stackSize);
13565
13566 }
13567 return ;
13568 }
13569 // $ANTLR end "rule__VLSAtomicFunction__Group_0_2__1__Impl"
13570
13571
13572 // $ANTLR start "rule__VLSAtomicFunction__Group_0_2__2"
13573 // InternalVampireLanguage.g:4375:1: rule__VLSAtomicFunction__Group_0_2__2 : rule__VLSAtomicFunction__Group_0_2__2__Impl rule__VLSAtomicFunction__Group_0_2__3 ;
13574 public final void rule__VLSAtomicFunction__Group_0_2__2() throws RecognitionException {
13575
13576 int stackSize = keepStackSize();
13577
13578 try {
13579 // InternalVampireLanguage.g:4379:1: ( rule__VLSAtomicFunction__Group_0_2__2__Impl rule__VLSAtomicFunction__Group_0_2__3 )
13580 // InternalVampireLanguage.g:4380:2: rule__VLSAtomicFunction__Group_0_2__2__Impl rule__VLSAtomicFunction__Group_0_2__3
13581 {
13582 pushFollow(FOLLOW_16);
13583 rule__VLSAtomicFunction__Group_0_2__2__Impl();
13584
13585 state._fsp--;
13586
13587 pushFollow(FOLLOW_2);
13588 rule__VLSAtomicFunction__Group_0_2__3();
13589
13590 state._fsp--;
13591
13592
13593 }
13594
13595 }
13596 catch (RecognitionException re) {
13597 reportError(re);
13598 recover(input,re);
13599 }
13600 finally {
13601
13602 restoreStackSize(stackSize);
13603
13604 }
13605 return ;
13606 }
13607 // $ANTLR end "rule__VLSAtomicFunction__Group_0_2__2"
13608
13609
13610 // $ANTLR start "rule__VLSAtomicFunction__Group_0_2__2__Impl"
13611 // InternalVampireLanguage.g:4387:1: rule__VLSAtomicFunction__Group_0_2__2__Impl : ( ( rule__VLSAtomicFunction__Group_0_2_2__0 )* ) ;
13612 public final void rule__VLSAtomicFunction__Group_0_2__2__Impl() throws RecognitionException {
13613
13614 int stackSize = keepStackSize();
13615
13616 try {
13617 // InternalVampireLanguage.g:4391:1: ( ( ( rule__VLSAtomicFunction__Group_0_2_2__0 )* ) )
13618 // InternalVampireLanguage.g:4392:1: ( ( rule__VLSAtomicFunction__Group_0_2_2__0 )* )
13619 {
13620 // InternalVampireLanguage.g:4392:1: ( ( rule__VLSAtomicFunction__Group_0_2_2__0 )* )
13621 // InternalVampireLanguage.g:4393:2: ( rule__VLSAtomicFunction__Group_0_2_2__0 )*
13622 {
13623 before(grammarAccess.getVLSAtomicFunctionAccess().getGroup_0_2_2());
13624 // InternalVampireLanguage.g:4394:2: ( rule__VLSAtomicFunction__Group_0_2_2__0 )*
13625 loop33:
13626 do {
13627 int alt33=2;
13628 int LA33_0 = input.LA(1);
13629
13630 if ( (LA33_0==45) ) {
13631 alt33=1;
13632 }
13633
13634
13635 switch (alt33) {
13636 case 1 :
13637 // InternalVampireLanguage.g:4394:3: rule__VLSAtomicFunction__Group_0_2_2__0
13638 {
13639 pushFollow(FOLLOW_10);
13640 rule__VLSAtomicFunction__Group_0_2_2__0();
13641
13642 state._fsp--;
13643
13644
13645 }
13646 break;
13647
13648 default :
13649 break loop33;
13650 }
13651 } while (true);
13652
13653 after(grammarAccess.getVLSAtomicFunctionAccess().getGroup_0_2_2());
13654
13655 }
13656
13657
13658 }
13659
13660 }
13661 catch (RecognitionException re) {
13662 reportError(re);
13663 recover(input,re);
13664 }
13665 finally {
13666
13667 restoreStackSize(stackSize);
13668
13669 }
13670 return ;
13671 }
13672 // $ANTLR end "rule__VLSAtomicFunction__Group_0_2__2__Impl"
13673
13674
13675 // $ANTLR start "rule__VLSAtomicFunction__Group_0_2__3"
13676 // InternalVampireLanguage.g:4402:1: rule__VLSAtomicFunction__Group_0_2__3 : rule__VLSAtomicFunction__Group_0_2__3__Impl ;
13677 public final void rule__VLSAtomicFunction__Group_0_2__3() throws RecognitionException {
13678
13679 int stackSize = keepStackSize();
13680
13681 try {
13682 // InternalVampireLanguage.g:4406:1: ( rule__VLSAtomicFunction__Group_0_2__3__Impl )
13683 // InternalVampireLanguage.g:4407:2: rule__VLSAtomicFunction__Group_0_2__3__Impl
13684 {
13685 pushFollow(FOLLOW_2);
13686 rule__VLSAtomicFunction__Group_0_2__3__Impl();
13687
13688 state._fsp--;
13689
13690
13691 }
13692
13693 }
13694 catch (RecognitionException re) {
13695 reportError(re);
13696 recover(input,re);
13697 }
13698 finally {
13699
13700 restoreStackSize(stackSize);
13701
13702 }
13703 return ;
13704 }
13705 // $ANTLR end "rule__VLSAtomicFunction__Group_0_2__3"
13706
13707
13708 // $ANTLR start "rule__VLSAtomicFunction__Group_0_2__3__Impl"
13709 // InternalVampireLanguage.g:4413:1: rule__VLSAtomicFunction__Group_0_2__3__Impl : ( ')' ) ;
13710 public final void rule__VLSAtomicFunction__Group_0_2__3__Impl() throws RecognitionException {
13711
13712 int stackSize = keepStackSize();
13713
13714 try {
13715 // InternalVampireLanguage.g:4417:1: ( ( ')' ) )
13716 // InternalVampireLanguage.g:4418:1: ( ')' )
13717 {
13718 // InternalVampireLanguage.g:4418:1: ( ')' )
13719 // InternalVampireLanguage.g:4419:2: ')'
13720 {
13721 before(grammarAccess.getVLSAtomicFunctionAccess().getRightParenthesisKeyword_0_2_3());
13722 match(input,48,FOLLOW_2);
13723 after(grammarAccess.getVLSAtomicFunctionAccess().getRightParenthesisKeyword_0_2_3());
13724
13725 }
13726
13727
13728 }
13729
13730 }
13731 catch (RecognitionException re) {
13732 reportError(re);
13733 recover(input,re);
13734 }
13735 finally {
13736
13737 restoreStackSize(stackSize);
13738
13739 }
13740 return ;
13741 }
13742 // $ANTLR end "rule__VLSAtomicFunction__Group_0_2__3__Impl"
13743
13744
13745 // $ANTLR start "rule__VLSAtomicFunction__Group_0_2_2__0"
13746 // InternalVampireLanguage.g:4429:1: rule__VLSAtomicFunction__Group_0_2_2__0 : rule__VLSAtomicFunction__Group_0_2_2__0__Impl rule__VLSAtomicFunction__Group_0_2_2__1 ;
13747 public final void rule__VLSAtomicFunction__Group_0_2_2__0() throws RecognitionException {
13748
13749 int stackSize = keepStackSize();
13750
13751 try {
13752 // InternalVampireLanguage.g:4433:1: ( rule__VLSAtomicFunction__Group_0_2_2__0__Impl rule__VLSAtomicFunction__Group_0_2_2__1 )
13753 // InternalVampireLanguage.g:4434:2: rule__VLSAtomicFunction__Group_0_2_2__0__Impl rule__VLSAtomicFunction__Group_0_2_2__1
13754 {
13755 pushFollow(FOLLOW_36);
13756 rule__VLSAtomicFunction__Group_0_2_2__0__Impl();
13757
13758 state._fsp--;
13759
13760 pushFollow(FOLLOW_2);
13761 rule__VLSAtomicFunction__Group_0_2_2__1();
13762
13763 state._fsp--;
13764
13765
13766 }
13767
13768 }
13769 catch (RecognitionException re) {
13770 reportError(re);
13771 recover(input,re);
13772 }
13773 finally {
13774
13775 restoreStackSize(stackSize);
13776
13777 }
13778 return ;
13779 }
13780 // $ANTLR end "rule__VLSAtomicFunction__Group_0_2_2__0"
13781
13782
13783 // $ANTLR start "rule__VLSAtomicFunction__Group_0_2_2__0__Impl"
13784 // InternalVampireLanguage.g:4441:1: rule__VLSAtomicFunction__Group_0_2_2__0__Impl : ( ',' ) ;
13785 public final void rule__VLSAtomicFunction__Group_0_2_2__0__Impl() throws RecognitionException {
13786
13787 int stackSize = keepStackSize();
13788
13789 try {
13790 // InternalVampireLanguage.g:4445:1: ( ( ',' ) )
13791 // InternalVampireLanguage.g:4446:1: ( ',' )
13792 {
13793 // InternalVampireLanguage.g:4446:1: ( ',' )
13794 // InternalVampireLanguage.g:4447:2: ','
13795 {
13796 before(grammarAccess.getVLSAtomicFunctionAccess().getCommaKeyword_0_2_2_0());
13797 match(input,45,FOLLOW_2);
13798 after(grammarAccess.getVLSAtomicFunctionAccess().getCommaKeyword_0_2_2_0());
13799
13800 }
13801
13802
13803 }
13804
13805 }
13806 catch (RecognitionException re) {
13807 reportError(re);
13808 recover(input,re);
13809 }
13810 finally {
13811
13812 restoreStackSize(stackSize);
13813
13814 }
13815 return ;
13816 }
13817 // $ANTLR end "rule__VLSAtomicFunction__Group_0_2_2__0__Impl"
13818
13819
13820 // $ANTLR start "rule__VLSAtomicFunction__Group_0_2_2__1"
13821 // InternalVampireLanguage.g:4456:1: rule__VLSAtomicFunction__Group_0_2_2__1 : rule__VLSAtomicFunction__Group_0_2_2__1__Impl ;
13822 public final void rule__VLSAtomicFunction__Group_0_2_2__1() throws RecognitionException {
13823
13824 int stackSize = keepStackSize();
13825
13826 try {
13827 // InternalVampireLanguage.g:4460:1: ( rule__VLSAtomicFunction__Group_0_2_2__1__Impl )
13828 // InternalVampireLanguage.g:4461:2: rule__VLSAtomicFunction__Group_0_2_2__1__Impl
13829 {
13830 pushFollow(FOLLOW_2);
13831 rule__VLSAtomicFunction__Group_0_2_2__1__Impl();
13832
13833 state._fsp--;
13834
13835
13836 }
13837
13838 }
13839 catch (RecognitionException re) {
13840 reportError(re);
13841 recover(input,re);
13842 }
13843 finally {
13844
13845 restoreStackSize(stackSize);
13846
13847 }
13848 return ;
13849 }
13850 // $ANTLR end "rule__VLSAtomicFunction__Group_0_2_2__1"
13851
13852
13853 // $ANTLR start "rule__VLSAtomicFunction__Group_0_2_2__1__Impl"
13854 // InternalVampireLanguage.g:4467:1: rule__VLSAtomicFunction__Group_0_2_2__1__Impl : ( ( rule__VLSAtomicFunction__TermsAssignment_0_2_2_1 ) ) ;
13855 public final void rule__VLSAtomicFunction__Group_0_2_2__1__Impl() throws RecognitionException {
13856
13857 int stackSize = keepStackSize();
13858
13859 try {
13860 // InternalVampireLanguage.g:4471:1: ( ( ( rule__VLSAtomicFunction__TermsAssignment_0_2_2_1 ) ) )
13861 // InternalVampireLanguage.g:4472:1: ( ( rule__VLSAtomicFunction__TermsAssignment_0_2_2_1 ) )
13862 {
13863 // InternalVampireLanguage.g:4472:1: ( ( rule__VLSAtomicFunction__TermsAssignment_0_2_2_1 ) )
13864 // InternalVampireLanguage.g:4473:2: ( rule__VLSAtomicFunction__TermsAssignment_0_2_2_1 )
13865 {
13866 before(grammarAccess.getVLSAtomicFunctionAccess().getTermsAssignment_0_2_2_1());
13867 // InternalVampireLanguage.g:4474:2: ( rule__VLSAtomicFunction__TermsAssignment_0_2_2_1 )
13868 // InternalVampireLanguage.g:4474:3: rule__VLSAtomicFunction__TermsAssignment_0_2_2_1
13869 {
13870 pushFollow(FOLLOW_2);
13871 rule__VLSAtomicFunction__TermsAssignment_0_2_2_1();
13872
13873 state._fsp--;
13874
13875
13876 }
13877
13878 after(grammarAccess.getVLSAtomicFunctionAccess().getTermsAssignment_0_2_2_1());
13879
13880 }
13881
13882
13883 }
13884
13885 }
13886 catch (RecognitionException re) {
13887 reportError(re);
13888 recover(input,re);
13889 }
13890 finally {
13891
13892 restoreStackSize(stackSize);
13893
13894 }
13895 return ;
13896 }
13897 // $ANTLR end "rule__VLSAtomicFunction__Group_0_2_2__1__Impl"
13898
13899
13900 // $ANTLR start "rule__VLSAtomicFunction__Group_1__0"
13901 // InternalVampireLanguage.g:4483:1: rule__VLSAtomicFunction__Group_1__0 : rule__VLSAtomicFunction__Group_1__0__Impl rule__VLSAtomicFunction__Group_1__1 ;
13902 public final void rule__VLSAtomicFunction__Group_1__0() throws RecognitionException {
13903
13904 int stackSize = keepStackSize();
13905
13906 try {
13907 // InternalVampireLanguage.g:4487:1: ( rule__VLSAtomicFunction__Group_1__0__Impl rule__VLSAtomicFunction__Group_1__1 )
13908 // InternalVampireLanguage.g:4488:2: rule__VLSAtomicFunction__Group_1__0__Impl rule__VLSAtomicFunction__Group_1__1
13909 {
13910 pushFollow(FOLLOW_42);
13911 rule__VLSAtomicFunction__Group_1__0__Impl();
13912
13913 state._fsp--;
13914
13915 pushFollow(FOLLOW_2);
13916 rule__VLSAtomicFunction__Group_1__1();
13917
13918 state._fsp--;
13919
13920
13921 }
13922
13923 }
13924 catch (RecognitionException re) {
13925 reportError(re);
13926 recover(input,re);
13927 }
13928 finally {
13929
13930 restoreStackSize(stackSize);
13931
13932 }
13933 return ;
13934 }
13935 // $ANTLR end "rule__VLSAtomicFunction__Group_1__0"
13936
13937
13938 // $ANTLR start "rule__VLSAtomicFunction__Group_1__0__Impl"
13939 // InternalVampireLanguage.g:4495:1: rule__VLSAtomicFunction__Group_1__0__Impl : ( () ) ;
13940 public final void rule__VLSAtomicFunction__Group_1__0__Impl() throws RecognitionException {
13941
13942 int stackSize = keepStackSize();
13943
13944 try {
13945 // InternalVampireLanguage.g:4499:1: ( ( () ) )
13946 // InternalVampireLanguage.g:4500:1: ( () )
13947 {
13948 // InternalVampireLanguage.g:4500:1: ( () )
13949 // InternalVampireLanguage.g:4501:2: ()
13950 {
13951 before(grammarAccess.getVLSAtomicFunctionAccess().getVLSLessAction_1_0());
13952 // InternalVampireLanguage.g:4502:2: ()
13953 // InternalVampireLanguage.g:4502:3:
13954 {
13955 }
13956
13957 after(grammarAccess.getVLSAtomicFunctionAccess().getVLSLessAction_1_0());
13958
13959 }
13960
13961
13962 }
13963
13964 }
13965 finally {
13966
13967 restoreStackSize(stackSize);
13968
13969 }
13970 return ;
13971 }
13972 // $ANTLR end "rule__VLSAtomicFunction__Group_1__0__Impl"
13973
13974
13975 // $ANTLR start "rule__VLSAtomicFunction__Group_1__1"
13976 // InternalVampireLanguage.g:4510:1: rule__VLSAtomicFunction__Group_1__1 : rule__VLSAtomicFunction__Group_1__1__Impl rule__VLSAtomicFunction__Group_1__2 ;
13977 public final void rule__VLSAtomicFunction__Group_1__1() throws RecognitionException {
13978
13979 int stackSize = keepStackSize();
13980
13981 try {
13982 // InternalVampireLanguage.g:4514:1: ( rule__VLSAtomicFunction__Group_1__1__Impl rule__VLSAtomicFunction__Group_1__2 )
13983 // InternalVampireLanguage.g:4515:2: rule__VLSAtomicFunction__Group_1__1__Impl rule__VLSAtomicFunction__Group_1__2
13984 {
13985 pushFollow(FOLLOW_11);
13986 rule__VLSAtomicFunction__Group_1__1__Impl();
13987
13988 state._fsp--;
13989
13990 pushFollow(FOLLOW_2);
13991 rule__VLSAtomicFunction__Group_1__2();
13992
13993 state._fsp--;
13994
13995
13996 }
13997
13998 }
13999 catch (RecognitionException re) {
14000 reportError(re);
14001 recover(input,re);
14002 }
14003 finally {
14004
14005 restoreStackSize(stackSize);
14006
14007 }
14008 return ;
14009 }
14010 // $ANTLR end "rule__VLSAtomicFunction__Group_1__1"
14011
14012
14013 // $ANTLR start "rule__VLSAtomicFunction__Group_1__1__Impl"
14014 // InternalVampireLanguage.g:4522:1: rule__VLSAtomicFunction__Group_1__1__Impl : ( ( rule__VLSAtomicFunction__NameAssignment_1_1 ) ) ;
14015 public final void rule__VLSAtomicFunction__Group_1__1__Impl() throws RecognitionException {
14016
14017 int stackSize = keepStackSize();
14018
14019 try {
14020 // InternalVampireLanguage.g:4526:1: ( ( ( rule__VLSAtomicFunction__NameAssignment_1_1 ) ) )
14021 // InternalVampireLanguage.g:4527:1: ( ( rule__VLSAtomicFunction__NameAssignment_1_1 ) )
14022 {
14023 // InternalVampireLanguage.g:4527:1: ( ( rule__VLSAtomicFunction__NameAssignment_1_1 ) )
14024 // InternalVampireLanguage.g:4528:2: ( rule__VLSAtomicFunction__NameAssignment_1_1 )
14025 {
14026 before(grammarAccess.getVLSAtomicFunctionAccess().getNameAssignment_1_1());
14027 // InternalVampireLanguage.g:4529:2: ( rule__VLSAtomicFunction__NameAssignment_1_1 )
14028 // InternalVampireLanguage.g:4529:3: rule__VLSAtomicFunction__NameAssignment_1_1
14029 {
14030 pushFollow(FOLLOW_2);
14031 rule__VLSAtomicFunction__NameAssignment_1_1();
14032
14033 state._fsp--;
14034
14035
14036 }
14037
14038 after(grammarAccess.getVLSAtomicFunctionAccess().getNameAssignment_1_1());
14039
14040 }
14041
14042
14043 }
14044
14045 }
14046 catch (RecognitionException re) {
14047 reportError(re);
14048 recover(input,re);
14049 }
14050 finally {
14051
14052 restoreStackSize(stackSize);
14053
14054 }
14055 return ;
14056 }
14057 // $ANTLR end "rule__VLSAtomicFunction__Group_1__1__Impl"
14058
14059
14060 // $ANTLR start "rule__VLSAtomicFunction__Group_1__2"
14061 // InternalVampireLanguage.g:4537:1: rule__VLSAtomicFunction__Group_1__2 : rule__VLSAtomicFunction__Group_1__2__Impl rule__VLSAtomicFunction__Group_1__3 ;
14062 public final void rule__VLSAtomicFunction__Group_1__2() throws RecognitionException {
14063
14064 int stackSize = keepStackSize();
14065
14066 try {
14067 // InternalVampireLanguage.g:4541:1: ( rule__VLSAtomicFunction__Group_1__2__Impl rule__VLSAtomicFunction__Group_1__3 )
14068 // InternalVampireLanguage.g:4542:2: rule__VLSAtomicFunction__Group_1__2__Impl rule__VLSAtomicFunction__Group_1__3
14069 {
14070 pushFollow(FOLLOW_36);
14071 rule__VLSAtomicFunction__Group_1__2__Impl();
14072
14073 state._fsp--;
14074
14075 pushFollow(FOLLOW_2);
14076 rule__VLSAtomicFunction__Group_1__3();
14077
14078 state._fsp--;
14079
14080
14081 }
14082
14083 }
14084 catch (RecognitionException re) {
14085 reportError(re);
14086 recover(input,re);
14087 }
14088 finally {
14089
14090 restoreStackSize(stackSize);
14091
14092 }
14093 return ;
14094 }
14095 // $ANTLR end "rule__VLSAtomicFunction__Group_1__2"
14096
14097
14098 // $ANTLR start "rule__VLSAtomicFunction__Group_1__2__Impl"
14099 // InternalVampireLanguage.g:4549:1: rule__VLSAtomicFunction__Group_1__2__Impl : ( '(' ) ;
14100 public final void rule__VLSAtomicFunction__Group_1__2__Impl() throws RecognitionException {
14101
14102 int stackSize = keepStackSize();
14103
14104 try {
14105 // InternalVampireLanguage.g:4553:1: ( ( '(' ) )
14106 // InternalVampireLanguage.g:4554:1: ( '(' )
14107 {
14108 // InternalVampireLanguage.g:4554:1: ( '(' )
14109 // InternalVampireLanguage.g:4555:2: '('
14110 {
14111 before(grammarAccess.getVLSAtomicFunctionAccess().getLeftParenthesisKeyword_1_2());
14112 match(input,47,FOLLOW_2);
14113 after(grammarAccess.getVLSAtomicFunctionAccess().getLeftParenthesisKeyword_1_2());
14114
14115 }
14116
14117
14118 }
14119
14120 }
14121 catch (RecognitionException re) {
14122 reportError(re);
14123 recover(input,re);
14124 }
14125 finally {
14126
14127 restoreStackSize(stackSize);
14128
14129 }
14130 return ;
14131 }
14132 // $ANTLR end "rule__VLSAtomicFunction__Group_1__2__Impl"
14133
14134
14135 // $ANTLR start "rule__VLSAtomicFunction__Group_1__3"
14136 // InternalVampireLanguage.g:4564:1: rule__VLSAtomicFunction__Group_1__3 : rule__VLSAtomicFunction__Group_1__3__Impl rule__VLSAtomicFunction__Group_1__4 ;
14137 public final void rule__VLSAtomicFunction__Group_1__3() throws RecognitionException {
14138
14139 int stackSize = keepStackSize();
14140
14141 try {
14142 // InternalVampireLanguage.g:4568:1: ( rule__VLSAtomicFunction__Group_1__3__Impl rule__VLSAtomicFunction__Group_1__4 )
14143 // InternalVampireLanguage.g:4569:2: rule__VLSAtomicFunction__Group_1__3__Impl rule__VLSAtomicFunction__Group_1__4
14144 {
14145 pushFollow(FOLLOW_13);
14146 rule__VLSAtomicFunction__Group_1__3__Impl();
14147
14148 state._fsp--;
14149
14150 pushFollow(FOLLOW_2);
14151 rule__VLSAtomicFunction__Group_1__4();
14152
14153 state._fsp--;
14154
14155
14156 }
14157
14158 }
14159 catch (RecognitionException re) {
14160 reportError(re);
14161 recover(input,re);
14162 }
14163 finally {
14164
14165 restoreStackSize(stackSize);
14166
14167 }
14168 return ;
14169 }
14170 // $ANTLR end "rule__VLSAtomicFunction__Group_1__3"
14171
14172
14173 // $ANTLR start "rule__VLSAtomicFunction__Group_1__3__Impl"
14174 // InternalVampireLanguage.g:4576:1: rule__VLSAtomicFunction__Group_1__3__Impl : ( ( rule__VLSAtomicFunction__TermsAssignment_1_3 ) ) ;
14175 public final void rule__VLSAtomicFunction__Group_1__3__Impl() throws RecognitionException {
14176
14177 int stackSize = keepStackSize();
14178
14179 try {
14180 // InternalVampireLanguage.g:4580:1: ( ( ( rule__VLSAtomicFunction__TermsAssignment_1_3 ) ) )
14181 // InternalVampireLanguage.g:4581:1: ( ( rule__VLSAtomicFunction__TermsAssignment_1_3 ) )
14182 {
14183 // InternalVampireLanguage.g:4581:1: ( ( rule__VLSAtomicFunction__TermsAssignment_1_3 ) )
14184 // InternalVampireLanguage.g:4582:2: ( rule__VLSAtomicFunction__TermsAssignment_1_3 )
14185 {
14186 before(grammarAccess.getVLSAtomicFunctionAccess().getTermsAssignment_1_3());
14187 // InternalVampireLanguage.g:4583:2: ( rule__VLSAtomicFunction__TermsAssignment_1_3 )
14188 // InternalVampireLanguage.g:4583:3: rule__VLSAtomicFunction__TermsAssignment_1_3
14189 {
14190 pushFollow(FOLLOW_2);
14191 rule__VLSAtomicFunction__TermsAssignment_1_3();
14192
14193 state._fsp--;
14194
14195
14196 }
14197
14198 after(grammarAccess.getVLSAtomicFunctionAccess().getTermsAssignment_1_3());
14199
14200 }
14201
14202
14203 }
14204
14205 }
14206 catch (RecognitionException re) {
14207 reportError(re);
14208 recover(input,re);
14209 }
14210 finally {
14211
14212 restoreStackSize(stackSize);
14213
14214 }
14215 return ;
14216 }
14217 // $ANTLR end "rule__VLSAtomicFunction__Group_1__3__Impl"
14218
14219
14220 // $ANTLR start "rule__VLSAtomicFunction__Group_1__4"
14221 // InternalVampireLanguage.g:4591:1: rule__VLSAtomicFunction__Group_1__4 : rule__VLSAtomicFunction__Group_1__4__Impl rule__VLSAtomicFunction__Group_1__5 ;
14222 public final void rule__VLSAtomicFunction__Group_1__4() throws RecognitionException {
14223
14224 int stackSize = keepStackSize();
14225
14226 try {
14227 // InternalVampireLanguage.g:4595:1: ( rule__VLSAtomicFunction__Group_1__4__Impl rule__VLSAtomicFunction__Group_1__5 )
14228 // InternalVampireLanguage.g:4596:2: rule__VLSAtomicFunction__Group_1__4__Impl rule__VLSAtomicFunction__Group_1__5
14229 {
14230 pushFollow(FOLLOW_36);
14231 rule__VLSAtomicFunction__Group_1__4__Impl();
14232
14233 state._fsp--;
14234
14235 pushFollow(FOLLOW_2);
14236 rule__VLSAtomicFunction__Group_1__5();
14237
14238 state._fsp--;
14239
14240
14241 }
14242
14243 }
14244 catch (RecognitionException re) {
14245 reportError(re);
14246 recover(input,re);
14247 }
14248 finally {
14249
14250 restoreStackSize(stackSize);
14251
14252 }
14253 return ;
14254 }
14255 // $ANTLR end "rule__VLSAtomicFunction__Group_1__4"
14256
14257
14258 // $ANTLR start "rule__VLSAtomicFunction__Group_1__4__Impl"
14259 // InternalVampireLanguage.g:4603:1: rule__VLSAtomicFunction__Group_1__4__Impl : ( ',' ) ;
14260 public final void rule__VLSAtomicFunction__Group_1__4__Impl() throws RecognitionException {
14261
14262 int stackSize = keepStackSize();
14263
14264 try {
14265 // InternalVampireLanguage.g:4607:1: ( ( ',' ) )
14266 // InternalVampireLanguage.g:4608:1: ( ',' )
14267 {
14268 // InternalVampireLanguage.g:4608:1: ( ',' )
14269 // InternalVampireLanguage.g:4609:2: ','
14270 {
14271 before(grammarAccess.getVLSAtomicFunctionAccess().getCommaKeyword_1_4());
14272 match(input,45,FOLLOW_2);
14273 after(grammarAccess.getVLSAtomicFunctionAccess().getCommaKeyword_1_4());
14274
14275 }
14276
14277
14278 }
14279
14280 }
14281 catch (RecognitionException re) {
14282 reportError(re);
14283 recover(input,re);
14284 }
14285 finally {
14286
14287 restoreStackSize(stackSize);
14288
14289 }
14290 return ;
14291 }
14292 // $ANTLR end "rule__VLSAtomicFunction__Group_1__4__Impl"
14293
14294
14295 // $ANTLR start "rule__VLSAtomicFunction__Group_1__5"
14296 // InternalVampireLanguage.g:4618:1: rule__VLSAtomicFunction__Group_1__5 : rule__VLSAtomicFunction__Group_1__5__Impl rule__VLSAtomicFunction__Group_1__6 ;
14297 public final void rule__VLSAtomicFunction__Group_1__5() throws RecognitionException {
14298
14299 int stackSize = keepStackSize();
14300
14301 try {
14302 // InternalVampireLanguage.g:4622:1: ( rule__VLSAtomicFunction__Group_1__5__Impl rule__VLSAtomicFunction__Group_1__6 )
14303 // InternalVampireLanguage.g:4623:2: rule__VLSAtomicFunction__Group_1__5__Impl rule__VLSAtomicFunction__Group_1__6
14304 {
14305 pushFollow(FOLLOW_19);
14306 rule__VLSAtomicFunction__Group_1__5__Impl();
14307
14308 state._fsp--;
14309
14310 pushFollow(FOLLOW_2);
14311 rule__VLSAtomicFunction__Group_1__6();
14312
14313 state._fsp--;
14314
14315
14316 }
14317
14318 }
14319 catch (RecognitionException re) {
14320 reportError(re);
14321 recover(input,re);
14322 }
14323 finally {
14324
14325 restoreStackSize(stackSize);
14326
14327 }
14328 return ;
14329 }
14330 // $ANTLR end "rule__VLSAtomicFunction__Group_1__5"
14331
14332
14333 // $ANTLR start "rule__VLSAtomicFunction__Group_1__5__Impl"
14334 // InternalVampireLanguage.g:4630:1: rule__VLSAtomicFunction__Group_1__5__Impl : ( ( rule__VLSAtomicFunction__TermsAssignment_1_5 ) ) ;
14335 public final void rule__VLSAtomicFunction__Group_1__5__Impl() throws RecognitionException {
14336
14337 int stackSize = keepStackSize();
14338
14339 try {
14340 // InternalVampireLanguage.g:4634:1: ( ( ( rule__VLSAtomicFunction__TermsAssignment_1_5 ) ) )
14341 // InternalVampireLanguage.g:4635:1: ( ( rule__VLSAtomicFunction__TermsAssignment_1_5 ) )
14342 {
14343 // InternalVampireLanguage.g:4635:1: ( ( rule__VLSAtomicFunction__TermsAssignment_1_5 ) )
14344 // InternalVampireLanguage.g:4636:2: ( rule__VLSAtomicFunction__TermsAssignment_1_5 )
14345 {
14346 before(grammarAccess.getVLSAtomicFunctionAccess().getTermsAssignment_1_5());
14347 // InternalVampireLanguage.g:4637:2: ( rule__VLSAtomicFunction__TermsAssignment_1_5 )
14348 // InternalVampireLanguage.g:4637:3: rule__VLSAtomicFunction__TermsAssignment_1_5
14349 {
14350 pushFollow(FOLLOW_2);
14351 rule__VLSAtomicFunction__TermsAssignment_1_5();
14352
14353 state._fsp--;
14354
14355
14356 }
14357
14358 after(grammarAccess.getVLSAtomicFunctionAccess().getTermsAssignment_1_5());
14359
14360 }
14361
14362
14363 }
14364
14365 }
14366 catch (RecognitionException re) {
14367 reportError(re);
14368 recover(input,re);
14369 }
14370 finally {
14371
14372 restoreStackSize(stackSize);
14373
14374 }
14375 return ;
14376 }
14377 // $ANTLR end "rule__VLSAtomicFunction__Group_1__5__Impl"
14378
14379
14380 // $ANTLR start "rule__VLSAtomicFunction__Group_1__6"
14381 // InternalVampireLanguage.g:4645:1: rule__VLSAtomicFunction__Group_1__6 : rule__VLSAtomicFunction__Group_1__6__Impl ;
14382 public final void rule__VLSAtomicFunction__Group_1__6() throws RecognitionException {
14383
14384 int stackSize = keepStackSize();
14385
14386 try {
14387 // InternalVampireLanguage.g:4649:1: ( rule__VLSAtomicFunction__Group_1__6__Impl )
14388 // InternalVampireLanguage.g:4650:2: rule__VLSAtomicFunction__Group_1__6__Impl
14389 {
14390 pushFollow(FOLLOW_2);
14391 rule__VLSAtomicFunction__Group_1__6__Impl();
14392
14393 state._fsp--;
14394
14395
14396 }
14397
14398 }
14399 catch (RecognitionException re) {
14400 reportError(re);
14401 recover(input,re);
14402 }
14403 finally {
14404
14405 restoreStackSize(stackSize);
14406
14407 }
14408 return ;
14409 }
14410 // $ANTLR end "rule__VLSAtomicFunction__Group_1__6"
14411
14412
14413 // $ANTLR start "rule__VLSAtomicFunction__Group_1__6__Impl"
14414 // InternalVampireLanguage.g:4656:1: rule__VLSAtomicFunction__Group_1__6__Impl : ( ')' ) ;
14415 public final void rule__VLSAtomicFunction__Group_1__6__Impl() throws RecognitionException {
14416
14417 int stackSize = keepStackSize();
14418
14419 try {
14420 // InternalVampireLanguage.g:4660:1: ( ( ')' ) )
14421 // InternalVampireLanguage.g:4661:1: ( ')' )
14422 {
14423 // InternalVampireLanguage.g:4661:1: ( ')' )
14424 // InternalVampireLanguage.g:4662:2: ')'
14425 {
14426 before(grammarAccess.getVLSAtomicFunctionAccess().getRightParenthesisKeyword_1_6());
14427 match(input,48,FOLLOW_2);
14428 after(grammarAccess.getVLSAtomicFunctionAccess().getRightParenthesisKeyword_1_6());
14429
14430 }
14431
14432
14433 }
14434
14435 }
14436 catch (RecognitionException re) {
14437 reportError(re);
14438 recover(input,re);
14439 }
14440 finally {
14441
14442 restoreStackSize(stackSize);
14443
14444 }
14445 return ;
14446 }
14447 // $ANTLR end "rule__VLSAtomicFunction__Group_1__6__Impl"
14448
14449
14450 // $ANTLR start "rule__VLSFunctionFof__Group__0"
14451 // InternalVampireLanguage.g:4672:1: rule__VLSFunctionFof__Group__0 : rule__VLSFunctionFof__Group__0__Impl rule__VLSFunctionFof__Group__1 ;
14452 public final void rule__VLSFunctionFof__Group__0() throws RecognitionException {
14453
14454 int stackSize = keepStackSize();
14455
14456 try {
14457 // InternalVampireLanguage.g:4676:1: ( rule__VLSFunctionFof__Group__0__Impl rule__VLSFunctionFof__Group__1 )
14458 // InternalVampireLanguage.g:4677:2: rule__VLSFunctionFof__Group__0__Impl rule__VLSFunctionFof__Group__1
14459 {
14460 pushFollow(FOLLOW_11);
14461 rule__VLSFunctionFof__Group__0__Impl();
14462
14463 state._fsp--;
14464
14465 pushFollow(FOLLOW_2);
14466 rule__VLSFunctionFof__Group__1();
14467
14468 state._fsp--;
14469
14470
14471 }
14472
14473 }
14474 catch (RecognitionException re) {
14475 reportError(re);
14476 recover(input,re);
14477 }
14478 finally {
14479
14480 restoreStackSize(stackSize);
14481
14482 }
14483 return ;
14484 }
14485 // $ANTLR end "rule__VLSFunctionFof__Group__0"
14486
14487
14488 // $ANTLR start "rule__VLSFunctionFof__Group__0__Impl"
14489 // InternalVampireLanguage.g:4684:1: rule__VLSFunctionFof__Group__0__Impl : ( ( rule__VLSFunctionFof__FunctorAssignment_0 ) ) ;
14490 public final void rule__VLSFunctionFof__Group__0__Impl() throws RecognitionException {
14491
14492 int stackSize = keepStackSize();
14493
14494 try {
14495 // InternalVampireLanguage.g:4688:1: ( ( ( rule__VLSFunctionFof__FunctorAssignment_0 ) ) )
14496 // InternalVampireLanguage.g:4689:1: ( ( rule__VLSFunctionFof__FunctorAssignment_0 ) )
14497 {
14498 // InternalVampireLanguage.g:4689:1: ( ( rule__VLSFunctionFof__FunctorAssignment_0 ) )
14499 // InternalVampireLanguage.g:4690:2: ( rule__VLSFunctionFof__FunctorAssignment_0 )
14500 {
14501 before(grammarAccess.getVLSFunctionFofAccess().getFunctorAssignment_0());
14502 // InternalVampireLanguage.g:4691:2: ( rule__VLSFunctionFof__FunctorAssignment_0 )
14503 // InternalVampireLanguage.g:4691:3: rule__VLSFunctionFof__FunctorAssignment_0
14504 {
14505 pushFollow(FOLLOW_2);
14506 rule__VLSFunctionFof__FunctorAssignment_0();
14507
14508 state._fsp--;
14509
14510
14511 }
14512
14513 after(grammarAccess.getVLSFunctionFofAccess().getFunctorAssignment_0());
14514
14515 }
14516
14517
14518 }
14519
14520 }
14521 catch (RecognitionException re) {
14522 reportError(re);
14523 recover(input,re);
14524 }
14525 finally {
14526
14527 restoreStackSize(stackSize);
14528
14529 }
14530 return ;
14531 }
14532 // $ANTLR end "rule__VLSFunctionFof__Group__0__Impl"
14533
14534
14535 // $ANTLR start "rule__VLSFunctionFof__Group__1"
14536 // InternalVampireLanguage.g:4699:1: rule__VLSFunctionFof__Group__1 : rule__VLSFunctionFof__Group__1__Impl ;
14537 public final void rule__VLSFunctionFof__Group__1() throws RecognitionException {
14538
14539 int stackSize = keepStackSize();
14540
14541 try {
14542 // InternalVampireLanguage.g:4703:1: ( rule__VLSFunctionFof__Group__1__Impl )
14543 // InternalVampireLanguage.g:4704:2: rule__VLSFunctionFof__Group__1__Impl
14544 {
14545 pushFollow(FOLLOW_2);
14546 rule__VLSFunctionFof__Group__1__Impl();
14547
14548 state._fsp--;
14549
14550
14551 }
14552
14553 }
14554 catch (RecognitionException re) {
14555 reportError(re);
14556 recover(input,re);
14557 }
14558 finally {
14559
14560 restoreStackSize(stackSize);
14561
14562 }
14563 return ;
14564 }
14565 // $ANTLR end "rule__VLSFunctionFof__Group__1"
14566
14567
14568 // $ANTLR start "rule__VLSFunctionFof__Group__1__Impl"
14569 // InternalVampireLanguage.g:4710:1: rule__VLSFunctionFof__Group__1__Impl : ( ( rule__VLSFunctionFof__Group_1__0 )? ) ;
14570 public final void rule__VLSFunctionFof__Group__1__Impl() throws RecognitionException {
14571
14572 int stackSize = keepStackSize();
14573
14574 try {
14575 // InternalVampireLanguage.g:4714:1: ( ( ( rule__VLSFunctionFof__Group_1__0 )? ) )
14576 // InternalVampireLanguage.g:4715:1: ( ( rule__VLSFunctionFof__Group_1__0 )? )
14577 {
14578 // InternalVampireLanguage.g:4715:1: ( ( rule__VLSFunctionFof__Group_1__0 )? )
14579 // InternalVampireLanguage.g:4716:2: ( rule__VLSFunctionFof__Group_1__0 )?
14580 {
14581 before(grammarAccess.getVLSFunctionFofAccess().getGroup_1());
14582 // InternalVampireLanguage.g:4717:2: ( rule__VLSFunctionFof__Group_1__0 )?
14583 int alt34=2;
14584 int LA34_0 = input.LA(1);
14585
14586 if ( (LA34_0==47) ) {
14587 alt34=1;
14588 }
14589 switch (alt34) {
14590 case 1 :
14591 // InternalVampireLanguage.g:4717:3: rule__VLSFunctionFof__Group_1__0
14592 {
14593 pushFollow(FOLLOW_2);
14594 rule__VLSFunctionFof__Group_1__0();
14595
14596 state._fsp--;
14597
14598
14599 }
14600 break;
14601
14602 }
14603
14604 after(grammarAccess.getVLSFunctionFofAccess().getGroup_1());
14605
14606 }
14607
14608
14609 }
14610
14611 }
14612 catch (RecognitionException re) {
14613 reportError(re);
14614 recover(input,re);
14615 }
14616 finally {
14617
14618 restoreStackSize(stackSize);
14619
14620 }
14621 return ;
14622 }
14623 // $ANTLR end "rule__VLSFunctionFof__Group__1__Impl"
14624
14625
14626 // $ANTLR start "rule__VLSFunctionFof__Group_1__0"
14627 // InternalVampireLanguage.g:4726:1: rule__VLSFunctionFof__Group_1__0 : rule__VLSFunctionFof__Group_1__0__Impl rule__VLSFunctionFof__Group_1__1 ;
14628 public final void rule__VLSFunctionFof__Group_1__0() throws RecognitionException {
14629
14630 int stackSize = keepStackSize();
14631
14632 try {
14633 // InternalVampireLanguage.g:4730:1: ( rule__VLSFunctionFof__Group_1__0__Impl rule__VLSFunctionFof__Group_1__1 )
14634 // InternalVampireLanguage.g:4731:2: rule__VLSFunctionFof__Group_1__0__Impl rule__VLSFunctionFof__Group_1__1
14635 {
14636 pushFollow(FOLLOW_36);
14637 rule__VLSFunctionFof__Group_1__0__Impl();
14638
14639 state._fsp--;
14640
14641 pushFollow(FOLLOW_2);
14642 rule__VLSFunctionFof__Group_1__1();
14643
14644 state._fsp--;
14645
14646
14647 }
14648
14649 }
14650 catch (RecognitionException re) {
14651 reportError(re);
14652 recover(input,re);
14653 }
14654 finally {
14655
14656 restoreStackSize(stackSize);
14657
14658 }
14659 return ;
14660 }
14661 // $ANTLR end "rule__VLSFunctionFof__Group_1__0"
14662
14663
14664 // $ANTLR start "rule__VLSFunctionFof__Group_1__0__Impl"
14665 // InternalVampireLanguage.g:4738:1: rule__VLSFunctionFof__Group_1__0__Impl : ( '(' ) ;
14666 public final void rule__VLSFunctionFof__Group_1__0__Impl() throws RecognitionException {
14667
14668 int stackSize = keepStackSize();
14669
14670 try {
14671 // InternalVampireLanguage.g:4742:1: ( ( '(' ) )
14672 // InternalVampireLanguage.g:4743:1: ( '(' )
14673 {
14674 // InternalVampireLanguage.g:4743:1: ( '(' )
14675 // InternalVampireLanguage.g:4744:2: '('
14676 {
14677 before(grammarAccess.getVLSFunctionFofAccess().getLeftParenthesisKeyword_1_0());
14678 match(input,47,FOLLOW_2);
14679 after(grammarAccess.getVLSFunctionFofAccess().getLeftParenthesisKeyword_1_0());
14680
14681 }
14682
14683
14684 }
14685
14686 }
14687 catch (RecognitionException re) {
14688 reportError(re);
14689 recover(input,re);
14690 }
14691 finally {
14692
14693 restoreStackSize(stackSize);
14694
14695 }
14696 return ;
14697 }
14698 // $ANTLR end "rule__VLSFunctionFof__Group_1__0__Impl"
14699
14700
14701 // $ANTLR start "rule__VLSFunctionFof__Group_1__1"
14702 // InternalVampireLanguage.g:4753:1: rule__VLSFunctionFof__Group_1__1 : rule__VLSFunctionFof__Group_1__1__Impl rule__VLSFunctionFof__Group_1__2 ;
14703 public final void rule__VLSFunctionFof__Group_1__1() throws RecognitionException {
14704
14705 int stackSize = keepStackSize();
14706
14707 try {
14708 // InternalVampireLanguage.g:4757:1: ( rule__VLSFunctionFof__Group_1__1__Impl rule__VLSFunctionFof__Group_1__2 )
14709 // InternalVampireLanguage.g:4758:2: rule__VLSFunctionFof__Group_1__1__Impl rule__VLSFunctionFof__Group_1__2
14710 {
14711 pushFollow(FOLLOW_16);
14712 rule__VLSFunctionFof__Group_1__1__Impl();
14713
14714 state._fsp--;
14715
14716 pushFollow(FOLLOW_2);
14717 rule__VLSFunctionFof__Group_1__2();
14718
14719 state._fsp--;
14720
14721
14722 }
14723
14724 }
14725 catch (RecognitionException re) {
14726 reportError(re);
14727 recover(input,re);
14728 }
14729 finally {
14730
14731 restoreStackSize(stackSize);
14732
14733 }
14734 return ;
14735 }
14736 // $ANTLR end "rule__VLSFunctionFof__Group_1__1"
14737
14738
14739 // $ANTLR start "rule__VLSFunctionFof__Group_1__1__Impl"
14740 // InternalVampireLanguage.g:4765:1: rule__VLSFunctionFof__Group_1__1__Impl : ( ( rule__VLSFunctionFof__TermsAssignment_1_1 ) ) ;
14741 public final void rule__VLSFunctionFof__Group_1__1__Impl() throws RecognitionException {
14742
14743 int stackSize = keepStackSize();
14744
14745 try {
14746 // InternalVampireLanguage.g:4769:1: ( ( ( rule__VLSFunctionFof__TermsAssignment_1_1 ) ) )
14747 // InternalVampireLanguage.g:4770:1: ( ( rule__VLSFunctionFof__TermsAssignment_1_1 ) )
14748 {
14749 // InternalVampireLanguage.g:4770:1: ( ( rule__VLSFunctionFof__TermsAssignment_1_1 ) )
14750 // InternalVampireLanguage.g:4771:2: ( rule__VLSFunctionFof__TermsAssignment_1_1 )
14751 {
14752 before(grammarAccess.getVLSFunctionFofAccess().getTermsAssignment_1_1());
14753 // InternalVampireLanguage.g:4772:2: ( rule__VLSFunctionFof__TermsAssignment_1_1 )
14754 // InternalVampireLanguage.g:4772:3: rule__VLSFunctionFof__TermsAssignment_1_1
14755 {
14756 pushFollow(FOLLOW_2);
14757 rule__VLSFunctionFof__TermsAssignment_1_1();
14758
14759 state._fsp--;
14760
14761
14762 }
14763
14764 after(grammarAccess.getVLSFunctionFofAccess().getTermsAssignment_1_1());
14765
14766 }
14767
14768
14769 }
14770
14771 }
14772 catch (RecognitionException re) {
14773 reportError(re);
14774 recover(input,re);
14775 }
14776 finally {
14777
14778 restoreStackSize(stackSize);
14779
14780 }
14781 return ;
14782 }
14783 // $ANTLR end "rule__VLSFunctionFof__Group_1__1__Impl"
14784
14785
14786 // $ANTLR start "rule__VLSFunctionFof__Group_1__2"
14787 // InternalVampireLanguage.g:4780:1: rule__VLSFunctionFof__Group_1__2 : rule__VLSFunctionFof__Group_1__2__Impl rule__VLSFunctionFof__Group_1__3 ;
14788 public final void rule__VLSFunctionFof__Group_1__2() throws RecognitionException {
14789
14790 int stackSize = keepStackSize();
14791
14792 try {
14793 // InternalVampireLanguage.g:4784:1: ( rule__VLSFunctionFof__Group_1__2__Impl rule__VLSFunctionFof__Group_1__3 )
14794 // InternalVampireLanguage.g:4785:2: rule__VLSFunctionFof__Group_1__2__Impl rule__VLSFunctionFof__Group_1__3
14795 {
14796 pushFollow(FOLLOW_16);
14797 rule__VLSFunctionFof__Group_1__2__Impl();
14798
14799 state._fsp--;
14800
14801 pushFollow(FOLLOW_2);
14802 rule__VLSFunctionFof__Group_1__3();
14803
14804 state._fsp--;
14805
14806
14807 }
14808
14809 }
14810 catch (RecognitionException re) {
14811 reportError(re);
14812 recover(input,re);
14813 }
14814 finally {
14815
14816 restoreStackSize(stackSize);
14817
14818 }
14819 return ;
14820 }
14821 // $ANTLR end "rule__VLSFunctionFof__Group_1__2"
14822
14823
14824 // $ANTLR start "rule__VLSFunctionFof__Group_1__2__Impl"
14825 // InternalVampireLanguage.g:4792:1: rule__VLSFunctionFof__Group_1__2__Impl : ( ( rule__VLSFunctionFof__Group_1_2__0 )* ) ;
14826 public final void rule__VLSFunctionFof__Group_1__2__Impl() throws RecognitionException {
14827
14828 int stackSize = keepStackSize();
14829
14830 try {
14831 // InternalVampireLanguage.g:4796:1: ( ( ( rule__VLSFunctionFof__Group_1_2__0 )* ) )
14832 // InternalVampireLanguage.g:4797:1: ( ( rule__VLSFunctionFof__Group_1_2__0 )* )
14833 {
14834 // InternalVampireLanguage.g:4797:1: ( ( rule__VLSFunctionFof__Group_1_2__0 )* )
14835 // InternalVampireLanguage.g:4798:2: ( rule__VLSFunctionFof__Group_1_2__0 )*
14836 {
14837 before(grammarAccess.getVLSFunctionFofAccess().getGroup_1_2());
14838 // InternalVampireLanguage.g:4799:2: ( rule__VLSFunctionFof__Group_1_2__0 )*
14839 loop35:
14840 do {
14841 int alt35=2;
14842 int LA35_0 = input.LA(1);
14843
14844 if ( (LA35_0==45) ) {
14845 alt35=1;
14846 }
14847
14848
14849 switch (alt35) {
14850 case 1 :
14851 // InternalVampireLanguage.g:4799:3: rule__VLSFunctionFof__Group_1_2__0
14852 {
14853 pushFollow(FOLLOW_10);
14854 rule__VLSFunctionFof__Group_1_2__0();
14855
14856 state._fsp--;
14857
14858
14859 }
14860 break;
14861
14862 default :
14863 break loop35;
14864 }
14865 } while (true);
14866
14867 after(grammarAccess.getVLSFunctionFofAccess().getGroup_1_2());
14868
14869 }
14870
14871
14872 }
14873
14874 }
14875 catch (RecognitionException re) {
14876 reportError(re);
14877 recover(input,re);
14878 }
14879 finally {
14880
14881 restoreStackSize(stackSize);
14882
14883 }
14884 return ;
14885 }
14886 // $ANTLR end "rule__VLSFunctionFof__Group_1__2__Impl"
14887
14888
14889 // $ANTLR start "rule__VLSFunctionFof__Group_1__3"
14890 // InternalVampireLanguage.g:4807:1: rule__VLSFunctionFof__Group_1__3 : rule__VLSFunctionFof__Group_1__3__Impl ;
14891 public final void rule__VLSFunctionFof__Group_1__3() throws RecognitionException {
14892
14893 int stackSize = keepStackSize();
14894
14895 try {
14896 // InternalVampireLanguage.g:4811:1: ( rule__VLSFunctionFof__Group_1__3__Impl )
14897 // InternalVampireLanguage.g:4812:2: rule__VLSFunctionFof__Group_1__3__Impl
14898 {
14899 pushFollow(FOLLOW_2);
14900 rule__VLSFunctionFof__Group_1__3__Impl();
14901
14902 state._fsp--;
14903
14904
14905 }
14906
14907 }
14908 catch (RecognitionException re) {
14909 reportError(re);
14910 recover(input,re);
14911 }
14912 finally {
14913
14914 restoreStackSize(stackSize);
14915
14916 }
14917 return ;
14918 }
14919 // $ANTLR end "rule__VLSFunctionFof__Group_1__3"
14920
14921
14922 // $ANTLR start "rule__VLSFunctionFof__Group_1__3__Impl"
14923 // InternalVampireLanguage.g:4818:1: rule__VLSFunctionFof__Group_1__3__Impl : ( ')' ) ;
14924 public final void rule__VLSFunctionFof__Group_1__3__Impl() throws RecognitionException {
14925
14926 int stackSize = keepStackSize();
14927
14928 try {
14929 // InternalVampireLanguage.g:4822:1: ( ( ')' ) )
14930 // InternalVampireLanguage.g:4823:1: ( ')' )
14931 {
14932 // InternalVampireLanguage.g:4823:1: ( ')' )
14933 // InternalVampireLanguage.g:4824:2: ')'
14934 {
14935 before(grammarAccess.getVLSFunctionFofAccess().getRightParenthesisKeyword_1_3());
14936 match(input,48,FOLLOW_2);
14937 after(grammarAccess.getVLSFunctionFofAccess().getRightParenthesisKeyword_1_3());
14938
14939 }
14940
14941
14942 }
14943
14944 }
14945 catch (RecognitionException re) {
14946 reportError(re);
14947 recover(input,re);
14948 }
14949 finally {
14950
14951 restoreStackSize(stackSize);
14952
14953 }
14954 return ;
14955 }
14956 // $ANTLR end "rule__VLSFunctionFof__Group_1__3__Impl"
14957
14958
14959 // $ANTLR start "rule__VLSFunctionFof__Group_1_2__0"
14960 // InternalVampireLanguage.g:4834:1: rule__VLSFunctionFof__Group_1_2__0 : rule__VLSFunctionFof__Group_1_2__0__Impl rule__VLSFunctionFof__Group_1_2__1 ;
14961 public final void rule__VLSFunctionFof__Group_1_2__0() throws RecognitionException {
14962
14963 int stackSize = keepStackSize();
14964
14965 try {
14966 // InternalVampireLanguage.g:4838:1: ( rule__VLSFunctionFof__Group_1_2__0__Impl rule__VLSFunctionFof__Group_1_2__1 )
14967 // InternalVampireLanguage.g:4839:2: rule__VLSFunctionFof__Group_1_2__0__Impl rule__VLSFunctionFof__Group_1_2__1
14968 {
14969 pushFollow(FOLLOW_36);
14970 rule__VLSFunctionFof__Group_1_2__0__Impl();
14971
14972 state._fsp--;
14973
14974 pushFollow(FOLLOW_2);
14975 rule__VLSFunctionFof__Group_1_2__1();
14976
14977 state._fsp--;
14978
14979
14980 }
14981
14982 }
14983 catch (RecognitionException re) {
14984 reportError(re);
14985 recover(input,re);
14986 }
14987 finally {
14988
14989 restoreStackSize(stackSize);
14990
14991 }
14992 return ;
14993 }
14994 // $ANTLR end "rule__VLSFunctionFof__Group_1_2__0"
14995
14996
14997 // $ANTLR start "rule__VLSFunctionFof__Group_1_2__0__Impl"
14998 // InternalVampireLanguage.g:4846:1: rule__VLSFunctionFof__Group_1_2__0__Impl : ( ',' ) ;
14999 public final void rule__VLSFunctionFof__Group_1_2__0__Impl() throws RecognitionException {
15000
15001 int stackSize = keepStackSize();
15002
15003 try {
15004 // InternalVampireLanguage.g:4850:1: ( ( ',' ) )
15005 // InternalVampireLanguage.g:4851:1: ( ',' )
15006 {
15007 // InternalVampireLanguage.g:4851:1: ( ',' )
15008 // InternalVampireLanguage.g:4852:2: ','
15009 {
15010 before(grammarAccess.getVLSFunctionFofAccess().getCommaKeyword_1_2_0());
15011 match(input,45,FOLLOW_2);
15012 after(grammarAccess.getVLSFunctionFofAccess().getCommaKeyword_1_2_0());
15013
15014 }
15015
15016
15017 }
15018
15019 }
15020 catch (RecognitionException re) {
15021 reportError(re);
15022 recover(input,re);
15023 }
15024 finally {
15025
15026 restoreStackSize(stackSize);
15027
15028 }
15029 return ;
15030 }
15031 // $ANTLR end "rule__VLSFunctionFof__Group_1_2__0__Impl"
15032
15033
15034 // $ANTLR start "rule__VLSFunctionFof__Group_1_2__1"
15035 // InternalVampireLanguage.g:4861:1: rule__VLSFunctionFof__Group_1_2__1 : rule__VLSFunctionFof__Group_1_2__1__Impl ;
15036 public final void rule__VLSFunctionFof__Group_1_2__1() throws RecognitionException {
15037
15038 int stackSize = keepStackSize();
15039
15040 try {
15041 // InternalVampireLanguage.g:4865:1: ( rule__VLSFunctionFof__Group_1_2__1__Impl )
15042 // InternalVampireLanguage.g:4866:2: rule__VLSFunctionFof__Group_1_2__1__Impl
15043 {
15044 pushFollow(FOLLOW_2);
15045 rule__VLSFunctionFof__Group_1_2__1__Impl();
15046
15047 state._fsp--;
15048
15049
15050 }
15051
15052 }
15053 catch (RecognitionException re) {
15054 reportError(re);
15055 recover(input,re);
15056 }
15057 finally {
15058
15059 restoreStackSize(stackSize);
15060
15061 }
15062 return ;
15063 }
15064 // $ANTLR end "rule__VLSFunctionFof__Group_1_2__1"
15065
15066
15067 // $ANTLR start "rule__VLSFunctionFof__Group_1_2__1__Impl"
15068 // InternalVampireLanguage.g:4872:1: rule__VLSFunctionFof__Group_1_2__1__Impl : ( ( rule__VLSFunctionFof__TermsAssignment_1_2_1 ) ) ;
15069 public final void rule__VLSFunctionFof__Group_1_2__1__Impl() throws RecognitionException {
15070
15071 int stackSize = keepStackSize();
15072
15073 try {
15074 // InternalVampireLanguage.g:4876:1: ( ( ( rule__VLSFunctionFof__TermsAssignment_1_2_1 ) ) )
15075 // InternalVampireLanguage.g:4877:1: ( ( rule__VLSFunctionFof__TermsAssignment_1_2_1 ) )
15076 {
15077 // InternalVampireLanguage.g:4877:1: ( ( rule__VLSFunctionFof__TermsAssignment_1_2_1 ) )
15078 // InternalVampireLanguage.g:4878:2: ( rule__VLSFunctionFof__TermsAssignment_1_2_1 )
15079 {
15080 before(grammarAccess.getVLSFunctionFofAccess().getTermsAssignment_1_2_1());
15081 // InternalVampireLanguage.g:4879:2: ( rule__VLSFunctionFof__TermsAssignment_1_2_1 )
15082 // InternalVampireLanguage.g:4879:3: rule__VLSFunctionFof__TermsAssignment_1_2_1
15083 {
15084 pushFollow(FOLLOW_2);
15085 rule__VLSFunctionFof__TermsAssignment_1_2_1();
15086
15087 state._fsp--;
15088
15089
15090 }
15091
15092 after(grammarAccess.getVLSFunctionFofAccess().getTermsAssignment_1_2_1());
15093
15094 }
15095
15096
15097 }
15098
15099 }
15100 catch (RecognitionException re) {
15101 reportError(re);
15102 recover(input,re);
15103 }
15104 finally {
15105
15106 restoreStackSize(stackSize);
15107
15108 }
15109 return ;
15110 }
15111 // $ANTLR end "rule__VLSFunctionFof__Group_1_2__1__Impl"
15112
15113
15114 // $ANTLR start "rule__VLSDefinedTerm__Group_0__0"
15115 // InternalVampireLanguage.g:4888:1: rule__VLSDefinedTerm__Group_0__0 : rule__VLSDefinedTerm__Group_0__0__Impl rule__VLSDefinedTerm__Group_0__1 ;
15116 public final void rule__VLSDefinedTerm__Group_0__0() throws RecognitionException {
15117
15118 int stackSize = keepStackSize();
15119
15120 try {
15121 // InternalVampireLanguage.g:4892:1: ( rule__VLSDefinedTerm__Group_0__0__Impl rule__VLSDefinedTerm__Group_0__1 )
15122 // InternalVampireLanguage.g:4893:2: rule__VLSDefinedTerm__Group_0__0__Impl rule__VLSDefinedTerm__Group_0__1
15123 {
15124 pushFollow(FOLLOW_43);
15125 rule__VLSDefinedTerm__Group_0__0__Impl();
15126
15127 state._fsp--;
15128
15129 pushFollow(FOLLOW_2);
15130 rule__VLSDefinedTerm__Group_0__1();
15131
15132 state._fsp--;
15133
15134
15135 }
15136
15137 }
15138 catch (RecognitionException re) {
15139 reportError(re);
15140 recover(input,re);
15141 }
15142 finally {
15143
15144 restoreStackSize(stackSize);
15145
15146 }
15147 return ;
15148 }
15149 // $ANTLR end "rule__VLSDefinedTerm__Group_0__0"
15150
15151
15152 // $ANTLR start "rule__VLSDefinedTerm__Group_0__0__Impl"
15153 // InternalVampireLanguage.g:4900:1: rule__VLSDefinedTerm__Group_0__0__Impl : ( () ) ;
15154 public final void rule__VLSDefinedTerm__Group_0__0__Impl() throws RecognitionException {
15155
15156 int stackSize = keepStackSize();
15157
15158 try {
15159 // InternalVampireLanguage.g:4904:1: ( ( () ) )
15160 // InternalVampireLanguage.g:4905:1: ( () )
15161 {
15162 // InternalVampireLanguage.g:4905:1: ( () )
15163 // InternalVampireLanguage.g:4906:2: ()
15164 {
15165 before(grammarAccess.getVLSDefinedTermAccess().getVLSIntAction_0_0());
15166 // InternalVampireLanguage.g:4907:2: ()
15167 // InternalVampireLanguage.g:4907:3:
15168 {
15169 }
15170
15171 after(grammarAccess.getVLSDefinedTermAccess().getVLSIntAction_0_0());
15172
15173 }
15174
15175
15176 }
15177
15178 }
15179 finally {
15180
15181 restoreStackSize(stackSize);
15182
15183 }
15184 return ;
15185 }
15186 // $ANTLR end "rule__VLSDefinedTerm__Group_0__0__Impl"
15187
15188
15189 // $ANTLR start "rule__VLSDefinedTerm__Group_0__1"
15190 // InternalVampireLanguage.g:4915:1: rule__VLSDefinedTerm__Group_0__1 : rule__VLSDefinedTerm__Group_0__1__Impl ;
15191 public final void rule__VLSDefinedTerm__Group_0__1() throws RecognitionException {
15192
15193 int stackSize = keepStackSize();
15194
15195 try {
15196 // InternalVampireLanguage.g:4919:1: ( rule__VLSDefinedTerm__Group_0__1__Impl )
15197 // InternalVampireLanguage.g:4920:2: rule__VLSDefinedTerm__Group_0__1__Impl
15198 {
15199 pushFollow(FOLLOW_2);
15200 rule__VLSDefinedTerm__Group_0__1__Impl();
15201
15202 state._fsp--;
15203
15204
15205 }
15206
15207 }
15208 catch (RecognitionException re) {
15209 reportError(re);
15210 recover(input,re);
15211 }
15212 finally {
15213
15214 restoreStackSize(stackSize);
15215
15216 }
15217 return ;
15218 }
15219 // $ANTLR end "rule__VLSDefinedTerm__Group_0__1"
15220
15221
15222 // $ANTLR start "rule__VLSDefinedTerm__Group_0__1__Impl"
15223 // InternalVampireLanguage.g:4926:1: rule__VLSDefinedTerm__Group_0__1__Impl : ( ( rule__VLSDefinedTerm__ValueAssignment_0_1 ) ) ;
15224 public final void rule__VLSDefinedTerm__Group_0__1__Impl() throws RecognitionException {
15225
15226 int stackSize = keepStackSize();
15227
15228 try {
15229 // InternalVampireLanguage.g:4930:1: ( ( ( rule__VLSDefinedTerm__ValueAssignment_0_1 ) ) )
15230 // InternalVampireLanguage.g:4931:1: ( ( rule__VLSDefinedTerm__ValueAssignment_0_1 ) )
15231 {
15232 // InternalVampireLanguage.g:4931:1: ( ( rule__VLSDefinedTerm__ValueAssignment_0_1 ) )
15233 // InternalVampireLanguage.g:4932:2: ( rule__VLSDefinedTerm__ValueAssignment_0_1 )
15234 {
15235 before(grammarAccess.getVLSDefinedTermAccess().getValueAssignment_0_1());
15236 // InternalVampireLanguage.g:4933:2: ( rule__VLSDefinedTerm__ValueAssignment_0_1 )
15237 // InternalVampireLanguage.g:4933:3: rule__VLSDefinedTerm__ValueAssignment_0_1
15238 {
15239 pushFollow(FOLLOW_2);
15240 rule__VLSDefinedTerm__ValueAssignment_0_1();
15241
15242 state._fsp--;
15243
15244
15245 }
15246
15247 after(grammarAccess.getVLSDefinedTermAccess().getValueAssignment_0_1());
15248
15249 }
15250
15251
15252 }
15253
15254 }
15255 catch (RecognitionException re) {
15256 reportError(re);
15257 recover(input,re);
15258 }
15259 finally {
15260
15261 restoreStackSize(stackSize);
15262
15263 }
15264 return ;
15265 }
15266 // $ANTLR end "rule__VLSDefinedTerm__Group_0__1__Impl"
15267
15268
15269 // $ANTLR start "rule__VLSDefinedTerm__Group_1__0"
15270 // InternalVampireLanguage.g:4942:1: rule__VLSDefinedTerm__Group_1__0 : rule__VLSDefinedTerm__Group_1__0__Impl rule__VLSDefinedTerm__Group_1__1 ;
15271 public final void rule__VLSDefinedTerm__Group_1__0() throws RecognitionException {
15272
15273 int stackSize = keepStackSize();
15274
15275 try {
15276 // InternalVampireLanguage.g:4946:1: ( rule__VLSDefinedTerm__Group_1__0__Impl rule__VLSDefinedTerm__Group_1__1 )
15277 // InternalVampireLanguage.g:4947:2: rule__VLSDefinedTerm__Group_1__0__Impl rule__VLSDefinedTerm__Group_1__1
15278 {
15279 pushFollow(FOLLOW_44);
15280 rule__VLSDefinedTerm__Group_1__0__Impl();
15281
15282 state._fsp--;
15283
15284 pushFollow(FOLLOW_2);
15285 rule__VLSDefinedTerm__Group_1__1();
15286
15287 state._fsp--;
15288
15289
15290 }
15291
15292 }
15293 catch (RecognitionException re) {
15294 reportError(re);
15295 recover(input,re);
15296 }
15297 finally {
15298
15299 restoreStackSize(stackSize);
15300
15301 }
15302 return ;
15303 }
15304 // $ANTLR end "rule__VLSDefinedTerm__Group_1__0"
15305
15306
15307 // $ANTLR start "rule__VLSDefinedTerm__Group_1__0__Impl"
15308 // InternalVampireLanguage.g:4954:1: rule__VLSDefinedTerm__Group_1__0__Impl : ( () ) ;
15309 public final void rule__VLSDefinedTerm__Group_1__0__Impl() throws RecognitionException {
15310
15311 int stackSize = keepStackSize();
15312
15313 try {
15314 // InternalVampireLanguage.g:4958:1: ( ( () ) )
15315 // InternalVampireLanguage.g:4959:1: ( () )
15316 {
15317 // InternalVampireLanguage.g:4959:1: ( () )
15318 // InternalVampireLanguage.g:4960:2: ()
15319 {
15320 before(grammarAccess.getVLSDefinedTermAccess().getVLSRealAction_1_0());
15321 // InternalVampireLanguage.g:4961:2: ()
15322 // InternalVampireLanguage.g:4961:3:
15323 {
15324 }
15325
15326 after(grammarAccess.getVLSDefinedTermAccess().getVLSRealAction_1_0());
15327
15328 }
15329
15330
15331 }
15332
15333 }
15334 finally {
15335
15336 restoreStackSize(stackSize);
15337
15338 }
15339 return ;
15340 }
15341 // $ANTLR end "rule__VLSDefinedTerm__Group_1__0__Impl"
15342
15343
15344 // $ANTLR start "rule__VLSDefinedTerm__Group_1__1"
15345 // InternalVampireLanguage.g:4969:1: rule__VLSDefinedTerm__Group_1__1 : rule__VLSDefinedTerm__Group_1__1__Impl ;
15346 public final void rule__VLSDefinedTerm__Group_1__1() throws RecognitionException {
15347
15348 int stackSize = keepStackSize();
15349
15350 try {
15351 // InternalVampireLanguage.g:4973:1: ( rule__VLSDefinedTerm__Group_1__1__Impl )
15352 // InternalVampireLanguage.g:4974:2: rule__VLSDefinedTerm__Group_1__1__Impl
15353 {
15354 pushFollow(FOLLOW_2);
15355 rule__VLSDefinedTerm__Group_1__1__Impl();
15356
15357 state._fsp--;
15358
15359
15360 }
15361
15362 }
15363 catch (RecognitionException re) {
15364 reportError(re);
15365 recover(input,re);
15366 }
15367 finally {
15368
15369 restoreStackSize(stackSize);
15370
15371 }
15372 return ;
15373 }
15374 // $ANTLR end "rule__VLSDefinedTerm__Group_1__1"
15375
15376
15377 // $ANTLR start "rule__VLSDefinedTerm__Group_1__1__Impl"
15378 // InternalVampireLanguage.g:4980:1: rule__VLSDefinedTerm__Group_1__1__Impl : ( ( rule__VLSDefinedTerm__ValueAssignment_1_1 ) ) ;
15379 public final void rule__VLSDefinedTerm__Group_1__1__Impl() throws RecognitionException {
15380
15381 int stackSize = keepStackSize();
15382
15383 try {
15384 // InternalVampireLanguage.g:4984:1: ( ( ( rule__VLSDefinedTerm__ValueAssignment_1_1 ) ) )
15385 // InternalVampireLanguage.g:4985:1: ( ( rule__VLSDefinedTerm__ValueAssignment_1_1 ) )
15386 {
15387 // InternalVampireLanguage.g:4985:1: ( ( rule__VLSDefinedTerm__ValueAssignment_1_1 ) )
15388 // InternalVampireLanguage.g:4986:2: ( rule__VLSDefinedTerm__ValueAssignment_1_1 )
15389 {
15390 before(grammarAccess.getVLSDefinedTermAccess().getValueAssignment_1_1());
15391 // InternalVampireLanguage.g:4987:2: ( rule__VLSDefinedTerm__ValueAssignment_1_1 )
15392 // InternalVampireLanguage.g:4987:3: rule__VLSDefinedTerm__ValueAssignment_1_1
15393 {
15394 pushFollow(FOLLOW_2);
15395 rule__VLSDefinedTerm__ValueAssignment_1_1();
15396
15397 state._fsp--;
15398
15399
15400 }
15401
15402 after(grammarAccess.getVLSDefinedTermAccess().getValueAssignment_1_1());
15403
15404 }
15405
15406
15407 }
15408
15409 }
15410 catch (RecognitionException re) {
15411 reportError(re);
15412 recover(input,re);
15413 }
15414 finally {
15415
15416 restoreStackSize(stackSize);
15417
15418 }
15419 return ;
15420 }
15421 // $ANTLR end "rule__VLSDefinedTerm__Group_1__1__Impl"
15422
15423
15424 // $ANTLR start "rule__VLSDefinedTerm__Group_2__0"
15425 // InternalVampireLanguage.g:4996:1: rule__VLSDefinedTerm__Group_2__0 : rule__VLSDefinedTerm__Group_2__0__Impl rule__VLSDefinedTerm__Group_2__1 ;
15426 public final void rule__VLSDefinedTerm__Group_2__0() throws RecognitionException {
15427
15428 int stackSize = keepStackSize();
15429
15430 try {
15431 // InternalVampireLanguage.g:5000:1: ( rule__VLSDefinedTerm__Group_2__0__Impl rule__VLSDefinedTerm__Group_2__1 )
15432 // InternalVampireLanguage.g:5001:2: rule__VLSDefinedTerm__Group_2__0__Impl rule__VLSDefinedTerm__Group_2__1
15433 {
15434 pushFollow(FOLLOW_45);
15435 rule__VLSDefinedTerm__Group_2__0__Impl();
15436
15437 state._fsp--;
15438
15439 pushFollow(FOLLOW_2);
15440 rule__VLSDefinedTerm__Group_2__1();
15441
15442 state._fsp--;
15443
15444
15445 }
15446
15447 }
15448 catch (RecognitionException re) {
15449 reportError(re);
15450 recover(input,re);
15451 }
15452 finally {
15453
15454 restoreStackSize(stackSize);
15455
15456 }
15457 return ;
15458 }
15459 // $ANTLR end "rule__VLSDefinedTerm__Group_2__0"
15460
15461
15462 // $ANTLR start "rule__VLSDefinedTerm__Group_2__0__Impl"
15463 // InternalVampireLanguage.g:5008:1: rule__VLSDefinedTerm__Group_2__0__Impl : ( () ) ;
15464 public final void rule__VLSDefinedTerm__Group_2__0__Impl() throws RecognitionException {
15465
15466 int stackSize = keepStackSize();
15467
15468 try {
15469 // InternalVampireLanguage.g:5012:1: ( ( () ) )
15470 // InternalVampireLanguage.g:5013:1: ( () )
15471 {
15472 // InternalVampireLanguage.g:5013:1: ( () )
15473 // InternalVampireLanguage.g:5014:2: ()
15474 {
15475 before(grammarAccess.getVLSDefinedTermAccess().getVLSRationalAction_2_0());
15476 // InternalVampireLanguage.g:5015:2: ()
15477 // InternalVampireLanguage.g:5015:3:
15478 {
15479 }
15480
15481 after(grammarAccess.getVLSDefinedTermAccess().getVLSRationalAction_2_0());
15482
15483 }
15484
15485
15486 }
15487
15488 }
15489 finally {
15490
15491 restoreStackSize(stackSize);
15492
15493 }
15494 return ;
15495 }
15496 // $ANTLR end "rule__VLSDefinedTerm__Group_2__0__Impl"
15497
15498
15499 // $ANTLR start "rule__VLSDefinedTerm__Group_2__1"
15500 // InternalVampireLanguage.g:5023:1: rule__VLSDefinedTerm__Group_2__1 : rule__VLSDefinedTerm__Group_2__1__Impl ;
15501 public final void rule__VLSDefinedTerm__Group_2__1() throws RecognitionException {
15502
15503 int stackSize = keepStackSize();
15504
15505 try {
15506 // InternalVampireLanguage.g:5027:1: ( rule__VLSDefinedTerm__Group_2__1__Impl )
15507 // InternalVampireLanguage.g:5028:2: rule__VLSDefinedTerm__Group_2__1__Impl
15508 {
15509 pushFollow(FOLLOW_2);
15510 rule__VLSDefinedTerm__Group_2__1__Impl();
15511
15512 state._fsp--;
15513
15514
15515 }
15516
15517 }
15518 catch (RecognitionException re) {
15519 reportError(re);
15520 recover(input,re);
15521 }
15522 finally {
15523
15524 restoreStackSize(stackSize);
15525
15526 }
15527 return ;
15528 }
15529 // $ANTLR end "rule__VLSDefinedTerm__Group_2__1"
15530
15531
15532 // $ANTLR start "rule__VLSDefinedTerm__Group_2__1__Impl"
15533 // InternalVampireLanguage.g:5034:1: rule__VLSDefinedTerm__Group_2__1__Impl : ( ( rule__VLSDefinedTerm__ValueAssignment_2_1 ) ) ;
15534 public final void rule__VLSDefinedTerm__Group_2__1__Impl() throws RecognitionException {
15535
15536 int stackSize = keepStackSize();
15537
15538 try {
15539 // InternalVampireLanguage.g:5038:1: ( ( ( rule__VLSDefinedTerm__ValueAssignment_2_1 ) ) )
15540 // InternalVampireLanguage.g:5039:1: ( ( rule__VLSDefinedTerm__ValueAssignment_2_1 ) )
15541 {
15542 // InternalVampireLanguage.g:5039:1: ( ( rule__VLSDefinedTerm__ValueAssignment_2_1 ) )
15543 // InternalVampireLanguage.g:5040:2: ( rule__VLSDefinedTerm__ValueAssignment_2_1 )
15544 {
15545 before(grammarAccess.getVLSDefinedTermAccess().getValueAssignment_2_1());
15546 // InternalVampireLanguage.g:5041:2: ( rule__VLSDefinedTerm__ValueAssignment_2_1 )
15547 // InternalVampireLanguage.g:5041:3: rule__VLSDefinedTerm__ValueAssignment_2_1
15548 {
15549 pushFollow(FOLLOW_2);
15550 rule__VLSDefinedTerm__ValueAssignment_2_1();
15551
15552 state._fsp--;
15553
15554
15555 }
15556
15557 after(grammarAccess.getVLSDefinedTermAccess().getValueAssignment_2_1());
15558
15559 }
15560
15561
15562 }
15563
15564 }
15565 catch (RecognitionException re) {
15566 reportError(re);
15567 recover(input,re);
15568 }
15569 finally {
15570
15571 restoreStackSize(stackSize);
15572
15573 }
15574 return ;
15575 }
15576 // $ANTLR end "rule__VLSDefinedTerm__Group_2__1__Impl"
15577
15578
15579 // $ANTLR start "rule__VLSDefinedTerm__Group_3__0"
15580 // InternalVampireLanguage.g:5050:1: rule__VLSDefinedTerm__Group_3__0 : rule__VLSDefinedTerm__Group_3__0__Impl rule__VLSDefinedTerm__Group_3__1 ;
15581 public final void rule__VLSDefinedTerm__Group_3__0() throws RecognitionException {
15582
15583 int stackSize = keepStackSize();
15584
15585 try {
15586 // InternalVampireLanguage.g:5054:1: ( rule__VLSDefinedTerm__Group_3__0__Impl rule__VLSDefinedTerm__Group_3__1 )
15587 // InternalVampireLanguage.g:5055:2: rule__VLSDefinedTerm__Group_3__0__Impl rule__VLSDefinedTerm__Group_3__1
15588 {
15589 pushFollow(FOLLOW_36);
15590 rule__VLSDefinedTerm__Group_3__0__Impl();
15591
15592 state._fsp--;
15593
15594 pushFollow(FOLLOW_2);
15595 rule__VLSDefinedTerm__Group_3__1();
15596
15597 state._fsp--;
15598
15599
15600 }
15601
15602 }
15603 catch (RecognitionException re) {
15604 reportError(re);
15605 recover(input,re);
15606 }
15607 finally {
15608
15609 restoreStackSize(stackSize);
15610
15611 }
15612 return ;
15613 }
15614 // $ANTLR end "rule__VLSDefinedTerm__Group_3__0"
15615
15616
15617 // $ANTLR start "rule__VLSDefinedTerm__Group_3__0__Impl"
15618 // InternalVampireLanguage.g:5062:1: rule__VLSDefinedTerm__Group_3__0__Impl : ( () ) ;
15619 public final void rule__VLSDefinedTerm__Group_3__0__Impl() throws RecognitionException {
15620
15621 int stackSize = keepStackSize();
15622
15623 try {
15624 // InternalVampireLanguage.g:5066:1: ( ( () ) )
15625 // InternalVampireLanguage.g:5067:1: ( () )
15626 {
15627 // InternalVampireLanguage.g:5067:1: ( () )
15628 // InternalVampireLanguage.g:5068:2: ()
15629 {
15630 before(grammarAccess.getVLSDefinedTermAccess().getVLSDoubleQuoteAction_3_0());
15631 // InternalVampireLanguage.g:5069:2: ()
15632 // InternalVampireLanguage.g:5069:3:
15633 {
15634 }
15635
15636 after(grammarAccess.getVLSDefinedTermAccess().getVLSDoubleQuoteAction_3_0());
15637
15638 }
15639
15640
15641 }
15642
15643 }
15644 finally {
15645
15646 restoreStackSize(stackSize);
15647
15648 }
15649 return ;
15650 }
15651 // $ANTLR end "rule__VLSDefinedTerm__Group_3__0__Impl"
15652
15653
15654 // $ANTLR start "rule__VLSDefinedTerm__Group_3__1"
15655 // InternalVampireLanguage.g:5077:1: rule__VLSDefinedTerm__Group_3__1 : rule__VLSDefinedTerm__Group_3__1__Impl ;
15656 public final void rule__VLSDefinedTerm__Group_3__1() throws RecognitionException {
15657
15658 int stackSize = keepStackSize();
15659
15660 try {
15661 // InternalVampireLanguage.g:5081:1: ( rule__VLSDefinedTerm__Group_3__1__Impl )
15662 // InternalVampireLanguage.g:5082:2: rule__VLSDefinedTerm__Group_3__1__Impl
15663 {
15664 pushFollow(FOLLOW_2);
15665 rule__VLSDefinedTerm__Group_3__1__Impl();
15666
15667 state._fsp--;
15668
15669
15670 }
15671
15672 }
15673 catch (RecognitionException re) {
15674 reportError(re);
15675 recover(input,re);
15676 }
15677 finally {
15678
15679 restoreStackSize(stackSize);
15680
15681 }
15682 return ;
15683 }
15684 // $ANTLR end "rule__VLSDefinedTerm__Group_3__1"
15685
15686
15687 // $ANTLR start "rule__VLSDefinedTerm__Group_3__1__Impl"
15688 // InternalVampireLanguage.g:5088:1: rule__VLSDefinedTerm__Group_3__1__Impl : ( ( rule__VLSDefinedTerm__ValueAssignment_3_1 ) ) ;
15689 public final void rule__VLSDefinedTerm__Group_3__1__Impl() throws RecognitionException {
15690
15691 int stackSize = keepStackSize();
15692
15693 try {
15694 // InternalVampireLanguage.g:5092:1: ( ( ( rule__VLSDefinedTerm__ValueAssignment_3_1 ) ) )
15695 // InternalVampireLanguage.g:5093:1: ( ( rule__VLSDefinedTerm__ValueAssignment_3_1 ) )
15696 {
15697 // InternalVampireLanguage.g:5093:1: ( ( rule__VLSDefinedTerm__ValueAssignment_3_1 ) )
15698 // InternalVampireLanguage.g:5094:2: ( rule__VLSDefinedTerm__ValueAssignment_3_1 )
15699 {
15700 before(grammarAccess.getVLSDefinedTermAccess().getValueAssignment_3_1());
15701 // InternalVampireLanguage.g:5095:2: ( rule__VLSDefinedTerm__ValueAssignment_3_1 )
15702 // InternalVampireLanguage.g:5095:3: rule__VLSDefinedTerm__ValueAssignment_3_1
15703 {
15704 pushFollow(FOLLOW_2);
15705 rule__VLSDefinedTerm__ValueAssignment_3_1();
15706
15707 state._fsp--;
15708
15709
15710 }
15711
15712 after(grammarAccess.getVLSDefinedTermAccess().getValueAssignment_3_1());
15713
15714 }
15715
15716
15717 }
15718
15719 }
15720 catch (RecognitionException re) {
15721 reportError(re);
15722 recover(input,re);
15723 }
15724 finally {
15725
15726 restoreStackSize(stackSize);
15727
15728 }
15729 return ;
15730 }
15731 // $ANTLR end "rule__VLSDefinedTerm__Group_3__1__Impl"
15732
15733
15734 // $ANTLR start "rule__VampireModel__IncludesAssignment_0"
15735 // InternalVampireLanguage.g:5104:1: rule__VampireModel__IncludesAssignment_0 : ( ruleVLSInclude ) ;
15736 public final void rule__VampireModel__IncludesAssignment_0() throws RecognitionException {
15737
15738 int stackSize = keepStackSize();
15739
15740 try {
15741 // InternalVampireLanguage.g:5108:1: ( ( ruleVLSInclude ) )
15742 // InternalVampireLanguage.g:5109:2: ( ruleVLSInclude )
15743 {
15744 // InternalVampireLanguage.g:5109:2: ( ruleVLSInclude )
15745 // InternalVampireLanguage.g:5110:3: ruleVLSInclude
15746 {
15747 before(grammarAccess.getVampireModelAccess().getIncludesVLSIncludeParserRuleCall_0_0());
15748 pushFollow(FOLLOW_2);
15749 ruleVLSInclude();
15750
15751 state._fsp--;
15752
15753 after(grammarAccess.getVampireModelAccess().getIncludesVLSIncludeParserRuleCall_0_0());
15754
15755 }
15756
15757
15758 }
15759
15760 }
15761 catch (RecognitionException re) {
15762 reportError(re);
15763 recover(input,re);
15764 }
15765 finally {
15766
15767 restoreStackSize(stackSize);
15768
15769 }
15770 return ;
15771 }
15772 // $ANTLR end "rule__VampireModel__IncludesAssignment_0"
15773
15774
15775 // $ANTLR start "rule__VampireModel__CommentsAssignment_1"
15776 // InternalVampireLanguage.g:5119:1: rule__VampireModel__CommentsAssignment_1 : ( ruleVLSComment ) ;
15777 public final void rule__VampireModel__CommentsAssignment_1() throws RecognitionException {
15778
15779 int stackSize = keepStackSize();
15780
15781 try {
15782 // InternalVampireLanguage.g:5123:1: ( ( ruleVLSComment ) )
15783 // InternalVampireLanguage.g:5124:2: ( ruleVLSComment )
15784 {
15785 // InternalVampireLanguage.g:5124:2: ( ruleVLSComment )
15786 // InternalVampireLanguage.g:5125:3: ruleVLSComment
15787 {
15788 before(grammarAccess.getVampireModelAccess().getCommentsVLSCommentParserRuleCall_1_0());
15789 pushFollow(FOLLOW_2);
15790 ruleVLSComment();
15791
15792 state._fsp--;
15793
15794 after(grammarAccess.getVampireModelAccess().getCommentsVLSCommentParserRuleCall_1_0());
15795
15796 }
15797
15798
15799 }
15800
15801 }
15802 catch (RecognitionException re) {
15803 reportError(re);
15804 recover(input,re);
15805 }
15806 finally {
15807
15808 restoreStackSize(stackSize);
15809
15810 }
15811 return ;
15812 }
15813 // $ANTLR end "rule__VampireModel__CommentsAssignment_1"
15814
15815
15816 // $ANTLR start "rule__VampireModel__FormulasAssignment_2"
15817 // InternalVampireLanguage.g:5134:1: rule__VampireModel__FormulasAssignment_2 : ( ruleVLSFofFormula ) ;
15818 public final void rule__VampireModel__FormulasAssignment_2() throws RecognitionException {
15819
15820 int stackSize = keepStackSize();
15821
15822 try {
15823 // InternalVampireLanguage.g:5138:1: ( ( ruleVLSFofFormula ) )
15824 // InternalVampireLanguage.g:5139:2: ( ruleVLSFofFormula )
15825 {
15826 // InternalVampireLanguage.g:5139:2: ( ruleVLSFofFormula )
15827 // InternalVampireLanguage.g:5140:3: ruleVLSFofFormula
15828 {
15829 before(grammarAccess.getVampireModelAccess().getFormulasVLSFofFormulaParserRuleCall_2_0());
15830 pushFollow(FOLLOW_2);
15831 ruleVLSFofFormula();
15832
15833 state._fsp--;
15834
15835 after(grammarAccess.getVampireModelAccess().getFormulasVLSFofFormulaParserRuleCall_2_0());
15836
15837 }
15838
15839
15840 }
15841
15842 }
15843 catch (RecognitionException re) {
15844 reportError(re);
15845 recover(input,re);
15846 }
15847 finally {
15848
15849 restoreStackSize(stackSize);
15850
15851 }
15852 return ;
15853 }
15854 // $ANTLR end "rule__VampireModel__FormulasAssignment_2"
15855
15856
15857 // $ANTLR start "rule__VLSInclude__FileNameAssignment_1"
15858 // InternalVampireLanguage.g:5149:1: rule__VLSInclude__FileNameAssignment_1 : ( RULE_SINGLE_QUOTE ) ;
15859 public final void rule__VLSInclude__FileNameAssignment_1() throws RecognitionException {
15860
15861 int stackSize = keepStackSize();
15862
15863 try {
15864 // InternalVampireLanguage.g:5153:1: ( ( RULE_SINGLE_QUOTE ) )
15865 // InternalVampireLanguage.g:5154:2: ( RULE_SINGLE_QUOTE )
15866 {
15867 // InternalVampireLanguage.g:5154:2: ( RULE_SINGLE_QUOTE )
15868 // InternalVampireLanguage.g:5155:3: RULE_SINGLE_QUOTE
15869 {
15870 before(grammarAccess.getVLSIncludeAccess().getFileNameSINGLE_QUOTETerminalRuleCall_1_0());
15871 match(input,RULE_SINGLE_QUOTE,FOLLOW_2);
15872 after(grammarAccess.getVLSIncludeAccess().getFileNameSINGLE_QUOTETerminalRuleCall_1_0());
15873
15874 }
15875
15876
15877 }
15878
15879 }
15880 catch (RecognitionException re) {
15881 reportError(re);
15882 recover(input,re);
15883 }
15884 finally {
15885
15886 restoreStackSize(stackSize);
15887
15888 }
15889 return ;
15890 }
15891 // $ANTLR end "rule__VLSInclude__FileNameAssignment_1"
15892
15893
15894 // $ANTLR start "rule__VLSInclude__NamesAssignment_2_1"
15895 // InternalVampireLanguage.g:5164:1: rule__VLSInclude__NamesAssignment_2_1 : ( ruleVLSName ) ;
15896 public final void rule__VLSInclude__NamesAssignment_2_1() throws RecognitionException {
15897
15898 int stackSize = keepStackSize();
15899
15900 try {
15901 // InternalVampireLanguage.g:5168:1: ( ( ruleVLSName ) )
15902 // InternalVampireLanguage.g:5169:2: ( ruleVLSName )
15903 {
15904 // InternalVampireLanguage.g:5169:2: ( ruleVLSName )
15905 // InternalVampireLanguage.g:5170:3: ruleVLSName
15906 {
15907 before(grammarAccess.getVLSIncludeAccess().getNamesVLSNameParserRuleCall_2_1_0());
15908 pushFollow(FOLLOW_2);
15909 ruleVLSName();
15910
15911 state._fsp--;
15912
15913 after(grammarAccess.getVLSIncludeAccess().getNamesVLSNameParserRuleCall_2_1_0());
15914
15915 }
15916
15917
15918 }
15919
15920 }
15921 catch (RecognitionException re) {
15922 reportError(re);
15923 recover(input,re);
15924 }
15925 finally {
15926
15927 restoreStackSize(stackSize);
15928
15929 }
15930 return ;
15931 }
15932 // $ANTLR end "rule__VLSInclude__NamesAssignment_2_1"
15933
15934
15935 // $ANTLR start "rule__VLSInclude__NamesAssignment_2_2_1"
15936 // InternalVampireLanguage.g:5179:1: rule__VLSInclude__NamesAssignment_2_2_1 : ( ruleVLSName ) ;
15937 public final void rule__VLSInclude__NamesAssignment_2_2_1() throws RecognitionException {
15938
15939 int stackSize = keepStackSize();
15940
15941 try {
15942 // InternalVampireLanguage.g:5183:1: ( ( ruleVLSName ) )
15943 // InternalVampireLanguage.g:5184:2: ( ruleVLSName )
15944 {
15945 // InternalVampireLanguage.g:5184:2: ( ruleVLSName )
15946 // InternalVampireLanguage.g:5185:3: ruleVLSName
15947 {
15948 before(grammarAccess.getVLSIncludeAccess().getNamesVLSNameParserRuleCall_2_2_1_0());
15949 pushFollow(FOLLOW_2);
15950 ruleVLSName();
15951
15952 state._fsp--;
15953
15954 after(grammarAccess.getVLSIncludeAccess().getNamesVLSNameParserRuleCall_2_2_1_0());
15955
15956 }
15957
15958
15959 }
15960
15961 }
15962 catch (RecognitionException re) {
15963 reportError(re);
15964 recover(input,re);
15965 }
15966 finally {
15967
15968 restoreStackSize(stackSize);
15969
15970 }
15971 return ;
15972 }
15973 // $ANTLR end "rule__VLSInclude__NamesAssignment_2_2_1"
15974
15975
15976 // $ANTLR start "rule__VLSName__NameAssignment"
15977 // InternalVampireLanguage.g:5194:1: rule__VLSName__NameAssignment : ( ( rule__VLSName__NameAlternatives_0 ) ) ;
15978 public final void rule__VLSName__NameAssignment() throws RecognitionException {
15979
15980 int stackSize = keepStackSize();
15981
15982 try {
15983 // InternalVampireLanguage.g:5198:1: ( ( ( rule__VLSName__NameAlternatives_0 ) ) )
15984 // InternalVampireLanguage.g:5199:2: ( ( rule__VLSName__NameAlternatives_0 ) )
15985 {
15986 // InternalVampireLanguage.g:5199:2: ( ( rule__VLSName__NameAlternatives_0 ) )
15987 // InternalVampireLanguage.g:5200:3: ( rule__VLSName__NameAlternatives_0 )
15988 {
15989 before(grammarAccess.getVLSNameAccess().getNameAlternatives_0());
15990 // InternalVampireLanguage.g:5201:3: ( rule__VLSName__NameAlternatives_0 )
15991 // InternalVampireLanguage.g:5201:4: rule__VLSName__NameAlternatives_0
15992 {
15993 pushFollow(FOLLOW_2);
15994 rule__VLSName__NameAlternatives_0();
15995
15996 state._fsp--;
15997
15998
15999 }
16000
16001 after(grammarAccess.getVLSNameAccess().getNameAlternatives_0());
16002
16003 }
16004
16005
16006 }
16007
16008 }
16009 catch (RecognitionException re) {
16010 reportError(re);
16011 recover(input,re);
16012 }
16013 finally {
16014
16015 restoreStackSize(stackSize);
16016
16017 }
16018 return ;
16019 }
16020 // $ANTLR end "rule__VLSName__NameAssignment"
16021
16022
16023 // $ANTLR start "rule__VLSComment__CommentAssignment"
16024 // InternalVampireLanguage.g:5209:1: rule__VLSComment__CommentAssignment : ( RULE_SINGLE_COMMENT ) ;
16025 public final void rule__VLSComment__CommentAssignment() throws RecognitionException {
16026
16027 int stackSize = keepStackSize();
16028
16029 try {
16030 // InternalVampireLanguage.g:5213:1: ( ( RULE_SINGLE_COMMENT ) )
16031 // InternalVampireLanguage.g:5214:2: ( RULE_SINGLE_COMMENT )
16032 {
16033 // InternalVampireLanguage.g:5214:2: ( RULE_SINGLE_COMMENT )
16034 // InternalVampireLanguage.g:5215:3: RULE_SINGLE_COMMENT
16035 {
16036 before(grammarAccess.getVLSCommentAccess().getCommentSINGLE_COMMENTTerminalRuleCall_0());
16037 match(input,RULE_SINGLE_COMMENT,FOLLOW_2);
16038 after(grammarAccess.getVLSCommentAccess().getCommentSINGLE_COMMENTTerminalRuleCall_0());
16039
16040 }
16041
16042
16043 }
16044
16045 }
16046 catch (RecognitionException re) {
16047 reportError(re);
16048 recover(input,re);
16049 }
16050 finally {
16051
16052 restoreStackSize(stackSize);
16053
16054 }
16055 return ;
16056 }
16057 // $ANTLR end "rule__VLSComment__CommentAssignment"
16058
16059
16060 // $ANTLR start "rule__VLSFofFormula__NameAssignment_2"
16061 // InternalVampireLanguage.g:5224:1: rule__VLSFofFormula__NameAssignment_2 : ( ( rule__VLSFofFormula__NameAlternatives_2_0 ) ) ;
16062 public final void rule__VLSFofFormula__NameAssignment_2() throws RecognitionException {
16063
16064 int stackSize = keepStackSize();
16065
16066 try {
16067 // InternalVampireLanguage.g:5228:1: ( ( ( rule__VLSFofFormula__NameAlternatives_2_0 ) ) )
16068 // InternalVampireLanguage.g:5229:2: ( ( rule__VLSFofFormula__NameAlternatives_2_0 ) )
16069 {
16070 // InternalVampireLanguage.g:5229:2: ( ( rule__VLSFofFormula__NameAlternatives_2_0 ) )
16071 // InternalVampireLanguage.g:5230:3: ( rule__VLSFofFormula__NameAlternatives_2_0 )
16072 {
16073 before(grammarAccess.getVLSFofFormulaAccess().getNameAlternatives_2_0());
16074 // InternalVampireLanguage.g:5231:3: ( rule__VLSFofFormula__NameAlternatives_2_0 )
16075 // InternalVampireLanguage.g:5231:4: rule__VLSFofFormula__NameAlternatives_2_0
16076 {
16077 pushFollow(FOLLOW_2);
16078 rule__VLSFofFormula__NameAlternatives_2_0();
16079
16080 state._fsp--;
16081
16082
16083 }
16084
16085 after(grammarAccess.getVLSFofFormulaAccess().getNameAlternatives_2_0());
16086
16087 }
16088
16089
16090 }
16091
16092 }
16093 catch (RecognitionException re) {
16094 reportError(re);
16095 recover(input,re);
16096 }
16097 finally {
16098
16099 restoreStackSize(stackSize);
16100
16101 }
16102 return ;
16103 }
16104 // $ANTLR end "rule__VLSFofFormula__NameAssignment_2"
16105
16106
16107 // $ANTLR start "rule__VLSFofFormula__FofRoleAssignment_4"
16108 // InternalVampireLanguage.g:5239:1: rule__VLSFofFormula__FofRoleAssignment_4 : ( ruleVLSRole ) ;
16109 public final void rule__VLSFofFormula__FofRoleAssignment_4() throws RecognitionException {
16110
16111 int stackSize = keepStackSize();
16112
16113 try {
16114 // InternalVampireLanguage.g:5243:1: ( ( ruleVLSRole ) )
16115 // InternalVampireLanguage.g:5244:2: ( ruleVLSRole )
16116 {
16117 // InternalVampireLanguage.g:5244:2: ( ruleVLSRole )
16118 // InternalVampireLanguage.g:5245:3: ruleVLSRole
16119 {
16120 before(grammarAccess.getVLSFofFormulaAccess().getFofRoleVLSRoleParserRuleCall_4_0());
16121 pushFollow(FOLLOW_2);
16122 ruleVLSRole();
16123
16124 state._fsp--;
16125
16126 after(grammarAccess.getVLSFofFormulaAccess().getFofRoleVLSRoleParserRuleCall_4_0());
16127
16128 }
16129
16130
16131 }
16132
16133 }
16134 catch (RecognitionException re) {
16135 reportError(re);
16136 recover(input,re);
16137 }
16138 finally {
16139
16140 restoreStackSize(stackSize);
16141
16142 }
16143 return ;
16144 }
16145 // $ANTLR end "rule__VLSFofFormula__FofRoleAssignment_4"
16146
16147
16148 // $ANTLR start "rule__VLSFofFormula__FofFormulaAssignment_6"
16149 // InternalVampireLanguage.g:5254:1: rule__VLSFofFormula__FofFormulaAssignment_6 : ( ruleVLSTerm ) ;
16150 public final void rule__VLSFofFormula__FofFormulaAssignment_6() throws RecognitionException {
16151
16152 int stackSize = keepStackSize();
16153
16154 try {
16155 // InternalVampireLanguage.g:5258:1: ( ( ruleVLSTerm ) )
16156 // InternalVampireLanguage.g:5259:2: ( ruleVLSTerm )
16157 {
16158 // InternalVampireLanguage.g:5259:2: ( ruleVLSTerm )
16159 // InternalVampireLanguage.g:5260:3: ruleVLSTerm
16160 {
16161 before(grammarAccess.getVLSFofFormulaAccess().getFofFormulaVLSTermParserRuleCall_6_0());
16162 pushFollow(FOLLOW_2);
16163 ruleVLSTerm();
16164
16165 state._fsp--;
16166
16167 after(grammarAccess.getVLSFofFormulaAccess().getFofFormulaVLSTermParserRuleCall_6_0());
16168
16169 }
16170
16171
16172 }
16173
16174 }
16175 catch (RecognitionException re) {
16176 reportError(re);
16177 recover(input,re);
16178 }
16179 finally {
16180
16181 restoreStackSize(stackSize);
16182
16183 }
16184 return ;
16185 }
16186 // $ANTLR end "rule__VLSFofFormula__FofFormulaAssignment_6"
16187
16188
16189 // $ANTLR start "rule__VLSFofFormula__AnnotationsAssignment_7_1"
16190 // InternalVampireLanguage.g:5269:1: rule__VLSFofFormula__AnnotationsAssignment_7_1 : ( ruleVLSAnnotation ) ;
16191 public final void rule__VLSFofFormula__AnnotationsAssignment_7_1() throws RecognitionException {
16192
16193 int stackSize = keepStackSize();
16194
16195 try {
16196 // InternalVampireLanguage.g:5273:1: ( ( ruleVLSAnnotation ) )
16197 // InternalVampireLanguage.g:5274:2: ( ruleVLSAnnotation )
16198 {
16199 // InternalVampireLanguage.g:5274:2: ( ruleVLSAnnotation )
16200 // InternalVampireLanguage.g:5275:3: ruleVLSAnnotation
16201 {
16202 before(grammarAccess.getVLSFofFormulaAccess().getAnnotationsVLSAnnotationParserRuleCall_7_1_0());
16203 pushFollow(FOLLOW_2);
16204 ruleVLSAnnotation();
16205
16206 state._fsp--;
16207
16208 after(grammarAccess.getVLSFofFormulaAccess().getAnnotationsVLSAnnotationParserRuleCall_7_1_0());
16209
16210 }
16211
16212
16213 }
16214
16215 }
16216 catch (RecognitionException re) {
16217 reportError(re);
16218 recover(input,re);
16219 }
16220 finally {
16221
16222 restoreStackSize(stackSize);
16223
16224 }
16225 return ;
16226 }
16227 // $ANTLR end "rule__VLSFofFormula__AnnotationsAssignment_7_1"
16228
16229
16230 // $ANTLR start "rule__VLSAnnotation__NameAssignment_1"
16231 // InternalVampireLanguage.g:5284:1: rule__VLSAnnotation__NameAssignment_1 : ( ( rule__VLSAnnotation__NameAlternatives_1_0 ) ) ;
16232 public final void rule__VLSAnnotation__NameAssignment_1() throws RecognitionException {
16233
16234 int stackSize = keepStackSize();
16235
16236 try {
16237 // InternalVampireLanguage.g:5288:1: ( ( ( rule__VLSAnnotation__NameAlternatives_1_0 ) ) )
16238 // InternalVampireLanguage.g:5289:2: ( ( rule__VLSAnnotation__NameAlternatives_1_0 ) )
16239 {
16240 // InternalVampireLanguage.g:5289:2: ( ( rule__VLSAnnotation__NameAlternatives_1_0 ) )
16241 // InternalVampireLanguage.g:5290:3: ( rule__VLSAnnotation__NameAlternatives_1_0 )
16242 {
16243 before(grammarAccess.getVLSAnnotationAccess().getNameAlternatives_1_0());
16244 // InternalVampireLanguage.g:5291:3: ( rule__VLSAnnotation__NameAlternatives_1_0 )
16245 // InternalVampireLanguage.g:5291:4: rule__VLSAnnotation__NameAlternatives_1_0
16246 {
16247 pushFollow(FOLLOW_2);
16248 rule__VLSAnnotation__NameAlternatives_1_0();
16249
16250 state._fsp--;
16251
16252
16253 }
16254
16255 after(grammarAccess.getVLSAnnotationAccess().getNameAlternatives_1_0());
16256
16257 }
16258
16259
16260 }
16261
16262 }
16263 catch (RecognitionException re) {
16264 reportError(re);
16265 recover(input,re);
16266 }
16267 finally {
16268
16269 restoreStackSize(stackSize);
16270
16271 }
16272 return ;
16273 }
16274 // $ANTLR end "rule__VLSAnnotation__NameAssignment_1"
16275
16276
16277 // $ANTLR start "rule__VLSAnnotation__FollowupAssignment_2_1"
16278 // InternalVampireLanguage.g:5299:1: rule__VLSAnnotation__FollowupAssignment_2_1 : ( ruleVLSAnnotationTerms ) ;
16279 public final void rule__VLSAnnotation__FollowupAssignment_2_1() throws RecognitionException {
16280
16281 int stackSize = keepStackSize();
16282
16283 try {
16284 // InternalVampireLanguage.g:5303:1: ( ( ruleVLSAnnotationTerms ) )
16285 // InternalVampireLanguage.g:5304:2: ( ruleVLSAnnotationTerms )
16286 {
16287 // InternalVampireLanguage.g:5304:2: ( ruleVLSAnnotationTerms )
16288 // InternalVampireLanguage.g:5305:3: ruleVLSAnnotationTerms
16289 {
16290 before(grammarAccess.getVLSAnnotationAccess().getFollowupVLSAnnotationTermsParserRuleCall_2_1_0());
16291 pushFollow(FOLLOW_2);
16292 ruleVLSAnnotationTerms();
16293
16294 state._fsp--;
16295
16296 after(grammarAccess.getVLSAnnotationAccess().getFollowupVLSAnnotationTermsParserRuleCall_2_1_0());
16297
16298 }
16299
16300
16301 }
16302
16303 }
16304 catch (RecognitionException re) {
16305 reportError(re);
16306 recover(input,re);
16307 }
16308 finally {
16309
16310 restoreStackSize(stackSize);
16311
16312 }
16313 return ;
16314 }
16315 // $ANTLR end "rule__VLSAnnotation__FollowupAssignment_2_1"
16316
16317
16318 // $ANTLR start "rule__VLSAnnotationTerms__TermsAssignment_0"
16319 // InternalVampireLanguage.g:5314:1: rule__VLSAnnotationTerms__TermsAssignment_0 : ( ruleVLSAnnotation ) ;
16320 public final void rule__VLSAnnotationTerms__TermsAssignment_0() throws RecognitionException {
16321
16322 int stackSize = keepStackSize();
16323
16324 try {
16325 // InternalVampireLanguage.g:5318:1: ( ( ruleVLSAnnotation ) )
16326 // InternalVampireLanguage.g:5319:2: ( ruleVLSAnnotation )
16327 {
16328 // InternalVampireLanguage.g:5319:2: ( ruleVLSAnnotation )
16329 // InternalVampireLanguage.g:5320:3: ruleVLSAnnotation
16330 {
16331 before(grammarAccess.getVLSAnnotationTermsAccess().getTermsVLSAnnotationParserRuleCall_0_0());
16332 pushFollow(FOLLOW_2);
16333 ruleVLSAnnotation();
16334
16335 state._fsp--;
16336
16337 after(grammarAccess.getVLSAnnotationTermsAccess().getTermsVLSAnnotationParserRuleCall_0_0());
16338
16339 }
16340
16341
16342 }
16343
16344 }
16345 catch (RecognitionException re) {
16346 reportError(re);
16347 recover(input,re);
16348 }
16349 finally {
16350
16351 restoreStackSize(stackSize);
16352
16353 }
16354 return ;
16355 }
16356 // $ANTLR end "rule__VLSAnnotationTerms__TermsAssignment_0"
16357
16358
16359 // $ANTLR start "rule__VLSAnnotationTerms__TermsAssignment_1_1"
16360 // InternalVampireLanguage.g:5329:1: rule__VLSAnnotationTerms__TermsAssignment_1_1 : ( ruleVLSAnnotation ) ;
16361 public final void rule__VLSAnnotationTerms__TermsAssignment_1_1() throws RecognitionException {
16362
16363 int stackSize = keepStackSize();
16364
16365 try {
16366 // InternalVampireLanguage.g:5333:1: ( ( ruleVLSAnnotation ) )
16367 // InternalVampireLanguage.g:5334:2: ( ruleVLSAnnotation )
16368 {
16369 // InternalVampireLanguage.g:5334:2: ( ruleVLSAnnotation )
16370 // InternalVampireLanguage.g:5335:3: ruleVLSAnnotation
16371 {
16372 before(grammarAccess.getVLSAnnotationTermsAccess().getTermsVLSAnnotationParserRuleCall_1_1_0());
16373 pushFollow(FOLLOW_2);
16374 ruleVLSAnnotation();
16375
16376 state._fsp--;
16377
16378 after(grammarAccess.getVLSAnnotationTermsAccess().getTermsVLSAnnotationParserRuleCall_1_1_0());
16379
16380 }
16381
16382
16383 }
16384
16385 }
16386 catch (RecognitionException re) {
16387 reportError(re);
16388 recover(input,re);
16389 }
16390 finally {
16391
16392 restoreStackSize(stackSize);
16393
16394 }
16395 return ;
16396 }
16397 // $ANTLR end "rule__VLSAnnotationTerms__TermsAssignment_1_1"
16398
16399
16400 // $ANTLR start "rule__VLSBinary__RightAssignment_1_0_1"
16401 // InternalVampireLanguage.g:5344:1: rule__VLSBinary__RightAssignment_1_0_1 : ( ruleVLSUnitaryFormula ) ;
16402 public final void rule__VLSBinary__RightAssignment_1_0_1() throws RecognitionException {
16403
16404 int stackSize = keepStackSize();
16405
16406 try {
16407 // InternalVampireLanguage.g:5348:1: ( ( ruleVLSUnitaryFormula ) )
16408 // InternalVampireLanguage.g:5349:2: ( ruleVLSUnitaryFormula )
16409 {
16410 // InternalVampireLanguage.g:5349:2: ( ruleVLSUnitaryFormula )
16411 // InternalVampireLanguage.g:5350:3: ruleVLSUnitaryFormula
16412 {
16413 before(grammarAccess.getVLSBinaryAccess().getRightVLSUnitaryFormulaParserRuleCall_1_0_1_0());
16414 pushFollow(FOLLOW_2);
16415 ruleVLSUnitaryFormula();
16416
16417 state._fsp--;
16418
16419 after(grammarAccess.getVLSBinaryAccess().getRightVLSUnitaryFormulaParserRuleCall_1_0_1_0());
16420
16421 }
16422
16423
16424 }
16425
16426 }
16427 catch (RecognitionException re) {
16428 reportError(re);
16429 recover(input,re);
16430 }
16431 finally {
16432
16433 restoreStackSize(stackSize);
16434
16435 }
16436 return ;
16437 }
16438 // $ANTLR end "rule__VLSBinary__RightAssignment_1_0_1"
16439
16440
16441 // $ANTLR start "rule__VLSBinary__RightAssignment_1_1_2"
16442 // InternalVampireLanguage.g:5359:1: rule__VLSBinary__RightAssignment_1_1_2 : ( ruleVLSUnitaryFormula ) ;
16443 public final void rule__VLSBinary__RightAssignment_1_1_2() throws RecognitionException {
16444
16445 int stackSize = keepStackSize();
16446
16447 try {
16448 // InternalVampireLanguage.g:5363:1: ( ( ruleVLSUnitaryFormula ) )
16449 // InternalVampireLanguage.g:5364:2: ( ruleVLSUnitaryFormula )
16450 {
16451 // InternalVampireLanguage.g:5364:2: ( ruleVLSUnitaryFormula )
16452 // InternalVampireLanguage.g:5365:3: ruleVLSUnitaryFormula
16453 {
16454 before(grammarAccess.getVLSBinaryAccess().getRightVLSUnitaryFormulaParserRuleCall_1_1_2_0());
16455 pushFollow(FOLLOW_2);
16456 ruleVLSUnitaryFormula();
16457
16458 state._fsp--;
16459
16460 after(grammarAccess.getVLSBinaryAccess().getRightVLSUnitaryFormulaParserRuleCall_1_1_2_0());
16461
16462 }
16463
16464
16465 }
16466
16467 }
16468 catch (RecognitionException re) {
16469 reportError(re);
16470 recover(input,re);
16471 }
16472 finally {
16473
16474 restoreStackSize(stackSize);
16475
16476 }
16477 return ;
16478 }
16479 // $ANTLR end "rule__VLSBinary__RightAssignment_1_1_2"
16480
16481
16482 // $ANTLR start "rule__VLSBinary__RightAssignment_1_2_2"
16483 // InternalVampireLanguage.g:5374:1: rule__VLSBinary__RightAssignment_1_2_2 : ( ruleVLSUnitaryFormula ) ;
16484 public final void rule__VLSBinary__RightAssignment_1_2_2() throws RecognitionException {
16485
16486 int stackSize = keepStackSize();
16487
16488 try {
16489 // InternalVampireLanguage.g:5378:1: ( ( ruleVLSUnitaryFormula ) )
16490 // InternalVampireLanguage.g:5379:2: ( ruleVLSUnitaryFormula )
16491 {
16492 // InternalVampireLanguage.g:5379:2: ( ruleVLSUnitaryFormula )
16493 // InternalVampireLanguage.g:5380:3: ruleVLSUnitaryFormula
16494 {
16495 before(grammarAccess.getVLSBinaryAccess().getRightVLSUnitaryFormulaParserRuleCall_1_2_2_0());
16496 pushFollow(FOLLOW_2);
16497 ruleVLSUnitaryFormula();
16498
16499 state._fsp--;
16500
16501 after(grammarAccess.getVLSBinaryAccess().getRightVLSUnitaryFormulaParserRuleCall_1_2_2_0());
16502
16503 }
16504
16505
16506 }
16507
16508 }
16509 catch (RecognitionException re) {
16510 reportError(re);
16511 recover(input,re);
16512 }
16513 finally {
16514
16515 restoreStackSize(stackSize);
16516
16517 }
16518 return ;
16519 }
16520 // $ANTLR end "rule__VLSBinary__RightAssignment_1_2_2"
16521
16522
16523 // $ANTLR start "rule__VLSUniversalQuantifier__VariablesAssignment_1_2"
16524 // InternalVampireLanguage.g:5389:1: rule__VLSUniversalQuantifier__VariablesAssignment_1_2 : ( ruleVLSVariable ) ;
16525 public final void rule__VLSUniversalQuantifier__VariablesAssignment_1_2() throws RecognitionException {
16526
16527 int stackSize = keepStackSize();
16528
16529 try {
16530 // InternalVampireLanguage.g:5393:1: ( ( ruleVLSVariable ) )
16531 // InternalVampireLanguage.g:5394:2: ( ruleVLSVariable )
16532 {
16533 // InternalVampireLanguage.g:5394:2: ( ruleVLSVariable )
16534 // InternalVampireLanguage.g:5395:3: ruleVLSVariable
16535 {
16536 before(grammarAccess.getVLSUniversalQuantifierAccess().getVariablesVLSVariableParserRuleCall_1_2_0());
16537 pushFollow(FOLLOW_2);
16538 ruleVLSVariable();
16539
16540 state._fsp--;
16541
16542 after(grammarAccess.getVLSUniversalQuantifierAccess().getVariablesVLSVariableParserRuleCall_1_2_0());
16543
16544 }
16545
16546
16547 }
16548
16549 }
16550 catch (RecognitionException re) {
16551 reportError(re);
16552 recover(input,re);
16553 }
16554 finally {
16555
16556 restoreStackSize(stackSize);
16557
16558 }
16559 return ;
16560 }
16561 // $ANTLR end "rule__VLSUniversalQuantifier__VariablesAssignment_1_2"
16562
16563
16564 // $ANTLR start "rule__VLSUniversalQuantifier__VariablesAssignment_1_3_1"
16565 // InternalVampireLanguage.g:5404:1: rule__VLSUniversalQuantifier__VariablesAssignment_1_3_1 : ( ruleVLSVariable ) ;
16566 public final void rule__VLSUniversalQuantifier__VariablesAssignment_1_3_1() throws RecognitionException {
16567
16568 int stackSize = keepStackSize();
16569
16570 try {
16571 // InternalVampireLanguage.g:5408:1: ( ( ruleVLSVariable ) )
16572 // InternalVampireLanguage.g:5409:2: ( ruleVLSVariable )
16573 {
16574 // InternalVampireLanguage.g:5409:2: ( ruleVLSVariable )
16575 // InternalVampireLanguage.g:5410:3: ruleVLSVariable
16576 {
16577 before(grammarAccess.getVLSUniversalQuantifierAccess().getVariablesVLSVariableParserRuleCall_1_3_1_0());
16578 pushFollow(FOLLOW_2);
16579 ruleVLSVariable();
16580
16581 state._fsp--;
16582
16583 after(grammarAccess.getVLSUniversalQuantifierAccess().getVariablesVLSVariableParserRuleCall_1_3_1_0());
16584
16585 }
16586
16587
16588 }
16589
16590 }
16591 catch (RecognitionException re) {
16592 reportError(re);
16593 recover(input,re);
16594 }
16595 finally {
16596
16597 restoreStackSize(stackSize);
16598
16599 }
16600 return ;
16601 }
16602 // $ANTLR end "rule__VLSUniversalQuantifier__VariablesAssignment_1_3_1"
16603
16604
16605 // $ANTLR start "rule__VLSUniversalQuantifier__OperandAssignment_2"
16606 // InternalVampireLanguage.g:5419:1: rule__VLSUniversalQuantifier__OperandAssignment_2 : ( ruleVLSUnitaryFormula ) ;
16607 public final void rule__VLSUniversalQuantifier__OperandAssignment_2() throws RecognitionException {
16608
16609 int stackSize = keepStackSize();
16610
16611 try {
16612 // InternalVampireLanguage.g:5423:1: ( ( ruleVLSUnitaryFormula ) )
16613 // InternalVampireLanguage.g:5424:2: ( ruleVLSUnitaryFormula )
16614 {
16615 // InternalVampireLanguage.g:5424:2: ( ruleVLSUnitaryFormula )
16616 // InternalVampireLanguage.g:5425:3: ruleVLSUnitaryFormula
16617 {
16618 before(grammarAccess.getVLSUniversalQuantifierAccess().getOperandVLSUnitaryFormulaParserRuleCall_2_0());
16619 pushFollow(FOLLOW_2);
16620 ruleVLSUnitaryFormula();
16621
16622 state._fsp--;
16623
16624 after(grammarAccess.getVLSUniversalQuantifierAccess().getOperandVLSUnitaryFormulaParserRuleCall_2_0());
16625
16626 }
16627
16628
16629 }
16630
16631 }
16632 catch (RecognitionException re) {
16633 reportError(re);
16634 recover(input,re);
16635 }
16636 finally {
16637
16638 restoreStackSize(stackSize);
16639
16640 }
16641 return ;
16642 }
16643 // $ANTLR end "rule__VLSUniversalQuantifier__OperandAssignment_2"
16644
16645
16646 // $ANTLR start "rule__VLSExistentialQuantifier__VariablesAssignment_1_2"
16647 // InternalVampireLanguage.g:5434:1: rule__VLSExistentialQuantifier__VariablesAssignment_1_2 : ( ruleVLSVariable ) ;
16648 public final void rule__VLSExistentialQuantifier__VariablesAssignment_1_2() throws RecognitionException {
16649
16650 int stackSize = keepStackSize();
16651
16652 try {
16653 // InternalVampireLanguage.g:5438:1: ( ( ruleVLSVariable ) )
16654 // InternalVampireLanguage.g:5439:2: ( ruleVLSVariable )
16655 {
16656 // InternalVampireLanguage.g:5439:2: ( ruleVLSVariable )
16657 // InternalVampireLanguage.g:5440:3: ruleVLSVariable
16658 {
16659 before(grammarAccess.getVLSExistentialQuantifierAccess().getVariablesVLSVariableParserRuleCall_1_2_0());
16660 pushFollow(FOLLOW_2);
16661 ruleVLSVariable();
16662
16663 state._fsp--;
16664
16665 after(grammarAccess.getVLSExistentialQuantifierAccess().getVariablesVLSVariableParserRuleCall_1_2_0());
16666
16667 }
16668
16669
16670 }
16671
16672 }
16673 catch (RecognitionException re) {
16674 reportError(re);
16675 recover(input,re);
16676 }
16677 finally {
16678
16679 restoreStackSize(stackSize);
16680
16681 }
16682 return ;
16683 }
16684 // $ANTLR end "rule__VLSExistentialQuantifier__VariablesAssignment_1_2"
16685
16686
16687 // $ANTLR start "rule__VLSExistentialQuantifier__VariablesAssignment_1_3_1"
16688 // InternalVampireLanguage.g:5449:1: rule__VLSExistentialQuantifier__VariablesAssignment_1_3_1 : ( ruleVLSVariable ) ;
16689 public final void rule__VLSExistentialQuantifier__VariablesAssignment_1_3_1() throws RecognitionException {
16690
16691 int stackSize = keepStackSize();
16692
16693 try {
16694 // InternalVampireLanguage.g:5453:1: ( ( ruleVLSVariable ) )
16695 // InternalVampireLanguage.g:5454:2: ( ruleVLSVariable )
16696 {
16697 // InternalVampireLanguage.g:5454:2: ( ruleVLSVariable )
16698 // InternalVampireLanguage.g:5455:3: ruleVLSVariable
16699 {
16700 before(grammarAccess.getVLSExistentialQuantifierAccess().getVariablesVLSVariableParserRuleCall_1_3_1_0());
16701 pushFollow(FOLLOW_2);
16702 ruleVLSVariable();
16703
16704 state._fsp--;
16705
16706 after(grammarAccess.getVLSExistentialQuantifierAccess().getVariablesVLSVariableParserRuleCall_1_3_1_0());
16707
16708 }
16709
16710
16711 }
16712
16713 }
16714 catch (RecognitionException re) {
16715 reportError(re);
16716 recover(input,re);
16717 }
16718 finally {
16719
16720 restoreStackSize(stackSize);
16721
16722 }
16723 return ;
16724 }
16725 // $ANTLR end "rule__VLSExistentialQuantifier__VariablesAssignment_1_3_1"
16726
16727
16728 // $ANTLR start "rule__VLSExistentialQuantifier__OperandAssignment_2"
16729 // InternalVampireLanguage.g:5464:1: rule__VLSExistentialQuantifier__OperandAssignment_2 : ( ruleVLSUnitaryFormula ) ;
16730 public final void rule__VLSExistentialQuantifier__OperandAssignment_2() throws RecognitionException {
16731
16732 int stackSize = keepStackSize();
16733
16734 try {
16735 // InternalVampireLanguage.g:5468:1: ( ( ruleVLSUnitaryFormula ) )
16736 // InternalVampireLanguage.g:5469:2: ( ruleVLSUnitaryFormula )
16737 {
16738 // InternalVampireLanguage.g:5469:2: ( ruleVLSUnitaryFormula )
16739 // InternalVampireLanguage.g:5470:3: ruleVLSUnitaryFormula
16740 {
16741 before(grammarAccess.getVLSExistentialQuantifierAccess().getOperandVLSUnitaryFormulaParserRuleCall_2_0());
16742 pushFollow(FOLLOW_2);
16743 ruleVLSUnitaryFormula();
16744
16745 state._fsp--;
16746
16747 after(grammarAccess.getVLSExistentialQuantifierAccess().getOperandVLSUnitaryFormulaParserRuleCall_2_0());
16748
16749 }
16750
16751
16752 }
16753
16754 }
16755 catch (RecognitionException re) {
16756 reportError(re);
16757 recover(input,re);
16758 }
16759 finally {
16760
16761 restoreStackSize(stackSize);
16762
16763 }
16764 return ;
16765 }
16766 // $ANTLR end "rule__VLSExistentialQuantifier__OperandAssignment_2"
16767
16768
16769 // $ANTLR start "rule__VLSUnaryNegation__OperandAssignment_2"
16770 // InternalVampireLanguage.g:5479:1: rule__VLSUnaryNegation__OperandAssignment_2 : ( ruleVLSUnitaryFormula ) ;
16771 public final void rule__VLSUnaryNegation__OperandAssignment_2() throws RecognitionException {
16772
16773 int stackSize = keepStackSize();
16774
16775 try {
16776 // InternalVampireLanguage.g:5483:1: ( ( ruleVLSUnitaryFormula ) )
16777 // InternalVampireLanguage.g:5484:2: ( ruleVLSUnitaryFormula )
16778 {
16779 // InternalVampireLanguage.g:5484:2: ( ruleVLSUnitaryFormula )
16780 // InternalVampireLanguage.g:5485:3: ruleVLSUnitaryFormula
16781 {
16782 before(grammarAccess.getVLSUnaryNegationAccess().getOperandVLSUnitaryFormulaParserRuleCall_2_0());
16783 pushFollow(FOLLOW_2);
16784 ruleVLSUnitaryFormula();
16785
16786 state._fsp--;
16787
16788 after(grammarAccess.getVLSUnaryNegationAccess().getOperandVLSUnitaryFormulaParserRuleCall_2_0());
16789
16790 }
16791
16792
16793 }
16794
16795 }
16796 catch (RecognitionException re) {
16797 reportError(re);
16798 recover(input,re);
16799 }
16800 finally {
16801
16802 restoreStackSize(stackSize);
16803
16804 }
16805 return ;
16806 }
16807 // $ANTLR end "rule__VLSUnaryNegation__OperandAssignment_2"
16808
16809
16810 // $ANTLR start "rule__VLSUnaryInfix__RightAssignment_1_1"
16811 // InternalVampireLanguage.g:5494:1: rule__VLSUnaryInfix__RightAssignment_1_1 : ( ruleVLSAtomic ) ;
16812 public final void rule__VLSUnaryInfix__RightAssignment_1_1() throws RecognitionException {
16813
16814 int stackSize = keepStackSize();
16815
16816 try {
16817 // InternalVampireLanguage.g:5498:1: ( ( ruleVLSAtomic ) )
16818 // InternalVampireLanguage.g:5499:2: ( ruleVLSAtomic )
16819 {
16820 // InternalVampireLanguage.g:5499:2: ( ruleVLSAtomic )
16821 // InternalVampireLanguage.g:5500:3: ruleVLSAtomic
16822 {
16823 before(grammarAccess.getVLSUnaryInfixAccess().getRightVLSAtomicParserRuleCall_1_1_0());
16824 pushFollow(FOLLOW_2);
16825 ruleVLSAtomic();
16826
16827 state._fsp--;
16828
16829 after(grammarAccess.getVLSUnaryInfixAccess().getRightVLSAtomicParserRuleCall_1_1_0());
16830
16831 }
16832
16833
16834 }
16835
16836 }
16837 catch (RecognitionException re) {
16838 reportError(re);
16839 recover(input,re);
16840 }
16841 finally {
16842
16843 restoreStackSize(stackSize);
16844
16845 }
16846 return ;
16847 }
16848 // $ANTLR end "rule__VLSUnaryInfix__RightAssignment_1_1"
16849
16850
16851 // $ANTLR start "rule__VLSAtomicConstant__NameAssignment_0_1"
16852 // InternalVampireLanguage.g:5509:1: rule__VLSAtomicConstant__NameAssignment_0_1 : ( ( rule__VLSAtomicConstant__NameAlternatives_0_1_0 ) ) ;
16853 public final void rule__VLSAtomicConstant__NameAssignment_0_1() throws RecognitionException {
16854
16855 int stackSize = keepStackSize();
16856
16857 try {
16858 // InternalVampireLanguage.g:5513:1: ( ( ( rule__VLSAtomicConstant__NameAlternatives_0_1_0 ) ) )
16859 // InternalVampireLanguage.g:5514:2: ( ( rule__VLSAtomicConstant__NameAlternatives_0_1_0 ) )
16860 {
16861 // InternalVampireLanguage.g:5514:2: ( ( rule__VLSAtomicConstant__NameAlternatives_0_1_0 ) )
16862 // InternalVampireLanguage.g:5515:3: ( rule__VLSAtomicConstant__NameAlternatives_0_1_0 )
16863 {
16864 before(grammarAccess.getVLSAtomicConstantAccess().getNameAlternatives_0_1_0());
16865 // InternalVampireLanguage.g:5516:3: ( rule__VLSAtomicConstant__NameAlternatives_0_1_0 )
16866 // InternalVampireLanguage.g:5516:4: rule__VLSAtomicConstant__NameAlternatives_0_1_0
16867 {
16868 pushFollow(FOLLOW_2);
16869 rule__VLSAtomicConstant__NameAlternatives_0_1_0();
16870
16871 state._fsp--;
16872
16873
16874 }
16875
16876 after(grammarAccess.getVLSAtomicConstantAccess().getNameAlternatives_0_1_0());
16877
16878 }
16879
16880
16881 }
16882
16883 }
16884 catch (RecognitionException re) {
16885 reportError(re);
16886 recover(input,re);
16887 }
16888 finally {
16889
16890 restoreStackSize(stackSize);
16891
16892 }
16893 return ;
16894 }
16895 // $ANTLR end "rule__VLSAtomicConstant__NameAssignment_0_1"
16896
16897
16898 // $ANTLR start "rule__VLSAtomicFunction__ConstantAssignment_0_1"
16899 // InternalVampireLanguage.g:5524:1: rule__VLSAtomicFunction__ConstantAssignment_0_1 : ( ( rule__VLSAtomicFunction__ConstantAlternatives_0_1_0 ) ) ;
16900 public final void rule__VLSAtomicFunction__ConstantAssignment_0_1() throws RecognitionException {
16901
16902 int stackSize = keepStackSize();
16903
16904 try {
16905 // InternalVampireLanguage.g:5528:1: ( ( ( rule__VLSAtomicFunction__ConstantAlternatives_0_1_0 ) ) )
16906 // InternalVampireLanguage.g:5529:2: ( ( rule__VLSAtomicFunction__ConstantAlternatives_0_1_0 ) )
16907 {
16908 // InternalVampireLanguage.g:5529:2: ( ( rule__VLSAtomicFunction__ConstantAlternatives_0_1_0 ) )
16909 // InternalVampireLanguage.g:5530:3: ( rule__VLSAtomicFunction__ConstantAlternatives_0_1_0 )
16910 {
16911 before(grammarAccess.getVLSAtomicFunctionAccess().getConstantAlternatives_0_1_0());
16912 // InternalVampireLanguage.g:5531:3: ( rule__VLSAtomicFunction__ConstantAlternatives_0_1_0 )
16913 // InternalVampireLanguage.g:5531:4: rule__VLSAtomicFunction__ConstantAlternatives_0_1_0
16914 {
16915 pushFollow(FOLLOW_2);
16916 rule__VLSAtomicFunction__ConstantAlternatives_0_1_0();
16917
16918 state._fsp--;
16919
16920
16921 }
16922
16923 after(grammarAccess.getVLSAtomicFunctionAccess().getConstantAlternatives_0_1_0());
16924
16925 }
16926
16927
16928 }
16929
16930 }
16931 catch (RecognitionException re) {
16932 reportError(re);
16933 recover(input,re);
16934 }
16935 finally {
16936
16937 restoreStackSize(stackSize);
16938
16939 }
16940 return ;
16941 }
16942 // $ANTLR end "rule__VLSAtomicFunction__ConstantAssignment_0_1"
16943
16944
16945 // $ANTLR start "rule__VLSAtomicFunction__TermsAssignment_0_2_1"
16946 // InternalVampireLanguage.g:5539:1: rule__VLSAtomicFunction__TermsAssignment_0_2_1 : ( ruleVLSFofTerm ) ;
16947 public final void rule__VLSAtomicFunction__TermsAssignment_0_2_1() throws RecognitionException {
16948
16949 int stackSize = keepStackSize();
16950
16951 try {
16952 // InternalVampireLanguage.g:5543:1: ( ( ruleVLSFofTerm ) )
16953 // InternalVampireLanguage.g:5544:2: ( ruleVLSFofTerm )
16954 {
16955 // InternalVampireLanguage.g:5544:2: ( ruleVLSFofTerm )
16956 // InternalVampireLanguage.g:5545:3: ruleVLSFofTerm
16957 {
16958 before(grammarAccess.getVLSAtomicFunctionAccess().getTermsVLSFofTermParserRuleCall_0_2_1_0());
16959 pushFollow(FOLLOW_2);
16960 ruleVLSFofTerm();
16961
16962 state._fsp--;
16963
16964 after(grammarAccess.getVLSAtomicFunctionAccess().getTermsVLSFofTermParserRuleCall_0_2_1_0());
16965
16966 }
16967
16968
16969 }
16970
16971 }
16972 catch (RecognitionException re) {
16973 reportError(re);
16974 recover(input,re);
16975 }
16976 finally {
16977
16978 restoreStackSize(stackSize);
16979
16980 }
16981 return ;
16982 }
16983 // $ANTLR end "rule__VLSAtomicFunction__TermsAssignment_0_2_1"
16984
16985
16986 // $ANTLR start "rule__VLSAtomicFunction__TermsAssignment_0_2_2_1"
16987 // InternalVampireLanguage.g:5554:1: rule__VLSAtomicFunction__TermsAssignment_0_2_2_1 : ( ruleVLSFofTerm ) ;
16988 public final void rule__VLSAtomicFunction__TermsAssignment_0_2_2_1() throws RecognitionException {
16989
16990 int stackSize = keepStackSize();
16991
16992 try {
16993 // InternalVampireLanguage.g:5558:1: ( ( ruleVLSFofTerm ) )
16994 // InternalVampireLanguage.g:5559:2: ( ruleVLSFofTerm )
16995 {
16996 // InternalVampireLanguage.g:5559:2: ( ruleVLSFofTerm )
16997 // InternalVampireLanguage.g:5560:3: ruleVLSFofTerm
16998 {
16999 before(grammarAccess.getVLSAtomicFunctionAccess().getTermsVLSFofTermParserRuleCall_0_2_2_1_0());
17000 pushFollow(FOLLOW_2);
17001 ruleVLSFofTerm();
17002
17003 state._fsp--;
17004
17005 after(grammarAccess.getVLSAtomicFunctionAccess().getTermsVLSFofTermParserRuleCall_0_2_2_1_0());
17006
17007 }
17008
17009
17010 }
17011
17012 }
17013 catch (RecognitionException re) {
17014 reportError(re);
17015 recover(input,re);
17016 }
17017 finally {
17018
17019 restoreStackSize(stackSize);
17020
17021 }
17022 return ;
17023 }
17024 // $ANTLR end "rule__VLSAtomicFunction__TermsAssignment_0_2_2_1"
17025
17026
17027 // $ANTLR start "rule__VLSAtomicFunction__NameAssignment_1_1"
17028 // InternalVampireLanguage.g:5569:1: rule__VLSAtomicFunction__NameAssignment_1_1 : ( ( '$less' ) ) ;
17029 public final void rule__VLSAtomicFunction__NameAssignment_1_1() throws RecognitionException {
17030
17031 int stackSize = keepStackSize();
17032
17033 try {
17034 // InternalVampireLanguage.g:5573:1: ( ( ( '$less' ) ) )
17035 // InternalVampireLanguage.g:5574:2: ( ( '$less' ) )
17036 {
17037 // InternalVampireLanguage.g:5574:2: ( ( '$less' ) )
17038 // InternalVampireLanguage.g:5575:3: ( '$less' )
17039 {
17040 before(grammarAccess.getVLSAtomicFunctionAccess().getNameLessKeyword_1_1_0());
17041 // InternalVampireLanguage.g:5576:3: ( '$less' )
17042 // InternalVampireLanguage.g:5577:4: '$less'
17043 {
17044 before(grammarAccess.getVLSAtomicFunctionAccess().getNameLessKeyword_1_1_0());
17045 match(input,68,FOLLOW_2);
17046 after(grammarAccess.getVLSAtomicFunctionAccess().getNameLessKeyword_1_1_0());
17047
17048 }
17049
17050 after(grammarAccess.getVLSAtomicFunctionAccess().getNameLessKeyword_1_1_0());
17051
17052 }
17053
17054
17055 }
17056
17057 }
17058 catch (RecognitionException re) {
17059 reportError(re);
17060 recover(input,re);
17061 }
17062 finally {
17063
17064 restoreStackSize(stackSize);
17065
17066 }
17067 return ;
17068 }
17069 // $ANTLR end "rule__VLSAtomicFunction__NameAssignment_1_1"
17070
17071
17072 // $ANTLR start "rule__VLSAtomicFunction__TermsAssignment_1_3"
17073 // InternalVampireLanguage.g:5588:1: rule__VLSAtomicFunction__TermsAssignment_1_3 : ( ruleVLSFofTerm ) ;
17074 public final void rule__VLSAtomicFunction__TermsAssignment_1_3() throws RecognitionException {
17075
17076 int stackSize = keepStackSize();
17077
17078 try {
17079 // InternalVampireLanguage.g:5592:1: ( ( ruleVLSFofTerm ) )
17080 // InternalVampireLanguage.g:5593:2: ( ruleVLSFofTerm )
17081 {
17082 // InternalVampireLanguage.g:5593:2: ( ruleVLSFofTerm )
17083 // InternalVampireLanguage.g:5594:3: ruleVLSFofTerm
17084 {
17085 before(grammarAccess.getVLSAtomicFunctionAccess().getTermsVLSFofTermParserRuleCall_1_3_0());
17086 pushFollow(FOLLOW_2);
17087 ruleVLSFofTerm();
17088
17089 state._fsp--;
17090
17091 after(grammarAccess.getVLSAtomicFunctionAccess().getTermsVLSFofTermParserRuleCall_1_3_0());
17092
17093 }
17094
17095
17096 }
17097
17098 }
17099 catch (RecognitionException re) {
17100 reportError(re);
17101 recover(input,re);
17102 }
17103 finally {
17104
17105 restoreStackSize(stackSize);
17106
17107 }
17108 return ;
17109 }
17110 // $ANTLR end "rule__VLSAtomicFunction__TermsAssignment_1_3"
17111
17112
17113 // $ANTLR start "rule__VLSAtomicFunction__TermsAssignment_1_5"
17114 // InternalVampireLanguage.g:5603:1: rule__VLSAtomicFunction__TermsAssignment_1_5 : ( ruleVLSFofTerm ) ;
17115 public final void rule__VLSAtomicFunction__TermsAssignment_1_5() throws RecognitionException {
17116
17117 int stackSize = keepStackSize();
17118
17119 try {
17120 // InternalVampireLanguage.g:5607:1: ( ( ruleVLSFofTerm ) )
17121 // InternalVampireLanguage.g:5608:2: ( ruleVLSFofTerm )
17122 {
17123 // InternalVampireLanguage.g:5608:2: ( ruleVLSFofTerm )
17124 // InternalVampireLanguage.g:5609:3: ruleVLSFofTerm
17125 {
17126 before(grammarAccess.getVLSAtomicFunctionAccess().getTermsVLSFofTermParserRuleCall_1_5_0());
17127 pushFollow(FOLLOW_2);
17128 ruleVLSFofTerm();
17129
17130 state._fsp--;
17131
17132 after(grammarAccess.getVLSAtomicFunctionAccess().getTermsVLSFofTermParserRuleCall_1_5_0());
17133
17134 }
17135
17136
17137 }
17138
17139 }
17140 catch (RecognitionException re) {
17141 reportError(re);
17142 recover(input,re);
17143 }
17144 finally {
17145
17146 restoreStackSize(stackSize);
17147
17148 }
17149 return ;
17150 }
17151 // $ANTLR end "rule__VLSAtomicFunction__TermsAssignment_1_5"
17152
17153
17154 // $ANTLR start "rule__VLSVariable__NameAssignment"
17155 // InternalVampireLanguage.g:5618:1: rule__VLSVariable__NameAssignment : ( RULE_UPPER_WORD_ID ) ;
17156 public final void rule__VLSVariable__NameAssignment() throws RecognitionException {
17157
17158 int stackSize = keepStackSize();
17159
17160 try {
17161 // InternalVampireLanguage.g:5622:1: ( ( RULE_UPPER_WORD_ID ) )
17162 // InternalVampireLanguage.g:5623:2: ( RULE_UPPER_WORD_ID )
17163 {
17164 // InternalVampireLanguage.g:5623:2: ( RULE_UPPER_WORD_ID )
17165 // InternalVampireLanguage.g:5624:3: RULE_UPPER_WORD_ID
17166 {
17167 before(grammarAccess.getVLSVariableAccess().getNameUPPER_WORD_IDTerminalRuleCall_0());
17168 match(input,RULE_UPPER_WORD_ID,FOLLOW_2);
17169 after(grammarAccess.getVLSVariableAccess().getNameUPPER_WORD_IDTerminalRuleCall_0());
17170
17171 }
17172
17173
17174 }
17175
17176 }
17177 catch (RecognitionException re) {
17178 reportError(re);
17179 recover(input,re);
17180 }
17181 finally {
17182
17183 restoreStackSize(stackSize);
17184
17185 }
17186 return ;
17187 }
17188 // $ANTLR end "rule__VLSVariable__NameAssignment"
17189
17190
17191 // $ANTLR start "rule__VLSFunctionFof__FunctorAssignment_0"
17192 // InternalVampireLanguage.g:5633:1: rule__VLSFunctionFof__FunctorAssignment_0 : ( ( rule__VLSFunctionFof__FunctorAlternatives_0_0 ) ) ;
17193 public final void rule__VLSFunctionFof__FunctorAssignment_0() throws RecognitionException {
17194
17195 int stackSize = keepStackSize();
17196
17197 try {
17198 // InternalVampireLanguage.g:5637:1: ( ( ( rule__VLSFunctionFof__FunctorAlternatives_0_0 ) ) )
17199 // InternalVampireLanguage.g:5638:2: ( ( rule__VLSFunctionFof__FunctorAlternatives_0_0 ) )
17200 {
17201 // InternalVampireLanguage.g:5638:2: ( ( rule__VLSFunctionFof__FunctorAlternatives_0_0 ) )
17202 // InternalVampireLanguage.g:5639:3: ( rule__VLSFunctionFof__FunctorAlternatives_0_0 )
17203 {
17204 before(grammarAccess.getVLSFunctionFofAccess().getFunctorAlternatives_0_0());
17205 // InternalVampireLanguage.g:5640:3: ( rule__VLSFunctionFof__FunctorAlternatives_0_0 )
17206 // InternalVampireLanguage.g:5640:4: rule__VLSFunctionFof__FunctorAlternatives_0_0
17207 {
17208 pushFollow(FOLLOW_2);
17209 rule__VLSFunctionFof__FunctorAlternatives_0_0();
17210
17211 state._fsp--;
17212
17213
17214 }
17215
17216 after(grammarAccess.getVLSFunctionFofAccess().getFunctorAlternatives_0_0());
17217
17218 }
17219
17220
17221 }
17222
17223 }
17224 catch (RecognitionException re) {
17225 reportError(re);
17226 recover(input,re);
17227 }
17228 finally {
17229
17230 restoreStackSize(stackSize);
17231
17232 }
17233 return ;
17234 }
17235 // $ANTLR end "rule__VLSFunctionFof__FunctorAssignment_0"
17236
17237
17238 // $ANTLR start "rule__VLSFunctionFof__TermsAssignment_1_1"
17239 // InternalVampireLanguage.g:5648:1: rule__VLSFunctionFof__TermsAssignment_1_1 : ( ruleVLSFofTerm ) ;
17240 public final void rule__VLSFunctionFof__TermsAssignment_1_1() throws RecognitionException {
17241
17242 int stackSize = keepStackSize();
17243
17244 try {
17245 // InternalVampireLanguage.g:5652:1: ( ( ruleVLSFofTerm ) )
17246 // InternalVampireLanguage.g:5653:2: ( ruleVLSFofTerm )
17247 {
17248 // InternalVampireLanguage.g:5653:2: ( ruleVLSFofTerm )
17249 // InternalVampireLanguage.g:5654:3: ruleVLSFofTerm
17250 {
17251 before(grammarAccess.getVLSFunctionFofAccess().getTermsVLSFofTermParserRuleCall_1_1_0());
17252 pushFollow(FOLLOW_2);
17253 ruleVLSFofTerm();
17254
17255 state._fsp--;
17256
17257 after(grammarAccess.getVLSFunctionFofAccess().getTermsVLSFofTermParserRuleCall_1_1_0());
17258
17259 }
17260
17261
17262 }
17263
17264 }
17265 catch (RecognitionException re) {
17266 reportError(re);
17267 recover(input,re);
17268 }
17269 finally {
17270
17271 restoreStackSize(stackSize);
17272
17273 }
17274 return ;
17275 }
17276 // $ANTLR end "rule__VLSFunctionFof__TermsAssignment_1_1"
17277
17278
17279 // $ANTLR start "rule__VLSFunctionFof__TermsAssignment_1_2_1"
17280 // InternalVampireLanguage.g:5663:1: rule__VLSFunctionFof__TermsAssignment_1_2_1 : ( ruleVLSFofTerm ) ;
17281 public final void rule__VLSFunctionFof__TermsAssignment_1_2_1() throws RecognitionException {
17282
17283 int stackSize = keepStackSize();
17284
17285 try {
17286 // InternalVampireLanguage.g:5667:1: ( ( ruleVLSFofTerm ) )
17287 // InternalVampireLanguage.g:5668:2: ( ruleVLSFofTerm )
17288 {
17289 // InternalVampireLanguage.g:5668:2: ( ruleVLSFofTerm )
17290 // InternalVampireLanguage.g:5669:3: ruleVLSFofTerm
17291 {
17292 before(grammarAccess.getVLSFunctionFofAccess().getTermsVLSFofTermParserRuleCall_1_2_1_0());
17293 pushFollow(FOLLOW_2);
17294 ruleVLSFofTerm();
17295
17296 state._fsp--;
17297
17298 after(grammarAccess.getVLSFunctionFofAccess().getTermsVLSFofTermParserRuleCall_1_2_1_0());
17299
17300 }
17301
17302
17303 }
17304
17305 }
17306 catch (RecognitionException re) {
17307 reportError(re);
17308 recover(input,re);
17309 }
17310 finally {
17311
17312 restoreStackSize(stackSize);
17313
17314 }
17315 return ;
17316 }
17317 // $ANTLR end "rule__VLSFunctionFof__TermsAssignment_1_2_1"
17318
17319
17320 // $ANTLR start "rule__VLSDefinedTerm__ValueAssignment_0_1"
17321 // InternalVampireLanguage.g:5678:1: rule__VLSDefinedTerm__ValueAssignment_0_1 : ( RULE_SIGNED_LITERAL ) ;
17322 public final void rule__VLSDefinedTerm__ValueAssignment_0_1() throws RecognitionException {
17323
17324 int stackSize = keepStackSize();
17325
17326 try {
17327 // InternalVampireLanguage.g:5682:1: ( ( RULE_SIGNED_LITERAL ) )
17328 // InternalVampireLanguage.g:5683:2: ( RULE_SIGNED_LITERAL )
17329 {
17330 // InternalVampireLanguage.g:5683:2: ( RULE_SIGNED_LITERAL )
17331 // InternalVampireLanguage.g:5684:3: RULE_SIGNED_LITERAL
17332 {
17333 before(grammarAccess.getVLSDefinedTermAccess().getValueSIGNED_LITERALTerminalRuleCall_0_1_0());
17334 match(input,RULE_SIGNED_LITERAL,FOLLOW_2);
17335 after(grammarAccess.getVLSDefinedTermAccess().getValueSIGNED_LITERALTerminalRuleCall_0_1_0());
17336
17337 }
17338
17339
17340 }
17341
17342 }
17343 catch (RecognitionException re) {
17344 reportError(re);
17345 recover(input,re);
17346 }
17347 finally {
17348
17349 restoreStackSize(stackSize);
17350
17351 }
17352 return ;
17353 }
17354 // $ANTLR end "rule__VLSDefinedTerm__ValueAssignment_0_1"
17355
17356
17357 // $ANTLR start "rule__VLSDefinedTerm__ValueAssignment_1_1"
17358 // InternalVampireLanguage.g:5693:1: rule__VLSDefinedTerm__ValueAssignment_1_1 : ( RULE_SIGNED_REAL_ID ) ;
17359 public final void rule__VLSDefinedTerm__ValueAssignment_1_1() throws RecognitionException {
17360
17361 int stackSize = keepStackSize();
17362
17363 try {
17364 // InternalVampireLanguage.g:5697:1: ( ( RULE_SIGNED_REAL_ID ) )
17365 // InternalVampireLanguage.g:5698:2: ( RULE_SIGNED_REAL_ID )
17366 {
17367 // InternalVampireLanguage.g:5698:2: ( RULE_SIGNED_REAL_ID )
17368 // InternalVampireLanguage.g:5699:3: RULE_SIGNED_REAL_ID
17369 {
17370 before(grammarAccess.getVLSDefinedTermAccess().getValueSIGNED_REAL_IDTerminalRuleCall_1_1_0());
17371 match(input,RULE_SIGNED_REAL_ID,FOLLOW_2);
17372 after(grammarAccess.getVLSDefinedTermAccess().getValueSIGNED_REAL_IDTerminalRuleCall_1_1_0());
17373
17374 }
17375
17376
17377 }
17378
17379 }
17380 catch (RecognitionException re) {
17381 reportError(re);
17382 recover(input,re);
17383 }
17384 finally {
17385
17386 restoreStackSize(stackSize);
17387
17388 }
17389 return ;
17390 }
17391 // $ANTLR end "rule__VLSDefinedTerm__ValueAssignment_1_1"
17392
17393
17394 // $ANTLR start "rule__VLSDefinedTerm__ValueAssignment_2_1"
17395 // InternalVampireLanguage.g:5708:1: rule__VLSDefinedTerm__ValueAssignment_2_1 : ( RULE_SIGNED_RAT_ID ) ;
17396 public final void rule__VLSDefinedTerm__ValueAssignment_2_1() throws RecognitionException {
17397
17398 int stackSize = keepStackSize();
17399
17400 try {
17401 // InternalVampireLanguage.g:5712:1: ( ( RULE_SIGNED_RAT_ID ) )
17402 // InternalVampireLanguage.g:5713:2: ( RULE_SIGNED_RAT_ID )
17403 {
17404 // InternalVampireLanguage.g:5713:2: ( RULE_SIGNED_RAT_ID )
17405 // InternalVampireLanguage.g:5714:3: RULE_SIGNED_RAT_ID
17406 {
17407 before(grammarAccess.getVLSDefinedTermAccess().getValueSIGNED_RAT_IDTerminalRuleCall_2_1_0());
17408 match(input,RULE_SIGNED_RAT_ID,FOLLOW_2);
17409 after(grammarAccess.getVLSDefinedTermAccess().getValueSIGNED_RAT_IDTerminalRuleCall_2_1_0());
17410
17411 }
17412
17413
17414 }
17415
17416 }
17417 catch (RecognitionException re) {
17418 reportError(re);
17419 recover(input,re);
17420 }
17421 finally {
17422
17423 restoreStackSize(stackSize);
17424
17425 }
17426 return ;
17427 }
17428 // $ANTLR end "rule__VLSDefinedTerm__ValueAssignment_2_1"
17429
17430
17431 // $ANTLR start "rule__VLSDefinedTerm__ValueAssignment_3_1"
17432 // InternalVampireLanguage.g:5723:1: rule__VLSDefinedTerm__ValueAssignment_3_1 : ( RULE_DOUBLE_QUOTE ) ;
17433 public final void rule__VLSDefinedTerm__ValueAssignment_3_1() throws RecognitionException {
17434
17435 int stackSize = keepStackSize();
17436
17437 try {
17438 // InternalVampireLanguage.g:5727:1: ( ( RULE_DOUBLE_QUOTE ) )
17439 // InternalVampireLanguage.g:5728:2: ( RULE_DOUBLE_QUOTE )
17440 {
17441 // InternalVampireLanguage.g:5728:2: ( RULE_DOUBLE_QUOTE )
17442 // InternalVampireLanguage.g:5729:3: RULE_DOUBLE_QUOTE
17443 {
17444 before(grammarAccess.getVLSDefinedTermAccess().getValueDOUBLE_QUOTETerminalRuleCall_3_1_0());
17445 match(input,RULE_DOUBLE_QUOTE,FOLLOW_2);
17446 after(grammarAccess.getVLSDefinedTermAccess().getValueDOUBLE_QUOTETerminalRuleCall_3_1_0());
17447
17448 }
17449
17450
17451 }
17452
17453 }
17454 catch (RecognitionException re) {
17455 reportError(re);
17456 recover(input,re);
17457 }
17458 finally {
17459
17460 restoreStackSize(stackSize);
17461
17462 }
17463 return ;
17464 }
17465 // $ANTLR end "rule__VLSDefinedTerm__ValueAssignment_3_1"
17466
17467 // Delegated rules
17468
17469
17470 protected DFA13 dfa13 = new DFA13(this);
17471 static final String dfa_1s = "\30\uffff";
17472 static final String dfa_2s = "\1\uffff\23\24\4\uffff";
17473 static final String dfa_3s = "\1\4\23\55\4\uffff";
17474 static final String dfa_4s = "\1\104\23\101\4\uffff";
17475 static final String dfa_5s = "\24\uffff\1\1\1\2\1\3\1\4";
17476 static final String dfa_6s = "\30\uffff}>";
17477 static final String[] dfa_7s = {
17478 "\1\1\1\2\1\uffff\1\27\1\3\1\4\1\uffff\1\26\3\27\14\uffff\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\30\uffff\2\24\1\25",
17479 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17480 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17481 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17482 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17483 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17484 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17485 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17486 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17487 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17488 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17489 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17490 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17491 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17492 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17493 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17494 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17495 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17496 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17497 "\1\24\1\uffff\1\25\1\24\2\uffff\10\24\4\uffff\3\24",
17498 "",
17499 "",
17500 "",
17501 ""
17502 };
17503
17504 static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s);
17505 static final short[] dfa_2 = DFA.unpackEncodedString(dfa_2s);
17506 static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s);
17507 static final char[] dfa_4 = DFA.unpackEncodedStringToUnsignedChars(dfa_4s);
17508 static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s);
17509 static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s);
17510 static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s);
17511
17512 class DFA13 extends DFA {
17513
17514 public DFA13(BaseRecognizer recognizer) {
17515 this.recognizer = recognizer;
17516 this.decisionNumber = 13;
17517 this.eot = dfa_1;
17518 this.eof = dfa_2;
17519 this.min = dfa_3;
17520 this.max = dfa_4;
17521 this.accept = dfa_5;
17522 this.special = dfa_6;
17523 this.transition = dfa_7;
17524 }
17525 public String getDescription() {
17526 return "1342:1: rule__VLSAtomic__Alternatives : ( ( ruleVLSAtomicConstant ) | ( ruleVLSAtomicFunction ) | ( ruleVLSVariable ) | ( ruleVLSDefinedTerm ) );";
17527 }
17528 }
17529
17530
17531 public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L});
17532 public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L});
17533 public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000440000000402L});
17534 public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0200000000000002L});
17535 public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0400000000000002L});
17536 public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000000020L});
17537 public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000080000000000L});
17538 public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x00000000000000F0L});
17539 public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000300000000000L});
17540 public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000200000000002L});
17541 public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000800000000000L});
17542 public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x00000000000000B0L});
17543 public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000200000000000L});
17544 public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x000003FFF8000000L});
17545 public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x680083FFF8007BB0L,0x000000000000001CL});
17546 public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0001200000000000L});
17547 public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0002000000000000L});
17548 public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x000493FFF8000030L});
17549 public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0001000000000000L});
17550 public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x07F8000000000000L});
17551 public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0008000000000000L});
17552 public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0010000000000000L});
17553 public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0020000000000000L});
17554 public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0040000000000000L});
17555 public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0080000000000000L});
17556 public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x01F8000000000000L});
17557 public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0200000000000000L});
17558 public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0400000000000000L});
17559 public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0800000000000000L});
17560 public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0004000000000000L});
17561 public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000000000800L});
17562 public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x1000000000000000L});
17563 public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x2000000000000000L});
17564 public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x4000000000000000L});
17565 public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x8000000000000000L,0x0000000000000003L});
17566 public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x000003FFF8007BB0L,0x000000000000001CL});
17567 public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x8000000000000000L});
17568 public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
17569 public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x000003FFF8000330L});
17570 public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
17571 public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x000003FFF8000330L,0x000000000000000CL});
17572 public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x000003FFF8000330L,0x0000000000000010L});
17573 public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000000000000080L});
17574 public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000001000L});
17575 public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000000002000L});
17576
17577} \ No newline at end of file
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-06-25 18:23:47 +0000