aboutsummaryrefslogtreecommitdiffstats
path: root/Application/org.eclipse.viatra.solver.language.ide
diff options
context:
space:
mode:
authorLibravatar Oszkar Semerath <semerath@mit.bme.hu>2020-04-28 20:43:04 +0200
committerLibravatar Oszkar Semerath <semerath@mit.bme.hu>2020-04-28 20:43:04 +0200
commit8a7b9b436b31e6d2f5a0521a077c960ebdeb4cbe (patch)
treed525bef75519f364d637e0779f8e63d4199dee31 /Application/org.eclipse.viatra.solver.language.ide
parentcheck expressions are mapped to WF constraints (diff)
downloadVIATRA-Generator-8a7b9b436b31e6d2f5a0521a077c960ebdeb4cbe.tar.gz
VIATRA-Generator-8a7b9b436b31e6d2f5a0521a077c960ebdeb4cbe.tar.zst
VIATRA-Generator-8a7b9b436b31e6d2f5a0521a077c960ebdeb4cbe.zip
initial commit
Diffstat (limited to 'Application/org.eclipse.viatra.solver.language.ide')
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/.classpath9
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/.gitignore1
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/.project34
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/.settings/org.eclipse.core.resources.prefs2
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/.settings/org.eclipse.jdt.core.prefs7
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/META-INF/MANIFEST.MF15
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/build.properties6
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/src-gen/META-INF/services/org.eclipse.xtext.ISetup1
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/AbstractSolverLanguageIdeModule.java60
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/PartialSolverLanguageContentAssistParser.java34
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/SolverLanguageParser.java187
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.g5882
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.tokens67
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageLexer.java1669
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.java17842
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/src/org/eclipse/viatra/solver/language/ide/SolverLanguageIdeModule.xtend11
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/src/org/eclipse/viatra/solver/language/ide/SolverLanguageIdeSetup.xtend20
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/xtend-gen/org/eclipse/viatra/solver/language/ide/.gitignore6
18 files changed, 25853 insertions, 0 deletions
diff --git a/Application/org.eclipse.viatra.solver.language.ide/.classpath b/Application/org.eclipse.viatra.solver.language.ide/.classpath
new file mode 100644
index 00000000..1287f96c
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/.classpath
@@ -0,0 +1,9 @@
1<?xml version="1.0" encoding="UTF-8"?>
2<classpath>
3 <classpathentry kind="src" path="src"/>
4 <classpathentry kind="src" path="src-gen"/>
5 <classpathentry kind="src" path="xtend-gen"/>
6 <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
7 <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
8 <classpathentry kind="output" path="bin"/>
9</classpath>
diff --git a/Application/org.eclipse.viatra.solver.language.ide/.gitignore b/Application/org.eclipse.viatra.solver.language.ide/.gitignore
new file mode 100644
index 00000000..ae3c1726
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/.gitignore
@@ -0,0 +1 @@
/bin/
diff --git a/Application/org.eclipse.viatra.solver.language.ide/.project b/Application/org.eclipse.viatra.solver.language.ide/.project
new file mode 100644
index 00000000..a27ef027
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/.project
@@ -0,0 +1,34 @@
1<?xml version="1.0" encoding="UTF-8"?>
2<projectDescription>
3 <name>org.eclipse.viatra.solver.language.ide</name>
4 <comment></comment>
5 <projects>
6 </projects>
7 <buildSpec>
8 <buildCommand>
9 <name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
10 <arguments>
11 </arguments>
12 </buildCommand>
13 <buildCommand>
14 <name>org.eclipse.jdt.core.javabuilder</name>
15 <arguments>
16 </arguments>
17 </buildCommand>
18 <buildCommand>
19 <name>org.eclipse.pde.ManifestBuilder</name>
20 <arguments>
21 </arguments>
22 </buildCommand>
23 <buildCommand>
24 <name>org.eclipse.pde.SchemaBuilder</name>
25 <arguments>
26 </arguments>
27 </buildCommand>
28 </buildSpec>
29 <natures>
30 <nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
31 <nature>org.eclipse.jdt.core.javanature</nature>
32 <nature>org.eclipse.pde.PluginNature</nature>
33 </natures>
34</projectDescription>
diff --git a/Application/org.eclipse.viatra.solver.language.ide/.settings/org.eclipse.core.resources.prefs b/Application/org.eclipse.viatra.solver.language.ide/.settings/org.eclipse.core.resources.prefs
new file mode 100644
index 00000000..4824b802
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/.settings/org.eclipse.core.resources.prefs
@@ -0,0 +1,2 @@
1eclipse.preferences.version=1
2encoding/<project>=UTF-8
diff --git a/Application/org.eclipse.viatra.solver.language.ide/.settings/org.eclipse.jdt.core.prefs b/Application/org.eclipse.viatra.solver.language.ide/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 00000000..295926d9
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,7 @@
1eclipse.preferences.version=1
2org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
3org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
4org.eclipse.jdt.core.compiler.compliance=1.8
5org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
6org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
7org.eclipse.jdt.core.compiler.source=1.8
diff --git a/Application/org.eclipse.viatra.solver.language.ide/META-INF/MANIFEST.MF b/Application/org.eclipse.viatra.solver.language.ide/META-INF/MANIFEST.MF
new file mode 100644
index 00000000..4312e426
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/META-INF/MANIFEST.MF
@@ -0,0 +1,15 @@
1Manifest-Version: 1.0
2Automatic-Module-Name: org.eclipse.viatra.solver.language.ide
3Bundle-ManifestVersion: 2
4Bundle-Name: org.eclipse.viatra.solver.language.ide
5Bundle-Vendor: My Company
6Bundle-Version: 1.0.0.qualifier
7Bundle-SymbolicName: org.eclipse.viatra.solver.language.ide; singleton:=true
8Bundle-ActivationPolicy: lazy
9Require-Bundle: org.eclipse.viatra.solver.language,
10 org.eclipse.xtext.ide,
11 org.eclipse.xtext.xbase.ide,
12 org.antlr.runtime;bundle-version="[3.2.0,3.2.1)"
13Bundle-RequiredExecutionEnvironment: JavaSE-1.8
14Export-Package: org.eclipse.viatra.solver.language.ide.contentassist.antlr,
15 org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal
diff --git a/Application/org.eclipse.viatra.solver.language.ide/build.properties b/Application/org.eclipse.viatra.solver.language.ide/build.properties
new file mode 100644
index 00000000..4c654e9b
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/build.properties
@@ -0,0 +1,6 @@
1source.. = src/,\
2 src-gen/,\
3 xtend-gen/
4bin.includes = .,\
5 META-INF/
6bin.excludes = **/*.xtend
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/META-INF/services/org.eclipse.xtext.ISetup b/Application/org.eclipse.viatra.solver.language.ide/src-gen/META-INF/services/org.eclipse.xtext.ISetup
new file mode 100644
index 00000000..1fe43147
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/META-INF/services/org.eclipse.xtext.ISetup
@@ -0,0 +1 @@
org.eclipse.viatra.solver.language.ide.SolverLanguageIdeSetup
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/AbstractSolverLanguageIdeModule.java b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/AbstractSolverLanguageIdeModule.java
new file mode 100644
index 00000000..2962a81a
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/AbstractSolverLanguageIdeModule.java
@@ -0,0 +1,60 @@
1/*
2 * generated by Xtext 2.18.0.M3
3 */
4package org.eclipse.viatra.solver.language.ide;
5
6import com.google.inject.Binder;
7import com.google.inject.name.Names;
8import org.eclipse.viatra.solver.language.ide.contentassist.antlr.SolverLanguageParser;
9import org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal.InternalSolverLanguageLexer;
10import org.eclipse.xtext.ide.DefaultIdeModule;
11import org.eclipse.xtext.ide.LexerIdeBindings;
12import org.eclipse.xtext.ide.editor.contentassist.FQNPrefixMatcher;
13import org.eclipse.xtext.ide.editor.contentassist.IPrefixMatcher;
14import org.eclipse.xtext.ide.editor.contentassist.IProposalConflictHelper;
15import org.eclipse.xtext.ide.editor.contentassist.antlr.AntlrProposalConflictHelper;
16import org.eclipse.xtext.ide.editor.contentassist.antlr.IContentAssistParser;
17import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer;
18import org.eclipse.xtext.ide.refactoring.IRenameStrategy2;
19import org.eclipse.xtext.ide.server.rename.IRenameService2;
20import org.eclipse.xtext.ide.server.rename.RenameService2;
21
22/**
23 * Manual modifications go to {@link SolverLanguageIdeModule}.
24 */
25@SuppressWarnings("all")
26public abstract class AbstractSolverLanguageIdeModule extends DefaultIdeModule {
27
28 // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
29 public void configureContentAssistLexer(Binder binder) {
30 binder.bind(Lexer.class)
31 .annotatedWith(Names.named(LexerIdeBindings.CONTENT_ASSIST))
32 .to(InternalSolverLanguageLexer.class);
33 }
34
35 // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
36 public Class<? extends IContentAssistParser> bindIContentAssistParser() {
37 return SolverLanguageParser.class;
38 }
39
40 // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
41 public Class<? extends IProposalConflictHelper> bindIProposalConflictHelper() {
42 return AntlrProposalConflictHelper.class;
43 }
44
45 // contributed by org.eclipse.xtext.xtext.generator.exporting.QualifiedNamesFragment2
46 public Class<? extends IPrefixMatcher> bindIPrefixMatcher() {
47 return FQNPrefixMatcher.class;
48 }
49
50 // contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2
51 public Class<? extends IRenameService2> bindIRenameService2() {
52 return RenameService2.class;
53 }
54
55 // contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2
56 public Class<? extends IRenameStrategy2> bindIRenameStrategy2() {
57 return IRenameStrategy2.DefaultImpl.class;
58 }
59
60}
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/PartialSolverLanguageContentAssistParser.java b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/PartialSolverLanguageContentAssistParser.java
new file mode 100644
index 00000000..ee6e19b9
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/PartialSolverLanguageContentAssistParser.java
@@ -0,0 +1,34 @@
1/*
2 * generated by Xtext 2.18.0.M3
3 */
4package org.eclipse.viatra.solver.language.ide.contentassist.antlr;
5
6import java.util.Collection;
7import java.util.Collections;
8import org.eclipse.xtext.AbstractRule;
9import org.eclipse.xtext.ide.editor.contentassist.antlr.FollowElement;
10import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
11import org.eclipse.xtext.ide.editor.partialEditing.IPartialEditingContentAssistParser;
12import org.eclipse.xtext.util.PolymorphicDispatcher;
13
14public class PartialSolverLanguageContentAssistParser extends SolverLanguageParser implements IPartialEditingContentAssistParser {
15
16 private AbstractRule rule;
17
18 @Override
19 public void initializeFor(AbstractRule rule) {
20 this.rule = rule;
21 }
22
23 @Override
24 protected Collection<FollowElement> getFollowElements(AbstractInternalContentAssistParser parser) {
25 if (rule == null || rule.eIsProxy())
26 return Collections.emptyList();
27 String methodName = "entryRule" + rule.getName();
28 PolymorphicDispatcher<Collection<FollowElement>> dispatcher =
29 new PolymorphicDispatcher<Collection<FollowElement>>(methodName, 0, 0, Collections.singletonList(parser));
30 dispatcher.invoke();
31 return parser.getFollowElements();
32 }
33
34}
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/SolverLanguageParser.java b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/SolverLanguageParser.java
new file mode 100644
index 00000000..0a4b46a5
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/SolverLanguageParser.java
@@ -0,0 +1,187 @@
1/*
2 * generated by Xtext 2.18.0.M3
3 */
4package org.eclipse.viatra.solver.language.ide.contentassist.antlr;
5
6import com.google.common.collect.ImmutableMap;
7import com.google.inject.Inject;
8import com.google.inject.Singleton;
9import java.util.Map;
10import org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal.InternalSolverLanguageParser;
11import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
12import org.eclipse.xtext.AbstractElement;
13import org.eclipse.xtext.ide.editor.contentassist.antlr.AbstractContentAssistParser;
14
15public class SolverLanguageParser extends AbstractContentAssistParser {
16
17 @Singleton
18 public static final class NameMappings {
19
20 private final Map<AbstractElement, String> mappings;
21
22 @Inject
23 public NameMappings(SolverLanguageGrammarAccess grammarAccess) {
24 ImmutableMap.Builder<AbstractElement, String> builder = ImmutableMap.builder();
25 init(builder, grammarAccess);
26 this.mappings = builder.build();
27 }
28
29 public String getRuleName(AbstractElement element) {
30 return mappings.get(element);
31 }
32
33 private static void init(ImmutableMap.Builder<AbstractElement, String> builder, SolverLanguageGrammarAccess grammarAccess) {
34 builder.put(grammarAccess.getStatementAccess().getAlternatives(), "rule__Statement__Alternatives");
35 builder.put(grammarAccess.getBooleanValueAccess().getAlternatives(), "rule__BooleanValue__Alternatives");
36 builder.put(grammarAccess.getTruthValueAccess().getAlternatives(), "rule__TruthValue__Alternatives");
37 builder.put(grammarAccess.getInterpretationAccess().getAlternatives(), "rule__Interpretation__Alternatives");
38 builder.put(grammarAccess.getSymbolAccess().getAlternatives(), "rule__Symbol__Alternatives");
39 builder.put(grammarAccess.getPartialitySymbolAccess().getAlternatives(), "rule__PartialitySymbol__Alternatives");
40 builder.put(grammarAccess.getDataSymbolAccess().getAlternatives(), "rule__DataSymbol__Alternatives");
41 builder.put(grammarAccess.getComplexObjectAccess().getAlternatives(), "rule__ComplexObject__Alternatives");
42 builder.put(grammarAccess.getObjectAccess().getAlternatives(), "rule__Object__Alternatives");
43 builder.put(grammarAccess.getDataObjectAccess().getAlternatives(), "rule__DataObject__Alternatives");
44 builder.put(grammarAccess.getPredicateAccess().getAlternatives(), "rule__Predicate__Alternatives");
45 builder.put(grammarAccess.getPredicateSymbolAccess().getAlternatives_6(), "rule__PredicateSymbol__Alternatives_6");
46 builder.put(grammarAccess.getErrorPredicateAccess().getAlternatives_5(), "rule__ErrorPredicate__Alternatives_5");
47 builder.put(grammarAccess.getPatternBodyAccess().getAlternatives_1(), "rule__PatternBody__Alternatives_1");
48 builder.put(grammarAccess.getPolarityAccess().getAlternatives(), "rule__Polarity__Alternatives");
49 builder.put(grammarAccess.getConstraintAccess().getAlternatives_2(), "rule__Constraint__Alternatives_2");
50 builder.put(grammarAccess.getClosureTypeAccess().getAlternatives(), "rule__ClosureType__Alternatives");
51 builder.put(grammarAccess.getLiteralAccess().getAlternatives(), "rule__Literal__Alternatives");
52 builder.put(grammarAccess.getCDInterpretationAccess().getAlternatives(), "rule__CDInterpretation__Alternatives");
53 builder.put(grammarAccess.getMultiplicityDefinitionAccess().getAlternatives_2(), "rule__MultiplicityDefinition__Alternatives_2");
54 builder.put(grammarAccess.getREALLiteralAccess().getGroup(), "rule__REALLiteral__Group__0");
55 builder.put(grammarAccess.getINTLiteralAccess().getGroup(), "rule__INTLiteral__Group__0");
56 builder.put(grammarAccess.getBooleanValueAccess().getGroup_0(), "rule__BooleanValue__Group_0__0");
57 builder.put(grammarAccess.getBooleanValueAccess().getGroup_1(), "rule__BooleanValue__Group_1__0");
58 builder.put(grammarAccess.getTruthValueAccess().getGroup_0(), "rule__TruthValue__Group_0__0");
59 builder.put(grammarAccess.getTruthValueAccess().getGroup_1(), "rule__TruthValue__Group_1__0");
60 builder.put(grammarAccess.getTruthValueAccess().getGroup_2(), "rule__TruthValue__Group_2__0");
61 builder.put(grammarAccess.getTruthValueAccess().getGroup_3(), "rule__TruthValue__Group_3__0");
62 builder.put(grammarAccess.getBasicInterpretationAccess().getGroup(), "rule__BasicInterpretation__Group__0");
63 builder.put(grammarAccess.getExistSymbolAccess().getGroup(), "rule__ExistSymbol__Group__0");
64 builder.put(grammarAccess.getEqualsSymbolAccess().getGroup(), "rule__EqualsSymbol__Group__0");
65 builder.put(grammarAccess.getBooleanSymbolAccess().getGroup(), "rule__BooleanSymbol__Group__0");
66 builder.put(grammarAccess.getIntegerSymbolAccess().getGroup(), "rule__IntegerSymbol__Group__0");
67 builder.put(grammarAccess.getRealSymbolAccess().getGroup(), "rule__RealSymbol__Group__0");
68 builder.put(grammarAccess.getStringSymbolAccess().getGroup(), "rule__StringSymbol__Group__0");
69 builder.put(grammarAccess.getNamedObjectAccess().getGroup(), "rule__NamedObject__Group__0");
70 builder.put(grammarAccess.getPredicateSymbolAccess().getGroup(), "rule__PredicateSymbol__Group__0");
71 builder.put(grammarAccess.getPredicateSymbolAccess().getGroup_6_1(), "rule__PredicateSymbol__Group_6_1__0");
72 builder.put(grammarAccess.getPredicateSymbolAccess().getGroup_6_1_1(), "rule__PredicateSymbol__Group_6_1_1__0");
73 builder.put(grammarAccess.getErrorPredicateAccess().getGroup(), "rule__ErrorPredicate__Group__0");
74 builder.put(grammarAccess.getErrorPredicateAccess().getGroup_3(), "rule__ErrorPredicate__Group_3__0");
75 builder.put(grammarAccess.getErrorPredicateAccess().getGroup_5_1(), "rule__ErrorPredicate__Group_5_1__0");
76 builder.put(grammarAccess.getErrorPredicateAccess().getGroup_5_1_1(), "rule__ErrorPredicate__Group_5_1_1__0");
77 builder.put(grammarAccess.getParameterAccess().getGroup(), "rule__Parameter__Group__0");
78 builder.put(grammarAccess.getParameterAccess().getGroup_1(), "rule__Parameter__Group_1__0");
79 builder.put(grammarAccess.getPatternBodyAccess().getGroup(), "rule__PatternBody__Group__0");
80 builder.put(grammarAccess.getPolarityAccess().getGroup_0(), "rule__Polarity__Group_0__0");
81 builder.put(grammarAccess.getPolarityAccess().getGroup_1(), "rule__Polarity__Group_1__0");
82 builder.put(grammarAccess.getConstraintAccess().getGroup(), "rule__Constraint__Group__0");
83 builder.put(grammarAccess.getConstraintAccess().getGroup_2_0(), "rule__Constraint__Group_2_0__0");
84 builder.put(grammarAccess.getConstraintAccess().getGroup_2_1(), "rule__Constraint__Group_2_1__0");
85 builder.put(grammarAccess.getClosureTypeAccess().getGroup_0(), "rule__ClosureType__Group_0__0");
86 builder.put(grammarAccess.getClosureTypeAccess().getGroup_1(), "rule__ClosureType__Group_1__0");
87 builder.put(grammarAccess.getAllInstancesAccess().getGroup(), "rule__AllInstances__Group__0");
88 builder.put(grammarAccess.getAllObjectsAccess().getGroup(), "rule__AllObjects__Group__0");
89 builder.put(grammarAccess.getDefaultInterpretationAccess().getGroup(), "rule__DefaultInterpretation__Group__0");
90 builder.put(grammarAccess.getClassInterpretationAccess().getGroup(), "rule__ClassInterpretation__Group__0");
91 builder.put(grammarAccess.getClassInterpretationAccess().getGroup_3(), "rule__ClassInterpretation__Group_3__0");
92 builder.put(grammarAccess.getEnumInterpretationAccess().getGroup(), "rule__EnumInterpretation__Group__0");
93 builder.put(grammarAccess.getFieldRelationInterpretationAccess().getGroup(), "rule__FieldRelationInterpretation__Group__0");
94 builder.put(grammarAccess.getGlobalRelationInterpretationAccess().getGroup(), "rule__GlobalRelationInterpretation__Group__0");
95 builder.put(grammarAccess.getMultiplicityDefinitionAccess().getGroup(), "rule__MultiplicityDefinition__Group__0");
96 builder.put(grammarAccess.getProblemAccess().getStatementsAssignment(), "rule__Problem__StatementsAssignment");
97 builder.put(grammarAccess.getBasicInterpretationAccess().getSymbolAssignment_0(), "rule__BasicInterpretation__SymbolAssignment_0");
98 builder.put(grammarAccess.getBasicInterpretationAccess().getObjectsAssignment_2(), "rule__BasicInterpretation__ObjectsAssignment_2");
99 builder.put(grammarAccess.getBasicInterpretationAccess().getValueAssignment_5(), "rule__BasicInterpretation__ValueAssignment_5");
100 builder.put(grammarAccess.getModelSymbolAccess().getNameAssignment(), "rule__ModelSymbol__NameAssignment");
101 builder.put(grammarAccess.getNamedObjectAccess().getNameAssignment_1(), "rule__NamedObject__NameAssignment_1");
102 builder.put(grammarAccess.getUnnamedObjectAccess().getNameAssignment(), "rule__UnnamedObject__NameAssignment");
103 builder.put(grammarAccess.getBooleanObjectAccess().getValueAssignment(), "rule__BooleanObject__ValueAssignment");
104 builder.put(grammarAccess.getIntObjectAccess().getValueAssignment(), "rule__IntObject__ValueAssignment");
105 builder.put(grammarAccess.getRealObjectAccess().getValueAssignment(), "rule__RealObject__ValueAssignment");
106 builder.put(grammarAccess.getStringObjectAccess().getValueAssignment(), "rule__StringObject__ValueAssignment");
107 builder.put(grammarAccess.getPredicateSymbolAccess().getSymbolAssignment_1(), "rule__PredicateSymbol__SymbolAssignment_1");
108 builder.put(grammarAccess.getPredicateSymbolAccess().getParametersAssignment_3(), "rule__PredicateSymbol__ParametersAssignment_3");
109 builder.put(grammarAccess.getPredicateSymbolAccess().getBodiesAssignment_6_1_0(), "rule__PredicateSymbol__BodiesAssignment_6_1_0");
110 builder.put(grammarAccess.getPredicateSymbolAccess().getBodiesAssignment_6_1_1_1(), "rule__PredicateSymbol__BodiesAssignment_6_1_1_1");
111 builder.put(grammarAccess.getErrorPredicateAccess().getNameAssignment_2(), "rule__ErrorPredicate__NameAssignment_2");
112 builder.put(grammarAccess.getErrorPredicateAccess().getParametersAssignment_3_1(), "rule__ErrorPredicate__ParametersAssignment_3_1");
113 builder.put(grammarAccess.getErrorPredicateAccess().getBodiesAssignment_5_1_0(), "rule__ErrorPredicate__BodiesAssignment_5_1_0");
114 builder.put(grammarAccess.getErrorPredicateAccess().getBodiesAssignment_5_1_1_1(), "rule__ErrorPredicate__BodiesAssignment_5_1_1_1");
115 builder.put(grammarAccess.getParameterAccess().getVariableAssignment_0(), "rule__Parameter__VariableAssignment_0");
116 builder.put(grammarAccess.getParameterAccess().getTypeAssignment_1_1(), "rule__Parameter__TypeAssignment_1_1");
117 builder.put(grammarAccess.getPatternBodyAccess().getConstraintsAssignment_1_1(), "rule__PatternBody__ConstraintsAssignment_1_1");
118 builder.put(grammarAccess.getConstraintAccess().getPolarityAssignment_0(), "rule__Constraint__PolarityAssignment_0");
119 builder.put(grammarAccess.getConstraintAccess().getSymbolAssignment_1(), "rule__Constraint__SymbolAssignment_1");
120 builder.put(grammarAccess.getConstraintAccess().getParamsAssignment_2_0_1(), "rule__Constraint__ParamsAssignment_2_0_1");
121 builder.put(grammarAccess.getConstraintAccess().getClosureTypeAssignment_2_1_0(), "rule__Constraint__ClosureTypeAssignment_2_1_0");
122 builder.put(grammarAccess.getConstraintAccess().getParamsAssignment_2_1_2(), "rule__Constraint__ParamsAssignment_2_1_2");
123 builder.put(grammarAccess.getConstraintAccess().getParamsAssignment_2_1_3(), "rule__Constraint__ParamsAssignment_2_1_3");
124 builder.put(grammarAccess.getVariableAccess().getNameAssignment(), "rule__Variable__NameAssignment");
125 builder.put(grammarAccess.getAllInstancesAccess().getSymbolAssignment_1(), "rule__AllInstances__SymbolAssignment_1");
126 builder.put(grammarAccess.getDefaultInterpretationAccess().getInterpretationAssignment_1(), "rule__DefaultInterpretation__InterpretationAssignment_1");
127 builder.put(grammarAccess.getClassInterpretationAccess().getAbstractAssignment_0(), "rule__ClassInterpretation__AbstractAssignment_0");
128 builder.put(grammarAccess.getClassInterpretationAccess().getSymbolAssignment_2(), "rule__ClassInterpretation__SymbolAssignment_2");
129 builder.put(grammarAccess.getClassInterpretationAccess().getSupertypesAssignment_3_1(), "rule__ClassInterpretation__SupertypesAssignment_3_1");
130 builder.put(grammarAccess.getClassInterpretationAccess().getFieltAssignment_5(), "rule__ClassInterpretation__FieltAssignment_5");
131 builder.put(grammarAccess.getEnumInterpretationAccess().getSymbolAssignment_1(), "rule__EnumInterpretation__SymbolAssignment_1");
132 builder.put(grammarAccess.getEnumInterpretationAccess().getObjectsAssignment_3(), "rule__EnumInterpretation__ObjectsAssignment_3");
133 builder.put(grammarAccess.getFieldRelationInterpretationAccess().getContainmentAssignment_0(), "rule__FieldRelationInterpretation__ContainmentAssignment_0");
134 builder.put(grammarAccess.getFieldRelationInterpretationAccess().getSymbolAssignment_1(), "rule__FieldRelationInterpretation__SymbolAssignment_1");
135 builder.put(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityAssignment_3(), "rule__FieldRelationInterpretation__MultiplicityAssignment_3");
136 builder.put(grammarAccess.getFieldRelationInterpretationAccess().getTargetAssignment_4(), "rule__FieldRelationInterpretation__TargetAssignment_4");
137 builder.put(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentAssignment_0(), "rule__GlobalRelationInterpretation__ContainmentAssignment_0");
138 builder.put(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolAssignment_2(), "rule__GlobalRelationInterpretation__SymbolAssignment_2");
139 builder.put(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityAssignment_4(), "rule__GlobalRelationInterpretation__SourceMultiplicityAssignment_4");
140 builder.put(grammarAccess.getGlobalRelationInterpretationAccess().getSourceAssignment_5(), "rule__GlobalRelationInterpretation__SourceAssignment_5");
141 builder.put(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityAssignment_6(), "rule__GlobalRelationInterpretation__TargetMultiplicityAssignment_6");
142 builder.put(grammarAccess.getGlobalRelationInterpretationAccess().getTargetAssignment_7(), "rule__GlobalRelationInterpretation__TargetAssignment_7");
143 builder.put(grammarAccess.getMultiplicityDefinitionAccess().getLowerAssignment_0(), "rule__MultiplicityDefinition__LowerAssignment_0");
144 builder.put(grammarAccess.getMultiplicityDefinitionAccess().getUpperAssignment_2_0(), "rule__MultiplicityDefinition__UpperAssignment_2_0");
145 builder.put(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAssignment_2_1(), "rule__MultiplicityDefinition__UnlimitedUpperAssignment_2_1");
146 }
147 }
148
149 @Inject
150 private NameMappings nameMappings;
151
152 @Inject
153 private SolverLanguageGrammarAccess grammarAccess;
154
155 @Override
156 protected InternalSolverLanguageParser createParser() {
157 InternalSolverLanguageParser result = new InternalSolverLanguageParser(null);
158 result.setGrammarAccess(grammarAccess);
159 return result;
160 }
161
162 @Override
163 protected String getRuleName(AbstractElement element) {
164 return nameMappings.getRuleName(element);
165 }
166
167 @Override
168 protected String[] getInitialHiddenTokens() {
169 return new String[] { "RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT" };
170 }
171
172 public SolverLanguageGrammarAccess getGrammarAccess() {
173 return this.grammarAccess;
174 }
175
176 public void setGrammarAccess(SolverLanguageGrammarAccess grammarAccess) {
177 this.grammarAccess = grammarAccess;
178 }
179
180 public NameMappings getNameMappings() {
181 return nameMappings;
182 }
183
184 public void setNameMappings(NameMappings nameMappings) {
185 this.nameMappings = nameMappings;
186 }
187}
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.g b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.g
new file mode 100644
index 00000000..5a6ae569
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.g
@@ -0,0 +1,5882 @@
1/*
2 * generated by Xtext 2.18.0.M3
3 */
4grammar InternalSolverLanguage;
5
6options {
7 superClass=AbstractInternalContentAssistParser;
8}
9
10@lexer::header {
11package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal;
12
13// Hack: Use our own Lexer superclass by means of import.
14// Currently there is no other way to specify the superclass for the lexer.
15import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer;
16}
17
18@parser::header {
19package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal;
20
21import java.io.InputStream;
22import org.eclipse.xtext.*;
23import org.eclipse.xtext.parser.*;
24import org.eclipse.xtext.parser.impl.*;
25import org.eclipse.emf.ecore.util.EcoreUtil;
26import org.eclipse.emf.ecore.EObject;
27import org.eclipse.xtext.parser.antlr.XtextTokenStream;
28import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
29import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
30import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA;
31import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
32
33}
34@parser::members {
35 private SolverLanguageGrammarAccess grammarAccess;
36
37 public void setGrammarAccess(SolverLanguageGrammarAccess grammarAccess) {
38 this.grammarAccess = grammarAccess;
39 }
40
41 @Override
42 protected Grammar getGrammar() {
43 return grammarAccess.getGrammar();
44 }
45
46 @Override
47 protected String getValueForTokenName(String tokenName) {
48 return tokenName;
49 }
50}
51
52// Entry rule entryRuleProblem
53entryRuleProblem
54:
55{ before(grammarAccess.getProblemRule()); }
56 ruleProblem
57{ after(grammarAccess.getProblemRule()); }
58 EOF
59;
60
61// Rule Problem
62ruleProblem
63 @init {
64 int stackSize = keepStackSize();
65 }
66 :
67 (
68 { before(grammarAccess.getProblemAccess().getStatementsAssignment()); }
69 (rule__Problem__StatementsAssignment)*
70 { after(grammarAccess.getProblemAccess().getStatementsAssignment()); }
71 )
72;
73finally {
74 restoreStackSize(stackSize);
75}
76
77// Entry rule entryRuleStatement
78entryRuleStatement
79:
80{ before(grammarAccess.getStatementRule()); }
81 ruleStatement
82{ after(grammarAccess.getStatementRule()); }
83 EOF
84;
85
86// Rule Statement
87ruleStatement
88 @init {
89 int stackSize = keepStackSize();
90 }
91 :
92 (
93 { before(grammarAccess.getStatementAccess().getAlternatives()); }
94 (rule__Statement__Alternatives)
95 { after(grammarAccess.getStatementAccess().getAlternatives()); }
96 )
97;
98finally {
99 restoreStackSize(stackSize);
100}
101
102// Entry rule entryRuleREALLiteral
103entryRuleREALLiteral
104:
105{ before(grammarAccess.getREALLiteralRule()); }
106 ruleREALLiteral
107{ after(grammarAccess.getREALLiteralRule()); }
108 EOF
109;
110
111// Rule REALLiteral
112ruleREALLiteral
113 @init {
114 int stackSize = keepStackSize();
115 }
116 :
117 (
118 { before(grammarAccess.getREALLiteralAccess().getGroup()); }
119 (rule__REALLiteral__Group__0)
120 { after(grammarAccess.getREALLiteralAccess().getGroup()); }
121 )
122;
123finally {
124 restoreStackSize(stackSize);
125}
126
127// Entry rule entryRuleINTLiteral
128entryRuleINTLiteral
129:
130{ before(grammarAccess.getINTLiteralRule()); }
131 ruleINTLiteral
132{ after(grammarAccess.getINTLiteralRule()); }
133 EOF
134;
135
136// Rule INTLiteral
137ruleINTLiteral
138 @init {
139 int stackSize = keepStackSize();
140 }
141 :
142 (
143 { before(grammarAccess.getINTLiteralAccess().getGroup()); }
144 (rule__INTLiteral__Group__0)
145 { after(grammarAccess.getINTLiteralAccess().getGroup()); }
146 )
147;
148finally {
149 restoreStackSize(stackSize);
150}
151
152// Entry rule entryRuleBooleanValue
153entryRuleBooleanValue
154:
155{ before(grammarAccess.getBooleanValueRule()); }
156 ruleBooleanValue
157{ after(grammarAccess.getBooleanValueRule()); }
158 EOF
159;
160
161// Rule BooleanValue
162ruleBooleanValue
163 @init {
164 int stackSize = keepStackSize();
165 }
166 :
167 (
168 { before(grammarAccess.getBooleanValueAccess().getAlternatives()); }
169 (rule__BooleanValue__Alternatives)
170 { after(grammarAccess.getBooleanValueAccess().getAlternatives()); }
171 )
172;
173finally {
174 restoreStackSize(stackSize);
175}
176
177// Entry rule entryRuleTruthValue
178entryRuleTruthValue
179:
180{ before(grammarAccess.getTruthValueRule()); }
181 ruleTruthValue
182{ after(grammarAccess.getTruthValueRule()); }
183 EOF
184;
185
186// Rule TruthValue
187ruleTruthValue
188 @init {
189 int stackSize = keepStackSize();
190 }
191 :
192 (
193 { before(grammarAccess.getTruthValueAccess().getAlternatives()); }
194 (rule__TruthValue__Alternatives)
195 { after(grammarAccess.getTruthValueAccess().getAlternatives()); }
196 )
197;
198finally {
199 restoreStackSize(stackSize);
200}
201
202// Entry rule entryRuleInterpretation
203entryRuleInterpretation
204:
205{ before(grammarAccess.getInterpretationRule()); }
206 ruleInterpretation
207{ after(grammarAccess.getInterpretationRule()); }
208 EOF
209;
210
211// Rule Interpretation
212ruleInterpretation
213 @init {
214 int stackSize = keepStackSize();
215 }
216 :
217 (
218 { before(grammarAccess.getInterpretationAccess().getAlternatives()); }
219 (rule__Interpretation__Alternatives)
220 { after(grammarAccess.getInterpretationAccess().getAlternatives()); }
221 )
222;
223finally {
224 restoreStackSize(stackSize);
225}
226
227// Entry rule entryRuleBasicInterpretation
228entryRuleBasicInterpretation
229:
230{ before(grammarAccess.getBasicInterpretationRule()); }
231 ruleBasicInterpretation
232{ after(grammarAccess.getBasicInterpretationRule()); }
233 EOF
234;
235
236// Rule BasicInterpretation
237ruleBasicInterpretation
238 @init {
239 int stackSize = keepStackSize();
240 }
241 :
242 (
243 { before(grammarAccess.getBasicInterpretationAccess().getGroup()); }
244 (rule__BasicInterpretation__Group__0)
245 { after(grammarAccess.getBasicInterpretationAccess().getGroup()); }
246 )
247;
248finally {
249 restoreStackSize(stackSize);
250}
251
252// Entry rule entryRuleSymbol
253entryRuleSymbol
254:
255{ before(grammarAccess.getSymbolRule()); }
256 ruleSymbol
257{ after(grammarAccess.getSymbolRule()); }
258 EOF
259;
260
261// Rule Symbol
262ruleSymbol
263 @init {
264 int stackSize = keepStackSize();
265 }
266 :
267 (
268 { before(grammarAccess.getSymbolAccess().getAlternatives()); }
269 (rule__Symbol__Alternatives)
270 { after(grammarAccess.getSymbolAccess().getAlternatives()); }
271 )
272;
273finally {
274 restoreStackSize(stackSize);
275}
276
277// Entry rule entryRuleModelSymbol
278entryRuleModelSymbol
279:
280{ before(grammarAccess.getModelSymbolRule()); }
281 ruleModelSymbol
282{ after(grammarAccess.getModelSymbolRule()); }
283 EOF
284;
285
286// Rule ModelSymbol
287ruleModelSymbol
288 @init {
289 int stackSize = keepStackSize();
290 }
291 :
292 (
293 { before(grammarAccess.getModelSymbolAccess().getNameAssignment()); }
294 (rule__ModelSymbol__NameAssignment)
295 { after(grammarAccess.getModelSymbolAccess().getNameAssignment()); }
296 )
297;
298finally {
299 restoreStackSize(stackSize);
300}
301
302// Entry rule entryRulePartialitySymbol
303entryRulePartialitySymbol
304:
305{ before(grammarAccess.getPartialitySymbolRule()); }
306 rulePartialitySymbol
307{ after(grammarAccess.getPartialitySymbolRule()); }
308 EOF
309;
310
311// Rule PartialitySymbol
312rulePartialitySymbol
313 @init {
314 int stackSize = keepStackSize();
315 }
316 :
317 (
318 { before(grammarAccess.getPartialitySymbolAccess().getAlternatives()); }
319 (rule__PartialitySymbol__Alternatives)
320 { after(grammarAccess.getPartialitySymbolAccess().getAlternatives()); }
321 )
322;
323finally {
324 restoreStackSize(stackSize);
325}
326
327// Entry rule entryRuleExistSymbol
328entryRuleExistSymbol
329:
330{ before(grammarAccess.getExistSymbolRule()); }
331 ruleExistSymbol
332{ after(grammarAccess.getExistSymbolRule()); }
333 EOF
334;
335
336// Rule ExistSymbol
337ruleExistSymbol
338 @init {
339 int stackSize = keepStackSize();
340 }
341 :
342 (
343 { before(grammarAccess.getExistSymbolAccess().getGroup()); }
344 (rule__ExistSymbol__Group__0)
345 { after(grammarAccess.getExistSymbolAccess().getGroup()); }
346 )
347;
348finally {
349 restoreStackSize(stackSize);
350}
351
352// Entry rule entryRuleEqualsSymbol
353entryRuleEqualsSymbol
354:
355{ before(grammarAccess.getEqualsSymbolRule()); }
356 ruleEqualsSymbol
357{ after(grammarAccess.getEqualsSymbolRule()); }
358 EOF
359;
360
361// Rule EqualsSymbol
362ruleEqualsSymbol
363 @init {
364 int stackSize = keepStackSize();
365 }
366 :
367 (
368 { before(grammarAccess.getEqualsSymbolAccess().getGroup()); }
369 (rule__EqualsSymbol__Group__0)
370 { after(grammarAccess.getEqualsSymbolAccess().getGroup()); }
371 )
372;
373finally {
374 restoreStackSize(stackSize);
375}
376
377// Entry rule entryRuleDataSymbol
378entryRuleDataSymbol
379:
380{ before(grammarAccess.getDataSymbolRule()); }
381 ruleDataSymbol
382{ after(grammarAccess.getDataSymbolRule()); }
383 EOF
384;
385
386// Rule DataSymbol
387ruleDataSymbol
388 @init {
389 int stackSize = keepStackSize();
390 }
391 :
392 (
393 { before(grammarAccess.getDataSymbolAccess().getAlternatives()); }
394 (rule__DataSymbol__Alternatives)
395 { after(grammarAccess.getDataSymbolAccess().getAlternatives()); }
396 )
397;
398finally {
399 restoreStackSize(stackSize);
400}
401
402// Entry rule entryRuleBooleanSymbol
403entryRuleBooleanSymbol
404:
405{ before(grammarAccess.getBooleanSymbolRule()); }
406 ruleBooleanSymbol
407{ after(grammarAccess.getBooleanSymbolRule()); }
408 EOF
409;
410
411// Rule BooleanSymbol
412ruleBooleanSymbol
413 @init {
414 int stackSize = keepStackSize();
415 }
416 :
417 (
418 { before(grammarAccess.getBooleanSymbolAccess().getGroup()); }
419 (rule__BooleanSymbol__Group__0)
420 { after(grammarAccess.getBooleanSymbolAccess().getGroup()); }
421 )
422;
423finally {
424 restoreStackSize(stackSize);
425}
426
427// Entry rule entryRuleIntegerSymbol
428entryRuleIntegerSymbol
429:
430{ before(grammarAccess.getIntegerSymbolRule()); }
431 ruleIntegerSymbol
432{ after(grammarAccess.getIntegerSymbolRule()); }
433 EOF
434;
435
436// Rule IntegerSymbol
437ruleIntegerSymbol
438 @init {
439 int stackSize = keepStackSize();
440 }
441 :
442 (
443 { before(grammarAccess.getIntegerSymbolAccess().getGroup()); }
444 (rule__IntegerSymbol__Group__0)
445 { after(grammarAccess.getIntegerSymbolAccess().getGroup()); }
446 )
447;
448finally {
449 restoreStackSize(stackSize);
450}
451
452// Entry rule entryRuleRealSymbol
453entryRuleRealSymbol
454:
455{ before(grammarAccess.getRealSymbolRule()); }
456 ruleRealSymbol
457{ after(grammarAccess.getRealSymbolRule()); }
458 EOF
459;
460
461// Rule RealSymbol
462ruleRealSymbol
463 @init {
464 int stackSize = keepStackSize();
465 }
466 :
467 (
468 { before(grammarAccess.getRealSymbolAccess().getGroup()); }
469 (rule__RealSymbol__Group__0)
470 { after(grammarAccess.getRealSymbolAccess().getGroup()); }
471 )
472;
473finally {
474 restoreStackSize(stackSize);
475}
476
477// Entry rule entryRuleStringSymbol
478entryRuleStringSymbol
479:
480{ before(grammarAccess.getStringSymbolRule()); }
481 ruleStringSymbol
482{ after(grammarAccess.getStringSymbolRule()); }
483 EOF
484;
485
486// Rule StringSymbol
487ruleStringSymbol
488 @init {
489 int stackSize = keepStackSize();
490 }
491 :
492 (
493 { before(grammarAccess.getStringSymbolAccess().getGroup()); }
494 (rule__StringSymbol__Group__0)
495 { after(grammarAccess.getStringSymbolAccess().getGroup()); }
496 )
497;
498finally {
499 restoreStackSize(stackSize);
500}
501
502// Entry rule entryRuleComplexObject
503entryRuleComplexObject
504:
505{ before(grammarAccess.getComplexObjectRule()); }
506 ruleComplexObject
507{ after(grammarAccess.getComplexObjectRule()); }
508 EOF
509;
510
511// Rule ComplexObject
512ruleComplexObject
513 @init {
514 int stackSize = keepStackSize();
515 }
516 :
517 (
518 { before(grammarAccess.getComplexObjectAccess().getAlternatives()); }
519 (rule__ComplexObject__Alternatives)
520 { after(grammarAccess.getComplexObjectAccess().getAlternatives()); }
521 )
522;
523finally {
524 restoreStackSize(stackSize);
525}
526
527// Entry rule entryRuleObject
528entryRuleObject
529:
530{ before(grammarAccess.getObjectRule()); }
531 ruleObject
532{ after(grammarAccess.getObjectRule()); }
533 EOF
534;
535
536// Rule Object
537ruleObject
538 @init {
539 int stackSize = keepStackSize();
540 }
541 :
542 (
543 { before(grammarAccess.getObjectAccess().getAlternatives()); }
544 (rule__Object__Alternatives)
545 { after(grammarAccess.getObjectAccess().getAlternatives()); }
546 )
547;
548finally {
549 restoreStackSize(stackSize);
550}
551
552// Entry rule entryRuleNamedObject
553entryRuleNamedObject
554:
555{ before(grammarAccess.getNamedObjectRule()); }
556 ruleNamedObject
557{ after(grammarAccess.getNamedObjectRule()); }
558 EOF
559;
560
561// Rule NamedObject
562ruleNamedObject
563 @init {
564 int stackSize = keepStackSize();
565 }
566 :
567 (
568 { before(grammarAccess.getNamedObjectAccess().getGroup()); }
569 (rule__NamedObject__Group__0)
570 { after(grammarAccess.getNamedObjectAccess().getGroup()); }
571 )
572;
573finally {
574 restoreStackSize(stackSize);
575}
576
577// Entry rule entryRuleUnnamedObject
578entryRuleUnnamedObject
579:
580{ before(grammarAccess.getUnnamedObjectRule()); }
581 ruleUnnamedObject
582{ after(grammarAccess.getUnnamedObjectRule()); }
583 EOF
584;
585
586// Rule UnnamedObject
587ruleUnnamedObject
588 @init {
589 int stackSize = keepStackSize();
590 }
591 :
592 (
593 { before(grammarAccess.getUnnamedObjectAccess().getNameAssignment()); }
594 (rule__UnnamedObject__NameAssignment)
595 { after(grammarAccess.getUnnamedObjectAccess().getNameAssignment()); }
596 )
597;
598finally {
599 restoreStackSize(stackSize);
600}
601
602// Entry rule entryRuleDataObject
603entryRuleDataObject
604:
605{ before(grammarAccess.getDataObjectRule()); }
606 ruleDataObject
607{ after(grammarAccess.getDataObjectRule()); }
608 EOF
609;
610
611// Rule DataObject
612ruleDataObject
613 @init {
614 int stackSize = keepStackSize();
615 }
616 :
617 (
618 { before(grammarAccess.getDataObjectAccess().getAlternatives()); }
619 (rule__DataObject__Alternatives)
620 { after(grammarAccess.getDataObjectAccess().getAlternatives()); }
621 )
622;
623finally {
624 restoreStackSize(stackSize);
625}
626
627// Entry rule entryRuleBooleanObject
628entryRuleBooleanObject
629:
630{ before(grammarAccess.getBooleanObjectRule()); }
631 ruleBooleanObject
632{ after(grammarAccess.getBooleanObjectRule()); }
633 EOF
634;
635
636// Rule BooleanObject
637ruleBooleanObject
638 @init {
639 int stackSize = keepStackSize();
640 }
641 :
642 (
643 { before(grammarAccess.getBooleanObjectAccess().getValueAssignment()); }
644 (rule__BooleanObject__ValueAssignment)
645 { after(grammarAccess.getBooleanObjectAccess().getValueAssignment()); }
646 )
647;
648finally {
649 restoreStackSize(stackSize);
650}
651
652// Entry rule entryRuleIntObject
653entryRuleIntObject
654:
655{ before(grammarAccess.getIntObjectRule()); }
656 ruleIntObject
657{ after(grammarAccess.getIntObjectRule()); }
658 EOF
659;
660
661// Rule IntObject
662ruleIntObject
663 @init {
664 int stackSize = keepStackSize();
665 }
666 :
667 (
668 { before(grammarAccess.getIntObjectAccess().getValueAssignment()); }
669 (rule__IntObject__ValueAssignment)
670 { after(grammarAccess.getIntObjectAccess().getValueAssignment()); }
671 )
672;
673finally {
674 restoreStackSize(stackSize);
675}
676
677// Entry rule entryRuleRealObject
678entryRuleRealObject
679:
680{ before(grammarAccess.getRealObjectRule()); }
681 ruleRealObject
682{ after(grammarAccess.getRealObjectRule()); }
683 EOF
684;
685
686// Rule RealObject
687ruleRealObject
688 @init {
689 int stackSize = keepStackSize();
690 }
691 :
692 (
693 { before(grammarAccess.getRealObjectAccess().getValueAssignment()); }
694 (rule__RealObject__ValueAssignment)
695 { after(grammarAccess.getRealObjectAccess().getValueAssignment()); }
696 )
697;
698finally {
699 restoreStackSize(stackSize);
700}
701
702// Entry rule entryRuleStringObject
703entryRuleStringObject
704:
705{ before(grammarAccess.getStringObjectRule()); }
706 ruleStringObject
707{ after(grammarAccess.getStringObjectRule()); }
708 EOF
709;
710
711// Rule StringObject
712ruleStringObject
713 @init {
714 int stackSize = keepStackSize();
715 }
716 :
717 (
718 { before(grammarAccess.getStringObjectAccess().getValueAssignment()); }
719 (rule__StringObject__ValueAssignment)
720 { after(grammarAccess.getStringObjectAccess().getValueAssignment()); }
721 )
722;
723finally {
724 restoreStackSize(stackSize);
725}
726
727// Entry rule entryRulePredicate
728entryRulePredicate
729:
730{ before(grammarAccess.getPredicateRule()); }
731 rulePredicate
732{ after(grammarAccess.getPredicateRule()); }
733 EOF
734;
735
736// Rule Predicate
737rulePredicate
738 @init {
739 int stackSize = keepStackSize();
740 }
741 :
742 (
743 { before(grammarAccess.getPredicateAccess().getAlternatives()); }
744 (rule__Predicate__Alternatives)
745 { after(grammarAccess.getPredicateAccess().getAlternatives()); }
746 )
747;
748finally {
749 restoreStackSize(stackSize);
750}
751
752// Entry rule entryRulePredicateSymbol
753entryRulePredicateSymbol
754:
755{ before(grammarAccess.getPredicateSymbolRule()); }
756 rulePredicateSymbol
757{ after(grammarAccess.getPredicateSymbolRule()); }
758 EOF
759;
760
761// Rule PredicateSymbol
762rulePredicateSymbol
763 @init {
764 int stackSize = keepStackSize();
765 }
766 :
767 (
768 { before(grammarAccess.getPredicateSymbolAccess().getGroup()); }
769 (rule__PredicateSymbol__Group__0)
770 { after(grammarAccess.getPredicateSymbolAccess().getGroup()); }
771 )
772;
773finally {
774 restoreStackSize(stackSize);
775}
776
777// Entry rule entryRuleErrorPredicate
778entryRuleErrorPredicate
779:
780{ before(grammarAccess.getErrorPredicateRule()); }
781 ruleErrorPredicate
782{ after(grammarAccess.getErrorPredicateRule()); }
783 EOF
784;
785
786// Rule ErrorPredicate
787ruleErrorPredicate
788 @init {
789 int stackSize = keepStackSize();
790 }
791 :
792 (
793 { before(grammarAccess.getErrorPredicateAccess().getGroup()); }
794 (rule__ErrorPredicate__Group__0)
795 { after(grammarAccess.getErrorPredicateAccess().getGroup()); }
796 )
797;
798finally {
799 restoreStackSize(stackSize);
800}
801
802// Entry rule entryRuleParameter
803entryRuleParameter
804:
805{ before(grammarAccess.getParameterRule()); }
806 ruleParameter
807{ after(grammarAccess.getParameterRule()); }
808 EOF
809;
810
811// Rule Parameter
812ruleParameter
813 @init {
814 int stackSize = keepStackSize();
815 }
816 :
817 (
818 { before(grammarAccess.getParameterAccess().getGroup()); }
819 (rule__Parameter__Group__0)
820 { after(grammarAccess.getParameterAccess().getGroup()); }
821 )
822;
823finally {
824 restoreStackSize(stackSize);
825}
826
827// Entry rule entryRulePatternBody
828entryRulePatternBody
829:
830{ before(grammarAccess.getPatternBodyRule()); }
831 rulePatternBody
832{ after(grammarAccess.getPatternBodyRule()); }
833 EOF
834;
835
836// Rule PatternBody
837rulePatternBody
838 @init {
839 int stackSize = keepStackSize();
840 }
841 :
842 (
843 { before(grammarAccess.getPatternBodyAccess().getGroup()); }
844 (rule__PatternBody__Group__0)
845 { after(grammarAccess.getPatternBodyAccess().getGroup()); }
846 )
847;
848finally {
849 restoreStackSize(stackSize);
850}
851
852// Entry rule entryRulePolarity
853entryRulePolarity
854:
855{ before(grammarAccess.getPolarityRule()); }
856 rulePolarity
857{ after(grammarAccess.getPolarityRule()); }
858 EOF
859;
860
861// Rule Polarity
862rulePolarity
863 @init {
864 int stackSize = keepStackSize();
865 }
866 :
867 (
868 { before(grammarAccess.getPolarityAccess().getAlternatives()); }
869 (rule__Polarity__Alternatives)
870 { after(grammarAccess.getPolarityAccess().getAlternatives()); }
871 )
872;
873finally {
874 restoreStackSize(stackSize);
875}
876
877// Entry rule entryRuleConstraint
878entryRuleConstraint
879:
880{ before(grammarAccess.getConstraintRule()); }
881 ruleConstraint
882{ after(grammarAccess.getConstraintRule()); }
883 EOF
884;
885
886// Rule Constraint
887ruleConstraint
888 @init {
889 int stackSize = keepStackSize();
890 }
891 :
892 (
893 { before(grammarAccess.getConstraintAccess().getGroup()); }
894 (rule__Constraint__Group__0)
895 { after(grammarAccess.getConstraintAccess().getGroup()); }
896 )
897;
898finally {
899 restoreStackSize(stackSize);
900}
901
902// Entry rule entryRuleClosureType
903entryRuleClosureType
904:
905{ before(grammarAccess.getClosureTypeRule()); }
906 ruleClosureType
907{ after(grammarAccess.getClosureTypeRule()); }
908 EOF
909;
910
911// Rule ClosureType
912ruleClosureType
913 @init {
914 int stackSize = keepStackSize();
915 }
916 :
917 (
918 { before(grammarAccess.getClosureTypeAccess().getAlternatives()); }
919 (rule__ClosureType__Alternatives)
920 { after(grammarAccess.getClosureTypeAccess().getAlternatives()); }
921 )
922;
923finally {
924 restoreStackSize(stackSize);
925}
926
927// Entry rule entryRuleLiteral
928entryRuleLiteral
929:
930{ before(grammarAccess.getLiteralRule()); }
931 ruleLiteral
932{ after(grammarAccess.getLiteralRule()); }
933 EOF
934;
935
936// Rule Literal
937ruleLiteral
938 @init {
939 int stackSize = keepStackSize();
940 }
941 :
942 (
943 { before(grammarAccess.getLiteralAccess().getAlternatives()); }
944 (rule__Literal__Alternatives)
945 { after(grammarAccess.getLiteralAccess().getAlternatives()); }
946 )
947;
948finally {
949 restoreStackSize(stackSize);
950}
951
952// Entry rule entryRuleVariable
953entryRuleVariable
954:
955{ before(grammarAccess.getVariableRule()); }
956 ruleVariable
957{ after(grammarAccess.getVariableRule()); }
958 EOF
959;
960
961// Rule Variable
962ruleVariable
963 @init {
964 int stackSize = keepStackSize();
965 }
966 :
967 (
968 { before(grammarAccess.getVariableAccess().getNameAssignment()); }
969 (rule__Variable__NameAssignment)
970 { after(grammarAccess.getVariableAccess().getNameAssignment()); }
971 )
972;
973finally {
974 restoreStackSize(stackSize);
975}
976
977// Entry rule entryRuleAllInstances
978entryRuleAllInstances
979:
980{ before(grammarAccess.getAllInstancesRule()); }
981 ruleAllInstances
982{ after(grammarAccess.getAllInstancesRule()); }
983 EOF
984;
985
986// Rule AllInstances
987ruleAllInstances
988 @init {
989 int stackSize = keepStackSize();
990 }
991 :
992 (
993 { before(grammarAccess.getAllInstancesAccess().getGroup()); }
994 (rule__AllInstances__Group__0)
995 { after(grammarAccess.getAllInstancesAccess().getGroup()); }
996 )
997;
998finally {
999 restoreStackSize(stackSize);
1000}
1001
1002// Entry rule entryRuleAllObjects
1003entryRuleAllObjects
1004:
1005{ before(grammarAccess.getAllObjectsRule()); }
1006 ruleAllObjects
1007{ after(grammarAccess.getAllObjectsRule()); }
1008 EOF
1009;
1010
1011// Rule AllObjects
1012ruleAllObjects
1013 @init {
1014 int stackSize = keepStackSize();
1015 }
1016 :
1017 (
1018 { before(grammarAccess.getAllObjectsAccess().getGroup()); }
1019 (rule__AllObjects__Group__0)
1020 { after(grammarAccess.getAllObjectsAccess().getGroup()); }
1021 )
1022;
1023finally {
1024 restoreStackSize(stackSize);
1025}
1026
1027// Entry rule entryRuleDefaultInterpretation
1028entryRuleDefaultInterpretation
1029:
1030{ before(grammarAccess.getDefaultInterpretationRule()); }
1031 ruleDefaultInterpretation
1032{ after(grammarAccess.getDefaultInterpretationRule()); }
1033 EOF
1034;
1035
1036// Rule DefaultInterpretation
1037ruleDefaultInterpretation
1038 @init {
1039 int stackSize = keepStackSize();
1040 }
1041 :
1042 (
1043 { before(grammarAccess.getDefaultInterpretationAccess().getGroup()); }
1044 (rule__DefaultInterpretation__Group__0)
1045 { after(grammarAccess.getDefaultInterpretationAccess().getGroup()); }
1046 )
1047;
1048finally {
1049 restoreStackSize(stackSize);
1050}
1051
1052// Entry rule entryRuleCDInterpretation
1053entryRuleCDInterpretation
1054:
1055{ before(grammarAccess.getCDInterpretationRule()); }
1056 ruleCDInterpretation
1057{ after(grammarAccess.getCDInterpretationRule()); }
1058 EOF
1059;
1060
1061// Rule CDInterpretation
1062ruleCDInterpretation
1063 @init {
1064 int stackSize = keepStackSize();
1065 }
1066 :
1067 (
1068 { before(grammarAccess.getCDInterpretationAccess().getAlternatives()); }
1069 (rule__CDInterpretation__Alternatives)
1070 { after(grammarAccess.getCDInterpretationAccess().getAlternatives()); }
1071 )
1072;
1073finally {
1074 restoreStackSize(stackSize);
1075}
1076
1077// Entry rule entryRuleClassInterpretation
1078entryRuleClassInterpretation
1079:
1080{ before(grammarAccess.getClassInterpretationRule()); }
1081 ruleClassInterpretation
1082{ after(grammarAccess.getClassInterpretationRule()); }
1083 EOF
1084;
1085
1086// Rule ClassInterpretation
1087ruleClassInterpretation
1088 @init {
1089 int stackSize = keepStackSize();
1090 }
1091 :
1092 (
1093 { before(grammarAccess.getClassInterpretationAccess().getGroup()); }
1094 (rule__ClassInterpretation__Group__0)
1095 { after(grammarAccess.getClassInterpretationAccess().getGroup()); }
1096 )
1097;
1098finally {
1099 restoreStackSize(stackSize);
1100}
1101
1102// Entry rule entryRuleEnumInterpretation
1103entryRuleEnumInterpretation
1104:
1105{ before(grammarAccess.getEnumInterpretationRule()); }
1106 ruleEnumInterpretation
1107{ after(grammarAccess.getEnumInterpretationRule()); }
1108 EOF
1109;
1110
1111// Rule EnumInterpretation
1112ruleEnumInterpretation
1113 @init {
1114 int stackSize = keepStackSize();
1115 }
1116 :
1117 (
1118 { before(grammarAccess.getEnumInterpretationAccess().getGroup()); }
1119 (rule__EnumInterpretation__Group__0)
1120 { after(grammarAccess.getEnumInterpretationAccess().getGroup()); }
1121 )
1122;
1123finally {
1124 restoreStackSize(stackSize);
1125}
1126
1127// Entry rule entryRuleFieldRelationInterpretation
1128entryRuleFieldRelationInterpretation
1129:
1130{ before(grammarAccess.getFieldRelationInterpretationRule()); }
1131 ruleFieldRelationInterpretation
1132{ after(grammarAccess.getFieldRelationInterpretationRule()); }
1133 EOF
1134;
1135
1136// Rule FieldRelationInterpretation
1137ruleFieldRelationInterpretation
1138 @init {
1139 int stackSize = keepStackSize();
1140 }
1141 :
1142 (
1143 { before(grammarAccess.getFieldRelationInterpretationAccess().getGroup()); }
1144 (rule__FieldRelationInterpretation__Group__0)
1145 { after(grammarAccess.getFieldRelationInterpretationAccess().getGroup()); }
1146 )
1147;
1148finally {
1149 restoreStackSize(stackSize);
1150}
1151
1152// Entry rule entryRuleGlobalRelationInterpretation
1153entryRuleGlobalRelationInterpretation
1154:
1155{ before(grammarAccess.getGlobalRelationInterpretationRule()); }
1156 ruleGlobalRelationInterpretation
1157{ after(grammarAccess.getGlobalRelationInterpretationRule()); }
1158 EOF
1159;
1160
1161// Rule GlobalRelationInterpretation
1162ruleGlobalRelationInterpretation
1163 @init {
1164 int stackSize = keepStackSize();
1165 }
1166 :
1167 (
1168 { before(grammarAccess.getGlobalRelationInterpretationAccess().getGroup()); }
1169 (rule__GlobalRelationInterpretation__Group__0)
1170 { after(grammarAccess.getGlobalRelationInterpretationAccess().getGroup()); }
1171 )
1172;
1173finally {
1174 restoreStackSize(stackSize);
1175}
1176
1177// Entry rule entryRuleMultiplicityDefinition
1178entryRuleMultiplicityDefinition
1179:
1180{ before(grammarAccess.getMultiplicityDefinitionRule()); }
1181 ruleMultiplicityDefinition
1182{ after(grammarAccess.getMultiplicityDefinitionRule()); }
1183 EOF
1184;
1185
1186// Rule MultiplicityDefinition
1187ruleMultiplicityDefinition
1188 @init {
1189 int stackSize = keepStackSize();
1190 }
1191 :
1192 (
1193 { before(grammarAccess.getMultiplicityDefinitionAccess().getGroup()); }
1194 (rule__MultiplicityDefinition__Group__0)
1195 { after(grammarAccess.getMultiplicityDefinitionAccess().getGroup()); }
1196 )
1197;
1198finally {
1199 restoreStackSize(stackSize);
1200}
1201
1202rule__Statement__Alternatives
1203 @init {
1204 int stackSize = keepStackSize();
1205 }
1206:
1207 (
1208 { before(grammarAccess.getStatementAccess().getInterpretationParserRuleCall_0()); }
1209 ruleInterpretation
1210 { after(grammarAccess.getStatementAccess().getInterpretationParserRuleCall_0()); }
1211 )
1212 |
1213 (
1214 { before(grammarAccess.getStatementAccess().getPredicateParserRuleCall_1()); }
1215 rulePredicate
1216 { after(grammarAccess.getStatementAccess().getPredicateParserRuleCall_1()); }
1217 )
1218;
1219finally {
1220 restoreStackSize(stackSize);
1221}
1222
1223rule__BooleanValue__Alternatives
1224 @init {
1225 int stackSize = keepStackSize();
1226 }
1227:
1228 (
1229 { before(grammarAccess.getBooleanValueAccess().getGroup_0()); }
1230 (rule__BooleanValue__Group_0__0)
1231 { after(grammarAccess.getBooleanValueAccess().getGroup_0()); }
1232 )
1233 |
1234 (
1235 { before(grammarAccess.getBooleanValueAccess().getGroup_1()); }
1236 (rule__BooleanValue__Group_1__0)
1237 { after(grammarAccess.getBooleanValueAccess().getGroup_1()); }
1238 )
1239;
1240finally {
1241 restoreStackSize(stackSize);
1242}
1243
1244rule__TruthValue__Alternatives
1245 @init {
1246 int stackSize = keepStackSize();
1247 }
1248:
1249 (
1250 { before(grammarAccess.getTruthValueAccess().getGroup_0()); }
1251 (rule__TruthValue__Group_0__0)
1252 { after(grammarAccess.getTruthValueAccess().getGroup_0()); }
1253 )
1254 |
1255 (
1256 { before(grammarAccess.getTruthValueAccess().getGroup_1()); }
1257 (rule__TruthValue__Group_1__0)
1258 { after(grammarAccess.getTruthValueAccess().getGroup_1()); }
1259 )
1260 |
1261 (
1262 { before(grammarAccess.getTruthValueAccess().getGroup_2()); }
1263 (rule__TruthValue__Group_2__0)
1264 { after(grammarAccess.getTruthValueAccess().getGroup_2()); }
1265 )
1266 |
1267 (
1268 { before(grammarAccess.getTruthValueAccess().getGroup_3()); }
1269 (rule__TruthValue__Group_3__0)
1270 { after(grammarAccess.getTruthValueAccess().getGroup_3()); }
1271 )
1272;
1273finally {
1274 restoreStackSize(stackSize);
1275}
1276
1277rule__Interpretation__Alternatives
1278 @init {
1279 int stackSize = keepStackSize();
1280 }
1281:
1282 (
1283 { before(grammarAccess.getInterpretationAccess().getBasicInterpretationParserRuleCall_0()); }
1284 ruleBasicInterpretation
1285 { after(grammarAccess.getInterpretationAccess().getBasicInterpretationParserRuleCall_0()); }
1286 )
1287 |
1288 (
1289 { before(grammarAccess.getInterpretationAccess().getDefaultInterpretationParserRuleCall_1()); }
1290 ruleDefaultInterpretation
1291 { after(grammarAccess.getInterpretationAccess().getDefaultInterpretationParserRuleCall_1()); }
1292 )
1293 |
1294 (
1295 { before(grammarAccess.getInterpretationAccess().getCDInterpretationParserRuleCall_2()); }
1296 ruleCDInterpretation
1297 { after(grammarAccess.getInterpretationAccess().getCDInterpretationParserRuleCall_2()); }
1298 )
1299;
1300finally {
1301 restoreStackSize(stackSize);
1302}
1303
1304rule__Symbol__Alternatives
1305 @init {
1306 int stackSize = keepStackSize();
1307 }
1308:
1309 (
1310 { before(grammarAccess.getSymbolAccess().getModelSymbolParserRuleCall_0()); }
1311 ruleModelSymbol
1312 { after(grammarAccess.getSymbolAccess().getModelSymbolParserRuleCall_0()); }
1313 )
1314 |
1315 (
1316 { before(grammarAccess.getSymbolAccess().getPartialitySymbolParserRuleCall_1()); }
1317 rulePartialitySymbol
1318 { after(grammarAccess.getSymbolAccess().getPartialitySymbolParserRuleCall_1()); }
1319 )
1320 |
1321 (
1322 { before(grammarAccess.getSymbolAccess().getDataSymbolParserRuleCall_2()); }
1323 ruleDataSymbol
1324 { after(grammarAccess.getSymbolAccess().getDataSymbolParserRuleCall_2()); }
1325 )
1326;
1327finally {
1328 restoreStackSize(stackSize);
1329}
1330
1331rule__PartialitySymbol__Alternatives
1332 @init {
1333 int stackSize = keepStackSize();
1334 }
1335:
1336 (
1337 { before(grammarAccess.getPartialitySymbolAccess().getExistSymbolParserRuleCall_0()); }
1338 ruleExistSymbol
1339 { after(grammarAccess.getPartialitySymbolAccess().getExistSymbolParserRuleCall_0()); }
1340 )
1341 |
1342 (
1343 { before(grammarAccess.getPartialitySymbolAccess().getEqualsSymbolParserRuleCall_1()); }
1344 ruleEqualsSymbol
1345 { after(grammarAccess.getPartialitySymbolAccess().getEqualsSymbolParserRuleCall_1()); }
1346 )
1347;
1348finally {
1349 restoreStackSize(stackSize);
1350}
1351
1352rule__DataSymbol__Alternatives
1353 @init {
1354 int stackSize = keepStackSize();
1355 }
1356:
1357 (
1358 { before(grammarAccess.getDataSymbolAccess().getBooleanSymbolParserRuleCall_0()); }
1359 ruleBooleanSymbol
1360 { after(grammarAccess.getDataSymbolAccess().getBooleanSymbolParserRuleCall_0()); }
1361 )
1362 |
1363 (
1364 { before(grammarAccess.getDataSymbolAccess().getIntegerSymbolParserRuleCall_1()); }
1365 ruleIntegerSymbol
1366 { after(grammarAccess.getDataSymbolAccess().getIntegerSymbolParserRuleCall_1()); }
1367 )
1368 |
1369 (
1370 { before(grammarAccess.getDataSymbolAccess().getRealSymbolParserRuleCall_2()); }
1371 ruleRealSymbol
1372 { after(grammarAccess.getDataSymbolAccess().getRealSymbolParserRuleCall_2()); }
1373 )
1374 |
1375 (
1376 { before(grammarAccess.getDataSymbolAccess().getStringSymbolParserRuleCall_3()); }
1377 ruleStringSymbol
1378 { after(grammarAccess.getDataSymbolAccess().getStringSymbolParserRuleCall_3()); }
1379 )
1380;
1381finally {
1382 restoreStackSize(stackSize);
1383}
1384
1385rule__ComplexObject__Alternatives
1386 @init {
1387 int stackSize = keepStackSize();
1388 }
1389:
1390 (
1391 { before(grammarAccess.getComplexObjectAccess().getObjectParserRuleCall_0()); }
1392 ruleObject
1393 { after(grammarAccess.getComplexObjectAccess().getObjectParserRuleCall_0()); }
1394 )
1395 |
1396 (
1397 { before(grammarAccess.getComplexObjectAccess().getAllInstancesParserRuleCall_1()); }
1398 ruleAllInstances
1399 { after(grammarAccess.getComplexObjectAccess().getAllInstancesParserRuleCall_1()); }
1400 )
1401 |
1402 (
1403 { before(grammarAccess.getComplexObjectAccess().getAllObjectsParserRuleCall_2()); }
1404 ruleAllObjects
1405 { after(grammarAccess.getComplexObjectAccess().getAllObjectsParserRuleCall_2()); }
1406 )
1407;
1408finally {
1409 restoreStackSize(stackSize);
1410}
1411
1412rule__Object__Alternatives
1413 @init {
1414 int stackSize = keepStackSize();
1415 }
1416:
1417 (
1418 { before(grammarAccess.getObjectAccess().getNamedObjectParserRuleCall_0()); }
1419 ruleNamedObject
1420 { after(grammarAccess.getObjectAccess().getNamedObjectParserRuleCall_0()); }
1421 )
1422 |
1423 (
1424 { before(grammarAccess.getObjectAccess().getUnnamedObjectParserRuleCall_1()); }
1425 ruleUnnamedObject
1426 { after(grammarAccess.getObjectAccess().getUnnamedObjectParserRuleCall_1()); }
1427 )
1428 |
1429 (
1430 { before(grammarAccess.getObjectAccess().getDataObjectParserRuleCall_2()); }
1431 ruleDataObject
1432 { after(grammarAccess.getObjectAccess().getDataObjectParserRuleCall_2()); }
1433 )
1434;
1435finally {
1436 restoreStackSize(stackSize);
1437}
1438
1439rule__DataObject__Alternatives
1440 @init {
1441 int stackSize = keepStackSize();
1442 }
1443:
1444 (
1445 { before(grammarAccess.getDataObjectAccess().getBooleanObjectParserRuleCall_0()); }
1446 ruleBooleanObject
1447 { after(grammarAccess.getDataObjectAccess().getBooleanObjectParserRuleCall_0()); }
1448 )
1449 |
1450 (
1451 { before(grammarAccess.getDataObjectAccess().getIntObjectParserRuleCall_1()); }
1452 ruleIntObject
1453 { after(grammarAccess.getDataObjectAccess().getIntObjectParserRuleCall_1()); }
1454 )
1455 |
1456 (
1457 { before(grammarAccess.getDataObjectAccess().getRealObjectParserRuleCall_2()); }
1458 ruleRealObject
1459 { after(grammarAccess.getDataObjectAccess().getRealObjectParserRuleCall_2()); }
1460 )
1461 |
1462 (
1463 { before(grammarAccess.getDataObjectAccess().getStringObjectParserRuleCall_3()); }
1464 ruleStringObject
1465 { after(grammarAccess.getDataObjectAccess().getStringObjectParserRuleCall_3()); }
1466 )
1467;
1468finally {
1469 restoreStackSize(stackSize);
1470}
1471
1472rule__Predicate__Alternatives
1473 @init {
1474 int stackSize = keepStackSize();
1475 }
1476:
1477 (
1478 { before(grammarAccess.getPredicateAccess().getPredicateSymbolParserRuleCall_0()); }
1479 rulePredicateSymbol
1480 { after(grammarAccess.getPredicateAccess().getPredicateSymbolParserRuleCall_0()); }
1481 )
1482 |
1483 (
1484 { before(grammarAccess.getPredicateAccess().getErrorPredicateParserRuleCall_1()); }
1485 ruleErrorPredicate
1486 { after(grammarAccess.getPredicateAccess().getErrorPredicateParserRuleCall_1()); }
1487 )
1488;
1489finally {
1490 restoreStackSize(stackSize);
1491}
1492
1493rule__PredicateSymbol__Alternatives_6
1494 @init {
1495 int stackSize = keepStackSize();
1496 }
1497:
1498 (
1499 { before(grammarAccess.getPredicateSymbolAccess().getFalseKeyword_6_0()); }
1500 'false'
1501 { after(grammarAccess.getPredicateSymbolAccess().getFalseKeyword_6_0()); }
1502 )
1503 |
1504 (
1505 { before(grammarAccess.getPredicateSymbolAccess().getGroup_6_1()); }
1506 (rule__PredicateSymbol__Group_6_1__0)
1507 { after(grammarAccess.getPredicateSymbolAccess().getGroup_6_1()); }
1508 )
1509;
1510finally {
1511 restoreStackSize(stackSize);
1512}
1513
1514rule__ErrorPredicate__Alternatives_5
1515 @init {
1516 int stackSize = keepStackSize();
1517 }
1518:
1519 (
1520 { before(grammarAccess.getErrorPredicateAccess().getFalseKeyword_5_0()); }
1521 'false'
1522 { after(grammarAccess.getErrorPredicateAccess().getFalseKeyword_5_0()); }
1523 )
1524 |
1525 (
1526 { before(grammarAccess.getErrorPredicateAccess().getGroup_5_1()); }
1527 (rule__ErrorPredicate__Group_5_1__0)
1528 { after(grammarAccess.getErrorPredicateAccess().getGroup_5_1()); }
1529 )
1530;
1531finally {
1532 restoreStackSize(stackSize);
1533}
1534
1535rule__PatternBody__Alternatives_1
1536 @init {
1537 int stackSize = keepStackSize();
1538 }
1539:
1540 (
1541 { before(grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0()); }
1542 'true'
1543 { after(grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0()); }
1544 )
1545 |
1546 (
1547 { before(grammarAccess.getPatternBodyAccess().getConstraintsAssignment_1_1()); }
1548 (rule__PatternBody__ConstraintsAssignment_1_1)*
1549 { after(grammarAccess.getPatternBodyAccess().getConstraintsAssignment_1_1()); }
1550 )
1551;
1552finally {
1553 restoreStackSize(stackSize);
1554}
1555
1556rule__Polarity__Alternatives
1557 @init {
1558 int stackSize = keepStackSize();
1559 }
1560:
1561 (
1562 { before(grammarAccess.getPolarityAccess().getGroup_0()); }
1563 (rule__Polarity__Group_0__0)
1564 { after(grammarAccess.getPolarityAccess().getGroup_0()); }
1565 )
1566 |
1567 (
1568 { before(grammarAccess.getPolarityAccess().getGroup_1()); }
1569 (rule__Polarity__Group_1__0)
1570 { after(grammarAccess.getPolarityAccess().getGroup_1()); }
1571 )
1572;
1573finally {
1574 restoreStackSize(stackSize);
1575}
1576
1577rule__Constraint__Alternatives_2
1578 @init {
1579 int stackSize = keepStackSize();
1580 }
1581:
1582 (
1583 { before(grammarAccess.getConstraintAccess().getGroup_2_0()); }
1584 (rule__Constraint__Group_2_0__0)
1585 { after(grammarAccess.getConstraintAccess().getGroup_2_0()); }
1586 )
1587 |
1588 (
1589 { before(grammarAccess.getConstraintAccess().getGroup_2_1()); }
1590 (rule__Constraint__Group_2_1__0)
1591 { after(grammarAccess.getConstraintAccess().getGroup_2_1()); }
1592 )
1593;
1594finally {
1595 restoreStackSize(stackSize);
1596}
1597
1598rule__ClosureType__Alternatives
1599 @init {
1600 int stackSize = keepStackSize();
1601 }
1602:
1603 (
1604 { before(grammarAccess.getClosureTypeAccess().getGroup_0()); }
1605 (rule__ClosureType__Group_0__0)
1606 { after(grammarAccess.getClosureTypeAccess().getGroup_0()); }
1607 )
1608 |
1609 (
1610 { before(grammarAccess.getClosureTypeAccess().getGroup_1()); }
1611 (rule__ClosureType__Group_1__0)
1612 { after(grammarAccess.getClosureTypeAccess().getGroup_1()); }
1613 )
1614;
1615finally {
1616 restoreStackSize(stackSize);
1617}
1618
1619rule__Literal__Alternatives
1620 @init {
1621 int stackSize = keepStackSize();
1622 }
1623:
1624 (
1625 { before(grammarAccess.getLiteralAccess().getVariableParserRuleCall_0()); }
1626 ruleVariable
1627 { after(grammarAccess.getLiteralAccess().getVariableParserRuleCall_0()); }
1628 )
1629 |
1630 (
1631 { before(grammarAccess.getLiteralAccess().getDataObjectParserRuleCall_1()); }
1632 ruleDataObject
1633 { after(grammarAccess.getLiteralAccess().getDataObjectParserRuleCall_1()); }
1634 )
1635;
1636finally {
1637 restoreStackSize(stackSize);
1638}
1639
1640rule__CDInterpretation__Alternatives
1641 @init {
1642 int stackSize = keepStackSize();
1643 }
1644:
1645 (
1646 { before(grammarAccess.getCDInterpretationAccess().getClassInterpretationParserRuleCall_0()); }
1647 ruleClassInterpretation
1648 { after(grammarAccess.getCDInterpretationAccess().getClassInterpretationParserRuleCall_0()); }
1649 )
1650 |
1651 (
1652 { before(grammarAccess.getCDInterpretationAccess().getEnumInterpretationParserRuleCall_1()); }
1653 ruleEnumInterpretation
1654 { after(grammarAccess.getCDInterpretationAccess().getEnumInterpretationParserRuleCall_1()); }
1655 )
1656 |
1657 (
1658 { before(grammarAccess.getCDInterpretationAccess().getGlobalRelationInterpretationParserRuleCall_2()); }
1659 ruleGlobalRelationInterpretation
1660 { after(grammarAccess.getCDInterpretationAccess().getGlobalRelationInterpretationParserRuleCall_2()); }
1661 )
1662;
1663finally {
1664 restoreStackSize(stackSize);
1665}
1666
1667rule__MultiplicityDefinition__Alternatives_2
1668 @init {
1669 int stackSize = keepStackSize();
1670 }
1671:
1672 (
1673 { before(grammarAccess.getMultiplicityDefinitionAccess().getUpperAssignment_2_0()); }
1674 (rule__MultiplicityDefinition__UpperAssignment_2_0)
1675 { after(grammarAccess.getMultiplicityDefinitionAccess().getUpperAssignment_2_0()); }
1676 )
1677 |
1678 (
1679 { before(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAssignment_2_1()); }
1680 (rule__MultiplicityDefinition__UnlimitedUpperAssignment_2_1)
1681 { after(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAssignment_2_1()); }
1682 )
1683;
1684finally {
1685 restoreStackSize(stackSize);
1686}
1687
1688rule__REALLiteral__Group__0
1689 @init {
1690 int stackSize = keepStackSize();
1691 }
1692:
1693 rule__REALLiteral__Group__0__Impl
1694 rule__REALLiteral__Group__1
1695;
1696finally {
1697 restoreStackSize(stackSize);
1698}
1699
1700rule__REALLiteral__Group__0__Impl
1701 @init {
1702 int stackSize = keepStackSize();
1703 }
1704:
1705(
1706 { before(grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0()); }
1707 ('-')?
1708 { after(grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0()); }
1709)
1710;
1711finally {
1712 restoreStackSize(stackSize);
1713}
1714
1715rule__REALLiteral__Group__1
1716 @init {
1717 int stackSize = keepStackSize();
1718 }
1719:
1720 rule__REALLiteral__Group__1__Impl
1721 rule__REALLiteral__Group__2
1722;
1723finally {
1724 restoreStackSize(stackSize);
1725}
1726
1727rule__REALLiteral__Group__1__Impl
1728 @init {
1729 int stackSize = keepStackSize();
1730 }
1731:
1732(
1733 { before(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1()); }
1734 RULE_INT
1735 { after(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1()); }
1736)
1737;
1738finally {
1739 restoreStackSize(stackSize);
1740}
1741
1742rule__REALLiteral__Group__2
1743 @init {
1744 int stackSize = keepStackSize();
1745 }
1746:
1747 rule__REALLiteral__Group__2__Impl
1748 rule__REALLiteral__Group__3
1749;
1750finally {
1751 restoreStackSize(stackSize);
1752}
1753
1754rule__REALLiteral__Group__2__Impl
1755 @init {
1756 int stackSize = keepStackSize();
1757 }
1758:
1759(
1760 { before(grammarAccess.getREALLiteralAccess().getFullStopKeyword_2()); }
1761 '.'
1762 { after(grammarAccess.getREALLiteralAccess().getFullStopKeyword_2()); }
1763)
1764;
1765finally {
1766 restoreStackSize(stackSize);
1767}
1768
1769rule__REALLiteral__Group__3
1770 @init {
1771 int stackSize = keepStackSize();
1772 }
1773:
1774 rule__REALLiteral__Group__3__Impl
1775;
1776finally {
1777 restoreStackSize(stackSize);
1778}
1779
1780rule__REALLiteral__Group__3__Impl
1781 @init {
1782 int stackSize = keepStackSize();
1783 }
1784:
1785(
1786 { before(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3()); }
1787 RULE_INT
1788 { after(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3()); }
1789)
1790;
1791finally {
1792 restoreStackSize(stackSize);
1793}
1794
1795
1796rule__INTLiteral__Group__0
1797 @init {
1798 int stackSize = keepStackSize();
1799 }
1800:
1801 rule__INTLiteral__Group__0__Impl
1802 rule__INTLiteral__Group__1
1803;
1804finally {
1805 restoreStackSize(stackSize);
1806}
1807
1808rule__INTLiteral__Group__0__Impl
1809 @init {
1810 int stackSize = keepStackSize();
1811 }
1812:
1813(
1814 { before(grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0()); }
1815 ('-')?
1816 { after(grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0()); }
1817)
1818;
1819finally {
1820 restoreStackSize(stackSize);
1821}
1822
1823rule__INTLiteral__Group__1
1824 @init {
1825 int stackSize = keepStackSize();
1826 }
1827:
1828 rule__INTLiteral__Group__1__Impl
1829;
1830finally {
1831 restoreStackSize(stackSize);
1832}
1833
1834rule__INTLiteral__Group__1__Impl
1835 @init {
1836 int stackSize = keepStackSize();
1837 }
1838:
1839(
1840 { before(grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1()); }
1841 RULE_INT
1842 { after(grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1()); }
1843)
1844;
1845finally {
1846 restoreStackSize(stackSize);
1847}
1848
1849
1850rule__BooleanValue__Group_0__0
1851 @init {
1852 int stackSize = keepStackSize();
1853 }
1854:
1855 rule__BooleanValue__Group_0__0__Impl
1856 rule__BooleanValue__Group_0__1
1857;
1858finally {
1859 restoreStackSize(stackSize);
1860}
1861
1862rule__BooleanValue__Group_0__0__Impl
1863 @init {
1864 int stackSize = keepStackSize();
1865 }
1866:
1867(
1868 { before(grammarAccess.getBooleanValueAccess().getBooleanTrueAction_0_0()); }
1869 ()
1870 { after(grammarAccess.getBooleanValueAccess().getBooleanTrueAction_0_0()); }
1871)
1872;
1873finally {
1874 restoreStackSize(stackSize);
1875}
1876
1877rule__BooleanValue__Group_0__1
1878 @init {
1879 int stackSize = keepStackSize();
1880 }
1881:
1882 rule__BooleanValue__Group_0__1__Impl
1883;
1884finally {
1885 restoreStackSize(stackSize);
1886}
1887
1888rule__BooleanValue__Group_0__1__Impl
1889 @init {
1890 int stackSize = keepStackSize();
1891 }
1892:
1893(
1894 { before(grammarAccess.getBooleanValueAccess().getTrueKeyword_0_1()); }
1895 'true'
1896 { after(grammarAccess.getBooleanValueAccess().getTrueKeyword_0_1()); }
1897)
1898;
1899finally {
1900 restoreStackSize(stackSize);
1901}
1902
1903
1904rule__BooleanValue__Group_1__0
1905 @init {
1906 int stackSize = keepStackSize();
1907 }
1908:
1909 rule__BooleanValue__Group_1__0__Impl
1910 rule__BooleanValue__Group_1__1
1911;
1912finally {
1913 restoreStackSize(stackSize);
1914}
1915
1916rule__BooleanValue__Group_1__0__Impl
1917 @init {
1918 int stackSize = keepStackSize();
1919 }
1920:
1921(
1922 { before(grammarAccess.getBooleanValueAccess().getFalseKeyword_1_0()); }
1923 'false'
1924 { after(grammarAccess.getBooleanValueAccess().getFalseKeyword_1_0()); }
1925)
1926;
1927finally {
1928 restoreStackSize(stackSize);
1929}
1930
1931rule__BooleanValue__Group_1__1
1932 @init {
1933 int stackSize = keepStackSize();
1934 }
1935:
1936 rule__BooleanValue__Group_1__1__Impl
1937;
1938finally {
1939 restoreStackSize(stackSize);
1940}
1941
1942rule__BooleanValue__Group_1__1__Impl
1943 @init {
1944 int stackSize = keepStackSize();
1945 }
1946:
1947(
1948 { before(grammarAccess.getBooleanValueAccess().getBooleanFalseAction_1_1()); }
1949 ()
1950 { after(grammarAccess.getBooleanValueAccess().getBooleanFalseAction_1_1()); }
1951)
1952;
1953finally {
1954 restoreStackSize(stackSize);
1955}
1956
1957
1958rule__TruthValue__Group_0__0
1959 @init {
1960 int stackSize = keepStackSize();
1961 }
1962:
1963 rule__TruthValue__Group_0__0__Impl
1964 rule__TruthValue__Group_0__1
1965;
1966finally {
1967 restoreStackSize(stackSize);
1968}
1969
1970rule__TruthValue__Group_0__0__Impl
1971 @init {
1972 int stackSize = keepStackSize();
1973 }
1974:
1975(
1976 { before(grammarAccess.getTruthValueAccess().getTrueAction_0_0()); }
1977 ()
1978 { after(grammarAccess.getTruthValueAccess().getTrueAction_0_0()); }
1979)
1980;
1981finally {
1982 restoreStackSize(stackSize);
1983}
1984
1985rule__TruthValue__Group_0__1
1986 @init {
1987 int stackSize = keepStackSize();
1988 }
1989:
1990 rule__TruthValue__Group_0__1__Impl
1991;
1992finally {
1993 restoreStackSize(stackSize);
1994}
1995
1996rule__TruthValue__Group_0__1__Impl
1997 @init {
1998 int stackSize = keepStackSize();
1999 }
2000:
2001(
2002 { before(grammarAccess.getTruthValueAccess().getTrueKeyword_0_1()); }
2003 'true'
2004 { after(grammarAccess.getTruthValueAccess().getTrueKeyword_0_1()); }
2005)
2006;
2007finally {
2008 restoreStackSize(stackSize);
2009}
2010
2011
2012rule__TruthValue__Group_1__0
2013 @init {
2014 int stackSize = keepStackSize();
2015 }
2016:
2017 rule__TruthValue__Group_1__0__Impl
2018 rule__TruthValue__Group_1__1
2019;
2020finally {
2021 restoreStackSize(stackSize);
2022}
2023
2024rule__TruthValue__Group_1__0__Impl
2025 @init {
2026 int stackSize = keepStackSize();
2027 }
2028:
2029(
2030 { before(grammarAccess.getTruthValueAccess().getFalseAction_1_0()); }
2031 ()
2032 { after(grammarAccess.getTruthValueAccess().getFalseAction_1_0()); }
2033)
2034;
2035finally {
2036 restoreStackSize(stackSize);
2037}
2038
2039rule__TruthValue__Group_1__1
2040 @init {
2041 int stackSize = keepStackSize();
2042 }
2043:
2044 rule__TruthValue__Group_1__1__Impl
2045;
2046finally {
2047 restoreStackSize(stackSize);
2048}
2049
2050rule__TruthValue__Group_1__1__Impl
2051 @init {
2052 int stackSize = keepStackSize();
2053 }
2054:
2055(
2056 { before(grammarAccess.getTruthValueAccess().getFalseKeyword_1_1()); }
2057 'false'
2058 { after(grammarAccess.getTruthValueAccess().getFalseKeyword_1_1()); }
2059)
2060;
2061finally {
2062 restoreStackSize(stackSize);
2063}
2064
2065
2066rule__TruthValue__Group_2__0
2067 @init {
2068 int stackSize = keepStackSize();
2069 }
2070:
2071 rule__TruthValue__Group_2__0__Impl
2072 rule__TruthValue__Group_2__1
2073;
2074finally {
2075 restoreStackSize(stackSize);
2076}
2077
2078rule__TruthValue__Group_2__0__Impl
2079 @init {
2080 int stackSize = keepStackSize();
2081 }
2082:
2083(
2084 { before(grammarAccess.getTruthValueAccess().getUnknownAction_2_0()); }
2085 ()
2086 { after(grammarAccess.getTruthValueAccess().getUnknownAction_2_0()); }
2087)
2088;
2089finally {
2090 restoreStackSize(stackSize);
2091}
2092
2093rule__TruthValue__Group_2__1
2094 @init {
2095 int stackSize = keepStackSize();
2096 }
2097:
2098 rule__TruthValue__Group_2__1__Impl
2099;
2100finally {
2101 restoreStackSize(stackSize);
2102}
2103
2104rule__TruthValue__Group_2__1__Impl
2105 @init {
2106 int stackSize = keepStackSize();
2107 }
2108:
2109(
2110 { before(grammarAccess.getTruthValueAccess().getUnknownKeyword_2_1()); }
2111 'unknown'
2112 { after(grammarAccess.getTruthValueAccess().getUnknownKeyword_2_1()); }
2113)
2114;
2115finally {
2116 restoreStackSize(stackSize);
2117}
2118
2119
2120rule__TruthValue__Group_3__0
2121 @init {
2122 int stackSize = keepStackSize();
2123 }
2124:
2125 rule__TruthValue__Group_3__0__Impl
2126 rule__TruthValue__Group_3__1
2127;
2128finally {
2129 restoreStackSize(stackSize);
2130}
2131
2132rule__TruthValue__Group_3__0__Impl
2133 @init {
2134 int stackSize = keepStackSize();
2135 }
2136:
2137(
2138 { before(grammarAccess.getTruthValueAccess().getErrorAction_3_0()); }
2139 ()
2140 { after(grammarAccess.getTruthValueAccess().getErrorAction_3_0()); }
2141)
2142;
2143finally {
2144 restoreStackSize(stackSize);
2145}
2146
2147rule__TruthValue__Group_3__1
2148 @init {
2149 int stackSize = keepStackSize();
2150 }
2151:
2152 rule__TruthValue__Group_3__1__Impl
2153;
2154finally {
2155 restoreStackSize(stackSize);
2156}
2157
2158rule__TruthValue__Group_3__1__Impl
2159 @init {
2160 int stackSize = keepStackSize();
2161 }
2162:
2163(
2164 { before(grammarAccess.getTruthValueAccess().getErrorKeyword_3_1()); }
2165 'error'
2166 { after(grammarAccess.getTruthValueAccess().getErrorKeyword_3_1()); }
2167)
2168;
2169finally {
2170 restoreStackSize(stackSize);
2171}
2172
2173
2174rule__BasicInterpretation__Group__0
2175 @init {
2176 int stackSize = keepStackSize();
2177 }
2178:
2179 rule__BasicInterpretation__Group__0__Impl
2180 rule__BasicInterpretation__Group__1
2181;
2182finally {
2183 restoreStackSize(stackSize);
2184}
2185
2186rule__BasicInterpretation__Group__0__Impl
2187 @init {
2188 int stackSize = keepStackSize();
2189 }
2190:
2191(
2192 { before(grammarAccess.getBasicInterpretationAccess().getSymbolAssignment_0()); }
2193 (rule__BasicInterpretation__SymbolAssignment_0)
2194 { after(grammarAccess.getBasicInterpretationAccess().getSymbolAssignment_0()); }
2195)
2196;
2197finally {
2198 restoreStackSize(stackSize);
2199}
2200
2201rule__BasicInterpretation__Group__1
2202 @init {
2203 int stackSize = keepStackSize();
2204 }
2205:
2206 rule__BasicInterpretation__Group__1__Impl
2207 rule__BasicInterpretation__Group__2
2208;
2209finally {
2210 restoreStackSize(stackSize);
2211}
2212
2213rule__BasicInterpretation__Group__1__Impl
2214 @init {
2215 int stackSize = keepStackSize();
2216 }
2217:
2218(
2219 { before(grammarAccess.getBasicInterpretationAccess().getLeftParenthesisKeyword_1()); }
2220 '('
2221 { after(grammarAccess.getBasicInterpretationAccess().getLeftParenthesisKeyword_1()); }
2222)
2223;
2224finally {
2225 restoreStackSize(stackSize);
2226}
2227
2228rule__BasicInterpretation__Group__2
2229 @init {
2230 int stackSize = keepStackSize();
2231 }
2232:
2233 rule__BasicInterpretation__Group__2__Impl
2234 rule__BasicInterpretation__Group__3
2235;
2236finally {
2237 restoreStackSize(stackSize);
2238}
2239
2240rule__BasicInterpretation__Group__2__Impl
2241 @init {
2242 int stackSize = keepStackSize();
2243 }
2244:
2245(
2246 { before(grammarAccess.getBasicInterpretationAccess().getObjectsAssignment_2()); }
2247 (rule__BasicInterpretation__ObjectsAssignment_2)*
2248 { after(grammarAccess.getBasicInterpretationAccess().getObjectsAssignment_2()); }
2249)
2250;
2251finally {
2252 restoreStackSize(stackSize);
2253}
2254
2255rule__BasicInterpretation__Group__3
2256 @init {
2257 int stackSize = keepStackSize();
2258 }
2259:
2260 rule__BasicInterpretation__Group__3__Impl
2261 rule__BasicInterpretation__Group__4
2262;
2263finally {
2264 restoreStackSize(stackSize);
2265}
2266
2267rule__BasicInterpretation__Group__3__Impl
2268 @init {
2269 int stackSize = keepStackSize();
2270 }
2271:
2272(
2273 { before(grammarAccess.getBasicInterpretationAccess().getRightParenthesisKeyword_3()); }
2274 ')'
2275 { after(grammarAccess.getBasicInterpretationAccess().getRightParenthesisKeyword_3()); }
2276)
2277;
2278finally {
2279 restoreStackSize(stackSize);
2280}
2281
2282rule__BasicInterpretation__Group__4
2283 @init {
2284 int stackSize = keepStackSize();
2285 }
2286:
2287 rule__BasicInterpretation__Group__4__Impl
2288 rule__BasicInterpretation__Group__5
2289;
2290finally {
2291 restoreStackSize(stackSize);
2292}
2293
2294rule__BasicInterpretation__Group__4__Impl
2295 @init {
2296 int stackSize = keepStackSize();
2297 }
2298:
2299(
2300 { before(grammarAccess.getBasicInterpretationAccess().getColonKeyword_4()); }
2301 ':'
2302 { after(grammarAccess.getBasicInterpretationAccess().getColonKeyword_4()); }
2303)
2304;
2305finally {
2306 restoreStackSize(stackSize);
2307}
2308
2309rule__BasicInterpretation__Group__5
2310 @init {
2311 int stackSize = keepStackSize();
2312 }
2313:
2314 rule__BasicInterpretation__Group__5__Impl
2315;
2316finally {
2317 restoreStackSize(stackSize);
2318}
2319
2320rule__BasicInterpretation__Group__5__Impl
2321 @init {
2322 int stackSize = keepStackSize();
2323 }
2324:
2325(
2326 { before(grammarAccess.getBasicInterpretationAccess().getValueAssignment_5()); }
2327 (rule__BasicInterpretation__ValueAssignment_5)
2328 { after(grammarAccess.getBasicInterpretationAccess().getValueAssignment_5()); }
2329)
2330;
2331finally {
2332 restoreStackSize(stackSize);
2333}
2334
2335
2336rule__ExistSymbol__Group__0
2337 @init {
2338 int stackSize = keepStackSize();
2339 }
2340:
2341 rule__ExistSymbol__Group__0__Impl
2342 rule__ExistSymbol__Group__1
2343;
2344finally {
2345 restoreStackSize(stackSize);
2346}
2347
2348rule__ExistSymbol__Group__0__Impl
2349 @init {
2350 int stackSize = keepStackSize();
2351 }
2352:
2353(
2354 { before(grammarAccess.getExistSymbolAccess().getExistsKeyword_0()); }
2355 'exists'
2356 { after(grammarAccess.getExistSymbolAccess().getExistsKeyword_0()); }
2357)
2358;
2359finally {
2360 restoreStackSize(stackSize);
2361}
2362
2363rule__ExistSymbol__Group__1
2364 @init {
2365 int stackSize = keepStackSize();
2366 }
2367:
2368 rule__ExistSymbol__Group__1__Impl
2369;
2370finally {
2371 restoreStackSize(stackSize);
2372}
2373
2374rule__ExistSymbol__Group__1__Impl
2375 @init {
2376 int stackSize = keepStackSize();
2377 }
2378:
2379(
2380 { before(grammarAccess.getExistSymbolAccess().getExistSymbolAction_1()); }
2381 ()
2382 { after(grammarAccess.getExistSymbolAccess().getExistSymbolAction_1()); }
2383)
2384;
2385finally {
2386 restoreStackSize(stackSize);
2387}
2388
2389
2390rule__EqualsSymbol__Group__0
2391 @init {
2392 int stackSize = keepStackSize();
2393 }
2394:
2395 rule__EqualsSymbol__Group__0__Impl
2396 rule__EqualsSymbol__Group__1
2397;
2398finally {
2399 restoreStackSize(stackSize);
2400}
2401
2402rule__EqualsSymbol__Group__0__Impl
2403 @init {
2404 int stackSize = keepStackSize();
2405 }
2406:
2407(
2408 { before(grammarAccess.getEqualsSymbolAccess().getEqualsKeyword_0()); }
2409 'equals'
2410 { after(grammarAccess.getEqualsSymbolAccess().getEqualsKeyword_0()); }
2411)
2412;
2413finally {
2414 restoreStackSize(stackSize);
2415}
2416
2417rule__EqualsSymbol__Group__1
2418 @init {
2419 int stackSize = keepStackSize();
2420 }
2421:
2422 rule__EqualsSymbol__Group__1__Impl
2423;
2424finally {
2425 restoreStackSize(stackSize);
2426}
2427
2428rule__EqualsSymbol__Group__1__Impl
2429 @init {
2430 int stackSize = keepStackSize();
2431 }
2432:
2433(
2434 { before(grammarAccess.getEqualsSymbolAccess().getEqualsSymbolAction_1()); }
2435 ()
2436 { after(grammarAccess.getEqualsSymbolAccess().getEqualsSymbolAction_1()); }
2437)
2438;
2439finally {
2440 restoreStackSize(stackSize);
2441}
2442
2443
2444rule__BooleanSymbol__Group__0
2445 @init {
2446 int stackSize = keepStackSize();
2447 }
2448:
2449 rule__BooleanSymbol__Group__0__Impl
2450 rule__BooleanSymbol__Group__1
2451;
2452finally {
2453 restoreStackSize(stackSize);
2454}
2455
2456rule__BooleanSymbol__Group__0__Impl
2457 @init {
2458 int stackSize = keepStackSize();
2459 }
2460:
2461(
2462 { before(grammarAccess.getBooleanSymbolAccess().getBoolKeyword_0()); }
2463 'bool'
2464 { after(grammarAccess.getBooleanSymbolAccess().getBoolKeyword_0()); }
2465)
2466;
2467finally {
2468 restoreStackSize(stackSize);
2469}
2470
2471rule__BooleanSymbol__Group__1
2472 @init {
2473 int stackSize = keepStackSize();
2474 }
2475:
2476 rule__BooleanSymbol__Group__1__Impl
2477;
2478finally {
2479 restoreStackSize(stackSize);
2480}
2481
2482rule__BooleanSymbol__Group__1__Impl
2483 @init {
2484 int stackSize = keepStackSize();
2485 }
2486:
2487(
2488 { before(grammarAccess.getBooleanSymbolAccess().getBooleanSymbolAction_1()); }
2489 ()
2490 { after(grammarAccess.getBooleanSymbolAccess().getBooleanSymbolAction_1()); }
2491)
2492;
2493finally {
2494 restoreStackSize(stackSize);
2495}
2496
2497
2498rule__IntegerSymbol__Group__0
2499 @init {
2500 int stackSize = keepStackSize();
2501 }
2502:
2503 rule__IntegerSymbol__Group__0__Impl
2504 rule__IntegerSymbol__Group__1
2505;
2506finally {
2507 restoreStackSize(stackSize);
2508}
2509
2510rule__IntegerSymbol__Group__0__Impl
2511 @init {
2512 int stackSize = keepStackSize();
2513 }
2514:
2515(
2516 { before(grammarAccess.getIntegerSymbolAccess().getIntKeyword_0()); }
2517 'int'
2518 { after(grammarAccess.getIntegerSymbolAccess().getIntKeyword_0()); }
2519)
2520;
2521finally {
2522 restoreStackSize(stackSize);
2523}
2524
2525rule__IntegerSymbol__Group__1
2526 @init {
2527 int stackSize = keepStackSize();
2528 }
2529:
2530 rule__IntegerSymbol__Group__1__Impl
2531;
2532finally {
2533 restoreStackSize(stackSize);
2534}
2535
2536rule__IntegerSymbol__Group__1__Impl
2537 @init {
2538 int stackSize = keepStackSize();
2539 }
2540:
2541(
2542 { before(grammarAccess.getIntegerSymbolAccess().getIntegerSymbolAction_1()); }
2543 ()
2544 { after(grammarAccess.getIntegerSymbolAccess().getIntegerSymbolAction_1()); }
2545)
2546;
2547finally {
2548 restoreStackSize(stackSize);
2549}
2550
2551
2552rule__RealSymbol__Group__0
2553 @init {
2554 int stackSize = keepStackSize();
2555 }
2556:
2557 rule__RealSymbol__Group__0__Impl
2558 rule__RealSymbol__Group__1
2559;
2560finally {
2561 restoreStackSize(stackSize);
2562}
2563
2564rule__RealSymbol__Group__0__Impl
2565 @init {
2566 int stackSize = keepStackSize();
2567 }
2568:
2569(
2570 { before(grammarAccess.getRealSymbolAccess().getRealKeyword_0()); }
2571 'real'
2572 { after(grammarAccess.getRealSymbolAccess().getRealKeyword_0()); }
2573)
2574;
2575finally {
2576 restoreStackSize(stackSize);
2577}
2578
2579rule__RealSymbol__Group__1
2580 @init {
2581 int stackSize = keepStackSize();
2582 }
2583:
2584 rule__RealSymbol__Group__1__Impl
2585;
2586finally {
2587 restoreStackSize(stackSize);
2588}
2589
2590rule__RealSymbol__Group__1__Impl
2591 @init {
2592 int stackSize = keepStackSize();
2593 }
2594:
2595(
2596 { before(grammarAccess.getRealSymbolAccess().getRealSymbolAction_1()); }
2597 ()
2598 { after(grammarAccess.getRealSymbolAccess().getRealSymbolAction_1()); }
2599)
2600;
2601finally {
2602 restoreStackSize(stackSize);
2603}
2604
2605
2606rule__StringSymbol__Group__0
2607 @init {
2608 int stackSize = keepStackSize();
2609 }
2610:
2611 rule__StringSymbol__Group__0__Impl
2612 rule__StringSymbol__Group__1
2613;
2614finally {
2615 restoreStackSize(stackSize);
2616}
2617
2618rule__StringSymbol__Group__0__Impl
2619 @init {
2620 int stackSize = keepStackSize();
2621 }
2622:
2623(
2624 { before(grammarAccess.getStringSymbolAccess().getStringKeyword_0()); }
2625 'string'
2626 { after(grammarAccess.getStringSymbolAccess().getStringKeyword_0()); }
2627)
2628;
2629finally {
2630 restoreStackSize(stackSize);
2631}
2632
2633rule__StringSymbol__Group__1
2634 @init {
2635 int stackSize = keepStackSize();
2636 }
2637:
2638 rule__StringSymbol__Group__1__Impl
2639;
2640finally {
2641 restoreStackSize(stackSize);
2642}
2643
2644rule__StringSymbol__Group__1__Impl
2645 @init {
2646 int stackSize = keepStackSize();
2647 }
2648:
2649(
2650 { before(grammarAccess.getStringSymbolAccess().getStringSymbolAction_1()); }
2651 ()
2652 { after(grammarAccess.getStringSymbolAccess().getStringSymbolAction_1()); }
2653)
2654;
2655finally {
2656 restoreStackSize(stackSize);
2657}
2658
2659
2660rule__NamedObject__Group__0
2661 @init {
2662 int stackSize = keepStackSize();
2663 }
2664:
2665 rule__NamedObject__Group__0__Impl
2666 rule__NamedObject__Group__1
2667;
2668finally {
2669 restoreStackSize(stackSize);
2670}
2671
2672rule__NamedObject__Group__0__Impl
2673 @init {
2674 int stackSize = keepStackSize();
2675 }
2676:
2677(
2678 { before(grammarAccess.getNamedObjectAccess().getApostropheKeyword_0()); }
2679 '\''
2680 { after(grammarAccess.getNamedObjectAccess().getApostropheKeyword_0()); }
2681)
2682;
2683finally {
2684 restoreStackSize(stackSize);
2685}
2686
2687rule__NamedObject__Group__1
2688 @init {
2689 int stackSize = keepStackSize();
2690 }
2691:
2692 rule__NamedObject__Group__1__Impl
2693 rule__NamedObject__Group__2
2694;
2695finally {
2696 restoreStackSize(stackSize);
2697}
2698
2699rule__NamedObject__Group__1__Impl
2700 @init {
2701 int stackSize = keepStackSize();
2702 }
2703:
2704(
2705 { before(grammarAccess.getNamedObjectAccess().getNameAssignment_1()); }
2706 (rule__NamedObject__NameAssignment_1)
2707 { after(grammarAccess.getNamedObjectAccess().getNameAssignment_1()); }
2708)
2709;
2710finally {
2711 restoreStackSize(stackSize);
2712}
2713
2714rule__NamedObject__Group__2
2715 @init {
2716 int stackSize = keepStackSize();
2717 }
2718:
2719 rule__NamedObject__Group__2__Impl
2720;
2721finally {
2722 restoreStackSize(stackSize);
2723}
2724
2725rule__NamedObject__Group__2__Impl
2726 @init {
2727 int stackSize = keepStackSize();
2728 }
2729:
2730(
2731 { before(grammarAccess.getNamedObjectAccess().getApostropheKeyword_2()); }
2732 '\''
2733 { after(grammarAccess.getNamedObjectAccess().getApostropheKeyword_2()); }
2734)
2735;
2736finally {
2737 restoreStackSize(stackSize);
2738}
2739
2740
2741rule__PredicateSymbol__Group__0
2742 @init {
2743 int stackSize = keepStackSize();
2744 }
2745:
2746 rule__PredicateSymbol__Group__0__Impl
2747 rule__PredicateSymbol__Group__1
2748;
2749finally {
2750 restoreStackSize(stackSize);
2751}
2752
2753rule__PredicateSymbol__Group__0__Impl
2754 @init {
2755 int stackSize = keepStackSize();
2756 }
2757:
2758(
2759 { before(grammarAccess.getPredicateSymbolAccess().getPredicateKeyword_0()); }
2760 'predicate'
2761 { after(grammarAccess.getPredicateSymbolAccess().getPredicateKeyword_0()); }
2762)
2763;
2764finally {
2765 restoreStackSize(stackSize);
2766}
2767
2768rule__PredicateSymbol__Group__1
2769 @init {
2770 int stackSize = keepStackSize();
2771 }
2772:
2773 rule__PredicateSymbol__Group__1__Impl
2774 rule__PredicateSymbol__Group__2
2775;
2776finally {
2777 restoreStackSize(stackSize);
2778}
2779
2780rule__PredicateSymbol__Group__1__Impl
2781 @init {
2782 int stackSize = keepStackSize();
2783 }
2784:
2785(
2786 { before(grammarAccess.getPredicateSymbolAccess().getSymbolAssignment_1()); }
2787 (rule__PredicateSymbol__SymbolAssignment_1)
2788 { after(grammarAccess.getPredicateSymbolAccess().getSymbolAssignment_1()); }
2789)
2790;
2791finally {
2792 restoreStackSize(stackSize);
2793}
2794
2795rule__PredicateSymbol__Group__2
2796 @init {
2797 int stackSize = keepStackSize();
2798 }
2799:
2800 rule__PredicateSymbol__Group__2__Impl
2801 rule__PredicateSymbol__Group__3
2802;
2803finally {
2804 restoreStackSize(stackSize);
2805}
2806
2807rule__PredicateSymbol__Group__2__Impl
2808 @init {
2809 int stackSize = keepStackSize();
2810 }
2811:
2812(
2813 { before(grammarAccess.getPredicateSymbolAccess().getLeftParenthesisKeyword_2()); }
2814 '('
2815 { after(grammarAccess.getPredicateSymbolAccess().getLeftParenthesisKeyword_2()); }
2816)
2817;
2818finally {
2819 restoreStackSize(stackSize);
2820}
2821
2822rule__PredicateSymbol__Group__3
2823 @init {
2824 int stackSize = keepStackSize();
2825 }
2826:
2827 rule__PredicateSymbol__Group__3__Impl
2828 rule__PredicateSymbol__Group__4
2829;
2830finally {
2831 restoreStackSize(stackSize);
2832}
2833
2834rule__PredicateSymbol__Group__3__Impl
2835 @init {
2836 int stackSize = keepStackSize();
2837 }
2838:
2839(
2840 { before(grammarAccess.getPredicateSymbolAccess().getParametersAssignment_3()); }
2841 (rule__PredicateSymbol__ParametersAssignment_3)*
2842 { after(grammarAccess.getPredicateSymbolAccess().getParametersAssignment_3()); }
2843)
2844;
2845finally {
2846 restoreStackSize(stackSize);
2847}
2848
2849rule__PredicateSymbol__Group__4
2850 @init {
2851 int stackSize = keepStackSize();
2852 }
2853:
2854 rule__PredicateSymbol__Group__4__Impl
2855 rule__PredicateSymbol__Group__5
2856;
2857finally {
2858 restoreStackSize(stackSize);
2859}
2860
2861rule__PredicateSymbol__Group__4__Impl
2862 @init {
2863 int stackSize = keepStackSize();
2864 }
2865:
2866(
2867 { before(grammarAccess.getPredicateSymbolAccess().getRightParenthesisKeyword_4()); }
2868 ')'
2869 { after(grammarAccess.getPredicateSymbolAccess().getRightParenthesisKeyword_4()); }
2870)
2871;
2872finally {
2873 restoreStackSize(stackSize);
2874}
2875
2876rule__PredicateSymbol__Group__5
2877 @init {
2878 int stackSize = keepStackSize();
2879 }
2880:
2881 rule__PredicateSymbol__Group__5__Impl
2882 rule__PredicateSymbol__Group__6
2883;
2884finally {
2885 restoreStackSize(stackSize);
2886}
2887
2888rule__PredicateSymbol__Group__5__Impl
2889 @init {
2890 int stackSize = keepStackSize();
2891 }
2892:
2893(
2894 { before(grammarAccess.getPredicateSymbolAccess().getColonKeyword_5()); }
2895 ':'
2896 { after(grammarAccess.getPredicateSymbolAccess().getColonKeyword_5()); }
2897)
2898;
2899finally {
2900 restoreStackSize(stackSize);
2901}
2902
2903rule__PredicateSymbol__Group__6
2904 @init {
2905 int stackSize = keepStackSize();
2906 }
2907:
2908 rule__PredicateSymbol__Group__6__Impl
2909 rule__PredicateSymbol__Group__7
2910;
2911finally {
2912 restoreStackSize(stackSize);
2913}
2914
2915rule__PredicateSymbol__Group__6__Impl
2916 @init {
2917 int stackSize = keepStackSize();
2918 }
2919:
2920(
2921 { before(grammarAccess.getPredicateSymbolAccess().getAlternatives_6()); }
2922 (rule__PredicateSymbol__Alternatives_6)
2923 { after(grammarAccess.getPredicateSymbolAccess().getAlternatives_6()); }
2924)
2925;
2926finally {
2927 restoreStackSize(stackSize);
2928}
2929
2930rule__PredicateSymbol__Group__7
2931 @init {
2932 int stackSize = keepStackSize();
2933 }
2934:
2935 rule__PredicateSymbol__Group__7__Impl
2936;
2937finally {
2938 restoreStackSize(stackSize);
2939}
2940
2941rule__PredicateSymbol__Group__7__Impl
2942 @init {
2943 int stackSize = keepStackSize();
2944 }
2945:
2946(
2947 { before(grammarAccess.getPredicateSymbolAccess().getFullStopKeyword_7()); }
2948 '.'
2949 { after(grammarAccess.getPredicateSymbolAccess().getFullStopKeyword_7()); }
2950)
2951;
2952finally {
2953 restoreStackSize(stackSize);
2954}
2955
2956
2957rule__PredicateSymbol__Group_6_1__0
2958 @init {
2959 int stackSize = keepStackSize();
2960 }
2961:
2962 rule__PredicateSymbol__Group_6_1__0__Impl
2963 rule__PredicateSymbol__Group_6_1__1
2964;
2965finally {
2966 restoreStackSize(stackSize);
2967}
2968
2969rule__PredicateSymbol__Group_6_1__0__Impl
2970 @init {
2971 int stackSize = keepStackSize();
2972 }
2973:
2974(
2975 { before(grammarAccess.getPredicateSymbolAccess().getBodiesAssignment_6_1_0()); }
2976 (rule__PredicateSymbol__BodiesAssignment_6_1_0)
2977 { after(grammarAccess.getPredicateSymbolAccess().getBodiesAssignment_6_1_0()); }
2978)
2979;
2980finally {
2981 restoreStackSize(stackSize);
2982}
2983
2984rule__PredicateSymbol__Group_6_1__1
2985 @init {
2986 int stackSize = keepStackSize();
2987 }
2988:
2989 rule__PredicateSymbol__Group_6_1__1__Impl
2990;
2991finally {
2992 restoreStackSize(stackSize);
2993}
2994
2995rule__PredicateSymbol__Group_6_1__1__Impl
2996 @init {
2997 int stackSize = keepStackSize();
2998 }
2999:
3000(
3001 { before(grammarAccess.getPredicateSymbolAccess().getGroup_6_1_1()); }
3002 (rule__PredicateSymbol__Group_6_1_1__0)*
3003 { after(grammarAccess.getPredicateSymbolAccess().getGroup_6_1_1()); }
3004)
3005;
3006finally {
3007 restoreStackSize(stackSize);
3008}
3009
3010
3011rule__PredicateSymbol__Group_6_1_1__0
3012 @init {
3013 int stackSize = keepStackSize();
3014 }
3015:
3016 rule__PredicateSymbol__Group_6_1_1__0__Impl
3017 rule__PredicateSymbol__Group_6_1_1__1
3018;
3019finally {
3020 restoreStackSize(stackSize);
3021}
3022
3023rule__PredicateSymbol__Group_6_1_1__0__Impl
3024 @init {
3025 int stackSize = keepStackSize();
3026 }
3027:
3028(
3029 { before(grammarAccess.getPredicateSymbolAccess().getVerticalLineKeyword_6_1_1_0()); }
3030 '|'
3031 { after(grammarAccess.getPredicateSymbolAccess().getVerticalLineKeyword_6_1_1_0()); }
3032)
3033;
3034finally {
3035 restoreStackSize(stackSize);
3036}
3037
3038rule__PredicateSymbol__Group_6_1_1__1
3039 @init {
3040 int stackSize = keepStackSize();
3041 }
3042:
3043 rule__PredicateSymbol__Group_6_1_1__1__Impl
3044;
3045finally {
3046 restoreStackSize(stackSize);
3047}
3048
3049rule__PredicateSymbol__Group_6_1_1__1__Impl
3050 @init {
3051 int stackSize = keepStackSize();
3052 }
3053:
3054(
3055 { before(grammarAccess.getPredicateSymbolAccess().getBodiesAssignment_6_1_1_1()); }
3056 (rule__PredicateSymbol__BodiesAssignment_6_1_1_1)
3057 { after(grammarAccess.getPredicateSymbolAccess().getBodiesAssignment_6_1_1_1()); }
3058)
3059;
3060finally {
3061 restoreStackSize(stackSize);
3062}
3063
3064
3065rule__ErrorPredicate__Group__0
3066 @init {
3067 int stackSize = keepStackSize();
3068 }
3069:
3070 rule__ErrorPredicate__Group__0__Impl
3071 rule__ErrorPredicate__Group__1
3072;
3073finally {
3074 restoreStackSize(stackSize);
3075}
3076
3077rule__ErrorPredicate__Group__0__Impl
3078 @init {
3079 int stackSize = keepStackSize();
3080 }
3081:
3082(
3083 { before(grammarAccess.getErrorPredicateAccess().getErrorPredicateAction_0()); }
3084 ()
3085 { after(grammarAccess.getErrorPredicateAccess().getErrorPredicateAction_0()); }
3086)
3087;
3088finally {
3089 restoreStackSize(stackSize);
3090}
3091
3092rule__ErrorPredicate__Group__1
3093 @init {
3094 int stackSize = keepStackSize();
3095 }
3096:
3097 rule__ErrorPredicate__Group__1__Impl
3098 rule__ErrorPredicate__Group__2
3099;
3100finally {
3101 restoreStackSize(stackSize);
3102}
3103
3104rule__ErrorPredicate__Group__1__Impl
3105 @init {
3106 int stackSize = keepStackSize();
3107 }
3108:
3109(
3110 { before(grammarAccess.getErrorPredicateAccess().getErrorKeyword_1()); }
3111 'error'
3112 { after(grammarAccess.getErrorPredicateAccess().getErrorKeyword_1()); }
3113)
3114;
3115finally {
3116 restoreStackSize(stackSize);
3117}
3118
3119rule__ErrorPredicate__Group__2
3120 @init {
3121 int stackSize = keepStackSize();
3122 }
3123:
3124 rule__ErrorPredicate__Group__2__Impl
3125 rule__ErrorPredicate__Group__3
3126;
3127finally {
3128 restoreStackSize(stackSize);
3129}
3130
3131rule__ErrorPredicate__Group__2__Impl
3132 @init {
3133 int stackSize = keepStackSize();
3134 }
3135:
3136(
3137 { before(grammarAccess.getErrorPredicateAccess().getNameAssignment_2()); }
3138 (rule__ErrorPredicate__NameAssignment_2)?
3139 { after(grammarAccess.getErrorPredicateAccess().getNameAssignment_2()); }
3140)
3141;
3142finally {
3143 restoreStackSize(stackSize);
3144}
3145
3146rule__ErrorPredicate__Group__3
3147 @init {
3148 int stackSize = keepStackSize();
3149 }
3150:
3151 rule__ErrorPredicate__Group__3__Impl
3152 rule__ErrorPredicate__Group__4
3153;
3154finally {
3155 restoreStackSize(stackSize);
3156}
3157
3158rule__ErrorPredicate__Group__3__Impl
3159 @init {
3160 int stackSize = keepStackSize();
3161 }
3162:
3163(
3164 { before(grammarAccess.getErrorPredicateAccess().getGroup_3()); }
3165 (rule__ErrorPredicate__Group_3__0)
3166 { after(grammarAccess.getErrorPredicateAccess().getGroup_3()); }
3167)
3168;
3169finally {
3170 restoreStackSize(stackSize);
3171}
3172
3173rule__ErrorPredicate__Group__4
3174 @init {
3175 int stackSize = keepStackSize();
3176 }
3177:
3178 rule__ErrorPredicate__Group__4__Impl
3179 rule__ErrorPredicate__Group__5
3180;
3181finally {
3182 restoreStackSize(stackSize);
3183}
3184
3185rule__ErrorPredicate__Group__4__Impl
3186 @init {
3187 int stackSize = keepStackSize();
3188 }
3189:
3190(
3191 { before(grammarAccess.getErrorPredicateAccess().getColonKeyword_4()); }
3192 ':'
3193 { after(grammarAccess.getErrorPredicateAccess().getColonKeyword_4()); }
3194)
3195;
3196finally {
3197 restoreStackSize(stackSize);
3198}
3199
3200rule__ErrorPredicate__Group__5
3201 @init {
3202 int stackSize = keepStackSize();
3203 }
3204:
3205 rule__ErrorPredicate__Group__5__Impl
3206 rule__ErrorPredicate__Group__6
3207;
3208finally {
3209 restoreStackSize(stackSize);
3210}
3211
3212rule__ErrorPredicate__Group__5__Impl
3213 @init {
3214 int stackSize = keepStackSize();
3215 }
3216:
3217(
3218 { before(grammarAccess.getErrorPredicateAccess().getAlternatives_5()); }
3219 (rule__ErrorPredicate__Alternatives_5)
3220 { after(grammarAccess.getErrorPredicateAccess().getAlternatives_5()); }
3221)
3222;
3223finally {
3224 restoreStackSize(stackSize);
3225}
3226
3227rule__ErrorPredicate__Group__6
3228 @init {
3229 int stackSize = keepStackSize();
3230 }
3231:
3232 rule__ErrorPredicate__Group__6__Impl
3233;
3234finally {
3235 restoreStackSize(stackSize);
3236}
3237
3238rule__ErrorPredicate__Group__6__Impl
3239 @init {
3240 int stackSize = keepStackSize();
3241 }
3242:
3243(
3244 { before(grammarAccess.getErrorPredicateAccess().getFullStopKeyword_6()); }
3245 '.'
3246 { after(grammarAccess.getErrorPredicateAccess().getFullStopKeyword_6()); }
3247)
3248;
3249finally {
3250 restoreStackSize(stackSize);
3251}
3252
3253
3254rule__ErrorPredicate__Group_3__0
3255 @init {
3256 int stackSize = keepStackSize();
3257 }
3258:
3259 rule__ErrorPredicate__Group_3__0__Impl
3260 rule__ErrorPredicate__Group_3__1
3261;
3262finally {
3263 restoreStackSize(stackSize);
3264}
3265
3266rule__ErrorPredicate__Group_3__0__Impl
3267 @init {
3268 int stackSize = keepStackSize();
3269 }
3270:
3271(
3272 { before(grammarAccess.getErrorPredicateAccess().getLeftParenthesisKeyword_3_0()); }
3273 '('
3274 { after(grammarAccess.getErrorPredicateAccess().getLeftParenthesisKeyword_3_0()); }
3275)
3276;
3277finally {
3278 restoreStackSize(stackSize);
3279}
3280
3281rule__ErrorPredicate__Group_3__1
3282 @init {
3283 int stackSize = keepStackSize();
3284 }
3285:
3286 rule__ErrorPredicate__Group_3__1__Impl
3287 rule__ErrorPredicate__Group_3__2
3288;
3289finally {
3290 restoreStackSize(stackSize);
3291}
3292
3293rule__ErrorPredicate__Group_3__1__Impl
3294 @init {
3295 int stackSize = keepStackSize();
3296 }
3297:
3298(
3299 { before(grammarAccess.getErrorPredicateAccess().getParametersAssignment_3_1()); }
3300 (rule__ErrorPredicate__ParametersAssignment_3_1)*
3301 { after(grammarAccess.getErrorPredicateAccess().getParametersAssignment_3_1()); }
3302)
3303;
3304finally {
3305 restoreStackSize(stackSize);
3306}
3307
3308rule__ErrorPredicate__Group_3__2
3309 @init {
3310 int stackSize = keepStackSize();
3311 }
3312:
3313 rule__ErrorPredicate__Group_3__2__Impl
3314;
3315finally {
3316 restoreStackSize(stackSize);
3317}
3318
3319rule__ErrorPredicate__Group_3__2__Impl
3320 @init {
3321 int stackSize = keepStackSize();
3322 }
3323:
3324(
3325 { before(grammarAccess.getErrorPredicateAccess().getRightParenthesisKeyword_3_2()); }
3326 ')'
3327 { after(grammarAccess.getErrorPredicateAccess().getRightParenthesisKeyword_3_2()); }
3328)
3329;
3330finally {
3331 restoreStackSize(stackSize);
3332}
3333
3334
3335rule__ErrorPredicate__Group_5_1__0
3336 @init {
3337 int stackSize = keepStackSize();
3338 }
3339:
3340 rule__ErrorPredicate__Group_5_1__0__Impl
3341 rule__ErrorPredicate__Group_5_1__1
3342;
3343finally {
3344 restoreStackSize(stackSize);
3345}
3346
3347rule__ErrorPredicate__Group_5_1__0__Impl
3348 @init {
3349 int stackSize = keepStackSize();
3350 }
3351:
3352(
3353 { before(grammarAccess.getErrorPredicateAccess().getBodiesAssignment_5_1_0()); }
3354 (rule__ErrorPredicate__BodiesAssignment_5_1_0)
3355 { after(grammarAccess.getErrorPredicateAccess().getBodiesAssignment_5_1_0()); }
3356)
3357;
3358finally {
3359 restoreStackSize(stackSize);
3360}
3361
3362rule__ErrorPredicate__Group_5_1__1
3363 @init {
3364 int stackSize = keepStackSize();
3365 }
3366:
3367 rule__ErrorPredicate__Group_5_1__1__Impl
3368;
3369finally {
3370 restoreStackSize(stackSize);
3371}
3372
3373rule__ErrorPredicate__Group_5_1__1__Impl
3374 @init {
3375 int stackSize = keepStackSize();
3376 }
3377:
3378(
3379 { before(grammarAccess.getErrorPredicateAccess().getGroup_5_1_1()); }
3380 (rule__ErrorPredicate__Group_5_1_1__0)*
3381 { after(grammarAccess.getErrorPredicateAccess().getGroup_5_1_1()); }
3382)
3383;
3384finally {
3385 restoreStackSize(stackSize);
3386}
3387
3388
3389rule__ErrorPredicate__Group_5_1_1__0
3390 @init {
3391 int stackSize = keepStackSize();
3392 }
3393:
3394 rule__ErrorPredicate__Group_5_1_1__0__Impl
3395 rule__ErrorPredicate__Group_5_1_1__1
3396;
3397finally {
3398 restoreStackSize(stackSize);
3399}
3400
3401rule__ErrorPredicate__Group_5_1_1__0__Impl
3402 @init {
3403 int stackSize = keepStackSize();
3404 }
3405:
3406(
3407 { before(grammarAccess.getErrorPredicateAccess().getVerticalLineKeyword_5_1_1_0()); }
3408 '|'
3409 { after(grammarAccess.getErrorPredicateAccess().getVerticalLineKeyword_5_1_1_0()); }
3410)
3411;
3412finally {
3413 restoreStackSize(stackSize);
3414}
3415
3416rule__ErrorPredicate__Group_5_1_1__1
3417 @init {
3418 int stackSize = keepStackSize();
3419 }
3420:
3421 rule__ErrorPredicate__Group_5_1_1__1__Impl
3422;
3423finally {
3424 restoreStackSize(stackSize);
3425}
3426
3427rule__ErrorPredicate__Group_5_1_1__1__Impl
3428 @init {
3429 int stackSize = keepStackSize();
3430 }
3431:
3432(
3433 { before(grammarAccess.getErrorPredicateAccess().getBodiesAssignment_5_1_1_1()); }
3434 (rule__ErrorPredicate__BodiesAssignment_5_1_1_1)
3435 { after(grammarAccess.getErrorPredicateAccess().getBodiesAssignment_5_1_1_1()); }
3436)
3437;
3438finally {
3439 restoreStackSize(stackSize);
3440}
3441
3442
3443rule__Parameter__Group__0
3444 @init {
3445 int stackSize = keepStackSize();
3446 }
3447:
3448 rule__Parameter__Group__0__Impl
3449 rule__Parameter__Group__1
3450;
3451finally {
3452 restoreStackSize(stackSize);
3453}
3454
3455rule__Parameter__Group__0__Impl
3456 @init {
3457 int stackSize = keepStackSize();
3458 }
3459:
3460(
3461 { before(grammarAccess.getParameterAccess().getVariableAssignment_0()); }
3462 (rule__Parameter__VariableAssignment_0)
3463 { after(grammarAccess.getParameterAccess().getVariableAssignment_0()); }
3464)
3465;
3466finally {
3467 restoreStackSize(stackSize);
3468}
3469
3470rule__Parameter__Group__1
3471 @init {
3472 int stackSize = keepStackSize();
3473 }
3474:
3475 rule__Parameter__Group__1__Impl
3476;
3477finally {
3478 restoreStackSize(stackSize);
3479}
3480
3481rule__Parameter__Group__1__Impl
3482 @init {
3483 int stackSize = keepStackSize();
3484 }
3485:
3486(
3487 { before(grammarAccess.getParameterAccess().getGroup_1()); }
3488 (rule__Parameter__Group_1__0)?
3489 { after(grammarAccess.getParameterAccess().getGroup_1()); }
3490)
3491;
3492finally {
3493 restoreStackSize(stackSize);
3494}
3495
3496
3497rule__Parameter__Group_1__0
3498 @init {
3499 int stackSize = keepStackSize();
3500 }
3501:
3502 rule__Parameter__Group_1__0__Impl
3503 rule__Parameter__Group_1__1
3504;
3505finally {
3506 restoreStackSize(stackSize);
3507}
3508
3509rule__Parameter__Group_1__0__Impl
3510 @init {
3511 int stackSize = keepStackSize();
3512 }
3513:
3514(
3515 { before(grammarAccess.getParameterAccess().getColonKeyword_1_0()); }
3516 ':'
3517 { after(grammarAccess.getParameterAccess().getColonKeyword_1_0()); }
3518)
3519;
3520finally {
3521 restoreStackSize(stackSize);
3522}
3523
3524rule__Parameter__Group_1__1
3525 @init {
3526 int stackSize = keepStackSize();
3527 }
3528:
3529 rule__Parameter__Group_1__1__Impl
3530;
3531finally {
3532 restoreStackSize(stackSize);
3533}
3534
3535rule__Parameter__Group_1__1__Impl
3536 @init {
3537 int stackSize = keepStackSize();
3538 }
3539:
3540(
3541 { before(grammarAccess.getParameterAccess().getTypeAssignment_1_1()); }
3542 (rule__Parameter__TypeAssignment_1_1)
3543 { after(grammarAccess.getParameterAccess().getTypeAssignment_1_1()); }
3544)
3545;
3546finally {
3547 restoreStackSize(stackSize);
3548}
3549
3550
3551rule__PatternBody__Group__0
3552 @init {
3553 int stackSize = keepStackSize();
3554 }
3555:
3556 rule__PatternBody__Group__0__Impl
3557 rule__PatternBody__Group__1
3558;
3559finally {
3560 restoreStackSize(stackSize);
3561}
3562
3563rule__PatternBody__Group__0__Impl
3564 @init {
3565 int stackSize = keepStackSize();
3566 }
3567:
3568(
3569 { before(grammarAccess.getPatternBodyAccess().getPatternBodyAction_0()); }
3570 ()
3571 { after(grammarAccess.getPatternBodyAccess().getPatternBodyAction_0()); }
3572)
3573;
3574finally {
3575 restoreStackSize(stackSize);
3576}
3577
3578rule__PatternBody__Group__1
3579 @init {
3580 int stackSize = keepStackSize();
3581 }
3582:
3583 rule__PatternBody__Group__1__Impl
3584;
3585finally {
3586 restoreStackSize(stackSize);
3587}
3588
3589rule__PatternBody__Group__1__Impl
3590 @init {
3591 int stackSize = keepStackSize();
3592 }
3593:
3594(
3595 { before(grammarAccess.getPatternBodyAccess().getAlternatives_1()); }
3596 (rule__PatternBody__Alternatives_1)
3597 { after(grammarAccess.getPatternBodyAccess().getAlternatives_1()); }
3598)
3599;
3600finally {
3601 restoreStackSize(stackSize);
3602}
3603
3604
3605rule__Polarity__Group_0__0
3606 @init {
3607 int stackSize = keepStackSize();
3608 }
3609:
3610 rule__Polarity__Group_0__0__Impl
3611 rule__Polarity__Group_0__1
3612;
3613finally {
3614 restoreStackSize(stackSize);
3615}
3616
3617rule__Polarity__Group_0__0__Impl
3618 @init {
3619 int stackSize = keepStackSize();
3620 }
3621:
3622(
3623 { before(grammarAccess.getPolarityAccess().getPositiveAction_0_0()); }
3624 ()
3625 { after(grammarAccess.getPolarityAccess().getPositiveAction_0_0()); }
3626)
3627;
3628finally {
3629 restoreStackSize(stackSize);
3630}
3631
3632rule__Polarity__Group_0__1
3633 @init {
3634 int stackSize = keepStackSize();
3635 }
3636:
3637 rule__Polarity__Group_0__1__Impl
3638;
3639finally {
3640 restoreStackSize(stackSize);
3641}
3642
3643rule__Polarity__Group_0__1__Impl
3644 @init {
3645 int stackSize = keepStackSize();
3646 }
3647:
3648(
3649 { before(grammarAccess.getPolarityAccess().getPlusSignKeyword_0_1()); }
3650 '+'
3651 { after(grammarAccess.getPolarityAccess().getPlusSignKeyword_0_1()); }
3652)
3653;
3654finally {
3655 restoreStackSize(stackSize);
3656}
3657
3658
3659rule__Polarity__Group_1__0
3660 @init {
3661 int stackSize = keepStackSize();
3662 }
3663:
3664 rule__Polarity__Group_1__0__Impl
3665 rule__Polarity__Group_1__1
3666;
3667finally {
3668 restoreStackSize(stackSize);
3669}
3670
3671rule__Polarity__Group_1__0__Impl
3672 @init {
3673 int stackSize = keepStackSize();
3674 }
3675:
3676(
3677 { before(grammarAccess.getPolarityAccess().getNegativeAction_1_0()); }
3678 ()
3679 { after(grammarAccess.getPolarityAccess().getNegativeAction_1_0()); }
3680)
3681;
3682finally {
3683 restoreStackSize(stackSize);
3684}
3685
3686rule__Polarity__Group_1__1
3687 @init {
3688 int stackSize = keepStackSize();
3689 }
3690:
3691 rule__Polarity__Group_1__1__Impl
3692;
3693finally {
3694 restoreStackSize(stackSize);
3695}
3696
3697rule__Polarity__Group_1__1__Impl
3698 @init {
3699 int stackSize = keepStackSize();
3700 }
3701:
3702(
3703 { before(grammarAccess.getPolarityAccess().getHyphenMinusKeyword_1_1()); }
3704 '-'
3705 { after(grammarAccess.getPolarityAccess().getHyphenMinusKeyword_1_1()); }
3706)
3707;
3708finally {
3709 restoreStackSize(stackSize);
3710}
3711
3712
3713rule__Constraint__Group__0
3714 @init {
3715 int stackSize = keepStackSize();
3716 }
3717:
3718 rule__Constraint__Group__0__Impl
3719 rule__Constraint__Group__1
3720;
3721finally {
3722 restoreStackSize(stackSize);
3723}
3724
3725rule__Constraint__Group__0__Impl
3726 @init {
3727 int stackSize = keepStackSize();
3728 }
3729:
3730(
3731 { before(grammarAccess.getConstraintAccess().getPolarityAssignment_0()); }
3732 (rule__Constraint__PolarityAssignment_0)?
3733 { after(grammarAccess.getConstraintAccess().getPolarityAssignment_0()); }
3734)
3735;
3736finally {
3737 restoreStackSize(stackSize);
3738}
3739
3740rule__Constraint__Group__1
3741 @init {
3742 int stackSize = keepStackSize();
3743 }
3744:
3745 rule__Constraint__Group__1__Impl
3746 rule__Constraint__Group__2
3747;
3748finally {
3749 restoreStackSize(stackSize);
3750}
3751
3752rule__Constraint__Group__1__Impl
3753 @init {
3754 int stackSize = keepStackSize();
3755 }
3756:
3757(
3758 { before(grammarAccess.getConstraintAccess().getSymbolAssignment_1()); }
3759 (rule__Constraint__SymbolAssignment_1)
3760 { after(grammarAccess.getConstraintAccess().getSymbolAssignment_1()); }
3761)
3762;
3763finally {
3764 restoreStackSize(stackSize);
3765}
3766
3767rule__Constraint__Group__2
3768 @init {
3769 int stackSize = keepStackSize();
3770 }
3771:
3772 rule__Constraint__Group__2__Impl
3773;
3774finally {
3775 restoreStackSize(stackSize);
3776}
3777
3778rule__Constraint__Group__2__Impl
3779 @init {
3780 int stackSize = keepStackSize();
3781 }
3782:
3783(
3784 { before(grammarAccess.getConstraintAccess().getAlternatives_2()); }
3785 (rule__Constraint__Alternatives_2)
3786 { after(grammarAccess.getConstraintAccess().getAlternatives_2()); }
3787)
3788;
3789finally {
3790 restoreStackSize(stackSize);
3791}
3792
3793
3794rule__Constraint__Group_2_0__0
3795 @init {
3796 int stackSize = keepStackSize();
3797 }
3798:
3799 rule__Constraint__Group_2_0__0__Impl
3800 rule__Constraint__Group_2_0__1
3801;
3802finally {
3803 restoreStackSize(stackSize);
3804}
3805
3806rule__Constraint__Group_2_0__0__Impl
3807 @init {
3808 int stackSize = keepStackSize();
3809 }
3810:
3811(
3812 { before(grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_0_0()); }
3813 '('
3814 { after(grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_0_0()); }
3815)
3816;
3817finally {
3818 restoreStackSize(stackSize);
3819}
3820
3821rule__Constraint__Group_2_0__1
3822 @init {
3823 int stackSize = keepStackSize();
3824 }
3825:
3826 rule__Constraint__Group_2_0__1__Impl
3827 rule__Constraint__Group_2_0__2
3828;
3829finally {
3830 restoreStackSize(stackSize);
3831}
3832
3833rule__Constraint__Group_2_0__1__Impl
3834 @init {
3835 int stackSize = keepStackSize();
3836 }
3837:
3838(
3839 { before(grammarAccess.getConstraintAccess().getParamsAssignment_2_0_1()); }
3840 (rule__Constraint__ParamsAssignment_2_0_1)*
3841 { after(grammarAccess.getConstraintAccess().getParamsAssignment_2_0_1()); }
3842)
3843;
3844finally {
3845 restoreStackSize(stackSize);
3846}
3847
3848rule__Constraint__Group_2_0__2
3849 @init {
3850 int stackSize = keepStackSize();
3851 }
3852:
3853 rule__Constraint__Group_2_0__2__Impl
3854;
3855finally {
3856 restoreStackSize(stackSize);
3857}
3858
3859rule__Constraint__Group_2_0__2__Impl
3860 @init {
3861 int stackSize = keepStackSize();
3862 }
3863:
3864(
3865 { before(grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_0_2()); }
3866 ')'
3867 { after(grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_0_2()); }
3868)
3869;
3870finally {
3871 restoreStackSize(stackSize);
3872}
3873
3874
3875rule__Constraint__Group_2_1__0
3876 @init {
3877 int stackSize = keepStackSize();
3878 }
3879:
3880 rule__Constraint__Group_2_1__0__Impl
3881 rule__Constraint__Group_2_1__1
3882;
3883finally {
3884 restoreStackSize(stackSize);
3885}
3886
3887rule__Constraint__Group_2_1__0__Impl
3888 @init {
3889 int stackSize = keepStackSize();
3890 }
3891:
3892(
3893 { before(grammarAccess.getConstraintAccess().getClosureTypeAssignment_2_1_0()); }
3894 (rule__Constraint__ClosureTypeAssignment_2_1_0)
3895 { after(grammarAccess.getConstraintAccess().getClosureTypeAssignment_2_1_0()); }
3896)
3897;
3898finally {
3899 restoreStackSize(stackSize);
3900}
3901
3902rule__Constraint__Group_2_1__1
3903 @init {
3904 int stackSize = keepStackSize();
3905 }
3906:
3907 rule__Constraint__Group_2_1__1__Impl
3908 rule__Constraint__Group_2_1__2
3909;
3910finally {
3911 restoreStackSize(stackSize);
3912}
3913
3914rule__Constraint__Group_2_1__1__Impl
3915 @init {
3916 int stackSize = keepStackSize();
3917 }
3918:
3919(
3920 { before(grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_1_1()); }
3921 '('
3922 { after(grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_1_1()); }
3923)
3924;
3925finally {
3926 restoreStackSize(stackSize);
3927}
3928
3929rule__Constraint__Group_2_1__2
3930 @init {
3931 int stackSize = keepStackSize();
3932 }
3933:
3934 rule__Constraint__Group_2_1__2__Impl
3935 rule__Constraint__Group_2_1__3
3936;
3937finally {
3938 restoreStackSize(stackSize);
3939}
3940
3941rule__Constraint__Group_2_1__2__Impl
3942 @init {
3943 int stackSize = keepStackSize();
3944 }
3945:
3946(
3947 { before(grammarAccess.getConstraintAccess().getParamsAssignment_2_1_2()); }
3948 (rule__Constraint__ParamsAssignment_2_1_2)
3949 { after(grammarAccess.getConstraintAccess().getParamsAssignment_2_1_2()); }
3950)
3951;
3952finally {
3953 restoreStackSize(stackSize);
3954}
3955
3956rule__Constraint__Group_2_1__3
3957 @init {
3958 int stackSize = keepStackSize();
3959 }
3960:
3961 rule__Constraint__Group_2_1__3__Impl
3962 rule__Constraint__Group_2_1__4
3963;
3964finally {
3965 restoreStackSize(stackSize);
3966}
3967
3968rule__Constraint__Group_2_1__3__Impl
3969 @init {
3970 int stackSize = keepStackSize();
3971 }
3972:
3973(
3974 { before(grammarAccess.getConstraintAccess().getParamsAssignment_2_1_3()); }
3975 (rule__Constraint__ParamsAssignment_2_1_3)
3976 { after(grammarAccess.getConstraintAccess().getParamsAssignment_2_1_3()); }
3977)
3978;
3979finally {
3980 restoreStackSize(stackSize);
3981}
3982
3983rule__Constraint__Group_2_1__4
3984 @init {
3985 int stackSize = keepStackSize();
3986 }
3987:
3988 rule__Constraint__Group_2_1__4__Impl
3989;
3990finally {
3991 restoreStackSize(stackSize);
3992}
3993
3994rule__Constraint__Group_2_1__4__Impl
3995 @init {
3996 int stackSize = keepStackSize();
3997 }
3998:
3999(
4000 { before(grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_1_4()); }
4001 ')'
4002 { after(grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_1_4()); }
4003)
4004;
4005finally {
4006 restoreStackSize(stackSize);
4007}
4008
4009
4010rule__ClosureType__Group_0__0
4011 @init {
4012 int stackSize = keepStackSize();
4013 }
4014:
4015 rule__ClosureType__Group_0__0__Impl
4016 rule__ClosureType__Group_0__1
4017;
4018finally {
4019 restoreStackSize(stackSize);
4020}
4021
4022rule__ClosureType__Group_0__0__Impl
4023 @init {
4024 int stackSize = keepStackSize();
4025 }
4026:
4027(
4028 { before(grammarAccess.getClosureTypeAccess().getReflexiveClosureAction_0_0()); }
4029 ()
4030 { after(grammarAccess.getClosureTypeAccess().getReflexiveClosureAction_0_0()); }
4031)
4032;
4033finally {
4034 restoreStackSize(stackSize);
4035}
4036
4037rule__ClosureType__Group_0__1
4038 @init {
4039 int stackSize = keepStackSize();
4040 }
4041:
4042 rule__ClosureType__Group_0__1__Impl
4043;
4044finally {
4045 restoreStackSize(stackSize);
4046}
4047
4048rule__ClosureType__Group_0__1__Impl
4049 @init {
4050 int stackSize = keepStackSize();
4051 }
4052:
4053(
4054 { before(grammarAccess.getClosureTypeAccess().getAsteriskKeyword_0_1()); }
4055 '*'
4056 { after(grammarAccess.getClosureTypeAccess().getAsteriskKeyword_0_1()); }
4057)
4058;
4059finally {
4060 restoreStackSize(stackSize);
4061}
4062
4063
4064rule__ClosureType__Group_1__0
4065 @init {
4066 int stackSize = keepStackSize();
4067 }
4068:
4069 rule__ClosureType__Group_1__0__Impl
4070 rule__ClosureType__Group_1__1
4071;
4072finally {
4073 restoreStackSize(stackSize);
4074}
4075
4076rule__ClosureType__Group_1__0__Impl
4077 @init {
4078 int stackSize = keepStackSize();
4079 }
4080:
4081(
4082 { before(grammarAccess.getClosureTypeAccess().getIrreflexiveClosureAction_1_0()); }
4083 ()
4084 { after(grammarAccess.getClosureTypeAccess().getIrreflexiveClosureAction_1_0()); }
4085)
4086;
4087finally {
4088 restoreStackSize(stackSize);
4089}
4090
4091rule__ClosureType__Group_1__1
4092 @init {
4093 int stackSize = keepStackSize();
4094 }
4095:
4096 rule__ClosureType__Group_1__1__Impl
4097;
4098finally {
4099 restoreStackSize(stackSize);
4100}
4101
4102rule__ClosureType__Group_1__1__Impl
4103 @init {
4104 int stackSize = keepStackSize();
4105 }
4106:
4107(
4108 { before(grammarAccess.getClosureTypeAccess().getPlusSignKeyword_1_1()); }
4109 '+'
4110 { after(grammarAccess.getClosureTypeAccess().getPlusSignKeyword_1_1()); }
4111)
4112;
4113finally {
4114 restoreStackSize(stackSize);
4115}
4116
4117
4118rule__AllInstances__Group__0
4119 @init {
4120 int stackSize = keepStackSize();
4121 }
4122:
4123 rule__AllInstances__Group__0__Impl
4124 rule__AllInstances__Group__1
4125;
4126finally {
4127 restoreStackSize(stackSize);
4128}
4129
4130rule__AllInstances__Group__0__Impl
4131 @init {
4132 int stackSize = keepStackSize();
4133 }
4134:
4135(
4136 { before(grammarAccess.getAllInstancesAccess().getColonKeyword_0()); }
4137 ':'
4138 { after(grammarAccess.getAllInstancesAccess().getColonKeyword_0()); }
4139)
4140;
4141finally {
4142 restoreStackSize(stackSize);
4143}
4144
4145rule__AllInstances__Group__1
4146 @init {
4147 int stackSize = keepStackSize();
4148 }
4149:
4150 rule__AllInstances__Group__1__Impl
4151;
4152finally {
4153 restoreStackSize(stackSize);
4154}
4155
4156rule__AllInstances__Group__1__Impl
4157 @init {
4158 int stackSize = keepStackSize();
4159 }
4160:
4161(
4162 { before(grammarAccess.getAllInstancesAccess().getSymbolAssignment_1()); }
4163 (rule__AllInstances__SymbolAssignment_1)
4164 { after(grammarAccess.getAllInstancesAccess().getSymbolAssignment_1()); }
4165)
4166;
4167finally {
4168 restoreStackSize(stackSize);
4169}
4170
4171
4172rule__AllObjects__Group__0
4173 @init {
4174 int stackSize = keepStackSize();
4175 }
4176:
4177 rule__AllObjects__Group__0__Impl
4178 rule__AllObjects__Group__1
4179;
4180finally {
4181 restoreStackSize(stackSize);
4182}
4183
4184rule__AllObjects__Group__0__Impl
4185 @init {
4186 int stackSize = keepStackSize();
4187 }
4188:
4189(
4190 { before(grammarAccess.getAllObjectsAccess().getAllObjectsAction_0()); }
4191 ()
4192 { after(grammarAccess.getAllObjectsAccess().getAllObjectsAction_0()); }
4193)
4194;
4195finally {
4196 restoreStackSize(stackSize);
4197}
4198
4199rule__AllObjects__Group__1
4200 @init {
4201 int stackSize = keepStackSize();
4202 }
4203:
4204 rule__AllObjects__Group__1__Impl
4205;
4206finally {
4207 restoreStackSize(stackSize);
4208}
4209
4210rule__AllObjects__Group__1__Impl
4211 @init {
4212 int stackSize = keepStackSize();
4213 }
4214:
4215(
4216 { before(grammarAccess.getAllObjectsAccess().getAsteriskKeyword_1()); }
4217 '*'
4218 { after(grammarAccess.getAllObjectsAccess().getAsteriskKeyword_1()); }
4219)
4220;
4221finally {
4222 restoreStackSize(stackSize);
4223}
4224
4225
4226rule__DefaultInterpretation__Group__0
4227 @init {
4228 int stackSize = keepStackSize();
4229 }
4230:
4231 rule__DefaultInterpretation__Group__0__Impl
4232 rule__DefaultInterpretation__Group__1
4233;
4234finally {
4235 restoreStackSize(stackSize);
4236}
4237
4238rule__DefaultInterpretation__Group__0__Impl
4239 @init {
4240 int stackSize = keepStackSize();
4241 }
4242:
4243(
4244 { before(grammarAccess.getDefaultInterpretationAccess().getDefaultKeyword_0()); }
4245 'default'
4246 { after(grammarAccess.getDefaultInterpretationAccess().getDefaultKeyword_0()); }
4247)
4248;
4249finally {
4250 restoreStackSize(stackSize);
4251}
4252
4253rule__DefaultInterpretation__Group__1
4254 @init {
4255 int stackSize = keepStackSize();
4256 }
4257:
4258 rule__DefaultInterpretation__Group__1__Impl
4259;
4260finally {
4261 restoreStackSize(stackSize);
4262}
4263
4264rule__DefaultInterpretation__Group__1__Impl
4265 @init {
4266 int stackSize = keepStackSize();
4267 }
4268:
4269(
4270 { before(grammarAccess.getDefaultInterpretationAccess().getInterpretationAssignment_1()); }
4271 (rule__DefaultInterpretation__InterpretationAssignment_1)
4272 { after(grammarAccess.getDefaultInterpretationAccess().getInterpretationAssignment_1()); }
4273)
4274;
4275finally {
4276 restoreStackSize(stackSize);
4277}
4278
4279
4280rule__ClassInterpretation__Group__0
4281 @init {
4282 int stackSize = keepStackSize();
4283 }
4284:
4285 rule__ClassInterpretation__Group__0__Impl
4286 rule__ClassInterpretation__Group__1
4287;
4288finally {
4289 restoreStackSize(stackSize);
4290}
4291
4292rule__ClassInterpretation__Group__0__Impl
4293 @init {
4294 int stackSize = keepStackSize();
4295 }
4296:
4297(
4298 { before(grammarAccess.getClassInterpretationAccess().getAbstractAssignment_0()); }
4299 (rule__ClassInterpretation__AbstractAssignment_0)
4300 { after(grammarAccess.getClassInterpretationAccess().getAbstractAssignment_0()); }
4301)
4302;
4303finally {
4304 restoreStackSize(stackSize);
4305}
4306
4307rule__ClassInterpretation__Group__1
4308 @init {
4309 int stackSize = keepStackSize();
4310 }
4311:
4312 rule__ClassInterpretation__Group__1__Impl
4313 rule__ClassInterpretation__Group__2
4314;
4315finally {
4316 restoreStackSize(stackSize);
4317}
4318
4319rule__ClassInterpretation__Group__1__Impl
4320 @init {
4321 int stackSize = keepStackSize();
4322 }
4323:
4324(
4325 { before(grammarAccess.getClassInterpretationAccess().getClassKeyword_1()); }
4326 'class'
4327 { after(grammarAccess.getClassInterpretationAccess().getClassKeyword_1()); }
4328)
4329;
4330finally {
4331 restoreStackSize(stackSize);
4332}
4333
4334rule__ClassInterpretation__Group__2
4335 @init {
4336 int stackSize = keepStackSize();
4337 }
4338:
4339 rule__ClassInterpretation__Group__2__Impl
4340 rule__ClassInterpretation__Group__3
4341;
4342finally {
4343 restoreStackSize(stackSize);
4344}
4345
4346rule__ClassInterpretation__Group__2__Impl
4347 @init {
4348 int stackSize = keepStackSize();
4349 }
4350:
4351(
4352 { before(grammarAccess.getClassInterpretationAccess().getSymbolAssignment_2()); }
4353 (rule__ClassInterpretation__SymbolAssignment_2)
4354 { after(grammarAccess.getClassInterpretationAccess().getSymbolAssignment_2()); }
4355)
4356;
4357finally {
4358 restoreStackSize(stackSize);
4359}
4360
4361rule__ClassInterpretation__Group__3
4362 @init {
4363 int stackSize = keepStackSize();
4364 }
4365:
4366 rule__ClassInterpretation__Group__3__Impl
4367 rule__ClassInterpretation__Group__4
4368;
4369finally {
4370 restoreStackSize(stackSize);
4371}
4372
4373rule__ClassInterpretation__Group__3__Impl
4374 @init {
4375 int stackSize = keepStackSize();
4376 }
4377:
4378(
4379 { before(grammarAccess.getClassInterpretationAccess().getGroup_3()); }
4380 (rule__ClassInterpretation__Group_3__0)?
4381 { after(grammarAccess.getClassInterpretationAccess().getGroup_3()); }
4382)
4383;
4384finally {
4385 restoreStackSize(stackSize);
4386}
4387
4388rule__ClassInterpretation__Group__4
4389 @init {
4390 int stackSize = keepStackSize();
4391 }
4392:
4393 rule__ClassInterpretation__Group__4__Impl
4394 rule__ClassInterpretation__Group__5
4395;
4396finally {
4397 restoreStackSize(stackSize);
4398}
4399
4400rule__ClassInterpretation__Group__4__Impl
4401 @init {
4402 int stackSize = keepStackSize();
4403 }
4404:
4405(
4406 { before(grammarAccess.getClassInterpretationAccess().getLeftCurlyBracketKeyword_4()); }
4407 '{'
4408 { after(grammarAccess.getClassInterpretationAccess().getLeftCurlyBracketKeyword_4()); }
4409)
4410;
4411finally {
4412 restoreStackSize(stackSize);
4413}
4414
4415rule__ClassInterpretation__Group__5
4416 @init {
4417 int stackSize = keepStackSize();
4418 }
4419:
4420 rule__ClassInterpretation__Group__5__Impl
4421 rule__ClassInterpretation__Group__6
4422;
4423finally {
4424 restoreStackSize(stackSize);
4425}
4426
4427rule__ClassInterpretation__Group__5__Impl
4428 @init {
4429 int stackSize = keepStackSize();
4430 }
4431:
4432(
4433 { before(grammarAccess.getClassInterpretationAccess().getFieltAssignment_5()); }
4434 (rule__ClassInterpretation__FieltAssignment_5)*
4435 { after(grammarAccess.getClassInterpretationAccess().getFieltAssignment_5()); }
4436)
4437;
4438finally {
4439 restoreStackSize(stackSize);
4440}
4441
4442rule__ClassInterpretation__Group__6
4443 @init {
4444 int stackSize = keepStackSize();
4445 }
4446:
4447 rule__ClassInterpretation__Group__6__Impl
4448;
4449finally {
4450 restoreStackSize(stackSize);
4451}
4452
4453rule__ClassInterpretation__Group__6__Impl
4454 @init {
4455 int stackSize = keepStackSize();
4456 }
4457:
4458(
4459 { before(grammarAccess.getClassInterpretationAccess().getRightCurlyBracketKeyword_6()); }
4460 '}'
4461 { after(grammarAccess.getClassInterpretationAccess().getRightCurlyBracketKeyword_6()); }
4462)
4463;
4464finally {
4465 restoreStackSize(stackSize);
4466}
4467
4468
4469rule__ClassInterpretation__Group_3__0
4470 @init {
4471 int stackSize = keepStackSize();
4472 }
4473:
4474 rule__ClassInterpretation__Group_3__0__Impl
4475 rule__ClassInterpretation__Group_3__1
4476;
4477finally {
4478 restoreStackSize(stackSize);
4479}
4480
4481rule__ClassInterpretation__Group_3__0__Impl
4482 @init {
4483 int stackSize = keepStackSize();
4484 }
4485:
4486(
4487 { before(grammarAccess.getClassInterpretationAccess().getExtendsKeyword_3_0()); }
4488 'extends'
4489 { after(grammarAccess.getClassInterpretationAccess().getExtendsKeyword_3_0()); }
4490)
4491;
4492finally {
4493 restoreStackSize(stackSize);
4494}
4495
4496rule__ClassInterpretation__Group_3__1
4497 @init {
4498 int stackSize = keepStackSize();
4499 }
4500:
4501 rule__ClassInterpretation__Group_3__1__Impl
4502;
4503finally {
4504 restoreStackSize(stackSize);
4505}
4506
4507rule__ClassInterpretation__Group_3__1__Impl
4508 @init {
4509 int stackSize = keepStackSize();
4510 }
4511:
4512(
4513 (
4514 { before(grammarAccess.getClassInterpretationAccess().getSupertypesAssignment_3_1()); }
4515 (rule__ClassInterpretation__SupertypesAssignment_3_1)
4516 { after(grammarAccess.getClassInterpretationAccess().getSupertypesAssignment_3_1()); }
4517 )
4518 (
4519 { before(grammarAccess.getClassInterpretationAccess().getSupertypesAssignment_3_1()); }
4520 (rule__ClassInterpretation__SupertypesAssignment_3_1)*
4521 { after(grammarAccess.getClassInterpretationAccess().getSupertypesAssignment_3_1()); }
4522 )
4523)
4524;
4525finally {
4526 restoreStackSize(stackSize);
4527}
4528
4529
4530rule__EnumInterpretation__Group__0
4531 @init {
4532 int stackSize = keepStackSize();
4533 }
4534:
4535 rule__EnumInterpretation__Group__0__Impl
4536 rule__EnumInterpretation__Group__1
4537;
4538finally {
4539 restoreStackSize(stackSize);
4540}
4541
4542rule__EnumInterpretation__Group__0__Impl
4543 @init {
4544 int stackSize = keepStackSize();
4545 }
4546:
4547(
4548 { before(grammarAccess.getEnumInterpretationAccess().getEnumKeyword_0()); }
4549 'enum'
4550 { after(grammarAccess.getEnumInterpretationAccess().getEnumKeyword_0()); }
4551)
4552;
4553finally {
4554 restoreStackSize(stackSize);
4555}
4556
4557rule__EnumInterpretation__Group__1
4558 @init {
4559 int stackSize = keepStackSize();
4560 }
4561:
4562 rule__EnumInterpretation__Group__1__Impl
4563 rule__EnumInterpretation__Group__2
4564;
4565finally {
4566 restoreStackSize(stackSize);
4567}
4568
4569rule__EnumInterpretation__Group__1__Impl
4570 @init {
4571 int stackSize = keepStackSize();
4572 }
4573:
4574(
4575 { before(grammarAccess.getEnumInterpretationAccess().getSymbolAssignment_1()); }
4576 (rule__EnumInterpretation__SymbolAssignment_1)
4577 { after(grammarAccess.getEnumInterpretationAccess().getSymbolAssignment_1()); }
4578)
4579;
4580finally {
4581 restoreStackSize(stackSize);
4582}
4583
4584rule__EnumInterpretation__Group__2
4585 @init {
4586 int stackSize = keepStackSize();
4587 }
4588:
4589 rule__EnumInterpretation__Group__2__Impl
4590 rule__EnumInterpretation__Group__3
4591;
4592finally {
4593 restoreStackSize(stackSize);
4594}
4595
4596rule__EnumInterpretation__Group__2__Impl
4597 @init {
4598 int stackSize = keepStackSize();
4599 }
4600:
4601(
4602 { before(grammarAccess.getEnumInterpretationAccess().getLeftCurlyBracketKeyword_2()); }
4603 '{'
4604 { after(grammarAccess.getEnumInterpretationAccess().getLeftCurlyBracketKeyword_2()); }
4605)
4606;
4607finally {
4608 restoreStackSize(stackSize);
4609}
4610
4611rule__EnumInterpretation__Group__3
4612 @init {
4613 int stackSize = keepStackSize();
4614 }
4615:
4616 rule__EnumInterpretation__Group__3__Impl
4617 rule__EnumInterpretation__Group__4
4618;
4619finally {
4620 restoreStackSize(stackSize);
4621}
4622
4623rule__EnumInterpretation__Group__3__Impl
4624 @init {
4625 int stackSize = keepStackSize();
4626 }
4627:
4628(
4629 (
4630 { before(grammarAccess.getEnumInterpretationAccess().getObjectsAssignment_3()); }
4631 (rule__EnumInterpretation__ObjectsAssignment_3)
4632 { after(grammarAccess.getEnumInterpretationAccess().getObjectsAssignment_3()); }
4633 )
4634 (
4635 { before(grammarAccess.getEnumInterpretationAccess().getObjectsAssignment_3()); }
4636 (rule__EnumInterpretation__ObjectsAssignment_3)*
4637 { after(grammarAccess.getEnumInterpretationAccess().getObjectsAssignment_3()); }
4638 )
4639)
4640;
4641finally {
4642 restoreStackSize(stackSize);
4643}
4644
4645rule__EnumInterpretation__Group__4
4646 @init {
4647 int stackSize = keepStackSize();
4648 }
4649:
4650 rule__EnumInterpretation__Group__4__Impl
4651;
4652finally {
4653 restoreStackSize(stackSize);
4654}
4655
4656rule__EnumInterpretation__Group__4__Impl
4657 @init {
4658 int stackSize = keepStackSize();
4659 }
4660:
4661(
4662 { before(grammarAccess.getEnumInterpretationAccess().getRightCurlyBracketKeyword_4()); }
4663 '}'
4664 { after(grammarAccess.getEnumInterpretationAccess().getRightCurlyBracketKeyword_4()); }
4665)
4666;
4667finally {
4668 restoreStackSize(stackSize);
4669}
4670
4671
4672rule__FieldRelationInterpretation__Group__0
4673 @init {
4674 int stackSize = keepStackSize();
4675 }
4676:
4677 rule__FieldRelationInterpretation__Group__0__Impl
4678 rule__FieldRelationInterpretation__Group__1
4679;
4680finally {
4681 restoreStackSize(stackSize);
4682}
4683
4684rule__FieldRelationInterpretation__Group__0__Impl
4685 @init {
4686 int stackSize = keepStackSize();
4687 }
4688:
4689(
4690 { before(grammarAccess.getFieldRelationInterpretationAccess().getContainmentAssignment_0()); }
4691 (rule__FieldRelationInterpretation__ContainmentAssignment_0)
4692 { after(grammarAccess.getFieldRelationInterpretationAccess().getContainmentAssignment_0()); }
4693)
4694;
4695finally {
4696 restoreStackSize(stackSize);
4697}
4698
4699rule__FieldRelationInterpretation__Group__1
4700 @init {
4701 int stackSize = keepStackSize();
4702 }
4703:
4704 rule__FieldRelationInterpretation__Group__1__Impl
4705 rule__FieldRelationInterpretation__Group__2
4706;
4707finally {
4708 restoreStackSize(stackSize);
4709}
4710
4711rule__FieldRelationInterpretation__Group__1__Impl
4712 @init {
4713 int stackSize = keepStackSize();
4714 }
4715:
4716(
4717 { before(grammarAccess.getFieldRelationInterpretationAccess().getSymbolAssignment_1()); }
4718 (rule__FieldRelationInterpretation__SymbolAssignment_1)
4719 { after(grammarAccess.getFieldRelationInterpretationAccess().getSymbolAssignment_1()); }
4720)
4721;
4722finally {
4723 restoreStackSize(stackSize);
4724}
4725
4726rule__FieldRelationInterpretation__Group__2
4727 @init {
4728 int stackSize = keepStackSize();
4729 }
4730:
4731 rule__FieldRelationInterpretation__Group__2__Impl
4732 rule__FieldRelationInterpretation__Group__3
4733;
4734finally {
4735 restoreStackSize(stackSize);
4736}
4737
4738rule__FieldRelationInterpretation__Group__2__Impl
4739 @init {
4740 int stackSize = keepStackSize();
4741 }
4742:
4743(
4744 { before(grammarAccess.getFieldRelationInterpretationAccess().getColonKeyword_2()); }
4745 ':'
4746 { after(grammarAccess.getFieldRelationInterpretationAccess().getColonKeyword_2()); }
4747)
4748;
4749finally {
4750 restoreStackSize(stackSize);
4751}
4752
4753rule__FieldRelationInterpretation__Group__3
4754 @init {
4755 int stackSize = keepStackSize();
4756 }
4757:
4758 rule__FieldRelationInterpretation__Group__3__Impl
4759 rule__FieldRelationInterpretation__Group__4
4760;
4761finally {
4762 restoreStackSize(stackSize);
4763}
4764
4765rule__FieldRelationInterpretation__Group__3__Impl
4766 @init {
4767 int stackSize = keepStackSize();
4768 }
4769:
4770(
4771 { before(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityAssignment_3()); }
4772 (rule__FieldRelationInterpretation__MultiplicityAssignment_3)?
4773 { after(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityAssignment_3()); }
4774)
4775;
4776finally {
4777 restoreStackSize(stackSize);
4778}
4779
4780rule__FieldRelationInterpretation__Group__4
4781 @init {
4782 int stackSize = keepStackSize();
4783 }
4784:
4785 rule__FieldRelationInterpretation__Group__4__Impl
4786;
4787finally {
4788 restoreStackSize(stackSize);
4789}
4790
4791rule__FieldRelationInterpretation__Group__4__Impl
4792 @init {
4793 int stackSize = keepStackSize();
4794 }
4795:
4796(
4797 { before(grammarAccess.getFieldRelationInterpretationAccess().getTargetAssignment_4()); }
4798 (rule__FieldRelationInterpretation__TargetAssignment_4)
4799 { after(grammarAccess.getFieldRelationInterpretationAccess().getTargetAssignment_4()); }
4800)
4801;
4802finally {
4803 restoreStackSize(stackSize);
4804}
4805
4806
4807rule__GlobalRelationInterpretation__Group__0
4808 @init {
4809 int stackSize = keepStackSize();
4810 }
4811:
4812 rule__GlobalRelationInterpretation__Group__0__Impl
4813 rule__GlobalRelationInterpretation__Group__1
4814;
4815finally {
4816 restoreStackSize(stackSize);
4817}
4818
4819rule__GlobalRelationInterpretation__Group__0__Impl
4820 @init {
4821 int stackSize = keepStackSize();
4822 }
4823:
4824(
4825 { before(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentAssignment_0()); }
4826 (rule__GlobalRelationInterpretation__ContainmentAssignment_0)
4827 { after(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentAssignment_0()); }
4828)
4829;
4830finally {
4831 restoreStackSize(stackSize);
4832}
4833
4834rule__GlobalRelationInterpretation__Group__1
4835 @init {
4836 int stackSize = keepStackSize();
4837 }
4838:
4839 rule__GlobalRelationInterpretation__Group__1__Impl
4840 rule__GlobalRelationInterpretation__Group__2
4841;
4842finally {
4843 restoreStackSize(stackSize);
4844}
4845
4846rule__GlobalRelationInterpretation__Group__1__Impl
4847 @init {
4848 int stackSize = keepStackSize();
4849 }
4850:
4851(
4852 { before(grammarAccess.getGlobalRelationInterpretationAccess().getRelationKeyword_1()); }
4853 'relation'
4854 { after(grammarAccess.getGlobalRelationInterpretationAccess().getRelationKeyword_1()); }
4855)
4856;
4857finally {
4858 restoreStackSize(stackSize);
4859}
4860
4861rule__GlobalRelationInterpretation__Group__2
4862 @init {
4863 int stackSize = keepStackSize();
4864 }
4865:
4866 rule__GlobalRelationInterpretation__Group__2__Impl
4867 rule__GlobalRelationInterpretation__Group__3
4868;
4869finally {
4870 restoreStackSize(stackSize);
4871}
4872
4873rule__GlobalRelationInterpretation__Group__2__Impl
4874 @init {
4875 int stackSize = keepStackSize();
4876 }
4877:
4878(
4879 { before(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolAssignment_2()); }
4880 (rule__GlobalRelationInterpretation__SymbolAssignment_2)
4881 { after(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolAssignment_2()); }
4882)
4883;
4884finally {
4885 restoreStackSize(stackSize);
4886}
4887
4888rule__GlobalRelationInterpretation__Group__3
4889 @init {
4890 int stackSize = keepStackSize();
4891 }
4892:
4893 rule__GlobalRelationInterpretation__Group__3__Impl
4894 rule__GlobalRelationInterpretation__Group__4
4895;
4896finally {
4897 restoreStackSize(stackSize);
4898}
4899
4900rule__GlobalRelationInterpretation__Group__3__Impl
4901 @init {
4902 int stackSize = keepStackSize();
4903 }
4904:
4905(
4906 { before(grammarAccess.getGlobalRelationInterpretationAccess().getColonKeyword_3()); }
4907 ':'
4908 { after(grammarAccess.getGlobalRelationInterpretationAccess().getColonKeyword_3()); }
4909)
4910;
4911finally {
4912 restoreStackSize(stackSize);
4913}
4914
4915rule__GlobalRelationInterpretation__Group__4
4916 @init {
4917 int stackSize = keepStackSize();
4918 }
4919:
4920 rule__GlobalRelationInterpretation__Group__4__Impl
4921 rule__GlobalRelationInterpretation__Group__5
4922;
4923finally {
4924 restoreStackSize(stackSize);
4925}
4926
4927rule__GlobalRelationInterpretation__Group__4__Impl
4928 @init {
4929 int stackSize = keepStackSize();
4930 }
4931:
4932(
4933 { before(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityAssignment_4()); }
4934 (rule__GlobalRelationInterpretation__SourceMultiplicityAssignment_4)?
4935 { after(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityAssignment_4()); }
4936)
4937;
4938finally {
4939 restoreStackSize(stackSize);
4940}
4941
4942rule__GlobalRelationInterpretation__Group__5
4943 @init {
4944 int stackSize = keepStackSize();
4945 }
4946:
4947 rule__GlobalRelationInterpretation__Group__5__Impl
4948 rule__GlobalRelationInterpretation__Group__6
4949;
4950finally {
4951 restoreStackSize(stackSize);
4952}
4953
4954rule__GlobalRelationInterpretation__Group__5__Impl
4955 @init {
4956 int stackSize = keepStackSize();
4957 }
4958:
4959(
4960 { before(grammarAccess.getGlobalRelationInterpretationAccess().getSourceAssignment_5()); }
4961 (rule__GlobalRelationInterpretation__SourceAssignment_5)
4962 { after(grammarAccess.getGlobalRelationInterpretationAccess().getSourceAssignment_5()); }
4963)
4964;
4965finally {
4966 restoreStackSize(stackSize);
4967}
4968
4969rule__GlobalRelationInterpretation__Group__6
4970 @init {
4971 int stackSize = keepStackSize();
4972 }
4973:
4974 rule__GlobalRelationInterpretation__Group__6__Impl
4975 rule__GlobalRelationInterpretation__Group__7
4976;
4977finally {
4978 restoreStackSize(stackSize);
4979}
4980
4981rule__GlobalRelationInterpretation__Group__6__Impl
4982 @init {
4983 int stackSize = keepStackSize();
4984 }
4985:
4986(
4987 { before(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityAssignment_6()); }
4988 (rule__GlobalRelationInterpretation__TargetMultiplicityAssignment_6)?
4989 { after(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityAssignment_6()); }
4990)
4991;
4992finally {
4993 restoreStackSize(stackSize);
4994}
4995
4996rule__GlobalRelationInterpretation__Group__7
4997 @init {
4998 int stackSize = keepStackSize();
4999 }
5000:
5001 rule__GlobalRelationInterpretation__Group__7__Impl
5002;
5003finally {
5004 restoreStackSize(stackSize);
5005}
5006
5007rule__GlobalRelationInterpretation__Group__7__Impl
5008 @init {
5009 int stackSize = keepStackSize();
5010 }
5011:
5012(
5013 { before(grammarAccess.getGlobalRelationInterpretationAccess().getTargetAssignment_7()); }
5014 (rule__GlobalRelationInterpretation__TargetAssignment_7)
5015 { after(grammarAccess.getGlobalRelationInterpretationAccess().getTargetAssignment_7()); }
5016)
5017;
5018finally {
5019 restoreStackSize(stackSize);
5020}
5021
5022
5023rule__MultiplicityDefinition__Group__0
5024 @init {
5025 int stackSize = keepStackSize();
5026 }
5027:
5028 rule__MultiplicityDefinition__Group__0__Impl
5029 rule__MultiplicityDefinition__Group__1
5030;
5031finally {
5032 restoreStackSize(stackSize);
5033}
5034
5035rule__MultiplicityDefinition__Group__0__Impl
5036 @init {
5037 int stackSize = keepStackSize();
5038 }
5039:
5040(
5041 { before(grammarAccess.getMultiplicityDefinitionAccess().getLowerAssignment_0()); }
5042 (rule__MultiplicityDefinition__LowerAssignment_0)
5043 { after(grammarAccess.getMultiplicityDefinitionAccess().getLowerAssignment_0()); }
5044)
5045;
5046finally {
5047 restoreStackSize(stackSize);
5048}
5049
5050rule__MultiplicityDefinition__Group__1
5051 @init {
5052 int stackSize = keepStackSize();
5053 }
5054:
5055 rule__MultiplicityDefinition__Group__1__Impl
5056 rule__MultiplicityDefinition__Group__2
5057;
5058finally {
5059 restoreStackSize(stackSize);
5060}
5061
5062rule__MultiplicityDefinition__Group__1__Impl
5063 @init {
5064 int stackSize = keepStackSize();
5065 }
5066:
5067(
5068 { before(grammarAccess.getMultiplicityDefinitionAccess().getFullStopFullStopKeyword_1()); }
5069 '..'
5070 { after(grammarAccess.getMultiplicityDefinitionAccess().getFullStopFullStopKeyword_1()); }
5071)
5072;
5073finally {
5074 restoreStackSize(stackSize);
5075}
5076
5077rule__MultiplicityDefinition__Group__2
5078 @init {
5079 int stackSize = keepStackSize();
5080 }
5081:
5082 rule__MultiplicityDefinition__Group__2__Impl
5083;
5084finally {
5085 restoreStackSize(stackSize);
5086}
5087
5088rule__MultiplicityDefinition__Group__2__Impl
5089 @init {
5090 int stackSize = keepStackSize();
5091 }
5092:
5093(
5094 { before(grammarAccess.getMultiplicityDefinitionAccess().getAlternatives_2()); }
5095 (rule__MultiplicityDefinition__Alternatives_2)
5096 { after(grammarAccess.getMultiplicityDefinitionAccess().getAlternatives_2()); }
5097)
5098;
5099finally {
5100 restoreStackSize(stackSize);
5101}
5102
5103
5104rule__Problem__StatementsAssignment
5105 @init {
5106 int stackSize = keepStackSize();
5107 }
5108:
5109 (
5110 { before(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); }
5111 ruleStatement
5112 { after(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); }
5113 )
5114;
5115finally {
5116 restoreStackSize(stackSize);
5117}
5118
5119rule__BasicInterpretation__SymbolAssignment_0
5120 @init {
5121 int stackSize = keepStackSize();
5122 }
5123:
5124 (
5125 { before(grammarAccess.getBasicInterpretationAccess().getSymbolSymbolParserRuleCall_0_0()); }
5126 ruleSymbol
5127 { after(grammarAccess.getBasicInterpretationAccess().getSymbolSymbolParserRuleCall_0_0()); }
5128 )
5129;
5130finally {
5131 restoreStackSize(stackSize);
5132}
5133
5134rule__BasicInterpretation__ObjectsAssignment_2
5135 @init {
5136 int stackSize = keepStackSize();
5137 }
5138:
5139 (
5140 { before(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_2_0()); }
5141 ruleComplexObject
5142 { after(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_2_0()); }
5143 )
5144;
5145finally {
5146 restoreStackSize(stackSize);
5147}
5148
5149rule__BasicInterpretation__ValueAssignment_5
5150 @init {
5151 int stackSize = keepStackSize();
5152 }
5153:
5154 (
5155 { before(grammarAccess.getBasicInterpretationAccess().getValueTruthValueParserRuleCall_5_0()); }
5156 ruleTruthValue
5157 { after(grammarAccess.getBasicInterpretationAccess().getValueTruthValueParserRuleCall_5_0()); }
5158 )
5159;
5160finally {
5161 restoreStackSize(stackSize);
5162}
5163
5164rule__ModelSymbol__NameAssignment
5165 @init {
5166 int stackSize = keepStackSize();
5167 }
5168:
5169 (
5170 { before(grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0()); }
5171 RULE_ID
5172 { after(grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0()); }
5173 )
5174;
5175finally {
5176 restoreStackSize(stackSize);
5177}
5178
5179rule__NamedObject__NameAssignment_1
5180 @init {
5181 int stackSize = keepStackSize();
5182 }
5183:
5184 (
5185 { before(grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0()); }
5186 RULE_ID
5187 { after(grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0()); }
5188 )
5189;
5190finally {
5191 restoreStackSize(stackSize);
5192}
5193
5194rule__UnnamedObject__NameAssignment
5195 @init {
5196 int stackSize = keepStackSize();
5197 }
5198:
5199 (
5200 { before(grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0()); }
5201 RULE_ID
5202 { after(grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0()); }
5203 )
5204;
5205finally {
5206 restoreStackSize(stackSize);
5207}
5208
5209rule__BooleanObject__ValueAssignment
5210 @init {
5211 int stackSize = keepStackSize();
5212 }
5213:
5214 (
5215 { before(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0()); }
5216 ruleBooleanValue
5217 { after(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0()); }
5218 )
5219;
5220finally {
5221 restoreStackSize(stackSize);
5222}
5223
5224rule__IntObject__ValueAssignment
5225 @init {
5226 int stackSize = keepStackSize();
5227 }
5228:
5229 (
5230 { before(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0()); }
5231 ruleINTLiteral
5232 { after(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0()); }
5233 )
5234;
5235finally {
5236 restoreStackSize(stackSize);
5237}
5238
5239rule__RealObject__ValueAssignment
5240 @init {
5241 int stackSize = keepStackSize();
5242 }
5243:
5244 (
5245 { before(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0()); }
5246 ruleREALLiteral
5247 { after(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0()); }
5248 )
5249;
5250finally {
5251 restoreStackSize(stackSize);
5252}
5253
5254rule__StringObject__ValueAssignment
5255 @init {
5256 int stackSize = keepStackSize();
5257 }
5258:
5259 (
5260 { before(grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0()); }
5261 RULE_STRING
5262 { after(grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0()); }
5263 )
5264;
5265finally {
5266 restoreStackSize(stackSize);
5267}
5268
5269rule__PredicateSymbol__SymbolAssignment_1
5270 @init {
5271 int stackSize = keepStackSize();
5272 }
5273:
5274 (
5275 { before(grammarAccess.getPredicateSymbolAccess().getSymbolModelSymbolParserRuleCall_1_0()); }
5276 ruleModelSymbol
5277 { after(grammarAccess.getPredicateSymbolAccess().getSymbolModelSymbolParserRuleCall_1_0()); }
5278 )
5279;
5280finally {
5281 restoreStackSize(stackSize);
5282}
5283
5284rule__PredicateSymbol__ParametersAssignment_3
5285 @init {
5286 int stackSize = keepStackSize();
5287 }
5288:
5289 (
5290 { before(grammarAccess.getPredicateSymbolAccess().getParametersParameterParserRuleCall_3_0()); }
5291 ruleParameter
5292 { after(grammarAccess.getPredicateSymbolAccess().getParametersParameterParserRuleCall_3_0()); }
5293 )
5294;
5295finally {
5296 restoreStackSize(stackSize);
5297}
5298
5299rule__PredicateSymbol__BodiesAssignment_6_1_0
5300 @init {
5301 int stackSize = keepStackSize();
5302 }
5303:
5304 (
5305 { before(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_0_0()); }
5306 rulePatternBody
5307 { after(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_0_0()); }
5308 )
5309;
5310finally {
5311 restoreStackSize(stackSize);
5312}
5313
5314rule__PredicateSymbol__BodiesAssignment_6_1_1_1
5315 @init {
5316 int stackSize = keepStackSize();
5317 }
5318:
5319 (
5320 { before(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_1_1_0()); }
5321 rulePatternBody
5322 { after(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_1_1_0()); }
5323 )
5324;
5325finally {
5326 restoreStackSize(stackSize);
5327}
5328
5329rule__ErrorPredicate__NameAssignment_2
5330 @init {
5331 int stackSize = keepStackSize();
5332 }
5333:
5334 (
5335 { before(grammarAccess.getErrorPredicateAccess().getNameIDTerminalRuleCall_2_0()); }
5336 RULE_ID
5337 { after(grammarAccess.getErrorPredicateAccess().getNameIDTerminalRuleCall_2_0()); }
5338 )
5339;
5340finally {
5341 restoreStackSize(stackSize);
5342}
5343
5344rule__ErrorPredicate__ParametersAssignment_3_1
5345 @init {
5346 int stackSize = keepStackSize();
5347 }
5348:
5349 (
5350 { before(grammarAccess.getErrorPredicateAccess().getParametersParameterParserRuleCall_3_1_0()); }
5351 ruleParameter
5352 { after(grammarAccess.getErrorPredicateAccess().getParametersParameterParserRuleCall_3_1_0()); }
5353 )
5354;
5355finally {
5356 restoreStackSize(stackSize);
5357}
5358
5359rule__ErrorPredicate__BodiesAssignment_5_1_0
5360 @init {
5361 int stackSize = keepStackSize();
5362 }
5363:
5364 (
5365 { before(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_0_0()); }
5366 rulePatternBody
5367 { after(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_0_0()); }
5368 )
5369;
5370finally {
5371 restoreStackSize(stackSize);
5372}
5373
5374rule__ErrorPredicate__BodiesAssignment_5_1_1_1
5375 @init {
5376 int stackSize = keepStackSize();
5377 }
5378:
5379 (
5380 { before(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_1_1_0()); }
5381 rulePatternBody
5382 { after(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_1_1_0()); }
5383 )
5384;
5385finally {
5386 restoreStackSize(stackSize);
5387}
5388
5389rule__Parameter__VariableAssignment_0
5390 @init {
5391 int stackSize = keepStackSize();
5392 }
5393:
5394 (
5395 { before(grammarAccess.getParameterAccess().getVariableVariableParserRuleCall_0_0()); }
5396 ruleVariable
5397 { after(grammarAccess.getParameterAccess().getVariableVariableParserRuleCall_0_0()); }
5398 )
5399;
5400finally {
5401 restoreStackSize(stackSize);
5402}
5403
5404rule__Parameter__TypeAssignment_1_1
5405 @init {
5406 int stackSize = keepStackSize();
5407 }
5408:
5409 (
5410 { before(grammarAccess.getParameterAccess().getTypeSymbolParserRuleCall_1_1_0()); }
5411 ruleSymbol
5412 { after(grammarAccess.getParameterAccess().getTypeSymbolParserRuleCall_1_1_0()); }
5413 )
5414;
5415finally {
5416 restoreStackSize(stackSize);
5417}
5418
5419rule__PatternBody__ConstraintsAssignment_1_1
5420 @init {
5421 int stackSize = keepStackSize();
5422 }
5423:
5424 (
5425 { before(grammarAccess.getPatternBodyAccess().getConstraintsConstraintParserRuleCall_1_1_0()); }
5426 ruleConstraint
5427 { after(grammarAccess.getPatternBodyAccess().getConstraintsConstraintParserRuleCall_1_1_0()); }
5428 )
5429;
5430finally {
5431 restoreStackSize(stackSize);
5432}
5433
5434rule__Constraint__PolarityAssignment_0
5435 @init {
5436 int stackSize = keepStackSize();
5437 }
5438:
5439 (
5440 { before(grammarAccess.getConstraintAccess().getPolarityPolarityParserRuleCall_0_0()); }
5441 rulePolarity
5442 { after(grammarAccess.getConstraintAccess().getPolarityPolarityParserRuleCall_0_0()); }
5443 )
5444;
5445finally {
5446 restoreStackSize(stackSize);
5447}
5448
5449rule__Constraint__SymbolAssignment_1
5450 @init {
5451 int stackSize = keepStackSize();
5452 }
5453:
5454 (
5455 { before(grammarAccess.getConstraintAccess().getSymbolModelSymbolParserRuleCall_1_0()); }
5456 ruleModelSymbol
5457 { after(grammarAccess.getConstraintAccess().getSymbolModelSymbolParserRuleCall_1_0()); }
5458 )
5459;
5460finally {
5461 restoreStackSize(stackSize);
5462}
5463
5464rule__Constraint__ParamsAssignment_2_0_1
5465 @init {
5466 int stackSize = keepStackSize();
5467 }
5468:
5469 (
5470 { before(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_0_1_0()); }
5471 ruleLiteral
5472 { after(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_0_1_0()); }
5473 )
5474;
5475finally {
5476 restoreStackSize(stackSize);
5477}
5478
5479rule__Constraint__ClosureTypeAssignment_2_1_0
5480 @init {
5481 int stackSize = keepStackSize();
5482 }
5483:
5484 (
5485 { before(grammarAccess.getConstraintAccess().getClosureTypeClosureTypeParserRuleCall_2_1_0_0()); }
5486 ruleClosureType
5487 { after(grammarAccess.getConstraintAccess().getClosureTypeClosureTypeParserRuleCall_2_1_0_0()); }
5488 )
5489;
5490finally {
5491 restoreStackSize(stackSize);
5492}
5493
5494rule__Constraint__ParamsAssignment_2_1_2
5495 @init {
5496 int stackSize = keepStackSize();
5497 }
5498:
5499 (
5500 { before(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_2_0()); }
5501 ruleLiteral
5502 { after(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_2_0()); }
5503 )
5504;
5505finally {
5506 restoreStackSize(stackSize);
5507}
5508
5509rule__Constraint__ParamsAssignment_2_1_3
5510 @init {
5511 int stackSize = keepStackSize();
5512 }
5513:
5514 (
5515 { before(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_3_0()); }
5516 ruleLiteral
5517 { after(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_3_0()); }
5518 )
5519;
5520finally {
5521 restoreStackSize(stackSize);
5522}
5523
5524rule__Variable__NameAssignment
5525 @init {
5526 int stackSize = keepStackSize();
5527 }
5528:
5529 (
5530 { before(grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0()); }
5531 RULE_ID
5532 { after(grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0()); }
5533 )
5534;
5535finally {
5536 restoreStackSize(stackSize);
5537}
5538
5539rule__AllInstances__SymbolAssignment_1
5540 @init {
5541 int stackSize = keepStackSize();
5542 }
5543:
5544 (
5545 { before(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0()); }
5546 ruleSymbol
5547 { after(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0()); }
5548 )
5549;
5550finally {
5551 restoreStackSize(stackSize);
5552}
5553
5554rule__DefaultInterpretation__InterpretationAssignment_1
5555 @init {
5556 int stackSize = keepStackSize();
5557 }
5558:
5559 (
5560 { before(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0()); }
5561 ruleBasicInterpretation
5562 { after(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0()); }
5563 )
5564;
5565finally {
5566 restoreStackSize(stackSize);
5567}
5568
5569rule__ClassInterpretation__AbstractAssignment_0
5570 @init {
5571 int stackSize = keepStackSize();
5572 }
5573:
5574 (
5575 { before(grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0()); }
5576 (
5577 { before(grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0()); }
5578 'abstract'
5579 { after(grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0()); }
5580 )
5581 { after(grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0()); }
5582 )
5583;
5584finally {
5585 restoreStackSize(stackSize);
5586}
5587
5588rule__ClassInterpretation__SymbolAssignment_2
5589 @init {
5590 int stackSize = keepStackSize();
5591 }
5592:
5593 (
5594 { before(grammarAccess.getClassInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); }
5595 ruleModelSymbol
5596 { after(grammarAccess.getClassInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); }
5597 )
5598;
5599finally {
5600 restoreStackSize(stackSize);
5601}
5602
5603rule__ClassInterpretation__SupertypesAssignment_3_1
5604 @init {
5605 int stackSize = keepStackSize();
5606 }
5607:
5608 (
5609 { before(grammarAccess.getClassInterpretationAccess().getSupertypesModelSymbolParserRuleCall_3_1_0()); }
5610 ruleModelSymbol
5611 { after(grammarAccess.getClassInterpretationAccess().getSupertypesModelSymbolParserRuleCall_3_1_0()); }
5612 )
5613;
5614finally {
5615 restoreStackSize(stackSize);
5616}
5617
5618rule__ClassInterpretation__FieltAssignment_5
5619 @init {
5620 int stackSize = keepStackSize();
5621 }
5622:
5623 (
5624 { before(grammarAccess.getClassInterpretationAccess().getFieltFieldRelationInterpretationParserRuleCall_5_0()); }
5625 ruleFieldRelationInterpretation
5626 { after(grammarAccess.getClassInterpretationAccess().getFieltFieldRelationInterpretationParserRuleCall_5_0()); }
5627 )
5628;
5629finally {
5630 restoreStackSize(stackSize);
5631}
5632
5633rule__EnumInterpretation__SymbolAssignment_1
5634 @init {
5635 int stackSize = keepStackSize();
5636 }
5637:
5638 (
5639 { before(grammarAccess.getEnumInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); }
5640 ruleModelSymbol
5641 { after(grammarAccess.getEnumInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); }
5642 )
5643;
5644finally {
5645 restoreStackSize(stackSize);
5646}
5647
5648rule__EnumInterpretation__ObjectsAssignment_3
5649 @init {
5650 int stackSize = keepStackSize();
5651 }
5652:
5653 (
5654 { before(grammarAccess.getEnumInterpretationAccess().getObjectsNamedObjectParserRuleCall_3_0()); }
5655 ruleNamedObject
5656 { after(grammarAccess.getEnumInterpretationAccess().getObjectsNamedObjectParserRuleCall_3_0()); }
5657 )
5658;
5659finally {
5660 restoreStackSize(stackSize);
5661}
5662
5663rule__FieldRelationInterpretation__ContainmentAssignment_0
5664 @init {
5665 int stackSize = keepStackSize();
5666 }
5667:
5668 (
5669 { before(grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); }
5670 (
5671 { before(grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); }
5672 'containment'
5673 { after(grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); }
5674 )
5675 { after(grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); }
5676 )
5677;
5678finally {
5679 restoreStackSize(stackSize);
5680}
5681
5682rule__FieldRelationInterpretation__SymbolAssignment_1
5683 @init {
5684 int stackSize = keepStackSize();
5685 }
5686:
5687 (
5688 { before(grammarAccess.getFieldRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); }
5689 ruleModelSymbol
5690 { after(grammarAccess.getFieldRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); }
5691 )
5692;
5693finally {
5694 restoreStackSize(stackSize);
5695}
5696
5697rule__FieldRelationInterpretation__MultiplicityAssignment_3
5698 @init {
5699 int stackSize = keepStackSize();
5700 }
5701:
5702 (
5703 { before(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityMultiplicityDefinitionParserRuleCall_3_0()); }
5704 ruleMultiplicityDefinition
5705 { after(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityMultiplicityDefinitionParserRuleCall_3_0()); }
5706 )
5707;
5708finally {
5709 restoreStackSize(stackSize);
5710}
5711
5712rule__FieldRelationInterpretation__TargetAssignment_4
5713 @init {
5714 int stackSize = keepStackSize();
5715 }
5716:
5717 (
5718 { before(grammarAccess.getFieldRelationInterpretationAccess().getTargetSymbolParserRuleCall_4_0()); }
5719 ruleSymbol
5720 { after(grammarAccess.getFieldRelationInterpretationAccess().getTargetSymbolParserRuleCall_4_0()); }
5721 )
5722;
5723finally {
5724 restoreStackSize(stackSize);
5725}
5726
5727rule__GlobalRelationInterpretation__ContainmentAssignment_0
5728 @init {
5729 int stackSize = keepStackSize();
5730 }
5731:
5732 (
5733 { before(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); }
5734 (
5735 { before(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); }
5736 'containment'
5737 { after(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); }
5738 )
5739 { after(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); }
5740 )
5741;
5742finally {
5743 restoreStackSize(stackSize);
5744}
5745
5746rule__GlobalRelationInterpretation__SymbolAssignment_2
5747 @init {
5748 int stackSize = keepStackSize();
5749 }
5750:
5751 (
5752 { before(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); }
5753 ruleModelSymbol
5754 { after(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); }
5755 )
5756;
5757finally {
5758 restoreStackSize(stackSize);
5759}
5760
5761rule__GlobalRelationInterpretation__SourceMultiplicityAssignment_4
5762 @init {
5763 int stackSize = keepStackSize();
5764 }
5765:
5766 (
5767 { before(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0()); }
5768 ruleMultiplicityDefinition
5769 { after(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0()); }
5770 )
5771;
5772finally {
5773 restoreStackSize(stackSize);
5774}
5775
5776rule__GlobalRelationInterpretation__SourceAssignment_5
5777 @init {
5778 int stackSize = keepStackSize();
5779 }
5780:
5781 (
5782 { before(grammarAccess.getGlobalRelationInterpretationAccess().getSourceSymbolParserRuleCall_5_0()); }
5783 ruleSymbol
5784 { after(grammarAccess.getGlobalRelationInterpretationAccess().getSourceSymbolParserRuleCall_5_0()); }
5785 )
5786;
5787finally {
5788 restoreStackSize(stackSize);
5789}
5790
5791rule__GlobalRelationInterpretation__TargetMultiplicityAssignment_6
5792 @init {
5793 int stackSize = keepStackSize();
5794 }
5795:
5796 (
5797 { before(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0()); }
5798 ruleMultiplicityDefinition
5799 { after(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0()); }
5800 )
5801;
5802finally {
5803 restoreStackSize(stackSize);
5804}
5805
5806rule__GlobalRelationInterpretation__TargetAssignment_7
5807 @init {
5808 int stackSize = keepStackSize();
5809 }
5810:
5811 (
5812 { before(grammarAccess.getGlobalRelationInterpretationAccess().getTargetSymbolParserRuleCall_7_0()); }
5813 ruleSymbol
5814 { after(grammarAccess.getGlobalRelationInterpretationAccess().getTargetSymbolParserRuleCall_7_0()); }
5815 )
5816;
5817finally {
5818 restoreStackSize(stackSize);
5819}
5820
5821rule__MultiplicityDefinition__LowerAssignment_0
5822 @init {
5823 int stackSize = keepStackSize();
5824 }
5825:
5826 (
5827 { before(grammarAccess.getMultiplicityDefinitionAccess().getLowerINTTerminalRuleCall_0_0()); }
5828 RULE_INT
5829 { after(grammarAccess.getMultiplicityDefinitionAccess().getLowerINTTerminalRuleCall_0_0()); }
5830 )
5831;
5832finally {
5833 restoreStackSize(stackSize);
5834}
5835
5836rule__MultiplicityDefinition__UpperAssignment_2_0
5837 @init {
5838 int stackSize = keepStackSize();
5839 }
5840:
5841 (
5842 { before(grammarAccess.getMultiplicityDefinitionAccess().getUpperINTTerminalRuleCall_2_0_0()); }
5843 RULE_INT
5844 { after(grammarAccess.getMultiplicityDefinitionAccess().getUpperINTTerminalRuleCall_2_0_0()); }
5845 )
5846;
5847finally {
5848 restoreStackSize(stackSize);
5849}
5850
5851rule__MultiplicityDefinition__UnlimitedUpperAssignment_2_1
5852 @init {
5853 int stackSize = keepStackSize();
5854 }
5855:
5856 (
5857 { before(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0()); }
5858 (
5859 { before(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0()); }
5860 '*'
5861 { after(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0()); }
5862 )
5863 { after(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0()); }
5864 )
5865;
5866finally {
5867 restoreStackSize(stackSize);
5868}
5869
5870RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"';
5871
5872RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*;
5873
5874RULE_INT : ('0'..'9')+;
5875
5876RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/';
5877
5878RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?;
5879
5880RULE_WS : (' '|'\t'|'\r'|'\n')+;
5881
5882RULE_ANY_OTHER : .;
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.tokens b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.tokens
new file mode 100644
index 00000000..e2d30366
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.tokens
@@ -0,0 +1,67 @@
1'('=17
2')'=18
3'*'=30
4'+'=29
5'-'=13
6'.'=14
7'..'=38
8':'=19
9'\''=26
10'abstract'=39
11'bool'=22
12'class'=32
13'containment'=40
14'default'=31
15'enum'=36
16'equals'=21
17'error'=16
18'exists'=20
19'extends'=35
20'false'=11
21'int'=23
22'predicate'=27
23'real'=24
24'relation'=37
25'string'=25
26'true'=12
27'unknown'=15
28'{'=33
29'|'=28
30'}'=34
31RULE_ANY_OTHER=10
32RULE_ID=5
33RULE_INT=4
34RULE_ML_COMMENT=7
35RULE_SL_COMMENT=8
36RULE_STRING=6
37RULE_WS=9
38T__11=11
39T__12=12
40T__13=13
41T__14=14
42T__15=15
43T__16=16
44T__17=17
45T__18=18
46T__19=19
47T__20=20
48T__21=21
49T__22=22
50T__23=23
51T__24=24
52T__25=25
53T__26=26
54T__27=27
55T__28=28
56T__29=29
57T__30=30
58T__31=31
59T__32=32
60T__33=33
61T__34=34
62T__35=35
63T__36=36
64T__37=37
65T__38=38
66T__39=39
67T__40=40
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageLexer.java b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageLexer.java
new file mode 100644
index 00000000..d5f63d03
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageLexer.java
@@ -0,0 +1,1669 @@
1package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal;
2
3// Hack: Use our own Lexer superclass by means of import.
4// Currently there is no other way to specify the superclass for the lexer.
5import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer;
6
7
8import org.antlr.runtime.*;
9import java.util.Stack;
10import java.util.List;
11import java.util.ArrayList;
12
13@SuppressWarnings("all")
14public class InternalSolverLanguageLexer extends Lexer {
15 public static final int RULE_STRING=6;
16 public static final int RULE_SL_COMMENT=8;
17 public static final int T__19=19;
18 public static final int T__15=15;
19 public static final int T__37=37;
20 public static final int T__16=16;
21 public static final int T__38=38;
22 public static final int T__17=17;
23 public static final int T__39=39;
24 public static final int T__18=18;
25 public static final int T__11=11;
26 public static final int T__33=33;
27 public static final int T__12=12;
28 public static final int T__34=34;
29 public static final int T__13=13;
30 public static final int T__35=35;
31 public static final int T__14=14;
32 public static final int T__36=36;
33 public static final int EOF=-1;
34 public static final int T__30=30;
35 public static final int T__31=31;
36 public static final int T__32=32;
37 public static final int RULE_ID=5;
38 public static final int RULE_WS=9;
39 public static final int RULE_ANY_OTHER=10;
40 public static final int T__26=26;
41 public static final int T__27=27;
42 public static final int T__28=28;
43 public static final int RULE_INT=4;
44 public static final int T__29=29;
45 public static final int T__22=22;
46 public static final int RULE_ML_COMMENT=7;
47 public static final int T__23=23;
48 public static final int T__24=24;
49 public static final int T__25=25;
50 public static final int T__40=40;
51 public static final int T__20=20;
52 public static final int T__21=21;
53
54 // delegates
55 // delegators
56
57 public InternalSolverLanguageLexer() {;}
58 public InternalSolverLanguageLexer(CharStream input) {
59 this(input, new RecognizerSharedState());
60 }
61 public InternalSolverLanguageLexer(CharStream input, RecognizerSharedState state) {
62 super(input,state);
63
64 }
65 public String getGrammarFileName() { return "InternalSolverLanguage.g"; }
66
67 // $ANTLR start "T__11"
68 public final void mT__11() throws RecognitionException {
69 try {
70 int _type = T__11;
71 int _channel = DEFAULT_TOKEN_CHANNEL;
72 // InternalSolverLanguage.g:11:7: ( 'false' )
73 // InternalSolverLanguage.g:11:9: 'false'
74 {
75 match("false");
76
77
78 }
79
80 state.type = _type;
81 state.channel = _channel;
82 }
83 finally {
84 }
85 }
86 // $ANTLR end "T__11"
87
88 // $ANTLR start "T__12"
89 public final void mT__12() throws RecognitionException {
90 try {
91 int _type = T__12;
92 int _channel = DEFAULT_TOKEN_CHANNEL;
93 // InternalSolverLanguage.g:12:7: ( 'true' )
94 // InternalSolverLanguage.g:12:9: 'true'
95 {
96 match("true");
97
98
99 }
100
101 state.type = _type;
102 state.channel = _channel;
103 }
104 finally {
105 }
106 }
107 // $ANTLR end "T__12"
108
109 // $ANTLR start "T__13"
110 public final void mT__13() throws RecognitionException {
111 try {
112 int _type = T__13;
113 int _channel = DEFAULT_TOKEN_CHANNEL;
114 // InternalSolverLanguage.g:13:7: ( '-' )
115 // InternalSolverLanguage.g:13:9: '-'
116 {
117 match('-');
118
119 }
120
121 state.type = _type;
122 state.channel = _channel;
123 }
124 finally {
125 }
126 }
127 // $ANTLR end "T__13"
128
129 // $ANTLR start "T__14"
130 public final void mT__14() throws RecognitionException {
131 try {
132 int _type = T__14;
133 int _channel = DEFAULT_TOKEN_CHANNEL;
134 // InternalSolverLanguage.g:14:7: ( '.' )
135 // InternalSolverLanguage.g:14:9: '.'
136 {
137 match('.');
138
139 }
140
141 state.type = _type;
142 state.channel = _channel;
143 }
144 finally {
145 }
146 }
147 // $ANTLR end "T__14"
148
149 // $ANTLR start "T__15"
150 public final void mT__15() throws RecognitionException {
151 try {
152 int _type = T__15;
153 int _channel = DEFAULT_TOKEN_CHANNEL;
154 // InternalSolverLanguage.g:15:7: ( 'unknown' )
155 // InternalSolverLanguage.g:15:9: 'unknown'
156 {
157 match("unknown");
158
159
160 }
161
162 state.type = _type;
163 state.channel = _channel;
164 }
165 finally {
166 }
167 }
168 // $ANTLR end "T__15"
169
170 // $ANTLR start "T__16"
171 public final void mT__16() throws RecognitionException {
172 try {
173 int _type = T__16;
174 int _channel = DEFAULT_TOKEN_CHANNEL;
175 // InternalSolverLanguage.g:16:7: ( 'error' )
176 // InternalSolverLanguage.g:16:9: 'error'
177 {
178 match("error");
179
180
181 }
182
183 state.type = _type;
184 state.channel = _channel;
185 }
186 finally {
187 }
188 }
189 // $ANTLR end "T__16"
190
191 // $ANTLR start "T__17"
192 public final void mT__17() throws RecognitionException {
193 try {
194 int _type = T__17;
195 int _channel = DEFAULT_TOKEN_CHANNEL;
196 // InternalSolverLanguage.g:17:7: ( '(' )
197 // InternalSolverLanguage.g:17:9: '('
198 {
199 match('(');
200
201 }
202
203 state.type = _type;
204 state.channel = _channel;
205 }
206 finally {
207 }
208 }
209 // $ANTLR end "T__17"
210
211 // $ANTLR start "T__18"
212 public final void mT__18() throws RecognitionException {
213 try {
214 int _type = T__18;
215 int _channel = DEFAULT_TOKEN_CHANNEL;
216 // InternalSolverLanguage.g:18:7: ( ')' )
217 // InternalSolverLanguage.g:18:9: ')'
218 {
219 match(')');
220
221 }
222
223 state.type = _type;
224 state.channel = _channel;
225 }
226 finally {
227 }
228 }
229 // $ANTLR end "T__18"
230
231 // $ANTLR start "T__19"
232 public final void mT__19() throws RecognitionException {
233 try {
234 int _type = T__19;
235 int _channel = DEFAULT_TOKEN_CHANNEL;
236 // InternalSolverLanguage.g:19:7: ( ':' )
237 // InternalSolverLanguage.g:19:9: ':'
238 {
239 match(':');
240
241 }
242
243 state.type = _type;
244 state.channel = _channel;
245 }
246 finally {
247 }
248 }
249 // $ANTLR end "T__19"
250
251 // $ANTLR start "T__20"
252 public final void mT__20() throws RecognitionException {
253 try {
254 int _type = T__20;
255 int _channel = DEFAULT_TOKEN_CHANNEL;
256 // InternalSolverLanguage.g:20:7: ( 'exists' )
257 // InternalSolverLanguage.g:20:9: 'exists'
258 {
259 match("exists");
260
261
262 }
263
264 state.type = _type;
265 state.channel = _channel;
266 }
267 finally {
268 }
269 }
270 // $ANTLR end "T__20"
271
272 // $ANTLR start "T__21"
273 public final void mT__21() throws RecognitionException {
274 try {
275 int _type = T__21;
276 int _channel = DEFAULT_TOKEN_CHANNEL;
277 // InternalSolverLanguage.g:21:7: ( 'equals' )
278 // InternalSolverLanguage.g:21:9: 'equals'
279 {
280 match("equals");
281
282
283 }
284
285 state.type = _type;
286 state.channel = _channel;
287 }
288 finally {
289 }
290 }
291 // $ANTLR end "T__21"
292
293 // $ANTLR start "T__22"
294 public final void mT__22() throws RecognitionException {
295 try {
296 int _type = T__22;
297 int _channel = DEFAULT_TOKEN_CHANNEL;
298 // InternalSolverLanguage.g:22:7: ( 'bool' )
299 // InternalSolverLanguage.g:22:9: 'bool'
300 {
301 match("bool");
302
303
304 }
305
306 state.type = _type;
307 state.channel = _channel;
308 }
309 finally {
310 }
311 }
312 // $ANTLR end "T__22"
313
314 // $ANTLR start "T__23"
315 public final void mT__23() throws RecognitionException {
316 try {
317 int _type = T__23;
318 int _channel = DEFAULT_TOKEN_CHANNEL;
319 // InternalSolverLanguage.g:23:7: ( 'int' )
320 // InternalSolverLanguage.g:23:9: 'int'
321 {
322 match("int");
323
324
325 }
326
327 state.type = _type;
328 state.channel = _channel;
329 }
330 finally {
331 }
332 }
333 // $ANTLR end "T__23"
334
335 // $ANTLR start "T__24"
336 public final void mT__24() throws RecognitionException {
337 try {
338 int _type = T__24;
339 int _channel = DEFAULT_TOKEN_CHANNEL;
340 // InternalSolverLanguage.g:24:7: ( 'real' )
341 // InternalSolverLanguage.g:24:9: 'real'
342 {
343 match("real");
344
345
346 }
347
348 state.type = _type;
349 state.channel = _channel;
350 }
351 finally {
352 }
353 }
354 // $ANTLR end "T__24"
355
356 // $ANTLR start "T__25"
357 public final void mT__25() throws RecognitionException {
358 try {
359 int _type = T__25;
360 int _channel = DEFAULT_TOKEN_CHANNEL;
361 // InternalSolverLanguage.g:25:7: ( 'string' )
362 // InternalSolverLanguage.g:25:9: 'string'
363 {
364 match("string");
365
366
367 }
368
369 state.type = _type;
370 state.channel = _channel;
371 }
372 finally {
373 }
374 }
375 // $ANTLR end "T__25"
376
377 // $ANTLR start "T__26"
378 public final void mT__26() throws RecognitionException {
379 try {
380 int _type = T__26;
381 int _channel = DEFAULT_TOKEN_CHANNEL;
382 // InternalSolverLanguage.g:26:7: ( '\\'' )
383 // InternalSolverLanguage.g:26:9: '\\''
384 {
385 match('\'');
386
387 }
388
389 state.type = _type;
390 state.channel = _channel;
391 }
392 finally {
393 }
394 }
395 // $ANTLR end "T__26"
396
397 // $ANTLR start "T__27"
398 public final void mT__27() throws RecognitionException {
399 try {
400 int _type = T__27;
401 int _channel = DEFAULT_TOKEN_CHANNEL;
402 // InternalSolverLanguage.g:27:7: ( 'predicate' )
403 // InternalSolverLanguage.g:27:9: 'predicate'
404 {
405 match("predicate");
406
407
408 }
409
410 state.type = _type;
411 state.channel = _channel;
412 }
413 finally {
414 }
415 }
416 // $ANTLR end "T__27"
417
418 // $ANTLR start "T__28"
419 public final void mT__28() throws RecognitionException {
420 try {
421 int _type = T__28;
422 int _channel = DEFAULT_TOKEN_CHANNEL;
423 // InternalSolverLanguage.g:28:7: ( '|' )
424 // InternalSolverLanguage.g:28:9: '|'
425 {
426 match('|');
427
428 }
429
430 state.type = _type;
431 state.channel = _channel;
432 }
433 finally {
434 }
435 }
436 // $ANTLR end "T__28"
437
438 // $ANTLR start "T__29"
439 public final void mT__29() throws RecognitionException {
440 try {
441 int _type = T__29;
442 int _channel = DEFAULT_TOKEN_CHANNEL;
443 // InternalSolverLanguage.g:29:7: ( '+' )
444 // InternalSolverLanguage.g:29:9: '+'
445 {
446 match('+');
447
448 }
449
450 state.type = _type;
451 state.channel = _channel;
452 }
453 finally {
454 }
455 }
456 // $ANTLR end "T__29"
457
458 // $ANTLR start "T__30"
459 public final void mT__30() throws RecognitionException {
460 try {
461 int _type = T__30;
462 int _channel = DEFAULT_TOKEN_CHANNEL;
463 // InternalSolverLanguage.g:30:7: ( '*' )
464 // InternalSolverLanguage.g:30:9: '*'
465 {
466 match('*');
467
468 }
469
470 state.type = _type;
471 state.channel = _channel;
472 }
473 finally {
474 }
475 }
476 // $ANTLR end "T__30"
477
478 // $ANTLR start "T__31"
479 public final void mT__31() throws RecognitionException {
480 try {
481 int _type = T__31;
482 int _channel = DEFAULT_TOKEN_CHANNEL;
483 // InternalSolverLanguage.g:31:7: ( 'default' )
484 // InternalSolverLanguage.g:31:9: 'default'
485 {
486 match("default");
487
488
489 }
490
491 state.type = _type;
492 state.channel = _channel;
493 }
494 finally {
495 }
496 }
497 // $ANTLR end "T__31"
498
499 // $ANTLR start "T__32"
500 public final void mT__32() throws RecognitionException {
501 try {
502 int _type = T__32;
503 int _channel = DEFAULT_TOKEN_CHANNEL;
504 // InternalSolverLanguage.g:32:7: ( 'class' )
505 // InternalSolverLanguage.g:32:9: 'class'
506 {
507 match("class");
508
509
510 }
511
512 state.type = _type;
513 state.channel = _channel;
514 }
515 finally {
516 }
517 }
518 // $ANTLR end "T__32"
519
520 // $ANTLR start "T__33"
521 public final void mT__33() throws RecognitionException {
522 try {
523 int _type = T__33;
524 int _channel = DEFAULT_TOKEN_CHANNEL;
525 // InternalSolverLanguage.g:33:7: ( '{' )
526 // InternalSolverLanguage.g:33:9: '{'
527 {
528 match('{');
529
530 }
531
532 state.type = _type;
533 state.channel = _channel;
534 }
535 finally {
536 }
537 }
538 // $ANTLR end "T__33"
539
540 // $ANTLR start "T__34"
541 public final void mT__34() throws RecognitionException {
542 try {
543 int _type = T__34;
544 int _channel = DEFAULT_TOKEN_CHANNEL;
545 // InternalSolverLanguage.g:34:7: ( '}' )
546 // InternalSolverLanguage.g:34:9: '}'
547 {
548 match('}');
549
550 }
551
552 state.type = _type;
553 state.channel = _channel;
554 }
555 finally {
556 }
557 }
558 // $ANTLR end "T__34"
559
560 // $ANTLR start "T__35"
561 public final void mT__35() throws RecognitionException {
562 try {
563 int _type = T__35;
564 int _channel = DEFAULT_TOKEN_CHANNEL;
565 // InternalSolverLanguage.g:35:7: ( 'extends' )
566 // InternalSolverLanguage.g:35:9: 'extends'
567 {
568 match("extends");
569
570
571 }
572
573 state.type = _type;
574 state.channel = _channel;
575 }
576 finally {
577 }
578 }
579 // $ANTLR end "T__35"
580
581 // $ANTLR start "T__36"
582 public final void mT__36() throws RecognitionException {
583 try {
584 int _type = T__36;
585 int _channel = DEFAULT_TOKEN_CHANNEL;
586 // InternalSolverLanguage.g:36:7: ( 'enum' )
587 // InternalSolverLanguage.g:36:9: 'enum'
588 {
589 match("enum");
590
591
592 }
593
594 state.type = _type;
595 state.channel = _channel;
596 }
597 finally {
598 }
599 }
600 // $ANTLR end "T__36"
601
602 // $ANTLR start "T__37"
603 public final void mT__37() throws RecognitionException {
604 try {
605 int _type = T__37;
606 int _channel = DEFAULT_TOKEN_CHANNEL;
607 // InternalSolverLanguage.g:37:7: ( 'relation' )
608 // InternalSolverLanguage.g:37:9: 'relation'
609 {
610 match("relation");
611
612
613 }
614
615 state.type = _type;
616 state.channel = _channel;
617 }
618 finally {
619 }
620 }
621 // $ANTLR end "T__37"
622
623 // $ANTLR start "T__38"
624 public final void mT__38() throws RecognitionException {
625 try {
626 int _type = T__38;
627 int _channel = DEFAULT_TOKEN_CHANNEL;
628 // InternalSolverLanguage.g:38:7: ( '..' )
629 // InternalSolverLanguage.g:38:9: '..'
630 {
631 match("..");
632
633
634 }
635
636 state.type = _type;
637 state.channel = _channel;
638 }
639 finally {
640 }
641 }
642 // $ANTLR end "T__38"
643
644 // $ANTLR start "T__39"
645 public final void mT__39() throws RecognitionException {
646 try {
647 int _type = T__39;
648 int _channel = DEFAULT_TOKEN_CHANNEL;
649 // InternalSolverLanguage.g:39:7: ( 'abstract' )
650 // InternalSolverLanguage.g:39:9: 'abstract'
651 {
652 match("abstract");
653
654
655 }
656
657 state.type = _type;
658 state.channel = _channel;
659 }
660 finally {
661 }
662 }
663 // $ANTLR end "T__39"
664
665 // $ANTLR start "T__40"
666 public final void mT__40() throws RecognitionException {
667 try {
668 int _type = T__40;
669 int _channel = DEFAULT_TOKEN_CHANNEL;
670 // InternalSolverLanguage.g:40:7: ( 'containment' )
671 // InternalSolverLanguage.g:40:9: 'containment'
672 {
673 match("containment");
674
675
676 }
677
678 state.type = _type;
679 state.channel = _channel;
680 }
681 finally {
682 }
683 }
684 // $ANTLR end "T__40"
685
686 // $ANTLR start "RULE_STRING"
687 public final void mRULE_STRING() throws RecognitionException {
688 try {
689 int _type = RULE_STRING;
690 int _channel = DEFAULT_TOKEN_CHANNEL;
691 // InternalSolverLanguage.g:5870:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' )
692 // InternalSolverLanguage.g:5870:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"'
693 {
694 match('\"');
695 // InternalSolverLanguage.g:5870:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
696 loop1:
697 do {
698 int alt1=3;
699 int LA1_0 = input.LA(1);
700
701 if ( (LA1_0=='\\') ) {
702 alt1=1;
703 }
704 else if ( ((LA1_0>='\u0000' && LA1_0<='!')||(LA1_0>='#' && LA1_0<='[')||(LA1_0>=']' && LA1_0<='\uFFFF')) ) {
705 alt1=2;
706 }
707
708
709 switch (alt1) {
710 case 1 :
711 // InternalSolverLanguage.g:5870:20: '\\\\' .
712 {
713 match('\\');
714 matchAny();
715
716 }
717 break;
718 case 2 :
719 // InternalSolverLanguage.g:5870:27: ~ ( ( '\\\\' | '\"' ) )
720 {
721 if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
722 input.consume();
723
724 }
725 else {
726 MismatchedSetException mse = new MismatchedSetException(null,input);
727 recover(mse);
728 throw mse;}
729
730
731 }
732 break;
733
734 default :
735 break loop1;
736 }
737 } while (true);
738
739 match('\"');
740
741 }
742
743 state.type = _type;
744 state.channel = _channel;
745 }
746 finally {
747 }
748 }
749 // $ANTLR end "RULE_STRING"
750
751 // $ANTLR start "RULE_ID"
752 public final void mRULE_ID() throws RecognitionException {
753 try {
754 int _type = RULE_ID;
755 int _channel = DEFAULT_TOKEN_CHANNEL;
756 // InternalSolverLanguage.g:5872:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
757 // InternalSolverLanguage.g:5872:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
758 {
759 // InternalSolverLanguage.g:5872:11: ( '^' )?
760 int alt2=2;
761 int LA2_0 = input.LA(1);
762
763 if ( (LA2_0=='^') ) {
764 alt2=1;
765 }
766 switch (alt2) {
767 case 1 :
768 // InternalSolverLanguage.g:5872:11: '^'
769 {
770 match('^');
771
772 }
773 break;
774
775 }
776
777 if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
778 input.consume();
779
780 }
781 else {
782 MismatchedSetException mse = new MismatchedSetException(null,input);
783 recover(mse);
784 throw mse;}
785
786 // InternalSolverLanguage.g:5872:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
787 loop3:
788 do {
789 int alt3=2;
790 int LA3_0 = input.LA(1);
791
792 if ( ((LA3_0>='0' && LA3_0<='9')||(LA3_0>='A' && LA3_0<='Z')||LA3_0=='_'||(LA3_0>='a' && LA3_0<='z')) ) {
793 alt3=1;
794 }
795
796
797 switch (alt3) {
798 case 1 :
799 // InternalSolverLanguage.g:
800 {
801 if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
802 input.consume();
803
804 }
805 else {
806 MismatchedSetException mse = new MismatchedSetException(null,input);
807 recover(mse);
808 throw mse;}
809
810
811 }
812 break;
813
814 default :
815 break loop3;
816 }
817 } while (true);
818
819
820 }
821
822 state.type = _type;
823 state.channel = _channel;
824 }
825 finally {
826 }
827 }
828 // $ANTLR end "RULE_ID"
829
830 // $ANTLR start "RULE_INT"
831 public final void mRULE_INT() throws RecognitionException {
832 try {
833 int _type = RULE_INT;
834 int _channel = DEFAULT_TOKEN_CHANNEL;
835 // InternalSolverLanguage.g:5874:10: ( ( '0' .. '9' )+ )
836 // InternalSolverLanguage.g:5874:12: ( '0' .. '9' )+
837 {
838 // InternalSolverLanguage.g:5874:12: ( '0' .. '9' )+
839 int cnt4=0;
840 loop4:
841 do {
842 int alt4=2;
843 int LA4_0 = input.LA(1);
844
845 if ( ((LA4_0>='0' && LA4_0<='9')) ) {
846 alt4=1;
847 }
848
849
850 switch (alt4) {
851 case 1 :
852 // InternalSolverLanguage.g:5874:13: '0' .. '9'
853 {
854 matchRange('0','9');
855
856 }
857 break;
858
859 default :
860 if ( cnt4 >= 1 ) break loop4;
861 EarlyExitException eee =
862 new EarlyExitException(4, input);
863 throw eee;
864 }
865 cnt4++;
866 } while (true);
867
868
869 }
870
871 state.type = _type;
872 state.channel = _channel;
873 }
874 finally {
875 }
876 }
877 // $ANTLR end "RULE_INT"
878
879 // $ANTLR start "RULE_ML_COMMENT"
880 public final void mRULE_ML_COMMENT() throws RecognitionException {
881 try {
882 int _type = RULE_ML_COMMENT;
883 int _channel = DEFAULT_TOKEN_CHANNEL;
884 // InternalSolverLanguage.g:5876:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
885 // InternalSolverLanguage.g:5876:19: '/*' ( options {greedy=false; } : . )* '*/'
886 {
887 match("/*");
888
889 // InternalSolverLanguage.g:5876:24: ( options {greedy=false; } : . )*
890 loop5:
891 do {
892 int alt5=2;
893 int LA5_0 = input.LA(1);
894
895 if ( (LA5_0=='*') ) {
896 int LA5_1 = input.LA(2);
897
898 if ( (LA5_1=='/') ) {
899 alt5=2;
900 }
901 else if ( ((LA5_1>='\u0000' && LA5_1<='.')||(LA5_1>='0' && LA5_1<='\uFFFF')) ) {
902 alt5=1;
903 }
904
905
906 }
907 else if ( ((LA5_0>='\u0000' && LA5_0<=')')||(LA5_0>='+' && LA5_0<='\uFFFF')) ) {
908 alt5=1;
909 }
910
911
912 switch (alt5) {
913 case 1 :
914 // InternalSolverLanguage.g:5876:52: .
915 {
916 matchAny();
917
918 }
919 break;
920
921 default :
922 break loop5;
923 }
924 } while (true);
925
926 match("*/");
927
928
929 }
930
931 state.type = _type;
932 state.channel = _channel;
933 }
934 finally {
935 }
936 }
937 // $ANTLR end "RULE_ML_COMMENT"
938
939 // $ANTLR start "RULE_SL_COMMENT"
940 public final void mRULE_SL_COMMENT() throws RecognitionException {
941 try {
942 int _type = RULE_SL_COMMENT;
943 int _channel = DEFAULT_TOKEN_CHANNEL;
944 // InternalSolverLanguage.g:5878:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
945 // InternalSolverLanguage.g:5878:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
946 {
947 match("//");
948
949 // InternalSolverLanguage.g:5878:24: (~ ( ( '\\n' | '\\r' ) ) )*
950 loop6:
951 do {
952 int alt6=2;
953 int LA6_0 = input.LA(1);
954
955 if ( ((LA6_0>='\u0000' && LA6_0<='\t')||(LA6_0>='\u000B' && LA6_0<='\f')||(LA6_0>='\u000E' && LA6_0<='\uFFFF')) ) {
956 alt6=1;
957 }
958
959
960 switch (alt6) {
961 case 1 :
962 // InternalSolverLanguage.g:5878:24: ~ ( ( '\\n' | '\\r' ) )
963 {
964 if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
965 input.consume();
966
967 }
968 else {
969 MismatchedSetException mse = new MismatchedSetException(null,input);
970 recover(mse);
971 throw mse;}
972
973
974 }
975 break;
976
977 default :
978 break loop6;
979 }
980 } while (true);
981
982 // InternalSolverLanguage.g:5878:40: ( ( '\\r' )? '\\n' )?
983 int alt8=2;
984 int LA8_0 = input.LA(1);
985
986 if ( (LA8_0=='\n'||LA8_0=='\r') ) {
987 alt8=1;
988 }
989 switch (alt8) {
990 case 1 :
991 // InternalSolverLanguage.g:5878:41: ( '\\r' )? '\\n'
992 {
993 // InternalSolverLanguage.g:5878:41: ( '\\r' )?
994 int alt7=2;
995 int LA7_0 = input.LA(1);
996
997 if ( (LA7_0=='\r') ) {
998 alt7=1;
999 }
1000 switch (alt7) {
1001 case 1 :
1002 // InternalSolverLanguage.g:5878:41: '\\r'
1003 {
1004 match('\r');
1005
1006 }
1007 break;
1008
1009 }
1010
1011 match('\n');
1012
1013 }
1014 break;
1015
1016 }
1017
1018
1019 }
1020
1021 state.type = _type;
1022 state.channel = _channel;
1023 }
1024 finally {
1025 }
1026 }
1027 // $ANTLR end "RULE_SL_COMMENT"
1028
1029 // $ANTLR start "RULE_WS"
1030 public final void mRULE_WS() throws RecognitionException {
1031 try {
1032 int _type = RULE_WS;
1033 int _channel = DEFAULT_TOKEN_CHANNEL;
1034 // InternalSolverLanguage.g:5880:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
1035 // InternalSolverLanguage.g:5880:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
1036 {
1037 // InternalSolverLanguage.g:5880:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
1038 int cnt9=0;
1039 loop9:
1040 do {
1041 int alt9=2;
1042 int LA9_0 = input.LA(1);
1043
1044 if ( ((LA9_0>='\t' && LA9_0<='\n')||LA9_0=='\r'||LA9_0==' ') ) {
1045 alt9=1;
1046 }
1047
1048
1049 switch (alt9) {
1050 case 1 :
1051 // InternalSolverLanguage.g:
1052 {
1053 if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
1054 input.consume();
1055
1056 }
1057 else {
1058 MismatchedSetException mse = new MismatchedSetException(null,input);
1059 recover(mse);
1060 throw mse;}
1061
1062
1063 }
1064 break;
1065
1066 default :
1067 if ( cnt9 >= 1 ) break loop9;
1068 EarlyExitException eee =
1069 new EarlyExitException(9, input);
1070 throw eee;
1071 }
1072 cnt9++;
1073 } while (true);
1074
1075
1076 }
1077
1078 state.type = _type;
1079 state.channel = _channel;
1080 }
1081 finally {
1082 }
1083 }
1084 // $ANTLR end "RULE_WS"
1085
1086 // $ANTLR start "RULE_ANY_OTHER"
1087 public final void mRULE_ANY_OTHER() throws RecognitionException {
1088 try {
1089 int _type = RULE_ANY_OTHER;
1090 int _channel = DEFAULT_TOKEN_CHANNEL;
1091 // InternalSolverLanguage.g:5882:16: ( . )
1092 // InternalSolverLanguage.g:5882:18: .
1093 {
1094 matchAny();
1095
1096 }
1097
1098 state.type = _type;
1099 state.channel = _channel;
1100 }
1101 finally {
1102 }
1103 }
1104 // $ANTLR end "RULE_ANY_OTHER"
1105
1106 public void mTokens() throws RecognitionException {
1107 // InternalSolverLanguage.g:1:8: ( T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | RULE_STRING | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER )
1108 int alt10=37;
1109 alt10 = dfa10.predict(input);
1110 switch (alt10) {
1111 case 1 :
1112 // InternalSolverLanguage.g:1:10: T__11
1113 {
1114 mT__11();
1115
1116 }
1117 break;
1118 case 2 :
1119 // InternalSolverLanguage.g:1:16: T__12
1120 {
1121 mT__12();
1122
1123 }
1124 break;
1125 case 3 :
1126 // InternalSolverLanguage.g:1:22: T__13
1127 {
1128 mT__13();
1129
1130 }
1131 break;
1132 case 4 :
1133 // InternalSolverLanguage.g:1:28: T__14
1134 {
1135 mT__14();
1136
1137 }
1138 break;
1139 case 5 :
1140 // InternalSolverLanguage.g:1:34: T__15
1141 {
1142 mT__15();
1143
1144 }
1145 break;
1146 case 6 :
1147 // InternalSolverLanguage.g:1:40: T__16
1148 {
1149 mT__16();
1150
1151 }
1152 break;
1153 case 7 :
1154 // InternalSolverLanguage.g:1:46: T__17
1155 {
1156 mT__17();
1157
1158 }
1159 break;
1160 case 8 :
1161 // InternalSolverLanguage.g:1:52: T__18
1162 {
1163 mT__18();
1164
1165 }
1166 break;
1167 case 9 :
1168 // InternalSolverLanguage.g:1:58: T__19
1169 {
1170 mT__19();
1171
1172 }
1173 break;
1174 case 10 :
1175 // InternalSolverLanguage.g:1:64: T__20
1176 {
1177 mT__20();
1178
1179 }
1180 break;
1181 case 11 :
1182 // InternalSolverLanguage.g:1:70: T__21
1183 {
1184 mT__21();
1185
1186 }
1187 break;
1188 case 12 :
1189 // InternalSolverLanguage.g:1:76: T__22
1190 {
1191 mT__22();
1192
1193 }
1194 break;
1195 case 13 :
1196 // InternalSolverLanguage.g:1:82: T__23
1197 {
1198 mT__23();
1199
1200 }
1201 break;
1202 case 14 :
1203 // InternalSolverLanguage.g:1:88: T__24
1204 {
1205 mT__24();
1206
1207 }
1208 break;
1209 case 15 :
1210 // InternalSolverLanguage.g:1:94: T__25
1211 {
1212 mT__25();
1213
1214 }
1215 break;
1216 case 16 :
1217 // InternalSolverLanguage.g:1:100: T__26
1218 {
1219 mT__26();
1220
1221 }
1222 break;
1223 case 17 :
1224 // InternalSolverLanguage.g:1:106: T__27
1225 {
1226 mT__27();
1227
1228 }
1229 break;
1230 case 18 :
1231 // InternalSolverLanguage.g:1:112: T__28
1232 {
1233 mT__28();
1234
1235 }
1236 break;
1237 case 19 :
1238 // InternalSolverLanguage.g:1:118: T__29
1239 {
1240 mT__29();
1241
1242 }
1243 break;
1244 case 20 :
1245 // InternalSolverLanguage.g:1:124: T__30
1246 {
1247 mT__30();
1248
1249 }
1250 break;
1251 case 21 :
1252 // InternalSolverLanguage.g:1:130: T__31
1253 {
1254 mT__31();
1255
1256 }
1257 break;
1258 case 22 :
1259 // InternalSolverLanguage.g:1:136: T__32
1260 {
1261 mT__32();
1262
1263 }
1264 break;
1265 case 23 :
1266 // InternalSolverLanguage.g:1:142: T__33
1267 {
1268 mT__33();
1269
1270 }
1271 break;
1272 case 24 :
1273 // InternalSolverLanguage.g:1:148: T__34
1274 {
1275 mT__34();
1276
1277 }
1278 break;
1279 case 25 :
1280 // InternalSolverLanguage.g:1:154: T__35
1281 {
1282 mT__35();
1283
1284 }
1285 break;
1286 case 26 :
1287 // InternalSolverLanguage.g:1:160: T__36
1288 {
1289 mT__36();
1290
1291 }
1292 break;
1293 case 27 :
1294 // InternalSolverLanguage.g:1:166: T__37
1295 {
1296 mT__37();
1297
1298 }
1299 break;
1300 case 28 :
1301 // InternalSolverLanguage.g:1:172: T__38
1302 {
1303 mT__38();
1304
1305 }
1306 break;
1307 case 29 :
1308 // InternalSolverLanguage.g:1:178: T__39
1309 {
1310 mT__39();
1311
1312 }
1313 break;
1314 case 30 :
1315 // InternalSolverLanguage.g:1:184: T__40
1316 {
1317 mT__40();
1318
1319 }
1320 break;
1321 case 31 :
1322 // InternalSolverLanguage.g:1:190: RULE_STRING
1323 {
1324 mRULE_STRING();
1325
1326 }
1327 break;
1328 case 32 :
1329 // InternalSolverLanguage.g:1:202: RULE_ID
1330 {
1331 mRULE_ID();
1332
1333 }
1334 break;
1335 case 33 :
1336 // InternalSolverLanguage.g:1:210: RULE_INT
1337 {
1338 mRULE_INT();
1339
1340 }
1341 break;
1342 case 34 :
1343 // InternalSolverLanguage.g:1:219: RULE_ML_COMMENT
1344 {
1345 mRULE_ML_COMMENT();
1346
1347 }
1348 break;
1349 case 35 :
1350 // InternalSolverLanguage.g:1:235: RULE_SL_COMMENT
1351 {
1352 mRULE_SL_COMMENT();
1353
1354 }
1355 break;
1356 case 36 :
1357 // InternalSolverLanguage.g:1:251: RULE_WS
1358 {
1359 mRULE_WS();
1360
1361 }
1362 break;
1363 case 37 :
1364 // InternalSolverLanguage.g:1:259: RULE_ANY_OTHER
1365 {
1366 mRULE_ANY_OTHER();
1367
1368 }
1369 break;
1370
1371 }
1372
1373 }
1374
1375
1376 protected DFA10 dfa10 = new DFA10(this);
1377 static final String DFA10_eotS =
1378 "\1\uffff\2\40\1\uffff\1\44\2\40\3\uffff\4\40\1\uffff\1\40\3\uffff\2\40\2\uffff\1\40\2\36\2\uffff\1\36\2\uffff\1\40\1\uffff\1\40\3\uffff\5\40\3\uffff\4\40\1\uffff\1\40\3\uffff\3\40\2\uffff\1\40\5\uffff\11\40\1\134\11\40\1\146\5\40\1\154\1\155\1\uffff\1\156\7\40\1\166\1\uffff\1\40\1\170\3\40\3\uffff\4\40\1\u0080\2\40\1\uffff\1\40\1\uffff\1\u0084\1\40\1\u0086\1\40\1\u0088\2\40\1\uffff\2\40\1\u008d\1\uffff\1\u008e\1\uffff\1\40\1\uffff\1\40\1\u0091\2\40\2\uffff\1\u0094\1\40\1\uffff\1\40\1\u0097\1\uffff\1\u0098\1\40\2\uffff\1\40\1\u009b\1\uffff";
1379 static final String DFA10_eofS =
1380 "\u009c\uffff";
1381 static final String DFA10_minS =
1382 "\1\0\1\141\1\162\1\uffff\1\56\2\156\3\uffff\1\157\1\156\1\145\1\164\1\uffff\1\162\3\uffff\1\145\1\154\2\uffff\1\142\1\0\1\101\2\uffff\1\52\2\uffff\1\154\1\uffff\1\165\3\uffff\1\153\1\162\1\151\2\165\3\uffff\1\157\1\164\1\141\1\162\1\uffff\1\145\3\uffff\1\146\1\141\1\156\2\uffff\1\163\5\uffff\1\163\1\145\1\156\1\157\1\163\1\145\1\141\1\155\1\154\1\60\1\154\1\141\1\151\1\144\1\141\1\163\2\164\1\145\1\60\1\157\1\162\1\164\1\156\1\154\2\60\1\uffff\1\60\1\164\1\156\1\151\1\165\1\163\1\141\1\162\1\60\1\uffff\1\167\1\60\1\163\1\144\1\163\3\uffff\1\151\1\147\1\143\1\154\1\60\1\151\1\141\1\uffff\1\156\1\uffff\1\60\1\163\1\60\1\157\1\60\1\141\1\164\1\uffff\1\156\1\143\1\60\1\uffff\1\60\1\uffff\1\156\1\uffff\1\164\1\60\1\155\1\164\2\uffff\1\60\1\145\1\uffff\1\145\1\60\1\uffff\1\60\1\156\2\uffff\1\164\1\60\1\uffff";
1383 static final String DFA10_maxS =
1384 "\1\uffff\1\141\1\162\1\uffff\1\56\1\156\1\170\3\uffff\1\157\1\156\1\145\1\164\1\uffff\1\162\3\uffff\1\145\1\157\2\uffff\1\142\1\uffff\1\172\2\uffff\1\57\2\uffff\1\154\1\uffff\1\165\3\uffff\1\153\1\162\1\164\2\165\3\uffff\1\157\1\164\1\154\1\162\1\uffff\1\145\3\uffff\1\146\1\141\1\156\2\uffff\1\163\5\uffff\1\163\1\145\1\156\1\157\1\163\1\145\1\141\1\155\1\154\1\172\1\154\1\141\1\151\1\144\1\141\1\163\2\164\1\145\1\172\1\157\1\162\1\164\1\156\1\154\2\172\1\uffff\1\172\1\164\1\156\1\151\1\165\1\163\1\141\1\162\1\172\1\uffff\1\167\1\172\1\163\1\144\1\163\3\uffff\1\151\1\147\1\143\1\154\1\172\1\151\1\141\1\uffff\1\156\1\uffff\1\172\1\163\1\172\1\157\1\172\1\141\1\164\1\uffff\1\156\1\143\1\172\1\uffff\1\172\1\uffff\1\156\1\uffff\1\164\1\172\1\155\1\164\2\uffff\1\172\1\145\1\uffff\1\145\1\172\1\uffff\1\172\1\156\2\uffff\1\164\1\172\1\uffff";
1385 static final String DFA10_acceptS =
1386 "\3\uffff\1\3\3\uffff\1\7\1\10\1\11\4\uffff\1\20\1\uffff\1\22\1\23\1\24\2\uffff\1\27\1\30\3\uffff\1\40\1\41\1\uffff\1\44\1\45\1\uffff\1\40\1\uffff\1\3\1\34\1\4\5\uffff\1\7\1\10\1\11\4\uffff\1\20\1\uffff\1\22\1\23\1\24\3\uffff\1\27\1\30\1\uffff\1\37\1\41\1\42\1\43\1\44\33\uffff\1\15\11\uffff\1\2\5\uffff\1\32\1\14\1\16\7\uffff\1\1\1\uffff\1\6\7\uffff\1\26\3\uffff\1\12\1\uffff\1\13\1\uffff\1\17\4\uffff\1\5\1\31\2\uffff\1\25\2\uffff\1\33\2\uffff\1\35\1\21\2\uffff\1\36";
1387 static final String DFA10_specialS =
1388 "\1\1\27\uffff\1\0\u0083\uffff}>";
1389 static final String[] DFA10_transitionS = {
1390 "\11\36\2\35\2\36\1\35\22\36\1\35\1\36\1\30\4\36\1\16\1\7\1\10\1\22\1\21\1\36\1\3\1\4\1\34\12\33\1\11\6\36\32\32\3\36\1\31\1\32\1\36\1\27\1\12\1\24\1\23\1\6\1\1\2\32\1\13\6\32\1\17\1\32\1\14\1\15\1\2\1\5\5\32\1\25\1\20\1\26\uff82\36",
1391 "\1\37",
1392 "\1\41",
1393 "",
1394 "\1\43",
1395 "\1\45",
1396 "\1\51\2\uffff\1\50\1\46\5\uffff\1\47",
1397 "",
1398 "",
1399 "",
1400 "\1\55",
1401 "\1\56",
1402 "\1\57",
1403 "\1\60",
1404 "",
1405 "\1\62",
1406 "",
1407 "",
1408 "",
1409 "\1\66",
1410 "\1\67\2\uffff\1\70",
1411 "",
1412 "",
1413 "\1\73",
1414 "\0\74",
1415 "\32\40\4\uffff\1\40\1\uffff\32\40",
1416 "",
1417 "",
1418 "\1\76\4\uffff\1\77",
1419 "",
1420 "",
1421 "\1\101",
1422 "",
1423 "\1\102",
1424 "",
1425 "",
1426 "",
1427 "\1\103",
1428 "\1\104",
1429 "\1\105\12\uffff\1\106",
1430 "\1\107",
1431 "\1\110",
1432 "",
1433 "",
1434 "",
1435 "\1\111",
1436 "\1\112",
1437 "\1\113\12\uffff\1\114",
1438 "\1\115",
1439 "",
1440 "\1\116",
1441 "",
1442 "",
1443 "",
1444 "\1\117",
1445 "\1\120",
1446 "\1\121",
1447 "",
1448 "",
1449 "\1\122",
1450 "",
1451 "",
1452 "",
1453 "",
1454 "",
1455 "\1\123",
1456 "\1\124",
1457 "\1\125",
1458 "\1\126",
1459 "\1\127",
1460 "\1\130",
1461 "\1\131",
1462 "\1\132",
1463 "\1\133",
1464 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1465 "\1\135",
1466 "\1\136",
1467 "\1\137",
1468 "\1\140",
1469 "\1\141",
1470 "\1\142",
1471 "\1\143",
1472 "\1\144",
1473 "\1\145",
1474 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1475 "\1\147",
1476 "\1\150",
1477 "\1\151",
1478 "\1\152",
1479 "\1\153",
1480 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1481 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1482 "",
1483 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1484 "\1\157",
1485 "\1\160",
1486 "\1\161",
1487 "\1\162",
1488 "\1\163",
1489 "\1\164",
1490 "\1\165",
1491 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1492 "",
1493 "\1\167",
1494 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1495 "\1\171",
1496 "\1\172",
1497 "\1\173",
1498 "",
1499 "",
1500 "",
1501 "\1\174",
1502 "\1\175",
1503 "\1\176",
1504 "\1\177",
1505 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1506 "\1\u0081",
1507 "\1\u0082",
1508 "",
1509 "\1\u0083",
1510 "",
1511 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1512 "\1\u0085",
1513 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1514 "\1\u0087",
1515 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1516 "\1\u0089",
1517 "\1\u008a",
1518 "",
1519 "\1\u008b",
1520 "\1\u008c",
1521 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1522 "",
1523 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1524 "",
1525 "\1\u008f",
1526 "",
1527 "\1\u0090",
1528 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1529 "\1\u0092",
1530 "\1\u0093",
1531 "",
1532 "",
1533 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1534 "\1\u0095",
1535 "",
1536 "\1\u0096",
1537 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1538 "",
1539 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1540 "\1\u0099",
1541 "",
1542 "",
1543 "\1\u009a",
1544 "\12\40\7\uffff\32\40\4\uffff\1\40\1\uffff\32\40",
1545 ""
1546 };
1547
1548 static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS);
1549 static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS);
1550 static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS);
1551 static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS);
1552 static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS);
1553 static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS);
1554 static final short[][] DFA10_transition;
1555
1556 static {
1557 int numStates = DFA10_transitionS.length;
1558 DFA10_transition = new short[numStates][];
1559 for (int i=0; i<numStates; i++) {
1560 DFA10_transition[i] = DFA.unpackEncodedString(DFA10_transitionS[i]);
1561 }
1562 }
1563
1564 class DFA10 extends DFA {
1565
1566 public DFA10(BaseRecognizer recognizer) {
1567 this.recognizer = recognizer;
1568 this.decisionNumber = 10;
1569 this.eot = DFA10_eot;
1570 this.eof = DFA10_eof;
1571 this.min = DFA10_min;
1572 this.max = DFA10_max;
1573 this.accept = DFA10_accept;
1574 this.special = DFA10_special;
1575 this.transition = DFA10_transition;
1576 }
1577 public String getDescription() {
1578 return "1:1: Tokens : ( T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | RULE_STRING | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER );";
1579 }
1580 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
1581 IntStream input = _input;
1582 int _s = s;
1583 switch ( s ) {
1584 case 0 :
1585 int LA10_24 = input.LA(1);
1586
1587 s = -1;
1588 if ( ((LA10_24>='\u0000' && LA10_24<='\uFFFF')) ) {s = 60;}
1589
1590 else s = 30;
1591
1592 if ( s>=0 ) return s;
1593 break;
1594 case 1 :
1595 int LA10_0 = input.LA(1);
1596
1597 s = -1;
1598 if ( (LA10_0=='f') ) {s = 1;}
1599
1600 else if ( (LA10_0=='t') ) {s = 2;}
1601
1602 else if ( (LA10_0=='-') ) {s = 3;}
1603
1604 else if ( (LA10_0=='.') ) {s = 4;}
1605
1606 else if ( (LA10_0=='u') ) {s = 5;}
1607
1608 else if ( (LA10_0=='e') ) {s = 6;}
1609
1610 else if ( (LA10_0=='(') ) {s = 7;}
1611
1612 else if ( (LA10_0==')') ) {s = 8;}
1613
1614 else if ( (LA10_0==':') ) {s = 9;}
1615
1616 else if ( (LA10_0=='b') ) {s = 10;}
1617
1618 else if ( (LA10_0=='i') ) {s = 11;}
1619
1620 else if ( (LA10_0=='r') ) {s = 12;}
1621
1622 else if ( (LA10_0=='s') ) {s = 13;}
1623
1624 else if ( (LA10_0=='\'') ) {s = 14;}
1625
1626 else if ( (LA10_0=='p') ) {s = 15;}
1627
1628 else if ( (LA10_0=='|') ) {s = 16;}
1629
1630 else if ( (LA10_0=='+') ) {s = 17;}
1631
1632 else if ( (LA10_0=='*') ) {s = 18;}
1633
1634 else if ( (LA10_0=='d') ) {s = 19;}
1635
1636 else if ( (LA10_0=='c') ) {s = 20;}
1637
1638 else if ( (LA10_0=='{') ) {s = 21;}
1639
1640 else if ( (LA10_0=='}') ) {s = 22;}
1641
1642 else if ( (LA10_0=='a') ) {s = 23;}
1643
1644 else if ( (LA10_0=='\"') ) {s = 24;}
1645
1646 else if ( (LA10_0=='^') ) {s = 25;}
1647
1648 else if ( ((LA10_0>='A' && LA10_0<='Z')||LA10_0=='_'||(LA10_0>='g' && LA10_0<='h')||(LA10_0>='j' && LA10_0<='o')||LA10_0=='q'||(LA10_0>='v' && LA10_0<='z')) ) {s = 26;}
1649
1650 else if ( ((LA10_0>='0' && LA10_0<='9')) ) {s = 27;}
1651
1652 else if ( (LA10_0=='/') ) {s = 28;}
1653
1654 else if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) {s = 29;}
1655
1656 else if ( ((LA10_0>='\u0000' && LA10_0<='\b')||(LA10_0>='\u000B' && LA10_0<='\f')||(LA10_0>='\u000E' && LA10_0<='\u001F')||LA10_0=='!'||(LA10_0>='#' && LA10_0<='&')||LA10_0==','||(LA10_0>=';' && LA10_0<='@')||(LA10_0>='[' && LA10_0<=']')||LA10_0=='`'||(LA10_0>='~' && LA10_0<='\uFFFF')) ) {s = 30;}
1657
1658 if ( s>=0 ) return s;
1659 break;
1660 }
1661 NoViableAltException nvae =
1662 new NoViableAltException(getDescription(), 10, _s, input);
1663 error(nvae);
1664 throw nvae;
1665 }
1666 }
1667
1668
1669} \ No newline at end of file
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.java b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.java
new file mode 100644
index 00000000..cc5980b1
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.java
@@ -0,0 +1,17842 @@
1package org.eclipse.viatra.solver.language.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 org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
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 InternalSolverLanguageParser extends AbstractInternalContentAssistParser {
24 public static final String[] tokenNames = new String[] {
25 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_INT", "RULE_ID", "RULE_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'false'", "'true'", "'-'", "'.'", "'unknown'", "'error'", "'('", "')'", "':'", "'exists'", "'equals'", "'bool'", "'int'", "'real'", "'string'", "'\\''", "'predicate'", "'|'", "'+'", "'*'", "'default'", "'class'", "'{'", "'}'", "'extends'", "'enum'", "'relation'", "'..'", "'abstract'", "'containment'"
26 };
27 public static final int RULE_STRING=6;
28 public static final int RULE_SL_COMMENT=8;
29 public static final int T__19=19;
30 public static final int T__15=15;
31 public static final int T__37=37;
32 public static final int T__16=16;
33 public static final int T__38=38;
34 public static final int T__17=17;
35 public static final int T__39=39;
36 public static final int T__18=18;
37 public static final int T__11=11;
38 public static final int T__33=33;
39 public static final int T__12=12;
40 public static final int T__34=34;
41 public static final int T__13=13;
42 public static final int T__35=35;
43 public static final int T__14=14;
44 public static final int T__36=36;
45 public static final int EOF=-1;
46 public static final int T__30=30;
47 public static final int T__31=31;
48 public static final int T__32=32;
49 public static final int RULE_ID=5;
50 public static final int RULE_WS=9;
51 public static final int RULE_ANY_OTHER=10;
52 public static final int T__26=26;
53 public static final int T__27=27;
54 public static final int T__28=28;
55 public static final int RULE_INT=4;
56 public static final int T__29=29;
57 public static final int T__22=22;
58 public static final int RULE_ML_COMMENT=7;
59 public static final int T__23=23;
60 public static final int T__24=24;
61 public static final int T__25=25;
62 public static final int T__40=40;
63 public static final int T__20=20;
64 public static final int T__21=21;
65
66 // delegates
67 // delegators
68
69
70 public InternalSolverLanguageParser(TokenStream input) {
71 this(input, new RecognizerSharedState());
72 }
73 public InternalSolverLanguageParser(TokenStream input, RecognizerSharedState state) {
74 super(input, state);
75
76 }
77
78
79 public String[] getTokenNames() { return InternalSolverLanguageParser.tokenNames; }
80 public String getGrammarFileName() { return "InternalSolverLanguage.g"; }
81
82
83 private SolverLanguageGrammarAccess grammarAccess;
84
85 public void setGrammarAccess(SolverLanguageGrammarAccess grammarAccess) {
86 this.grammarAccess = grammarAccess;
87 }
88
89 @Override
90 protected Grammar getGrammar() {
91 return grammarAccess.getGrammar();
92 }
93
94 @Override
95 protected String getValueForTokenName(String tokenName) {
96 return tokenName;
97 }
98
99
100
101 // $ANTLR start "entryRuleProblem"
102 // InternalSolverLanguage.g:53:1: entryRuleProblem : ruleProblem EOF ;
103 public final void entryRuleProblem() throws RecognitionException {
104 try {
105 // InternalSolverLanguage.g:54:1: ( ruleProblem EOF )
106 // InternalSolverLanguage.g:55:1: ruleProblem EOF
107 {
108 before(grammarAccess.getProblemRule());
109 pushFollow(FOLLOW_1);
110 ruleProblem();
111
112 state._fsp--;
113
114 after(grammarAccess.getProblemRule());
115 match(input,EOF,FOLLOW_2);
116
117 }
118
119 }
120 catch (RecognitionException re) {
121 reportError(re);
122 recover(input,re);
123 }
124 finally {
125 }
126 return ;
127 }
128 // $ANTLR end "entryRuleProblem"
129
130
131 // $ANTLR start "ruleProblem"
132 // InternalSolverLanguage.g:62:1: ruleProblem : ( ( rule__Problem__StatementsAssignment )* ) ;
133 public final void ruleProblem() throws RecognitionException {
134
135 int stackSize = keepStackSize();
136
137 try {
138 // InternalSolverLanguage.g:66:2: ( ( ( rule__Problem__StatementsAssignment )* ) )
139 // InternalSolverLanguage.g:67:2: ( ( rule__Problem__StatementsAssignment )* )
140 {
141 // InternalSolverLanguage.g:67:2: ( ( rule__Problem__StatementsAssignment )* )
142 // InternalSolverLanguage.g:68:3: ( rule__Problem__StatementsAssignment )*
143 {
144 before(grammarAccess.getProblemAccess().getStatementsAssignment());
145 // InternalSolverLanguage.g:69:3: ( rule__Problem__StatementsAssignment )*
146 loop1:
147 do {
148 int alt1=2;
149 int LA1_0 = input.LA(1);
150
151 if ( (LA1_0==RULE_ID||LA1_0==16||(LA1_0>=20 && LA1_0<=25)||LA1_0==27||LA1_0==31||LA1_0==36||(LA1_0>=39 && LA1_0<=40)) ) {
152 alt1=1;
153 }
154
155
156 switch (alt1) {
157 case 1 :
158 // InternalSolverLanguage.g:69:4: rule__Problem__StatementsAssignment
159 {
160 pushFollow(FOLLOW_3);
161 rule__Problem__StatementsAssignment();
162
163 state._fsp--;
164
165
166 }
167 break;
168
169 default :
170 break loop1;
171 }
172 } while (true);
173
174 after(grammarAccess.getProblemAccess().getStatementsAssignment());
175
176 }
177
178
179 }
180
181 }
182 catch (RecognitionException re) {
183 reportError(re);
184 recover(input,re);
185 }
186 finally {
187
188 restoreStackSize(stackSize);
189
190 }
191 return ;
192 }
193 // $ANTLR end "ruleProblem"
194
195
196 // $ANTLR start "entryRuleStatement"
197 // InternalSolverLanguage.g:78:1: entryRuleStatement : ruleStatement EOF ;
198 public final void entryRuleStatement() throws RecognitionException {
199 try {
200 // InternalSolverLanguage.g:79:1: ( ruleStatement EOF )
201 // InternalSolverLanguage.g:80:1: ruleStatement EOF
202 {
203 before(grammarAccess.getStatementRule());
204 pushFollow(FOLLOW_1);
205 ruleStatement();
206
207 state._fsp--;
208
209 after(grammarAccess.getStatementRule());
210 match(input,EOF,FOLLOW_2);
211
212 }
213
214 }
215 catch (RecognitionException re) {
216 reportError(re);
217 recover(input,re);
218 }
219 finally {
220 }
221 return ;
222 }
223 // $ANTLR end "entryRuleStatement"
224
225
226 // $ANTLR start "ruleStatement"
227 // InternalSolverLanguage.g:87:1: ruleStatement : ( ( rule__Statement__Alternatives ) ) ;
228 public final void ruleStatement() throws RecognitionException {
229
230 int stackSize = keepStackSize();
231
232 try {
233 // InternalSolverLanguage.g:91:2: ( ( ( rule__Statement__Alternatives ) ) )
234 // InternalSolverLanguage.g:92:2: ( ( rule__Statement__Alternatives ) )
235 {
236 // InternalSolverLanguage.g:92:2: ( ( rule__Statement__Alternatives ) )
237 // InternalSolverLanguage.g:93:3: ( rule__Statement__Alternatives )
238 {
239 before(grammarAccess.getStatementAccess().getAlternatives());
240 // InternalSolverLanguage.g:94:3: ( rule__Statement__Alternatives )
241 // InternalSolverLanguage.g:94:4: rule__Statement__Alternatives
242 {
243 pushFollow(FOLLOW_2);
244 rule__Statement__Alternatives();
245
246 state._fsp--;
247
248
249 }
250
251 after(grammarAccess.getStatementAccess().getAlternatives());
252
253 }
254
255
256 }
257
258 }
259 catch (RecognitionException re) {
260 reportError(re);
261 recover(input,re);
262 }
263 finally {
264
265 restoreStackSize(stackSize);
266
267 }
268 return ;
269 }
270 // $ANTLR end "ruleStatement"
271
272
273 // $ANTLR start "entryRuleREALLiteral"
274 // InternalSolverLanguage.g:103:1: entryRuleREALLiteral : ruleREALLiteral EOF ;
275 public final void entryRuleREALLiteral() throws RecognitionException {
276 try {
277 // InternalSolverLanguage.g:104:1: ( ruleREALLiteral EOF )
278 // InternalSolverLanguage.g:105:1: ruleREALLiteral EOF
279 {
280 before(grammarAccess.getREALLiteralRule());
281 pushFollow(FOLLOW_1);
282 ruleREALLiteral();
283
284 state._fsp--;
285
286 after(grammarAccess.getREALLiteralRule());
287 match(input,EOF,FOLLOW_2);
288
289 }
290
291 }
292 catch (RecognitionException re) {
293 reportError(re);
294 recover(input,re);
295 }
296 finally {
297 }
298 return ;
299 }
300 // $ANTLR end "entryRuleREALLiteral"
301
302
303 // $ANTLR start "ruleREALLiteral"
304 // InternalSolverLanguage.g:112:1: ruleREALLiteral : ( ( rule__REALLiteral__Group__0 ) ) ;
305 public final void ruleREALLiteral() throws RecognitionException {
306
307 int stackSize = keepStackSize();
308
309 try {
310 // InternalSolverLanguage.g:116:2: ( ( ( rule__REALLiteral__Group__0 ) ) )
311 // InternalSolverLanguage.g:117:2: ( ( rule__REALLiteral__Group__0 ) )
312 {
313 // InternalSolverLanguage.g:117:2: ( ( rule__REALLiteral__Group__0 ) )
314 // InternalSolverLanguage.g:118:3: ( rule__REALLiteral__Group__0 )
315 {
316 before(grammarAccess.getREALLiteralAccess().getGroup());
317 // InternalSolverLanguage.g:119:3: ( rule__REALLiteral__Group__0 )
318 // InternalSolverLanguage.g:119:4: rule__REALLiteral__Group__0
319 {
320 pushFollow(FOLLOW_2);
321 rule__REALLiteral__Group__0();
322
323 state._fsp--;
324
325
326 }
327
328 after(grammarAccess.getREALLiteralAccess().getGroup());
329
330 }
331
332
333 }
334
335 }
336 catch (RecognitionException re) {
337 reportError(re);
338 recover(input,re);
339 }
340 finally {
341
342 restoreStackSize(stackSize);
343
344 }
345 return ;
346 }
347 // $ANTLR end "ruleREALLiteral"
348
349
350 // $ANTLR start "entryRuleINTLiteral"
351 // InternalSolverLanguage.g:128:1: entryRuleINTLiteral : ruleINTLiteral EOF ;
352 public final void entryRuleINTLiteral() throws RecognitionException {
353 try {
354 // InternalSolverLanguage.g:129:1: ( ruleINTLiteral EOF )
355 // InternalSolverLanguage.g:130:1: ruleINTLiteral EOF
356 {
357 before(grammarAccess.getINTLiteralRule());
358 pushFollow(FOLLOW_1);
359 ruleINTLiteral();
360
361 state._fsp--;
362
363 after(grammarAccess.getINTLiteralRule());
364 match(input,EOF,FOLLOW_2);
365
366 }
367
368 }
369 catch (RecognitionException re) {
370 reportError(re);
371 recover(input,re);
372 }
373 finally {
374 }
375 return ;
376 }
377 // $ANTLR end "entryRuleINTLiteral"
378
379
380 // $ANTLR start "ruleINTLiteral"
381 // InternalSolverLanguage.g:137:1: ruleINTLiteral : ( ( rule__INTLiteral__Group__0 ) ) ;
382 public final void ruleINTLiteral() throws RecognitionException {
383
384 int stackSize = keepStackSize();
385
386 try {
387 // InternalSolverLanguage.g:141:2: ( ( ( rule__INTLiteral__Group__0 ) ) )
388 // InternalSolverLanguage.g:142:2: ( ( rule__INTLiteral__Group__0 ) )
389 {
390 // InternalSolverLanguage.g:142:2: ( ( rule__INTLiteral__Group__0 ) )
391 // InternalSolverLanguage.g:143:3: ( rule__INTLiteral__Group__0 )
392 {
393 before(grammarAccess.getINTLiteralAccess().getGroup());
394 // InternalSolverLanguage.g:144:3: ( rule__INTLiteral__Group__0 )
395 // InternalSolverLanguage.g:144:4: rule__INTLiteral__Group__0
396 {
397 pushFollow(FOLLOW_2);
398 rule__INTLiteral__Group__0();
399
400 state._fsp--;
401
402
403 }
404
405 after(grammarAccess.getINTLiteralAccess().getGroup());
406
407 }
408
409
410 }
411
412 }
413 catch (RecognitionException re) {
414 reportError(re);
415 recover(input,re);
416 }
417 finally {
418
419 restoreStackSize(stackSize);
420
421 }
422 return ;
423 }
424 // $ANTLR end "ruleINTLiteral"
425
426
427 // $ANTLR start "entryRuleBooleanValue"
428 // InternalSolverLanguage.g:153:1: entryRuleBooleanValue : ruleBooleanValue EOF ;
429 public final void entryRuleBooleanValue() throws RecognitionException {
430 try {
431 // InternalSolverLanguage.g:154:1: ( ruleBooleanValue EOF )
432 // InternalSolverLanguage.g:155:1: ruleBooleanValue EOF
433 {
434 before(grammarAccess.getBooleanValueRule());
435 pushFollow(FOLLOW_1);
436 ruleBooleanValue();
437
438 state._fsp--;
439
440 after(grammarAccess.getBooleanValueRule());
441 match(input,EOF,FOLLOW_2);
442
443 }
444
445 }
446 catch (RecognitionException re) {
447 reportError(re);
448 recover(input,re);
449 }
450 finally {
451 }
452 return ;
453 }
454 // $ANTLR end "entryRuleBooleanValue"
455
456
457 // $ANTLR start "ruleBooleanValue"
458 // InternalSolverLanguage.g:162:1: ruleBooleanValue : ( ( rule__BooleanValue__Alternatives ) ) ;
459 public final void ruleBooleanValue() throws RecognitionException {
460
461 int stackSize = keepStackSize();
462
463 try {
464 // InternalSolverLanguage.g:166:2: ( ( ( rule__BooleanValue__Alternatives ) ) )
465 // InternalSolverLanguage.g:167:2: ( ( rule__BooleanValue__Alternatives ) )
466 {
467 // InternalSolverLanguage.g:167:2: ( ( rule__BooleanValue__Alternatives ) )
468 // InternalSolverLanguage.g:168:3: ( rule__BooleanValue__Alternatives )
469 {
470 before(grammarAccess.getBooleanValueAccess().getAlternatives());
471 // InternalSolverLanguage.g:169:3: ( rule__BooleanValue__Alternatives )
472 // InternalSolverLanguage.g:169:4: rule__BooleanValue__Alternatives
473 {
474 pushFollow(FOLLOW_2);
475 rule__BooleanValue__Alternatives();
476
477 state._fsp--;
478
479
480 }
481
482 after(grammarAccess.getBooleanValueAccess().getAlternatives());
483
484 }
485
486
487 }
488
489 }
490 catch (RecognitionException re) {
491 reportError(re);
492 recover(input,re);
493 }
494 finally {
495
496 restoreStackSize(stackSize);
497
498 }
499 return ;
500 }
501 // $ANTLR end "ruleBooleanValue"
502
503
504 // $ANTLR start "entryRuleTruthValue"
505 // InternalSolverLanguage.g:178:1: entryRuleTruthValue : ruleTruthValue EOF ;
506 public final void entryRuleTruthValue() throws RecognitionException {
507 try {
508 // InternalSolverLanguage.g:179:1: ( ruleTruthValue EOF )
509 // InternalSolverLanguage.g:180:1: ruleTruthValue EOF
510 {
511 before(grammarAccess.getTruthValueRule());
512 pushFollow(FOLLOW_1);
513 ruleTruthValue();
514
515 state._fsp--;
516
517 after(grammarAccess.getTruthValueRule());
518 match(input,EOF,FOLLOW_2);
519
520 }
521
522 }
523 catch (RecognitionException re) {
524 reportError(re);
525 recover(input,re);
526 }
527 finally {
528 }
529 return ;
530 }
531 // $ANTLR end "entryRuleTruthValue"
532
533
534 // $ANTLR start "ruleTruthValue"
535 // InternalSolverLanguage.g:187:1: ruleTruthValue : ( ( rule__TruthValue__Alternatives ) ) ;
536 public final void ruleTruthValue() throws RecognitionException {
537
538 int stackSize = keepStackSize();
539
540 try {
541 // InternalSolverLanguage.g:191:2: ( ( ( rule__TruthValue__Alternatives ) ) )
542 // InternalSolverLanguage.g:192:2: ( ( rule__TruthValue__Alternatives ) )
543 {
544 // InternalSolverLanguage.g:192:2: ( ( rule__TruthValue__Alternatives ) )
545 // InternalSolverLanguage.g:193:3: ( rule__TruthValue__Alternatives )
546 {
547 before(grammarAccess.getTruthValueAccess().getAlternatives());
548 // InternalSolverLanguage.g:194:3: ( rule__TruthValue__Alternatives )
549 // InternalSolverLanguage.g:194:4: rule__TruthValue__Alternatives
550 {
551 pushFollow(FOLLOW_2);
552 rule__TruthValue__Alternatives();
553
554 state._fsp--;
555
556
557 }
558
559 after(grammarAccess.getTruthValueAccess().getAlternatives());
560
561 }
562
563
564 }
565
566 }
567 catch (RecognitionException re) {
568 reportError(re);
569 recover(input,re);
570 }
571 finally {
572
573 restoreStackSize(stackSize);
574
575 }
576 return ;
577 }
578 // $ANTLR end "ruleTruthValue"
579
580
581 // $ANTLR start "entryRuleInterpretation"
582 // InternalSolverLanguage.g:203:1: entryRuleInterpretation : ruleInterpretation EOF ;
583 public final void entryRuleInterpretation() throws RecognitionException {
584 try {
585 // InternalSolverLanguage.g:204:1: ( ruleInterpretation EOF )
586 // InternalSolverLanguage.g:205:1: ruleInterpretation EOF
587 {
588 before(grammarAccess.getInterpretationRule());
589 pushFollow(FOLLOW_1);
590 ruleInterpretation();
591
592 state._fsp--;
593
594 after(grammarAccess.getInterpretationRule());
595 match(input,EOF,FOLLOW_2);
596
597 }
598
599 }
600 catch (RecognitionException re) {
601 reportError(re);
602 recover(input,re);
603 }
604 finally {
605 }
606 return ;
607 }
608 // $ANTLR end "entryRuleInterpretation"
609
610
611 // $ANTLR start "ruleInterpretation"
612 // InternalSolverLanguage.g:212:1: ruleInterpretation : ( ( rule__Interpretation__Alternatives ) ) ;
613 public final void ruleInterpretation() throws RecognitionException {
614
615 int stackSize = keepStackSize();
616
617 try {
618 // InternalSolverLanguage.g:216:2: ( ( ( rule__Interpretation__Alternatives ) ) )
619 // InternalSolverLanguage.g:217:2: ( ( rule__Interpretation__Alternatives ) )
620 {
621 // InternalSolverLanguage.g:217:2: ( ( rule__Interpretation__Alternatives ) )
622 // InternalSolverLanguage.g:218:3: ( rule__Interpretation__Alternatives )
623 {
624 before(grammarAccess.getInterpretationAccess().getAlternatives());
625 // InternalSolverLanguage.g:219:3: ( rule__Interpretation__Alternatives )
626 // InternalSolverLanguage.g:219:4: rule__Interpretation__Alternatives
627 {
628 pushFollow(FOLLOW_2);
629 rule__Interpretation__Alternatives();
630
631 state._fsp--;
632
633
634 }
635
636 after(grammarAccess.getInterpretationAccess().getAlternatives());
637
638 }
639
640
641 }
642
643 }
644 catch (RecognitionException re) {
645 reportError(re);
646 recover(input,re);
647 }
648 finally {
649
650 restoreStackSize(stackSize);
651
652 }
653 return ;
654 }
655 // $ANTLR end "ruleInterpretation"
656
657
658 // $ANTLR start "entryRuleBasicInterpretation"
659 // InternalSolverLanguage.g:228:1: entryRuleBasicInterpretation : ruleBasicInterpretation EOF ;
660 public final void entryRuleBasicInterpretation() throws RecognitionException {
661 try {
662 // InternalSolverLanguage.g:229:1: ( ruleBasicInterpretation EOF )
663 // InternalSolverLanguage.g:230:1: ruleBasicInterpretation EOF
664 {
665 before(grammarAccess.getBasicInterpretationRule());
666 pushFollow(FOLLOW_1);
667 ruleBasicInterpretation();
668
669 state._fsp--;
670
671 after(grammarAccess.getBasicInterpretationRule());
672 match(input,EOF,FOLLOW_2);
673
674 }
675
676 }
677 catch (RecognitionException re) {
678 reportError(re);
679 recover(input,re);
680 }
681 finally {
682 }
683 return ;
684 }
685 // $ANTLR end "entryRuleBasicInterpretation"
686
687
688 // $ANTLR start "ruleBasicInterpretation"
689 // InternalSolverLanguage.g:237:1: ruleBasicInterpretation : ( ( rule__BasicInterpretation__Group__0 ) ) ;
690 public final void ruleBasicInterpretation() throws RecognitionException {
691
692 int stackSize = keepStackSize();
693
694 try {
695 // InternalSolverLanguage.g:241:2: ( ( ( rule__BasicInterpretation__Group__0 ) ) )
696 // InternalSolverLanguage.g:242:2: ( ( rule__BasicInterpretation__Group__0 ) )
697 {
698 // InternalSolverLanguage.g:242:2: ( ( rule__BasicInterpretation__Group__0 ) )
699 // InternalSolverLanguage.g:243:3: ( rule__BasicInterpretation__Group__0 )
700 {
701 before(grammarAccess.getBasicInterpretationAccess().getGroup());
702 // InternalSolverLanguage.g:244:3: ( rule__BasicInterpretation__Group__0 )
703 // InternalSolverLanguage.g:244:4: rule__BasicInterpretation__Group__0
704 {
705 pushFollow(FOLLOW_2);
706 rule__BasicInterpretation__Group__0();
707
708 state._fsp--;
709
710
711 }
712
713 after(grammarAccess.getBasicInterpretationAccess().getGroup());
714
715 }
716
717
718 }
719
720 }
721 catch (RecognitionException re) {
722 reportError(re);
723 recover(input,re);
724 }
725 finally {
726
727 restoreStackSize(stackSize);
728
729 }
730 return ;
731 }
732 // $ANTLR end "ruleBasicInterpretation"
733
734
735 // $ANTLR start "entryRuleSymbol"
736 // InternalSolverLanguage.g:253:1: entryRuleSymbol : ruleSymbol EOF ;
737 public final void entryRuleSymbol() throws RecognitionException {
738 try {
739 // InternalSolverLanguage.g:254:1: ( ruleSymbol EOF )
740 // InternalSolverLanguage.g:255:1: ruleSymbol EOF
741 {
742 before(grammarAccess.getSymbolRule());
743 pushFollow(FOLLOW_1);
744 ruleSymbol();
745
746 state._fsp--;
747
748 after(grammarAccess.getSymbolRule());
749 match(input,EOF,FOLLOW_2);
750
751 }
752
753 }
754 catch (RecognitionException re) {
755 reportError(re);
756 recover(input,re);
757 }
758 finally {
759 }
760 return ;
761 }
762 // $ANTLR end "entryRuleSymbol"
763
764
765 // $ANTLR start "ruleSymbol"
766 // InternalSolverLanguage.g:262:1: ruleSymbol : ( ( rule__Symbol__Alternatives ) ) ;
767 public final void ruleSymbol() throws RecognitionException {
768
769 int stackSize = keepStackSize();
770
771 try {
772 // InternalSolverLanguage.g:266:2: ( ( ( rule__Symbol__Alternatives ) ) )
773 // InternalSolverLanguage.g:267:2: ( ( rule__Symbol__Alternatives ) )
774 {
775 // InternalSolverLanguage.g:267:2: ( ( rule__Symbol__Alternatives ) )
776 // InternalSolverLanguage.g:268:3: ( rule__Symbol__Alternatives )
777 {
778 before(grammarAccess.getSymbolAccess().getAlternatives());
779 // InternalSolverLanguage.g:269:3: ( rule__Symbol__Alternatives )
780 // InternalSolverLanguage.g:269:4: rule__Symbol__Alternatives
781 {
782 pushFollow(FOLLOW_2);
783 rule__Symbol__Alternatives();
784
785 state._fsp--;
786
787
788 }
789
790 after(grammarAccess.getSymbolAccess().getAlternatives());
791
792 }
793
794
795 }
796
797 }
798 catch (RecognitionException re) {
799 reportError(re);
800 recover(input,re);
801 }
802 finally {
803
804 restoreStackSize(stackSize);
805
806 }
807 return ;
808 }
809 // $ANTLR end "ruleSymbol"
810
811
812 // $ANTLR start "entryRuleModelSymbol"
813 // InternalSolverLanguage.g:278:1: entryRuleModelSymbol : ruleModelSymbol EOF ;
814 public final void entryRuleModelSymbol() throws RecognitionException {
815 try {
816 // InternalSolverLanguage.g:279:1: ( ruleModelSymbol EOF )
817 // InternalSolverLanguage.g:280:1: ruleModelSymbol EOF
818 {
819 before(grammarAccess.getModelSymbolRule());
820 pushFollow(FOLLOW_1);
821 ruleModelSymbol();
822
823 state._fsp--;
824
825 after(grammarAccess.getModelSymbolRule());
826 match(input,EOF,FOLLOW_2);
827
828 }
829
830 }
831 catch (RecognitionException re) {
832 reportError(re);
833 recover(input,re);
834 }
835 finally {
836 }
837 return ;
838 }
839 // $ANTLR end "entryRuleModelSymbol"
840
841
842 // $ANTLR start "ruleModelSymbol"
843 // InternalSolverLanguage.g:287:1: ruleModelSymbol : ( ( rule__ModelSymbol__NameAssignment ) ) ;
844 public final void ruleModelSymbol() throws RecognitionException {
845
846 int stackSize = keepStackSize();
847
848 try {
849 // InternalSolverLanguage.g:291:2: ( ( ( rule__ModelSymbol__NameAssignment ) ) )
850 // InternalSolverLanguage.g:292:2: ( ( rule__ModelSymbol__NameAssignment ) )
851 {
852 // InternalSolverLanguage.g:292:2: ( ( rule__ModelSymbol__NameAssignment ) )
853 // InternalSolverLanguage.g:293:3: ( rule__ModelSymbol__NameAssignment )
854 {
855 before(grammarAccess.getModelSymbolAccess().getNameAssignment());
856 // InternalSolverLanguage.g:294:3: ( rule__ModelSymbol__NameAssignment )
857 // InternalSolverLanguage.g:294:4: rule__ModelSymbol__NameAssignment
858 {
859 pushFollow(FOLLOW_2);
860 rule__ModelSymbol__NameAssignment();
861
862 state._fsp--;
863
864
865 }
866
867 after(grammarAccess.getModelSymbolAccess().getNameAssignment());
868
869 }
870
871
872 }
873
874 }
875 catch (RecognitionException re) {
876 reportError(re);
877 recover(input,re);
878 }
879 finally {
880
881 restoreStackSize(stackSize);
882
883 }
884 return ;
885 }
886 // $ANTLR end "ruleModelSymbol"
887
888
889 // $ANTLR start "entryRulePartialitySymbol"
890 // InternalSolverLanguage.g:303:1: entryRulePartialitySymbol : rulePartialitySymbol EOF ;
891 public final void entryRulePartialitySymbol() throws RecognitionException {
892 try {
893 // InternalSolverLanguage.g:304:1: ( rulePartialitySymbol EOF )
894 // InternalSolverLanguage.g:305:1: rulePartialitySymbol EOF
895 {
896 before(grammarAccess.getPartialitySymbolRule());
897 pushFollow(FOLLOW_1);
898 rulePartialitySymbol();
899
900 state._fsp--;
901
902 after(grammarAccess.getPartialitySymbolRule());
903 match(input,EOF,FOLLOW_2);
904
905 }
906
907 }
908 catch (RecognitionException re) {
909 reportError(re);
910 recover(input,re);
911 }
912 finally {
913 }
914 return ;
915 }
916 // $ANTLR end "entryRulePartialitySymbol"
917
918
919 // $ANTLR start "rulePartialitySymbol"
920 // InternalSolverLanguage.g:312:1: rulePartialitySymbol : ( ( rule__PartialitySymbol__Alternatives ) ) ;
921 public final void rulePartialitySymbol() throws RecognitionException {
922
923 int stackSize = keepStackSize();
924
925 try {
926 // InternalSolverLanguage.g:316:2: ( ( ( rule__PartialitySymbol__Alternatives ) ) )
927 // InternalSolverLanguage.g:317:2: ( ( rule__PartialitySymbol__Alternatives ) )
928 {
929 // InternalSolverLanguage.g:317:2: ( ( rule__PartialitySymbol__Alternatives ) )
930 // InternalSolverLanguage.g:318:3: ( rule__PartialitySymbol__Alternatives )
931 {
932 before(grammarAccess.getPartialitySymbolAccess().getAlternatives());
933 // InternalSolverLanguage.g:319:3: ( rule__PartialitySymbol__Alternatives )
934 // InternalSolverLanguage.g:319:4: rule__PartialitySymbol__Alternatives
935 {
936 pushFollow(FOLLOW_2);
937 rule__PartialitySymbol__Alternatives();
938
939 state._fsp--;
940
941
942 }
943
944 after(grammarAccess.getPartialitySymbolAccess().getAlternatives());
945
946 }
947
948
949 }
950
951 }
952 catch (RecognitionException re) {
953 reportError(re);
954 recover(input,re);
955 }
956 finally {
957
958 restoreStackSize(stackSize);
959
960 }
961 return ;
962 }
963 // $ANTLR end "rulePartialitySymbol"
964
965
966 // $ANTLR start "entryRuleExistSymbol"
967 // InternalSolverLanguage.g:328:1: entryRuleExistSymbol : ruleExistSymbol EOF ;
968 public final void entryRuleExistSymbol() throws RecognitionException {
969 try {
970 // InternalSolverLanguage.g:329:1: ( ruleExistSymbol EOF )
971 // InternalSolverLanguage.g:330:1: ruleExistSymbol EOF
972 {
973 before(grammarAccess.getExistSymbolRule());
974 pushFollow(FOLLOW_1);
975 ruleExistSymbol();
976
977 state._fsp--;
978
979 after(grammarAccess.getExistSymbolRule());
980 match(input,EOF,FOLLOW_2);
981
982 }
983
984 }
985 catch (RecognitionException re) {
986 reportError(re);
987 recover(input,re);
988 }
989 finally {
990 }
991 return ;
992 }
993 // $ANTLR end "entryRuleExistSymbol"
994
995
996 // $ANTLR start "ruleExistSymbol"
997 // InternalSolverLanguage.g:337:1: ruleExistSymbol : ( ( rule__ExistSymbol__Group__0 ) ) ;
998 public final void ruleExistSymbol() throws RecognitionException {
999
1000 int stackSize = keepStackSize();
1001
1002 try {
1003 // InternalSolverLanguage.g:341:2: ( ( ( rule__ExistSymbol__Group__0 ) ) )
1004 // InternalSolverLanguage.g:342:2: ( ( rule__ExistSymbol__Group__0 ) )
1005 {
1006 // InternalSolverLanguage.g:342:2: ( ( rule__ExistSymbol__Group__0 ) )
1007 // InternalSolverLanguage.g:343:3: ( rule__ExistSymbol__Group__0 )
1008 {
1009 before(grammarAccess.getExistSymbolAccess().getGroup());
1010 // InternalSolverLanguage.g:344:3: ( rule__ExistSymbol__Group__0 )
1011 // InternalSolverLanguage.g:344:4: rule__ExistSymbol__Group__0
1012 {
1013 pushFollow(FOLLOW_2);
1014 rule__ExistSymbol__Group__0();
1015
1016 state._fsp--;
1017
1018
1019 }
1020
1021 after(grammarAccess.getExistSymbolAccess().getGroup());
1022
1023 }
1024
1025
1026 }
1027
1028 }
1029 catch (RecognitionException re) {
1030 reportError(re);
1031 recover(input,re);
1032 }
1033 finally {
1034
1035 restoreStackSize(stackSize);
1036
1037 }
1038 return ;
1039 }
1040 // $ANTLR end "ruleExistSymbol"
1041
1042
1043 // $ANTLR start "entryRuleEqualsSymbol"
1044 // InternalSolverLanguage.g:353:1: entryRuleEqualsSymbol : ruleEqualsSymbol EOF ;
1045 public final void entryRuleEqualsSymbol() throws RecognitionException {
1046 try {
1047 // InternalSolverLanguage.g:354:1: ( ruleEqualsSymbol EOF )
1048 // InternalSolverLanguage.g:355:1: ruleEqualsSymbol EOF
1049 {
1050 before(grammarAccess.getEqualsSymbolRule());
1051 pushFollow(FOLLOW_1);
1052 ruleEqualsSymbol();
1053
1054 state._fsp--;
1055
1056 after(grammarAccess.getEqualsSymbolRule());
1057 match(input,EOF,FOLLOW_2);
1058
1059 }
1060
1061 }
1062 catch (RecognitionException re) {
1063 reportError(re);
1064 recover(input,re);
1065 }
1066 finally {
1067 }
1068 return ;
1069 }
1070 // $ANTLR end "entryRuleEqualsSymbol"
1071
1072
1073 // $ANTLR start "ruleEqualsSymbol"
1074 // InternalSolverLanguage.g:362:1: ruleEqualsSymbol : ( ( rule__EqualsSymbol__Group__0 ) ) ;
1075 public final void ruleEqualsSymbol() throws RecognitionException {
1076
1077 int stackSize = keepStackSize();
1078
1079 try {
1080 // InternalSolverLanguage.g:366:2: ( ( ( rule__EqualsSymbol__Group__0 ) ) )
1081 // InternalSolverLanguage.g:367:2: ( ( rule__EqualsSymbol__Group__0 ) )
1082 {
1083 // InternalSolverLanguage.g:367:2: ( ( rule__EqualsSymbol__Group__0 ) )
1084 // InternalSolverLanguage.g:368:3: ( rule__EqualsSymbol__Group__0 )
1085 {
1086 before(grammarAccess.getEqualsSymbolAccess().getGroup());
1087 // InternalSolverLanguage.g:369:3: ( rule__EqualsSymbol__Group__0 )
1088 // InternalSolverLanguage.g:369:4: rule__EqualsSymbol__Group__0
1089 {
1090 pushFollow(FOLLOW_2);
1091 rule__EqualsSymbol__Group__0();
1092
1093 state._fsp--;
1094
1095
1096 }
1097
1098 after(grammarAccess.getEqualsSymbolAccess().getGroup());
1099
1100 }
1101
1102
1103 }
1104
1105 }
1106 catch (RecognitionException re) {
1107 reportError(re);
1108 recover(input,re);
1109 }
1110 finally {
1111
1112 restoreStackSize(stackSize);
1113
1114 }
1115 return ;
1116 }
1117 // $ANTLR end "ruleEqualsSymbol"
1118
1119
1120 // $ANTLR start "entryRuleDataSymbol"
1121 // InternalSolverLanguage.g:378:1: entryRuleDataSymbol : ruleDataSymbol EOF ;
1122 public final void entryRuleDataSymbol() throws RecognitionException {
1123 try {
1124 // InternalSolverLanguage.g:379:1: ( ruleDataSymbol EOF )
1125 // InternalSolverLanguage.g:380:1: ruleDataSymbol EOF
1126 {
1127 before(grammarAccess.getDataSymbolRule());
1128 pushFollow(FOLLOW_1);
1129 ruleDataSymbol();
1130
1131 state._fsp--;
1132
1133 after(grammarAccess.getDataSymbolRule());
1134 match(input,EOF,FOLLOW_2);
1135
1136 }
1137
1138 }
1139 catch (RecognitionException re) {
1140 reportError(re);
1141 recover(input,re);
1142 }
1143 finally {
1144 }
1145 return ;
1146 }
1147 // $ANTLR end "entryRuleDataSymbol"
1148
1149
1150 // $ANTLR start "ruleDataSymbol"
1151 // InternalSolverLanguage.g:387:1: ruleDataSymbol : ( ( rule__DataSymbol__Alternatives ) ) ;
1152 public final void ruleDataSymbol() throws RecognitionException {
1153
1154 int stackSize = keepStackSize();
1155
1156 try {
1157 // InternalSolverLanguage.g:391:2: ( ( ( rule__DataSymbol__Alternatives ) ) )
1158 // InternalSolverLanguage.g:392:2: ( ( rule__DataSymbol__Alternatives ) )
1159 {
1160 // InternalSolverLanguage.g:392:2: ( ( rule__DataSymbol__Alternatives ) )
1161 // InternalSolverLanguage.g:393:3: ( rule__DataSymbol__Alternatives )
1162 {
1163 before(grammarAccess.getDataSymbolAccess().getAlternatives());
1164 // InternalSolverLanguage.g:394:3: ( rule__DataSymbol__Alternatives )
1165 // InternalSolverLanguage.g:394:4: rule__DataSymbol__Alternatives
1166 {
1167 pushFollow(FOLLOW_2);
1168 rule__DataSymbol__Alternatives();
1169
1170 state._fsp--;
1171
1172
1173 }
1174
1175 after(grammarAccess.getDataSymbolAccess().getAlternatives());
1176
1177 }
1178
1179
1180 }
1181
1182 }
1183 catch (RecognitionException re) {
1184 reportError(re);
1185 recover(input,re);
1186 }
1187 finally {
1188
1189 restoreStackSize(stackSize);
1190
1191 }
1192 return ;
1193 }
1194 // $ANTLR end "ruleDataSymbol"
1195
1196
1197 // $ANTLR start "entryRuleBooleanSymbol"
1198 // InternalSolverLanguage.g:403:1: entryRuleBooleanSymbol : ruleBooleanSymbol EOF ;
1199 public final void entryRuleBooleanSymbol() throws RecognitionException {
1200 try {
1201 // InternalSolverLanguage.g:404:1: ( ruleBooleanSymbol EOF )
1202 // InternalSolverLanguage.g:405:1: ruleBooleanSymbol EOF
1203 {
1204 before(grammarAccess.getBooleanSymbolRule());
1205 pushFollow(FOLLOW_1);
1206 ruleBooleanSymbol();
1207
1208 state._fsp--;
1209
1210 after(grammarAccess.getBooleanSymbolRule());
1211 match(input,EOF,FOLLOW_2);
1212
1213 }
1214
1215 }
1216 catch (RecognitionException re) {
1217 reportError(re);
1218 recover(input,re);
1219 }
1220 finally {
1221 }
1222 return ;
1223 }
1224 // $ANTLR end "entryRuleBooleanSymbol"
1225
1226
1227 // $ANTLR start "ruleBooleanSymbol"
1228 // InternalSolverLanguage.g:412:1: ruleBooleanSymbol : ( ( rule__BooleanSymbol__Group__0 ) ) ;
1229 public final void ruleBooleanSymbol() throws RecognitionException {
1230
1231 int stackSize = keepStackSize();
1232
1233 try {
1234 // InternalSolverLanguage.g:416:2: ( ( ( rule__BooleanSymbol__Group__0 ) ) )
1235 // InternalSolverLanguage.g:417:2: ( ( rule__BooleanSymbol__Group__0 ) )
1236 {
1237 // InternalSolverLanguage.g:417:2: ( ( rule__BooleanSymbol__Group__0 ) )
1238 // InternalSolverLanguage.g:418:3: ( rule__BooleanSymbol__Group__0 )
1239 {
1240 before(grammarAccess.getBooleanSymbolAccess().getGroup());
1241 // InternalSolverLanguage.g:419:3: ( rule__BooleanSymbol__Group__0 )
1242 // InternalSolverLanguage.g:419:4: rule__BooleanSymbol__Group__0
1243 {
1244 pushFollow(FOLLOW_2);
1245 rule__BooleanSymbol__Group__0();
1246
1247 state._fsp--;
1248
1249
1250 }
1251
1252 after(grammarAccess.getBooleanSymbolAccess().getGroup());
1253
1254 }
1255
1256
1257 }
1258
1259 }
1260 catch (RecognitionException re) {
1261 reportError(re);
1262 recover(input,re);
1263 }
1264 finally {
1265
1266 restoreStackSize(stackSize);
1267
1268 }
1269 return ;
1270 }
1271 // $ANTLR end "ruleBooleanSymbol"
1272
1273
1274 // $ANTLR start "entryRuleIntegerSymbol"
1275 // InternalSolverLanguage.g:428:1: entryRuleIntegerSymbol : ruleIntegerSymbol EOF ;
1276 public final void entryRuleIntegerSymbol() throws RecognitionException {
1277 try {
1278 // InternalSolverLanguage.g:429:1: ( ruleIntegerSymbol EOF )
1279 // InternalSolverLanguage.g:430:1: ruleIntegerSymbol EOF
1280 {
1281 before(grammarAccess.getIntegerSymbolRule());
1282 pushFollow(FOLLOW_1);
1283 ruleIntegerSymbol();
1284
1285 state._fsp--;
1286
1287 after(grammarAccess.getIntegerSymbolRule());
1288 match(input,EOF,FOLLOW_2);
1289
1290 }
1291
1292 }
1293 catch (RecognitionException re) {
1294 reportError(re);
1295 recover(input,re);
1296 }
1297 finally {
1298 }
1299 return ;
1300 }
1301 // $ANTLR end "entryRuleIntegerSymbol"
1302
1303
1304 // $ANTLR start "ruleIntegerSymbol"
1305 // InternalSolverLanguage.g:437:1: ruleIntegerSymbol : ( ( rule__IntegerSymbol__Group__0 ) ) ;
1306 public final void ruleIntegerSymbol() throws RecognitionException {
1307
1308 int stackSize = keepStackSize();
1309
1310 try {
1311 // InternalSolverLanguage.g:441:2: ( ( ( rule__IntegerSymbol__Group__0 ) ) )
1312 // InternalSolverLanguage.g:442:2: ( ( rule__IntegerSymbol__Group__0 ) )
1313 {
1314 // InternalSolverLanguage.g:442:2: ( ( rule__IntegerSymbol__Group__0 ) )
1315 // InternalSolverLanguage.g:443:3: ( rule__IntegerSymbol__Group__0 )
1316 {
1317 before(grammarAccess.getIntegerSymbolAccess().getGroup());
1318 // InternalSolverLanguage.g:444:3: ( rule__IntegerSymbol__Group__0 )
1319 // InternalSolverLanguage.g:444:4: rule__IntegerSymbol__Group__0
1320 {
1321 pushFollow(FOLLOW_2);
1322 rule__IntegerSymbol__Group__0();
1323
1324 state._fsp--;
1325
1326
1327 }
1328
1329 after(grammarAccess.getIntegerSymbolAccess().getGroup());
1330
1331 }
1332
1333
1334 }
1335
1336 }
1337 catch (RecognitionException re) {
1338 reportError(re);
1339 recover(input,re);
1340 }
1341 finally {
1342
1343 restoreStackSize(stackSize);
1344
1345 }
1346 return ;
1347 }
1348 // $ANTLR end "ruleIntegerSymbol"
1349
1350
1351 // $ANTLR start "entryRuleRealSymbol"
1352 // InternalSolverLanguage.g:453:1: entryRuleRealSymbol : ruleRealSymbol EOF ;
1353 public final void entryRuleRealSymbol() throws RecognitionException {
1354 try {
1355 // InternalSolverLanguage.g:454:1: ( ruleRealSymbol EOF )
1356 // InternalSolverLanguage.g:455:1: ruleRealSymbol EOF
1357 {
1358 before(grammarAccess.getRealSymbolRule());
1359 pushFollow(FOLLOW_1);
1360 ruleRealSymbol();
1361
1362 state._fsp--;
1363
1364 after(grammarAccess.getRealSymbolRule());
1365 match(input,EOF,FOLLOW_2);
1366
1367 }
1368
1369 }
1370 catch (RecognitionException re) {
1371 reportError(re);
1372 recover(input,re);
1373 }
1374 finally {
1375 }
1376 return ;
1377 }
1378 // $ANTLR end "entryRuleRealSymbol"
1379
1380
1381 // $ANTLR start "ruleRealSymbol"
1382 // InternalSolverLanguage.g:462:1: ruleRealSymbol : ( ( rule__RealSymbol__Group__0 ) ) ;
1383 public final void ruleRealSymbol() throws RecognitionException {
1384
1385 int stackSize = keepStackSize();
1386
1387 try {
1388 // InternalSolverLanguage.g:466:2: ( ( ( rule__RealSymbol__Group__0 ) ) )
1389 // InternalSolverLanguage.g:467:2: ( ( rule__RealSymbol__Group__0 ) )
1390 {
1391 // InternalSolverLanguage.g:467:2: ( ( rule__RealSymbol__Group__0 ) )
1392 // InternalSolverLanguage.g:468:3: ( rule__RealSymbol__Group__0 )
1393 {
1394 before(grammarAccess.getRealSymbolAccess().getGroup());
1395 // InternalSolverLanguage.g:469:3: ( rule__RealSymbol__Group__0 )
1396 // InternalSolverLanguage.g:469:4: rule__RealSymbol__Group__0
1397 {
1398 pushFollow(FOLLOW_2);
1399 rule__RealSymbol__Group__0();
1400
1401 state._fsp--;
1402
1403
1404 }
1405
1406 after(grammarAccess.getRealSymbolAccess().getGroup());
1407
1408 }
1409
1410
1411 }
1412
1413 }
1414 catch (RecognitionException re) {
1415 reportError(re);
1416 recover(input,re);
1417 }
1418 finally {
1419
1420 restoreStackSize(stackSize);
1421
1422 }
1423 return ;
1424 }
1425 // $ANTLR end "ruleRealSymbol"
1426
1427
1428 // $ANTLR start "entryRuleStringSymbol"
1429 // InternalSolverLanguage.g:478:1: entryRuleStringSymbol : ruleStringSymbol EOF ;
1430 public final void entryRuleStringSymbol() throws RecognitionException {
1431 try {
1432 // InternalSolverLanguage.g:479:1: ( ruleStringSymbol EOF )
1433 // InternalSolverLanguage.g:480:1: ruleStringSymbol EOF
1434 {
1435 before(grammarAccess.getStringSymbolRule());
1436 pushFollow(FOLLOW_1);
1437 ruleStringSymbol();
1438
1439 state._fsp--;
1440
1441 after(grammarAccess.getStringSymbolRule());
1442 match(input,EOF,FOLLOW_2);
1443
1444 }
1445
1446 }
1447 catch (RecognitionException re) {
1448 reportError(re);
1449 recover(input,re);
1450 }
1451 finally {
1452 }
1453 return ;
1454 }
1455 // $ANTLR end "entryRuleStringSymbol"
1456
1457
1458 // $ANTLR start "ruleStringSymbol"
1459 // InternalSolverLanguage.g:487:1: ruleStringSymbol : ( ( rule__StringSymbol__Group__0 ) ) ;
1460 public final void ruleStringSymbol() throws RecognitionException {
1461
1462 int stackSize = keepStackSize();
1463
1464 try {
1465 // InternalSolverLanguage.g:491:2: ( ( ( rule__StringSymbol__Group__0 ) ) )
1466 // InternalSolverLanguage.g:492:2: ( ( rule__StringSymbol__Group__0 ) )
1467 {
1468 // InternalSolverLanguage.g:492:2: ( ( rule__StringSymbol__Group__0 ) )
1469 // InternalSolverLanguage.g:493:3: ( rule__StringSymbol__Group__0 )
1470 {
1471 before(grammarAccess.getStringSymbolAccess().getGroup());
1472 // InternalSolverLanguage.g:494:3: ( rule__StringSymbol__Group__0 )
1473 // InternalSolverLanguage.g:494:4: rule__StringSymbol__Group__0
1474 {
1475 pushFollow(FOLLOW_2);
1476 rule__StringSymbol__Group__0();
1477
1478 state._fsp--;
1479
1480
1481 }
1482
1483 after(grammarAccess.getStringSymbolAccess().getGroup());
1484
1485 }
1486
1487
1488 }
1489
1490 }
1491 catch (RecognitionException re) {
1492 reportError(re);
1493 recover(input,re);
1494 }
1495 finally {
1496
1497 restoreStackSize(stackSize);
1498
1499 }
1500 return ;
1501 }
1502 // $ANTLR end "ruleStringSymbol"
1503
1504
1505 // $ANTLR start "entryRuleComplexObject"
1506 // InternalSolverLanguage.g:503:1: entryRuleComplexObject : ruleComplexObject EOF ;
1507 public final void entryRuleComplexObject() throws RecognitionException {
1508 try {
1509 // InternalSolverLanguage.g:504:1: ( ruleComplexObject EOF )
1510 // InternalSolverLanguage.g:505:1: ruleComplexObject EOF
1511 {
1512 before(grammarAccess.getComplexObjectRule());
1513 pushFollow(FOLLOW_1);
1514 ruleComplexObject();
1515
1516 state._fsp--;
1517
1518 after(grammarAccess.getComplexObjectRule());
1519 match(input,EOF,FOLLOW_2);
1520
1521 }
1522
1523 }
1524 catch (RecognitionException re) {
1525 reportError(re);
1526 recover(input,re);
1527 }
1528 finally {
1529 }
1530 return ;
1531 }
1532 // $ANTLR end "entryRuleComplexObject"
1533
1534
1535 // $ANTLR start "ruleComplexObject"
1536 // InternalSolverLanguage.g:512:1: ruleComplexObject : ( ( rule__ComplexObject__Alternatives ) ) ;
1537 public final void ruleComplexObject() throws RecognitionException {
1538
1539 int stackSize = keepStackSize();
1540
1541 try {
1542 // InternalSolverLanguage.g:516:2: ( ( ( rule__ComplexObject__Alternatives ) ) )
1543 // InternalSolverLanguage.g:517:2: ( ( rule__ComplexObject__Alternatives ) )
1544 {
1545 // InternalSolverLanguage.g:517:2: ( ( rule__ComplexObject__Alternatives ) )
1546 // InternalSolverLanguage.g:518:3: ( rule__ComplexObject__Alternatives )
1547 {
1548 before(grammarAccess.getComplexObjectAccess().getAlternatives());
1549 // InternalSolverLanguage.g:519:3: ( rule__ComplexObject__Alternatives )
1550 // InternalSolverLanguage.g:519:4: rule__ComplexObject__Alternatives
1551 {
1552 pushFollow(FOLLOW_2);
1553 rule__ComplexObject__Alternatives();
1554
1555 state._fsp--;
1556
1557
1558 }
1559
1560 after(grammarAccess.getComplexObjectAccess().getAlternatives());
1561
1562 }
1563
1564
1565 }
1566
1567 }
1568 catch (RecognitionException re) {
1569 reportError(re);
1570 recover(input,re);
1571 }
1572 finally {
1573
1574 restoreStackSize(stackSize);
1575
1576 }
1577 return ;
1578 }
1579 // $ANTLR end "ruleComplexObject"
1580
1581
1582 // $ANTLR start "entryRuleObject"
1583 // InternalSolverLanguage.g:528:1: entryRuleObject : ruleObject EOF ;
1584 public final void entryRuleObject() throws RecognitionException {
1585 try {
1586 // InternalSolverLanguage.g:529:1: ( ruleObject EOF )
1587 // InternalSolverLanguage.g:530:1: ruleObject EOF
1588 {
1589 before(grammarAccess.getObjectRule());
1590 pushFollow(FOLLOW_1);
1591 ruleObject();
1592
1593 state._fsp--;
1594
1595 after(grammarAccess.getObjectRule());
1596 match(input,EOF,FOLLOW_2);
1597
1598 }
1599
1600 }
1601 catch (RecognitionException re) {
1602 reportError(re);
1603 recover(input,re);
1604 }
1605 finally {
1606 }
1607 return ;
1608 }
1609 // $ANTLR end "entryRuleObject"
1610
1611
1612 // $ANTLR start "ruleObject"
1613 // InternalSolverLanguage.g:537:1: ruleObject : ( ( rule__Object__Alternatives ) ) ;
1614 public final void ruleObject() throws RecognitionException {
1615
1616 int stackSize = keepStackSize();
1617
1618 try {
1619 // InternalSolverLanguage.g:541:2: ( ( ( rule__Object__Alternatives ) ) )
1620 // InternalSolverLanguage.g:542:2: ( ( rule__Object__Alternatives ) )
1621 {
1622 // InternalSolverLanguage.g:542:2: ( ( rule__Object__Alternatives ) )
1623 // InternalSolverLanguage.g:543:3: ( rule__Object__Alternatives )
1624 {
1625 before(grammarAccess.getObjectAccess().getAlternatives());
1626 // InternalSolverLanguage.g:544:3: ( rule__Object__Alternatives )
1627 // InternalSolverLanguage.g:544:4: rule__Object__Alternatives
1628 {
1629 pushFollow(FOLLOW_2);
1630 rule__Object__Alternatives();
1631
1632 state._fsp--;
1633
1634
1635 }
1636
1637 after(grammarAccess.getObjectAccess().getAlternatives());
1638
1639 }
1640
1641
1642 }
1643
1644 }
1645 catch (RecognitionException re) {
1646 reportError(re);
1647 recover(input,re);
1648 }
1649 finally {
1650
1651 restoreStackSize(stackSize);
1652
1653 }
1654 return ;
1655 }
1656 // $ANTLR end "ruleObject"
1657
1658
1659 // $ANTLR start "entryRuleNamedObject"
1660 // InternalSolverLanguage.g:553:1: entryRuleNamedObject : ruleNamedObject EOF ;
1661 public final void entryRuleNamedObject() throws RecognitionException {
1662 try {
1663 // InternalSolverLanguage.g:554:1: ( ruleNamedObject EOF )
1664 // InternalSolverLanguage.g:555:1: ruleNamedObject EOF
1665 {
1666 before(grammarAccess.getNamedObjectRule());
1667 pushFollow(FOLLOW_1);
1668 ruleNamedObject();
1669
1670 state._fsp--;
1671
1672 after(grammarAccess.getNamedObjectRule());
1673 match(input,EOF,FOLLOW_2);
1674
1675 }
1676
1677 }
1678 catch (RecognitionException re) {
1679 reportError(re);
1680 recover(input,re);
1681 }
1682 finally {
1683 }
1684 return ;
1685 }
1686 // $ANTLR end "entryRuleNamedObject"
1687
1688
1689 // $ANTLR start "ruleNamedObject"
1690 // InternalSolverLanguage.g:562:1: ruleNamedObject : ( ( rule__NamedObject__Group__0 ) ) ;
1691 public final void ruleNamedObject() throws RecognitionException {
1692
1693 int stackSize = keepStackSize();
1694
1695 try {
1696 // InternalSolverLanguage.g:566:2: ( ( ( rule__NamedObject__Group__0 ) ) )
1697 // InternalSolverLanguage.g:567:2: ( ( rule__NamedObject__Group__0 ) )
1698 {
1699 // InternalSolverLanguage.g:567:2: ( ( rule__NamedObject__Group__0 ) )
1700 // InternalSolverLanguage.g:568:3: ( rule__NamedObject__Group__0 )
1701 {
1702 before(grammarAccess.getNamedObjectAccess().getGroup());
1703 // InternalSolverLanguage.g:569:3: ( rule__NamedObject__Group__0 )
1704 // InternalSolverLanguage.g:569:4: rule__NamedObject__Group__0
1705 {
1706 pushFollow(FOLLOW_2);
1707 rule__NamedObject__Group__0();
1708
1709 state._fsp--;
1710
1711
1712 }
1713
1714 after(grammarAccess.getNamedObjectAccess().getGroup());
1715
1716 }
1717
1718
1719 }
1720
1721 }
1722 catch (RecognitionException re) {
1723 reportError(re);
1724 recover(input,re);
1725 }
1726 finally {
1727
1728 restoreStackSize(stackSize);
1729
1730 }
1731 return ;
1732 }
1733 // $ANTLR end "ruleNamedObject"
1734
1735
1736 // $ANTLR start "entryRuleUnnamedObject"
1737 // InternalSolverLanguage.g:578:1: entryRuleUnnamedObject : ruleUnnamedObject EOF ;
1738 public final void entryRuleUnnamedObject() throws RecognitionException {
1739 try {
1740 // InternalSolverLanguage.g:579:1: ( ruleUnnamedObject EOF )
1741 // InternalSolverLanguage.g:580:1: ruleUnnamedObject EOF
1742 {
1743 before(grammarAccess.getUnnamedObjectRule());
1744 pushFollow(FOLLOW_1);
1745 ruleUnnamedObject();
1746
1747 state._fsp--;
1748
1749 after(grammarAccess.getUnnamedObjectRule());
1750 match(input,EOF,FOLLOW_2);
1751
1752 }
1753
1754 }
1755 catch (RecognitionException re) {
1756 reportError(re);
1757 recover(input,re);
1758 }
1759 finally {
1760 }
1761 return ;
1762 }
1763 // $ANTLR end "entryRuleUnnamedObject"
1764
1765
1766 // $ANTLR start "ruleUnnamedObject"
1767 // InternalSolverLanguage.g:587:1: ruleUnnamedObject : ( ( rule__UnnamedObject__NameAssignment ) ) ;
1768 public final void ruleUnnamedObject() throws RecognitionException {
1769
1770 int stackSize = keepStackSize();
1771
1772 try {
1773 // InternalSolverLanguage.g:591:2: ( ( ( rule__UnnamedObject__NameAssignment ) ) )
1774 // InternalSolverLanguage.g:592:2: ( ( rule__UnnamedObject__NameAssignment ) )
1775 {
1776 // InternalSolverLanguage.g:592:2: ( ( rule__UnnamedObject__NameAssignment ) )
1777 // InternalSolverLanguage.g:593:3: ( rule__UnnamedObject__NameAssignment )
1778 {
1779 before(grammarAccess.getUnnamedObjectAccess().getNameAssignment());
1780 // InternalSolverLanguage.g:594:3: ( rule__UnnamedObject__NameAssignment )
1781 // InternalSolverLanguage.g:594:4: rule__UnnamedObject__NameAssignment
1782 {
1783 pushFollow(FOLLOW_2);
1784 rule__UnnamedObject__NameAssignment();
1785
1786 state._fsp--;
1787
1788
1789 }
1790
1791 after(grammarAccess.getUnnamedObjectAccess().getNameAssignment());
1792
1793 }
1794
1795
1796 }
1797
1798 }
1799 catch (RecognitionException re) {
1800 reportError(re);
1801 recover(input,re);
1802 }
1803 finally {
1804
1805 restoreStackSize(stackSize);
1806
1807 }
1808 return ;
1809 }
1810 // $ANTLR end "ruleUnnamedObject"
1811
1812
1813 // $ANTLR start "entryRuleDataObject"
1814 // InternalSolverLanguage.g:603:1: entryRuleDataObject : ruleDataObject EOF ;
1815 public final void entryRuleDataObject() throws RecognitionException {
1816 try {
1817 // InternalSolverLanguage.g:604:1: ( ruleDataObject EOF )
1818 // InternalSolverLanguage.g:605:1: ruleDataObject EOF
1819 {
1820 before(grammarAccess.getDataObjectRule());
1821 pushFollow(FOLLOW_1);
1822 ruleDataObject();
1823
1824 state._fsp--;
1825
1826 after(grammarAccess.getDataObjectRule());
1827 match(input,EOF,FOLLOW_2);
1828
1829 }
1830
1831 }
1832 catch (RecognitionException re) {
1833 reportError(re);
1834 recover(input,re);
1835 }
1836 finally {
1837 }
1838 return ;
1839 }
1840 // $ANTLR end "entryRuleDataObject"
1841
1842
1843 // $ANTLR start "ruleDataObject"
1844 // InternalSolverLanguage.g:612:1: ruleDataObject : ( ( rule__DataObject__Alternatives ) ) ;
1845 public final void ruleDataObject() throws RecognitionException {
1846
1847 int stackSize = keepStackSize();
1848
1849 try {
1850 // InternalSolverLanguage.g:616:2: ( ( ( rule__DataObject__Alternatives ) ) )
1851 // InternalSolverLanguage.g:617:2: ( ( rule__DataObject__Alternatives ) )
1852 {
1853 // InternalSolverLanguage.g:617:2: ( ( rule__DataObject__Alternatives ) )
1854 // InternalSolverLanguage.g:618:3: ( rule__DataObject__Alternatives )
1855 {
1856 before(grammarAccess.getDataObjectAccess().getAlternatives());
1857 // InternalSolverLanguage.g:619:3: ( rule__DataObject__Alternatives )
1858 // InternalSolverLanguage.g:619:4: rule__DataObject__Alternatives
1859 {
1860 pushFollow(FOLLOW_2);
1861 rule__DataObject__Alternatives();
1862
1863 state._fsp--;
1864
1865
1866 }
1867
1868 after(grammarAccess.getDataObjectAccess().getAlternatives());
1869
1870 }
1871
1872
1873 }
1874
1875 }
1876 catch (RecognitionException re) {
1877 reportError(re);
1878 recover(input,re);
1879 }
1880 finally {
1881
1882 restoreStackSize(stackSize);
1883
1884 }
1885 return ;
1886 }
1887 // $ANTLR end "ruleDataObject"
1888
1889
1890 // $ANTLR start "entryRuleBooleanObject"
1891 // InternalSolverLanguage.g:628:1: entryRuleBooleanObject : ruleBooleanObject EOF ;
1892 public final void entryRuleBooleanObject() throws RecognitionException {
1893 try {
1894 // InternalSolverLanguage.g:629:1: ( ruleBooleanObject EOF )
1895 // InternalSolverLanguage.g:630:1: ruleBooleanObject EOF
1896 {
1897 before(grammarAccess.getBooleanObjectRule());
1898 pushFollow(FOLLOW_1);
1899 ruleBooleanObject();
1900
1901 state._fsp--;
1902
1903 after(grammarAccess.getBooleanObjectRule());
1904 match(input,EOF,FOLLOW_2);
1905
1906 }
1907
1908 }
1909 catch (RecognitionException re) {
1910 reportError(re);
1911 recover(input,re);
1912 }
1913 finally {
1914 }
1915 return ;
1916 }
1917 // $ANTLR end "entryRuleBooleanObject"
1918
1919
1920 // $ANTLR start "ruleBooleanObject"
1921 // InternalSolverLanguage.g:637:1: ruleBooleanObject : ( ( rule__BooleanObject__ValueAssignment ) ) ;
1922 public final void ruleBooleanObject() throws RecognitionException {
1923
1924 int stackSize = keepStackSize();
1925
1926 try {
1927 // InternalSolverLanguage.g:641:2: ( ( ( rule__BooleanObject__ValueAssignment ) ) )
1928 // InternalSolverLanguage.g:642:2: ( ( rule__BooleanObject__ValueAssignment ) )
1929 {
1930 // InternalSolverLanguage.g:642:2: ( ( rule__BooleanObject__ValueAssignment ) )
1931 // InternalSolverLanguage.g:643:3: ( rule__BooleanObject__ValueAssignment )
1932 {
1933 before(grammarAccess.getBooleanObjectAccess().getValueAssignment());
1934 // InternalSolverLanguage.g:644:3: ( rule__BooleanObject__ValueAssignment )
1935 // InternalSolverLanguage.g:644:4: rule__BooleanObject__ValueAssignment
1936 {
1937 pushFollow(FOLLOW_2);
1938 rule__BooleanObject__ValueAssignment();
1939
1940 state._fsp--;
1941
1942
1943 }
1944
1945 after(grammarAccess.getBooleanObjectAccess().getValueAssignment());
1946
1947 }
1948
1949
1950 }
1951
1952 }
1953 catch (RecognitionException re) {
1954 reportError(re);
1955 recover(input,re);
1956 }
1957 finally {
1958
1959 restoreStackSize(stackSize);
1960
1961 }
1962 return ;
1963 }
1964 // $ANTLR end "ruleBooleanObject"
1965
1966
1967 // $ANTLR start "entryRuleIntObject"
1968 // InternalSolverLanguage.g:653:1: entryRuleIntObject : ruleIntObject EOF ;
1969 public final void entryRuleIntObject() throws RecognitionException {
1970 try {
1971 // InternalSolverLanguage.g:654:1: ( ruleIntObject EOF )
1972 // InternalSolverLanguage.g:655:1: ruleIntObject EOF
1973 {
1974 before(grammarAccess.getIntObjectRule());
1975 pushFollow(FOLLOW_1);
1976 ruleIntObject();
1977
1978 state._fsp--;
1979
1980 after(grammarAccess.getIntObjectRule());
1981 match(input,EOF,FOLLOW_2);
1982
1983 }
1984
1985 }
1986 catch (RecognitionException re) {
1987 reportError(re);
1988 recover(input,re);
1989 }
1990 finally {
1991 }
1992 return ;
1993 }
1994 // $ANTLR end "entryRuleIntObject"
1995
1996
1997 // $ANTLR start "ruleIntObject"
1998 // InternalSolverLanguage.g:662:1: ruleIntObject : ( ( rule__IntObject__ValueAssignment ) ) ;
1999 public final void ruleIntObject() throws RecognitionException {
2000
2001 int stackSize = keepStackSize();
2002
2003 try {
2004 // InternalSolverLanguage.g:666:2: ( ( ( rule__IntObject__ValueAssignment ) ) )
2005 // InternalSolverLanguage.g:667:2: ( ( rule__IntObject__ValueAssignment ) )
2006 {
2007 // InternalSolverLanguage.g:667:2: ( ( rule__IntObject__ValueAssignment ) )
2008 // InternalSolverLanguage.g:668:3: ( rule__IntObject__ValueAssignment )
2009 {
2010 before(grammarAccess.getIntObjectAccess().getValueAssignment());
2011 // InternalSolverLanguage.g:669:3: ( rule__IntObject__ValueAssignment )
2012 // InternalSolverLanguage.g:669:4: rule__IntObject__ValueAssignment
2013 {
2014 pushFollow(FOLLOW_2);
2015 rule__IntObject__ValueAssignment();
2016
2017 state._fsp--;
2018
2019
2020 }
2021
2022 after(grammarAccess.getIntObjectAccess().getValueAssignment());
2023
2024 }
2025
2026
2027 }
2028
2029 }
2030 catch (RecognitionException re) {
2031 reportError(re);
2032 recover(input,re);
2033 }
2034 finally {
2035
2036 restoreStackSize(stackSize);
2037
2038 }
2039 return ;
2040 }
2041 // $ANTLR end "ruleIntObject"
2042
2043
2044 // $ANTLR start "entryRuleRealObject"
2045 // InternalSolverLanguage.g:678:1: entryRuleRealObject : ruleRealObject EOF ;
2046 public final void entryRuleRealObject() throws RecognitionException {
2047 try {
2048 // InternalSolverLanguage.g:679:1: ( ruleRealObject EOF )
2049 // InternalSolverLanguage.g:680:1: ruleRealObject EOF
2050 {
2051 before(grammarAccess.getRealObjectRule());
2052 pushFollow(FOLLOW_1);
2053 ruleRealObject();
2054
2055 state._fsp--;
2056
2057 after(grammarAccess.getRealObjectRule());
2058 match(input,EOF,FOLLOW_2);
2059
2060 }
2061
2062 }
2063 catch (RecognitionException re) {
2064 reportError(re);
2065 recover(input,re);
2066 }
2067 finally {
2068 }
2069 return ;
2070 }
2071 // $ANTLR end "entryRuleRealObject"
2072
2073
2074 // $ANTLR start "ruleRealObject"
2075 // InternalSolverLanguage.g:687:1: ruleRealObject : ( ( rule__RealObject__ValueAssignment ) ) ;
2076 public final void ruleRealObject() throws RecognitionException {
2077
2078 int stackSize = keepStackSize();
2079
2080 try {
2081 // InternalSolverLanguage.g:691:2: ( ( ( rule__RealObject__ValueAssignment ) ) )
2082 // InternalSolverLanguage.g:692:2: ( ( rule__RealObject__ValueAssignment ) )
2083 {
2084 // InternalSolverLanguage.g:692:2: ( ( rule__RealObject__ValueAssignment ) )
2085 // InternalSolverLanguage.g:693:3: ( rule__RealObject__ValueAssignment )
2086 {
2087 before(grammarAccess.getRealObjectAccess().getValueAssignment());
2088 // InternalSolverLanguage.g:694:3: ( rule__RealObject__ValueAssignment )
2089 // InternalSolverLanguage.g:694:4: rule__RealObject__ValueAssignment
2090 {
2091 pushFollow(FOLLOW_2);
2092 rule__RealObject__ValueAssignment();
2093
2094 state._fsp--;
2095
2096
2097 }
2098
2099 after(grammarAccess.getRealObjectAccess().getValueAssignment());
2100
2101 }
2102
2103
2104 }
2105
2106 }
2107 catch (RecognitionException re) {
2108 reportError(re);
2109 recover(input,re);
2110 }
2111 finally {
2112
2113 restoreStackSize(stackSize);
2114
2115 }
2116 return ;
2117 }
2118 // $ANTLR end "ruleRealObject"
2119
2120
2121 // $ANTLR start "entryRuleStringObject"
2122 // InternalSolverLanguage.g:703:1: entryRuleStringObject : ruleStringObject EOF ;
2123 public final void entryRuleStringObject() throws RecognitionException {
2124 try {
2125 // InternalSolverLanguage.g:704:1: ( ruleStringObject EOF )
2126 // InternalSolverLanguage.g:705:1: ruleStringObject EOF
2127 {
2128 before(grammarAccess.getStringObjectRule());
2129 pushFollow(FOLLOW_1);
2130 ruleStringObject();
2131
2132 state._fsp--;
2133
2134 after(grammarAccess.getStringObjectRule());
2135 match(input,EOF,FOLLOW_2);
2136
2137 }
2138
2139 }
2140 catch (RecognitionException re) {
2141 reportError(re);
2142 recover(input,re);
2143 }
2144 finally {
2145 }
2146 return ;
2147 }
2148 // $ANTLR end "entryRuleStringObject"
2149
2150
2151 // $ANTLR start "ruleStringObject"
2152 // InternalSolverLanguage.g:712:1: ruleStringObject : ( ( rule__StringObject__ValueAssignment ) ) ;
2153 public final void ruleStringObject() throws RecognitionException {
2154
2155 int stackSize = keepStackSize();
2156
2157 try {
2158 // InternalSolverLanguage.g:716:2: ( ( ( rule__StringObject__ValueAssignment ) ) )
2159 // InternalSolverLanguage.g:717:2: ( ( rule__StringObject__ValueAssignment ) )
2160 {
2161 // InternalSolverLanguage.g:717:2: ( ( rule__StringObject__ValueAssignment ) )
2162 // InternalSolverLanguage.g:718:3: ( rule__StringObject__ValueAssignment )
2163 {
2164 before(grammarAccess.getStringObjectAccess().getValueAssignment());
2165 // InternalSolverLanguage.g:719:3: ( rule__StringObject__ValueAssignment )
2166 // InternalSolverLanguage.g:719:4: rule__StringObject__ValueAssignment
2167 {
2168 pushFollow(FOLLOW_2);
2169 rule__StringObject__ValueAssignment();
2170
2171 state._fsp--;
2172
2173
2174 }
2175
2176 after(grammarAccess.getStringObjectAccess().getValueAssignment());
2177
2178 }
2179
2180
2181 }
2182
2183 }
2184 catch (RecognitionException re) {
2185 reportError(re);
2186 recover(input,re);
2187 }
2188 finally {
2189
2190 restoreStackSize(stackSize);
2191
2192 }
2193 return ;
2194 }
2195 // $ANTLR end "ruleStringObject"
2196
2197
2198 // $ANTLR start "entryRulePredicate"
2199 // InternalSolverLanguage.g:728:1: entryRulePredicate : rulePredicate EOF ;
2200 public final void entryRulePredicate() throws RecognitionException {
2201 try {
2202 // InternalSolverLanguage.g:729:1: ( rulePredicate EOF )
2203 // InternalSolverLanguage.g:730:1: rulePredicate EOF
2204 {
2205 before(grammarAccess.getPredicateRule());
2206 pushFollow(FOLLOW_1);
2207 rulePredicate();
2208
2209 state._fsp--;
2210
2211 after(grammarAccess.getPredicateRule());
2212 match(input,EOF,FOLLOW_2);
2213
2214 }
2215
2216 }
2217 catch (RecognitionException re) {
2218 reportError(re);
2219 recover(input,re);
2220 }
2221 finally {
2222 }
2223 return ;
2224 }
2225 // $ANTLR end "entryRulePredicate"
2226
2227
2228 // $ANTLR start "rulePredicate"
2229 // InternalSolverLanguage.g:737:1: rulePredicate : ( ( rule__Predicate__Alternatives ) ) ;
2230 public final void rulePredicate() throws RecognitionException {
2231
2232 int stackSize = keepStackSize();
2233
2234 try {
2235 // InternalSolverLanguage.g:741:2: ( ( ( rule__Predicate__Alternatives ) ) )
2236 // InternalSolverLanguage.g:742:2: ( ( rule__Predicate__Alternatives ) )
2237 {
2238 // InternalSolverLanguage.g:742:2: ( ( rule__Predicate__Alternatives ) )
2239 // InternalSolverLanguage.g:743:3: ( rule__Predicate__Alternatives )
2240 {
2241 before(grammarAccess.getPredicateAccess().getAlternatives());
2242 // InternalSolverLanguage.g:744:3: ( rule__Predicate__Alternatives )
2243 // InternalSolverLanguage.g:744:4: rule__Predicate__Alternatives
2244 {
2245 pushFollow(FOLLOW_2);
2246 rule__Predicate__Alternatives();
2247
2248 state._fsp--;
2249
2250
2251 }
2252
2253 after(grammarAccess.getPredicateAccess().getAlternatives());
2254
2255 }
2256
2257
2258 }
2259
2260 }
2261 catch (RecognitionException re) {
2262 reportError(re);
2263 recover(input,re);
2264 }
2265 finally {
2266
2267 restoreStackSize(stackSize);
2268
2269 }
2270 return ;
2271 }
2272 // $ANTLR end "rulePredicate"
2273
2274
2275 // $ANTLR start "entryRulePredicateSymbol"
2276 // InternalSolverLanguage.g:753:1: entryRulePredicateSymbol : rulePredicateSymbol EOF ;
2277 public final void entryRulePredicateSymbol() throws RecognitionException {
2278 try {
2279 // InternalSolverLanguage.g:754:1: ( rulePredicateSymbol EOF )
2280 // InternalSolverLanguage.g:755:1: rulePredicateSymbol EOF
2281 {
2282 before(grammarAccess.getPredicateSymbolRule());
2283 pushFollow(FOLLOW_1);
2284 rulePredicateSymbol();
2285
2286 state._fsp--;
2287
2288 after(grammarAccess.getPredicateSymbolRule());
2289 match(input,EOF,FOLLOW_2);
2290
2291 }
2292
2293 }
2294 catch (RecognitionException re) {
2295 reportError(re);
2296 recover(input,re);
2297 }
2298 finally {
2299 }
2300 return ;
2301 }
2302 // $ANTLR end "entryRulePredicateSymbol"
2303
2304
2305 // $ANTLR start "rulePredicateSymbol"
2306 // InternalSolverLanguage.g:762:1: rulePredicateSymbol : ( ( rule__PredicateSymbol__Group__0 ) ) ;
2307 public final void rulePredicateSymbol() throws RecognitionException {
2308
2309 int stackSize = keepStackSize();
2310
2311 try {
2312 // InternalSolverLanguage.g:766:2: ( ( ( rule__PredicateSymbol__Group__0 ) ) )
2313 // InternalSolverLanguage.g:767:2: ( ( rule__PredicateSymbol__Group__0 ) )
2314 {
2315 // InternalSolverLanguage.g:767:2: ( ( rule__PredicateSymbol__Group__0 ) )
2316 // InternalSolverLanguage.g:768:3: ( rule__PredicateSymbol__Group__0 )
2317 {
2318 before(grammarAccess.getPredicateSymbolAccess().getGroup());
2319 // InternalSolverLanguage.g:769:3: ( rule__PredicateSymbol__Group__0 )
2320 // InternalSolverLanguage.g:769:4: rule__PredicateSymbol__Group__0
2321 {
2322 pushFollow(FOLLOW_2);
2323 rule__PredicateSymbol__Group__0();
2324
2325 state._fsp--;
2326
2327
2328 }
2329
2330 after(grammarAccess.getPredicateSymbolAccess().getGroup());
2331
2332 }
2333
2334
2335 }
2336
2337 }
2338 catch (RecognitionException re) {
2339 reportError(re);
2340 recover(input,re);
2341 }
2342 finally {
2343
2344 restoreStackSize(stackSize);
2345
2346 }
2347 return ;
2348 }
2349 // $ANTLR end "rulePredicateSymbol"
2350
2351
2352 // $ANTLR start "entryRuleErrorPredicate"
2353 // InternalSolverLanguage.g:778:1: entryRuleErrorPredicate : ruleErrorPredicate EOF ;
2354 public final void entryRuleErrorPredicate() throws RecognitionException {
2355 try {
2356 // InternalSolverLanguage.g:779:1: ( ruleErrorPredicate EOF )
2357 // InternalSolverLanguage.g:780:1: ruleErrorPredicate EOF
2358 {
2359 before(grammarAccess.getErrorPredicateRule());
2360 pushFollow(FOLLOW_1);
2361 ruleErrorPredicate();
2362
2363 state._fsp--;
2364
2365 after(grammarAccess.getErrorPredicateRule());
2366 match(input,EOF,FOLLOW_2);
2367
2368 }
2369
2370 }
2371 catch (RecognitionException re) {
2372 reportError(re);
2373 recover(input,re);
2374 }
2375 finally {
2376 }
2377 return ;
2378 }
2379 // $ANTLR end "entryRuleErrorPredicate"
2380
2381
2382 // $ANTLR start "ruleErrorPredicate"
2383 // InternalSolverLanguage.g:787:1: ruleErrorPredicate : ( ( rule__ErrorPredicate__Group__0 ) ) ;
2384 public final void ruleErrorPredicate() throws RecognitionException {
2385
2386 int stackSize = keepStackSize();
2387
2388 try {
2389 // InternalSolverLanguage.g:791:2: ( ( ( rule__ErrorPredicate__Group__0 ) ) )
2390 // InternalSolverLanguage.g:792:2: ( ( rule__ErrorPredicate__Group__0 ) )
2391 {
2392 // InternalSolverLanguage.g:792:2: ( ( rule__ErrorPredicate__Group__0 ) )
2393 // InternalSolverLanguage.g:793:3: ( rule__ErrorPredicate__Group__0 )
2394 {
2395 before(grammarAccess.getErrorPredicateAccess().getGroup());
2396 // InternalSolverLanguage.g:794:3: ( rule__ErrorPredicate__Group__0 )
2397 // InternalSolverLanguage.g:794:4: rule__ErrorPredicate__Group__0
2398 {
2399 pushFollow(FOLLOW_2);
2400 rule__ErrorPredicate__Group__0();
2401
2402 state._fsp--;
2403
2404
2405 }
2406
2407 after(grammarAccess.getErrorPredicateAccess().getGroup());
2408
2409 }
2410
2411
2412 }
2413
2414 }
2415 catch (RecognitionException re) {
2416 reportError(re);
2417 recover(input,re);
2418 }
2419 finally {
2420
2421 restoreStackSize(stackSize);
2422
2423 }
2424 return ;
2425 }
2426 // $ANTLR end "ruleErrorPredicate"
2427
2428
2429 // $ANTLR start "entryRuleParameter"
2430 // InternalSolverLanguage.g:803:1: entryRuleParameter : ruleParameter EOF ;
2431 public final void entryRuleParameter() throws RecognitionException {
2432 try {
2433 // InternalSolverLanguage.g:804:1: ( ruleParameter EOF )
2434 // InternalSolverLanguage.g:805:1: ruleParameter EOF
2435 {
2436 before(grammarAccess.getParameterRule());
2437 pushFollow(FOLLOW_1);
2438 ruleParameter();
2439
2440 state._fsp--;
2441
2442 after(grammarAccess.getParameterRule());
2443 match(input,EOF,FOLLOW_2);
2444
2445 }
2446
2447 }
2448 catch (RecognitionException re) {
2449 reportError(re);
2450 recover(input,re);
2451 }
2452 finally {
2453 }
2454 return ;
2455 }
2456 // $ANTLR end "entryRuleParameter"
2457
2458
2459 // $ANTLR start "ruleParameter"
2460 // InternalSolverLanguage.g:812:1: ruleParameter : ( ( rule__Parameter__Group__0 ) ) ;
2461 public final void ruleParameter() throws RecognitionException {
2462
2463 int stackSize = keepStackSize();
2464
2465 try {
2466 // InternalSolverLanguage.g:816:2: ( ( ( rule__Parameter__Group__0 ) ) )
2467 // InternalSolverLanguage.g:817:2: ( ( rule__Parameter__Group__0 ) )
2468 {
2469 // InternalSolverLanguage.g:817:2: ( ( rule__Parameter__Group__0 ) )
2470 // InternalSolverLanguage.g:818:3: ( rule__Parameter__Group__0 )
2471 {
2472 before(grammarAccess.getParameterAccess().getGroup());
2473 // InternalSolverLanguage.g:819:3: ( rule__Parameter__Group__0 )
2474 // InternalSolverLanguage.g:819:4: rule__Parameter__Group__0
2475 {
2476 pushFollow(FOLLOW_2);
2477 rule__Parameter__Group__0();
2478
2479 state._fsp--;
2480
2481
2482 }
2483
2484 after(grammarAccess.getParameterAccess().getGroup());
2485
2486 }
2487
2488
2489 }
2490
2491 }
2492 catch (RecognitionException re) {
2493 reportError(re);
2494 recover(input,re);
2495 }
2496 finally {
2497
2498 restoreStackSize(stackSize);
2499
2500 }
2501 return ;
2502 }
2503 // $ANTLR end "ruleParameter"
2504
2505
2506 // $ANTLR start "entryRulePatternBody"
2507 // InternalSolverLanguage.g:828:1: entryRulePatternBody : rulePatternBody EOF ;
2508 public final void entryRulePatternBody() throws RecognitionException {
2509 try {
2510 // InternalSolverLanguage.g:829:1: ( rulePatternBody EOF )
2511 // InternalSolverLanguage.g:830:1: rulePatternBody EOF
2512 {
2513 before(grammarAccess.getPatternBodyRule());
2514 pushFollow(FOLLOW_1);
2515 rulePatternBody();
2516
2517 state._fsp--;
2518
2519 after(grammarAccess.getPatternBodyRule());
2520 match(input,EOF,FOLLOW_2);
2521
2522 }
2523
2524 }
2525 catch (RecognitionException re) {
2526 reportError(re);
2527 recover(input,re);
2528 }
2529 finally {
2530 }
2531 return ;
2532 }
2533 // $ANTLR end "entryRulePatternBody"
2534
2535
2536 // $ANTLR start "rulePatternBody"
2537 // InternalSolverLanguage.g:837:1: rulePatternBody : ( ( rule__PatternBody__Group__0 ) ) ;
2538 public final void rulePatternBody() throws RecognitionException {
2539
2540 int stackSize = keepStackSize();
2541
2542 try {
2543 // InternalSolverLanguage.g:841:2: ( ( ( rule__PatternBody__Group__0 ) ) )
2544 // InternalSolverLanguage.g:842:2: ( ( rule__PatternBody__Group__0 ) )
2545 {
2546 // InternalSolverLanguage.g:842:2: ( ( rule__PatternBody__Group__0 ) )
2547 // InternalSolverLanguage.g:843:3: ( rule__PatternBody__Group__0 )
2548 {
2549 before(grammarAccess.getPatternBodyAccess().getGroup());
2550 // InternalSolverLanguage.g:844:3: ( rule__PatternBody__Group__0 )
2551 // InternalSolverLanguage.g:844:4: rule__PatternBody__Group__0
2552 {
2553 pushFollow(FOLLOW_2);
2554 rule__PatternBody__Group__0();
2555
2556 state._fsp--;
2557
2558
2559 }
2560
2561 after(grammarAccess.getPatternBodyAccess().getGroup());
2562
2563 }
2564
2565
2566 }
2567
2568 }
2569 catch (RecognitionException re) {
2570 reportError(re);
2571 recover(input,re);
2572 }
2573 finally {
2574
2575 restoreStackSize(stackSize);
2576
2577 }
2578 return ;
2579 }
2580 // $ANTLR end "rulePatternBody"
2581
2582
2583 // $ANTLR start "entryRulePolarity"
2584 // InternalSolverLanguage.g:853:1: entryRulePolarity : rulePolarity EOF ;
2585 public final void entryRulePolarity() throws RecognitionException {
2586 try {
2587 // InternalSolverLanguage.g:854:1: ( rulePolarity EOF )
2588 // InternalSolverLanguage.g:855:1: rulePolarity EOF
2589 {
2590 before(grammarAccess.getPolarityRule());
2591 pushFollow(FOLLOW_1);
2592 rulePolarity();
2593
2594 state._fsp--;
2595
2596 after(grammarAccess.getPolarityRule());
2597 match(input,EOF,FOLLOW_2);
2598
2599 }
2600
2601 }
2602 catch (RecognitionException re) {
2603 reportError(re);
2604 recover(input,re);
2605 }
2606 finally {
2607 }
2608 return ;
2609 }
2610 // $ANTLR end "entryRulePolarity"
2611
2612
2613 // $ANTLR start "rulePolarity"
2614 // InternalSolverLanguage.g:862:1: rulePolarity : ( ( rule__Polarity__Alternatives ) ) ;
2615 public final void rulePolarity() throws RecognitionException {
2616
2617 int stackSize = keepStackSize();
2618
2619 try {
2620 // InternalSolverLanguage.g:866:2: ( ( ( rule__Polarity__Alternatives ) ) )
2621 // InternalSolverLanguage.g:867:2: ( ( rule__Polarity__Alternatives ) )
2622 {
2623 // InternalSolverLanguage.g:867:2: ( ( rule__Polarity__Alternatives ) )
2624 // InternalSolverLanguage.g:868:3: ( rule__Polarity__Alternatives )
2625 {
2626 before(grammarAccess.getPolarityAccess().getAlternatives());
2627 // InternalSolverLanguage.g:869:3: ( rule__Polarity__Alternatives )
2628 // InternalSolverLanguage.g:869:4: rule__Polarity__Alternatives
2629 {
2630 pushFollow(FOLLOW_2);
2631 rule__Polarity__Alternatives();
2632
2633 state._fsp--;
2634
2635
2636 }
2637
2638 after(grammarAccess.getPolarityAccess().getAlternatives());
2639
2640 }
2641
2642
2643 }
2644
2645 }
2646 catch (RecognitionException re) {
2647 reportError(re);
2648 recover(input,re);
2649 }
2650 finally {
2651
2652 restoreStackSize(stackSize);
2653
2654 }
2655 return ;
2656 }
2657 // $ANTLR end "rulePolarity"
2658
2659
2660 // $ANTLR start "entryRuleConstraint"
2661 // InternalSolverLanguage.g:878:1: entryRuleConstraint : ruleConstraint EOF ;
2662 public final void entryRuleConstraint() throws RecognitionException {
2663 try {
2664 // InternalSolverLanguage.g:879:1: ( ruleConstraint EOF )
2665 // InternalSolverLanguage.g:880:1: ruleConstraint EOF
2666 {
2667 before(grammarAccess.getConstraintRule());
2668 pushFollow(FOLLOW_1);
2669 ruleConstraint();
2670
2671 state._fsp--;
2672
2673 after(grammarAccess.getConstraintRule());
2674 match(input,EOF,FOLLOW_2);
2675
2676 }
2677
2678 }
2679 catch (RecognitionException re) {
2680 reportError(re);
2681 recover(input,re);
2682 }
2683 finally {
2684 }
2685 return ;
2686 }
2687 // $ANTLR end "entryRuleConstraint"
2688
2689
2690 // $ANTLR start "ruleConstraint"
2691 // InternalSolverLanguage.g:887:1: ruleConstraint : ( ( rule__Constraint__Group__0 ) ) ;
2692 public final void ruleConstraint() throws RecognitionException {
2693
2694 int stackSize = keepStackSize();
2695
2696 try {
2697 // InternalSolverLanguage.g:891:2: ( ( ( rule__Constraint__Group__0 ) ) )
2698 // InternalSolverLanguage.g:892:2: ( ( rule__Constraint__Group__0 ) )
2699 {
2700 // InternalSolverLanguage.g:892:2: ( ( rule__Constraint__Group__0 ) )
2701 // InternalSolverLanguage.g:893:3: ( rule__Constraint__Group__0 )
2702 {
2703 before(grammarAccess.getConstraintAccess().getGroup());
2704 // InternalSolverLanguage.g:894:3: ( rule__Constraint__Group__0 )
2705 // InternalSolverLanguage.g:894:4: rule__Constraint__Group__0
2706 {
2707 pushFollow(FOLLOW_2);
2708 rule__Constraint__Group__0();
2709
2710 state._fsp--;
2711
2712
2713 }
2714
2715 after(grammarAccess.getConstraintAccess().getGroup());
2716
2717 }
2718
2719
2720 }
2721
2722 }
2723 catch (RecognitionException re) {
2724 reportError(re);
2725 recover(input,re);
2726 }
2727 finally {
2728
2729 restoreStackSize(stackSize);
2730
2731 }
2732 return ;
2733 }
2734 // $ANTLR end "ruleConstraint"
2735
2736
2737 // $ANTLR start "entryRuleClosureType"
2738 // InternalSolverLanguage.g:903:1: entryRuleClosureType : ruleClosureType EOF ;
2739 public final void entryRuleClosureType() throws RecognitionException {
2740 try {
2741 // InternalSolverLanguage.g:904:1: ( ruleClosureType EOF )
2742 // InternalSolverLanguage.g:905:1: ruleClosureType EOF
2743 {
2744 before(grammarAccess.getClosureTypeRule());
2745 pushFollow(FOLLOW_1);
2746 ruleClosureType();
2747
2748 state._fsp--;
2749
2750 after(grammarAccess.getClosureTypeRule());
2751 match(input,EOF,FOLLOW_2);
2752
2753 }
2754
2755 }
2756 catch (RecognitionException re) {
2757 reportError(re);
2758 recover(input,re);
2759 }
2760 finally {
2761 }
2762 return ;
2763 }
2764 // $ANTLR end "entryRuleClosureType"
2765
2766
2767 // $ANTLR start "ruleClosureType"
2768 // InternalSolverLanguage.g:912:1: ruleClosureType : ( ( rule__ClosureType__Alternatives ) ) ;
2769 public final void ruleClosureType() throws RecognitionException {
2770
2771 int stackSize = keepStackSize();
2772
2773 try {
2774 // InternalSolverLanguage.g:916:2: ( ( ( rule__ClosureType__Alternatives ) ) )
2775 // InternalSolverLanguage.g:917:2: ( ( rule__ClosureType__Alternatives ) )
2776 {
2777 // InternalSolverLanguage.g:917:2: ( ( rule__ClosureType__Alternatives ) )
2778 // InternalSolverLanguage.g:918:3: ( rule__ClosureType__Alternatives )
2779 {
2780 before(grammarAccess.getClosureTypeAccess().getAlternatives());
2781 // InternalSolverLanguage.g:919:3: ( rule__ClosureType__Alternatives )
2782 // InternalSolverLanguage.g:919:4: rule__ClosureType__Alternatives
2783 {
2784 pushFollow(FOLLOW_2);
2785 rule__ClosureType__Alternatives();
2786
2787 state._fsp--;
2788
2789
2790 }
2791
2792 after(grammarAccess.getClosureTypeAccess().getAlternatives());
2793
2794 }
2795
2796
2797 }
2798
2799 }
2800 catch (RecognitionException re) {
2801 reportError(re);
2802 recover(input,re);
2803 }
2804 finally {
2805
2806 restoreStackSize(stackSize);
2807
2808 }
2809 return ;
2810 }
2811 // $ANTLR end "ruleClosureType"
2812
2813
2814 // $ANTLR start "entryRuleLiteral"
2815 // InternalSolverLanguage.g:928:1: entryRuleLiteral : ruleLiteral EOF ;
2816 public final void entryRuleLiteral() throws RecognitionException {
2817 try {
2818 // InternalSolverLanguage.g:929:1: ( ruleLiteral EOF )
2819 // InternalSolverLanguage.g:930:1: ruleLiteral EOF
2820 {
2821 before(grammarAccess.getLiteralRule());
2822 pushFollow(FOLLOW_1);
2823 ruleLiteral();
2824
2825 state._fsp--;
2826
2827 after(grammarAccess.getLiteralRule());
2828 match(input,EOF,FOLLOW_2);
2829
2830 }
2831
2832 }
2833 catch (RecognitionException re) {
2834 reportError(re);
2835 recover(input,re);
2836 }
2837 finally {
2838 }
2839 return ;
2840 }
2841 // $ANTLR end "entryRuleLiteral"
2842
2843
2844 // $ANTLR start "ruleLiteral"
2845 // InternalSolverLanguage.g:937:1: ruleLiteral : ( ( rule__Literal__Alternatives ) ) ;
2846 public final void ruleLiteral() throws RecognitionException {
2847
2848 int stackSize = keepStackSize();
2849
2850 try {
2851 // InternalSolverLanguage.g:941:2: ( ( ( rule__Literal__Alternatives ) ) )
2852 // InternalSolverLanguage.g:942:2: ( ( rule__Literal__Alternatives ) )
2853 {
2854 // InternalSolverLanguage.g:942:2: ( ( rule__Literal__Alternatives ) )
2855 // InternalSolverLanguage.g:943:3: ( rule__Literal__Alternatives )
2856 {
2857 before(grammarAccess.getLiteralAccess().getAlternatives());
2858 // InternalSolverLanguage.g:944:3: ( rule__Literal__Alternatives )
2859 // InternalSolverLanguage.g:944:4: rule__Literal__Alternatives
2860 {
2861 pushFollow(FOLLOW_2);
2862 rule__Literal__Alternatives();
2863
2864 state._fsp--;
2865
2866
2867 }
2868
2869 after(grammarAccess.getLiteralAccess().getAlternatives());
2870
2871 }
2872
2873
2874 }
2875
2876 }
2877 catch (RecognitionException re) {
2878 reportError(re);
2879 recover(input,re);
2880 }
2881 finally {
2882
2883 restoreStackSize(stackSize);
2884
2885 }
2886 return ;
2887 }
2888 // $ANTLR end "ruleLiteral"
2889
2890
2891 // $ANTLR start "entryRuleVariable"
2892 // InternalSolverLanguage.g:953:1: entryRuleVariable : ruleVariable EOF ;
2893 public final void entryRuleVariable() throws RecognitionException {
2894 try {
2895 // InternalSolverLanguage.g:954:1: ( ruleVariable EOF )
2896 // InternalSolverLanguage.g:955:1: ruleVariable EOF
2897 {
2898 before(grammarAccess.getVariableRule());
2899 pushFollow(FOLLOW_1);
2900 ruleVariable();
2901
2902 state._fsp--;
2903
2904 after(grammarAccess.getVariableRule());
2905 match(input,EOF,FOLLOW_2);
2906
2907 }
2908
2909 }
2910 catch (RecognitionException re) {
2911 reportError(re);
2912 recover(input,re);
2913 }
2914 finally {
2915 }
2916 return ;
2917 }
2918 // $ANTLR end "entryRuleVariable"
2919
2920
2921 // $ANTLR start "ruleVariable"
2922 // InternalSolverLanguage.g:962:1: ruleVariable : ( ( rule__Variable__NameAssignment ) ) ;
2923 public final void ruleVariable() throws RecognitionException {
2924
2925 int stackSize = keepStackSize();
2926
2927 try {
2928 // InternalSolverLanguage.g:966:2: ( ( ( rule__Variable__NameAssignment ) ) )
2929 // InternalSolverLanguage.g:967:2: ( ( rule__Variable__NameAssignment ) )
2930 {
2931 // InternalSolverLanguage.g:967:2: ( ( rule__Variable__NameAssignment ) )
2932 // InternalSolverLanguage.g:968:3: ( rule__Variable__NameAssignment )
2933 {
2934 before(grammarAccess.getVariableAccess().getNameAssignment());
2935 // InternalSolverLanguage.g:969:3: ( rule__Variable__NameAssignment )
2936 // InternalSolverLanguage.g:969:4: rule__Variable__NameAssignment
2937 {
2938 pushFollow(FOLLOW_2);
2939 rule__Variable__NameAssignment();
2940
2941 state._fsp--;
2942
2943
2944 }
2945
2946 after(grammarAccess.getVariableAccess().getNameAssignment());
2947
2948 }
2949
2950
2951 }
2952
2953 }
2954 catch (RecognitionException re) {
2955 reportError(re);
2956 recover(input,re);
2957 }
2958 finally {
2959
2960 restoreStackSize(stackSize);
2961
2962 }
2963 return ;
2964 }
2965 // $ANTLR end "ruleVariable"
2966
2967
2968 // $ANTLR start "entryRuleAllInstances"
2969 // InternalSolverLanguage.g:978:1: entryRuleAllInstances : ruleAllInstances EOF ;
2970 public final void entryRuleAllInstances() throws RecognitionException {
2971 try {
2972 // InternalSolverLanguage.g:979:1: ( ruleAllInstances EOF )
2973 // InternalSolverLanguage.g:980:1: ruleAllInstances EOF
2974 {
2975 before(grammarAccess.getAllInstancesRule());
2976 pushFollow(FOLLOW_1);
2977 ruleAllInstances();
2978
2979 state._fsp--;
2980
2981 after(grammarAccess.getAllInstancesRule());
2982 match(input,EOF,FOLLOW_2);
2983
2984 }
2985
2986 }
2987 catch (RecognitionException re) {
2988 reportError(re);
2989 recover(input,re);
2990 }
2991 finally {
2992 }
2993 return ;
2994 }
2995 // $ANTLR end "entryRuleAllInstances"
2996
2997
2998 // $ANTLR start "ruleAllInstances"
2999 // InternalSolverLanguage.g:987:1: ruleAllInstances : ( ( rule__AllInstances__Group__0 ) ) ;
3000 public final void ruleAllInstances() throws RecognitionException {
3001
3002 int stackSize = keepStackSize();
3003
3004 try {
3005 // InternalSolverLanguage.g:991:2: ( ( ( rule__AllInstances__Group__0 ) ) )
3006 // InternalSolverLanguage.g:992:2: ( ( rule__AllInstances__Group__0 ) )
3007 {
3008 // InternalSolverLanguage.g:992:2: ( ( rule__AllInstances__Group__0 ) )
3009 // InternalSolverLanguage.g:993:3: ( rule__AllInstances__Group__0 )
3010 {
3011 before(grammarAccess.getAllInstancesAccess().getGroup());
3012 // InternalSolverLanguage.g:994:3: ( rule__AllInstances__Group__0 )
3013 // InternalSolverLanguage.g:994:4: rule__AllInstances__Group__0
3014 {
3015 pushFollow(FOLLOW_2);
3016 rule__AllInstances__Group__0();
3017
3018 state._fsp--;
3019
3020
3021 }
3022
3023 after(grammarAccess.getAllInstancesAccess().getGroup());
3024
3025 }
3026
3027
3028 }
3029
3030 }
3031 catch (RecognitionException re) {
3032 reportError(re);
3033 recover(input,re);
3034 }
3035 finally {
3036
3037 restoreStackSize(stackSize);
3038
3039 }
3040 return ;
3041 }
3042 // $ANTLR end "ruleAllInstances"
3043
3044
3045 // $ANTLR start "entryRuleAllObjects"
3046 // InternalSolverLanguage.g:1003:1: entryRuleAllObjects : ruleAllObjects EOF ;
3047 public final void entryRuleAllObjects() throws RecognitionException {
3048 try {
3049 // InternalSolverLanguage.g:1004:1: ( ruleAllObjects EOF )
3050 // InternalSolverLanguage.g:1005:1: ruleAllObjects EOF
3051 {
3052 before(grammarAccess.getAllObjectsRule());
3053 pushFollow(FOLLOW_1);
3054 ruleAllObjects();
3055
3056 state._fsp--;
3057
3058 after(grammarAccess.getAllObjectsRule());
3059 match(input,EOF,FOLLOW_2);
3060
3061 }
3062
3063 }
3064 catch (RecognitionException re) {
3065 reportError(re);
3066 recover(input,re);
3067 }
3068 finally {
3069 }
3070 return ;
3071 }
3072 // $ANTLR end "entryRuleAllObjects"
3073
3074
3075 // $ANTLR start "ruleAllObjects"
3076 // InternalSolverLanguage.g:1012:1: ruleAllObjects : ( ( rule__AllObjects__Group__0 ) ) ;
3077 public final void ruleAllObjects() throws RecognitionException {
3078
3079 int stackSize = keepStackSize();
3080
3081 try {
3082 // InternalSolverLanguage.g:1016:2: ( ( ( rule__AllObjects__Group__0 ) ) )
3083 // InternalSolverLanguage.g:1017:2: ( ( rule__AllObjects__Group__0 ) )
3084 {
3085 // InternalSolverLanguage.g:1017:2: ( ( rule__AllObjects__Group__0 ) )
3086 // InternalSolverLanguage.g:1018:3: ( rule__AllObjects__Group__0 )
3087 {
3088 before(grammarAccess.getAllObjectsAccess().getGroup());
3089 // InternalSolverLanguage.g:1019:3: ( rule__AllObjects__Group__0 )
3090 // InternalSolverLanguage.g:1019:4: rule__AllObjects__Group__0
3091 {
3092 pushFollow(FOLLOW_2);
3093 rule__AllObjects__Group__0();
3094
3095 state._fsp--;
3096
3097
3098 }
3099
3100 after(grammarAccess.getAllObjectsAccess().getGroup());
3101
3102 }
3103
3104
3105 }
3106
3107 }
3108 catch (RecognitionException re) {
3109 reportError(re);
3110 recover(input,re);
3111 }
3112 finally {
3113
3114 restoreStackSize(stackSize);
3115
3116 }
3117 return ;
3118 }
3119 // $ANTLR end "ruleAllObjects"
3120
3121
3122 // $ANTLR start "entryRuleDefaultInterpretation"
3123 // InternalSolverLanguage.g:1028:1: entryRuleDefaultInterpretation : ruleDefaultInterpretation EOF ;
3124 public final void entryRuleDefaultInterpretation() throws RecognitionException {
3125 try {
3126 // InternalSolverLanguage.g:1029:1: ( ruleDefaultInterpretation EOF )
3127 // InternalSolverLanguage.g:1030:1: ruleDefaultInterpretation EOF
3128 {
3129 before(grammarAccess.getDefaultInterpretationRule());
3130 pushFollow(FOLLOW_1);
3131 ruleDefaultInterpretation();
3132
3133 state._fsp--;
3134
3135 after(grammarAccess.getDefaultInterpretationRule());
3136 match(input,EOF,FOLLOW_2);
3137
3138 }
3139
3140 }
3141 catch (RecognitionException re) {
3142 reportError(re);
3143 recover(input,re);
3144 }
3145 finally {
3146 }
3147 return ;
3148 }
3149 // $ANTLR end "entryRuleDefaultInterpretation"
3150
3151
3152 // $ANTLR start "ruleDefaultInterpretation"
3153 // InternalSolverLanguage.g:1037:1: ruleDefaultInterpretation : ( ( rule__DefaultInterpretation__Group__0 ) ) ;
3154 public final void ruleDefaultInterpretation() throws RecognitionException {
3155
3156 int stackSize = keepStackSize();
3157
3158 try {
3159 // InternalSolverLanguage.g:1041:2: ( ( ( rule__DefaultInterpretation__Group__0 ) ) )
3160 // InternalSolverLanguage.g:1042:2: ( ( rule__DefaultInterpretation__Group__0 ) )
3161 {
3162 // InternalSolverLanguage.g:1042:2: ( ( rule__DefaultInterpretation__Group__0 ) )
3163 // InternalSolverLanguage.g:1043:3: ( rule__DefaultInterpretation__Group__0 )
3164 {
3165 before(grammarAccess.getDefaultInterpretationAccess().getGroup());
3166 // InternalSolverLanguage.g:1044:3: ( rule__DefaultInterpretation__Group__0 )
3167 // InternalSolverLanguage.g:1044:4: rule__DefaultInterpretation__Group__0
3168 {
3169 pushFollow(FOLLOW_2);
3170 rule__DefaultInterpretation__Group__0();
3171
3172 state._fsp--;
3173
3174
3175 }
3176
3177 after(grammarAccess.getDefaultInterpretationAccess().getGroup());
3178
3179 }
3180
3181
3182 }
3183
3184 }
3185 catch (RecognitionException re) {
3186 reportError(re);
3187 recover(input,re);
3188 }
3189 finally {
3190
3191 restoreStackSize(stackSize);
3192
3193 }
3194 return ;
3195 }
3196 // $ANTLR end "ruleDefaultInterpretation"
3197
3198
3199 // $ANTLR start "entryRuleCDInterpretation"
3200 // InternalSolverLanguage.g:1053:1: entryRuleCDInterpretation : ruleCDInterpretation EOF ;
3201 public final void entryRuleCDInterpretation() throws RecognitionException {
3202 try {
3203 // InternalSolverLanguage.g:1054:1: ( ruleCDInterpretation EOF )
3204 // InternalSolverLanguage.g:1055:1: ruleCDInterpretation EOF
3205 {
3206 before(grammarAccess.getCDInterpretationRule());
3207 pushFollow(FOLLOW_1);
3208 ruleCDInterpretation();
3209
3210 state._fsp--;
3211
3212 after(grammarAccess.getCDInterpretationRule());
3213 match(input,EOF,FOLLOW_2);
3214
3215 }
3216
3217 }
3218 catch (RecognitionException re) {
3219 reportError(re);
3220 recover(input,re);
3221 }
3222 finally {
3223 }
3224 return ;
3225 }
3226 // $ANTLR end "entryRuleCDInterpretation"
3227
3228
3229 // $ANTLR start "ruleCDInterpretation"
3230 // InternalSolverLanguage.g:1062:1: ruleCDInterpretation : ( ( rule__CDInterpretation__Alternatives ) ) ;
3231 public final void ruleCDInterpretation() throws RecognitionException {
3232
3233 int stackSize = keepStackSize();
3234
3235 try {
3236 // InternalSolverLanguage.g:1066:2: ( ( ( rule__CDInterpretation__Alternatives ) ) )
3237 // InternalSolverLanguage.g:1067:2: ( ( rule__CDInterpretation__Alternatives ) )
3238 {
3239 // InternalSolverLanguage.g:1067:2: ( ( rule__CDInterpretation__Alternatives ) )
3240 // InternalSolverLanguage.g:1068:3: ( rule__CDInterpretation__Alternatives )
3241 {
3242 before(grammarAccess.getCDInterpretationAccess().getAlternatives());
3243 // InternalSolverLanguage.g:1069:3: ( rule__CDInterpretation__Alternatives )
3244 // InternalSolverLanguage.g:1069:4: rule__CDInterpretation__Alternatives
3245 {
3246 pushFollow(FOLLOW_2);
3247 rule__CDInterpretation__Alternatives();
3248
3249 state._fsp--;
3250
3251
3252 }
3253
3254 after(grammarAccess.getCDInterpretationAccess().getAlternatives());
3255
3256 }
3257
3258
3259 }
3260
3261 }
3262 catch (RecognitionException re) {
3263 reportError(re);
3264 recover(input,re);
3265 }
3266 finally {
3267
3268 restoreStackSize(stackSize);
3269
3270 }
3271 return ;
3272 }
3273 // $ANTLR end "ruleCDInterpretation"
3274
3275
3276 // $ANTLR start "entryRuleClassInterpretation"
3277 // InternalSolverLanguage.g:1078:1: entryRuleClassInterpretation : ruleClassInterpretation EOF ;
3278 public final void entryRuleClassInterpretation() throws RecognitionException {
3279 try {
3280 // InternalSolverLanguage.g:1079:1: ( ruleClassInterpretation EOF )
3281 // InternalSolverLanguage.g:1080:1: ruleClassInterpretation EOF
3282 {
3283 before(grammarAccess.getClassInterpretationRule());
3284 pushFollow(FOLLOW_1);
3285 ruleClassInterpretation();
3286
3287 state._fsp--;
3288
3289 after(grammarAccess.getClassInterpretationRule());
3290 match(input,EOF,FOLLOW_2);
3291
3292 }
3293
3294 }
3295 catch (RecognitionException re) {
3296 reportError(re);
3297 recover(input,re);
3298 }
3299 finally {
3300 }
3301 return ;
3302 }
3303 // $ANTLR end "entryRuleClassInterpretation"
3304
3305
3306 // $ANTLR start "ruleClassInterpretation"
3307 // InternalSolverLanguage.g:1087:1: ruleClassInterpretation : ( ( rule__ClassInterpretation__Group__0 ) ) ;
3308 public final void ruleClassInterpretation() throws RecognitionException {
3309
3310 int stackSize = keepStackSize();
3311
3312 try {
3313 // InternalSolverLanguage.g:1091:2: ( ( ( rule__ClassInterpretation__Group__0 ) ) )
3314 // InternalSolverLanguage.g:1092:2: ( ( rule__ClassInterpretation__Group__0 ) )
3315 {
3316 // InternalSolverLanguage.g:1092:2: ( ( rule__ClassInterpretation__Group__0 ) )
3317 // InternalSolverLanguage.g:1093:3: ( rule__ClassInterpretation__Group__0 )
3318 {
3319 before(grammarAccess.getClassInterpretationAccess().getGroup());
3320 // InternalSolverLanguage.g:1094:3: ( rule__ClassInterpretation__Group__0 )
3321 // InternalSolverLanguage.g:1094:4: rule__ClassInterpretation__Group__0
3322 {
3323 pushFollow(FOLLOW_2);
3324 rule__ClassInterpretation__Group__0();
3325
3326 state._fsp--;
3327
3328
3329 }
3330
3331 after(grammarAccess.getClassInterpretationAccess().getGroup());
3332
3333 }
3334
3335
3336 }
3337
3338 }
3339 catch (RecognitionException re) {
3340 reportError(re);
3341 recover(input,re);
3342 }
3343 finally {
3344
3345 restoreStackSize(stackSize);
3346
3347 }
3348 return ;
3349 }
3350 // $ANTLR end "ruleClassInterpretation"
3351
3352
3353 // $ANTLR start "entryRuleEnumInterpretation"
3354 // InternalSolverLanguage.g:1103:1: entryRuleEnumInterpretation : ruleEnumInterpretation EOF ;
3355 public final void entryRuleEnumInterpretation() throws RecognitionException {
3356 try {
3357 // InternalSolverLanguage.g:1104:1: ( ruleEnumInterpretation EOF )
3358 // InternalSolverLanguage.g:1105:1: ruleEnumInterpretation EOF
3359 {
3360 before(grammarAccess.getEnumInterpretationRule());
3361 pushFollow(FOLLOW_1);
3362 ruleEnumInterpretation();
3363
3364 state._fsp--;
3365
3366 after(grammarAccess.getEnumInterpretationRule());
3367 match(input,EOF,FOLLOW_2);
3368
3369 }
3370
3371 }
3372 catch (RecognitionException re) {
3373 reportError(re);
3374 recover(input,re);
3375 }
3376 finally {
3377 }
3378 return ;
3379 }
3380 // $ANTLR end "entryRuleEnumInterpretation"
3381
3382
3383 // $ANTLR start "ruleEnumInterpretation"
3384 // InternalSolverLanguage.g:1112:1: ruleEnumInterpretation : ( ( rule__EnumInterpretation__Group__0 ) ) ;
3385 public final void ruleEnumInterpretation() throws RecognitionException {
3386
3387 int stackSize = keepStackSize();
3388
3389 try {
3390 // InternalSolverLanguage.g:1116:2: ( ( ( rule__EnumInterpretation__Group__0 ) ) )
3391 // InternalSolverLanguage.g:1117:2: ( ( rule__EnumInterpretation__Group__0 ) )
3392 {
3393 // InternalSolverLanguage.g:1117:2: ( ( rule__EnumInterpretation__Group__0 ) )
3394 // InternalSolverLanguage.g:1118:3: ( rule__EnumInterpretation__Group__0 )
3395 {
3396 before(grammarAccess.getEnumInterpretationAccess().getGroup());
3397 // InternalSolverLanguage.g:1119:3: ( rule__EnumInterpretation__Group__0 )
3398 // InternalSolverLanguage.g:1119:4: rule__EnumInterpretation__Group__0
3399 {
3400 pushFollow(FOLLOW_2);
3401 rule__EnumInterpretation__Group__0();
3402
3403 state._fsp--;
3404
3405
3406 }
3407
3408 after(grammarAccess.getEnumInterpretationAccess().getGroup());
3409
3410 }
3411
3412
3413 }
3414
3415 }
3416 catch (RecognitionException re) {
3417 reportError(re);
3418 recover(input,re);
3419 }
3420 finally {
3421
3422 restoreStackSize(stackSize);
3423
3424 }
3425 return ;
3426 }
3427 // $ANTLR end "ruleEnumInterpretation"
3428
3429
3430 // $ANTLR start "entryRuleFieldRelationInterpretation"
3431 // InternalSolverLanguage.g:1128:1: entryRuleFieldRelationInterpretation : ruleFieldRelationInterpretation EOF ;
3432 public final void entryRuleFieldRelationInterpretation() throws RecognitionException {
3433 try {
3434 // InternalSolverLanguage.g:1129:1: ( ruleFieldRelationInterpretation EOF )
3435 // InternalSolverLanguage.g:1130:1: ruleFieldRelationInterpretation EOF
3436 {
3437 before(grammarAccess.getFieldRelationInterpretationRule());
3438 pushFollow(FOLLOW_1);
3439 ruleFieldRelationInterpretation();
3440
3441 state._fsp--;
3442
3443 after(grammarAccess.getFieldRelationInterpretationRule());
3444 match(input,EOF,FOLLOW_2);
3445
3446 }
3447
3448 }
3449 catch (RecognitionException re) {
3450 reportError(re);
3451 recover(input,re);
3452 }
3453 finally {
3454 }
3455 return ;
3456 }
3457 // $ANTLR end "entryRuleFieldRelationInterpretation"
3458
3459
3460 // $ANTLR start "ruleFieldRelationInterpretation"
3461 // InternalSolverLanguage.g:1137:1: ruleFieldRelationInterpretation : ( ( rule__FieldRelationInterpretation__Group__0 ) ) ;
3462 public final void ruleFieldRelationInterpretation() throws RecognitionException {
3463
3464 int stackSize = keepStackSize();
3465
3466 try {
3467 // InternalSolverLanguage.g:1141:2: ( ( ( rule__FieldRelationInterpretation__Group__0 ) ) )
3468 // InternalSolverLanguage.g:1142:2: ( ( rule__FieldRelationInterpretation__Group__0 ) )
3469 {
3470 // InternalSolverLanguage.g:1142:2: ( ( rule__FieldRelationInterpretation__Group__0 ) )
3471 // InternalSolverLanguage.g:1143:3: ( rule__FieldRelationInterpretation__Group__0 )
3472 {
3473 before(grammarAccess.getFieldRelationInterpretationAccess().getGroup());
3474 // InternalSolverLanguage.g:1144:3: ( rule__FieldRelationInterpretation__Group__0 )
3475 // InternalSolverLanguage.g:1144:4: rule__FieldRelationInterpretation__Group__0
3476 {
3477 pushFollow(FOLLOW_2);
3478 rule__FieldRelationInterpretation__Group__0();
3479
3480 state._fsp--;
3481
3482
3483 }
3484
3485 after(grammarAccess.getFieldRelationInterpretationAccess().getGroup());
3486
3487 }
3488
3489
3490 }
3491
3492 }
3493 catch (RecognitionException re) {
3494 reportError(re);
3495 recover(input,re);
3496 }
3497 finally {
3498
3499 restoreStackSize(stackSize);
3500
3501 }
3502 return ;
3503 }
3504 // $ANTLR end "ruleFieldRelationInterpretation"
3505
3506
3507 // $ANTLR start "entryRuleGlobalRelationInterpretation"
3508 // InternalSolverLanguage.g:1153:1: entryRuleGlobalRelationInterpretation : ruleGlobalRelationInterpretation EOF ;
3509 public final void entryRuleGlobalRelationInterpretation() throws RecognitionException {
3510 try {
3511 // InternalSolverLanguage.g:1154:1: ( ruleGlobalRelationInterpretation EOF )
3512 // InternalSolverLanguage.g:1155:1: ruleGlobalRelationInterpretation EOF
3513 {
3514 before(grammarAccess.getGlobalRelationInterpretationRule());
3515 pushFollow(FOLLOW_1);
3516 ruleGlobalRelationInterpretation();
3517
3518 state._fsp--;
3519
3520 after(grammarAccess.getGlobalRelationInterpretationRule());
3521 match(input,EOF,FOLLOW_2);
3522
3523 }
3524
3525 }
3526 catch (RecognitionException re) {
3527 reportError(re);
3528 recover(input,re);
3529 }
3530 finally {
3531 }
3532 return ;
3533 }
3534 // $ANTLR end "entryRuleGlobalRelationInterpretation"
3535
3536
3537 // $ANTLR start "ruleGlobalRelationInterpretation"
3538 // InternalSolverLanguage.g:1162:1: ruleGlobalRelationInterpretation : ( ( rule__GlobalRelationInterpretation__Group__0 ) ) ;
3539 public final void ruleGlobalRelationInterpretation() throws RecognitionException {
3540
3541 int stackSize = keepStackSize();
3542
3543 try {
3544 // InternalSolverLanguage.g:1166:2: ( ( ( rule__GlobalRelationInterpretation__Group__0 ) ) )
3545 // InternalSolverLanguage.g:1167:2: ( ( rule__GlobalRelationInterpretation__Group__0 ) )
3546 {
3547 // InternalSolverLanguage.g:1167:2: ( ( rule__GlobalRelationInterpretation__Group__0 ) )
3548 // InternalSolverLanguage.g:1168:3: ( rule__GlobalRelationInterpretation__Group__0 )
3549 {
3550 before(grammarAccess.getGlobalRelationInterpretationAccess().getGroup());
3551 // InternalSolverLanguage.g:1169:3: ( rule__GlobalRelationInterpretation__Group__0 )
3552 // InternalSolverLanguage.g:1169:4: rule__GlobalRelationInterpretation__Group__0
3553 {
3554 pushFollow(FOLLOW_2);
3555 rule__GlobalRelationInterpretation__Group__0();
3556
3557 state._fsp--;
3558
3559
3560 }
3561
3562 after(grammarAccess.getGlobalRelationInterpretationAccess().getGroup());
3563
3564 }
3565
3566
3567 }
3568
3569 }
3570 catch (RecognitionException re) {
3571 reportError(re);
3572 recover(input,re);
3573 }
3574 finally {
3575
3576 restoreStackSize(stackSize);
3577
3578 }
3579 return ;
3580 }
3581 // $ANTLR end "ruleGlobalRelationInterpretation"
3582
3583
3584 // $ANTLR start "entryRuleMultiplicityDefinition"
3585 // InternalSolverLanguage.g:1178:1: entryRuleMultiplicityDefinition : ruleMultiplicityDefinition EOF ;
3586 public final void entryRuleMultiplicityDefinition() throws RecognitionException {
3587 try {
3588 // InternalSolverLanguage.g:1179:1: ( ruleMultiplicityDefinition EOF )
3589 // InternalSolverLanguage.g:1180:1: ruleMultiplicityDefinition EOF
3590 {
3591 before(grammarAccess.getMultiplicityDefinitionRule());
3592 pushFollow(FOLLOW_1);
3593 ruleMultiplicityDefinition();
3594
3595 state._fsp--;
3596
3597 after(grammarAccess.getMultiplicityDefinitionRule());
3598 match(input,EOF,FOLLOW_2);
3599
3600 }
3601
3602 }
3603 catch (RecognitionException re) {
3604 reportError(re);
3605 recover(input,re);
3606 }
3607 finally {
3608 }
3609 return ;
3610 }
3611 // $ANTLR end "entryRuleMultiplicityDefinition"
3612
3613
3614 // $ANTLR start "ruleMultiplicityDefinition"
3615 // InternalSolverLanguage.g:1187:1: ruleMultiplicityDefinition : ( ( rule__MultiplicityDefinition__Group__0 ) ) ;
3616 public final void ruleMultiplicityDefinition() throws RecognitionException {
3617
3618 int stackSize = keepStackSize();
3619
3620 try {
3621 // InternalSolverLanguage.g:1191:2: ( ( ( rule__MultiplicityDefinition__Group__0 ) ) )
3622 // InternalSolverLanguage.g:1192:2: ( ( rule__MultiplicityDefinition__Group__0 ) )
3623 {
3624 // InternalSolverLanguage.g:1192:2: ( ( rule__MultiplicityDefinition__Group__0 ) )
3625 // InternalSolverLanguage.g:1193:3: ( rule__MultiplicityDefinition__Group__0 )
3626 {
3627 before(grammarAccess.getMultiplicityDefinitionAccess().getGroup());
3628 // InternalSolverLanguage.g:1194:3: ( rule__MultiplicityDefinition__Group__0 )
3629 // InternalSolverLanguage.g:1194:4: rule__MultiplicityDefinition__Group__0
3630 {
3631 pushFollow(FOLLOW_2);
3632 rule__MultiplicityDefinition__Group__0();
3633
3634 state._fsp--;
3635
3636
3637 }
3638
3639 after(grammarAccess.getMultiplicityDefinitionAccess().getGroup());
3640
3641 }
3642
3643
3644 }
3645
3646 }
3647 catch (RecognitionException re) {
3648 reportError(re);
3649 recover(input,re);
3650 }
3651 finally {
3652
3653 restoreStackSize(stackSize);
3654
3655 }
3656 return ;
3657 }
3658 // $ANTLR end "ruleMultiplicityDefinition"
3659
3660
3661 // $ANTLR start "rule__Statement__Alternatives"
3662 // InternalSolverLanguage.g:1202:1: rule__Statement__Alternatives : ( ( ruleInterpretation ) | ( rulePredicate ) );
3663 public final void rule__Statement__Alternatives() throws RecognitionException {
3664
3665 int stackSize = keepStackSize();
3666
3667 try {
3668 // InternalSolverLanguage.g:1206:1: ( ( ruleInterpretation ) | ( rulePredicate ) )
3669 int alt2=2;
3670 int LA2_0 = input.LA(1);
3671
3672 if ( (LA2_0==RULE_ID||(LA2_0>=20 && LA2_0<=25)||LA2_0==31||LA2_0==36||(LA2_0>=39 && LA2_0<=40)) ) {
3673 alt2=1;
3674 }
3675 else if ( (LA2_0==16||LA2_0==27) ) {
3676 alt2=2;
3677 }
3678 else {
3679 NoViableAltException nvae =
3680 new NoViableAltException("", 2, 0, input);
3681
3682 throw nvae;
3683 }
3684 switch (alt2) {
3685 case 1 :
3686 // InternalSolverLanguage.g:1207:2: ( ruleInterpretation )
3687 {
3688 // InternalSolverLanguage.g:1207:2: ( ruleInterpretation )
3689 // InternalSolverLanguage.g:1208:3: ruleInterpretation
3690 {
3691 before(grammarAccess.getStatementAccess().getInterpretationParserRuleCall_0());
3692 pushFollow(FOLLOW_2);
3693 ruleInterpretation();
3694
3695 state._fsp--;
3696
3697 after(grammarAccess.getStatementAccess().getInterpretationParserRuleCall_0());
3698
3699 }
3700
3701
3702 }
3703 break;
3704 case 2 :
3705 // InternalSolverLanguage.g:1213:2: ( rulePredicate )
3706 {
3707 // InternalSolverLanguage.g:1213:2: ( rulePredicate )
3708 // InternalSolverLanguage.g:1214:3: rulePredicate
3709 {
3710 before(grammarAccess.getStatementAccess().getPredicateParserRuleCall_1());
3711 pushFollow(FOLLOW_2);
3712 rulePredicate();
3713
3714 state._fsp--;
3715
3716 after(grammarAccess.getStatementAccess().getPredicateParserRuleCall_1());
3717
3718 }
3719
3720
3721 }
3722 break;
3723
3724 }
3725 }
3726 catch (RecognitionException re) {
3727 reportError(re);
3728 recover(input,re);
3729 }
3730 finally {
3731
3732 restoreStackSize(stackSize);
3733
3734 }
3735 return ;
3736 }
3737 // $ANTLR end "rule__Statement__Alternatives"
3738
3739
3740 // $ANTLR start "rule__BooleanValue__Alternatives"
3741 // InternalSolverLanguage.g:1223:1: rule__BooleanValue__Alternatives : ( ( ( rule__BooleanValue__Group_0__0 ) ) | ( ( rule__BooleanValue__Group_1__0 ) ) );
3742 public final void rule__BooleanValue__Alternatives() throws RecognitionException {
3743
3744 int stackSize = keepStackSize();
3745
3746 try {
3747 // InternalSolverLanguage.g:1227:1: ( ( ( rule__BooleanValue__Group_0__0 ) ) | ( ( rule__BooleanValue__Group_1__0 ) ) )
3748 int alt3=2;
3749 int LA3_0 = input.LA(1);
3750
3751 if ( (LA3_0==12) ) {
3752 alt3=1;
3753 }
3754 else if ( (LA3_0==11) ) {
3755 alt3=2;
3756 }
3757 else {
3758 NoViableAltException nvae =
3759 new NoViableAltException("", 3, 0, input);
3760
3761 throw nvae;
3762 }
3763 switch (alt3) {
3764 case 1 :
3765 // InternalSolverLanguage.g:1228:2: ( ( rule__BooleanValue__Group_0__0 ) )
3766 {
3767 // InternalSolverLanguage.g:1228:2: ( ( rule__BooleanValue__Group_0__0 ) )
3768 // InternalSolverLanguage.g:1229:3: ( rule__BooleanValue__Group_0__0 )
3769 {
3770 before(grammarAccess.getBooleanValueAccess().getGroup_0());
3771 // InternalSolverLanguage.g:1230:3: ( rule__BooleanValue__Group_0__0 )
3772 // InternalSolverLanguage.g:1230:4: rule__BooleanValue__Group_0__0
3773 {
3774 pushFollow(FOLLOW_2);
3775 rule__BooleanValue__Group_0__0();
3776
3777 state._fsp--;
3778
3779
3780 }
3781
3782 after(grammarAccess.getBooleanValueAccess().getGroup_0());
3783
3784 }
3785
3786
3787 }
3788 break;
3789 case 2 :
3790 // InternalSolverLanguage.g:1234:2: ( ( rule__BooleanValue__Group_1__0 ) )
3791 {
3792 // InternalSolverLanguage.g:1234:2: ( ( rule__BooleanValue__Group_1__0 ) )
3793 // InternalSolverLanguage.g:1235:3: ( rule__BooleanValue__Group_1__0 )
3794 {
3795 before(grammarAccess.getBooleanValueAccess().getGroup_1());
3796 // InternalSolverLanguage.g:1236:3: ( rule__BooleanValue__Group_1__0 )
3797 // InternalSolverLanguage.g:1236:4: rule__BooleanValue__Group_1__0
3798 {
3799 pushFollow(FOLLOW_2);
3800 rule__BooleanValue__Group_1__0();
3801
3802 state._fsp--;
3803
3804
3805 }
3806
3807 after(grammarAccess.getBooleanValueAccess().getGroup_1());
3808
3809 }
3810
3811
3812 }
3813 break;
3814
3815 }
3816 }
3817 catch (RecognitionException re) {
3818 reportError(re);
3819 recover(input,re);
3820 }
3821 finally {
3822
3823 restoreStackSize(stackSize);
3824
3825 }
3826 return ;
3827 }
3828 // $ANTLR end "rule__BooleanValue__Alternatives"
3829
3830
3831 // $ANTLR start "rule__TruthValue__Alternatives"
3832 // InternalSolverLanguage.g:1244:1: rule__TruthValue__Alternatives : ( ( ( rule__TruthValue__Group_0__0 ) ) | ( ( rule__TruthValue__Group_1__0 ) ) | ( ( rule__TruthValue__Group_2__0 ) ) | ( ( rule__TruthValue__Group_3__0 ) ) );
3833 public final void rule__TruthValue__Alternatives() throws RecognitionException {
3834
3835 int stackSize = keepStackSize();
3836
3837 try {
3838 // InternalSolverLanguage.g:1248:1: ( ( ( rule__TruthValue__Group_0__0 ) ) | ( ( rule__TruthValue__Group_1__0 ) ) | ( ( rule__TruthValue__Group_2__0 ) ) | ( ( rule__TruthValue__Group_3__0 ) ) )
3839 int alt4=4;
3840 switch ( input.LA(1) ) {
3841 case 12:
3842 {
3843 alt4=1;
3844 }
3845 break;
3846 case 11:
3847 {
3848 alt4=2;
3849 }
3850 break;
3851 case 15:
3852 {
3853 alt4=3;
3854 }
3855 break;
3856 case 16:
3857 {
3858 alt4=4;
3859 }
3860 break;
3861 default:
3862 NoViableAltException nvae =
3863 new NoViableAltException("", 4, 0, input);
3864
3865 throw nvae;
3866 }
3867
3868 switch (alt4) {
3869 case 1 :
3870 // InternalSolverLanguage.g:1249:2: ( ( rule__TruthValue__Group_0__0 ) )
3871 {
3872 // InternalSolverLanguage.g:1249:2: ( ( rule__TruthValue__Group_0__0 ) )
3873 // InternalSolverLanguage.g:1250:3: ( rule__TruthValue__Group_0__0 )
3874 {
3875 before(grammarAccess.getTruthValueAccess().getGroup_0());
3876 // InternalSolverLanguage.g:1251:3: ( rule__TruthValue__Group_0__0 )
3877 // InternalSolverLanguage.g:1251:4: rule__TruthValue__Group_0__0
3878 {
3879 pushFollow(FOLLOW_2);
3880 rule__TruthValue__Group_0__0();
3881
3882 state._fsp--;
3883
3884
3885 }
3886
3887 after(grammarAccess.getTruthValueAccess().getGroup_0());
3888
3889 }
3890
3891
3892 }
3893 break;
3894 case 2 :
3895 // InternalSolverLanguage.g:1255:2: ( ( rule__TruthValue__Group_1__0 ) )
3896 {
3897 // InternalSolverLanguage.g:1255:2: ( ( rule__TruthValue__Group_1__0 ) )
3898 // InternalSolverLanguage.g:1256:3: ( rule__TruthValue__Group_1__0 )
3899 {
3900 before(grammarAccess.getTruthValueAccess().getGroup_1());
3901 // InternalSolverLanguage.g:1257:3: ( rule__TruthValue__Group_1__0 )
3902 // InternalSolverLanguage.g:1257:4: rule__TruthValue__Group_1__0
3903 {
3904 pushFollow(FOLLOW_2);
3905 rule__TruthValue__Group_1__0();
3906
3907 state._fsp--;
3908
3909
3910 }
3911
3912 after(grammarAccess.getTruthValueAccess().getGroup_1());
3913
3914 }
3915
3916
3917 }
3918 break;
3919 case 3 :
3920 // InternalSolverLanguage.g:1261:2: ( ( rule__TruthValue__Group_2__0 ) )
3921 {
3922 // InternalSolverLanguage.g:1261:2: ( ( rule__TruthValue__Group_2__0 ) )
3923 // InternalSolverLanguage.g:1262:3: ( rule__TruthValue__Group_2__0 )
3924 {
3925 before(grammarAccess.getTruthValueAccess().getGroup_2());
3926 // InternalSolverLanguage.g:1263:3: ( rule__TruthValue__Group_2__0 )
3927 // InternalSolverLanguage.g:1263:4: rule__TruthValue__Group_2__0
3928 {
3929 pushFollow(FOLLOW_2);
3930 rule__TruthValue__Group_2__0();
3931
3932 state._fsp--;
3933
3934
3935 }
3936
3937 after(grammarAccess.getTruthValueAccess().getGroup_2());
3938
3939 }
3940
3941
3942 }
3943 break;
3944 case 4 :
3945 // InternalSolverLanguage.g:1267:2: ( ( rule__TruthValue__Group_3__0 ) )
3946 {
3947 // InternalSolverLanguage.g:1267:2: ( ( rule__TruthValue__Group_3__0 ) )
3948 // InternalSolverLanguage.g:1268:3: ( rule__TruthValue__Group_3__0 )
3949 {
3950 before(grammarAccess.getTruthValueAccess().getGroup_3());
3951 // InternalSolverLanguage.g:1269:3: ( rule__TruthValue__Group_3__0 )
3952 // InternalSolverLanguage.g:1269:4: rule__TruthValue__Group_3__0
3953 {
3954 pushFollow(FOLLOW_2);
3955 rule__TruthValue__Group_3__0();
3956
3957 state._fsp--;
3958
3959
3960 }
3961
3962 after(grammarAccess.getTruthValueAccess().getGroup_3());
3963
3964 }
3965
3966
3967 }
3968 break;
3969
3970 }
3971 }
3972 catch (RecognitionException re) {
3973 reportError(re);
3974 recover(input,re);
3975 }
3976 finally {
3977
3978 restoreStackSize(stackSize);
3979
3980 }
3981 return ;
3982 }
3983 // $ANTLR end "rule__TruthValue__Alternatives"
3984
3985
3986 // $ANTLR start "rule__Interpretation__Alternatives"
3987 // InternalSolverLanguage.g:1277:1: rule__Interpretation__Alternatives : ( ( ruleBasicInterpretation ) | ( ruleDefaultInterpretation ) | ( ruleCDInterpretation ) );
3988 public final void rule__Interpretation__Alternatives() throws RecognitionException {
3989
3990 int stackSize = keepStackSize();
3991
3992 try {
3993 // InternalSolverLanguage.g:1281:1: ( ( ruleBasicInterpretation ) | ( ruleDefaultInterpretation ) | ( ruleCDInterpretation ) )
3994 int alt5=3;
3995 switch ( input.LA(1) ) {
3996 case RULE_ID:
3997 case 20:
3998 case 21:
3999 case 22:
4000 case 23:
4001 case 24:
4002 case 25:
4003 {
4004 alt5=1;
4005 }
4006 break;
4007 case 31:
4008 {
4009 alt5=2;
4010 }
4011 break;
4012 case 36:
4013 case 39:
4014 case 40:
4015 {
4016 alt5=3;
4017 }
4018 break;
4019 default:
4020 NoViableAltException nvae =
4021 new NoViableAltException("", 5, 0, input);
4022
4023 throw nvae;
4024 }
4025
4026 switch (alt5) {
4027 case 1 :
4028 // InternalSolverLanguage.g:1282:2: ( ruleBasicInterpretation )
4029 {
4030 // InternalSolverLanguage.g:1282:2: ( ruleBasicInterpretation )
4031 // InternalSolverLanguage.g:1283:3: ruleBasicInterpretation
4032 {
4033 before(grammarAccess.getInterpretationAccess().getBasicInterpretationParserRuleCall_0());
4034 pushFollow(FOLLOW_2);
4035 ruleBasicInterpretation();
4036
4037 state._fsp--;
4038
4039 after(grammarAccess.getInterpretationAccess().getBasicInterpretationParserRuleCall_0());
4040
4041 }
4042
4043
4044 }
4045 break;
4046 case 2 :
4047 // InternalSolverLanguage.g:1288:2: ( ruleDefaultInterpretation )
4048 {
4049 // InternalSolverLanguage.g:1288:2: ( ruleDefaultInterpretation )
4050 // InternalSolverLanguage.g:1289:3: ruleDefaultInterpretation
4051 {
4052 before(grammarAccess.getInterpretationAccess().getDefaultInterpretationParserRuleCall_1());
4053 pushFollow(FOLLOW_2);
4054 ruleDefaultInterpretation();
4055
4056 state._fsp--;
4057
4058 after(grammarAccess.getInterpretationAccess().getDefaultInterpretationParserRuleCall_1());
4059
4060 }
4061
4062
4063 }
4064 break;
4065 case 3 :
4066 // InternalSolverLanguage.g:1294:2: ( ruleCDInterpretation )
4067 {
4068 // InternalSolverLanguage.g:1294:2: ( ruleCDInterpretation )
4069 // InternalSolverLanguage.g:1295:3: ruleCDInterpretation
4070 {
4071 before(grammarAccess.getInterpretationAccess().getCDInterpretationParserRuleCall_2());
4072 pushFollow(FOLLOW_2);
4073 ruleCDInterpretation();
4074
4075 state._fsp--;
4076
4077 after(grammarAccess.getInterpretationAccess().getCDInterpretationParserRuleCall_2());
4078
4079 }
4080
4081
4082 }
4083 break;
4084
4085 }
4086 }
4087 catch (RecognitionException re) {
4088 reportError(re);
4089 recover(input,re);
4090 }
4091 finally {
4092
4093 restoreStackSize(stackSize);
4094
4095 }
4096 return ;
4097 }
4098 // $ANTLR end "rule__Interpretation__Alternatives"
4099
4100
4101 // $ANTLR start "rule__Symbol__Alternatives"
4102 // InternalSolverLanguage.g:1304:1: rule__Symbol__Alternatives : ( ( ruleModelSymbol ) | ( rulePartialitySymbol ) | ( ruleDataSymbol ) );
4103 public final void rule__Symbol__Alternatives() throws RecognitionException {
4104
4105 int stackSize = keepStackSize();
4106
4107 try {
4108 // InternalSolverLanguage.g:1308:1: ( ( ruleModelSymbol ) | ( rulePartialitySymbol ) | ( ruleDataSymbol ) )
4109 int alt6=3;
4110 switch ( input.LA(1) ) {
4111 case RULE_ID:
4112 {
4113 alt6=1;
4114 }
4115 break;
4116 case 20:
4117 case 21:
4118 {
4119 alt6=2;
4120 }
4121 break;
4122 case 22:
4123 case 23:
4124 case 24:
4125 case 25:
4126 {
4127 alt6=3;
4128 }
4129 break;
4130 default:
4131 NoViableAltException nvae =
4132 new NoViableAltException("", 6, 0, input);
4133
4134 throw nvae;
4135 }
4136
4137 switch (alt6) {
4138 case 1 :
4139 // InternalSolverLanguage.g:1309:2: ( ruleModelSymbol )
4140 {
4141 // InternalSolverLanguage.g:1309:2: ( ruleModelSymbol )
4142 // InternalSolverLanguage.g:1310:3: ruleModelSymbol
4143 {
4144 before(grammarAccess.getSymbolAccess().getModelSymbolParserRuleCall_0());
4145 pushFollow(FOLLOW_2);
4146 ruleModelSymbol();
4147
4148 state._fsp--;
4149
4150 after(grammarAccess.getSymbolAccess().getModelSymbolParserRuleCall_0());
4151
4152 }
4153
4154
4155 }
4156 break;
4157 case 2 :
4158 // InternalSolverLanguage.g:1315:2: ( rulePartialitySymbol )
4159 {
4160 // InternalSolverLanguage.g:1315:2: ( rulePartialitySymbol )
4161 // InternalSolverLanguage.g:1316:3: rulePartialitySymbol
4162 {
4163 before(grammarAccess.getSymbolAccess().getPartialitySymbolParserRuleCall_1());
4164 pushFollow(FOLLOW_2);
4165 rulePartialitySymbol();
4166
4167 state._fsp--;
4168
4169 after(grammarAccess.getSymbolAccess().getPartialitySymbolParserRuleCall_1());
4170
4171 }
4172
4173
4174 }
4175 break;
4176 case 3 :
4177 // InternalSolverLanguage.g:1321:2: ( ruleDataSymbol )
4178 {
4179 // InternalSolverLanguage.g:1321:2: ( ruleDataSymbol )
4180 // InternalSolverLanguage.g:1322:3: ruleDataSymbol
4181 {
4182 before(grammarAccess.getSymbolAccess().getDataSymbolParserRuleCall_2());
4183 pushFollow(FOLLOW_2);
4184 ruleDataSymbol();
4185
4186 state._fsp--;
4187
4188 after(grammarAccess.getSymbolAccess().getDataSymbolParserRuleCall_2());
4189
4190 }
4191
4192
4193 }
4194 break;
4195
4196 }
4197 }
4198 catch (RecognitionException re) {
4199 reportError(re);
4200 recover(input,re);
4201 }
4202 finally {
4203
4204 restoreStackSize(stackSize);
4205
4206 }
4207 return ;
4208 }
4209 // $ANTLR end "rule__Symbol__Alternatives"
4210
4211
4212 // $ANTLR start "rule__PartialitySymbol__Alternatives"
4213 // InternalSolverLanguage.g:1331:1: rule__PartialitySymbol__Alternatives : ( ( ruleExistSymbol ) | ( ruleEqualsSymbol ) );
4214 public final void rule__PartialitySymbol__Alternatives() throws RecognitionException {
4215
4216 int stackSize = keepStackSize();
4217
4218 try {
4219 // InternalSolverLanguage.g:1335:1: ( ( ruleExistSymbol ) | ( ruleEqualsSymbol ) )
4220 int alt7=2;
4221 int LA7_0 = input.LA(1);
4222
4223 if ( (LA7_0==20) ) {
4224 alt7=1;
4225 }
4226 else if ( (LA7_0==21) ) {
4227 alt7=2;
4228 }
4229 else {
4230 NoViableAltException nvae =
4231 new NoViableAltException("", 7, 0, input);
4232
4233 throw nvae;
4234 }
4235 switch (alt7) {
4236 case 1 :
4237 // InternalSolverLanguage.g:1336:2: ( ruleExistSymbol )
4238 {
4239 // InternalSolverLanguage.g:1336:2: ( ruleExistSymbol )
4240 // InternalSolverLanguage.g:1337:3: ruleExistSymbol
4241 {
4242 before(grammarAccess.getPartialitySymbolAccess().getExistSymbolParserRuleCall_0());
4243 pushFollow(FOLLOW_2);
4244 ruleExistSymbol();
4245
4246 state._fsp--;
4247
4248 after(grammarAccess.getPartialitySymbolAccess().getExistSymbolParserRuleCall_0());
4249
4250 }
4251
4252
4253 }
4254 break;
4255 case 2 :
4256 // InternalSolverLanguage.g:1342:2: ( ruleEqualsSymbol )
4257 {
4258 // InternalSolverLanguage.g:1342:2: ( ruleEqualsSymbol )
4259 // InternalSolverLanguage.g:1343:3: ruleEqualsSymbol
4260 {
4261 before(grammarAccess.getPartialitySymbolAccess().getEqualsSymbolParserRuleCall_1());
4262 pushFollow(FOLLOW_2);
4263 ruleEqualsSymbol();
4264
4265 state._fsp--;
4266
4267 after(grammarAccess.getPartialitySymbolAccess().getEqualsSymbolParserRuleCall_1());
4268
4269 }
4270
4271
4272 }
4273 break;
4274
4275 }
4276 }
4277 catch (RecognitionException re) {
4278 reportError(re);
4279 recover(input,re);
4280 }
4281 finally {
4282
4283 restoreStackSize(stackSize);
4284
4285 }
4286 return ;
4287 }
4288 // $ANTLR end "rule__PartialitySymbol__Alternatives"
4289
4290
4291 // $ANTLR start "rule__DataSymbol__Alternatives"
4292 // InternalSolverLanguage.g:1352:1: rule__DataSymbol__Alternatives : ( ( ruleBooleanSymbol ) | ( ruleIntegerSymbol ) | ( ruleRealSymbol ) | ( ruleStringSymbol ) );
4293 public final void rule__DataSymbol__Alternatives() throws RecognitionException {
4294
4295 int stackSize = keepStackSize();
4296
4297 try {
4298 // InternalSolverLanguage.g:1356:1: ( ( ruleBooleanSymbol ) | ( ruleIntegerSymbol ) | ( ruleRealSymbol ) | ( ruleStringSymbol ) )
4299 int alt8=4;
4300 switch ( input.LA(1) ) {
4301 case 22:
4302 {
4303 alt8=1;
4304 }
4305 break;
4306 case 23:
4307 {
4308 alt8=2;
4309 }
4310 break;
4311 case 24:
4312 {
4313 alt8=3;
4314 }
4315 break;
4316 case 25:
4317 {
4318 alt8=4;
4319 }
4320 break;
4321 default:
4322 NoViableAltException nvae =
4323 new NoViableAltException("", 8, 0, input);
4324
4325 throw nvae;
4326 }
4327
4328 switch (alt8) {
4329 case 1 :
4330 // InternalSolverLanguage.g:1357:2: ( ruleBooleanSymbol )
4331 {
4332 // InternalSolverLanguage.g:1357:2: ( ruleBooleanSymbol )
4333 // InternalSolverLanguage.g:1358:3: ruleBooleanSymbol
4334 {
4335 before(grammarAccess.getDataSymbolAccess().getBooleanSymbolParserRuleCall_0());
4336 pushFollow(FOLLOW_2);
4337 ruleBooleanSymbol();
4338
4339 state._fsp--;
4340
4341 after(grammarAccess.getDataSymbolAccess().getBooleanSymbolParserRuleCall_0());
4342
4343 }
4344
4345
4346 }
4347 break;
4348 case 2 :
4349 // InternalSolverLanguage.g:1363:2: ( ruleIntegerSymbol )
4350 {
4351 // InternalSolverLanguage.g:1363:2: ( ruleIntegerSymbol )
4352 // InternalSolverLanguage.g:1364:3: ruleIntegerSymbol
4353 {
4354 before(grammarAccess.getDataSymbolAccess().getIntegerSymbolParserRuleCall_1());
4355 pushFollow(FOLLOW_2);
4356 ruleIntegerSymbol();
4357
4358 state._fsp--;
4359
4360 after(grammarAccess.getDataSymbolAccess().getIntegerSymbolParserRuleCall_1());
4361
4362 }
4363
4364
4365 }
4366 break;
4367 case 3 :
4368 // InternalSolverLanguage.g:1369:2: ( ruleRealSymbol )
4369 {
4370 // InternalSolverLanguage.g:1369:2: ( ruleRealSymbol )
4371 // InternalSolverLanguage.g:1370:3: ruleRealSymbol
4372 {
4373 before(grammarAccess.getDataSymbolAccess().getRealSymbolParserRuleCall_2());
4374 pushFollow(FOLLOW_2);
4375 ruleRealSymbol();
4376
4377 state._fsp--;
4378
4379 after(grammarAccess.getDataSymbolAccess().getRealSymbolParserRuleCall_2());
4380
4381 }
4382
4383
4384 }
4385 break;
4386 case 4 :
4387 // InternalSolverLanguage.g:1375:2: ( ruleStringSymbol )
4388 {
4389 // InternalSolverLanguage.g:1375:2: ( ruleStringSymbol )
4390 // InternalSolverLanguage.g:1376:3: ruleStringSymbol
4391 {
4392 before(grammarAccess.getDataSymbolAccess().getStringSymbolParserRuleCall_3());
4393 pushFollow(FOLLOW_2);
4394 ruleStringSymbol();
4395
4396 state._fsp--;
4397
4398 after(grammarAccess.getDataSymbolAccess().getStringSymbolParserRuleCall_3());
4399
4400 }
4401
4402
4403 }
4404 break;
4405
4406 }
4407 }
4408 catch (RecognitionException re) {
4409 reportError(re);
4410 recover(input,re);
4411 }
4412 finally {
4413
4414 restoreStackSize(stackSize);
4415
4416 }
4417 return ;
4418 }
4419 // $ANTLR end "rule__DataSymbol__Alternatives"
4420
4421
4422 // $ANTLR start "rule__ComplexObject__Alternatives"
4423 // InternalSolverLanguage.g:1385:1: rule__ComplexObject__Alternatives : ( ( ruleObject ) | ( ruleAllInstances ) | ( ruleAllObjects ) );
4424 public final void rule__ComplexObject__Alternatives() throws RecognitionException {
4425
4426 int stackSize = keepStackSize();
4427
4428 try {
4429 // InternalSolverLanguage.g:1389:1: ( ( ruleObject ) | ( ruleAllInstances ) | ( ruleAllObjects ) )
4430 int alt9=3;
4431 switch ( input.LA(1) ) {
4432 case RULE_INT:
4433 case RULE_ID:
4434 case RULE_STRING:
4435 case 11:
4436 case 12:
4437 case 13:
4438 case 26:
4439 {
4440 alt9=1;
4441 }
4442 break;
4443 case 19:
4444 {
4445 alt9=2;
4446 }
4447 break;
4448 case 30:
4449 {
4450 alt9=3;
4451 }
4452 break;
4453 default:
4454 NoViableAltException nvae =
4455 new NoViableAltException("", 9, 0, input);
4456
4457 throw nvae;
4458 }
4459
4460 switch (alt9) {
4461 case 1 :
4462 // InternalSolverLanguage.g:1390:2: ( ruleObject )
4463 {
4464 // InternalSolverLanguage.g:1390:2: ( ruleObject )
4465 // InternalSolverLanguage.g:1391:3: ruleObject
4466 {
4467 before(grammarAccess.getComplexObjectAccess().getObjectParserRuleCall_0());
4468 pushFollow(FOLLOW_2);
4469 ruleObject();
4470
4471 state._fsp--;
4472
4473 after(grammarAccess.getComplexObjectAccess().getObjectParserRuleCall_0());
4474
4475 }
4476
4477
4478 }
4479 break;
4480 case 2 :
4481 // InternalSolverLanguage.g:1396:2: ( ruleAllInstances )
4482 {
4483 // InternalSolverLanguage.g:1396:2: ( ruleAllInstances )
4484 // InternalSolverLanguage.g:1397:3: ruleAllInstances
4485 {
4486 before(grammarAccess.getComplexObjectAccess().getAllInstancesParserRuleCall_1());
4487 pushFollow(FOLLOW_2);
4488 ruleAllInstances();
4489
4490 state._fsp--;
4491
4492 after(grammarAccess.getComplexObjectAccess().getAllInstancesParserRuleCall_1());
4493
4494 }
4495
4496
4497 }
4498 break;
4499 case 3 :
4500 // InternalSolverLanguage.g:1402:2: ( ruleAllObjects )
4501 {
4502 // InternalSolverLanguage.g:1402:2: ( ruleAllObjects )
4503 // InternalSolverLanguage.g:1403:3: ruleAllObjects
4504 {
4505 before(grammarAccess.getComplexObjectAccess().getAllObjectsParserRuleCall_2());
4506 pushFollow(FOLLOW_2);
4507 ruleAllObjects();
4508
4509 state._fsp--;
4510
4511 after(grammarAccess.getComplexObjectAccess().getAllObjectsParserRuleCall_2());
4512
4513 }
4514
4515
4516 }
4517 break;
4518
4519 }
4520 }
4521 catch (RecognitionException re) {
4522 reportError(re);
4523 recover(input,re);
4524 }
4525 finally {
4526
4527 restoreStackSize(stackSize);
4528
4529 }
4530 return ;
4531 }
4532 // $ANTLR end "rule__ComplexObject__Alternatives"
4533
4534
4535 // $ANTLR start "rule__Object__Alternatives"
4536 // InternalSolverLanguage.g:1412:1: rule__Object__Alternatives : ( ( ruleNamedObject ) | ( ruleUnnamedObject ) | ( ruleDataObject ) );
4537 public final void rule__Object__Alternatives() throws RecognitionException {
4538
4539 int stackSize = keepStackSize();
4540
4541 try {
4542 // InternalSolverLanguage.g:1416:1: ( ( ruleNamedObject ) | ( ruleUnnamedObject ) | ( ruleDataObject ) )
4543 int alt10=3;
4544 switch ( input.LA(1) ) {
4545 case 26:
4546 {
4547 alt10=1;
4548 }
4549 break;
4550 case RULE_ID:
4551 {
4552 alt10=2;
4553 }
4554 break;
4555 case RULE_INT:
4556 case RULE_STRING:
4557 case 11:
4558 case 12:
4559 case 13:
4560 {
4561 alt10=3;
4562 }
4563 break;
4564 default:
4565 NoViableAltException nvae =
4566 new NoViableAltException("", 10, 0, input);
4567
4568 throw nvae;
4569 }
4570
4571 switch (alt10) {
4572 case 1 :
4573 // InternalSolverLanguage.g:1417:2: ( ruleNamedObject )
4574 {
4575 // InternalSolverLanguage.g:1417:2: ( ruleNamedObject )
4576 // InternalSolverLanguage.g:1418:3: ruleNamedObject
4577 {
4578 before(grammarAccess.getObjectAccess().getNamedObjectParserRuleCall_0());
4579 pushFollow(FOLLOW_2);
4580 ruleNamedObject();
4581
4582 state._fsp--;
4583
4584 after(grammarAccess.getObjectAccess().getNamedObjectParserRuleCall_0());
4585
4586 }
4587
4588
4589 }
4590 break;
4591 case 2 :
4592 // InternalSolverLanguage.g:1423:2: ( ruleUnnamedObject )
4593 {
4594 // InternalSolverLanguage.g:1423:2: ( ruleUnnamedObject )
4595 // InternalSolverLanguage.g:1424:3: ruleUnnamedObject
4596 {
4597 before(grammarAccess.getObjectAccess().getUnnamedObjectParserRuleCall_1());
4598 pushFollow(FOLLOW_2);
4599 ruleUnnamedObject();
4600
4601 state._fsp--;
4602
4603 after(grammarAccess.getObjectAccess().getUnnamedObjectParserRuleCall_1());
4604
4605 }
4606
4607
4608 }
4609 break;
4610 case 3 :
4611 // InternalSolverLanguage.g:1429:2: ( ruleDataObject )
4612 {
4613 // InternalSolverLanguage.g:1429:2: ( ruleDataObject )
4614 // InternalSolverLanguage.g:1430:3: ruleDataObject
4615 {
4616 before(grammarAccess.getObjectAccess().getDataObjectParserRuleCall_2());
4617 pushFollow(FOLLOW_2);
4618 ruleDataObject();
4619
4620 state._fsp--;
4621
4622 after(grammarAccess.getObjectAccess().getDataObjectParserRuleCall_2());
4623
4624 }
4625
4626
4627 }
4628 break;
4629
4630 }
4631 }
4632 catch (RecognitionException re) {
4633 reportError(re);
4634 recover(input,re);
4635 }
4636 finally {
4637
4638 restoreStackSize(stackSize);
4639
4640 }
4641 return ;
4642 }
4643 // $ANTLR end "rule__Object__Alternatives"
4644
4645
4646 // $ANTLR start "rule__DataObject__Alternatives"
4647 // InternalSolverLanguage.g:1439:1: rule__DataObject__Alternatives : ( ( ruleBooleanObject ) | ( ruleIntObject ) | ( ruleRealObject ) | ( ruleStringObject ) );
4648 public final void rule__DataObject__Alternatives() throws RecognitionException {
4649
4650 int stackSize = keepStackSize();
4651
4652 try {
4653 // InternalSolverLanguage.g:1443:1: ( ( ruleBooleanObject ) | ( ruleIntObject ) | ( ruleRealObject ) | ( ruleStringObject ) )
4654 int alt11=4;
4655 switch ( input.LA(1) ) {
4656 case 11:
4657 case 12:
4658 {
4659 alt11=1;
4660 }
4661 break;
4662 case 13:
4663 {
4664 int LA11_2 = input.LA(2);
4665
4666 if ( (LA11_2==RULE_INT) ) {
4667 int LA11_3 = input.LA(3);
4668
4669 if ( (LA11_3==14) ) {
4670 alt11=3;
4671 }
4672 else if ( (LA11_3==EOF||(LA11_3>=RULE_INT && LA11_3<=RULE_STRING)||(LA11_3>=11 && LA11_3<=13)||(LA11_3>=18 && LA11_3<=19)||LA11_3==26||LA11_3==30) ) {
4673 alt11=2;
4674 }
4675 else {
4676 NoViableAltException nvae =
4677 new NoViableAltException("", 11, 3, input);
4678
4679 throw nvae;
4680 }
4681 }
4682 else {
4683 NoViableAltException nvae =
4684 new NoViableAltException("", 11, 2, input);
4685
4686 throw nvae;
4687 }
4688 }
4689 break;
4690 case RULE_INT:
4691 {
4692 int LA11_3 = input.LA(2);
4693
4694 if ( (LA11_3==14) ) {
4695 alt11=3;
4696 }
4697 else if ( (LA11_3==EOF||(LA11_3>=RULE_INT && LA11_3<=RULE_STRING)||(LA11_3>=11 && LA11_3<=13)||(LA11_3>=18 && LA11_3<=19)||LA11_3==26||LA11_3==30) ) {
4698 alt11=2;
4699 }
4700 else {
4701 NoViableAltException nvae =
4702 new NoViableAltException("", 11, 3, input);
4703
4704 throw nvae;
4705 }
4706 }
4707 break;
4708 case RULE_STRING:
4709 {
4710 alt11=4;
4711 }
4712 break;
4713 default:
4714 NoViableAltException nvae =
4715 new NoViableAltException("", 11, 0, input);
4716
4717 throw nvae;
4718 }
4719
4720 switch (alt11) {
4721 case 1 :
4722 // InternalSolverLanguage.g:1444:2: ( ruleBooleanObject )
4723 {
4724 // InternalSolverLanguage.g:1444:2: ( ruleBooleanObject )
4725 // InternalSolverLanguage.g:1445:3: ruleBooleanObject
4726 {
4727 before(grammarAccess.getDataObjectAccess().getBooleanObjectParserRuleCall_0());
4728 pushFollow(FOLLOW_2);
4729 ruleBooleanObject();
4730
4731 state._fsp--;
4732
4733 after(grammarAccess.getDataObjectAccess().getBooleanObjectParserRuleCall_0());
4734
4735 }
4736
4737
4738 }
4739 break;
4740 case 2 :
4741 // InternalSolverLanguage.g:1450:2: ( ruleIntObject )
4742 {
4743 // InternalSolverLanguage.g:1450:2: ( ruleIntObject )
4744 // InternalSolverLanguage.g:1451:3: ruleIntObject
4745 {
4746 before(grammarAccess.getDataObjectAccess().getIntObjectParserRuleCall_1());
4747 pushFollow(FOLLOW_2);
4748 ruleIntObject();
4749
4750 state._fsp--;
4751
4752 after(grammarAccess.getDataObjectAccess().getIntObjectParserRuleCall_1());
4753
4754 }
4755
4756
4757 }
4758 break;
4759 case 3 :
4760 // InternalSolverLanguage.g:1456:2: ( ruleRealObject )
4761 {
4762 // InternalSolverLanguage.g:1456:2: ( ruleRealObject )
4763 // InternalSolverLanguage.g:1457:3: ruleRealObject
4764 {
4765 before(grammarAccess.getDataObjectAccess().getRealObjectParserRuleCall_2());
4766 pushFollow(FOLLOW_2);
4767 ruleRealObject();
4768
4769 state._fsp--;
4770
4771 after(grammarAccess.getDataObjectAccess().getRealObjectParserRuleCall_2());
4772
4773 }
4774
4775
4776 }
4777 break;
4778 case 4 :
4779 // InternalSolverLanguage.g:1462:2: ( ruleStringObject )
4780 {
4781 // InternalSolverLanguage.g:1462:2: ( ruleStringObject )
4782 // InternalSolverLanguage.g:1463:3: ruleStringObject
4783 {
4784 before(grammarAccess.getDataObjectAccess().getStringObjectParserRuleCall_3());
4785 pushFollow(FOLLOW_2);
4786 ruleStringObject();
4787
4788 state._fsp--;
4789
4790 after(grammarAccess.getDataObjectAccess().getStringObjectParserRuleCall_3());
4791
4792 }
4793
4794
4795 }
4796 break;
4797
4798 }
4799 }
4800 catch (RecognitionException re) {
4801 reportError(re);
4802 recover(input,re);
4803 }
4804 finally {
4805
4806 restoreStackSize(stackSize);
4807
4808 }
4809 return ;
4810 }
4811 // $ANTLR end "rule__DataObject__Alternatives"
4812
4813
4814 // $ANTLR start "rule__Predicate__Alternatives"
4815 // InternalSolverLanguage.g:1472:1: rule__Predicate__Alternatives : ( ( rulePredicateSymbol ) | ( ruleErrorPredicate ) );
4816 public final void rule__Predicate__Alternatives() throws RecognitionException {
4817
4818 int stackSize = keepStackSize();
4819
4820 try {
4821 // InternalSolverLanguage.g:1476:1: ( ( rulePredicateSymbol ) | ( ruleErrorPredicate ) )
4822 int alt12=2;
4823 int LA12_0 = input.LA(1);
4824
4825 if ( (LA12_0==27) ) {
4826 alt12=1;
4827 }
4828 else if ( (LA12_0==16) ) {
4829 alt12=2;
4830 }
4831 else {
4832 NoViableAltException nvae =
4833 new NoViableAltException("", 12, 0, input);
4834
4835 throw nvae;
4836 }
4837 switch (alt12) {
4838 case 1 :
4839 // InternalSolverLanguage.g:1477:2: ( rulePredicateSymbol )
4840 {
4841 // InternalSolverLanguage.g:1477:2: ( rulePredicateSymbol )
4842 // InternalSolverLanguage.g:1478:3: rulePredicateSymbol
4843 {
4844 before(grammarAccess.getPredicateAccess().getPredicateSymbolParserRuleCall_0());
4845 pushFollow(FOLLOW_2);
4846 rulePredicateSymbol();
4847
4848 state._fsp--;
4849
4850 after(grammarAccess.getPredicateAccess().getPredicateSymbolParserRuleCall_0());
4851
4852 }
4853
4854
4855 }
4856 break;
4857 case 2 :
4858 // InternalSolverLanguage.g:1483:2: ( ruleErrorPredicate )
4859 {
4860 // InternalSolverLanguage.g:1483:2: ( ruleErrorPredicate )
4861 // InternalSolverLanguage.g:1484:3: ruleErrorPredicate
4862 {
4863 before(grammarAccess.getPredicateAccess().getErrorPredicateParserRuleCall_1());
4864 pushFollow(FOLLOW_2);
4865 ruleErrorPredicate();
4866
4867 state._fsp--;
4868
4869 after(grammarAccess.getPredicateAccess().getErrorPredicateParserRuleCall_1());
4870
4871 }
4872
4873
4874 }
4875 break;
4876
4877 }
4878 }
4879 catch (RecognitionException re) {
4880 reportError(re);
4881 recover(input,re);
4882 }
4883 finally {
4884
4885 restoreStackSize(stackSize);
4886
4887 }
4888 return ;
4889 }
4890 // $ANTLR end "rule__Predicate__Alternatives"
4891
4892
4893 // $ANTLR start "rule__PredicateSymbol__Alternatives_6"
4894 // InternalSolverLanguage.g:1493:1: rule__PredicateSymbol__Alternatives_6 : ( ( 'false' ) | ( ( rule__PredicateSymbol__Group_6_1__0 ) ) );
4895 public final void rule__PredicateSymbol__Alternatives_6() throws RecognitionException {
4896
4897 int stackSize = keepStackSize();
4898
4899 try {
4900 // InternalSolverLanguage.g:1497:1: ( ( 'false' ) | ( ( rule__PredicateSymbol__Group_6_1__0 ) ) )
4901 int alt13=2;
4902 int LA13_0 = input.LA(1);
4903
4904 if ( (LA13_0==11) ) {
4905 alt13=1;
4906 }
4907 else if ( (LA13_0==EOF||LA13_0==RULE_ID||(LA13_0>=12 && LA13_0<=14)||(LA13_0>=28 && LA13_0<=29)) ) {
4908 alt13=2;
4909 }
4910 else {
4911 NoViableAltException nvae =
4912 new NoViableAltException("", 13, 0, input);
4913
4914 throw nvae;
4915 }
4916 switch (alt13) {
4917 case 1 :
4918 // InternalSolverLanguage.g:1498:2: ( 'false' )
4919 {
4920 // InternalSolverLanguage.g:1498:2: ( 'false' )
4921 // InternalSolverLanguage.g:1499:3: 'false'
4922 {
4923 before(grammarAccess.getPredicateSymbolAccess().getFalseKeyword_6_0());
4924 match(input,11,FOLLOW_2);
4925 after(grammarAccess.getPredicateSymbolAccess().getFalseKeyword_6_0());
4926
4927 }
4928
4929
4930 }
4931 break;
4932 case 2 :
4933 // InternalSolverLanguage.g:1504:2: ( ( rule__PredicateSymbol__Group_6_1__0 ) )
4934 {
4935 // InternalSolverLanguage.g:1504:2: ( ( rule__PredicateSymbol__Group_6_1__0 ) )
4936 // InternalSolverLanguage.g:1505:3: ( rule__PredicateSymbol__Group_6_1__0 )
4937 {
4938 before(grammarAccess.getPredicateSymbolAccess().getGroup_6_1());
4939 // InternalSolverLanguage.g:1506:3: ( rule__PredicateSymbol__Group_6_1__0 )
4940 // InternalSolverLanguage.g:1506:4: rule__PredicateSymbol__Group_6_1__0
4941 {
4942 pushFollow(FOLLOW_2);
4943 rule__PredicateSymbol__Group_6_1__0();
4944
4945 state._fsp--;
4946
4947
4948 }
4949
4950 after(grammarAccess.getPredicateSymbolAccess().getGroup_6_1());
4951
4952 }
4953
4954
4955 }
4956 break;
4957
4958 }
4959 }
4960 catch (RecognitionException re) {
4961 reportError(re);
4962 recover(input,re);
4963 }
4964 finally {
4965
4966 restoreStackSize(stackSize);
4967
4968 }
4969 return ;
4970 }
4971 // $ANTLR end "rule__PredicateSymbol__Alternatives_6"
4972
4973
4974 // $ANTLR start "rule__ErrorPredicate__Alternatives_5"
4975 // InternalSolverLanguage.g:1514:1: rule__ErrorPredicate__Alternatives_5 : ( ( 'false' ) | ( ( rule__ErrorPredicate__Group_5_1__0 ) ) );
4976 public final void rule__ErrorPredicate__Alternatives_5() throws RecognitionException {
4977
4978 int stackSize = keepStackSize();
4979
4980 try {
4981 // InternalSolverLanguage.g:1518:1: ( ( 'false' ) | ( ( rule__ErrorPredicate__Group_5_1__0 ) ) )
4982 int alt14=2;
4983 int LA14_0 = input.LA(1);
4984
4985 if ( (LA14_0==11) ) {
4986 alt14=1;
4987 }
4988 else if ( (LA14_0==EOF||LA14_0==RULE_ID||(LA14_0>=12 && LA14_0<=14)||(LA14_0>=28 && LA14_0<=29)) ) {
4989 alt14=2;
4990 }
4991 else {
4992 NoViableAltException nvae =
4993 new NoViableAltException("", 14, 0, input);
4994
4995 throw nvae;
4996 }
4997 switch (alt14) {
4998 case 1 :
4999 // InternalSolverLanguage.g:1519:2: ( 'false' )
5000 {
5001 // InternalSolverLanguage.g:1519:2: ( 'false' )
5002 // InternalSolverLanguage.g:1520:3: 'false'
5003 {
5004 before(grammarAccess.getErrorPredicateAccess().getFalseKeyword_5_0());
5005 match(input,11,FOLLOW_2);
5006 after(grammarAccess.getErrorPredicateAccess().getFalseKeyword_5_0());
5007
5008 }
5009
5010
5011 }
5012 break;
5013 case 2 :
5014 // InternalSolverLanguage.g:1525:2: ( ( rule__ErrorPredicate__Group_5_1__0 ) )
5015 {
5016 // InternalSolverLanguage.g:1525:2: ( ( rule__ErrorPredicate__Group_5_1__0 ) )
5017 // InternalSolverLanguage.g:1526:3: ( rule__ErrorPredicate__Group_5_1__0 )
5018 {
5019 before(grammarAccess.getErrorPredicateAccess().getGroup_5_1());
5020 // InternalSolverLanguage.g:1527:3: ( rule__ErrorPredicate__Group_5_1__0 )
5021 // InternalSolverLanguage.g:1527:4: rule__ErrorPredicate__Group_5_1__0
5022 {
5023 pushFollow(FOLLOW_2);
5024 rule__ErrorPredicate__Group_5_1__0();
5025
5026 state._fsp--;
5027
5028
5029 }
5030
5031 after(grammarAccess.getErrorPredicateAccess().getGroup_5_1());
5032
5033 }
5034
5035
5036 }
5037 break;
5038
5039 }
5040 }
5041 catch (RecognitionException re) {
5042 reportError(re);
5043 recover(input,re);
5044 }
5045 finally {
5046
5047 restoreStackSize(stackSize);
5048
5049 }
5050 return ;
5051 }
5052 // $ANTLR end "rule__ErrorPredicate__Alternatives_5"
5053
5054
5055 // $ANTLR start "rule__PatternBody__Alternatives_1"
5056 // InternalSolverLanguage.g:1535:1: rule__PatternBody__Alternatives_1 : ( ( 'true' ) | ( ( rule__PatternBody__ConstraintsAssignment_1_1 )* ) );
5057 public final void rule__PatternBody__Alternatives_1() throws RecognitionException {
5058
5059 int stackSize = keepStackSize();
5060
5061 try {
5062 // InternalSolverLanguage.g:1539:1: ( ( 'true' ) | ( ( rule__PatternBody__ConstraintsAssignment_1_1 )* ) )
5063 int alt16=2;
5064 int LA16_0 = input.LA(1);
5065
5066 if ( (LA16_0==12) ) {
5067 alt16=1;
5068 }
5069 else if ( (LA16_0==EOF||LA16_0==RULE_ID||(LA16_0>=13 && LA16_0<=14)||(LA16_0>=28 && LA16_0<=29)) ) {
5070 alt16=2;
5071 }
5072 else {
5073 NoViableAltException nvae =
5074 new NoViableAltException("", 16, 0, input);
5075
5076 throw nvae;
5077 }
5078 switch (alt16) {
5079 case 1 :
5080 // InternalSolverLanguage.g:1540:2: ( 'true' )
5081 {
5082 // InternalSolverLanguage.g:1540:2: ( 'true' )
5083 // InternalSolverLanguage.g:1541:3: 'true'
5084 {
5085 before(grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0());
5086 match(input,12,FOLLOW_2);
5087 after(grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0());
5088
5089 }
5090
5091
5092 }
5093 break;
5094 case 2 :
5095 // InternalSolverLanguage.g:1546:2: ( ( rule__PatternBody__ConstraintsAssignment_1_1 )* )
5096 {
5097 // InternalSolverLanguage.g:1546:2: ( ( rule__PatternBody__ConstraintsAssignment_1_1 )* )
5098 // InternalSolverLanguage.g:1547:3: ( rule__PatternBody__ConstraintsAssignment_1_1 )*
5099 {
5100 before(grammarAccess.getPatternBodyAccess().getConstraintsAssignment_1_1());
5101 // InternalSolverLanguage.g:1548:3: ( rule__PatternBody__ConstraintsAssignment_1_1 )*
5102 loop15:
5103 do {
5104 int alt15=2;
5105 int LA15_0 = input.LA(1);
5106
5107 if ( (LA15_0==RULE_ID||LA15_0==13||LA15_0==29) ) {
5108 alt15=1;
5109 }
5110
5111
5112 switch (alt15) {
5113 case 1 :
5114 // InternalSolverLanguage.g:1548:4: rule__PatternBody__ConstraintsAssignment_1_1
5115 {
5116 pushFollow(FOLLOW_4);
5117 rule__PatternBody__ConstraintsAssignment_1_1();
5118
5119 state._fsp--;
5120
5121
5122 }
5123 break;
5124
5125 default :
5126 break loop15;
5127 }
5128 } while (true);
5129
5130 after(grammarAccess.getPatternBodyAccess().getConstraintsAssignment_1_1());
5131
5132 }
5133
5134
5135 }
5136 break;
5137
5138 }
5139 }
5140 catch (RecognitionException re) {
5141 reportError(re);
5142 recover(input,re);
5143 }
5144 finally {
5145
5146 restoreStackSize(stackSize);
5147
5148 }
5149 return ;
5150 }
5151 // $ANTLR end "rule__PatternBody__Alternatives_1"
5152
5153
5154 // $ANTLR start "rule__Polarity__Alternatives"
5155 // InternalSolverLanguage.g:1556:1: rule__Polarity__Alternatives : ( ( ( rule__Polarity__Group_0__0 ) ) | ( ( rule__Polarity__Group_1__0 ) ) );
5156 public final void rule__Polarity__Alternatives() throws RecognitionException {
5157
5158 int stackSize = keepStackSize();
5159
5160 try {
5161 // InternalSolverLanguage.g:1560:1: ( ( ( rule__Polarity__Group_0__0 ) ) | ( ( rule__Polarity__Group_1__0 ) ) )
5162 int alt17=2;
5163 int LA17_0 = input.LA(1);
5164
5165 if ( (LA17_0==29) ) {
5166 alt17=1;
5167 }
5168 else if ( (LA17_0==13) ) {
5169 alt17=2;
5170 }
5171 else {
5172 NoViableAltException nvae =
5173 new NoViableAltException("", 17, 0, input);
5174
5175 throw nvae;
5176 }
5177 switch (alt17) {
5178 case 1 :
5179 // InternalSolverLanguage.g:1561:2: ( ( rule__Polarity__Group_0__0 ) )
5180 {
5181 // InternalSolverLanguage.g:1561:2: ( ( rule__Polarity__Group_0__0 ) )
5182 // InternalSolverLanguage.g:1562:3: ( rule__Polarity__Group_0__0 )
5183 {
5184 before(grammarAccess.getPolarityAccess().getGroup_0());
5185 // InternalSolverLanguage.g:1563:3: ( rule__Polarity__Group_0__0 )
5186 // InternalSolverLanguage.g:1563:4: rule__Polarity__Group_0__0
5187 {
5188 pushFollow(FOLLOW_2);
5189 rule__Polarity__Group_0__0();
5190
5191 state._fsp--;
5192
5193
5194 }
5195
5196 after(grammarAccess.getPolarityAccess().getGroup_0());
5197
5198 }
5199
5200
5201 }
5202 break;
5203 case 2 :
5204 // InternalSolverLanguage.g:1567:2: ( ( rule__Polarity__Group_1__0 ) )
5205 {
5206 // InternalSolverLanguage.g:1567:2: ( ( rule__Polarity__Group_1__0 ) )
5207 // InternalSolverLanguage.g:1568:3: ( rule__Polarity__Group_1__0 )
5208 {
5209 before(grammarAccess.getPolarityAccess().getGroup_1());
5210 // InternalSolverLanguage.g:1569:3: ( rule__Polarity__Group_1__0 )
5211 // InternalSolverLanguage.g:1569:4: rule__Polarity__Group_1__0
5212 {
5213 pushFollow(FOLLOW_2);
5214 rule__Polarity__Group_1__0();
5215
5216 state._fsp--;
5217
5218
5219 }
5220
5221 after(grammarAccess.getPolarityAccess().getGroup_1());
5222
5223 }
5224
5225
5226 }
5227 break;
5228
5229 }
5230 }
5231 catch (RecognitionException re) {
5232 reportError(re);
5233 recover(input,re);
5234 }
5235 finally {
5236
5237 restoreStackSize(stackSize);
5238
5239 }
5240 return ;
5241 }
5242 // $ANTLR end "rule__Polarity__Alternatives"
5243
5244
5245 // $ANTLR start "rule__Constraint__Alternatives_2"
5246 // InternalSolverLanguage.g:1577:1: rule__Constraint__Alternatives_2 : ( ( ( rule__Constraint__Group_2_0__0 ) ) | ( ( rule__Constraint__Group_2_1__0 ) ) );
5247 public final void rule__Constraint__Alternatives_2() throws RecognitionException {
5248
5249 int stackSize = keepStackSize();
5250
5251 try {
5252 // InternalSolverLanguage.g:1581:1: ( ( ( rule__Constraint__Group_2_0__0 ) ) | ( ( rule__Constraint__Group_2_1__0 ) ) )
5253 int alt18=2;
5254 int LA18_0 = input.LA(1);
5255
5256 if ( (LA18_0==17) ) {
5257 alt18=1;
5258 }
5259 else if ( ((LA18_0>=29 && LA18_0<=30)) ) {
5260 alt18=2;
5261 }
5262 else {
5263 NoViableAltException nvae =
5264 new NoViableAltException("", 18, 0, input);
5265
5266 throw nvae;
5267 }
5268 switch (alt18) {
5269 case 1 :
5270 // InternalSolverLanguage.g:1582:2: ( ( rule__Constraint__Group_2_0__0 ) )
5271 {
5272 // InternalSolverLanguage.g:1582:2: ( ( rule__Constraint__Group_2_0__0 ) )
5273 // InternalSolverLanguage.g:1583:3: ( rule__Constraint__Group_2_0__0 )
5274 {
5275 before(grammarAccess.getConstraintAccess().getGroup_2_0());
5276 // InternalSolverLanguage.g:1584:3: ( rule__Constraint__Group_2_0__0 )
5277 // InternalSolverLanguage.g:1584:4: rule__Constraint__Group_2_0__0
5278 {
5279 pushFollow(FOLLOW_2);
5280 rule__Constraint__Group_2_0__0();
5281
5282 state._fsp--;
5283
5284
5285 }
5286
5287 after(grammarAccess.getConstraintAccess().getGroup_2_0());
5288
5289 }
5290
5291
5292 }
5293 break;
5294 case 2 :
5295 // InternalSolverLanguage.g:1588:2: ( ( rule__Constraint__Group_2_1__0 ) )
5296 {
5297 // InternalSolverLanguage.g:1588:2: ( ( rule__Constraint__Group_2_1__0 ) )
5298 // InternalSolverLanguage.g:1589:3: ( rule__Constraint__Group_2_1__0 )
5299 {
5300 before(grammarAccess.getConstraintAccess().getGroup_2_1());
5301 // InternalSolverLanguage.g:1590:3: ( rule__Constraint__Group_2_1__0 )
5302 // InternalSolverLanguage.g:1590:4: rule__Constraint__Group_2_1__0
5303 {
5304 pushFollow(FOLLOW_2);
5305 rule__Constraint__Group_2_1__0();
5306
5307 state._fsp--;
5308
5309
5310 }
5311
5312 after(grammarAccess.getConstraintAccess().getGroup_2_1());
5313
5314 }
5315
5316
5317 }
5318 break;
5319
5320 }
5321 }
5322 catch (RecognitionException re) {
5323 reportError(re);
5324 recover(input,re);
5325 }
5326 finally {
5327
5328 restoreStackSize(stackSize);
5329
5330 }
5331 return ;
5332 }
5333 // $ANTLR end "rule__Constraint__Alternatives_2"
5334
5335
5336 // $ANTLR start "rule__ClosureType__Alternatives"
5337 // InternalSolverLanguage.g:1598:1: rule__ClosureType__Alternatives : ( ( ( rule__ClosureType__Group_0__0 ) ) | ( ( rule__ClosureType__Group_1__0 ) ) );
5338 public final void rule__ClosureType__Alternatives() throws RecognitionException {
5339
5340 int stackSize = keepStackSize();
5341
5342 try {
5343 // InternalSolverLanguage.g:1602:1: ( ( ( rule__ClosureType__Group_0__0 ) ) | ( ( rule__ClosureType__Group_1__0 ) ) )
5344 int alt19=2;
5345 int LA19_0 = input.LA(1);
5346
5347 if ( (LA19_0==30) ) {
5348 alt19=1;
5349 }
5350 else if ( (LA19_0==29) ) {
5351 alt19=2;
5352 }
5353 else {
5354 NoViableAltException nvae =
5355 new NoViableAltException("", 19, 0, input);
5356
5357 throw nvae;
5358 }
5359 switch (alt19) {
5360 case 1 :
5361 // InternalSolverLanguage.g:1603:2: ( ( rule__ClosureType__Group_0__0 ) )
5362 {
5363 // InternalSolverLanguage.g:1603:2: ( ( rule__ClosureType__Group_0__0 ) )
5364 // InternalSolverLanguage.g:1604:3: ( rule__ClosureType__Group_0__0 )
5365 {
5366 before(grammarAccess.getClosureTypeAccess().getGroup_0());
5367 // InternalSolverLanguage.g:1605:3: ( rule__ClosureType__Group_0__0 )
5368 // InternalSolverLanguage.g:1605:4: rule__ClosureType__Group_0__0
5369 {
5370 pushFollow(FOLLOW_2);
5371 rule__ClosureType__Group_0__0();
5372
5373 state._fsp--;
5374
5375
5376 }
5377
5378 after(grammarAccess.getClosureTypeAccess().getGroup_0());
5379
5380 }
5381
5382
5383 }
5384 break;
5385 case 2 :
5386 // InternalSolverLanguage.g:1609:2: ( ( rule__ClosureType__Group_1__0 ) )
5387 {
5388 // InternalSolverLanguage.g:1609:2: ( ( rule__ClosureType__Group_1__0 ) )
5389 // InternalSolverLanguage.g:1610:3: ( rule__ClosureType__Group_1__0 )
5390 {
5391 before(grammarAccess.getClosureTypeAccess().getGroup_1());
5392 // InternalSolverLanguage.g:1611:3: ( rule__ClosureType__Group_1__0 )
5393 // InternalSolverLanguage.g:1611:4: rule__ClosureType__Group_1__0
5394 {
5395 pushFollow(FOLLOW_2);
5396 rule__ClosureType__Group_1__0();
5397
5398 state._fsp--;
5399
5400
5401 }
5402
5403 after(grammarAccess.getClosureTypeAccess().getGroup_1());
5404
5405 }
5406
5407
5408 }
5409 break;
5410
5411 }
5412 }
5413 catch (RecognitionException re) {
5414 reportError(re);
5415 recover(input,re);
5416 }
5417 finally {
5418
5419 restoreStackSize(stackSize);
5420
5421 }
5422 return ;
5423 }
5424 // $ANTLR end "rule__ClosureType__Alternatives"
5425
5426
5427 // $ANTLR start "rule__Literal__Alternatives"
5428 // InternalSolverLanguage.g:1619:1: rule__Literal__Alternatives : ( ( ruleVariable ) | ( ruleDataObject ) );
5429 public final void rule__Literal__Alternatives() throws RecognitionException {
5430
5431 int stackSize = keepStackSize();
5432
5433 try {
5434 // InternalSolverLanguage.g:1623:1: ( ( ruleVariable ) | ( ruleDataObject ) )
5435 int alt20=2;
5436 int LA20_0 = input.LA(1);
5437
5438 if ( (LA20_0==RULE_ID) ) {
5439 alt20=1;
5440 }
5441 else if ( (LA20_0==RULE_INT||LA20_0==RULE_STRING||(LA20_0>=11 && LA20_0<=13)) ) {
5442 alt20=2;
5443 }
5444 else {
5445 NoViableAltException nvae =
5446 new NoViableAltException("", 20, 0, input);
5447
5448 throw nvae;
5449 }
5450 switch (alt20) {
5451 case 1 :
5452 // InternalSolverLanguage.g:1624:2: ( ruleVariable )
5453 {
5454 // InternalSolverLanguage.g:1624:2: ( ruleVariable )
5455 // InternalSolverLanguage.g:1625:3: ruleVariable
5456 {
5457 before(grammarAccess.getLiteralAccess().getVariableParserRuleCall_0());
5458 pushFollow(FOLLOW_2);
5459 ruleVariable();
5460
5461 state._fsp--;
5462
5463 after(grammarAccess.getLiteralAccess().getVariableParserRuleCall_0());
5464
5465 }
5466
5467
5468 }
5469 break;
5470 case 2 :
5471 // InternalSolverLanguage.g:1630:2: ( ruleDataObject )
5472 {
5473 // InternalSolverLanguage.g:1630:2: ( ruleDataObject )
5474 // InternalSolverLanguage.g:1631:3: ruleDataObject
5475 {
5476 before(grammarAccess.getLiteralAccess().getDataObjectParserRuleCall_1());
5477 pushFollow(FOLLOW_2);
5478 ruleDataObject();
5479
5480 state._fsp--;
5481
5482 after(grammarAccess.getLiteralAccess().getDataObjectParserRuleCall_1());
5483
5484 }
5485
5486
5487 }
5488 break;
5489
5490 }
5491 }
5492 catch (RecognitionException re) {
5493 reportError(re);
5494 recover(input,re);
5495 }
5496 finally {
5497
5498 restoreStackSize(stackSize);
5499
5500 }
5501 return ;
5502 }
5503 // $ANTLR end "rule__Literal__Alternatives"
5504
5505
5506 // $ANTLR start "rule__CDInterpretation__Alternatives"
5507 // InternalSolverLanguage.g:1640:1: rule__CDInterpretation__Alternatives : ( ( ruleClassInterpretation ) | ( ruleEnumInterpretation ) | ( ruleGlobalRelationInterpretation ) );
5508 public final void rule__CDInterpretation__Alternatives() throws RecognitionException {
5509
5510 int stackSize = keepStackSize();
5511
5512 try {
5513 // InternalSolverLanguage.g:1644:1: ( ( ruleClassInterpretation ) | ( ruleEnumInterpretation ) | ( ruleGlobalRelationInterpretation ) )
5514 int alt21=3;
5515 switch ( input.LA(1) ) {
5516 case 39:
5517 {
5518 alt21=1;
5519 }
5520 break;
5521 case 36:
5522 {
5523 alt21=2;
5524 }
5525 break;
5526 case 40:
5527 {
5528 alt21=3;
5529 }
5530 break;
5531 default:
5532 NoViableAltException nvae =
5533 new NoViableAltException("", 21, 0, input);
5534
5535 throw nvae;
5536 }
5537
5538 switch (alt21) {
5539 case 1 :
5540 // InternalSolverLanguage.g:1645:2: ( ruleClassInterpretation )
5541 {
5542 // InternalSolverLanguage.g:1645:2: ( ruleClassInterpretation )
5543 // InternalSolverLanguage.g:1646:3: ruleClassInterpretation
5544 {
5545 before(grammarAccess.getCDInterpretationAccess().getClassInterpretationParserRuleCall_0());
5546 pushFollow(FOLLOW_2);
5547 ruleClassInterpretation();
5548
5549 state._fsp--;
5550
5551 after(grammarAccess.getCDInterpretationAccess().getClassInterpretationParserRuleCall_0());
5552
5553 }
5554
5555
5556 }
5557 break;
5558 case 2 :
5559 // InternalSolverLanguage.g:1651:2: ( ruleEnumInterpretation )
5560 {
5561 // InternalSolverLanguage.g:1651:2: ( ruleEnumInterpretation )
5562 // InternalSolverLanguage.g:1652:3: ruleEnumInterpretation
5563 {
5564 before(grammarAccess.getCDInterpretationAccess().getEnumInterpretationParserRuleCall_1());
5565 pushFollow(FOLLOW_2);
5566 ruleEnumInterpretation();
5567
5568 state._fsp--;
5569
5570 after(grammarAccess.getCDInterpretationAccess().getEnumInterpretationParserRuleCall_1());
5571
5572 }
5573
5574
5575 }
5576 break;
5577 case 3 :
5578 // InternalSolverLanguage.g:1657:2: ( ruleGlobalRelationInterpretation )
5579 {
5580 // InternalSolverLanguage.g:1657:2: ( ruleGlobalRelationInterpretation )
5581 // InternalSolverLanguage.g:1658:3: ruleGlobalRelationInterpretation
5582 {
5583 before(grammarAccess.getCDInterpretationAccess().getGlobalRelationInterpretationParserRuleCall_2());
5584 pushFollow(FOLLOW_2);
5585 ruleGlobalRelationInterpretation();
5586
5587 state._fsp--;
5588
5589 after(grammarAccess.getCDInterpretationAccess().getGlobalRelationInterpretationParserRuleCall_2());
5590
5591 }
5592
5593
5594 }
5595 break;
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__CDInterpretation__Alternatives"
5611
5612
5613 // $ANTLR start "rule__MultiplicityDefinition__Alternatives_2"
5614 // InternalSolverLanguage.g:1667:1: rule__MultiplicityDefinition__Alternatives_2 : ( ( ( rule__MultiplicityDefinition__UpperAssignment_2_0 ) ) | ( ( rule__MultiplicityDefinition__UnlimitedUpperAssignment_2_1 ) ) );
5615 public final void rule__MultiplicityDefinition__Alternatives_2() throws RecognitionException {
5616
5617 int stackSize = keepStackSize();
5618
5619 try {
5620 // InternalSolverLanguage.g:1671:1: ( ( ( rule__MultiplicityDefinition__UpperAssignment_2_0 ) ) | ( ( rule__MultiplicityDefinition__UnlimitedUpperAssignment_2_1 ) ) )
5621 int alt22=2;
5622 int LA22_0 = input.LA(1);
5623
5624 if ( (LA22_0==RULE_INT) ) {
5625 alt22=1;
5626 }
5627 else if ( (LA22_0==30) ) {
5628 alt22=2;
5629 }
5630 else {
5631 NoViableAltException nvae =
5632 new NoViableAltException("", 22, 0, input);
5633
5634 throw nvae;
5635 }
5636 switch (alt22) {
5637 case 1 :
5638 // InternalSolverLanguage.g:1672:2: ( ( rule__MultiplicityDefinition__UpperAssignment_2_0 ) )
5639 {
5640 // InternalSolverLanguage.g:1672:2: ( ( rule__MultiplicityDefinition__UpperAssignment_2_0 ) )
5641 // InternalSolverLanguage.g:1673:3: ( rule__MultiplicityDefinition__UpperAssignment_2_0 )
5642 {
5643 before(grammarAccess.getMultiplicityDefinitionAccess().getUpperAssignment_2_0());
5644 // InternalSolverLanguage.g:1674:3: ( rule__MultiplicityDefinition__UpperAssignment_2_0 )
5645 // InternalSolverLanguage.g:1674:4: rule__MultiplicityDefinition__UpperAssignment_2_0
5646 {
5647 pushFollow(FOLLOW_2);
5648 rule__MultiplicityDefinition__UpperAssignment_2_0();
5649
5650 state._fsp--;
5651
5652
5653 }
5654
5655 after(grammarAccess.getMultiplicityDefinitionAccess().getUpperAssignment_2_0());
5656
5657 }
5658
5659
5660 }
5661 break;
5662 case 2 :
5663 // InternalSolverLanguage.g:1678:2: ( ( rule__MultiplicityDefinition__UnlimitedUpperAssignment_2_1 ) )
5664 {
5665 // InternalSolverLanguage.g:1678:2: ( ( rule__MultiplicityDefinition__UnlimitedUpperAssignment_2_1 ) )
5666 // InternalSolverLanguage.g:1679:3: ( rule__MultiplicityDefinition__UnlimitedUpperAssignment_2_1 )
5667 {
5668 before(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAssignment_2_1());
5669 // InternalSolverLanguage.g:1680:3: ( rule__MultiplicityDefinition__UnlimitedUpperAssignment_2_1 )
5670 // InternalSolverLanguage.g:1680:4: rule__MultiplicityDefinition__UnlimitedUpperAssignment_2_1
5671 {
5672 pushFollow(FOLLOW_2);
5673 rule__MultiplicityDefinition__UnlimitedUpperAssignment_2_1();
5674
5675 state._fsp--;
5676
5677
5678 }
5679
5680 after(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAssignment_2_1());
5681
5682 }
5683
5684
5685 }
5686 break;
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__MultiplicityDefinition__Alternatives_2"
5702
5703
5704 // $ANTLR start "rule__REALLiteral__Group__0"
5705 // InternalSolverLanguage.g:1688:1: rule__REALLiteral__Group__0 : rule__REALLiteral__Group__0__Impl rule__REALLiteral__Group__1 ;
5706 public final void rule__REALLiteral__Group__0() throws RecognitionException {
5707
5708 int stackSize = keepStackSize();
5709
5710 try {
5711 // InternalSolverLanguage.g:1692:1: ( rule__REALLiteral__Group__0__Impl rule__REALLiteral__Group__1 )
5712 // InternalSolverLanguage.g:1693:2: rule__REALLiteral__Group__0__Impl rule__REALLiteral__Group__1
5713 {
5714 pushFollow(FOLLOW_5);
5715 rule__REALLiteral__Group__0__Impl();
5716
5717 state._fsp--;
5718
5719 pushFollow(FOLLOW_2);
5720 rule__REALLiteral__Group__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__REALLiteral__Group__0"
5740
5741
5742 // $ANTLR start "rule__REALLiteral__Group__0__Impl"
5743 // InternalSolverLanguage.g:1700:1: rule__REALLiteral__Group__0__Impl : ( ( '-' )? ) ;
5744 public final void rule__REALLiteral__Group__0__Impl() throws RecognitionException {
5745
5746 int stackSize = keepStackSize();
5747
5748 try {
5749 // InternalSolverLanguage.g:1704:1: ( ( ( '-' )? ) )
5750 // InternalSolverLanguage.g:1705:1: ( ( '-' )? )
5751 {
5752 // InternalSolverLanguage.g:1705:1: ( ( '-' )? )
5753 // InternalSolverLanguage.g:1706:2: ( '-' )?
5754 {
5755 before(grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0());
5756 // InternalSolverLanguage.g:1707:2: ( '-' )?
5757 int alt23=2;
5758 int LA23_0 = input.LA(1);
5759
5760 if ( (LA23_0==13) ) {
5761 alt23=1;
5762 }
5763 switch (alt23) {
5764 case 1 :
5765 // InternalSolverLanguage.g:1707:3: '-'
5766 {
5767 match(input,13,FOLLOW_2);
5768
5769 }
5770 break;
5771
5772 }
5773
5774 after(grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0());
5775
5776 }
5777
5778
5779 }
5780
5781 }
5782 catch (RecognitionException re) {
5783 reportError(re);
5784 recover(input,re);
5785 }
5786 finally {
5787
5788 restoreStackSize(stackSize);
5789
5790 }
5791 return ;
5792 }
5793 // $ANTLR end "rule__REALLiteral__Group__0__Impl"
5794
5795
5796 // $ANTLR start "rule__REALLiteral__Group__1"
5797 // InternalSolverLanguage.g:1715:1: rule__REALLiteral__Group__1 : rule__REALLiteral__Group__1__Impl rule__REALLiteral__Group__2 ;
5798 public final void rule__REALLiteral__Group__1() throws RecognitionException {
5799
5800 int stackSize = keepStackSize();
5801
5802 try {
5803 // InternalSolverLanguage.g:1719:1: ( rule__REALLiteral__Group__1__Impl rule__REALLiteral__Group__2 )
5804 // InternalSolverLanguage.g:1720:2: rule__REALLiteral__Group__1__Impl rule__REALLiteral__Group__2
5805 {
5806 pushFollow(FOLLOW_6);
5807 rule__REALLiteral__Group__1__Impl();
5808
5809 state._fsp--;
5810
5811 pushFollow(FOLLOW_2);
5812 rule__REALLiteral__Group__2();
5813
5814 state._fsp--;
5815
5816
5817 }
5818
5819 }
5820 catch (RecognitionException re) {
5821 reportError(re);
5822 recover(input,re);
5823 }
5824 finally {
5825
5826 restoreStackSize(stackSize);
5827
5828 }
5829 return ;
5830 }
5831 // $ANTLR end "rule__REALLiteral__Group__1"
5832
5833
5834 // $ANTLR start "rule__REALLiteral__Group__1__Impl"
5835 // InternalSolverLanguage.g:1727:1: rule__REALLiteral__Group__1__Impl : ( RULE_INT ) ;
5836 public final void rule__REALLiteral__Group__1__Impl() throws RecognitionException {
5837
5838 int stackSize = keepStackSize();
5839
5840 try {
5841 // InternalSolverLanguage.g:1731:1: ( ( RULE_INT ) )
5842 // InternalSolverLanguage.g:1732:1: ( RULE_INT )
5843 {
5844 // InternalSolverLanguage.g:1732:1: ( RULE_INT )
5845 // InternalSolverLanguage.g:1733:2: RULE_INT
5846 {
5847 before(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1());
5848 match(input,RULE_INT,FOLLOW_2);
5849 after(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1());
5850
5851 }
5852
5853
5854 }
5855
5856 }
5857 catch (RecognitionException re) {
5858 reportError(re);
5859 recover(input,re);
5860 }
5861 finally {
5862
5863 restoreStackSize(stackSize);
5864
5865 }
5866 return ;
5867 }
5868 // $ANTLR end "rule__REALLiteral__Group__1__Impl"
5869
5870
5871 // $ANTLR start "rule__REALLiteral__Group__2"
5872 // InternalSolverLanguage.g:1742:1: rule__REALLiteral__Group__2 : rule__REALLiteral__Group__2__Impl rule__REALLiteral__Group__3 ;
5873 public final void rule__REALLiteral__Group__2() throws RecognitionException {
5874
5875 int stackSize = keepStackSize();
5876
5877 try {
5878 // InternalSolverLanguage.g:1746:1: ( rule__REALLiteral__Group__2__Impl rule__REALLiteral__Group__3 )
5879 // InternalSolverLanguage.g:1747:2: rule__REALLiteral__Group__2__Impl rule__REALLiteral__Group__3
5880 {
5881 pushFollow(FOLLOW_5);
5882 rule__REALLiteral__Group__2__Impl();
5883
5884 state._fsp--;
5885
5886 pushFollow(FOLLOW_2);
5887 rule__REALLiteral__Group__3();
5888
5889 state._fsp--;
5890
5891
5892 }
5893
5894 }
5895 catch (RecognitionException re) {
5896 reportError(re);
5897 recover(input,re);
5898 }
5899 finally {
5900
5901 restoreStackSize(stackSize);
5902
5903 }
5904 return ;
5905 }
5906 // $ANTLR end "rule__REALLiteral__Group__2"
5907
5908
5909 // $ANTLR start "rule__REALLiteral__Group__2__Impl"
5910 // InternalSolverLanguage.g:1754:1: rule__REALLiteral__Group__2__Impl : ( '.' ) ;
5911 public final void rule__REALLiteral__Group__2__Impl() throws RecognitionException {
5912
5913 int stackSize = keepStackSize();
5914
5915 try {
5916 // InternalSolverLanguage.g:1758:1: ( ( '.' ) )
5917 // InternalSolverLanguage.g:1759:1: ( '.' )
5918 {
5919 // InternalSolverLanguage.g:1759:1: ( '.' )
5920 // InternalSolverLanguage.g:1760:2: '.'
5921 {
5922 before(grammarAccess.getREALLiteralAccess().getFullStopKeyword_2());
5923 match(input,14,FOLLOW_2);
5924 after(grammarAccess.getREALLiteralAccess().getFullStopKeyword_2());
5925
5926 }
5927
5928
5929 }
5930
5931 }
5932 catch (RecognitionException re) {
5933 reportError(re);
5934 recover(input,re);
5935 }
5936 finally {
5937
5938 restoreStackSize(stackSize);
5939
5940 }
5941 return ;
5942 }
5943 // $ANTLR end "rule__REALLiteral__Group__2__Impl"
5944
5945
5946 // $ANTLR start "rule__REALLiteral__Group__3"
5947 // InternalSolverLanguage.g:1769:1: rule__REALLiteral__Group__3 : rule__REALLiteral__Group__3__Impl ;
5948 public final void rule__REALLiteral__Group__3() throws RecognitionException {
5949
5950 int stackSize = keepStackSize();
5951
5952 try {
5953 // InternalSolverLanguage.g:1773:1: ( rule__REALLiteral__Group__3__Impl )
5954 // InternalSolverLanguage.g:1774:2: rule__REALLiteral__Group__3__Impl
5955 {
5956 pushFollow(FOLLOW_2);
5957 rule__REALLiteral__Group__3__Impl();
5958
5959 state._fsp--;
5960
5961
5962 }
5963
5964 }
5965 catch (RecognitionException re) {
5966 reportError(re);
5967 recover(input,re);
5968 }
5969 finally {
5970
5971 restoreStackSize(stackSize);
5972
5973 }
5974 return ;
5975 }
5976 // $ANTLR end "rule__REALLiteral__Group__3"
5977
5978
5979 // $ANTLR start "rule__REALLiteral__Group__3__Impl"
5980 // InternalSolverLanguage.g:1780:1: rule__REALLiteral__Group__3__Impl : ( RULE_INT ) ;
5981 public final void rule__REALLiteral__Group__3__Impl() throws RecognitionException {
5982
5983 int stackSize = keepStackSize();
5984
5985 try {
5986 // InternalSolverLanguage.g:1784:1: ( ( RULE_INT ) )
5987 // InternalSolverLanguage.g:1785:1: ( RULE_INT )
5988 {
5989 // InternalSolverLanguage.g:1785:1: ( RULE_INT )
5990 // InternalSolverLanguage.g:1786:2: RULE_INT
5991 {
5992 before(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3());
5993 match(input,RULE_INT,FOLLOW_2);
5994 after(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3());
5995
5996 }
5997
5998
5999 }
6000
6001 }
6002 catch (RecognitionException re) {
6003 reportError(re);
6004 recover(input,re);
6005 }
6006 finally {
6007
6008 restoreStackSize(stackSize);
6009
6010 }
6011 return ;
6012 }
6013 // $ANTLR end "rule__REALLiteral__Group__3__Impl"
6014
6015
6016 // $ANTLR start "rule__INTLiteral__Group__0"
6017 // InternalSolverLanguage.g:1796:1: rule__INTLiteral__Group__0 : rule__INTLiteral__Group__0__Impl rule__INTLiteral__Group__1 ;
6018 public final void rule__INTLiteral__Group__0() throws RecognitionException {
6019
6020 int stackSize = keepStackSize();
6021
6022 try {
6023 // InternalSolverLanguage.g:1800:1: ( rule__INTLiteral__Group__0__Impl rule__INTLiteral__Group__1 )
6024 // InternalSolverLanguage.g:1801:2: rule__INTLiteral__Group__0__Impl rule__INTLiteral__Group__1
6025 {
6026 pushFollow(FOLLOW_5);
6027 rule__INTLiteral__Group__0__Impl();
6028
6029 state._fsp--;
6030
6031 pushFollow(FOLLOW_2);
6032 rule__INTLiteral__Group__1();
6033
6034 state._fsp--;
6035
6036
6037 }
6038
6039 }
6040 catch (RecognitionException re) {
6041 reportError(re);
6042 recover(input,re);
6043 }
6044 finally {
6045
6046 restoreStackSize(stackSize);
6047
6048 }
6049 return ;
6050 }
6051 // $ANTLR end "rule__INTLiteral__Group__0"
6052
6053
6054 // $ANTLR start "rule__INTLiteral__Group__0__Impl"
6055 // InternalSolverLanguage.g:1808:1: rule__INTLiteral__Group__0__Impl : ( ( '-' )? ) ;
6056 public final void rule__INTLiteral__Group__0__Impl() throws RecognitionException {
6057
6058 int stackSize = keepStackSize();
6059
6060 try {
6061 // InternalSolverLanguage.g:1812:1: ( ( ( '-' )? ) )
6062 // InternalSolverLanguage.g:1813:1: ( ( '-' )? )
6063 {
6064 // InternalSolverLanguage.g:1813:1: ( ( '-' )? )
6065 // InternalSolverLanguage.g:1814:2: ( '-' )?
6066 {
6067 before(grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0());
6068 // InternalSolverLanguage.g:1815:2: ( '-' )?
6069 int alt24=2;
6070 int LA24_0 = input.LA(1);
6071
6072 if ( (LA24_0==13) ) {
6073 alt24=1;
6074 }
6075 switch (alt24) {
6076 case 1 :
6077 // InternalSolverLanguage.g:1815:3: '-'
6078 {
6079 match(input,13,FOLLOW_2);
6080
6081 }
6082 break;
6083
6084 }
6085
6086 after(grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0());
6087
6088 }
6089
6090
6091 }
6092
6093 }
6094 catch (RecognitionException re) {
6095 reportError(re);
6096 recover(input,re);
6097 }
6098 finally {
6099
6100 restoreStackSize(stackSize);
6101
6102 }
6103 return ;
6104 }
6105 // $ANTLR end "rule__INTLiteral__Group__0__Impl"
6106
6107
6108 // $ANTLR start "rule__INTLiteral__Group__1"
6109 // InternalSolverLanguage.g:1823:1: rule__INTLiteral__Group__1 : rule__INTLiteral__Group__1__Impl ;
6110 public final void rule__INTLiteral__Group__1() throws RecognitionException {
6111
6112 int stackSize = keepStackSize();
6113
6114 try {
6115 // InternalSolverLanguage.g:1827:1: ( rule__INTLiteral__Group__1__Impl )
6116 // InternalSolverLanguage.g:1828:2: rule__INTLiteral__Group__1__Impl
6117 {
6118 pushFollow(FOLLOW_2);
6119 rule__INTLiteral__Group__1__Impl();
6120
6121 state._fsp--;
6122
6123
6124 }
6125
6126 }
6127 catch (RecognitionException re) {
6128 reportError(re);
6129 recover(input,re);
6130 }
6131 finally {
6132
6133 restoreStackSize(stackSize);
6134
6135 }
6136 return ;
6137 }
6138 // $ANTLR end "rule__INTLiteral__Group__1"
6139
6140
6141 // $ANTLR start "rule__INTLiteral__Group__1__Impl"
6142 // InternalSolverLanguage.g:1834:1: rule__INTLiteral__Group__1__Impl : ( RULE_INT ) ;
6143 public final void rule__INTLiteral__Group__1__Impl() throws RecognitionException {
6144
6145 int stackSize = keepStackSize();
6146
6147 try {
6148 // InternalSolverLanguage.g:1838:1: ( ( RULE_INT ) )
6149 // InternalSolverLanguage.g:1839:1: ( RULE_INT )
6150 {
6151 // InternalSolverLanguage.g:1839:1: ( RULE_INT )
6152 // InternalSolverLanguage.g:1840:2: RULE_INT
6153 {
6154 before(grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1());
6155 match(input,RULE_INT,FOLLOW_2);
6156 after(grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1());
6157
6158 }
6159
6160
6161 }
6162
6163 }
6164 catch (RecognitionException re) {
6165 reportError(re);
6166 recover(input,re);
6167 }
6168 finally {
6169
6170 restoreStackSize(stackSize);
6171
6172 }
6173 return ;
6174 }
6175 // $ANTLR end "rule__INTLiteral__Group__1__Impl"
6176
6177
6178 // $ANTLR start "rule__BooleanValue__Group_0__0"
6179 // InternalSolverLanguage.g:1850:1: rule__BooleanValue__Group_0__0 : rule__BooleanValue__Group_0__0__Impl rule__BooleanValue__Group_0__1 ;
6180 public final void rule__BooleanValue__Group_0__0() throws RecognitionException {
6181
6182 int stackSize = keepStackSize();
6183
6184 try {
6185 // InternalSolverLanguage.g:1854:1: ( rule__BooleanValue__Group_0__0__Impl rule__BooleanValue__Group_0__1 )
6186 // InternalSolverLanguage.g:1855:2: rule__BooleanValue__Group_0__0__Impl rule__BooleanValue__Group_0__1
6187 {
6188 pushFollow(FOLLOW_7);
6189 rule__BooleanValue__Group_0__0__Impl();
6190
6191 state._fsp--;
6192
6193 pushFollow(FOLLOW_2);
6194 rule__BooleanValue__Group_0__1();
6195
6196 state._fsp--;
6197
6198
6199 }
6200
6201 }
6202 catch (RecognitionException re) {
6203 reportError(re);
6204 recover(input,re);
6205 }
6206 finally {
6207
6208 restoreStackSize(stackSize);
6209
6210 }
6211 return ;
6212 }
6213 // $ANTLR end "rule__BooleanValue__Group_0__0"
6214
6215
6216 // $ANTLR start "rule__BooleanValue__Group_0__0__Impl"
6217 // InternalSolverLanguage.g:1862:1: rule__BooleanValue__Group_0__0__Impl : ( () ) ;
6218 public final void rule__BooleanValue__Group_0__0__Impl() throws RecognitionException {
6219
6220 int stackSize = keepStackSize();
6221
6222 try {
6223 // InternalSolverLanguage.g:1866:1: ( ( () ) )
6224 // InternalSolverLanguage.g:1867:1: ( () )
6225 {
6226 // InternalSolverLanguage.g:1867:1: ( () )
6227 // InternalSolverLanguage.g:1868:2: ()
6228 {
6229 before(grammarAccess.getBooleanValueAccess().getBooleanTrueAction_0_0());
6230 // InternalSolverLanguage.g:1869:2: ()
6231 // InternalSolverLanguage.g:1869:3:
6232 {
6233 }
6234
6235 after(grammarAccess.getBooleanValueAccess().getBooleanTrueAction_0_0());
6236
6237 }
6238
6239
6240 }
6241
6242 }
6243 finally {
6244
6245 restoreStackSize(stackSize);
6246
6247 }
6248 return ;
6249 }
6250 // $ANTLR end "rule__BooleanValue__Group_0__0__Impl"
6251
6252
6253 // $ANTLR start "rule__BooleanValue__Group_0__1"
6254 // InternalSolverLanguage.g:1877:1: rule__BooleanValue__Group_0__1 : rule__BooleanValue__Group_0__1__Impl ;
6255 public final void rule__BooleanValue__Group_0__1() throws RecognitionException {
6256
6257 int stackSize = keepStackSize();
6258
6259 try {
6260 // InternalSolverLanguage.g:1881:1: ( rule__BooleanValue__Group_0__1__Impl )
6261 // InternalSolverLanguage.g:1882:2: rule__BooleanValue__Group_0__1__Impl
6262 {
6263 pushFollow(FOLLOW_2);
6264 rule__BooleanValue__Group_0__1__Impl();
6265
6266 state._fsp--;
6267
6268
6269 }
6270
6271 }
6272 catch (RecognitionException re) {
6273 reportError(re);
6274 recover(input,re);
6275 }
6276 finally {
6277
6278 restoreStackSize(stackSize);
6279
6280 }
6281 return ;
6282 }
6283 // $ANTLR end "rule__BooleanValue__Group_0__1"
6284
6285
6286 // $ANTLR start "rule__BooleanValue__Group_0__1__Impl"
6287 // InternalSolverLanguage.g:1888:1: rule__BooleanValue__Group_0__1__Impl : ( 'true' ) ;
6288 public final void rule__BooleanValue__Group_0__1__Impl() throws RecognitionException {
6289
6290 int stackSize = keepStackSize();
6291
6292 try {
6293 // InternalSolverLanguage.g:1892:1: ( ( 'true' ) )
6294 // InternalSolverLanguage.g:1893:1: ( 'true' )
6295 {
6296 // InternalSolverLanguage.g:1893:1: ( 'true' )
6297 // InternalSolverLanguage.g:1894:2: 'true'
6298 {
6299 before(grammarAccess.getBooleanValueAccess().getTrueKeyword_0_1());
6300 match(input,12,FOLLOW_2);
6301 after(grammarAccess.getBooleanValueAccess().getTrueKeyword_0_1());
6302
6303 }
6304
6305
6306 }
6307
6308 }
6309 catch (RecognitionException re) {
6310 reportError(re);
6311 recover(input,re);
6312 }
6313 finally {
6314
6315 restoreStackSize(stackSize);
6316
6317 }
6318 return ;
6319 }
6320 // $ANTLR end "rule__BooleanValue__Group_0__1__Impl"
6321
6322
6323 // $ANTLR start "rule__BooleanValue__Group_1__0"
6324 // InternalSolverLanguage.g:1904:1: rule__BooleanValue__Group_1__0 : rule__BooleanValue__Group_1__0__Impl rule__BooleanValue__Group_1__1 ;
6325 public final void rule__BooleanValue__Group_1__0() throws RecognitionException {
6326
6327 int stackSize = keepStackSize();
6328
6329 try {
6330 // InternalSolverLanguage.g:1908:1: ( rule__BooleanValue__Group_1__0__Impl rule__BooleanValue__Group_1__1 )
6331 // InternalSolverLanguage.g:1909:2: rule__BooleanValue__Group_1__0__Impl rule__BooleanValue__Group_1__1
6332 {
6333 pushFollow(FOLLOW_1);
6334 rule__BooleanValue__Group_1__0__Impl();
6335
6336 state._fsp--;
6337
6338 pushFollow(FOLLOW_2);
6339 rule__BooleanValue__Group_1__1();
6340
6341 state._fsp--;
6342
6343
6344 }
6345
6346 }
6347 catch (RecognitionException re) {
6348 reportError(re);
6349 recover(input,re);
6350 }
6351 finally {
6352
6353 restoreStackSize(stackSize);
6354
6355 }
6356 return ;
6357 }
6358 // $ANTLR end "rule__BooleanValue__Group_1__0"
6359
6360
6361 // $ANTLR start "rule__BooleanValue__Group_1__0__Impl"
6362 // InternalSolverLanguage.g:1916:1: rule__BooleanValue__Group_1__0__Impl : ( 'false' ) ;
6363 public final void rule__BooleanValue__Group_1__0__Impl() throws RecognitionException {
6364
6365 int stackSize = keepStackSize();
6366
6367 try {
6368 // InternalSolverLanguage.g:1920:1: ( ( 'false' ) )
6369 // InternalSolverLanguage.g:1921:1: ( 'false' )
6370 {
6371 // InternalSolverLanguage.g:1921:1: ( 'false' )
6372 // InternalSolverLanguage.g:1922:2: 'false'
6373 {
6374 before(grammarAccess.getBooleanValueAccess().getFalseKeyword_1_0());
6375 match(input,11,FOLLOW_2);
6376 after(grammarAccess.getBooleanValueAccess().getFalseKeyword_1_0());
6377
6378 }
6379
6380
6381 }
6382
6383 }
6384 catch (RecognitionException re) {
6385 reportError(re);
6386 recover(input,re);
6387 }
6388 finally {
6389
6390 restoreStackSize(stackSize);
6391
6392 }
6393 return ;
6394 }
6395 // $ANTLR end "rule__BooleanValue__Group_1__0__Impl"
6396
6397
6398 // $ANTLR start "rule__BooleanValue__Group_1__1"
6399 // InternalSolverLanguage.g:1931:1: rule__BooleanValue__Group_1__1 : rule__BooleanValue__Group_1__1__Impl ;
6400 public final void rule__BooleanValue__Group_1__1() throws RecognitionException {
6401
6402 int stackSize = keepStackSize();
6403
6404 try {
6405 // InternalSolverLanguage.g:1935:1: ( rule__BooleanValue__Group_1__1__Impl )
6406 // InternalSolverLanguage.g:1936:2: rule__BooleanValue__Group_1__1__Impl
6407 {
6408 pushFollow(FOLLOW_2);
6409 rule__BooleanValue__Group_1__1__Impl();
6410
6411 state._fsp--;
6412
6413
6414 }
6415
6416 }
6417 catch (RecognitionException re) {
6418 reportError(re);
6419 recover(input,re);
6420 }
6421 finally {
6422
6423 restoreStackSize(stackSize);
6424
6425 }
6426 return ;
6427 }
6428 // $ANTLR end "rule__BooleanValue__Group_1__1"
6429
6430
6431 // $ANTLR start "rule__BooleanValue__Group_1__1__Impl"
6432 // InternalSolverLanguage.g:1942:1: rule__BooleanValue__Group_1__1__Impl : ( () ) ;
6433 public final void rule__BooleanValue__Group_1__1__Impl() throws RecognitionException {
6434
6435 int stackSize = keepStackSize();
6436
6437 try {
6438 // InternalSolverLanguage.g:1946:1: ( ( () ) )
6439 // InternalSolverLanguage.g:1947:1: ( () )
6440 {
6441 // InternalSolverLanguage.g:1947:1: ( () )
6442 // InternalSolverLanguage.g:1948:2: ()
6443 {
6444 before(grammarAccess.getBooleanValueAccess().getBooleanFalseAction_1_1());
6445 // InternalSolverLanguage.g:1949:2: ()
6446 // InternalSolverLanguage.g:1949:3:
6447 {
6448 }
6449
6450 after(grammarAccess.getBooleanValueAccess().getBooleanFalseAction_1_1());
6451
6452 }
6453
6454
6455 }
6456
6457 }
6458 finally {
6459
6460 restoreStackSize(stackSize);
6461
6462 }
6463 return ;
6464 }
6465 // $ANTLR end "rule__BooleanValue__Group_1__1__Impl"
6466
6467
6468 // $ANTLR start "rule__TruthValue__Group_0__0"
6469 // InternalSolverLanguage.g:1958:1: rule__TruthValue__Group_0__0 : rule__TruthValue__Group_0__0__Impl rule__TruthValue__Group_0__1 ;
6470 public final void rule__TruthValue__Group_0__0() throws RecognitionException {
6471
6472 int stackSize = keepStackSize();
6473
6474 try {
6475 // InternalSolverLanguage.g:1962:1: ( rule__TruthValue__Group_0__0__Impl rule__TruthValue__Group_0__1 )
6476 // InternalSolverLanguage.g:1963:2: rule__TruthValue__Group_0__0__Impl rule__TruthValue__Group_0__1
6477 {
6478 pushFollow(FOLLOW_7);
6479 rule__TruthValue__Group_0__0__Impl();
6480
6481 state._fsp--;
6482
6483 pushFollow(FOLLOW_2);
6484 rule__TruthValue__Group_0__1();
6485
6486 state._fsp--;
6487
6488
6489 }
6490
6491 }
6492 catch (RecognitionException re) {
6493 reportError(re);
6494 recover(input,re);
6495 }
6496 finally {
6497
6498 restoreStackSize(stackSize);
6499
6500 }
6501 return ;
6502 }
6503 // $ANTLR end "rule__TruthValue__Group_0__0"
6504
6505
6506 // $ANTLR start "rule__TruthValue__Group_0__0__Impl"
6507 // InternalSolverLanguage.g:1970:1: rule__TruthValue__Group_0__0__Impl : ( () ) ;
6508 public final void rule__TruthValue__Group_0__0__Impl() throws RecognitionException {
6509
6510 int stackSize = keepStackSize();
6511
6512 try {
6513 // InternalSolverLanguage.g:1974:1: ( ( () ) )
6514 // InternalSolverLanguage.g:1975:1: ( () )
6515 {
6516 // InternalSolverLanguage.g:1975:1: ( () )
6517 // InternalSolverLanguage.g:1976:2: ()
6518 {
6519 before(grammarAccess.getTruthValueAccess().getTrueAction_0_0());
6520 // InternalSolverLanguage.g:1977:2: ()
6521 // InternalSolverLanguage.g:1977:3:
6522 {
6523 }
6524
6525 after(grammarAccess.getTruthValueAccess().getTrueAction_0_0());
6526
6527 }
6528
6529
6530 }
6531
6532 }
6533 finally {
6534
6535 restoreStackSize(stackSize);
6536
6537 }
6538 return ;
6539 }
6540 // $ANTLR end "rule__TruthValue__Group_0__0__Impl"
6541
6542
6543 // $ANTLR start "rule__TruthValue__Group_0__1"
6544 // InternalSolverLanguage.g:1985:1: rule__TruthValue__Group_0__1 : rule__TruthValue__Group_0__1__Impl ;
6545 public final void rule__TruthValue__Group_0__1() throws RecognitionException {
6546
6547 int stackSize = keepStackSize();
6548
6549 try {
6550 // InternalSolverLanguage.g:1989:1: ( rule__TruthValue__Group_0__1__Impl )
6551 // InternalSolverLanguage.g:1990:2: rule__TruthValue__Group_0__1__Impl
6552 {
6553 pushFollow(FOLLOW_2);
6554 rule__TruthValue__Group_0__1__Impl();
6555
6556 state._fsp--;
6557
6558
6559 }
6560
6561 }
6562 catch (RecognitionException re) {
6563 reportError(re);
6564 recover(input,re);
6565 }
6566 finally {
6567
6568 restoreStackSize(stackSize);
6569
6570 }
6571 return ;
6572 }
6573 // $ANTLR end "rule__TruthValue__Group_0__1"
6574
6575
6576 // $ANTLR start "rule__TruthValue__Group_0__1__Impl"
6577 // InternalSolverLanguage.g:1996:1: rule__TruthValue__Group_0__1__Impl : ( 'true' ) ;
6578 public final void rule__TruthValue__Group_0__1__Impl() throws RecognitionException {
6579
6580 int stackSize = keepStackSize();
6581
6582 try {
6583 // InternalSolverLanguage.g:2000:1: ( ( 'true' ) )
6584 // InternalSolverLanguage.g:2001:1: ( 'true' )
6585 {
6586 // InternalSolverLanguage.g:2001:1: ( 'true' )
6587 // InternalSolverLanguage.g:2002:2: 'true'
6588 {
6589 before(grammarAccess.getTruthValueAccess().getTrueKeyword_0_1());
6590 match(input,12,FOLLOW_2);
6591 after(grammarAccess.getTruthValueAccess().getTrueKeyword_0_1());
6592
6593 }
6594
6595
6596 }
6597
6598 }
6599 catch (RecognitionException re) {
6600 reportError(re);
6601 recover(input,re);
6602 }
6603 finally {
6604
6605 restoreStackSize(stackSize);
6606
6607 }
6608 return ;
6609 }
6610 // $ANTLR end "rule__TruthValue__Group_0__1__Impl"
6611
6612
6613 // $ANTLR start "rule__TruthValue__Group_1__0"
6614 // InternalSolverLanguage.g:2012:1: rule__TruthValue__Group_1__0 : rule__TruthValue__Group_1__0__Impl rule__TruthValue__Group_1__1 ;
6615 public final void rule__TruthValue__Group_1__0() throws RecognitionException {
6616
6617 int stackSize = keepStackSize();
6618
6619 try {
6620 // InternalSolverLanguage.g:2016:1: ( rule__TruthValue__Group_1__0__Impl rule__TruthValue__Group_1__1 )
6621 // InternalSolverLanguage.g:2017:2: rule__TruthValue__Group_1__0__Impl rule__TruthValue__Group_1__1
6622 {
6623 pushFollow(FOLLOW_8);
6624 rule__TruthValue__Group_1__0__Impl();
6625
6626 state._fsp--;
6627
6628 pushFollow(FOLLOW_2);
6629 rule__TruthValue__Group_1__1();
6630
6631 state._fsp--;
6632
6633
6634 }
6635
6636 }
6637 catch (RecognitionException re) {
6638 reportError(re);
6639 recover(input,re);
6640 }
6641 finally {
6642
6643 restoreStackSize(stackSize);
6644
6645 }
6646 return ;
6647 }
6648 // $ANTLR end "rule__TruthValue__Group_1__0"
6649
6650
6651 // $ANTLR start "rule__TruthValue__Group_1__0__Impl"
6652 // InternalSolverLanguage.g:2024:1: rule__TruthValue__Group_1__0__Impl : ( () ) ;
6653 public final void rule__TruthValue__Group_1__0__Impl() throws RecognitionException {
6654
6655 int stackSize = keepStackSize();
6656
6657 try {
6658 // InternalSolverLanguage.g:2028:1: ( ( () ) )
6659 // InternalSolverLanguage.g:2029:1: ( () )
6660 {
6661 // InternalSolverLanguage.g:2029:1: ( () )
6662 // InternalSolverLanguage.g:2030:2: ()
6663 {
6664 before(grammarAccess.getTruthValueAccess().getFalseAction_1_0());
6665 // InternalSolverLanguage.g:2031:2: ()
6666 // InternalSolverLanguage.g:2031:3:
6667 {
6668 }
6669
6670 after(grammarAccess.getTruthValueAccess().getFalseAction_1_0());
6671
6672 }
6673
6674
6675 }
6676
6677 }
6678 finally {
6679
6680 restoreStackSize(stackSize);
6681
6682 }
6683 return ;
6684 }
6685 // $ANTLR end "rule__TruthValue__Group_1__0__Impl"
6686
6687
6688 // $ANTLR start "rule__TruthValue__Group_1__1"
6689 // InternalSolverLanguage.g:2039:1: rule__TruthValue__Group_1__1 : rule__TruthValue__Group_1__1__Impl ;
6690 public final void rule__TruthValue__Group_1__1() throws RecognitionException {
6691
6692 int stackSize = keepStackSize();
6693
6694 try {
6695 // InternalSolverLanguage.g:2043:1: ( rule__TruthValue__Group_1__1__Impl )
6696 // InternalSolverLanguage.g:2044:2: rule__TruthValue__Group_1__1__Impl
6697 {
6698 pushFollow(FOLLOW_2);
6699 rule__TruthValue__Group_1__1__Impl();
6700
6701 state._fsp--;
6702
6703
6704 }
6705
6706 }
6707 catch (RecognitionException re) {
6708 reportError(re);
6709 recover(input,re);
6710 }
6711 finally {
6712
6713 restoreStackSize(stackSize);
6714
6715 }
6716 return ;
6717 }
6718 // $ANTLR end "rule__TruthValue__Group_1__1"
6719
6720
6721 // $ANTLR start "rule__TruthValue__Group_1__1__Impl"
6722 // InternalSolverLanguage.g:2050:1: rule__TruthValue__Group_1__1__Impl : ( 'false' ) ;
6723 public final void rule__TruthValue__Group_1__1__Impl() throws RecognitionException {
6724
6725 int stackSize = keepStackSize();
6726
6727 try {
6728 // InternalSolverLanguage.g:2054:1: ( ( 'false' ) )
6729 // InternalSolverLanguage.g:2055:1: ( 'false' )
6730 {
6731 // InternalSolverLanguage.g:2055:1: ( 'false' )
6732 // InternalSolverLanguage.g:2056:2: 'false'
6733 {
6734 before(grammarAccess.getTruthValueAccess().getFalseKeyword_1_1());
6735 match(input,11,FOLLOW_2);
6736 after(grammarAccess.getTruthValueAccess().getFalseKeyword_1_1());
6737
6738 }
6739
6740
6741 }
6742
6743 }
6744 catch (RecognitionException re) {
6745 reportError(re);
6746 recover(input,re);
6747 }
6748 finally {
6749
6750 restoreStackSize(stackSize);
6751
6752 }
6753 return ;
6754 }
6755 // $ANTLR end "rule__TruthValue__Group_1__1__Impl"
6756
6757
6758 // $ANTLR start "rule__TruthValue__Group_2__0"
6759 // InternalSolverLanguage.g:2066:1: rule__TruthValue__Group_2__0 : rule__TruthValue__Group_2__0__Impl rule__TruthValue__Group_2__1 ;
6760 public final void rule__TruthValue__Group_2__0() throws RecognitionException {
6761
6762 int stackSize = keepStackSize();
6763
6764 try {
6765 // InternalSolverLanguage.g:2070:1: ( rule__TruthValue__Group_2__0__Impl rule__TruthValue__Group_2__1 )
6766 // InternalSolverLanguage.g:2071:2: rule__TruthValue__Group_2__0__Impl rule__TruthValue__Group_2__1
6767 {
6768 pushFollow(FOLLOW_9);
6769 rule__TruthValue__Group_2__0__Impl();
6770
6771 state._fsp--;
6772
6773 pushFollow(FOLLOW_2);
6774 rule__TruthValue__Group_2__1();
6775
6776 state._fsp--;
6777
6778
6779 }
6780
6781 }
6782 catch (RecognitionException re) {
6783 reportError(re);
6784 recover(input,re);
6785 }
6786 finally {
6787
6788 restoreStackSize(stackSize);
6789
6790 }
6791 return ;
6792 }
6793 // $ANTLR end "rule__TruthValue__Group_2__0"
6794
6795
6796 // $ANTLR start "rule__TruthValue__Group_2__0__Impl"
6797 // InternalSolverLanguage.g:2078:1: rule__TruthValue__Group_2__0__Impl : ( () ) ;
6798 public final void rule__TruthValue__Group_2__0__Impl() throws RecognitionException {
6799
6800 int stackSize = keepStackSize();
6801
6802 try {
6803 // InternalSolverLanguage.g:2082:1: ( ( () ) )
6804 // InternalSolverLanguage.g:2083:1: ( () )
6805 {
6806 // InternalSolverLanguage.g:2083:1: ( () )
6807 // InternalSolverLanguage.g:2084:2: ()
6808 {
6809 before(grammarAccess.getTruthValueAccess().getUnknownAction_2_0());
6810 // InternalSolverLanguage.g:2085:2: ()
6811 // InternalSolverLanguage.g:2085:3:
6812 {
6813 }
6814
6815 after(grammarAccess.getTruthValueAccess().getUnknownAction_2_0());
6816
6817 }
6818
6819
6820 }
6821
6822 }
6823 finally {
6824
6825 restoreStackSize(stackSize);
6826
6827 }
6828 return ;
6829 }
6830 // $ANTLR end "rule__TruthValue__Group_2__0__Impl"
6831
6832
6833 // $ANTLR start "rule__TruthValue__Group_2__1"
6834 // InternalSolverLanguage.g:2093:1: rule__TruthValue__Group_2__1 : rule__TruthValue__Group_2__1__Impl ;
6835 public final void rule__TruthValue__Group_2__1() throws RecognitionException {
6836
6837 int stackSize = keepStackSize();
6838
6839 try {
6840 // InternalSolverLanguage.g:2097:1: ( rule__TruthValue__Group_2__1__Impl )
6841 // InternalSolverLanguage.g:2098:2: rule__TruthValue__Group_2__1__Impl
6842 {
6843 pushFollow(FOLLOW_2);
6844 rule__TruthValue__Group_2__1__Impl();
6845
6846 state._fsp--;
6847
6848
6849 }
6850
6851 }
6852 catch (RecognitionException re) {
6853 reportError(re);
6854 recover(input,re);
6855 }
6856 finally {
6857
6858 restoreStackSize(stackSize);
6859
6860 }
6861 return ;
6862 }
6863 // $ANTLR end "rule__TruthValue__Group_2__1"
6864
6865
6866 // $ANTLR start "rule__TruthValue__Group_2__1__Impl"
6867 // InternalSolverLanguage.g:2104:1: rule__TruthValue__Group_2__1__Impl : ( 'unknown' ) ;
6868 public final void rule__TruthValue__Group_2__1__Impl() throws RecognitionException {
6869
6870 int stackSize = keepStackSize();
6871
6872 try {
6873 // InternalSolverLanguage.g:2108:1: ( ( 'unknown' ) )
6874 // InternalSolverLanguage.g:2109:1: ( 'unknown' )
6875 {
6876 // InternalSolverLanguage.g:2109:1: ( 'unknown' )
6877 // InternalSolverLanguage.g:2110:2: 'unknown'
6878 {
6879 before(grammarAccess.getTruthValueAccess().getUnknownKeyword_2_1());
6880 match(input,15,FOLLOW_2);
6881 after(grammarAccess.getTruthValueAccess().getUnknownKeyword_2_1());
6882
6883 }
6884
6885
6886 }
6887
6888 }
6889 catch (RecognitionException re) {
6890 reportError(re);
6891 recover(input,re);
6892 }
6893 finally {
6894
6895 restoreStackSize(stackSize);
6896
6897 }
6898 return ;
6899 }
6900 // $ANTLR end "rule__TruthValue__Group_2__1__Impl"
6901
6902
6903 // $ANTLR start "rule__TruthValue__Group_3__0"
6904 // InternalSolverLanguage.g:2120:1: rule__TruthValue__Group_3__0 : rule__TruthValue__Group_3__0__Impl rule__TruthValue__Group_3__1 ;
6905 public final void rule__TruthValue__Group_3__0() throws RecognitionException {
6906
6907 int stackSize = keepStackSize();
6908
6909 try {
6910 // InternalSolverLanguage.g:2124:1: ( rule__TruthValue__Group_3__0__Impl rule__TruthValue__Group_3__1 )
6911 // InternalSolverLanguage.g:2125:2: rule__TruthValue__Group_3__0__Impl rule__TruthValue__Group_3__1
6912 {
6913 pushFollow(FOLLOW_10);
6914 rule__TruthValue__Group_3__0__Impl();
6915
6916 state._fsp--;
6917
6918 pushFollow(FOLLOW_2);
6919 rule__TruthValue__Group_3__1();
6920
6921 state._fsp--;
6922
6923
6924 }
6925
6926 }
6927 catch (RecognitionException re) {
6928 reportError(re);
6929 recover(input,re);
6930 }
6931 finally {
6932
6933 restoreStackSize(stackSize);
6934
6935 }
6936 return ;
6937 }
6938 // $ANTLR end "rule__TruthValue__Group_3__0"
6939
6940
6941 // $ANTLR start "rule__TruthValue__Group_3__0__Impl"
6942 // InternalSolverLanguage.g:2132:1: rule__TruthValue__Group_3__0__Impl : ( () ) ;
6943 public final void rule__TruthValue__Group_3__0__Impl() throws RecognitionException {
6944
6945 int stackSize = keepStackSize();
6946
6947 try {
6948 // InternalSolverLanguage.g:2136:1: ( ( () ) )
6949 // InternalSolverLanguage.g:2137:1: ( () )
6950 {
6951 // InternalSolverLanguage.g:2137:1: ( () )
6952 // InternalSolverLanguage.g:2138:2: ()
6953 {
6954 before(grammarAccess.getTruthValueAccess().getErrorAction_3_0());
6955 // InternalSolverLanguage.g:2139:2: ()
6956 // InternalSolverLanguage.g:2139:3:
6957 {
6958 }
6959
6960 after(grammarAccess.getTruthValueAccess().getErrorAction_3_0());
6961
6962 }
6963
6964
6965 }
6966
6967 }
6968 finally {
6969
6970 restoreStackSize(stackSize);
6971
6972 }
6973 return ;
6974 }
6975 // $ANTLR end "rule__TruthValue__Group_3__0__Impl"
6976
6977
6978 // $ANTLR start "rule__TruthValue__Group_3__1"
6979 // InternalSolverLanguage.g:2147:1: rule__TruthValue__Group_3__1 : rule__TruthValue__Group_3__1__Impl ;
6980 public final void rule__TruthValue__Group_3__1() throws RecognitionException {
6981
6982 int stackSize = keepStackSize();
6983
6984 try {
6985 // InternalSolverLanguage.g:2151:1: ( rule__TruthValue__Group_3__1__Impl )
6986 // InternalSolverLanguage.g:2152:2: rule__TruthValue__Group_3__1__Impl
6987 {
6988 pushFollow(FOLLOW_2);
6989 rule__TruthValue__Group_3__1__Impl();
6990
6991 state._fsp--;
6992
6993
6994 }
6995
6996 }
6997 catch (RecognitionException re) {
6998 reportError(re);
6999 recover(input,re);
7000 }
7001 finally {
7002
7003 restoreStackSize(stackSize);
7004
7005 }
7006 return ;
7007 }
7008 // $ANTLR end "rule__TruthValue__Group_3__1"
7009
7010
7011 // $ANTLR start "rule__TruthValue__Group_3__1__Impl"
7012 // InternalSolverLanguage.g:2158:1: rule__TruthValue__Group_3__1__Impl : ( 'error' ) ;
7013 public final void rule__TruthValue__Group_3__1__Impl() throws RecognitionException {
7014
7015 int stackSize = keepStackSize();
7016
7017 try {
7018 // InternalSolverLanguage.g:2162:1: ( ( 'error' ) )
7019 // InternalSolverLanguage.g:2163:1: ( 'error' )
7020 {
7021 // InternalSolverLanguage.g:2163:1: ( 'error' )
7022 // InternalSolverLanguage.g:2164:2: 'error'
7023 {
7024 before(grammarAccess.getTruthValueAccess().getErrorKeyword_3_1());
7025 match(input,16,FOLLOW_2);
7026 after(grammarAccess.getTruthValueAccess().getErrorKeyword_3_1());
7027
7028 }
7029
7030
7031 }
7032
7033 }
7034 catch (RecognitionException re) {
7035 reportError(re);
7036 recover(input,re);
7037 }
7038 finally {
7039
7040 restoreStackSize(stackSize);
7041
7042 }
7043 return ;
7044 }
7045 // $ANTLR end "rule__TruthValue__Group_3__1__Impl"
7046
7047
7048 // $ANTLR start "rule__BasicInterpretation__Group__0"
7049 // InternalSolverLanguage.g:2174:1: rule__BasicInterpretation__Group__0 : rule__BasicInterpretation__Group__0__Impl rule__BasicInterpretation__Group__1 ;
7050 public final void rule__BasicInterpretation__Group__0() throws RecognitionException {
7051
7052 int stackSize = keepStackSize();
7053
7054 try {
7055 // InternalSolverLanguage.g:2178:1: ( rule__BasicInterpretation__Group__0__Impl rule__BasicInterpretation__Group__1 )
7056 // InternalSolverLanguage.g:2179:2: rule__BasicInterpretation__Group__0__Impl rule__BasicInterpretation__Group__1
7057 {
7058 pushFollow(FOLLOW_11);
7059 rule__BasicInterpretation__Group__0__Impl();
7060
7061 state._fsp--;
7062
7063 pushFollow(FOLLOW_2);
7064 rule__BasicInterpretation__Group__1();
7065
7066 state._fsp--;
7067
7068
7069 }
7070
7071 }
7072 catch (RecognitionException re) {
7073 reportError(re);
7074 recover(input,re);
7075 }
7076 finally {
7077
7078 restoreStackSize(stackSize);
7079
7080 }
7081 return ;
7082 }
7083 // $ANTLR end "rule__BasicInterpretation__Group__0"
7084
7085
7086 // $ANTLR start "rule__BasicInterpretation__Group__0__Impl"
7087 // InternalSolverLanguage.g:2186:1: rule__BasicInterpretation__Group__0__Impl : ( ( rule__BasicInterpretation__SymbolAssignment_0 ) ) ;
7088 public final void rule__BasicInterpretation__Group__0__Impl() throws RecognitionException {
7089
7090 int stackSize = keepStackSize();
7091
7092 try {
7093 // InternalSolverLanguage.g:2190:1: ( ( ( rule__BasicInterpretation__SymbolAssignment_0 ) ) )
7094 // InternalSolverLanguage.g:2191:1: ( ( rule__BasicInterpretation__SymbolAssignment_0 ) )
7095 {
7096 // InternalSolverLanguage.g:2191:1: ( ( rule__BasicInterpretation__SymbolAssignment_0 ) )
7097 // InternalSolverLanguage.g:2192:2: ( rule__BasicInterpretation__SymbolAssignment_0 )
7098 {
7099 before(grammarAccess.getBasicInterpretationAccess().getSymbolAssignment_0());
7100 // InternalSolverLanguage.g:2193:2: ( rule__BasicInterpretation__SymbolAssignment_0 )
7101 // InternalSolverLanguage.g:2193:3: rule__BasicInterpretation__SymbolAssignment_0
7102 {
7103 pushFollow(FOLLOW_2);
7104 rule__BasicInterpretation__SymbolAssignment_0();
7105
7106 state._fsp--;
7107
7108
7109 }
7110
7111 after(grammarAccess.getBasicInterpretationAccess().getSymbolAssignment_0());
7112
7113 }
7114
7115
7116 }
7117
7118 }
7119 catch (RecognitionException re) {
7120 reportError(re);
7121 recover(input,re);
7122 }
7123 finally {
7124
7125 restoreStackSize(stackSize);
7126
7127 }
7128 return ;
7129 }
7130 // $ANTLR end "rule__BasicInterpretation__Group__0__Impl"
7131
7132
7133 // $ANTLR start "rule__BasicInterpretation__Group__1"
7134 // InternalSolverLanguage.g:2201:1: rule__BasicInterpretation__Group__1 : rule__BasicInterpretation__Group__1__Impl rule__BasicInterpretation__Group__2 ;
7135 public final void rule__BasicInterpretation__Group__1() throws RecognitionException {
7136
7137 int stackSize = keepStackSize();
7138
7139 try {
7140 // InternalSolverLanguage.g:2205:1: ( rule__BasicInterpretation__Group__1__Impl rule__BasicInterpretation__Group__2 )
7141 // InternalSolverLanguage.g:2206:2: rule__BasicInterpretation__Group__1__Impl rule__BasicInterpretation__Group__2
7142 {
7143 pushFollow(FOLLOW_12);
7144 rule__BasicInterpretation__Group__1__Impl();
7145
7146 state._fsp--;
7147
7148 pushFollow(FOLLOW_2);
7149 rule__BasicInterpretation__Group__2();
7150
7151 state._fsp--;
7152
7153
7154 }
7155
7156 }
7157 catch (RecognitionException re) {
7158 reportError(re);
7159 recover(input,re);
7160 }
7161 finally {
7162
7163 restoreStackSize(stackSize);
7164
7165 }
7166 return ;
7167 }
7168 // $ANTLR end "rule__BasicInterpretation__Group__1"
7169
7170
7171 // $ANTLR start "rule__BasicInterpretation__Group__1__Impl"
7172 // InternalSolverLanguage.g:2213:1: rule__BasicInterpretation__Group__1__Impl : ( '(' ) ;
7173 public final void rule__BasicInterpretation__Group__1__Impl() throws RecognitionException {
7174
7175 int stackSize = keepStackSize();
7176
7177 try {
7178 // InternalSolverLanguage.g:2217:1: ( ( '(' ) )
7179 // InternalSolverLanguage.g:2218:1: ( '(' )
7180 {
7181 // InternalSolverLanguage.g:2218:1: ( '(' )
7182 // InternalSolverLanguage.g:2219:2: '('
7183 {
7184 before(grammarAccess.getBasicInterpretationAccess().getLeftParenthesisKeyword_1());
7185 match(input,17,FOLLOW_2);
7186 after(grammarAccess.getBasicInterpretationAccess().getLeftParenthesisKeyword_1());
7187
7188 }
7189
7190
7191 }
7192
7193 }
7194 catch (RecognitionException re) {
7195 reportError(re);
7196 recover(input,re);
7197 }
7198 finally {
7199
7200 restoreStackSize(stackSize);
7201
7202 }
7203 return ;
7204 }
7205 // $ANTLR end "rule__BasicInterpretation__Group__1__Impl"
7206
7207
7208 // $ANTLR start "rule__BasicInterpretation__Group__2"
7209 // InternalSolverLanguage.g:2228:1: rule__BasicInterpretation__Group__2 : rule__BasicInterpretation__Group__2__Impl rule__BasicInterpretation__Group__3 ;
7210 public final void rule__BasicInterpretation__Group__2() throws RecognitionException {
7211
7212 int stackSize = keepStackSize();
7213
7214 try {
7215 // InternalSolverLanguage.g:2232:1: ( rule__BasicInterpretation__Group__2__Impl rule__BasicInterpretation__Group__3 )
7216 // InternalSolverLanguage.g:2233:2: rule__BasicInterpretation__Group__2__Impl rule__BasicInterpretation__Group__3
7217 {
7218 pushFollow(FOLLOW_12);
7219 rule__BasicInterpretation__Group__2__Impl();
7220
7221 state._fsp--;
7222
7223 pushFollow(FOLLOW_2);
7224 rule__BasicInterpretation__Group__3();
7225
7226 state._fsp--;
7227
7228
7229 }
7230
7231 }
7232 catch (RecognitionException re) {
7233 reportError(re);
7234 recover(input,re);
7235 }
7236 finally {
7237
7238 restoreStackSize(stackSize);
7239
7240 }
7241 return ;
7242 }
7243 // $ANTLR end "rule__BasicInterpretation__Group__2"
7244
7245
7246 // $ANTLR start "rule__BasicInterpretation__Group__2__Impl"
7247 // InternalSolverLanguage.g:2240:1: rule__BasicInterpretation__Group__2__Impl : ( ( rule__BasicInterpretation__ObjectsAssignment_2 )* ) ;
7248 public final void rule__BasicInterpretation__Group__2__Impl() throws RecognitionException {
7249
7250 int stackSize = keepStackSize();
7251
7252 try {
7253 // InternalSolverLanguage.g:2244:1: ( ( ( rule__BasicInterpretation__ObjectsAssignment_2 )* ) )
7254 // InternalSolverLanguage.g:2245:1: ( ( rule__BasicInterpretation__ObjectsAssignment_2 )* )
7255 {
7256 // InternalSolverLanguage.g:2245:1: ( ( rule__BasicInterpretation__ObjectsAssignment_2 )* )
7257 // InternalSolverLanguage.g:2246:2: ( rule__BasicInterpretation__ObjectsAssignment_2 )*
7258 {
7259 before(grammarAccess.getBasicInterpretationAccess().getObjectsAssignment_2());
7260 // InternalSolverLanguage.g:2247:2: ( rule__BasicInterpretation__ObjectsAssignment_2 )*
7261 loop25:
7262 do {
7263 int alt25=2;
7264 int LA25_0 = input.LA(1);
7265
7266 if ( ((LA25_0>=RULE_INT && LA25_0<=RULE_STRING)||(LA25_0>=11 && LA25_0<=13)||LA25_0==19||LA25_0==26||LA25_0==30) ) {
7267 alt25=1;
7268 }
7269
7270
7271 switch (alt25) {
7272 case 1 :
7273 // InternalSolverLanguage.g:2247:3: rule__BasicInterpretation__ObjectsAssignment_2
7274 {
7275 pushFollow(FOLLOW_13);
7276 rule__BasicInterpretation__ObjectsAssignment_2();
7277
7278 state._fsp--;
7279
7280
7281 }
7282 break;
7283
7284 default :
7285 break loop25;
7286 }
7287 } while (true);
7288
7289 after(grammarAccess.getBasicInterpretationAccess().getObjectsAssignment_2());
7290
7291 }
7292
7293
7294 }
7295
7296 }
7297 catch (RecognitionException re) {
7298 reportError(re);
7299 recover(input,re);
7300 }
7301 finally {
7302
7303 restoreStackSize(stackSize);
7304
7305 }
7306 return ;
7307 }
7308 // $ANTLR end "rule__BasicInterpretation__Group__2__Impl"
7309
7310
7311 // $ANTLR start "rule__BasicInterpretation__Group__3"
7312 // InternalSolverLanguage.g:2255:1: rule__BasicInterpretation__Group__3 : rule__BasicInterpretation__Group__3__Impl rule__BasicInterpretation__Group__4 ;
7313 public final void rule__BasicInterpretation__Group__3() throws RecognitionException {
7314
7315 int stackSize = keepStackSize();
7316
7317 try {
7318 // InternalSolverLanguage.g:2259:1: ( rule__BasicInterpretation__Group__3__Impl rule__BasicInterpretation__Group__4 )
7319 // InternalSolverLanguage.g:2260:2: rule__BasicInterpretation__Group__3__Impl rule__BasicInterpretation__Group__4
7320 {
7321 pushFollow(FOLLOW_14);
7322 rule__BasicInterpretation__Group__3__Impl();
7323
7324 state._fsp--;
7325
7326 pushFollow(FOLLOW_2);
7327 rule__BasicInterpretation__Group__4();
7328
7329 state._fsp--;
7330
7331
7332 }
7333
7334 }
7335 catch (RecognitionException re) {
7336 reportError(re);
7337 recover(input,re);
7338 }
7339 finally {
7340
7341 restoreStackSize(stackSize);
7342
7343 }
7344 return ;
7345 }
7346 // $ANTLR end "rule__BasicInterpretation__Group__3"
7347
7348
7349 // $ANTLR start "rule__BasicInterpretation__Group__3__Impl"
7350 // InternalSolverLanguage.g:2267:1: rule__BasicInterpretation__Group__3__Impl : ( ')' ) ;
7351 public final void rule__BasicInterpretation__Group__3__Impl() throws RecognitionException {
7352
7353 int stackSize = keepStackSize();
7354
7355 try {
7356 // InternalSolverLanguage.g:2271:1: ( ( ')' ) )
7357 // InternalSolverLanguage.g:2272:1: ( ')' )
7358 {
7359 // InternalSolverLanguage.g:2272:1: ( ')' )
7360 // InternalSolverLanguage.g:2273:2: ')'
7361 {
7362 before(grammarAccess.getBasicInterpretationAccess().getRightParenthesisKeyword_3());
7363 match(input,18,FOLLOW_2);
7364 after(grammarAccess.getBasicInterpretationAccess().getRightParenthesisKeyword_3());
7365
7366 }
7367
7368
7369 }
7370
7371 }
7372 catch (RecognitionException re) {
7373 reportError(re);
7374 recover(input,re);
7375 }
7376 finally {
7377
7378 restoreStackSize(stackSize);
7379
7380 }
7381 return ;
7382 }
7383 // $ANTLR end "rule__BasicInterpretation__Group__3__Impl"
7384
7385
7386 // $ANTLR start "rule__BasicInterpretation__Group__4"
7387 // InternalSolverLanguage.g:2282:1: rule__BasicInterpretation__Group__4 : rule__BasicInterpretation__Group__4__Impl rule__BasicInterpretation__Group__5 ;
7388 public final void rule__BasicInterpretation__Group__4() throws RecognitionException {
7389
7390 int stackSize = keepStackSize();
7391
7392 try {
7393 // InternalSolverLanguage.g:2286:1: ( rule__BasicInterpretation__Group__4__Impl rule__BasicInterpretation__Group__5 )
7394 // InternalSolverLanguage.g:2287:2: rule__BasicInterpretation__Group__4__Impl rule__BasicInterpretation__Group__5
7395 {
7396 pushFollow(FOLLOW_15);
7397 rule__BasicInterpretation__Group__4__Impl();
7398
7399 state._fsp--;
7400
7401 pushFollow(FOLLOW_2);
7402 rule__BasicInterpretation__Group__5();
7403
7404 state._fsp--;
7405
7406
7407 }
7408
7409 }
7410 catch (RecognitionException re) {
7411 reportError(re);
7412 recover(input,re);
7413 }
7414 finally {
7415
7416 restoreStackSize(stackSize);
7417
7418 }
7419 return ;
7420 }
7421 // $ANTLR end "rule__BasicInterpretation__Group__4"
7422
7423
7424 // $ANTLR start "rule__BasicInterpretation__Group__4__Impl"
7425 // InternalSolverLanguage.g:2294:1: rule__BasicInterpretation__Group__4__Impl : ( ':' ) ;
7426 public final void rule__BasicInterpretation__Group__4__Impl() throws RecognitionException {
7427
7428 int stackSize = keepStackSize();
7429
7430 try {
7431 // InternalSolverLanguage.g:2298:1: ( ( ':' ) )
7432 // InternalSolverLanguage.g:2299:1: ( ':' )
7433 {
7434 // InternalSolverLanguage.g:2299:1: ( ':' )
7435 // InternalSolverLanguage.g:2300:2: ':'
7436 {
7437 before(grammarAccess.getBasicInterpretationAccess().getColonKeyword_4());
7438 match(input,19,FOLLOW_2);
7439 after(grammarAccess.getBasicInterpretationAccess().getColonKeyword_4());
7440
7441 }
7442
7443
7444 }
7445
7446 }
7447 catch (RecognitionException re) {
7448 reportError(re);
7449 recover(input,re);
7450 }
7451 finally {
7452
7453 restoreStackSize(stackSize);
7454
7455 }
7456 return ;
7457 }
7458 // $ANTLR end "rule__BasicInterpretation__Group__4__Impl"
7459
7460
7461 // $ANTLR start "rule__BasicInterpretation__Group__5"
7462 // InternalSolverLanguage.g:2309:1: rule__BasicInterpretation__Group__5 : rule__BasicInterpretation__Group__5__Impl ;
7463 public final void rule__BasicInterpretation__Group__5() throws RecognitionException {
7464
7465 int stackSize = keepStackSize();
7466
7467 try {
7468 // InternalSolverLanguage.g:2313:1: ( rule__BasicInterpretation__Group__5__Impl )
7469 // InternalSolverLanguage.g:2314:2: rule__BasicInterpretation__Group__5__Impl
7470 {
7471 pushFollow(FOLLOW_2);
7472 rule__BasicInterpretation__Group__5__Impl();
7473
7474 state._fsp--;
7475
7476
7477 }
7478
7479 }
7480 catch (RecognitionException re) {
7481 reportError(re);
7482 recover(input,re);
7483 }
7484 finally {
7485
7486 restoreStackSize(stackSize);
7487
7488 }
7489 return ;
7490 }
7491 // $ANTLR end "rule__BasicInterpretation__Group__5"
7492
7493
7494 // $ANTLR start "rule__BasicInterpretation__Group__5__Impl"
7495 // InternalSolverLanguage.g:2320:1: rule__BasicInterpretation__Group__5__Impl : ( ( rule__BasicInterpretation__ValueAssignment_5 ) ) ;
7496 public final void rule__BasicInterpretation__Group__5__Impl() throws RecognitionException {
7497
7498 int stackSize = keepStackSize();
7499
7500 try {
7501 // InternalSolverLanguage.g:2324:1: ( ( ( rule__BasicInterpretation__ValueAssignment_5 ) ) )
7502 // InternalSolverLanguage.g:2325:1: ( ( rule__BasicInterpretation__ValueAssignment_5 ) )
7503 {
7504 // InternalSolverLanguage.g:2325:1: ( ( rule__BasicInterpretation__ValueAssignment_5 ) )
7505 // InternalSolverLanguage.g:2326:2: ( rule__BasicInterpretation__ValueAssignment_5 )
7506 {
7507 before(grammarAccess.getBasicInterpretationAccess().getValueAssignment_5());
7508 // InternalSolverLanguage.g:2327:2: ( rule__BasicInterpretation__ValueAssignment_5 )
7509 // InternalSolverLanguage.g:2327:3: rule__BasicInterpretation__ValueAssignment_5
7510 {
7511 pushFollow(FOLLOW_2);
7512 rule__BasicInterpretation__ValueAssignment_5();
7513
7514 state._fsp--;
7515
7516
7517 }
7518
7519 after(grammarAccess.getBasicInterpretationAccess().getValueAssignment_5());
7520
7521 }
7522
7523
7524 }
7525
7526 }
7527 catch (RecognitionException re) {
7528 reportError(re);
7529 recover(input,re);
7530 }
7531 finally {
7532
7533 restoreStackSize(stackSize);
7534
7535 }
7536 return ;
7537 }
7538 // $ANTLR end "rule__BasicInterpretation__Group__5__Impl"
7539
7540
7541 // $ANTLR start "rule__ExistSymbol__Group__0"
7542 // InternalSolverLanguage.g:2336:1: rule__ExistSymbol__Group__0 : rule__ExistSymbol__Group__0__Impl rule__ExistSymbol__Group__1 ;
7543 public final void rule__ExistSymbol__Group__0() throws RecognitionException {
7544
7545 int stackSize = keepStackSize();
7546
7547 try {
7548 // InternalSolverLanguage.g:2340:1: ( rule__ExistSymbol__Group__0__Impl rule__ExistSymbol__Group__1 )
7549 // InternalSolverLanguage.g:2341:2: rule__ExistSymbol__Group__0__Impl rule__ExistSymbol__Group__1
7550 {
7551 pushFollow(FOLLOW_1);
7552 rule__ExistSymbol__Group__0__Impl();
7553
7554 state._fsp--;
7555
7556 pushFollow(FOLLOW_2);
7557 rule__ExistSymbol__Group__1();
7558
7559 state._fsp--;
7560
7561
7562 }
7563
7564 }
7565 catch (RecognitionException re) {
7566 reportError(re);
7567 recover(input,re);
7568 }
7569 finally {
7570
7571 restoreStackSize(stackSize);
7572
7573 }
7574 return ;
7575 }
7576 // $ANTLR end "rule__ExistSymbol__Group__0"
7577
7578
7579 // $ANTLR start "rule__ExistSymbol__Group__0__Impl"
7580 // InternalSolverLanguage.g:2348:1: rule__ExistSymbol__Group__0__Impl : ( 'exists' ) ;
7581 public final void rule__ExistSymbol__Group__0__Impl() throws RecognitionException {
7582
7583 int stackSize = keepStackSize();
7584
7585 try {
7586 // InternalSolverLanguage.g:2352:1: ( ( 'exists' ) )
7587 // InternalSolverLanguage.g:2353:1: ( 'exists' )
7588 {
7589 // InternalSolverLanguage.g:2353:1: ( 'exists' )
7590 // InternalSolverLanguage.g:2354:2: 'exists'
7591 {
7592 before(grammarAccess.getExistSymbolAccess().getExistsKeyword_0());
7593 match(input,20,FOLLOW_2);
7594 after(grammarAccess.getExistSymbolAccess().getExistsKeyword_0());
7595
7596 }
7597
7598
7599 }
7600
7601 }
7602 catch (RecognitionException re) {
7603 reportError(re);
7604 recover(input,re);
7605 }
7606 finally {
7607
7608 restoreStackSize(stackSize);
7609
7610 }
7611 return ;
7612 }
7613 // $ANTLR end "rule__ExistSymbol__Group__0__Impl"
7614
7615
7616 // $ANTLR start "rule__ExistSymbol__Group__1"
7617 // InternalSolverLanguage.g:2363:1: rule__ExistSymbol__Group__1 : rule__ExistSymbol__Group__1__Impl ;
7618 public final void rule__ExistSymbol__Group__1() throws RecognitionException {
7619
7620 int stackSize = keepStackSize();
7621
7622 try {
7623 // InternalSolverLanguage.g:2367:1: ( rule__ExistSymbol__Group__1__Impl )
7624 // InternalSolverLanguage.g:2368:2: rule__ExistSymbol__Group__1__Impl
7625 {
7626 pushFollow(FOLLOW_2);
7627 rule__ExistSymbol__Group__1__Impl();
7628
7629 state._fsp--;
7630
7631
7632 }
7633
7634 }
7635 catch (RecognitionException re) {
7636 reportError(re);
7637 recover(input,re);
7638 }
7639 finally {
7640
7641 restoreStackSize(stackSize);
7642
7643 }
7644 return ;
7645 }
7646 // $ANTLR end "rule__ExistSymbol__Group__1"
7647
7648
7649 // $ANTLR start "rule__ExistSymbol__Group__1__Impl"
7650 // InternalSolverLanguage.g:2374:1: rule__ExistSymbol__Group__1__Impl : ( () ) ;
7651 public final void rule__ExistSymbol__Group__1__Impl() throws RecognitionException {
7652
7653 int stackSize = keepStackSize();
7654
7655 try {
7656 // InternalSolverLanguage.g:2378:1: ( ( () ) )
7657 // InternalSolverLanguage.g:2379:1: ( () )
7658 {
7659 // InternalSolverLanguage.g:2379:1: ( () )
7660 // InternalSolverLanguage.g:2380:2: ()
7661 {
7662 before(grammarAccess.getExistSymbolAccess().getExistSymbolAction_1());
7663 // InternalSolverLanguage.g:2381:2: ()
7664 // InternalSolverLanguage.g:2381:3:
7665 {
7666 }
7667
7668 after(grammarAccess.getExistSymbolAccess().getExistSymbolAction_1());
7669
7670 }
7671
7672
7673 }
7674
7675 }
7676 finally {
7677
7678 restoreStackSize(stackSize);
7679
7680 }
7681 return ;
7682 }
7683 // $ANTLR end "rule__ExistSymbol__Group__1__Impl"
7684
7685
7686 // $ANTLR start "rule__EqualsSymbol__Group__0"
7687 // InternalSolverLanguage.g:2390:1: rule__EqualsSymbol__Group__0 : rule__EqualsSymbol__Group__0__Impl rule__EqualsSymbol__Group__1 ;
7688 public final void rule__EqualsSymbol__Group__0() throws RecognitionException {
7689
7690 int stackSize = keepStackSize();
7691
7692 try {
7693 // InternalSolverLanguage.g:2394:1: ( rule__EqualsSymbol__Group__0__Impl rule__EqualsSymbol__Group__1 )
7694 // InternalSolverLanguage.g:2395:2: rule__EqualsSymbol__Group__0__Impl rule__EqualsSymbol__Group__1
7695 {
7696 pushFollow(FOLLOW_1);
7697 rule__EqualsSymbol__Group__0__Impl();
7698
7699 state._fsp--;
7700
7701 pushFollow(FOLLOW_2);
7702 rule__EqualsSymbol__Group__1();
7703
7704 state._fsp--;
7705
7706
7707 }
7708
7709 }
7710 catch (RecognitionException re) {
7711 reportError(re);
7712 recover(input,re);
7713 }
7714 finally {
7715
7716 restoreStackSize(stackSize);
7717
7718 }
7719 return ;
7720 }
7721 // $ANTLR end "rule__EqualsSymbol__Group__0"
7722
7723
7724 // $ANTLR start "rule__EqualsSymbol__Group__0__Impl"
7725 // InternalSolverLanguage.g:2402:1: rule__EqualsSymbol__Group__0__Impl : ( 'equals' ) ;
7726 public final void rule__EqualsSymbol__Group__0__Impl() throws RecognitionException {
7727
7728 int stackSize = keepStackSize();
7729
7730 try {
7731 // InternalSolverLanguage.g:2406:1: ( ( 'equals' ) )
7732 // InternalSolverLanguage.g:2407:1: ( 'equals' )
7733 {
7734 // InternalSolverLanguage.g:2407:1: ( 'equals' )
7735 // InternalSolverLanguage.g:2408:2: 'equals'
7736 {
7737 before(grammarAccess.getEqualsSymbolAccess().getEqualsKeyword_0());
7738 match(input,21,FOLLOW_2);
7739 after(grammarAccess.getEqualsSymbolAccess().getEqualsKeyword_0());
7740
7741 }
7742
7743
7744 }
7745
7746 }
7747 catch (RecognitionException re) {
7748 reportError(re);
7749 recover(input,re);
7750 }
7751 finally {
7752
7753 restoreStackSize(stackSize);
7754
7755 }
7756 return ;
7757 }
7758 // $ANTLR end "rule__EqualsSymbol__Group__0__Impl"
7759
7760
7761 // $ANTLR start "rule__EqualsSymbol__Group__1"
7762 // InternalSolverLanguage.g:2417:1: rule__EqualsSymbol__Group__1 : rule__EqualsSymbol__Group__1__Impl ;
7763 public final void rule__EqualsSymbol__Group__1() throws RecognitionException {
7764
7765 int stackSize = keepStackSize();
7766
7767 try {
7768 // InternalSolverLanguage.g:2421:1: ( rule__EqualsSymbol__Group__1__Impl )
7769 // InternalSolverLanguage.g:2422:2: rule__EqualsSymbol__Group__1__Impl
7770 {
7771 pushFollow(FOLLOW_2);
7772 rule__EqualsSymbol__Group__1__Impl();
7773
7774 state._fsp--;
7775
7776
7777 }
7778
7779 }
7780 catch (RecognitionException re) {
7781 reportError(re);
7782 recover(input,re);
7783 }
7784 finally {
7785
7786 restoreStackSize(stackSize);
7787
7788 }
7789 return ;
7790 }
7791 // $ANTLR end "rule__EqualsSymbol__Group__1"
7792
7793
7794 // $ANTLR start "rule__EqualsSymbol__Group__1__Impl"
7795 // InternalSolverLanguage.g:2428:1: rule__EqualsSymbol__Group__1__Impl : ( () ) ;
7796 public final void rule__EqualsSymbol__Group__1__Impl() throws RecognitionException {
7797
7798 int stackSize = keepStackSize();
7799
7800 try {
7801 // InternalSolverLanguage.g:2432:1: ( ( () ) )
7802 // InternalSolverLanguage.g:2433:1: ( () )
7803 {
7804 // InternalSolverLanguage.g:2433:1: ( () )
7805 // InternalSolverLanguage.g:2434:2: ()
7806 {
7807 before(grammarAccess.getEqualsSymbolAccess().getEqualsSymbolAction_1());
7808 // InternalSolverLanguage.g:2435:2: ()
7809 // InternalSolverLanguage.g:2435:3:
7810 {
7811 }
7812
7813 after(grammarAccess.getEqualsSymbolAccess().getEqualsSymbolAction_1());
7814
7815 }
7816
7817
7818 }
7819
7820 }
7821 finally {
7822
7823 restoreStackSize(stackSize);
7824
7825 }
7826 return ;
7827 }
7828 // $ANTLR end "rule__EqualsSymbol__Group__1__Impl"
7829
7830
7831 // $ANTLR start "rule__BooleanSymbol__Group__0"
7832 // InternalSolverLanguage.g:2444:1: rule__BooleanSymbol__Group__0 : rule__BooleanSymbol__Group__0__Impl rule__BooleanSymbol__Group__1 ;
7833 public final void rule__BooleanSymbol__Group__0() throws RecognitionException {
7834
7835 int stackSize = keepStackSize();
7836
7837 try {
7838 // InternalSolverLanguage.g:2448:1: ( rule__BooleanSymbol__Group__0__Impl rule__BooleanSymbol__Group__1 )
7839 // InternalSolverLanguage.g:2449:2: rule__BooleanSymbol__Group__0__Impl rule__BooleanSymbol__Group__1
7840 {
7841 pushFollow(FOLLOW_1);
7842 rule__BooleanSymbol__Group__0__Impl();
7843
7844 state._fsp--;
7845
7846 pushFollow(FOLLOW_2);
7847 rule__BooleanSymbol__Group__1();
7848
7849 state._fsp--;
7850
7851
7852 }
7853
7854 }
7855 catch (RecognitionException re) {
7856 reportError(re);
7857 recover(input,re);
7858 }
7859 finally {
7860
7861 restoreStackSize(stackSize);
7862
7863 }
7864 return ;
7865 }
7866 // $ANTLR end "rule__BooleanSymbol__Group__0"
7867
7868
7869 // $ANTLR start "rule__BooleanSymbol__Group__0__Impl"
7870 // InternalSolverLanguage.g:2456:1: rule__BooleanSymbol__Group__0__Impl : ( 'bool' ) ;
7871 public final void rule__BooleanSymbol__Group__0__Impl() throws RecognitionException {
7872
7873 int stackSize = keepStackSize();
7874
7875 try {
7876 // InternalSolverLanguage.g:2460:1: ( ( 'bool' ) )
7877 // InternalSolverLanguage.g:2461:1: ( 'bool' )
7878 {
7879 // InternalSolverLanguage.g:2461:1: ( 'bool' )
7880 // InternalSolverLanguage.g:2462:2: 'bool'
7881 {
7882 before(grammarAccess.getBooleanSymbolAccess().getBoolKeyword_0());
7883 match(input,22,FOLLOW_2);
7884 after(grammarAccess.getBooleanSymbolAccess().getBoolKeyword_0());
7885
7886 }
7887
7888
7889 }
7890
7891 }
7892 catch (RecognitionException re) {
7893 reportError(re);
7894 recover(input,re);
7895 }
7896 finally {
7897
7898 restoreStackSize(stackSize);
7899
7900 }
7901 return ;
7902 }
7903 // $ANTLR end "rule__BooleanSymbol__Group__0__Impl"
7904
7905
7906 // $ANTLR start "rule__BooleanSymbol__Group__1"
7907 // InternalSolverLanguage.g:2471:1: rule__BooleanSymbol__Group__1 : rule__BooleanSymbol__Group__1__Impl ;
7908 public final void rule__BooleanSymbol__Group__1() throws RecognitionException {
7909
7910 int stackSize = keepStackSize();
7911
7912 try {
7913 // InternalSolverLanguage.g:2475:1: ( rule__BooleanSymbol__Group__1__Impl )
7914 // InternalSolverLanguage.g:2476:2: rule__BooleanSymbol__Group__1__Impl
7915 {
7916 pushFollow(FOLLOW_2);
7917 rule__BooleanSymbol__Group__1__Impl();
7918
7919 state._fsp--;
7920
7921
7922 }
7923
7924 }
7925 catch (RecognitionException re) {
7926 reportError(re);
7927 recover(input,re);
7928 }
7929 finally {
7930
7931 restoreStackSize(stackSize);
7932
7933 }
7934 return ;
7935 }
7936 // $ANTLR end "rule__BooleanSymbol__Group__1"
7937
7938
7939 // $ANTLR start "rule__BooleanSymbol__Group__1__Impl"
7940 // InternalSolverLanguage.g:2482:1: rule__BooleanSymbol__Group__1__Impl : ( () ) ;
7941 public final void rule__BooleanSymbol__Group__1__Impl() throws RecognitionException {
7942
7943 int stackSize = keepStackSize();
7944
7945 try {
7946 // InternalSolverLanguage.g:2486:1: ( ( () ) )
7947 // InternalSolverLanguage.g:2487:1: ( () )
7948 {
7949 // InternalSolverLanguage.g:2487:1: ( () )
7950 // InternalSolverLanguage.g:2488:2: ()
7951 {
7952 before(grammarAccess.getBooleanSymbolAccess().getBooleanSymbolAction_1());
7953 // InternalSolverLanguage.g:2489:2: ()
7954 // InternalSolverLanguage.g:2489:3:
7955 {
7956 }
7957
7958 after(grammarAccess.getBooleanSymbolAccess().getBooleanSymbolAction_1());
7959
7960 }
7961
7962
7963 }
7964
7965 }
7966 finally {
7967
7968 restoreStackSize(stackSize);
7969
7970 }
7971 return ;
7972 }
7973 // $ANTLR end "rule__BooleanSymbol__Group__1__Impl"
7974
7975
7976 // $ANTLR start "rule__IntegerSymbol__Group__0"
7977 // InternalSolverLanguage.g:2498:1: rule__IntegerSymbol__Group__0 : rule__IntegerSymbol__Group__0__Impl rule__IntegerSymbol__Group__1 ;
7978 public final void rule__IntegerSymbol__Group__0() throws RecognitionException {
7979
7980 int stackSize = keepStackSize();
7981
7982 try {
7983 // InternalSolverLanguage.g:2502:1: ( rule__IntegerSymbol__Group__0__Impl rule__IntegerSymbol__Group__1 )
7984 // InternalSolverLanguage.g:2503:2: rule__IntegerSymbol__Group__0__Impl rule__IntegerSymbol__Group__1
7985 {
7986 pushFollow(FOLLOW_1);
7987 rule__IntegerSymbol__Group__0__Impl();
7988
7989 state._fsp--;
7990
7991 pushFollow(FOLLOW_2);
7992 rule__IntegerSymbol__Group__1();
7993
7994 state._fsp--;
7995
7996
7997 }
7998
7999 }
8000 catch (RecognitionException re) {
8001 reportError(re);
8002 recover(input,re);
8003 }
8004 finally {
8005
8006 restoreStackSize(stackSize);
8007
8008 }
8009 return ;
8010 }
8011 // $ANTLR end "rule__IntegerSymbol__Group__0"
8012
8013
8014 // $ANTLR start "rule__IntegerSymbol__Group__0__Impl"
8015 // InternalSolverLanguage.g:2510:1: rule__IntegerSymbol__Group__0__Impl : ( 'int' ) ;
8016 public final void rule__IntegerSymbol__Group__0__Impl() throws RecognitionException {
8017
8018 int stackSize = keepStackSize();
8019
8020 try {
8021 // InternalSolverLanguage.g:2514:1: ( ( 'int' ) )
8022 // InternalSolverLanguage.g:2515:1: ( 'int' )
8023 {
8024 // InternalSolverLanguage.g:2515:1: ( 'int' )
8025 // InternalSolverLanguage.g:2516:2: 'int'
8026 {
8027 before(grammarAccess.getIntegerSymbolAccess().getIntKeyword_0());
8028 match(input,23,FOLLOW_2);
8029 after(grammarAccess.getIntegerSymbolAccess().getIntKeyword_0());
8030
8031 }
8032
8033
8034 }
8035
8036 }
8037 catch (RecognitionException re) {
8038 reportError(re);
8039 recover(input,re);
8040 }
8041 finally {
8042
8043 restoreStackSize(stackSize);
8044
8045 }
8046 return ;
8047 }
8048 // $ANTLR end "rule__IntegerSymbol__Group__0__Impl"
8049
8050
8051 // $ANTLR start "rule__IntegerSymbol__Group__1"
8052 // InternalSolverLanguage.g:2525:1: rule__IntegerSymbol__Group__1 : rule__IntegerSymbol__Group__1__Impl ;
8053 public final void rule__IntegerSymbol__Group__1() throws RecognitionException {
8054
8055 int stackSize = keepStackSize();
8056
8057 try {
8058 // InternalSolverLanguage.g:2529:1: ( rule__IntegerSymbol__Group__1__Impl )
8059 // InternalSolverLanguage.g:2530:2: rule__IntegerSymbol__Group__1__Impl
8060 {
8061 pushFollow(FOLLOW_2);
8062 rule__IntegerSymbol__Group__1__Impl();
8063
8064 state._fsp--;
8065
8066
8067 }
8068
8069 }
8070 catch (RecognitionException re) {
8071 reportError(re);
8072 recover(input,re);
8073 }
8074 finally {
8075
8076 restoreStackSize(stackSize);
8077
8078 }
8079 return ;
8080 }
8081 // $ANTLR end "rule__IntegerSymbol__Group__1"
8082
8083
8084 // $ANTLR start "rule__IntegerSymbol__Group__1__Impl"
8085 // InternalSolverLanguage.g:2536:1: rule__IntegerSymbol__Group__1__Impl : ( () ) ;
8086 public final void rule__IntegerSymbol__Group__1__Impl() throws RecognitionException {
8087
8088 int stackSize = keepStackSize();
8089
8090 try {
8091 // InternalSolverLanguage.g:2540:1: ( ( () ) )
8092 // InternalSolverLanguage.g:2541:1: ( () )
8093 {
8094 // InternalSolverLanguage.g:2541:1: ( () )
8095 // InternalSolverLanguage.g:2542:2: ()
8096 {
8097 before(grammarAccess.getIntegerSymbolAccess().getIntegerSymbolAction_1());
8098 // InternalSolverLanguage.g:2543:2: ()
8099 // InternalSolverLanguage.g:2543:3:
8100 {
8101 }
8102
8103 after(grammarAccess.getIntegerSymbolAccess().getIntegerSymbolAction_1());
8104
8105 }
8106
8107
8108 }
8109
8110 }
8111 finally {
8112
8113 restoreStackSize(stackSize);
8114
8115 }
8116 return ;
8117 }
8118 // $ANTLR end "rule__IntegerSymbol__Group__1__Impl"
8119
8120
8121 // $ANTLR start "rule__RealSymbol__Group__0"
8122 // InternalSolverLanguage.g:2552:1: rule__RealSymbol__Group__0 : rule__RealSymbol__Group__0__Impl rule__RealSymbol__Group__1 ;
8123 public final void rule__RealSymbol__Group__0() throws RecognitionException {
8124
8125 int stackSize = keepStackSize();
8126
8127 try {
8128 // InternalSolverLanguage.g:2556:1: ( rule__RealSymbol__Group__0__Impl rule__RealSymbol__Group__1 )
8129 // InternalSolverLanguage.g:2557:2: rule__RealSymbol__Group__0__Impl rule__RealSymbol__Group__1
8130 {
8131 pushFollow(FOLLOW_1);
8132 rule__RealSymbol__Group__0__Impl();
8133
8134 state._fsp--;
8135
8136 pushFollow(FOLLOW_2);
8137 rule__RealSymbol__Group__1();
8138
8139 state._fsp--;
8140
8141
8142 }
8143
8144 }
8145 catch (RecognitionException re) {
8146 reportError(re);
8147 recover(input,re);
8148 }
8149 finally {
8150
8151 restoreStackSize(stackSize);
8152
8153 }
8154 return ;
8155 }
8156 // $ANTLR end "rule__RealSymbol__Group__0"
8157
8158
8159 // $ANTLR start "rule__RealSymbol__Group__0__Impl"
8160 // InternalSolverLanguage.g:2564:1: rule__RealSymbol__Group__0__Impl : ( 'real' ) ;
8161 public final void rule__RealSymbol__Group__0__Impl() throws RecognitionException {
8162
8163 int stackSize = keepStackSize();
8164
8165 try {
8166 // InternalSolverLanguage.g:2568:1: ( ( 'real' ) )
8167 // InternalSolverLanguage.g:2569:1: ( 'real' )
8168 {
8169 // InternalSolverLanguage.g:2569:1: ( 'real' )
8170 // InternalSolverLanguage.g:2570:2: 'real'
8171 {
8172 before(grammarAccess.getRealSymbolAccess().getRealKeyword_0());
8173 match(input,24,FOLLOW_2);
8174 after(grammarAccess.getRealSymbolAccess().getRealKeyword_0());
8175
8176 }
8177
8178
8179 }
8180
8181 }
8182 catch (RecognitionException re) {
8183 reportError(re);
8184 recover(input,re);
8185 }
8186 finally {
8187
8188 restoreStackSize(stackSize);
8189
8190 }
8191 return ;
8192 }
8193 // $ANTLR end "rule__RealSymbol__Group__0__Impl"
8194
8195
8196 // $ANTLR start "rule__RealSymbol__Group__1"
8197 // InternalSolverLanguage.g:2579:1: rule__RealSymbol__Group__1 : rule__RealSymbol__Group__1__Impl ;
8198 public final void rule__RealSymbol__Group__1() throws RecognitionException {
8199
8200 int stackSize = keepStackSize();
8201
8202 try {
8203 // InternalSolverLanguage.g:2583:1: ( rule__RealSymbol__Group__1__Impl )
8204 // InternalSolverLanguage.g:2584:2: rule__RealSymbol__Group__1__Impl
8205 {
8206 pushFollow(FOLLOW_2);
8207 rule__RealSymbol__Group__1__Impl();
8208
8209 state._fsp--;
8210
8211
8212 }
8213
8214 }
8215 catch (RecognitionException re) {
8216 reportError(re);
8217 recover(input,re);
8218 }
8219 finally {
8220
8221 restoreStackSize(stackSize);
8222
8223 }
8224 return ;
8225 }
8226 // $ANTLR end "rule__RealSymbol__Group__1"
8227
8228
8229 // $ANTLR start "rule__RealSymbol__Group__1__Impl"
8230 // InternalSolverLanguage.g:2590:1: rule__RealSymbol__Group__1__Impl : ( () ) ;
8231 public final void rule__RealSymbol__Group__1__Impl() throws RecognitionException {
8232
8233 int stackSize = keepStackSize();
8234
8235 try {
8236 // InternalSolverLanguage.g:2594:1: ( ( () ) )
8237 // InternalSolverLanguage.g:2595:1: ( () )
8238 {
8239 // InternalSolverLanguage.g:2595:1: ( () )
8240 // InternalSolverLanguage.g:2596:2: ()
8241 {
8242 before(grammarAccess.getRealSymbolAccess().getRealSymbolAction_1());
8243 // InternalSolverLanguage.g:2597:2: ()
8244 // InternalSolverLanguage.g:2597:3:
8245 {
8246 }
8247
8248 after(grammarAccess.getRealSymbolAccess().getRealSymbolAction_1());
8249
8250 }
8251
8252
8253 }
8254
8255 }
8256 finally {
8257
8258 restoreStackSize(stackSize);
8259
8260 }
8261 return ;
8262 }
8263 // $ANTLR end "rule__RealSymbol__Group__1__Impl"
8264
8265
8266 // $ANTLR start "rule__StringSymbol__Group__0"
8267 // InternalSolverLanguage.g:2606:1: rule__StringSymbol__Group__0 : rule__StringSymbol__Group__0__Impl rule__StringSymbol__Group__1 ;
8268 public final void rule__StringSymbol__Group__0() throws RecognitionException {
8269
8270 int stackSize = keepStackSize();
8271
8272 try {
8273 // InternalSolverLanguage.g:2610:1: ( rule__StringSymbol__Group__0__Impl rule__StringSymbol__Group__1 )
8274 // InternalSolverLanguage.g:2611:2: rule__StringSymbol__Group__0__Impl rule__StringSymbol__Group__1
8275 {
8276 pushFollow(FOLLOW_1);
8277 rule__StringSymbol__Group__0__Impl();
8278
8279 state._fsp--;
8280
8281 pushFollow(FOLLOW_2);
8282 rule__StringSymbol__Group__1();
8283
8284 state._fsp--;
8285
8286
8287 }
8288
8289 }
8290 catch (RecognitionException re) {
8291 reportError(re);
8292 recover(input,re);
8293 }
8294 finally {
8295
8296 restoreStackSize(stackSize);
8297
8298 }
8299 return ;
8300 }
8301 // $ANTLR end "rule__StringSymbol__Group__0"
8302
8303
8304 // $ANTLR start "rule__StringSymbol__Group__0__Impl"
8305 // InternalSolverLanguage.g:2618:1: rule__StringSymbol__Group__0__Impl : ( 'string' ) ;
8306 public final void rule__StringSymbol__Group__0__Impl() throws RecognitionException {
8307
8308 int stackSize = keepStackSize();
8309
8310 try {
8311 // InternalSolverLanguage.g:2622:1: ( ( 'string' ) )
8312 // InternalSolverLanguage.g:2623:1: ( 'string' )
8313 {
8314 // InternalSolverLanguage.g:2623:1: ( 'string' )
8315 // InternalSolverLanguage.g:2624:2: 'string'
8316 {
8317 before(grammarAccess.getStringSymbolAccess().getStringKeyword_0());
8318 match(input,25,FOLLOW_2);
8319 after(grammarAccess.getStringSymbolAccess().getStringKeyword_0());
8320
8321 }
8322
8323
8324 }
8325
8326 }
8327 catch (RecognitionException re) {
8328 reportError(re);
8329 recover(input,re);
8330 }
8331 finally {
8332
8333 restoreStackSize(stackSize);
8334
8335 }
8336 return ;
8337 }
8338 // $ANTLR end "rule__StringSymbol__Group__0__Impl"
8339
8340
8341 // $ANTLR start "rule__StringSymbol__Group__1"
8342 // InternalSolverLanguage.g:2633:1: rule__StringSymbol__Group__1 : rule__StringSymbol__Group__1__Impl ;
8343 public final void rule__StringSymbol__Group__1() throws RecognitionException {
8344
8345 int stackSize = keepStackSize();
8346
8347 try {
8348 // InternalSolverLanguage.g:2637:1: ( rule__StringSymbol__Group__1__Impl )
8349 // InternalSolverLanguage.g:2638:2: rule__StringSymbol__Group__1__Impl
8350 {
8351 pushFollow(FOLLOW_2);
8352 rule__StringSymbol__Group__1__Impl();
8353
8354 state._fsp--;
8355
8356
8357 }
8358
8359 }
8360 catch (RecognitionException re) {
8361 reportError(re);
8362 recover(input,re);
8363 }
8364 finally {
8365
8366 restoreStackSize(stackSize);
8367
8368 }
8369 return ;
8370 }
8371 // $ANTLR end "rule__StringSymbol__Group__1"
8372
8373
8374 // $ANTLR start "rule__StringSymbol__Group__1__Impl"
8375 // InternalSolverLanguage.g:2644:1: rule__StringSymbol__Group__1__Impl : ( () ) ;
8376 public final void rule__StringSymbol__Group__1__Impl() throws RecognitionException {
8377
8378 int stackSize = keepStackSize();
8379
8380 try {
8381 // InternalSolverLanguage.g:2648:1: ( ( () ) )
8382 // InternalSolverLanguage.g:2649:1: ( () )
8383 {
8384 // InternalSolverLanguage.g:2649:1: ( () )
8385 // InternalSolverLanguage.g:2650:2: ()
8386 {
8387 before(grammarAccess.getStringSymbolAccess().getStringSymbolAction_1());
8388 // InternalSolverLanguage.g:2651:2: ()
8389 // InternalSolverLanguage.g:2651:3:
8390 {
8391 }
8392
8393 after(grammarAccess.getStringSymbolAccess().getStringSymbolAction_1());
8394
8395 }
8396
8397
8398 }
8399
8400 }
8401 finally {
8402
8403 restoreStackSize(stackSize);
8404
8405 }
8406 return ;
8407 }
8408 // $ANTLR end "rule__StringSymbol__Group__1__Impl"
8409
8410
8411 // $ANTLR start "rule__NamedObject__Group__0"
8412 // InternalSolverLanguage.g:2660:1: rule__NamedObject__Group__0 : rule__NamedObject__Group__0__Impl rule__NamedObject__Group__1 ;
8413 public final void rule__NamedObject__Group__0() throws RecognitionException {
8414
8415 int stackSize = keepStackSize();
8416
8417 try {
8418 // InternalSolverLanguage.g:2664:1: ( rule__NamedObject__Group__0__Impl rule__NamedObject__Group__1 )
8419 // InternalSolverLanguage.g:2665:2: rule__NamedObject__Group__0__Impl rule__NamedObject__Group__1
8420 {
8421 pushFollow(FOLLOW_16);
8422 rule__NamedObject__Group__0__Impl();
8423
8424 state._fsp--;
8425
8426 pushFollow(FOLLOW_2);
8427 rule__NamedObject__Group__1();
8428
8429 state._fsp--;
8430
8431
8432 }
8433
8434 }
8435 catch (RecognitionException re) {
8436 reportError(re);
8437 recover(input,re);
8438 }
8439 finally {
8440
8441 restoreStackSize(stackSize);
8442
8443 }
8444 return ;
8445 }
8446 // $ANTLR end "rule__NamedObject__Group__0"
8447
8448
8449 // $ANTLR start "rule__NamedObject__Group__0__Impl"
8450 // InternalSolverLanguage.g:2672:1: rule__NamedObject__Group__0__Impl : ( '\\'' ) ;
8451 public final void rule__NamedObject__Group__0__Impl() throws RecognitionException {
8452
8453 int stackSize = keepStackSize();
8454
8455 try {
8456 // InternalSolverLanguage.g:2676:1: ( ( '\\'' ) )
8457 // InternalSolverLanguage.g:2677:1: ( '\\'' )
8458 {
8459 // InternalSolverLanguage.g:2677:1: ( '\\'' )
8460 // InternalSolverLanguage.g:2678:2: '\\''
8461 {
8462 before(grammarAccess.getNamedObjectAccess().getApostropheKeyword_0());
8463 match(input,26,FOLLOW_2);
8464 after(grammarAccess.getNamedObjectAccess().getApostropheKeyword_0());
8465
8466 }
8467
8468
8469 }
8470
8471 }
8472 catch (RecognitionException re) {
8473 reportError(re);
8474 recover(input,re);
8475 }
8476 finally {
8477
8478 restoreStackSize(stackSize);
8479
8480 }
8481 return ;
8482 }
8483 // $ANTLR end "rule__NamedObject__Group__0__Impl"
8484
8485
8486 // $ANTLR start "rule__NamedObject__Group__1"
8487 // InternalSolverLanguage.g:2687:1: rule__NamedObject__Group__1 : rule__NamedObject__Group__1__Impl rule__NamedObject__Group__2 ;
8488 public final void rule__NamedObject__Group__1() throws RecognitionException {
8489
8490 int stackSize = keepStackSize();
8491
8492 try {
8493 // InternalSolverLanguage.g:2691:1: ( rule__NamedObject__Group__1__Impl rule__NamedObject__Group__2 )
8494 // InternalSolverLanguage.g:2692:2: rule__NamedObject__Group__1__Impl rule__NamedObject__Group__2
8495 {
8496 pushFollow(FOLLOW_17);
8497 rule__NamedObject__Group__1__Impl();
8498
8499 state._fsp--;
8500
8501 pushFollow(FOLLOW_2);
8502 rule__NamedObject__Group__2();
8503
8504 state._fsp--;
8505
8506
8507 }
8508
8509 }
8510 catch (RecognitionException re) {
8511 reportError(re);
8512 recover(input,re);
8513 }
8514 finally {
8515
8516 restoreStackSize(stackSize);
8517
8518 }
8519 return ;
8520 }
8521 // $ANTLR end "rule__NamedObject__Group__1"
8522
8523
8524 // $ANTLR start "rule__NamedObject__Group__1__Impl"
8525 // InternalSolverLanguage.g:2699:1: rule__NamedObject__Group__1__Impl : ( ( rule__NamedObject__NameAssignment_1 ) ) ;
8526 public final void rule__NamedObject__Group__1__Impl() throws RecognitionException {
8527
8528 int stackSize = keepStackSize();
8529
8530 try {
8531 // InternalSolverLanguage.g:2703:1: ( ( ( rule__NamedObject__NameAssignment_1 ) ) )
8532 // InternalSolverLanguage.g:2704:1: ( ( rule__NamedObject__NameAssignment_1 ) )
8533 {
8534 // InternalSolverLanguage.g:2704:1: ( ( rule__NamedObject__NameAssignment_1 ) )
8535 // InternalSolverLanguage.g:2705:2: ( rule__NamedObject__NameAssignment_1 )
8536 {
8537 before(grammarAccess.getNamedObjectAccess().getNameAssignment_1());
8538 // InternalSolverLanguage.g:2706:2: ( rule__NamedObject__NameAssignment_1 )
8539 // InternalSolverLanguage.g:2706:3: rule__NamedObject__NameAssignment_1
8540 {
8541 pushFollow(FOLLOW_2);
8542 rule__NamedObject__NameAssignment_1();
8543
8544 state._fsp--;
8545
8546
8547 }
8548
8549 after(grammarAccess.getNamedObjectAccess().getNameAssignment_1());
8550
8551 }
8552
8553
8554 }
8555
8556 }
8557 catch (RecognitionException re) {
8558 reportError(re);
8559 recover(input,re);
8560 }
8561 finally {
8562
8563 restoreStackSize(stackSize);
8564
8565 }
8566 return ;
8567 }
8568 // $ANTLR end "rule__NamedObject__Group__1__Impl"
8569
8570
8571 // $ANTLR start "rule__NamedObject__Group__2"
8572 // InternalSolverLanguage.g:2714:1: rule__NamedObject__Group__2 : rule__NamedObject__Group__2__Impl ;
8573 public final void rule__NamedObject__Group__2() throws RecognitionException {
8574
8575 int stackSize = keepStackSize();
8576
8577 try {
8578 // InternalSolverLanguage.g:2718:1: ( rule__NamedObject__Group__2__Impl )
8579 // InternalSolverLanguage.g:2719:2: rule__NamedObject__Group__2__Impl
8580 {
8581 pushFollow(FOLLOW_2);
8582 rule__NamedObject__Group__2__Impl();
8583
8584 state._fsp--;
8585
8586
8587 }
8588
8589 }
8590 catch (RecognitionException re) {
8591 reportError(re);
8592 recover(input,re);
8593 }
8594 finally {
8595
8596 restoreStackSize(stackSize);
8597
8598 }
8599 return ;
8600 }
8601 // $ANTLR end "rule__NamedObject__Group__2"
8602
8603
8604 // $ANTLR start "rule__NamedObject__Group__2__Impl"
8605 // InternalSolverLanguage.g:2725:1: rule__NamedObject__Group__2__Impl : ( '\\'' ) ;
8606 public final void rule__NamedObject__Group__2__Impl() throws RecognitionException {
8607
8608 int stackSize = keepStackSize();
8609
8610 try {
8611 // InternalSolverLanguage.g:2729:1: ( ( '\\'' ) )
8612 // InternalSolverLanguage.g:2730:1: ( '\\'' )
8613 {
8614 // InternalSolverLanguage.g:2730:1: ( '\\'' )
8615 // InternalSolverLanguage.g:2731:2: '\\''
8616 {
8617 before(grammarAccess.getNamedObjectAccess().getApostropheKeyword_2());
8618 match(input,26,FOLLOW_2);
8619 after(grammarAccess.getNamedObjectAccess().getApostropheKeyword_2());
8620
8621 }
8622
8623
8624 }
8625
8626 }
8627 catch (RecognitionException re) {
8628 reportError(re);
8629 recover(input,re);
8630 }
8631 finally {
8632
8633 restoreStackSize(stackSize);
8634
8635 }
8636 return ;
8637 }
8638 // $ANTLR end "rule__NamedObject__Group__2__Impl"
8639
8640
8641 // $ANTLR start "rule__PredicateSymbol__Group__0"
8642 // InternalSolverLanguage.g:2741:1: rule__PredicateSymbol__Group__0 : rule__PredicateSymbol__Group__0__Impl rule__PredicateSymbol__Group__1 ;
8643 public final void rule__PredicateSymbol__Group__0() throws RecognitionException {
8644
8645 int stackSize = keepStackSize();
8646
8647 try {
8648 // InternalSolverLanguage.g:2745:1: ( rule__PredicateSymbol__Group__0__Impl rule__PredicateSymbol__Group__1 )
8649 // InternalSolverLanguage.g:2746:2: rule__PredicateSymbol__Group__0__Impl rule__PredicateSymbol__Group__1
8650 {
8651 pushFollow(FOLLOW_16);
8652 rule__PredicateSymbol__Group__0__Impl();
8653
8654 state._fsp--;
8655
8656 pushFollow(FOLLOW_2);
8657 rule__PredicateSymbol__Group__1();
8658
8659 state._fsp--;
8660
8661
8662 }
8663
8664 }
8665 catch (RecognitionException re) {
8666 reportError(re);
8667 recover(input,re);
8668 }
8669 finally {
8670
8671 restoreStackSize(stackSize);
8672
8673 }
8674 return ;
8675 }
8676 // $ANTLR end "rule__PredicateSymbol__Group__0"
8677
8678
8679 // $ANTLR start "rule__PredicateSymbol__Group__0__Impl"
8680 // InternalSolverLanguage.g:2753:1: rule__PredicateSymbol__Group__0__Impl : ( 'predicate' ) ;
8681 public final void rule__PredicateSymbol__Group__0__Impl() throws RecognitionException {
8682
8683 int stackSize = keepStackSize();
8684
8685 try {
8686 // InternalSolverLanguage.g:2757:1: ( ( 'predicate' ) )
8687 // InternalSolverLanguage.g:2758:1: ( 'predicate' )
8688 {
8689 // InternalSolverLanguage.g:2758:1: ( 'predicate' )
8690 // InternalSolverLanguage.g:2759:2: 'predicate'
8691 {
8692 before(grammarAccess.getPredicateSymbolAccess().getPredicateKeyword_0());
8693 match(input,27,FOLLOW_2);
8694 after(grammarAccess.getPredicateSymbolAccess().getPredicateKeyword_0());
8695
8696 }
8697
8698
8699 }
8700
8701 }
8702 catch (RecognitionException re) {
8703 reportError(re);
8704 recover(input,re);
8705 }
8706 finally {
8707
8708 restoreStackSize(stackSize);
8709
8710 }
8711 return ;
8712 }
8713 // $ANTLR end "rule__PredicateSymbol__Group__0__Impl"
8714
8715
8716 // $ANTLR start "rule__PredicateSymbol__Group__1"
8717 // InternalSolverLanguage.g:2768:1: rule__PredicateSymbol__Group__1 : rule__PredicateSymbol__Group__1__Impl rule__PredicateSymbol__Group__2 ;
8718 public final void rule__PredicateSymbol__Group__1() throws RecognitionException {
8719
8720 int stackSize = keepStackSize();
8721
8722 try {
8723 // InternalSolverLanguage.g:2772:1: ( rule__PredicateSymbol__Group__1__Impl rule__PredicateSymbol__Group__2 )
8724 // InternalSolverLanguage.g:2773:2: rule__PredicateSymbol__Group__1__Impl rule__PredicateSymbol__Group__2
8725 {
8726 pushFollow(FOLLOW_11);
8727 rule__PredicateSymbol__Group__1__Impl();
8728
8729 state._fsp--;
8730
8731 pushFollow(FOLLOW_2);
8732 rule__PredicateSymbol__Group__2();
8733
8734 state._fsp--;
8735
8736
8737 }
8738
8739 }
8740 catch (RecognitionException re) {
8741 reportError(re);
8742 recover(input,re);
8743 }
8744 finally {
8745
8746 restoreStackSize(stackSize);
8747
8748 }
8749 return ;
8750 }
8751 // $ANTLR end "rule__PredicateSymbol__Group__1"
8752
8753
8754 // $ANTLR start "rule__PredicateSymbol__Group__1__Impl"
8755 // InternalSolverLanguage.g:2780:1: rule__PredicateSymbol__Group__1__Impl : ( ( rule__PredicateSymbol__SymbolAssignment_1 ) ) ;
8756 public final void rule__PredicateSymbol__Group__1__Impl() throws RecognitionException {
8757
8758 int stackSize = keepStackSize();
8759
8760 try {
8761 // InternalSolverLanguage.g:2784:1: ( ( ( rule__PredicateSymbol__SymbolAssignment_1 ) ) )
8762 // InternalSolverLanguage.g:2785:1: ( ( rule__PredicateSymbol__SymbolAssignment_1 ) )
8763 {
8764 // InternalSolverLanguage.g:2785:1: ( ( rule__PredicateSymbol__SymbolAssignment_1 ) )
8765 // InternalSolverLanguage.g:2786:2: ( rule__PredicateSymbol__SymbolAssignment_1 )
8766 {
8767 before(grammarAccess.getPredicateSymbolAccess().getSymbolAssignment_1());
8768 // InternalSolverLanguage.g:2787:2: ( rule__PredicateSymbol__SymbolAssignment_1 )
8769 // InternalSolverLanguage.g:2787:3: rule__PredicateSymbol__SymbolAssignment_1
8770 {
8771 pushFollow(FOLLOW_2);
8772 rule__PredicateSymbol__SymbolAssignment_1();
8773
8774 state._fsp--;
8775
8776
8777 }
8778
8779 after(grammarAccess.getPredicateSymbolAccess().getSymbolAssignment_1());
8780
8781 }
8782
8783
8784 }
8785
8786 }
8787 catch (RecognitionException re) {
8788 reportError(re);
8789 recover(input,re);
8790 }
8791 finally {
8792
8793 restoreStackSize(stackSize);
8794
8795 }
8796 return ;
8797 }
8798 // $ANTLR end "rule__PredicateSymbol__Group__1__Impl"
8799
8800
8801 // $ANTLR start "rule__PredicateSymbol__Group__2"
8802 // InternalSolverLanguage.g:2795:1: rule__PredicateSymbol__Group__2 : rule__PredicateSymbol__Group__2__Impl rule__PredicateSymbol__Group__3 ;
8803 public final void rule__PredicateSymbol__Group__2() throws RecognitionException {
8804
8805 int stackSize = keepStackSize();
8806
8807 try {
8808 // InternalSolverLanguage.g:2799:1: ( rule__PredicateSymbol__Group__2__Impl rule__PredicateSymbol__Group__3 )
8809 // InternalSolverLanguage.g:2800:2: rule__PredicateSymbol__Group__2__Impl rule__PredicateSymbol__Group__3
8810 {
8811 pushFollow(FOLLOW_18);
8812 rule__PredicateSymbol__Group__2__Impl();
8813
8814 state._fsp--;
8815
8816 pushFollow(FOLLOW_2);
8817 rule__PredicateSymbol__Group__3();
8818
8819 state._fsp--;
8820
8821
8822 }
8823
8824 }
8825 catch (RecognitionException re) {
8826 reportError(re);
8827 recover(input,re);
8828 }
8829 finally {
8830
8831 restoreStackSize(stackSize);
8832
8833 }
8834 return ;
8835 }
8836 // $ANTLR end "rule__PredicateSymbol__Group__2"
8837
8838
8839 // $ANTLR start "rule__PredicateSymbol__Group__2__Impl"
8840 // InternalSolverLanguage.g:2807:1: rule__PredicateSymbol__Group__2__Impl : ( '(' ) ;
8841 public final void rule__PredicateSymbol__Group__2__Impl() throws RecognitionException {
8842
8843 int stackSize = keepStackSize();
8844
8845 try {
8846 // InternalSolverLanguage.g:2811:1: ( ( '(' ) )
8847 // InternalSolverLanguage.g:2812:1: ( '(' )
8848 {
8849 // InternalSolverLanguage.g:2812:1: ( '(' )
8850 // InternalSolverLanguage.g:2813:2: '('
8851 {
8852 before(grammarAccess.getPredicateSymbolAccess().getLeftParenthesisKeyword_2());
8853 match(input,17,FOLLOW_2);
8854 after(grammarAccess.getPredicateSymbolAccess().getLeftParenthesisKeyword_2());
8855
8856 }
8857
8858
8859 }
8860
8861 }
8862 catch (RecognitionException re) {
8863 reportError(re);
8864 recover(input,re);
8865 }
8866 finally {
8867
8868 restoreStackSize(stackSize);
8869
8870 }
8871 return ;
8872 }
8873 // $ANTLR end "rule__PredicateSymbol__Group__2__Impl"
8874
8875
8876 // $ANTLR start "rule__PredicateSymbol__Group__3"
8877 // InternalSolverLanguage.g:2822:1: rule__PredicateSymbol__Group__3 : rule__PredicateSymbol__Group__3__Impl rule__PredicateSymbol__Group__4 ;
8878 public final void rule__PredicateSymbol__Group__3() throws RecognitionException {
8879
8880 int stackSize = keepStackSize();
8881
8882 try {
8883 // InternalSolverLanguage.g:2826:1: ( rule__PredicateSymbol__Group__3__Impl rule__PredicateSymbol__Group__4 )
8884 // InternalSolverLanguage.g:2827:2: rule__PredicateSymbol__Group__3__Impl rule__PredicateSymbol__Group__4
8885 {
8886 pushFollow(FOLLOW_18);
8887 rule__PredicateSymbol__Group__3__Impl();
8888
8889 state._fsp--;
8890
8891 pushFollow(FOLLOW_2);
8892 rule__PredicateSymbol__Group__4();
8893
8894 state._fsp--;
8895
8896
8897 }
8898
8899 }
8900 catch (RecognitionException re) {
8901 reportError(re);
8902 recover(input,re);
8903 }
8904 finally {
8905
8906 restoreStackSize(stackSize);
8907
8908 }
8909 return ;
8910 }
8911 // $ANTLR end "rule__PredicateSymbol__Group__3"
8912
8913
8914 // $ANTLR start "rule__PredicateSymbol__Group__3__Impl"
8915 // InternalSolverLanguage.g:2834:1: rule__PredicateSymbol__Group__3__Impl : ( ( rule__PredicateSymbol__ParametersAssignment_3 )* ) ;
8916 public final void rule__PredicateSymbol__Group__3__Impl() throws RecognitionException {
8917
8918 int stackSize = keepStackSize();
8919
8920 try {
8921 // InternalSolverLanguage.g:2838:1: ( ( ( rule__PredicateSymbol__ParametersAssignment_3 )* ) )
8922 // InternalSolverLanguage.g:2839:1: ( ( rule__PredicateSymbol__ParametersAssignment_3 )* )
8923 {
8924 // InternalSolverLanguage.g:2839:1: ( ( rule__PredicateSymbol__ParametersAssignment_3 )* )
8925 // InternalSolverLanguage.g:2840:2: ( rule__PredicateSymbol__ParametersAssignment_3 )*
8926 {
8927 before(grammarAccess.getPredicateSymbolAccess().getParametersAssignment_3());
8928 // InternalSolverLanguage.g:2841:2: ( rule__PredicateSymbol__ParametersAssignment_3 )*
8929 loop26:
8930 do {
8931 int alt26=2;
8932 int LA26_0 = input.LA(1);
8933
8934 if ( (LA26_0==RULE_ID) ) {
8935 alt26=1;
8936 }
8937
8938
8939 switch (alt26) {
8940 case 1 :
8941 // InternalSolverLanguage.g:2841:3: rule__PredicateSymbol__ParametersAssignment_3
8942 {
8943 pushFollow(FOLLOW_19);
8944 rule__PredicateSymbol__ParametersAssignment_3();
8945
8946 state._fsp--;
8947
8948
8949 }
8950 break;
8951
8952 default :
8953 break loop26;
8954 }
8955 } while (true);
8956
8957 after(grammarAccess.getPredicateSymbolAccess().getParametersAssignment_3());
8958
8959 }
8960
8961
8962 }
8963
8964 }
8965 catch (RecognitionException re) {
8966 reportError(re);
8967 recover(input,re);
8968 }
8969 finally {
8970
8971 restoreStackSize(stackSize);
8972
8973 }
8974 return ;
8975 }
8976 // $ANTLR end "rule__PredicateSymbol__Group__3__Impl"
8977
8978
8979 // $ANTLR start "rule__PredicateSymbol__Group__4"
8980 // InternalSolverLanguage.g:2849:1: rule__PredicateSymbol__Group__4 : rule__PredicateSymbol__Group__4__Impl rule__PredicateSymbol__Group__5 ;
8981 public final void rule__PredicateSymbol__Group__4() throws RecognitionException {
8982
8983 int stackSize = keepStackSize();
8984
8985 try {
8986 // InternalSolverLanguage.g:2853:1: ( rule__PredicateSymbol__Group__4__Impl rule__PredicateSymbol__Group__5 )
8987 // InternalSolverLanguage.g:2854:2: rule__PredicateSymbol__Group__4__Impl rule__PredicateSymbol__Group__5
8988 {
8989 pushFollow(FOLLOW_14);
8990 rule__PredicateSymbol__Group__4__Impl();
8991
8992 state._fsp--;
8993
8994 pushFollow(FOLLOW_2);
8995 rule__PredicateSymbol__Group__5();
8996
8997 state._fsp--;
8998
8999
9000 }
9001
9002 }
9003 catch (RecognitionException re) {
9004 reportError(re);
9005 recover(input,re);
9006 }
9007 finally {
9008
9009 restoreStackSize(stackSize);
9010
9011 }
9012 return ;
9013 }
9014 // $ANTLR end "rule__PredicateSymbol__Group__4"
9015
9016
9017 // $ANTLR start "rule__PredicateSymbol__Group__4__Impl"
9018 // InternalSolverLanguage.g:2861:1: rule__PredicateSymbol__Group__4__Impl : ( ')' ) ;
9019 public final void rule__PredicateSymbol__Group__4__Impl() throws RecognitionException {
9020
9021 int stackSize = keepStackSize();
9022
9023 try {
9024 // InternalSolverLanguage.g:2865:1: ( ( ')' ) )
9025 // InternalSolverLanguage.g:2866:1: ( ')' )
9026 {
9027 // InternalSolverLanguage.g:2866:1: ( ')' )
9028 // InternalSolverLanguage.g:2867:2: ')'
9029 {
9030 before(grammarAccess.getPredicateSymbolAccess().getRightParenthesisKeyword_4());
9031 match(input,18,FOLLOW_2);
9032 after(grammarAccess.getPredicateSymbolAccess().getRightParenthesisKeyword_4());
9033
9034 }
9035
9036
9037 }
9038
9039 }
9040 catch (RecognitionException re) {
9041 reportError(re);
9042 recover(input,re);
9043 }
9044 finally {
9045
9046 restoreStackSize(stackSize);
9047
9048 }
9049 return ;
9050 }
9051 // $ANTLR end "rule__PredicateSymbol__Group__4__Impl"
9052
9053
9054 // $ANTLR start "rule__PredicateSymbol__Group__5"
9055 // InternalSolverLanguage.g:2876:1: rule__PredicateSymbol__Group__5 : rule__PredicateSymbol__Group__5__Impl rule__PredicateSymbol__Group__6 ;
9056 public final void rule__PredicateSymbol__Group__5() throws RecognitionException {
9057
9058 int stackSize = keepStackSize();
9059
9060 try {
9061 // InternalSolverLanguage.g:2880:1: ( rule__PredicateSymbol__Group__5__Impl rule__PredicateSymbol__Group__6 )
9062 // InternalSolverLanguage.g:2881:2: rule__PredicateSymbol__Group__5__Impl rule__PredicateSymbol__Group__6
9063 {
9064 pushFollow(FOLLOW_20);
9065 rule__PredicateSymbol__Group__5__Impl();
9066
9067 state._fsp--;
9068
9069 pushFollow(FOLLOW_2);
9070 rule__PredicateSymbol__Group__6();
9071
9072 state._fsp--;
9073
9074
9075 }
9076
9077 }
9078 catch (RecognitionException re) {
9079 reportError(re);
9080 recover(input,re);
9081 }
9082 finally {
9083
9084 restoreStackSize(stackSize);
9085
9086 }
9087 return ;
9088 }
9089 // $ANTLR end "rule__PredicateSymbol__Group__5"
9090
9091
9092 // $ANTLR start "rule__PredicateSymbol__Group__5__Impl"
9093 // InternalSolverLanguage.g:2888:1: rule__PredicateSymbol__Group__5__Impl : ( ':' ) ;
9094 public final void rule__PredicateSymbol__Group__5__Impl() throws RecognitionException {
9095
9096 int stackSize = keepStackSize();
9097
9098 try {
9099 // InternalSolverLanguage.g:2892:1: ( ( ':' ) )
9100 // InternalSolverLanguage.g:2893:1: ( ':' )
9101 {
9102 // InternalSolverLanguage.g:2893:1: ( ':' )
9103 // InternalSolverLanguage.g:2894:2: ':'
9104 {
9105 before(grammarAccess.getPredicateSymbolAccess().getColonKeyword_5());
9106 match(input,19,FOLLOW_2);
9107 after(grammarAccess.getPredicateSymbolAccess().getColonKeyword_5());
9108
9109 }
9110
9111
9112 }
9113
9114 }
9115 catch (RecognitionException re) {
9116 reportError(re);
9117 recover(input,re);
9118 }
9119 finally {
9120
9121 restoreStackSize(stackSize);
9122
9123 }
9124 return ;
9125 }
9126 // $ANTLR end "rule__PredicateSymbol__Group__5__Impl"
9127
9128
9129 // $ANTLR start "rule__PredicateSymbol__Group__6"
9130 // InternalSolverLanguage.g:2903:1: rule__PredicateSymbol__Group__6 : rule__PredicateSymbol__Group__6__Impl rule__PredicateSymbol__Group__7 ;
9131 public final void rule__PredicateSymbol__Group__6() throws RecognitionException {
9132
9133 int stackSize = keepStackSize();
9134
9135 try {
9136 // InternalSolverLanguage.g:2907:1: ( rule__PredicateSymbol__Group__6__Impl rule__PredicateSymbol__Group__7 )
9137 // InternalSolverLanguage.g:2908:2: rule__PredicateSymbol__Group__6__Impl rule__PredicateSymbol__Group__7
9138 {
9139 pushFollow(FOLLOW_6);
9140 rule__PredicateSymbol__Group__6__Impl();
9141
9142 state._fsp--;
9143
9144 pushFollow(FOLLOW_2);
9145 rule__PredicateSymbol__Group__7();
9146
9147 state._fsp--;
9148
9149
9150 }
9151
9152 }
9153 catch (RecognitionException re) {
9154 reportError(re);
9155 recover(input,re);
9156 }
9157 finally {
9158
9159 restoreStackSize(stackSize);
9160
9161 }
9162 return ;
9163 }
9164 // $ANTLR end "rule__PredicateSymbol__Group__6"
9165
9166
9167 // $ANTLR start "rule__PredicateSymbol__Group__6__Impl"
9168 // InternalSolverLanguage.g:2915:1: rule__PredicateSymbol__Group__6__Impl : ( ( rule__PredicateSymbol__Alternatives_6 ) ) ;
9169 public final void rule__PredicateSymbol__Group__6__Impl() throws RecognitionException {
9170
9171 int stackSize = keepStackSize();
9172
9173 try {
9174 // InternalSolverLanguage.g:2919:1: ( ( ( rule__PredicateSymbol__Alternatives_6 ) ) )
9175 // InternalSolverLanguage.g:2920:1: ( ( rule__PredicateSymbol__Alternatives_6 ) )
9176 {
9177 // InternalSolverLanguage.g:2920:1: ( ( rule__PredicateSymbol__Alternatives_6 ) )
9178 // InternalSolverLanguage.g:2921:2: ( rule__PredicateSymbol__Alternatives_6 )
9179 {
9180 before(grammarAccess.getPredicateSymbolAccess().getAlternatives_6());
9181 // InternalSolverLanguage.g:2922:2: ( rule__PredicateSymbol__Alternatives_6 )
9182 // InternalSolverLanguage.g:2922:3: rule__PredicateSymbol__Alternatives_6
9183 {
9184 pushFollow(FOLLOW_2);
9185 rule__PredicateSymbol__Alternatives_6();
9186
9187 state._fsp--;
9188
9189
9190 }
9191
9192 after(grammarAccess.getPredicateSymbolAccess().getAlternatives_6());
9193
9194 }
9195
9196
9197 }
9198
9199 }
9200 catch (RecognitionException re) {
9201 reportError(re);
9202 recover(input,re);
9203 }
9204 finally {
9205
9206 restoreStackSize(stackSize);
9207
9208 }
9209 return ;
9210 }
9211 // $ANTLR end "rule__PredicateSymbol__Group__6__Impl"
9212
9213
9214 // $ANTLR start "rule__PredicateSymbol__Group__7"
9215 // InternalSolverLanguage.g:2930:1: rule__PredicateSymbol__Group__7 : rule__PredicateSymbol__Group__7__Impl ;
9216 public final void rule__PredicateSymbol__Group__7() throws RecognitionException {
9217
9218 int stackSize = keepStackSize();
9219
9220 try {
9221 // InternalSolverLanguage.g:2934:1: ( rule__PredicateSymbol__Group__7__Impl )
9222 // InternalSolverLanguage.g:2935:2: rule__PredicateSymbol__Group__7__Impl
9223 {
9224 pushFollow(FOLLOW_2);
9225 rule__PredicateSymbol__Group__7__Impl();
9226
9227 state._fsp--;
9228
9229
9230 }
9231
9232 }
9233 catch (RecognitionException re) {
9234 reportError(re);
9235 recover(input,re);
9236 }
9237 finally {
9238
9239 restoreStackSize(stackSize);
9240
9241 }
9242 return ;
9243 }
9244 // $ANTLR end "rule__PredicateSymbol__Group__7"
9245
9246
9247 // $ANTLR start "rule__PredicateSymbol__Group__7__Impl"
9248 // InternalSolverLanguage.g:2941:1: rule__PredicateSymbol__Group__7__Impl : ( '.' ) ;
9249 public final void rule__PredicateSymbol__Group__7__Impl() throws RecognitionException {
9250
9251 int stackSize = keepStackSize();
9252
9253 try {
9254 // InternalSolverLanguage.g:2945:1: ( ( '.' ) )
9255 // InternalSolverLanguage.g:2946:1: ( '.' )
9256 {
9257 // InternalSolverLanguage.g:2946:1: ( '.' )
9258 // InternalSolverLanguage.g:2947:2: '.'
9259 {
9260 before(grammarAccess.getPredicateSymbolAccess().getFullStopKeyword_7());
9261 match(input,14,FOLLOW_2);
9262 after(grammarAccess.getPredicateSymbolAccess().getFullStopKeyword_7());
9263
9264 }
9265
9266
9267 }
9268
9269 }
9270 catch (RecognitionException re) {
9271 reportError(re);
9272 recover(input,re);
9273 }
9274 finally {
9275
9276 restoreStackSize(stackSize);
9277
9278 }
9279 return ;
9280 }
9281 // $ANTLR end "rule__PredicateSymbol__Group__7__Impl"
9282
9283
9284 // $ANTLR start "rule__PredicateSymbol__Group_6_1__0"
9285 // InternalSolverLanguage.g:2957:1: rule__PredicateSymbol__Group_6_1__0 : rule__PredicateSymbol__Group_6_1__0__Impl rule__PredicateSymbol__Group_6_1__1 ;
9286 public final void rule__PredicateSymbol__Group_6_1__0() throws RecognitionException {
9287
9288 int stackSize = keepStackSize();
9289
9290 try {
9291 // InternalSolverLanguage.g:2961:1: ( rule__PredicateSymbol__Group_6_1__0__Impl rule__PredicateSymbol__Group_6_1__1 )
9292 // InternalSolverLanguage.g:2962:2: rule__PredicateSymbol__Group_6_1__0__Impl rule__PredicateSymbol__Group_6_1__1
9293 {
9294 pushFollow(FOLLOW_21);
9295 rule__PredicateSymbol__Group_6_1__0__Impl();
9296
9297 state._fsp--;
9298
9299 pushFollow(FOLLOW_2);
9300 rule__PredicateSymbol__Group_6_1__1();
9301
9302 state._fsp--;
9303
9304
9305 }
9306
9307 }
9308 catch (RecognitionException re) {
9309 reportError(re);
9310 recover(input,re);
9311 }
9312 finally {
9313
9314 restoreStackSize(stackSize);
9315
9316 }
9317 return ;
9318 }
9319 // $ANTLR end "rule__PredicateSymbol__Group_6_1__0"
9320
9321
9322 // $ANTLR start "rule__PredicateSymbol__Group_6_1__0__Impl"
9323 // InternalSolverLanguage.g:2969:1: rule__PredicateSymbol__Group_6_1__0__Impl : ( ( rule__PredicateSymbol__BodiesAssignment_6_1_0 ) ) ;
9324 public final void rule__PredicateSymbol__Group_6_1__0__Impl() throws RecognitionException {
9325
9326 int stackSize = keepStackSize();
9327
9328 try {
9329 // InternalSolverLanguage.g:2973:1: ( ( ( rule__PredicateSymbol__BodiesAssignment_6_1_0 ) ) )
9330 // InternalSolverLanguage.g:2974:1: ( ( rule__PredicateSymbol__BodiesAssignment_6_1_0 ) )
9331 {
9332 // InternalSolverLanguage.g:2974:1: ( ( rule__PredicateSymbol__BodiesAssignment_6_1_0 ) )
9333 // InternalSolverLanguage.g:2975:2: ( rule__PredicateSymbol__BodiesAssignment_6_1_0 )
9334 {
9335 before(grammarAccess.getPredicateSymbolAccess().getBodiesAssignment_6_1_0());
9336 // InternalSolverLanguage.g:2976:2: ( rule__PredicateSymbol__BodiesAssignment_6_1_0 )
9337 // InternalSolverLanguage.g:2976:3: rule__PredicateSymbol__BodiesAssignment_6_1_0
9338 {
9339 pushFollow(FOLLOW_2);
9340 rule__PredicateSymbol__BodiesAssignment_6_1_0();
9341
9342 state._fsp--;
9343
9344
9345 }
9346
9347 after(grammarAccess.getPredicateSymbolAccess().getBodiesAssignment_6_1_0());
9348
9349 }
9350
9351
9352 }
9353
9354 }
9355 catch (RecognitionException re) {
9356 reportError(re);
9357 recover(input,re);
9358 }
9359 finally {
9360
9361 restoreStackSize(stackSize);
9362
9363 }
9364 return ;
9365 }
9366 // $ANTLR end "rule__PredicateSymbol__Group_6_1__0__Impl"
9367
9368
9369 // $ANTLR start "rule__PredicateSymbol__Group_6_1__1"
9370 // InternalSolverLanguage.g:2984:1: rule__PredicateSymbol__Group_6_1__1 : rule__PredicateSymbol__Group_6_1__1__Impl ;
9371 public final void rule__PredicateSymbol__Group_6_1__1() throws RecognitionException {
9372
9373 int stackSize = keepStackSize();
9374
9375 try {
9376 // InternalSolverLanguage.g:2988:1: ( rule__PredicateSymbol__Group_6_1__1__Impl )
9377 // InternalSolverLanguage.g:2989:2: rule__PredicateSymbol__Group_6_1__1__Impl
9378 {
9379 pushFollow(FOLLOW_2);
9380 rule__PredicateSymbol__Group_6_1__1__Impl();
9381
9382 state._fsp--;
9383
9384
9385 }
9386
9387 }
9388 catch (RecognitionException re) {
9389 reportError(re);
9390 recover(input,re);
9391 }
9392 finally {
9393
9394 restoreStackSize(stackSize);
9395
9396 }
9397 return ;
9398 }
9399 // $ANTLR end "rule__PredicateSymbol__Group_6_1__1"
9400
9401
9402 // $ANTLR start "rule__PredicateSymbol__Group_6_1__1__Impl"
9403 // InternalSolverLanguage.g:2995:1: rule__PredicateSymbol__Group_6_1__1__Impl : ( ( rule__PredicateSymbol__Group_6_1_1__0 )* ) ;
9404 public final void rule__PredicateSymbol__Group_6_1__1__Impl() throws RecognitionException {
9405
9406 int stackSize = keepStackSize();
9407
9408 try {
9409 // InternalSolverLanguage.g:2999:1: ( ( ( rule__PredicateSymbol__Group_6_1_1__0 )* ) )
9410 // InternalSolverLanguage.g:3000:1: ( ( rule__PredicateSymbol__Group_6_1_1__0 )* )
9411 {
9412 // InternalSolverLanguage.g:3000:1: ( ( rule__PredicateSymbol__Group_6_1_1__0 )* )
9413 // InternalSolverLanguage.g:3001:2: ( rule__PredicateSymbol__Group_6_1_1__0 )*
9414 {
9415 before(grammarAccess.getPredicateSymbolAccess().getGroup_6_1_1());
9416 // InternalSolverLanguage.g:3002:2: ( rule__PredicateSymbol__Group_6_1_1__0 )*
9417 loop27:
9418 do {
9419 int alt27=2;
9420 int LA27_0 = input.LA(1);
9421
9422 if ( (LA27_0==28) ) {
9423 alt27=1;
9424 }
9425
9426
9427 switch (alt27) {
9428 case 1 :
9429 // InternalSolverLanguage.g:3002:3: rule__PredicateSymbol__Group_6_1_1__0
9430 {
9431 pushFollow(FOLLOW_22);
9432 rule__PredicateSymbol__Group_6_1_1__0();
9433
9434 state._fsp--;
9435
9436
9437 }
9438 break;
9439
9440 default :
9441 break loop27;
9442 }
9443 } while (true);
9444
9445 after(grammarAccess.getPredicateSymbolAccess().getGroup_6_1_1());
9446
9447 }
9448
9449
9450 }
9451
9452 }
9453 catch (RecognitionException re) {
9454 reportError(re);
9455 recover(input,re);
9456 }
9457 finally {
9458
9459 restoreStackSize(stackSize);
9460
9461 }
9462 return ;
9463 }
9464 // $ANTLR end "rule__PredicateSymbol__Group_6_1__1__Impl"
9465
9466
9467 // $ANTLR start "rule__PredicateSymbol__Group_6_1_1__0"
9468 // InternalSolverLanguage.g:3011:1: rule__PredicateSymbol__Group_6_1_1__0 : rule__PredicateSymbol__Group_6_1_1__0__Impl rule__PredicateSymbol__Group_6_1_1__1 ;
9469 public final void rule__PredicateSymbol__Group_6_1_1__0() throws RecognitionException {
9470
9471 int stackSize = keepStackSize();
9472
9473 try {
9474 // InternalSolverLanguage.g:3015:1: ( rule__PredicateSymbol__Group_6_1_1__0__Impl rule__PredicateSymbol__Group_6_1_1__1 )
9475 // InternalSolverLanguage.g:3016:2: rule__PredicateSymbol__Group_6_1_1__0__Impl rule__PredicateSymbol__Group_6_1_1__1
9476 {
9477 pushFollow(FOLLOW_20);
9478 rule__PredicateSymbol__Group_6_1_1__0__Impl();
9479
9480 state._fsp--;
9481
9482 pushFollow(FOLLOW_2);
9483 rule__PredicateSymbol__Group_6_1_1__1();
9484
9485 state._fsp--;
9486
9487
9488 }
9489
9490 }
9491 catch (RecognitionException re) {
9492 reportError(re);
9493 recover(input,re);
9494 }
9495 finally {
9496
9497 restoreStackSize(stackSize);
9498
9499 }
9500 return ;
9501 }
9502 // $ANTLR end "rule__PredicateSymbol__Group_6_1_1__0"
9503
9504
9505 // $ANTLR start "rule__PredicateSymbol__Group_6_1_1__0__Impl"
9506 // InternalSolverLanguage.g:3023:1: rule__PredicateSymbol__Group_6_1_1__0__Impl : ( '|' ) ;
9507 public final void rule__PredicateSymbol__Group_6_1_1__0__Impl() throws RecognitionException {
9508
9509 int stackSize = keepStackSize();
9510
9511 try {
9512 // InternalSolverLanguage.g:3027:1: ( ( '|' ) )
9513 // InternalSolverLanguage.g:3028:1: ( '|' )
9514 {
9515 // InternalSolverLanguage.g:3028:1: ( '|' )
9516 // InternalSolverLanguage.g:3029:2: '|'
9517 {
9518 before(grammarAccess.getPredicateSymbolAccess().getVerticalLineKeyword_6_1_1_0());
9519 match(input,28,FOLLOW_2);
9520 after(grammarAccess.getPredicateSymbolAccess().getVerticalLineKeyword_6_1_1_0());
9521
9522 }
9523
9524
9525 }
9526
9527 }
9528 catch (RecognitionException re) {
9529 reportError(re);
9530 recover(input,re);
9531 }
9532 finally {
9533
9534 restoreStackSize(stackSize);
9535
9536 }
9537 return ;
9538 }
9539 // $ANTLR end "rule__PredicateSymbol__Group_6_1_1__0__Impl"
9540
9541
9542 // $ANTLR start "rule__PredicateSymbol__Group_6_1_1__1"
9543 // InternalSolverLanguage.g:3038:1: rule__PredicateSymbol__Group_6_1_1__1 : rule__PredicateSymbol__Group_6_1_1__1__Impl ;
9544 public final void rule__PredicateSymbol__Group_6_1_1__1() throws RecognitionException {
9545
9546 int stackSize = keepStackSize();
9547
9548 try {
9549 // InternalSolverLanguage.g:3042:1: ( rule__PredicateSymbol__Group_6_1_1__1__Impl )
9550 // InternalSolverLanguage.g:3043:2: rule__PredicateSymbol__Group_6_1_1__1__Impl
9551 {
9552 pushFollow(FOLLOW_2);
9553 rule__PredicateSymbol__Group_6_1_1__1__Impl();
9554
9555 state._fsp--;
9556
9557
9558 }
9559
9560 }
9561 catch (RecognitionException re) {
9562 reportError(re);
9563 recover(input,re);
9564 }
9565 finally {
9566
9567 restoreStackSize(stackSize);
9568
9569 }
9570 return ;
9571 }
9572 // $ANTLR end "rule__PredicateSymbol__Group_6_1_1__1"
9573
9574
9575 // $ANTLR start "rule__PredicateSymbol__Group_6_1_1__1__Impl"
9576 // InternalSolverLanguage.g:3049:1: rule__PredicateSymbol__Group_6_1_1__1__Impl : ( ( rule__PredicateSymbol__BodiesAssignment_6_1_1_1 ) ) ;
9577 public final void rule__PredicateSymbol__Group_6_1_1__1__Impl() throws RecognitionException {
9578
9579 int stackSize = keepStackSize();
9580
9581 try {
9582 // InternalSolverLanguage.g:3053:1: ( ( ( rule__PredicateSymbol__BodiesAssignment_6_1_1_1 ) ) )
9583 // InternalSolverLanguage.g:3054:1: ( ( rule__PredicateSymbol__BodiesAssignment_6_1_1_1 ) )
9584 {
9585 // InternalSolverLanguage.g:3054:1: ( ( rule__PredicateSymbol__BodiesAssignment_6_1_1_1 ) )
9586 // InternalSolverLanguage.g:3055:2: ( rule__PredicateSymbol__BodiesAssignment_6_1_1_1 )
9587 {
9588 before(grammarAccess.getPredicateSymbolAccess().getBodiesAssignment_6_1_1_1());
9589 // InternalSolverLanguage.g:3056:2: ( rule__PredicateSymbol__BodiesAssignment_6_1_1_1 )
9590 // InternalSolverLanguage.g:3056:3: rule__PredicateSymbol__BodiesAssignment_6_1_1_1
9591 {
9592 pushFollow(FOLLOW_2);
9593 rule__PredicateSymbol__BodiesAssignment_6_1_1_1();
9594
9595 state._fsp--;
9596
9597
9598 }
9599
9600 after(grammarAccess.getPredicateSymbolAccess().getBodiesAssignment_6_1_1_1());
9601
9602 }
9603
9604
9605 }
9606
9607 }
9608 catch (RecognitionException re) {
9609 reportError(re);
9610 recover(input,re);
9611 }
9612 finally {
9613
9614 restoreStackSize(stackSize);
9615
9616 }
9617 return ;
9618 }
9619 // $ANTLR end "rule__PredicateSymbol__Group_6_1_1__1__Impl"
9620
9621
9622 // $ANTLR start "rule__ErrorPredicate__Group__0"
9623 // InternalSolverLanguage.g:3065:1: rule__ErrorPredicate__Group__0 : rule__ErrorPredicate__Group__0__Impl rule__ErrorPredicate__Group__1 ;
9624 public final void rule__ErrorPredicate__Group__0() throws RecognitionException {
9625
9626 int stackSize = keepStackSize();
9627
9628 try {
9629 // InternalSolverLanguage.g:3069:1: ( rule__ErrorPredicate__Group__0__Impl rule__ErrorPredicate__Group__1 )
9630 // InternalSolverLanguage.g:3070:2: rule__ErrorPredicate__Group__0__Impl rule__ErrorPredicate__Group__1
9631 {
9632 pushFollow(FOLLOW_23);
9633 rule__ErrorPredicate__Group__0__Impl();
9634
9635 state._fsp--;
9636
9637 pushFollow(FOLLOW_2);
9638 rule__ErrorPredicate__Group__1();
9639
9640 state._fsp--;
9641
9642
9643 }
9644
9645 }
9646 catch (RecognitionException re) {
9647 reportError(re);
9648 recover(input,re);
9649 }
9650 finally {
9651
9652 restoreStackSize(stackSize);
9653
9654 }
9655 return ;
9656 }
9657 // $ANTLR end "rule__ErrorPredicate__Group__0"
9658
9659
9660 // $ANTLR start "rule__ErrorPredicate__Group__0__Impl"
9661 // InternalSolverLanguage.g:3077:1: rule__ErrorPredicate__Group__0__Impl : ( () ) ;
9662 public final void rule__ErrorPredicate__Group__0__Impl() throws RecognitionException {
9663
9664 int stackSize = keepStackSize();
9665
9666 try {
9667 // InternalSolverLanguage.g:3081:1: ( ( () ) )
9668 // InternalSolverLanguage.g:3082:1: ( () )
9669 {
9670 // InternalSolverLanguage.g:3082:1: ( () )
9671 // InternalSolverLanguage.g:3083:2: ()
9672 {
9673 before(grammarAccess.getErrorPredicateAccess().getErrorPredicateAction_0());
9674 // InternalSolverLanguage.g:3084:2: ()
9675 // InternalSolverLanguage.g:3084:3:
9676 {
9677 }
9678
9679 after(grammarAccess.getErrorPredicateAccess().getErrorPredicateAction_0());
9680
9681 }
9682
9683
9684 }
9685
9686 }
9687 finally {
9688
9689 restoreStackSize(stackSize);
9690
9691 }
9692 return ;
9693 }
9694 // $ANTLR end "rule__ErrorPredicate__Group__0__Impl"
9695
9696
9697 // $ANTLR start "rule__ErrorPredicate__Group__1"
9698 // InternalSolverLanguage.g:3092:1: rule__ErrorPredicate__Group__1 : rule__ErrorPredicate__Group__1__Impl rule__ErrorPredicate__Group__2 ;
9699 public final void rule__ErrorPredicate__Group__1() throws RecognitionException {
9700
9701 int stackSize = keepStackSize();
9702
9703 try {
9704 // InternalSolverLanguage.g:3096:1: ( rule__ErrorPredicate__Group__1__Impl rule__ErrorPredicate__Group__2 )
9705 // InternalSolverLanguage.g:3097:2: rule__ErrorPredicate__Group__1__Impl rule__ErrorPredicate__Group__2
9706 {
9707 pushFollow(FOLLOW_24);
9708 rule__ErrorPredicate__Group__1__Impl();
9709
9710 state._fsp--;
9711
9712 pushFollow(FOLLOW_2);
9713 rule__ErrorPredicate__Group__2();
9714
9715 state._fsp--;
9716
9717
9718 }
9719
9720 }
9721 catch (RecognitionException re) {
9722 reportError(re);
9723 recover(input,re);
9724 }
9725 finally {
9726
9727 restoreStackSize(stackSize);
9728
9729 }
9730 return ;
9731 }
9732 // $ANTLR end "rule__ErrorPredicate__Group__1"
9733
9734
9735 // $ANTLR start "rule__ErrorPredicate__Group__1__Impl"
9736 // InternalSolverLanguage.g:3104:1: rule__ErrorPredicate__Group__1__Impl : ( 'error' ) ;
9737 public final void rule__ErrorPredicate__Group__1__Impl() throws RecognitionException {
9738
9739 int stackSize = keepStackSize();
9740
9741 try {
9742 // InternalSolverLanguage.g:3108:1: ( ( 'error' ) )
9743 // InternalSolverLanguage.g:3109:1: ( 'error' )
9744 {
9745 // InternalSolverLanguage.g:3109:1: ( 'error' )
9746 // InternalSolverLanguage.g:3110:2: 'error'
9747 {
9748 before(grammarAccess.getErrorPredicateAccess().getErrorKeyword_1());
9749 match(input,16,FOLLOW_2);
9750 after(grammarAccess.getErrorPredicateAccess().getErrorKeyword_1());
9751
9752 }
9753
9754
9755 }
9756
9757 }
9758 catch (RecognitionException re) {
9759 reportError(re);
9760 recover(input,re);
9761 }
9762 finally {
9763
9764 restoreStackSize(stackSize);
9765
9766 }
9767 return ;
9768 }
9769 // $ANTLR end "rule__ErrorPredicate__Group__1__Impl"
9770
9771
9772 // $ANTLR start "rule__ErrorPredicate__Group__2"
9773 // InternalSolverLanguage.g:3119:1: rule__ErrorPredicate__Group__2 : rule__ErrorPredicate__Group__2__Impl rule__ErrorPredicate__Group__3 ;
9774 public final void rule__ErrorPredicate__Group__2() throws RecognitionException {
9775
9776 int stackSize = keepStackSize();
9777
9778 try {
9779 // InternalSolverLanguage.g:3123:1: ( rule__ErrorPredicate__Group__2__Impl rule__ErrorPredicate__Group__3 )
9780 // InternalSolverLanguage.g:3124:2: rule__ErrorPredicate__Group__2__Impl rule__ErrorPredicate__Group__3
9781 {
9782 pushFollow(FOLLOW_24);
9783 rule__ErrorPredicate__Group__2__Impl();
9784
9785 state._fsp--;
9786
9787 pushFollow(FOLLOW_2);
9788 rule__ErrorPredicate__Group__3();
9789
9790 state._fsp--;
9791
9792
9793 }
9794
9795 }
9796 catch (RecognitionException re) {
9797 reportError(re);
9798 recover(input,re);
9799 }
9800 finally {
9801
9802 restoreStackSize(stackSize);
9803
9804 }
9805 return ;
9806 }
9807 // $ANTLR end "rule__ErrorPredicate__Group__2"
9808
9809
9810 // $ANTLR start "rule__ErrorPredicate__Group__2__Impl"
9811 // InternalSolverLanguage.g:3131:1: rule__ErrorPredicate__Group__2__Impl : ( ( rule__ErrorPredicate__NameAssignment_2 )? ) ;
9812 public final void rule__ErrorPredicate__Group__2__Impl() throws RecognitionException {
9813
9814 int stackSize = keepStackSize();
9815
9816 try {
9817 // InternalSolverLanguage.g:3135:1: ( ( ( rule__ErrorPredicate__NameAssignment_2 )? ) )
9818 // InternalSolverLanguage.g:3136:1: ( ( rule__ErrorPredicate__NameAssignment_2 )? )
9819 {
9820 // InternalSolverLanguage.g:3136:1: ( ( rule__ErrorPredicate__NameAssignment_2 )? )
9821 // InternalSolverLanguage.g:3137:2: ( rule__ErrorPredicate__NameAssignment_2 )?
9822 {
9823 before(grammarAccess.getErrorPredicateAccess().getNameAssignment_2());
9824 // InternalSolverLanguage.g:3138:2: ( rule__ErrorPredicate__NameAssignment_2 )?
9825 int alt28=2;
9826 int LA28_0 = input.LA(1);
9827
9828 if ( (LA28_0==RULE_ID) ) {
9829 alt28=1;
9830 }
9831 switch (alt28) {
9832 case 1 :
9833 // InternalSolverLanguage.g:3138:3: rule__ErrorPredicate__NameAssignment_2
9834 {
9835 pushFollow(FOLLOW_2);
9836 rule__ErrorPredicate__NameAssignment_2();
9837
9838 state._fsp--;
9839
9840
9841 }
9842 break;
9843
9844 }
9845
9846 after(grammarAccess.getErrorPredicateAccess().getNameAssignment_2());
9847
9848 }
9849
9850
9851 }
9852
9853 }
9854 catch (RecognitionException re) {
9855 reportError(re);
9856 recover(input,re);
9857 }
9858 finally {
9859
9860 restoreStackSize(stackSize);
9861
9862 }
9863 return ;
9864 }
9865 // $ANTLR end "rule__ErrorPredicate__Group__2__Impl"
9866
9867
9868 // $ANTLR start "rule__ErrorPredicate__Group__3"
9869 // InternalSolverLanguage.g:3146:1: rule__ErrorPredicate__Group__3 : rule__ErrorPredicate__Group__3__Impl rule__ErrorPredicate__Group__4 ;
9870 public final void rule__ErrorPredicate__Group__3() throws RecognitionException {
9871
9872 int stackSize = keepStackSize();
9873
9874 try {
9875 // InternalSolverLanguage.g:3150:1: ( rule__ErrorPredicate__Group__3__Impl rule__ErrorPredicate__Group__4 )
9876 // InternalSolverLanguage.g:3151:2: rule__ErrorPredicate__Group__3__Impl rule__ErrorPredicate__Group__4
9877 {
9878 pushFollow(FOLLOW_14);
9879 rule__ErrorPredicate__Group__3__Impl();
9880
9881 state._fsp--;
9882
9883 pushFollow(FOLLOW_2);
9884 rule__ErrorPredicate__Group__4();
9885
9886 state._fsp--;
9887
9888
9889 }
9890
9891 }
9892 catch (RecognitionException re) {
9893 reportError(re);
9894 recover(input,re);
9895 }
9896 finally {
9897
9898 restoreStackSize(stackSize);
9899
9900 }
9901 return ;
9902 }
9903 // $ANTLR end "rule__ErrorPredicate__Group__3"
9904
9905
9906 // $ANTLR start "rule__ErrorPredicate__Group__3__Impl"
9907 // InternalSolverLanguage.g:3158:1: rule__ErrorPredicate__Group__3__Impl : ( ( rule__ErrorPredicate__Group_3__0 ) ) ;
9908 public final void rule__ErrorPredicate__Group__3__Impl() throws RecognitionException {
9909
9910 int stackSize = keepStackSize();
9911
9912 try {
9913 // InternalSolverLanguage.g:3162:1: ( ( ( rule__ErrorPredicate__Group_3__0 ) ) )
9914 // InternalSolverLanguage.g:3163:1: ( ( rule__ErrorPredicate__Group_3__0 ) )
9915 {
9916 // InternalSolverLanguage.g:3163:1: ( ( rule__ErrorPredicate__Group_3__0 ) )
9917 // InternalSolverLanguage.g:3164:2: ( rule__ErrorPredicate__Group_3__0 )
9918 {
9919 before(grammarAccess.getErrorPredicateAccess().getGroup_3());
9920 // InternalSolverLanguage.g:3165:2: ( rule__ErrorPredicate__Group_3__0 )
9921 // InternalSolverLanguage.g:3165:3: rule__ErrorPredicate__Group_3__0
9922 {
9923 pushFollow(FOLLOW_2);
9924 rule__ErrorPredicate__Group_3__0();
9925
9926 state._fsp--;
9927
9928
9929 }
9930
9931 after(grammarAccess.getErrorPredicateAccess().getGroup_3());
9932
9933 }
9934
9935
9936 }
9937
9938 }
9939 catch (RecognitionException re) {
9940 reportError(re);
9941 recover(input,re);
9942 }
9943 finally {
9944
9945 restoreStackSize(stackSize);
9946
9947 }
9948 return ;
9949 }
9950 // $ANTLR end "rule__ErrorPredicate__Group__3__Impl"
9951
9952
9953 // $ANTLR start "rule__ErrorPredicate__Group__4"
9954 // InternalSolverLanguage.g:3173:1: rule__ErrorPredicate__Group__4 : rule__ErrorPredicate__Group__4__Impl rule__ErrorPredicate__Group__5 ;
9955 public final void rule__ErrorPredicate__Group__4() throws RecognitionException {
9956
9957 int stackSize = keepStackSize();
9958
9959 try {
9960 // InternalSolverLanguage.g:3177:1: ( rule__ErrorPredicate__Group__4__Impl rule__ErrorPredicate__Group__5 )
9961 // InternalSolverLanguage.g:3178:2: rule__ErrorPredicate__Group__4__Impl rule__ErrorPredicate__Group__5
9962 {
9963 pushFollow(FOLLOW_20);
9964 rule__ErrorPredicate__Group__4__Impl();
9965
9966 state._fsp--;
9967
9968 pushFollow(FOLLOW_2);
9969 rule__ErrorPredicate__Group__5();
9970
9971 state._fsp--;
9972
9973
9974 }
9975
9976 }
9977 catch (RecognitionException re) {
9978 reportError(re);
9979 recover(input,re);
9980 }
9981 finally {
9982
9983 restoreStackSize(stackSize);
9984
9985 }
9986 return ;
9987 }
9988 // $ANTLR end "rule__ErrorPredicate__Group__4"
9989
9990
9991 // $ANTLR start "rule__ErrorPredicate__Group__4__Impl"
9992 // InternalSolverLanguage.g:3185:1: rule__ErrorPredicate__Group__4__Impl : ( ':' ) ;
9993 public final void rule__ErrorPredicate__Group__4__Impl() throws RecognitionException {
9994
9995 int stackSize = keepStackSize();
9996
9997 try {
9998 // InternalSolverLanguage.g:3189:1: ( ( ':' ) )
9999 // InternalSolverLanguage.g:3190:1: ( ':' )
10000 {
10001 // InternalSolverLanguage.g:3190:1: ( ':' )
10002 // InternalSolverLanguage.g:3191:2: ':'
10003 {
10004 before(grammarAccess.getErrorPredicateAccess().getColonKeyword_4());
10005 match(input,19,FOLLOW_2);
10006 after(grammarAccess.getErrorPredicateAccess().getColonKeyword_4());
10007
10008 }
10009
10010
10011 }
10012
10013 }
10014 catch (RecognitionException re) {
10015 reportError(re);
10016 recover(input,re);
10017 }
10018 finally {
10019
10020 restoreStackSize(stackSize);
10021
10022 }
10023 return ;
10024 }
10025 // $ANTLR end "rule__ErrorPredicate__Group__4__Impl"
10026
10027
10028 // $ANTLR start "rule__ErrorPredicate__Group__5"
10029 // InternalSolverLanguage.g:3200:1: rule__ErrorPredicate__Group__5 : rule__ErrorPredicate__Group__5__Impl rule__ErrorPredicate__Group__6 ;
10030 public final void rule__ErrorPredicate__Group__5() throws RecognitionException {
10031
10032 int stackSize = keepStackSize();
10033
10034 try {
10035 // InternalSolverLanguage.g:3204:1: ( rule__ErrorPredicate__Group__5__Impl rule__ErrorPredicate__Group__6 )
10036 // InternalSolverLanguage.g:3205:2: rule__ErrorPredicate__Group__5__Impl rule__ErrorPredicate__Group__6
10037 {
10038 pushFollow(FOLLOW_6);
10039 rule__ErrorPredicate__Group__5__Impl();
10040
10041 state._fsp--;
10042
10043 pushFollow(FOLLOW_2);
10044 rule__ErrorPredicate__Group__6();
10045
10046 state._fsp--;
10047
10048
10049 }
10050
10051 }
10052 catch (RecognitionException re) {
10053 reportError(re);
10054 recover(input,re);
10055 }
10056 finally {
10057
10058 restoreStackSize(stackSize);
10059
10060 }
10061 return ;
10062 }
10063 // $ANTLR end "rule__ErrorPredicate__Group__5"
10064
10065
10066 // $ANTLR start "rule__ErrorPredicate__Group__5__Impl"
10067 // InternalSolverLanguage.g:3212:1: rule__ErrorPredicate__Group__5__Impl : ( ( rule__ErrorPredicate__Alternatives_5 ) ) ;
10068 public final void rule__ErrorPredicate__Group__5__Impl() throws RecognitionException {
10069
10070 int stackSize = keepStackSize();
10071
10072 try {
10073 // InternalSolverLanguage.g:3216:1: ( ( ( rule__ErrorPredicate__Alternatives_5 ) ) )
10074 // InternalSolverLanguage.g:3217:1: ( ( rule__ErrorPredicate__Alternatives_5 ) )
10075 {
10076 // InternalSolverLanguage.g:3217:1: ( ( rule__ErrorPredicate__Alternatives_5 ) )
10077 // InternalSolverLanguage.g:3218:2: ( rule__ErrorPredicate__Alternatives_5 )
10078 {
10079 before(grammarAccess.getErrorPredicateAccess().getAlternatives_5());
10080 // InternalSolverLanguage.g:3219:2: ( rule__ErrorPredicate__Alternatives_5 )
10081 // InternalSolverLanguage.g:3219:3: rule__ErrorPredicate__Alternatives_5
10082 {
10083 pushFollow(FOLLOW_2);
10084 rule__ErrorPredicate__Alternatives_5();
10085
10086 state._fsp--;
10087
10088
10089 }
10090
10091 after(grammarAccess.getErrorPredicateAccess().getAlternatives_5());
10092
10093 }
10094
10095
10096 }
10097
10098 }
10099 catch (RecognitionException re) {
10100 reportError(re);
10101 recover(input,re);
10102 }
10103 finally {
10104
10105 restoreStackSize(stackSize);
10106
10107 }
10108 return ;
10109 }
10110 // $ANTLR end "rule__ErrorPredicate__Group__5__Impl"
10111
10112
10113 // $ANTLR start "rule__ErrorPredicate__Group__6"
10114 // InternalSolverLanguage.g:3227:1: rule__ErrorPredicate__Group__6 : rule__ErrorPredicate__Group__6__Impl ;
10115 public final void rule__ErrorPredicate__Group__6() throws RecognitionException {
10116
10117 int stackSize = keepStackSize();
10118
10119 try {
10120 // InternalSolverLanguage.g:3231:1: ( rule__ErrorPredicate__Group__6__Impl )
10121 // InternalSolverLanguage.g:3232:2: rule__ErrorPredicate__Group__6__Impl
10122 {
10123 pushFollow(FOLLOW_2);
10124 rule__ErrorPredicate__Group__6__Impl();
10125
10126 state._fsp--;
10127
10128
10129 }
10130
10131 }
10132 catch (RecognitionException re) {
10133 reportError(re);
10134 recover(input,re);
10135 }
10136 finally {
10137
10138 restoreStackSize(stackSize);
10139
10140 }
10141 return ;
10142 }
10143 // $ANTLR end "rule__ErrorPredicate__Group__6"
10144
10145
10146 // $ANTLR start "rule__ErrorPredicate__Group__6__Impl"
10147 // InternalSolverLanguage.g:3238:1: rule__ErrorPredicate__Group__6__Impl : ( '.' ) ;
10148 public final void rule__ErrorPredicate__Group__6__Impl() throws RecognitionException {
10149
10150 int stackSize = keepStackSize();
10151
10152 try {
10153 // InternalSolverLanguage.g:3242:1: ( ( '.' ) )
10154 // InternalSolverLanguage.g:3243:1: ( '.' )
10155 {
10156 // InternalSolverLanguage.g:3243:1: ( '.' )
10157 // InternalSolverLanguage.g:3244:2: '.'
10158 {
10159 before(grammarAccess.getErrorPredicateAccess().getFullStopKeyword_6());
10160 match(input,14,FOLLOW_2);
10161 after(grammarAccess.getErrorPredicateAccess().getFullStopKeyword_6());
10162
10163 }
10164
10165
10166 }
10167
10168 }
10169 catch (RecognitionException re) {
10170 reportError(re);
10171 recover(input,re);
10172 }
10173 finally {
10174
10175 restoreStackSize(stackSize);
10176
10177 }
10178 return ;
10179 }
10180 // $ANTLR end "rule__ErrorPredicate__Group__6__Impl"
10181
10182
10183 // $ANTLR start "rule__ErrorPredicate__Group_3__0"
10184 // InternalSolverLanguage.g:3254:1: rule__ErrorPredicate__Group_3__0 : rule__ErrorPredicate__Group_3__0__Impl rule__ErrorPredicate__Group_3__1 ;
10185 public final void rule__ErrorPredicate__Group_3__0() throws RecognitionException {
10186
10187 int stackSize = keepStackSize();
10188
10189 try {
10190 // InternalSolverLanguage.g:3258:1: ( rule__ErrorPredicate__Group_3__0__Impl rule__ErrorPredicate__Group_3__1 )
10191 // InternalSolverLanguage.g:3259:2: rule__ErrorPredicate__Group_3__0__Impl rule__ErrorPredicate__Group_3__1
10192 {
10193 pushFollow(FOLLOW_18);
10194 rule__ErrorPredicate__Group_3__0__Impl();
10195
10196 state._fsp--;
10197
10198 pushFollow(FOLLOW_2);
10199 rule__ErrorPredicate__Group_3__1();
10200
10201 state._fsp--;
10202
10203
10204 }
10205
10206 }
10207 catch (RecognitionException re) {
10208 reportError(re);
10209 recover(input,re);
10210 }
10211 finally {
10212
10213 restoreStackSize(stackSize);
10214
10215 }
10216 return ;
10217 }
10218 // $ANTLR end "rule__ErrorPredicate__Group_3__0"
10219
10220
10221 // $ANTLR start "rule__ErrorPredicate__Group_3__0__Impl"
10222 // InternalSolverLanguage.g:3266:1: rule__ErrorPredicate__Group_3__0__Impl : ( '(' ) ;
10223 public final void rule__ErrorPredicate__Group_3__0__Impl() throws RecognitionException {
10224
10225 int stackSize = keepStackSize();
10226
10227 try {
10228 // InternalSolverLanguage.g:3270:1: ( ( '(' ) )
10229 // InternalSolverLanguage.g:3271:1: ( '(' )
10230 {
10231 // InternalSolverLanguage.g:3271:1: ( '(' )
10232 // InternalSolverLanguage.g:3272:2: '('
10233 {
10234 before(grammarAccess.getErrorPredicateAccess().getLeftParenthesisKeyword_3_0());
10235 match(input,17,FOLLOW_2);
10236 after(grammarAccess.getErrorPredicateAccess().getLeftParenthesisKeyword_3_0());
10237
10238 }
10239
10240
10241 }
10242
10243 }
10244 catch (RecognitionException re) {
10245 reportError(re);
10246 recover(input,re);
10247 }
10248 finally {
10249
10250 restoreStackSize(stackSize);
10251
10252 }
10253 return ;
10254 }
10255 // $ANTLR end "rule__ErrorPredicate__Group_3__0__Impl"
10256
10257
10258 // $ANTLR start "rule__ErrorPredicate__Group_3__1"
10259 // InternalSolverLanguage.g:3281:1: rule__ErrorPredicate__Group_3__1 : rule__ErrorPredicate__Group_3__1__Impl rule__ErrorPredicate__Group_3__2 ;
10260 public final void rule__ErrorPredicate__Group_3__1() throws RecognitionException {
10261
10262 int stackSize = keepStackSize();
10263
10264 try {
10265 // InternalSolverLanguage.g:3285:1: ( rule__ErrorPredicate__Group_3__1__Impl rule__ErrorPredicate__Group_3__2 )
10266 // InternalSolverLanguage.g:3286:2: rule__ErrorPredicate__Group_3__1__Impl rule__ErrorPredicate__Group_3__2
10267 {
10268 pushFollow(FOLLOW_18);
10269 rule__ErrorPredicate__Group_3__1__Impl();
10270
10271 state._fsp--;
10272
10273 pushFollow(FOLLOW_2);
10274 rule__ErrorPredicate__Group_3__2();
10275
10276 state._fsp--;
10277
10278
10279 }
10280
10281 }
10282 catch (RecognitionException re) {
10283 reportError(re);
10284 recover(input,re);
10285 }
10286 finally {
10287
10288 restoreStackSize(stackSize);
10289
10290 }
10291 return ;
10292 }
10293 // $ANTLR end "rule__ErrorPredicate__Group_3__1"
10294
10295
10296 // $ANTLR start "rule__ErrorPredicate__Group_3__1__Impl"
10297 // InternalSolverLanguage.g:3293:1: rule__ErrorPredicate__Group_3__1__Impl : ( ( rule__ErrorPredicate__ParametersAssignment_3_1 )* ) ;
10298 public final void rule__ErrorPredicate__Group_3__1__Impl() throws RecognitionException {
10299
10300 int stackSize = keepStackSize();
10301
10302 try {
10303 // InternalSolverLanguage.g:3297:1: ( ( ( rule__ErrorPredicate__ParametersAssignment_3_1 )* ) )
10304 // InternalSolverLanguage.g:3298:1: ( ( rule__ErrorPredicate__ParametersAssignment_3_1 )* )
10305 {
10306 // InternalSolverLanguage.g:3298:1: ( ( rule__ErrorPredicate__ParametersAssignment_3_1 )* )
10307 // InternalSolverLanguage.g:3299:2: ( rule__ErrorPredicate__ParametersAssignment_3_1 )*
10308 {
10309 before(grammarAccess.getErrorPredicateAccess().getParametersAssignment_3_1());
10310 // InternalSolverLanguage.g:3300:2: ( rule__ErrorPredicate__ParametersAssignment_3_1 )*
10311 loop29:
10312 do {
10313 int alt29=2;
10314 int LA29_0 = input.LA(1);
10315
10316 if ( (LA29_0==RULE_ID) ) {
10317 alt29=1;
10318 }
10319
10320
10321 switch (alt29) {
10322 case 1 :
10323 // InternalSolverLanguage.g:3300:3: rule__ErrorPredicate__ParametersAssignment_3_1
10324 {
10325 pushFollow(FOLLOW_19);
10326 rule__ErrorPredicate__ParametersAssignment_3_1();
10327
10328 state._fsp--;
10329
10330
10331 }
10332 break;
10333
10334 default :
10335 break loop29;
10336 }
10337 } while (true);
10338
10339 after(grammarAccess.getErrorPredicateAccess().getParametersAssignment_3_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__ErrorPredicate__Group_3__1__Impl"
10359
10360
10361 // $ANTLR start "rule__ErrorPredicate__Group_3__2"
10362 // InternalSolverLanguage.g:3308:1: rule__ErrorPredicate__Group_3__2 : rule__ErrorPredicate__Group_3__2__Impl ;
10363 public final void rule__ErrorPredicate__Group_3__2() throws RecognitionException {
10364
10365 int stackSize = keepStackSize();
10366
10367 try {
10368 // InternalSolverLanguage.g:3312:1: ( rule__ErrorPredicate__Group_3__2__Impl )
10369 // InternalSolverLanguage.g:3313:2: rule__ErrorPredicate__Group_3__2__Impl
10370 {
10371 pushFollow(FOLLOW_2);
10372 rule__ErrorPredicate__Group_3__2__Impl();
10373
10374 state._fsp--;
10375
10376
10377 }
10378
10379 }
10380 catch (RecognitionException re) {
10381 reportError(re);
10382 recover(input,re);
10383 }
10384 finally {
10385
10386 restoreStackSize(stackSize);
10387
10388 }
10389 return ;
10390 }
10391 // $ANTLR end "rule__ErrorPredicate__Group_3__2"
10392
10393
10394 // $ANTLR start "rule__ErrorPredicate__Group_3__2__Impl"
10395 // InternalSolverLanguage.g:3319:1: rule__ErrorPredicate__Group_3__2__Impl : ( ')' ) ;
10396 public final void rule__ErrorPredicate__Group_3__2__Impl() throws RecognitionException {
10397
10398 int stackSize = keepStackSize();
10399
10400 try {
10401 // InternalSolverLanguage.g:3323:1: ( ( ')' ) )
10402 // InternalSolverLanguage.g:3324:1: ( ')' )
10403 {
10404 // InternalSolverLanguage.g:3324:1: ( ')' )
10405 // InternalSolverLanguage.g:3325:2: ')'
10406 {
10407 before(grammarAccess.getErrorPredicateAccess().getRightParenthesisKeyword_3_2());
10408 match(input,18,FOLLOW_2);
10409 after(grammarAccess.getErrorPredicateAccess().getRightParenthesisKeyword_3_2());
10410
10411 }
10412
10413
10414 }
10415
10416 }
10417 catch (RecognitionException re) {
10418 reportError(re);
10419 recover(input,re);
10420 }
10421 finally {
10422
10423 restoreStackSize(stackSize);
10424
10425 }
10426 return ;
10427 }
10428 // $ANTLR end "rule__ErrorPredicate__Group_3__2__Impl"
10429
10430
10431 // $ANTLR start "rule__ErrorPredicate__Group_5_1__0"
10432 // InternalSolverLanguage.g:3335:1: rule__ErrorPredicate__Group_5_1__0 : rule__ErrorPredicate__Group_5_1__0__Impl rule__ErrorPredicate__Group_5_1__1 ;
10433 public final void rule__ErrorPredicate__Group_5_1__0() throws RecognitionException {
10434
10435 int stackSize = keepStackSize();
10436
10437 try {
10438 // InternalSolverLanguage.g:3339:1: ( rule__ErrorPredicate__Group_5_1__0__Impl rule__ErrorPredicate__Group_5_1__1 )
10439 // InternalSolverLanguage.g:3340:2: rule__ErrorPredicate__Group_5_1__0__Impl rule__ErrorPredicate__Group_5_1__1
10440 {
10441 pushFollow(FOLLOW_21);
10442 rule__ErrorPredicate__Group_5_1__0__Impl();
10443
10444 state._fsp--;
10445
10446 pushFollow(FOLLOW_2);
10447 rule__ErrorPredicate__Group_5_1__1();
10448
10449 state._fsp--;
10450
10451
10452 }
10453
10454 }
10455 catch (RecognitionException re) {
10456 reportError(re);
10457 recover(input,re);
10458 }
10459 finally {
10460
10461 restoreStackSize(stackSize);
10462
10463 }
10464 return ;
10465 }
10466 // $ANTLR end "rule__ErrorPredicate__Group_5_1__0"
10467
10468
10469 // $ANTLR start "rule__ErrorPredicate__Group_5_1__0__Impl"
10470 // InternalSolverLanguage.g:3347:1: rule__ErrorPredicate__Group_5_1__0__Impl : ( ( rule__ErrorPredicate__BodiesAssignment_5_1_0 ) ) ;
10471 public final void rule__ErrorPredicate__Group_5_1__0__Impl() throws RecognitionException {
10472
10473 int stackSize = keepStackSize();
10474
10475 try {
10476 // InternalSolverLanguage.g:3351:1: ( ( ( rule__ErrorPredicate__BodiesAssignment_5_1_0 ) ) )
10477 // InternalSolverLanguage.g:3352:1: ( ( rule__ErrorPredicate__BodiesAssignment_5_1_0 ) )
10478 {
10479 // InternalSolverLanguage.g:3352:1: ( ( rule__ErrorPredicate__BodiesAssignment_5_1_0 ) )
10480 // InternalSolverLanguage.g:3353:2: ( rule__ErrorPredicate__BodiesAssignment_5_1_0 )
10481 {
10482 before(grammarAccess.getErrorPredicateAccess().getBodiesAssignment_5_1_0());
10483 // InternalSolverLanguage.g:3354:2: ( rule__ErrorPredicate__BodiesAssignment_5_1_0 )
10484 // InternalSolverLanguage.g:3354:3: rule__ErrorPredicate__BodiesAssignment_5_1_0
10485 {
10486 pushFollow(FOLLOW_2);
10487 rule__ErrorPredicate__BodiesAssignment_5_1_0();
10488
10489 state._fsp--;
10490
10491
10492 }
10493
10494 after(grammarAccess.getErrorPredicateAccess().getBodiesAssignment_5_1_0());
10495
10496 }
10497
10498
10499 }
10500
10501 }
10502 catch (RecognitionException re) {
10503 reportError(re);
10504 recover(input,re);
10505 }
10506 finally {
10507
10508 restoreStackSize(stackSize);
10509
10510 }
10511 return ;
10512 }
10513 // $ANTLR end "rule__ErrorPredicate__Group_5_1__0__Impl"
10514
10515
10516 // $ANTLR start "rule__ErrorPredicate__Group_5_1__1"
10517 // InternalSolverLanguage.g:3362:1: rule__ErrorPredicate__Group_5_1__1 : rule__ErrorPredicate__Group_5_1__1__Impl ;
10518 public final void rule__ErrorPredicate__Group_5_1__1() throws RecognitionException {
10519
10520 int stackSize = keepStackSize();
10521
10522 try {
10523 // InternalSolverLanguage.g:3366:1: ( rule__ErrorPredicate__Group_5_1__1__Impl )
10524 // InternalSolverLanguage.g:3367:2: rule__ErrorPredicate__Group_5_1__1__Impl
10525 {
10526 pushFollow(FOLLOW_2);
10527 rule__ErrorPredicate__Group_5_1__1__Impl();
10528
10529 state._fsp--;
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__ErrorPredicate__Group_5_1__1"
10547
10548
10549 // $ANTLR start "rule__ErrorPredicate__Group_5_1__1__Impl"
10550 // InternalSolverLanguage.g:3373:1: rule__ErrorPredicate__Group_5_1__1__Impl : ( ( rule__ErrorPredicate__Group_5_1_1__0 )* ) ;
10551 public final void rule__ErrorPredicate__Group_5_1__1__Impl() throws RecognitionException {
10552
10553 int stackSize = keepStackSize();
10554
10555 try {
10556 // InternalSolverLanguage.g:3377:1: ( ( ( rule__ErrorPredicate__Group_5_1_1__0 )* ) )
10557 // InternalSolverLanguage.g:3378:1: ( ( rule__ErrorPredicate__Group_5_1_1__0 )* )
10558 {
10559 // InternalSolverLanguage.g:3378:1: ( ( rule__ErrorPredicate__Group_5_1_1__0 )* )
10560 // InternalSolverLanguage.g:3379:2: ( rule__ErrorPredicate__Group_5_1_1__0 )*
10561 {
10562 before(grammarAccess.getErrorPredicateAccess().getGroup_5_1_1());
10563 // InternalSolverLanguage.g:3380:2: ( rule__ErrorPredicate__Group_5_1_1__0 )*
10564 loop30:
10565 do {
10566 int alt30=2;
10567 int LA30_0 = input.LA(1);
10568
10569 if ( (LA30_0==28) ) {
10570 alt30=1;
10571 }
10572
10573
10574 switch (alt30) {
10575 case 1 :
10576 // InternalSolverLanguage.g:3380:3: rule__ErrorPredicate__Group_5_1_1__0
10577 {
10578 pushFollow(FOLLOW_22);
10579 rule__ErrorPredicate__Group_5_1_1__0();
10580
10581 state._fsp--;
10582
10583
10584 }
10585 break;
10586
10587 default :
10588 break loop30;
10589 }
10590 } while (true);
10591
10592 after(grammarAccess.getErrorPredicateAccess().getGroup_5_1_1());
10593
10594 }
10595
10596
10597 }
10598
10599 }
10600 catch (RecognitionException re) {
10601 reportError(re);
10602 recover(input,re);
10603 }
10604 finally {
10605
10606 restoreStackSize(stackSize);
10607
10608 }
10609 return ;
10610 }
10611 // $ANTLR end "rule__ErrorPredicate__Group_5_1__1__Impl"
10612
10613
10614 // $ANTLR start "rule__ErrorPredicate__Group_5_1_1__0"
10615 // InternalSolverLanguage.g:3389:1: rule__ErrorPredicate__Group_5_1_1__0 : rule__ErrorPredicate__Group_5_1_1__0__Impl rule__ErrorPredicate__Group_5_1_1__1 ;
10616 public final void rule__ErrorPredicate__Group_5_1_1__0() throws RecognitionException {
10617
10618 int stackSize = keepStackSize();
10619
10620 try {
10621 // InternalSolverLanguage.g:3393:1: ( rule__ErrorPredicate__Group_5_1_1__0__Impl rule__ErrorPredicate__Group_5_1_1__1 )
10622 // InternalSolverLanguage.g:3394:2: rule__ErrorPredicate__Group_5_1_1__0__Impl rule__ErrorPredicate__Group_5_1_1__1
10623 {
10624 pushFollow(FOLLOW_20);
10625 rule__ErrorPredicate__Group_5_1_1__0__Impl();
10626
10627 state._fsp--;
10628
10629 pushFollow(FOLLOW_2);
10630 rule__ErrorPredicate__Group_5_1_1__1();
10631
10632 state._fsp--;
10633
10634
10635 }
10636
10637 }
10638 catch (RecognitionException re) {
10639 reportError(re);
10640 recover(input,re);
10641 }
10642 finally {
10643
10644 restoreStackSize(stackSize);
10645
10646 }
10647 return ;
10648 }
10649 // $ANTLR end "rule__ErrorPredicate__Group_5_1_1__0"
10650
10651
10652 // $ANTLR start "rule__ErrorPredicate__Group_5_1_1__0__Impl"
10653 // InternalSolverLanguage.g:3401:1: rule__ErrorPredicate__Group_5_1_1__0__Impl : ( '|' ) ;
10654 public final void rule__ErrorPredicate__Group_5_1_1__0__Impl() throws RecognitionException {
10655
10656 int stackSize = keepStackSize();
10657
10658 try {
10659 // InternalSolverLanguage.g:3405:1: ( ( '|' ) )
10660 // InternalSolverLanguage.g:3406:1: ( '|' )
10661 {
10662 // InternalSolverLanguage.g:3406:1: ( '|' )
10663 // InternalSolverLanguage.g:3407:2: '|'
10664 {
10665 before(grammarAccess.getErrorPredicateAccess().getVerticalLineKeyword_5_1_1_0());
10666 match(input,28,FOLLOW_2);
10667 after(grammarAccess.getErrorPredicateAccess().getVerticalLineKeyword_5_1_1_0());
10668
10669 }
10670
10671
10672 }
10673
10674 }
10675 catch (RecognitionException re) {
10676 reportError(re);
10677 recover(input,re);
10678 }
10679 finally {
10680
10681 restoreStackSize(stackSize);
10682
10683 }
10684 return ;
10685 }
10686 // $ANTLR end "rule__ErrorPredicate__Group_5_1_1__0__Impl"
10687
10688
10689 // $ANTLR start "rule__ErrorPredicate__Group_5_1_1__1"
10690 // InternalSolverLanguage.g:3416:1: rule__ErrorPredicate__Group_5_1_1__1 : rule__ErrorPredicate__Group_5_1_1__1__Impl ;
10691 public final void rule__ErrorPredicate__Group_5_1_1__1() throws RecognitionException {
10692
10693 int stackSize = keepStackSize();
10694
10695 try {
10696 // InternalSolverLanguage.g:3420:1: ( rule__ErrorPredicate__Group_5_1_1__1__Impl )
10697 // InternalSolverLanguage.g:3421:2: rule__ErrorPredicate__Group_5_1_1__1__Impl
10698 {
10699 pushFollow(FOLLOW_2);
10700 rule__ErrorPredicate__Group_5_1_1__1__Impl();
10701
10702 state._fsp--;
10703
10704
10705 }
10706
10707 }
10708 catch (RecognitionException re) {
10709 reportError(re);
10710 recover(input,re);
10711 }
10712 finally {
10713
10714 restoreStackSize(stackSize);
10715
10716 }
10717 return ;
10718 }
10719 // $ANTLR end "rule__ErrorPredicate__Group_5_1_1__1"
10720
10721
10722 // $ANTLR start "rule__ErrorPredicate__Group_5_1_1__1__Impl"
10723 // InternalSolverLanguage.g:3427:1: rule__ErrorPredicate__Group_5_1_1__1__Impl : ( ( rule__ErrorPredicate__BodiesAssignment_5_1_1_1 ) ) ;
10724 public final void rule__ErrorPredicate__Group_5_1_1__1__Impl() throws RecognitionException {
10725
10726 int stackSize = keepStackSize();
10727
10728 try {
10729 // InternalSolverLanguage.g:3431:1: ( ( ( rule__ErrorPredicate__BodiesAssignment_5_1_1_1 ) ) )
10730 // InternalSolverLanguage.g:3432:1: ( ( rule__ErrorPredicate__BodiesAssignment_5_1_1_1 ) )
10731 {
10732 // InternalSolverLanguage.g:3432:1: ( ( rule__ErrorPredicate__BodiesAssignment_5_1_1_1 ) )
10733 // InternalSolverLanguage.g:3433:2: ( rule__ErrorPredicate__BodiesAssignment_5_1_1_1 )
10734 {
10735 before(grammarAccess.getErrorPredicateAccess().getBodiesAssignment_5_1_1_1());
10736 // InternalSolverLanguage.g:3434:2: ( rule__ErrorPredicate__BodiesAssignment_5_1_1_1 )
10737 // InternalSolverLanguage.g:3434:3: rule__ErrorPredicate__BodiesAssignment_5_1_1_1
10738 {
10739 pushFollow(FOLLOW_2);
10740 rule__ErrorPredicate__BodiesAssignment_5_1_1_1();
10741
10742 state._fsp--;
10743
10744
10745 }
10746
10747 after(grammarAccess.getErrorPredicateAccess().getBodiesAssignment_5_1_1_1());
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__ErrorPredicate__Group_5_1_1__1__Impl"
10767
10768
10769 // $ANTLR start "rule__Parameter__Group__0"
10770 // InternalSolverLanguage.g:3443:1: rule__Parameter__Group__0 : rule__Parameter__Group__0__Impl rule__Parameter__Group__1 ;
10771 public final void rule__Parameter__Group__0() throws RecognitionException {
10772
10773 int stackSize = keepStackSize();
10774
10775 try {
10776 // InternalSolverLanguage.g:3447:1: ( rule__Parameter__Group__0__Impl rule__Parameter__Group__1 )
10777 // InternalSolverLanguage.g:3448:2: rule__Parameter__Group__0__Impl rule__Parameter__Group__1
10778 {
10779 pushFollow(FOLLOW_14);
10780 rule__Parameter__Group__0__Impl();
10781
10782 state._fsp--;
10783
10784 pushFollow(FOLLOW_2);
10785 rule__Parameter__Group__1();
10786
10787 state._fsp--;
10788
10789
10790 }
10791
10792 }
10793 catch (RecognitionException re) {
10794 reportError(re);
10795 recover(input,re);
10796 }
10797 finally {
10798
10799 restoreStackSize(stackSize);
10800
10801 }
10802 return ;
10803 }
10804 // $ANTLR end "rule__Parameter__Group__0"
10805
10806
10807 // $ANTLR start "rule__Parameter__Group__0__Impl"
10808 // InternalSolverLanguage.g:3455:1: rule__Parameter__Group__0__Impl : ( ( rule__Parameter__VariableAssignment_0 ) ) ;
10809 public final void rule__Parameter__Group__0__Impl() throws RecognitionException {
10810
10811 int stackSize = keepStackSize();
10812
10813 try {
10814 // InternalSolverLanguage.g:3459:1: ( ( ( rule__Parameter__VariableAssignment_0 ) ) )
10815 // InternalSolverLanguage.g:3460:1: ( ( rule__Parameter__VariableAssignment_0 ) )
10816 {
10817 // InternalSolverLanguage.g:3460:1: ( ( rule__Parameter__VariableAssignment_0 ) )
10818 // InternalSolverLanguage.g:3461:2: ( rule__Parameter__VariableAssignment_0 )
10819 {
10820 before(grammarAccess.getParameterAccess().getVariableAssignment_0());
10821 // InternalSolverLanguage.g:3462:2: ( rule__Parameter__VariableAssignment_0 )
10822 // InternalSolverLanguage.g:3462:3: rule__Parameter__VariableAssignment_0
10823 {
10824 pushFollow(FOLLOW_2);
10825 rule__Parameter__VariableAssignment_0();
10826
10827 state._fsp--;
10828
10829
10830 }
10831
10832 after(grammarAccess.getParameterAccess().getVariableAssignment_0());
10833
10834 }
10835
10836
10837 }
10838
10839 }
10840 catch (RecognitionException re) {
10841 reportError(re);
10842 recover(input,re);
10843 }
10844 finally {
10845
10846 restoreStackSize(stackSize);
10847
10848 }
10849 return ;
10850 }
10851 // $ANTLR end "rule__Parameter__Group__0__Impl"
10852
10853
10854 // $ANTLR start "rule__Parameter__Group__1"
10855 // InternalSolverLanguage.g:3470:1: rule__Parameter__Group__1 : rule__Parameter__Group__1__Impl ;
10856 public final void rule__Parameter__Group__1() throws RecognitionException {
10857
10858 int stackSize = keepStackSize();
10859
10860 try {
10861 // InternalSolverLanguage.g:3474:1: ( rule__Parameter__Group__1__Impl )
10862 // InternalSolverLanguage.g:3475:2: rule__Parameter__Group__1__Impl
10863 {
10864 pushFollow(FOLLOW_2);
10865 rule__Parameter__Group__1__Impl();
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__Parameter__Group__1"
10885
10886
10887 // $ANTLR start "rule__Parameter__Group__1__Impl"
10888 // InternalSolverLanguage.g:3481:1: rule__Parameter__Group__1__Impl : ( ( rule__Parameter__Group_1__0 )? ) ;
10889 public final void rule__Parameter__Group__1__Impl() throws RecognitionException {
10890
10891 int stackSize = keepStackSize();
10892
10893 try {
10894 // InternalSolverLanguage.g:3485:1: ( ( ( rule__Parameter__Group_1__0 )? ) )
10895 // InternalSolverLanguage.g:3486:1: ( ( rule__Parameter__Group_1__0 )? )
10896 {
10897 // InternalSolverLanguage.g:3486:1: ( ( rule__Parameter__Group_1__0 )? )
10898 // InternalSolverLanguage.g:3487:2: ( rule__Parameter__Group_1__0 )?
10899 {
10900 before(grammarAccess.getParameterAccess().getGroup_1());
10901 // InternalSolverLanguage.g:3488:2: ( rule__Parameter__Group_1__0 )?
10902 int alt31=2;
10903 int LA31_0 = input.LA(1);
10904
10905 if ( (LA31_0==19) ) {
10906 alt31=1;
10907 }
10908 switch (alt31) {
10909 case 1 :
10910 // InternalSolverLanguage.g:3488:3: rule__Parameter__Group_1__0
10911 {
10912 pushFollow(FOLLOW_2);
10913 rule__Parameter__Group_1__0();
10914
10915 state._fsp--;
10916
10917
10918 }
10919 break;
10920
10921 }
10922
10923 after(grammarAccess.getParameterAccess().getGroup_1());
10924
10925 }
10926
10927
10928 }
10929
10930 }
10931 catch (RecognitionException re) {
10932 reportError(re);
10933 recover(input,re);
10934 }
10935 finally {
10936
10937 restoreStackSize(stackSize);
10938
10939 }
10940 return ;
10941 }
10942 // $ANTLR end "rule__Parameter__Group__1__Impl"
10943
10944
10945 // $ANTLR start "rule__Parameter__Group_1__0"
10946 // InternalSolverLanguage.g:3497:1: rule__Parameter__Group_1__0 : rule__Parameter__Group_1__0__Impl rule__Parameter__Group_1__1 ;
10947 public final void rule__Parameter__Group_1__0() throws RecognitionException {
10948
10949 int stackSize = keepStackSize();
10950
10951 try {
10952 // InternalSolverLanguage.g:3501:1: ( rule__Parameter__Group_1__0__Impl rule__Parameter__Group_1__1 )
10953 // InternalSolverLanguage.g:3502:2: rule__Parameter__Group_1__0__Impl rule__Parameter__Group_1__1
10954 {
10955 pushFollow(FOLLOW_25);
10956 rule__Parameter__Group_1__0__Impl();
10957
10958 state._fsp--;
10959
10960 pushFollow(FOLLOW_2);
10961 rule__Parameter__Group_1__1();
10962
10963 state._fsp--;
10964
10965
10966 }
10967
10968 }
10969 catch (RecognitionException re) {
10970 reportError(re);
10971 recover(input,re);
10972 }
10973 finally {
10974
10975 restoreStackSize(stackSize);
10976
10977 }
10978 return ;
10979 }
10980 // $ANTLR end "rule__Parameter__Group_1__0"
10981
10982
10983 // $ANTLR start "rule__Parameter__Group_1__0__Impl"
10984 // InternalSolverLanguage.g:3509:1: rule__Parameter__Group_1__0__Impl : ( ':' ) ;
10985 public final void rule__Parameter__Group_1__0__Impl() throws RecognitionException {
10986
10987 int stackSize = keepStackSize();
10988
10989 try {
10990 // InternalSolverLanguage.g:3513:1: ( ( ':' ) )
10991 // InternalSolverLanguage.g:3514:1: ( ':' )
10992 {
10993 // InternalSolverLanguage.g:3514:1: ( ':' )
10994 // InternalSolverLanguage.g:3515:2: ':'
10995 {
10996 before(grammarAccess.getParameterAccess().getColonKeyword_1_0());
10997 match(input,19,FOLLOW_2);
10998 after(grammarAccess.getParameterAccess().getColonKeyword_1_0());
10999
11000 }
11001
11002
11003 }
11004
11005 }
11006 catch (RecognitionException re) {
11007 reportError(re);
11008 recover(input,re);
11009 }
11010 finally {
11011
11012 restoreStackSize(stackSize);
11013
11014 }
11015 return ;
11016 }
11017 // $ANTLR end "rule__Parameter__Group_1__0__Impl"
11018
11019
11020 // $ANTLR start "rule__Parameter__Group_1__1"
11021 // InternalSolverLanguage.g:3524:1: rule__Parameter__Group_1__1 : rule__Parameter__Group_1__1__Impl ;
11022 public final void rule__Parameter__Group_1__1() throws RecognitionException {
11023
11024 int stackSize = keepStackSize();
11025
11026 try {
11027 // InternalSolverLanguage.g:3528:1: ( rule__Parameter__Group_1__1__Impl )
11028 // InternalSolverLanguage.g:3529:2: rule__Parameter__Group_1__1__Impl
11029 {
11030 pushFollow(FOLLOW_2);
11031 rule__Parameter__Group_1__1__Impl();
11032
11033 state._fsp--;
11034
11035
11036 }
11037
11038 }
11039 catch (RecognitionException re) {
11040 reportError(re);
11041 recover(input,re);
11042 }
11043 finally {
11044
11045 restoreStackSize(stackSize);
11046
11047 }
11048 return ;
11049 }
11050 // $ANTLR end "rule__Parameter__Group_1__1"
11051
11052
11053 // $ANTLR start "rule__Parameter__Group_1__1__Impl"
11054 // InternalSolverLanguage.g:3535:1: rule__Parameter__Group_1__1__Impl : ( ( rule__Parameter__TypeAssignment_1_1 ) ) ;
11055 public final void rule__Parameter__Group_1__1__Impl() throws RecognitionException {
11056
11057 int stackSize = keepStackSize();
11058
11059 try {
11060 // InternalSolverLanguage.g:3539:1: ( ( ( rule__Parameter__TypeAssignment_1_1 ) ) )
11061 // InternalSolverLanguage.g:3540:1: ( ( rule__Parameter__TypeAssignment_1_1 ) )
11062 {
11063 // InternalSolverLanguage.g:3540:1: ( ( rule__Parameter__TypeAssignment_1_1 ) )
11064 // InternalSolverLanguage.g:3541:2: ( rule__Parameter__TypeAssignment_1_1 )
11065 {
11066 before(grammarAccess.getParameterAccess().getTypeAssignment_1_1());
11067 // InternalSolverLanguage.g:3542:2: ( rule__Parameter__TypeAssignment_1_1 )
11068 // InternalSolverLanguage.g:3542:3: rule__Parameter__TypeAssignment_1_1
11069 {
11070 pushFollow(FOLLOW_2);
11071 rule__Parameter__TypeAssignment_1_1();
11072
11073 state._fsp--;
11074
11075
11076 }
11077
11078 after(grammarAccess.getParameterAccess().getTypeAssignment_1_1());
11079
11080 }
11081
11082
11083 }
11084
11085 }
11086 catch (RecognitionException re) {
11087 reportError(re);
11088 recover(input,re);
11089 }
11090 finally {
11091
11092 restoreStackSize(stackSize);
11093
11094 }
11095 return ;
11096 }
11097 // $ANTLR end "rule__Parameter__Group_1__1__Impl"
11098
11099
11100 // $ANTLR start "rule__PatternBody__Group__0"
11101 // InternalSolverLanguage.g:3551:1: rule__PatternBody__Group__0 : rule__PatternBody__Group__0__Impl rule__PatternBody__Group__1 ;
11102 public final void rule__PatternBody__Group__0() throws RecognitionException {
11103
11104 int stackSize = keepStackSize();
11105
11106 try {
11107 // InternalSolverLanguage.g:3555:1: ( rule__PatternBody__Group__0__Impl rule__PatternBody__Group__1 )
11108 // InternalSolverLanguage.g:3556:2: rule__PatternBody__Group__0__Impl rule__PatternBody__Group__1
11109 {
11110 pushFollow(FOLLOW_20);
11111 rule__PatternBody__Group__0__Impl();
11112
11113 state._fsp--;
11114
11115 pushFollow(FOLLOW_2);
11116 rule__PatternBody__Group__1();
11117
11118 state._fsp--;
11119
11120
11121 }
11122
11123 }
11124 catch (RecognitionException re) {
11125 reportError(re);
11126 recover(input,re);
11127 }
11128 finally {
11129
11130 restoreStackSize(stackSize);
11131
11132 }
11133 return ;
11134 }
11135 // $ANTLR end "rule__PatternBody__Group__0"
11136
11137
11138 // $ANTLR start "rule__PatternBody__Group__0__Impl"
11139 // InternalSolverLanguage.g:3563:1: rule__PatternBody__Group__0__Impl : ( () ) ;
11140 public final void rule__PatternBody__Group__0__Impl() throws RecognitionException {
11141
11142 int stackSize = keepStackSize();
11143
11144 try {
11145 // InternalSolverLanguage.g:3567:1: ( ( () ) )
11146 // InternalSolverLanguage.g:3568:1: ( () )
11147 {
11148 // InternalSolverLanguage.g:3568:1: ( () )
11149 // InternalSolverLanguage.g:3569:2: ()
11150 {
11151 before(grammarAccess.getPatternBodyAccess().getPatternBodyAction_0());
11152 // InternalSolverLanguage.g:3570:2: ()
11153 // InternalSolverLanguage.g:3570:3:
11154 {
11155 }
11156
11157 after(grammarAccess.getPatternBodyAccess().getPatternBodyAction_0());
11158
11159 }
11160
11161
11162 }
11163
11164 }
11165 finally {
11166
11167 restoreStackSize(stackSize);
11168
11169 }
11170 return ;
11171 }
11172 // $ANTLR end "rule__PatternBody__Group__0__Impl"
11173
11174
11175 // $ANTLR start "rule__PatternBody__Group__1"
11176 // InternalSolverLanguage.g:3578:1: rule__PatternBody__Group__1 : rule__PatternBody__Group__1__Impl ;
11177 public final void rule__PatternBody__Group__1() throws RecognitionException {
11178
11179 int stackSize = keepStackSize();
11180
11181 try {
11182 // InternalSolverLanguage.g:3582:1: ( rule__PatternBody__Group__1__Impl )
11183 // InternalSolverLanguage.g:3583:2: rule__PatternBody__Group__1__Impl
11184 {
11185 pushFollow(FOLLOW_2);
11186 rule__PatternBody__Group__1__Impl();
11187
11188 state._fsp--;
11189
11190
11191 }
11192
11193 }
11194 catch (RecognitionException re) {
11195 reportError(re);
11196 recover(input,re);
11197 }
11198 finally {
11199
11200 restoreStackSize(stackSize);
11201
11202 }
11203 return ;
11204 }
11205 // $ANTLR end "rule__PatternBody__Group__1"
11206
11207
11208 // $ANTLR start "rule__PatternBody__Group__1__Impl"
11209 // InternalSolverLanguage.g:3589:1: rule__PatternBody__Group__1__Impl : ( ( rule__PatternBody__Alternatives_1 ) ) ;
11210 public final void rule__PatternBody__Group__1__Impl() throws RecognitionException {
11211
11212 int stackSize = keepStackSize();
11213
11214 try {
11215 // InternalSolverLanguage.g:3593:1: ( ( ( rule__PatternBody__Alternatives_1 ) ) )
11216 // InternalSolverLanguage.g:3594:1: ( ( rule__PatternBody__Alternatives_1 ) )
11217 {
11218 // InternalSolverLanguage.g:3594:1: ( ( rule__PatternBody__Alternatives_1 ) )
11219 // InternalSolverLanguage.g:3595:2: ( rule__PatternBody__Alternatives_1 )
11220 {
11221 before(grammarAccess.getPatternBodyAccess().getAlternatives_1());
11222 // InternalSolverLanguage.g:3596:2: ( rule__PatternBody__Alternatives_1 )
11223 // InternalSolverLanguage.g:3596:3: rule__PatternBody__Alternatives_1
11224 {
11225 pushFollow(FOLLOW_2);
11226 rule__PatternBody__Alternatives_1();
11227
11228 state._fsp--;
11229
11230
11231 }
11232
11233 after(grammarAccess.getPatternBodyAccess().getAlternatives_1());
11234
11235 }
11236
11237
11238 }
11239
11240 }
11241 catch (RecognitionException re) {
11242 reportError(re);
11243 recover(input,re);
11244 }
11245 finally {
11246
11247 restoreStackSize(stackSize);
11248
11249 }
11250 return ;
11251 }
11252 // $ANTLR end "rule__PatternBody__Group__1__Impl"
11253
11254
11255 // $ANTLR start "rule__Polarity__Group_0__0"
11256 // InternalSolverLanguage.g:3605:1: rule__Polarity__Group_0__0 : rule__Polarity__Group_0__0__Impl rule__Polarity__Group_0__1 ;
11257 public final void rule__Polarity__Group_0__0() throws RecognitionException {
11258
11259 int stackSize = keepStackSize();
11260
11261 try {
11262 // InternalSolverLanguage.g:3609:1: ( rule__Polarity__Group_0__0__Impl rule__Polarity__Group_0__1 )
11263 // InternalSolverLanguage.g:3610:2: rule__Polarity__Group_0__0__Impl rule__Polarity__Group_0__1
11264 {
11265 pushFollow(FOLLOW_26);
11266 rule__Polarity__Group_0__0__Impl();
11267
11268 state._fsp--;
11269
11270 pushFollow(FOLLOW_2);
11271 rule__Polarity__Group_0__1();
11272
11273 state._fsp--;
11274
11275
11276 }
11277
11278 }
11279 catch (RecognitionException re) {
11280 reportError(re);
11281 recover(input,re);
11282 }
11283 finally {
11284
11285 restoreStackSize(stackSize);
11286
11287 }
11288 return ;
11289 }
11290 // $ANTLR end "rule__Polarity__Group_0__0"
11291
11292
11293 // $ANTLR start "rule__Polarity__Group_0__0__Impl"
11294 // InternalSolverLanguage.g:3617:1: rule__Polarity__Group_0__0__Impl : ( () ) ;
11295 public final void rule__Polarity__Group_0__0__Impl() throws RecognitionException {
11296
11297 int stackSize = keepStackSize();
11298
11299 try {
11300 // InternalSolverLanguage.g:3621:1: ( ( () ) )
11301 // InternalSolverLanguage.g:3622:1: ( () )
11302 {
11303 // InternalSolverLanguage.g:3622:1: ( () )
11304 // InternalSolverLanguage.g:3623:2: ()
11305 {
11306 before(grammarAccess.getPolarityAccess().getPositiveAction_0_0());
11307 // InternalSolverLanguage.g:3624:2: ()
11308 // InternalSolverLanguage.g:3624:3:
11309 {
11310 }
11311
11312 after(grammarAccess.getPolarityAccess().getPositiveAction_0_0());
11313
11314 }
11315
11316
11317 }
11318
11319 }
11320 finally {
11321
11322 restoreStackSize(stackSize);
11323
11324 }
11325 return ;
11326 }
11327 // $ANTLR end "rule__Polarity__Group_0__0__Impl"
11328
11329
11330 // $ANTLR start "rule__Polarity__Group_0__1"
11331 // InternalSolverLanguage.g:3632:1: rule__Polarity__Group_0__1 : rule__Polarity__Group_0__1__Impl ;
11332 public final void rule__Polarity__Group_0__1() throws RecognitionException {
11333
11334 int stackSize = keepStackSize();
11335
11336 try {
11337 // InternalSolverLanguage.g:3636:1: ( rule__Polarity__Group_0__1__Impl )
11338 // InternalSolverLanguage.g:3637:2: rule__Polarity__Group_0__1__Impl
11339 {
11340 pushFollow(FOLLOW_2);
11341 rule__Polarity__Group_0__1__Impl();
11342
11343 state._fsp--;
11344
11345
11346 }
11347
11348 }
11349 catch (RecognitionException re) {
11350 reportError(re);
11351 recover(input,re);
11352 }
11353 finally {
11354
11355 restoreStackSize(stackSize);
11356
11357 }
11358 return ;
11359 }
11360 // $ANTLR end "rule__Polarity__Group_0__1"
11361
11362
11363 // $ANTLR start "rule__Polarity__Group_0__1__Impl"
11364 // InternalSolverLanguage.g:3643:1: rule__Polarity__Group_0__1__Impl : ( '+' ) ;
11365 public final void rule__Polarity__Group_0__1__Impl() throws RecognitionException {
11366
11367 int stackSize = keepStackSize();
11368
11369 try {
11370 // InternalSolverLanguage.g:3647:1: ( ( '+' ) )
11371 // InternalSolverLanguage.g:3648:1: ( '+' )
11372 {
11373 // InternalSolverLanguage.g:3648:1: ( '+' )
11374 // InternalSolverLanguage.g:3649:2: '+'
11375 {
11376 before(grammarAccess.getPolarityAccess().getPlusSignKeyword_0_1());
11377 match(input,29,FOLLOW_2);
11378 after(grammarAccess.getPolarityAccess().getPlusSignKeyword_0_1());
11379
11380 }
11381
11382
11383 }
11384
11385 }
11386 catch (RecognitionException re) {
11387 reportError(re);
11388 recover(input,re);
11389 }
11390 finally {
11391
11392 restoreStackSize(stackSize);
11393
11394 }
11395 return ;
11396 }
11397 // $ANTLR end "rule__Polarity__Group_0__1__Impl"
11398
11399
11400 // $ANTLR start "rule__Polarity__Group_1__0"
11401 // InternalSolverLanguage.g:3659:1: rule__Polarity__Group_1__0 : rule__Polarity__Group_1__0__Impl rule__Polarity__Group_1__1 ;
11402 public final void rule__Polarity__Group_1__0() throws RecognitionException {
11403
11404 int stackSize = keepStackSize();
11405
11406 try {
11407 // InternalSolverLanguage.g:3663:1: ( rule__Polarity__Group_1__0__Impl rule__Polarity__Group_1__1 )
11408 // InternalSolverLanguage.g:3664:2: rule__Polarity__Group_1__0__Impl rule__Polarity__Group_1__1
11409 {
11410 pushFollow(FOLLOW_27);
11411 rule__Polarity__Group_1__0__Impl();
11412
11413 state._fsp--;
11414
11415 pushFollow(FOLLOW_2);
11416 rule__Polarity__Group_1__1();
11417
11418 state._fsp--;
11419
11420
11421 }
11422
11423 }
11424 catch (RecognitionException re) {
11425 reportError(re);
11426 recover(input,re);
11427 }
11428 finally {
11429
11430 restoreStackSize(stackSize);
11431
11432 }
11433 return ;
11434 }
11435 // $ANTLR end "rule__Polarity__Group_1__0"
11436
11437
11438 // $ANTLR start "rule__Polarity__Group_1__0__Impl"
11439 // InternalSolverLanguage.g:3671:1: rule__Polarity__Group_1__0__Impl : ( () ) ;
11440 public final void rule__Polarity__Group_1__0__Impl() throws RecognitionException {
11441
11442 int stackSize = keepStackSize();
11443
11444 try {
11445 // InternalSolverLanguage.g:3675:1: ( ( () ) )
11446 // InternalSolverLanguage.g:3676:1: ( () )
11447 {
11448 // InternalSolverLanguage.g:3676:1: ( () )
11449 // InternalSolverLanguage.g:3677:2: ()
11450 {
11451 before(grammarAccess.getPolarityAccess().getNegativeAction_1_0());
11452 // InternalSolverLanguage.g:3678:2: ()
11453 // InternalSolverLanguage.g:3678:3:
11454 {
11455 }
11456
11457 after(grammarAccess.getPolarityAccess().getNegativeAction_1_0());
11458
11459 }
11460
11461
11462 }
11463
11464 }
11465 finally {
11466
11467 restoreStackSize(stackSize);
11468
11469 }
11470 return ;
11471 }
11472 // $ANTLR end "rule__Polarity__Group_1__0__Impl"
11473
11474
11475 // $ANTLR start "rule__Polarity__Group_1__1"
11476 // InternalSolverLanguage.g:3686:1: rule__Polarity__Group_1__1 : rule__Polarity__Group_1__1__Impl ;
11477 public final void rule__Polarity__Group_1__1() throws RecognitionException {
11478
11479 int stackSize = keepStackSize();
11480
11481 try {
11482 // InternalSolverLanguage.g:3690:1: ( rule__Polarity__Group_1__1__Impl )
11483 // InternalSolverLanguage.g:3691:2: rule__Polarity__Group_1__1__Impl
11484 {
11485 pushFollow(FOLLOW_2);
11486 rule__Polarity__Group_1__1__Impl();
11487
11488 state._fsp--;
11489
11490
11491 }
11492
11493 }
11494 catch (RecognitionException re) {
11495 reportError(re);
11496 recover(input,re);
11497 }
11498 finally {
11499
11500 restoreStackSize(stackSize);
11501
11502 }
11503 return ;
11504 }
11505 // $ANTLR end "rule__Polarity__Group_1__1"
11506
11507
11508 // $ANTLR start "rule__Polarity__Group_1__1__Impl"
11509 // InternalSolverLanguage.g:3697:1: rule__Polarity__Group_1__1__Impl : ( '-' ) ;
11510 public final void rule__Polarity__Group_1__1__Impl() throws RecognitionException {
11511
11512 int stackSize = keepStackSize();
11513
11514 try {
11515 // InternalSolverLanguage.g:3701:1: ( ( '-' ) )
11516 // InternalSolverLanguage.g:3702:1: ( '-' )
11517 {
11518 // InternalSolverLanguage.g:3702:1: ( '-' )
11519 // InternalSolverLanguage.g:3703:2: '-'
11520 {
11521 before(grammarAccess.getPolarityAccess().getHyphenMinusKeyword_1_1());
11522 match(input,13,FOLLOW_2);
11523 after(grammarAccess.getPolarityAccess().getHyphenMinusKeyword_1_1());
11524
11525 }
11526
11527
11528 }
11529
11530 }
11531 catch (RecognitionException re) {
11532 reportError(re);
11533 recover(input,re);
11534 }
11535 finally {
11536
11537 restoreStackSize(stackSize);
11538
11539 }
11540 return ;
11541 }
11542 // $ANTLR end "rule__Polarity__Group_1__1__Impl"
11543
11544
11545 // $ANTLR start "rule__Constraint__Group__0"
11546 // InternalSolverLanguage.g:3713:1: rule__Constraint__Group__0 : rule__Constraint__Group__0__Impl rule__Constraint__Group__1 ;
11547 public final void rule__Constraint__Group__0() throws RecognitionException {
11548
11549 int stackSize = keepStackSize();
11550
11551 try {
11552 // InternalSolverLanguage.g:3717:1: ( rule__Constraint__Group__0__Impl rule__Constraint__Group__1 )
11553 // InternalSolverLanguage.g:3718:2: rule__Constraint__Group__0__Impl rule__Constraint__Group__1
11554 {
11555 pushFollow(FOLLOW_28);
11556 rule__Constraint__Group__0__Impl();
11557
11558 state._fsp--;
11559
11560 pushFollow(FOLLOW_2);
11561 rule__Constraint__Group__1();
11562
11563 state._fsp--;
11564
11565
11566 }
11567
11568 }
11569 catch (RecognitionException re) {
11570 reportError(re);
11571 recover(input,re);
11572 }
11573 finally {
11574
11575 restoreStackSize(stackSize);
11576
11577 }
11578 return ;
11579 }
11580 // $ANTLR end "rule__Constraint__Group__0"
11581
11582
11583 // $ANTLR start "rule__Constraint__Group__0__Impl"
11584 // InternalSolverLanguage.g:3725:1: rule__Constraint__Group__0__Impl : ( ( rule__Constraint__PolarityAssignment_0 )? ) ;
11585 public final void rule__Constraint__Group__0__Impl() throws RecognitionException {
11586
11587 int stackSize = keepStackSize();
11588
11589 try {
11590 // InternalSolverLanguage.g:3729:1: ( ( ( rule__Constraint__PolarityAssignment_0 )? ) )
11591 // InternalSolverLanguage.g:3730:1: ( ( rule__Constraint__PolarityAssignment_0 )? )
11592 {
11593 // InternalSolverLanguage.g:3730:1: ( ( rule__Constraint__PolarityAssignment_0 )? )
11594 // InternalSolverLanguage.g:3731:2: ( rule__Constraint__PolarityAssignment_0 )?
11595 {
11596 before(grammarAccess.getConstraintAccess().getPolarityAssignment_0());
11597 // InternalSolverLanguage.g:3732:2: ( rule__Constraint__PolarityAssignment_0 )?
11598 int alt32=2;
11599 int LA32_0 = input.LA(1);
11600
11601 if ( (LA32_0==13||LA32_0==29) ) {
11602 alt32=1;
11603 }
11604 switch (alt32) {
11605 case 1 :
11606 // InternalSolverLanguage.g:3732:3: rule__Constraint__PolarityAssignment_0
11607 {
11608 pushFollow(FOLLOW_2);
11609 rule__Constraint__PolarityAssignment_0();
11610
11611 state._fsp--;
11612
11613
11614 }
11615 break;
11616
11617 }
11618
11619 after(grammarAccess.getConstraintAccess().getPolarityAssignment_0());
11620
11621 }
11622
11623
11624 }
11625
11626 }
11627 catch (RecognitionException re) {
11628 reportError(re);
11629 recover(input,re);
11630 }
11631 finally {
11632
11633 restoreStackSize(stackSize);
11634
11635 }
11636 return ;
11637 }
11638 // $ANTLR end "rule__Constraint__Group__0__Impl"
11639
11640
11641 // $ANTLR start "rule__Constraint__Group__1"
11642 // InternalSolverLanguage.g:3740:1: rule__Constraint__Group__1 : rule__Constraint__Group__1__Impl rule__Constraint__Group__2 ;
11643 public final void rule__Constraint__Group__1() throws RecognitionException {
11644
11645 int stackSize = keepStackSize();
11646
11647 try {
11648 // InternalSolverLanguage.g:3744:1: ( rule__Constraint__Group__1__Impl rule__Constraint__Group__2 )
11649 // InternalSolverLanguage.g:3745:2: rule__Constraint__Group__1__Impl rule__Constraint__Group__2
11650 {
11651 pushFollow(FOLLOW_29);
11652 rule__Constraint__Group__1__Impl();
11653
11654 state._fsp--;
11655
11656 pushFollow(FOLLOW_2);
11657 rule__Constraint__Group__2();
11658
11659 state._fsp--;
11660
11661
11662 }
11663
11664 }
11665 catch (RecognitionException re) {
11666 reportError(re);
11667 recover(input,re);
11668 }
11669 finally {
11670
11671 restoreStackSize(stackSize);
11672
11673 }
11674 return ;
11675 }
11676 // $ANTLR end "rule__Constraint__Group__1"
11677
11678
11679 // $ANTLR start "rule__Constraint__Group__1__Impl"
11680 // InternalSolverLanguage.g:3752:1: rule__Constraint__Group__1__Impl : ( ( rule__Constraint__SymbolAssignment_1 ) ) ;
11681 public final void rule__Constraint__Group__1__Impl() throws RecognitionException {
11682
11683 int stackSize = keepStackSize();
11684
11685 try {
11686 // InternalSolverLanguage.g:3756:1: ( ( ( rule__Constraint__SymbolAssignment_1 ) ) )
11687 // InternalSolverLanguage.g:3757:1: ( ( rule__Constraint__SymbolAssignment_1 ) )
11688 {
11689 // InternalSolverLanguage.g:3757:1: ( ( rule__Constraint__SymbolAssignment_1 ) )
11690 // InternalSolverLanguage.g:3758:2: ( rule__Constraint__SymbolAssignment_1 )
11691 {
11692 before(grammarAccess.getConstraintAccess().getSymbolAssignment_1());
11693 // InternalSolverLanguage.g:3759:2: ( rule__Constraint__SymbolAssignment_1 )
11694 // InternalSolverLanguage.g:3759:3: rule__Constraint__SymbolAssignment_1
11695 {
11696 pushFollow(FOLLOW_2);
11697 rule__Constraint__SymbolAssignment_1();
11698
11699 state._fsp--;
11700
11701
11702 }
11703
11704 after(grammarAccess.getConstraintAccess().getSymbolAssignment_1());
11705
11706 }
11707
11708
11709 }
11710
11711 }
11712 catch (RecognitionException re) {
11713 reportError(re);
11714 recover(input,re);
11715 }
11716 finally {
11717
11718 restoreStackSize(stackSize);
11719
11720 }
11721 return ;
11722 }
11723 // $ANTLR end "rule__Constraint__Group__1__Impl"
11724
11725
11726 // $ANTLR start "rule__Constraint__Group__2"
11727 // InternalSolverLanguage.g:3767:1: rule__Constraint__Group__2 : rule__Constraint__Group__2__Impl ;
11728 public final void rule__Constraint__Group__2() throws RecognitionException {
11729
11730 int stackSize = keepStackSize();
11731
11732 try {
11733 // InternalSolverLanguage.g:3771:1: ( rule__Constraint__Group__2__Impl )
11734 // InternalSolverLanguage.g:3772:2: rule__Constraint__Group__2__Impl
11735 {
11736 pushFollow(FOLLOW_2);
11737 rule__Constraint__Group__2__Impl();
11738
11739 state._fsp--;
11740
11741
11742 }
11743
11744 }
11745 catch (RecognitionException re) {
11746 reportError(re);
11747 recover(input,re);
11748 }
11749 finally {
11750
11751 restoreStackSize(stackSize);
11752
11753 }
11754 return ;
11755 }
11756 // $ANTLR end "rule__Constraint__Group__2"
11757
11758
11759 // $ANTLR start "rule__Constraint__Group__2__Impl"
11760 // InternalSolverLanguage.g:3778:1: rule__Constraint__Group__2__Impl : ( ( rule__Constraint__Alternatives_2 ) ) ;
11761 public final void rule__Constraint__Group__2__Impl() throws RecognitionException {
11762
11763 int stackSize = keepStackSize();
11764
11765 try {
11766 // InternalSolverLanguage.g:3782:1: ( ( ( rule__Constraint__Alternatives_2 ) ) )
11767 // InternalSolverLanguage.g:3783:1: ( ( rule__Constraint__Alternatives_2 ) )
11768 {
11769 // InternalSolverLanguage.g:3783:1: ( ( rule__Constraint__Alternatives_2 ) )
11770 // InternalSolverLanguage.g:3784:2: ( rule__Constraint__Alternatives_2 )
11771 {
11772 before(grammarAccess.getConstraintAccess().getAlternatives_2());
11773 // InternalSolverLanguage.g:3785:2: ( rule__Constraint__Alternatives_2 )
11774 // InternalSolverLanguage.g:3785:3: rule__Constraint__Alternatives_2
11775 {
11776 pushFollow(FOLLOW_2);
11777 rule__Constraint__Alternatives_2();
11778
11779 state._fsp--;
11780
11781
11782 }
11783
11784 after(grammarAccess.getConstraintAccess().getAlternatives_2());
11785
11786 }
11787
11788
11789 }
11790
11791 }
11792 catch (RecognitionException re) {
11793 reportError(re);
11794 recover(input,re);
11795 }
11796 finally {
11797
11798 restoreStackSize(stackSize);
11799
11800 }
11801 return ;
11802 }
11803 // $ANTLR end "rule__Constraint__Group__2__Impl"
11804
11805
11806 // $ANTLR start "rule__Constraint__Group_2_0__0"
11807 // InternalSolverLanguage.g:3794:1: rule__Constraint__Group_2_0__0 : rule__Constraint__Group_2_0__0__Impl rule__Constraint__Group_2_0__1 ;
11808 public final void rule__Constraint__Group_2_0__0() throws RecognitionException {
11809
11810 int stackSize = keepStackSize();
11811
11812 try {
11813 // InternalSolverLanguage.g:3798:1: ( rule__Constraint__Group_2_0__0__Impl rule__Constraint__Group_2_0__1 )
11814 // InternalSolverLanguage.g:3799:2: rule__Constraint__Group_2_0__0__Impl rule__Constraint__Group_2_0__1
11815 {
11816 pushFollow(FOLLOW_30);
11817 rule__Constraint__Group_2_0__0__Impl();
11818
11819 state._fsp--;
11820
11821 pushFollow(FOLLOW_2);
11822 rule__Constraint__Group_2_0__1();
11823
11824 state._fsp--;
11825
11826
11827 }
11828
11829 }
11830 catch (RecognitionException re) {
11831 reportError(re);
11832 recover(input,re);
11833 }
11834 finally {
11835
11836 restoreStackSize(stackSize);
11837
11838 }
11839 return ;
11840 }
11841 // $ANTLR end "rule__Constraint__Group_2_0__0"
11842
11843
11844 // $ANTLR start "rule__Constraint__Group_2_0__0__Impl"
11845 // InternalSolverLanguage.g:3806:1: rule__Constraint__Group_2_0__0__Impl : ( '(' ) ;
11846 public final void rule__Constraint__Group_2_0__0__Impl() throws RecognitionException {
11847
11848 int stackSize = keepStackSize();
11849
11850 try {
11851 // InternalSolverLanguage.g:3810:1: ( ( '(' ) )
11852 // InternalSolverLanguage.g:3811:1: ( '(' )
11853 {
11854 // InternalSolverLanguage.g:3811:1: ( '(' )
11855 // InternalSolverLanguage.g:3812:2: '('
11856 {
11857 before(grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_0_0());
11858 match(input,17,FOLLOW_2);
11859 after(grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_0_0());
11860
11861 }
11862
11863
11864 }
11865
11866 }
11867 catch (RecognitionException re) {
11868 reportError(re);
11869 recover(input,re);
11870 }
11871 finally {
11872
11873 restoreStackSize(stackSize);
11874
11875 }
11876 return ;
11877 }
11878 // $ANTLR end "rule__Constraint__Group_2_0__0__Impl"
11879
11880
11881 // $ANTLR start "rule__Constraint__Group_2_0__1"
11882 // InternalSolverLanguage.g:3821:1: rule__Constraint__Group_2_0__1 : rule__Constraint__Group_2_0__1__Impl rule__Constraint__Group_2_0__2 ;
11883 public final void rule__Constraint__Group_2_0__1() throws RecognitionException {
11884
11885 int stackSize = keepStackSize();
11886
11887 try {
11888 // InternalSolverLanguage.g:3825:1: ( rule__Constraint__Group_2_0__1__Impl rule__Constraint__Group_2_0__2 )
11889 // InternalSolverLanguage.g:3826:2: rule__Constraint__Group_2_0__1__Impl rule__Constraint__Group_2_0__2
11890 {
11891 pushFollow(FOLLOW_30);
11892 rule__Constraint__Group_2_0__1__Impl();
11893
11894 state._fsp--;
11895
11896 pushFollow(FOLLOW_2);
11897 rule__Constraint__Group_2_0__2();
11898
11899 state._fsp--;
11900
11901
11902 }
11903
11904 }
11905 catch (RecognitionException re) {
11906 reportError(re);
11907 recover(input,re);
11908 }
11909 finally {
11910
11911 restoreStackSize(stackSize);
11912
11913 }
11914 return ;
11915 }
11916 // $ANTLR end "rule__Constraint__Group_2_0__1"
11917
11918
11919 // $ANTLR start "rule__Constraint__Group_2_0__1__Impl"
11920 // InternalSolverLanguage.g:3833:1: rule__Constraint__Group_2_0__1__Impl : ( ( rule__Constraint__ParamsAssignment_2_0_1 )* ) ;
11921 public final void rule__Constraint__Group_2_0__1__Impl() throws RecognitionException {
11922
11923 int stackSize = keepStackSize();
11924
11925 try {
11926 // InternalSolverLanguage.g:3837:1: ( ( ( rule__Constraint__ParamsAssignment_2_0_1 )* ) )
11927 // InternalSolverLanguage.g:3838:1: ( ( rule__Constraint__ParamsAssignment_2_0_1 )* )
11928 {
11929 // InternalSolverLanguage.g:3838:1: ( ( rule__Constraint__ParamsAssignment_2_0_1 )* )
11930 // InternalSolverLanguage.g:3839:2: ( rule__Constraint__ParamsAssignment_2_0_1 )*
11931 {
11932 before(grammarAccess.getConstraintAccess().getParamsAssignment_2_0_1());
11933 // InternalSolverLanguage.g:3840:2: ( rule__Constraint__ParamsAssignment_2_0_1 )*
11934 loop33:
11935 do {
11936 int alt33=2;
11937 int LA33_0 = input.LA(1);
11938
11939 if ( ((LA33_0>=RULE_INT && LA33_0<=RULE_STRING)||(LA33_0>=11 && LA33_0<=13)) ) {
11940 alt33=1;
11941 }
11942
11943
11944 switch (alt33) {
11945 case 1 :
11946 // InternalSolverLanguage.g:3840:3: rule__Constraint__ParamsAssignment_2_0_1
11947 {
11948 pushFollow(FOLLOW_31);
11949 rule__Constraint__ParamsAssignment_2_0_1();
11950
11951 state._fsp--;
11952
11953
11954 }
11955 break;
11956
11957 default :
11958 break loop33;
11959 }
11960 } while (true);
11961
11962 after(grammarAccess.getConstraintAccess().getParamsAssignment_2_0_1());
11963
11964 }
11965
11966
11967 }
11968
11969 }
11970 catch (RecognitionException re) {
11971 reportError(re);
11972 recover(input,re);
11973 }
11974 finally {
11975
11976 restoreStackSize(stackSize);
11977
11978 }
11979 return ;
11980 }
11981 // $ANTLR end "rule__Constraint__Group_2_0__1__Impl"
11982
11983
11984 // $ANTLR start "rule__Constraint__Group_2_0__2"
11985 // InternalSolverLanguage.g:3848:1: rule__Constraint__Group_2_0__2 : rule__Constraint__Group_2_0__2__Impl ;
11986 public final void rule__Constraint__Group_2_0__2() throws RecognitionException {
11987
11988 int stackSize = keepStackSize();
11989
11990 try {
11991 // InternalSolverLanguage.g:3852:1: ( rule__Constraint__Group_2_0__2__Impl )
11992 // InternalSolverLanguage.g:3853:2: rule__Constraint__Group_2_0__2__Impl
11993 {
11994 pushFollow(FOLLOW_2);
11995 rule__Constraint__Group_2_0__2__Impl();
11996
11997 state._fsp--;
11998
11999
12000 }
12001
12002 }
12003 catch (RecognitionException re) {
12004 reportError(re);
12005 recover(input,re);
12006 }
12007 finally {
12008
12009 restoreStackSize(stackSize);
12010
12011 }
12012 return ;
12013 }
12014 // $ANTLR end "rule__Constraint__Group_2_0__2"
12015
12016
12017 // $ANTLR start "rule__Constraint__Group_2_0__2__Impl"
12018 // InternalSolverLanguage.g:3859:1: rule__Constraint__Group_2_0__2__Impl : ( ')' ) ;
12019 public final void rule__Constraint__Group_2_0__2__Impl() throws RecognitionException {
12020
12021 int stackSize = keepStackSize();
12022
12023 try {
12024 // InternalSolverLanguage.g:3863:1: ( ( ')' ) )
12025 // InternalSolverLanguage.g:3864:1: ( ')' )
12026 {
12027 // InternalSolverLanguage.g:3864:1: ( ')' )
12028 // InternalSolverLanguage.g:3865:2: ')'
12029 {
12030 before(grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_0_2());
12031 match(input,18,FOLLOW_2);
12032 after(grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_0_2());
12033
12034 }
12035
12036
12037 }
12038
12039 }
12040 catch (RecognitionException re) {
12041 reportError(re);
12042 recover(input,re);
12043 }
12044 finally {
12045
12046 restoreStackSize(stackSize);
12047
12048 }
12049 return ;
12050 }
12051 // $ANTLR end "rule__Constraint__Group_2_0__2__Impl"
12052
12053
12054 // $ANTLR start "rule__Constraint__Group_2_1__0"
12055 // InternalSolverLanguage.g:3875:1: rule__Constraint__Group_2_1__0 : rule__Constraint__Group_2_1__0__Impl rule__Constraint__Group_2_1__1 ;
12056 public final void rule__Constraint__Group_2_1__0() throws RecognitionException {
12057
12058 int stackSize = keepStackSize();
12059
12060 try {
12061 // InternalSolverLanguage.g:3879:1: ( rule__Constraint__Group_2_1__0__Impl rule__Constraint__Group_2_1__1 )
12062 // InternalSolverLanguage.g:3880:2: rule__Constraint__Group_2_1__0__Impl rule__Constraint__Group_2_1__1
12063 {
12064 pushFollow(FOLLOW_11);
12065 rule__Constraint__Group_2_1__0__Impl();
12066
12067 state._fsp--;
12068
12069 pushFollow(FOLLOW_2);
12070 rule__Constraint__Group_2_1__1();
12071
12072 state._fsp--;
12073
12074
12075 }
12076
12077 }
12078 catch (RecognitionException re) {
12079 reportError(re);
12080 recover(input,re);
12081 }
12082 finally {
12083
12084 restoreStackSize(stackSize);
12085
12086 }
12087 return ;
12088 }
12089 // $ANTLR end "rule__Constraint__Group_2_1__0"
12090
12091
12092 // $ANTLR start "rule__Constraint__Group_2_1__0__Impl"
12093 // InternalSolverLanguage.g:3887:1: rule__Constraint__Group_2_1__0__Impl : ( ( rule__Constraint__ClosureTypeAssignment_2_1_0 ) ) ;
12094 public final void rule__Constraint__Group_2_1__0__Impl() throws RecognitionException {
12095
12096 int stackSize = keepStackSize();
12097
12098 try {
12099 // InternalSolverLanguage.g:3891:1: ( ( ( rule__Constraint__ClosureTypeAssignment_2_1_0 ) ) )
12100 // InternalSolverLanguage.g:3892:1: ( ( rule__Constraint__ClosureTypeAssignment_2_1_0 ) )
12101 {
12102 // InternalSolverLanguage.g:3892:1: ( ( rule__Constraint__ClosureTypeAssignment_2_1_0 ) )
12103 // InternalSolverLanguage.g:3893:2: ( rule__Constraint__ClosureTypeAssignment_2_1_0 )
12104 {
12105 before(grammarAccess.getConstraintAccess().getClosureTypeAssignment_2_1_0());
12106 // InternalSolverLanguage.g:3894:2: ( rule__Constraint__ClosureTypeAssignment_2_1_0 )
12107 // InternalSolverLanguage.g:3894:3: rule__Constraint__ClosureTypeAssignment_2_1_0
12108 {
12109 pushFollow(FOLLOW_2);
12110 rule__Constraint__ClosureTypeAssignment_2_1_0();
12111
12112 state._fsp--;
12113
12114
12115 }
12116
12117 after(grammarAccess.getConstraintAccess().getClosureTypeAssignment_2_1_0());
12118
12119 }
12120
12121
12122 }
12123
12124 }
12125 catch (RecognitionException re) {
12126 reportError(re);
12127 recover(input,re);
12128 }
12129 finally {
12130
12131 restoreStackSize(stackSize);
12132
12133 }
12134 return ;
12135 }
12136 // $ANTLR end "rule__Constraint__Group_2_1__0__Impl"
12137
12138
12139 // $ANTLR start "rule__Constraint__Group_2_1__1"
12140 // InternalSolverLanguage.g:3902:1: rule__Constraint__Group_2_1__1 : rule__Constraint__Group_2_1__1__Impl rule__Constraint__Group_2_1__2 ;
12141 public final void rule__Constraint__Group_2_1__1() throws RecognitionException {
12142
12143 int stackSize = keepStackSize();
12144
12145 try {
12146 // InternalSolverLanguage.g:3906:1: ( rule__Constraint__Group_2_1__1__Impl rule__Constraint__Group_2_1__2 )
12147 // InternalSolverLanguage.g:3907:2: rule__Constraint__Group_2_1__1__Impl rule__Constraint__Group_2_1__2
12148 {
12149 pushFollow(FOLLOW_32);
12150 rule__Constraint__Group_2_1__1__Impl();
12151
12152 state._fsp--;
12153
12154 pushFollow(FOLLOW_2);
12155 rule__Constraint__Group_2_1__2();
12156
12157 state._fsp--;
12158
12159
12160 }
12161
12162 }
12163 catch (RecognitionException re) {
12164 reportError(re);
12165 recover(input,re);
12166 }
12167 finally {
12168
12169 restoreStackSize(stackSize);
12170
12171 }
12172 return ;
12173 }
12174 // $ANTLR end "rule__Constraint__Group_2_1__1"
12175
12176
12177 // $ANTLR start "rule__Constraint__Group_2_1__1__Impl"
12178 // InternalSolverLanguage.g:3914:1: rule__Constraint__Group_2_1__1__Impl : ( '(' ) ;
12179 public final void rule__Constraint__Group_2_1__1__Impl() throws RecognitionException {
12180
12181 int stackSize = keepStackSize();
12182
12183 try {
12184 // InternalSolverLanguage.g:3918:1: ( ( '(' ) )
12185 // InternalSolverLanguage.g:3919:1: ( '(' )
12186 {
12187 // InternalSolverLanguage.g:3919:1: ( '(' )
12188 // InternalSolverLanguage.g:3920:2: '('
12189 {
12190 before(grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_1_1());
12191 match(input,17,FOLLOW_2);
12192 after(grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_1_1());
12193
12194 }
12195
12196
12197 }
12198
12199 }
12200 catch (RecognitionException re) {
12201 reportError(re);
12202 recover(input,re);
12203 }
12204 finally {
12205
12206 restoreStackSize(stackSize);
12207
12208 }
12209 return ;
12210 }
12211 // $ANTLR end "rule__Constraint__Group_2_1__1__Impl"
12212
12213
12214 // $ANTLR start "rule__Constraint__Group_2_1__2"
12215 // InternalSolverLanguage.g:3929:1: rule__Constraint__Group_2_1__2 : rule__Constraint__Group_2_1__2__Impl rule__Constraint__Group_2_1__3 ;
12216 public final void rule__Constraint__Group_2_1__2() throws RecognitionException {
12217
12218 int stackSize = keepStackSize();
12219
12220 try {
12221 // InternalSolverLanguage.g:3933:1: ( rule__Constraint__Group_2_1__2__Impl rule__Constraint__Group_2_1__3 )
12222 // InternalSolverLanguage.g:3934:2: rule__Constraint__Group_2_1__2__Impl rule__Constraint__Group_2_1__3
12223 {
12224 pushFollow(FOLLOW_32);
12225 rule__Constraint__Group_2_1__2__Impl();
12226
12227 state._fsp--;
12228
12229 pushFollow(FOLLOW_2);
12230 rule__Constraint__Group_2_1__3();
12231
12232 state._fsp--;
12233
12234
12235 }
12236
12237 }
12238 catch (RecognitionException re) {
12239 reportError(re);
12240 recover(input,re);
12241 }
12242 finally {
12243
12244 restoreStackSize(stackSize);
12245
12246 }
12247 return ;
12248 }
12249 // $ANTLR end "rule__Constraint__Group_2_1__2"
12250
12251
12252 // $ANTLR start "rule__Constraint__Group_2_1__2__Impl"
12253 // InternalSolverLanguage.g:3941:1: rule__Constraint__Group_2_1__2__Impl : ( ( rule__Constraint__ParamsAssignment_2_1_2 ) ) ;
12254 public final void rule__Constraint__Group_2_1__2__Impl() throws RecognitionException {
12255
12256 int stackSize = keepStackSize();
12257
12258 try {
12259 // InternalSolverLanguage.g:3945:1: ( ( ( rule__Constraint__ParamsAssignment_2_1_2 ) ) )
12260 // InternalSolverLanguage.g:3946:1: ( ( rule__Constraint__ParamsAssignment_2_1_2 ) )
12261 {
12262 // InternalSolverLanguage.g:3946:1: ( ( rule__Constraint__ParamsAssignment_2_1_2 ) )
12263 // InternalSolverLanguage.g:3947:2: ( rule__Constraint__ParamsAssignment_2_1_2 )
12264 {
12265 before(grammarAccess.getConstraintAccess().getParamsAssignment_2_1_2());
12266 // InternalSolverLanguage.g:3948:2: ( rule__Constraint__ParamsAssignment_2_1_2 )
12267 // InternalSolverLanguage.g:3948:3: rule__Constraint__ParamsAssignment_2_1_2
12268 {
12269 pushFollow(FOLLOW_2);
12270 rule__Constraint__ParamsAssignment_2_1_2();
12271
12272 state._fsp--;
12273
12274
12275 }
12276
12277 after(grammarAccess.getConstraintAccess().getParamsAssignment_2_1_2());
12278
12279 }
12280
12281
12282 }
12283
12284 }
12285 catch (RecognitionException re) {
12286 reportError(re);
12287 recover(input,re);
12288 }
12289 finally {
12290
12291 restoreStackSize(stackSize);
12292
12293 }
12294 return ;
12295 }
12296 // $ANTLR end "rule__Constraint__Group_2_1__2__Impl"
12297
12298
12299 // $ANTLR start "rule__Constraint__Group_2_1__3"
12300 // InternalSolverLanguage.g:3956:1: rule__Constraint__Group_2_1__3 : rule__Constraint__Group_2_1__3__Impl rule__Constraint__Group_2_1__4 ;
12301 public final void rule__Constraint__Group_2_1__3() throws RecognitionException {
12302
12303 int stackSize = keepStackSize();
12304
12305 try {
12306 // InternalSolverLanguage.g:3960:1: ( rule__Constraint__Group_2_1__3__Impl rule__Constraint__Group_2_1__4 )
12307 // InternalSolverLanguage.g:3961:2: rule__Constraint__Group_2_1__3__Impl rule__Constraint__Group_2_1__4
12308 {
12309 pushFollow(FOLLOW_33);
12310 rule__Constraint__Group_2_1__3__Impl();
12311
12312 state._fsp--;
12313
12314 pushFollow(FOLLOW_2);
12315 rule__Constraint__Group_2_1__4();
12316
12317 state._fsp--;
12318
12319
12320 }
12321
12322 }
12323 catch (RecognitionException re) {
12324 reportError(re);
12325 recover(input,re);
12326 }
12327 finally {
12328
12329 restoreStackSize(stackSize);
12330
12331 }
12332 return ;
12333 }
12334 // $ANTLR end "rule__Constraint__Group_2_1__3"
12335
12336
12337 // $ANTLR start "rule__Constraint__Group_2_1__3__Impl"
12338 // InternalSolverLanguage.g:3968:1: rule__Constraint__Group_2_1__3__Impl : ( ( rule__Constraint__ParamsAssignment_2_1_3 ) ) ;
12339 public final void rule__Constraint__Group_2_1__3__Impl() throws RecognitionException {
12340
12341 int stackSize = keepStackSize();
12342
12343 try {
12344 // InternalSolverLanguage.g:3972:1: ( ( ( rule__Constraint__ParamsAssignment_2_1_3 ) ) )
12345 // InternalSolverLanguage.g:3973:1: ( ( rule__Constraint__ParamsAssignment_2_1_3 ) )
12346 {
12347 // InternalSolverLanguage.g:3973:1: ( ( rule__Constraint__ParamsAssignment_2_1_3 ) )
12348 // InternalSolverLanguage.g:3974:2: ( rule__Constraint__ParamsAssignment_2_1_3 )
12349 {
12350 before(grammarAccess.getConstraintAccess().getParamsAssignment_2_1_3());
12351 // InternalSolverLanguage.g:3975:2: ( rule__Constraint__ParamsAssignment_2_1_3 )
12352 // InternalSolverLanguage.g:3975:3: rule__Constraint__ParamsAssignment_2_1_3
12353 {
12354 pushFollow(FOLLOW_2);
12355 rule__Constraint__ParamsAssignment_2_1_3();
12356
12357 state._fsp--;
12358
12359
12360 }
12361
12362 after(grammarAccess.getConstraintAccess().getParamsAssignment_2_1_3());
12363
12364 }
12365
12366
12367 }
12368
12369 }
12370 catch (RecognitionException re) {
12371 reportError(re);
12372 recover(input,re);
12373 }
12374 finally {
12375
12376 restoreStackSize(stackSize);
12377
12378 }
12379 return ;
12380 }
12381 // $ANTLR end "rule__Constraint__Group_2_1__3__Impl"
12382
12383
12384 // $ANTLR start "rule__Constraint__Group_2_1__4"
12385 // InternalSolverLanguage.g:3983:1: rule__Constraint__Group_2_1__4 : rule__Constraint__Group_2_1__4__Impl ;
12386 public final void rule__Constraint__Group_2_1__4() throws RecognitionException {
12387
12388 int stackSize = keepStackSize();
12389
12390 try {
12391 // InternalSolverLanguage.g:3987:1: ( rule__Constraint__Group_2_1__4__Impl )
12392 // InternalSolverLanguage.g:3988:2: rule__Constraint__Group_2_1__4__Impl
12393 {
12394 pushFollow(FOLLOW_2);
12395 rule__Constraint__Group_2_1__4__Impl();
12396
12397 state._fsp--;
12398
12399
12400 }
12401
12402 }
12403 catch (RecognitionException re) {
12404 reportError(re);
12405 recover(input,re);
12406 }
12407 finally {
12408
12409 restoreStackSize(stackSize);
12410
12411 }
12412 return ;
12413 }
12414 // $ANTLR end "rule__Constraint__Group_2_1__4"
12415
12416
12417 // $ANTLR start "rule__Constraint__Group_2_1__4__Impl"
12418 // InternalSolverLanguage.g:3994:1: rule__Constraint__Group_2_1__4__Impl : ( ')' ) ;
12419 public final void rule__Constraint__Group_2_1__4__Impl() throws RecognitionException {
12420
12421 int stackSize = keepStackSize();
12422
12423 try {
12424 // InternalSolverLanguage.g:3998:1: ( ( ')' ) )
12425 // InternalSolverLanguage.g:3999:1: ( ')' )
12426 {
12427 // InternalSolverLanguage.g:3999:1: ( ')' )
12428 // InternalSolverLanguage.g:4000:2: ')'
12429 {
12430 before(grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_1_4());
12431 match(input,18,FOLLOW_2);
12432 after(grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_1_4());
12433
12434 }
12435
12436
12437 }
12438
12439 }
12440 catch (RecognitionException re) {
12441 reportError(re);
12442 recover(input,re);
12443 }
12444 finally {
12445
12446 restoreStackSize(stackSize);
12447
12448 }
12449 return ;
12450 }
12451 // $ANTLR end "rule__Constraint__Group_2_1__4__Impl"
12452
12453
12454 // $ANTLR start "rule__ClosureType__Group_0__0"
12455 // InternalSolverLanguage.g:4010:1: rule__ClosureType__Group_0__0 : rule__ClosureType__Group_0__0__Impl rule__ClosureType__Group_0__1 ;
12456 public final void rule__ClosureType__Group_0__0() throws RecognitionException {
12457
12458 int stackSize = keepStackSize();
12459
12460 try {
12461 // InternalSolverLanguage.g:4014:1: ( rule__ClosureType__Group_0__0__Impl rule__ClosureType__Group_0__1 )
12462 // InternalSolverLanguage.g:4015:2: rule__ClosureType__Group_0__0__Impl rule__ClosureType__Group_0__1
12463 {
12464 pushFollow(FOLLOW_34);
12465 rule__ClosureType__Group_0__0__Impl();
12466
12467 state._fsp--;
12468
12469 pushFollow(FOLLOW_2);
12470 rule__ClosureType__Group_0__1();
12471
12472 state._fsp--;
12473
12474
12475 }
12476
12477 }
12478 catch (RecognitionException re) {
12479 reportError(re);
12480 recover(input,re);
12481 }
12482 finally {
12483
12484 restoreStackSize(stackSize);
12485
12486 }
12487 return ;
12488 }
12489 // $ANTLR end "rule__ClosureType__Group_0__0"
12490
12491
12492 // $ANTLR start "rule__ClosureType__Group_0__0__Impl"
12493 // InternalSolverLanguage.g:4022:1: rule__ClosureType__Group_0__0__Impl : ( () ) ;
12494 public final void rule__ClosureType__Group_0__0__Impl() throws RecognitionException {
12495
12496 int stackSize = keepStackSize();
12497
12498 try {
12499 // InternalSolverLanguage.g:4026:1: ( ( () ) )
12500 // InternalSolverLanguage.g:4027:1: ( () )
12501 {
12502 // InternalSolverLanguage.g:4027:1: ( () )
12503 // InternalSolverLanguage.g:4028:2: ()
12504 {
12505 before(grammarAccess.getClosureTypeAccess().getReflexiveClosureAction_0_0());
12506 // InternalSolverLanguage.g:4029:2: ()
12507 // InternalSolverLanguage.g:4029:3:
12508 {
12509 }
12510
12511 after(grammarAccess.getClosureTypeAccess().getReflexiveClosureAction_0_0());
12512
12513 }
12514
12515
12516 }
12517
12518 }
12519 finally {
12520
12521 restoreStackSize(stackSize);
12522
12523 }
12524 return ;
12525 }
12526 // $ANTLR end "rule__ClosureType__Group_0__0__Impl"
12527
12528
12529 // $ANTLR start "rule__ClosureType__Group_0__1"
12530 // InternalSolverLanguage.g:4037:1: rule__ClosureType__Group_0__1 : rule__ClosureType__Group_0__1__Impl ;
12531 public final void rule__ClosureType__Group_0__1() throws RecognitionException {
12532
12533 int stackSize = keepStackSize();
12534
12535 try {
12536 // InternalSolverLanguage.g:4041:1: ( rule__ClosureType__Group_0__1__Impl )
12537 // InternalSolverLanguage.g:4042:2: rule__ClosureType__Group_0__1__Impl
12538 {
12539 pushFollow(FOLLOW_2);
12540 rule__ClosureType__Group_0__1__Impl();
12541
12542 state._fsp--;
12543
12544
12545 }
12546
12547 }
12548 catch (RecognitionException re) {
12549 reportError(re);
12550 recover(input,re);
12551 }
12552 finally {
12553
12554 restoreStackSize(stackSize);
12555
12556 }
12557 return ;
12558 }
12559 // $ANTLR end "rule__ClosureType__Group_0__1"
12560
12561
12562 // $ANTLR start "rule__ClosureType__Group_0__1__Impl"
12563 // InternalSolverLanguage.g:4048:1: rule__ClosureType__Group_0__1__Impl : ( '*' ) ;
12564 public final void rule__ClosureType__Group_0__1__Impl() throws RecognitionException {
12565
12566 int stackSize = keepStackSize();
12567
12568 try {
12569 // InternalSolverLanguage.g:4052:1: ( ( '*' ) )
12570 // InternalSolverLanguage.g:4053:1: ( '*' )
12571 {
12572 // InternalSolverLanguage.g:4053:1: ( '*' )
12573 // InternalSolverLanguage.g:4054:2: '*'
12574 {
12575 before(grammarAccess.getClosureTypeAccess().getAsteriskKeyword_0_1());
12576 match(input,30,FOLLOW_2);
12577 after(grammarAccess.getClosureTypeAccess().getAsteriskKeyword_0_1());
12578
12579 }
12580
12581
12582 }
12583
12584 }
12585 catch (RecognitionException re) {
12586 reportError(re);
12587 recover(input,re);
12588 }
12589 finally {
12590
12591 restoreStackSize(stackSize);
12592
12593 }
12594 return ;
12595 }
12596 // $ANTLR end "rule__ClosureType__Group_0__1__Impl"
12597
12598
12599 // $ANTLR start "rule__ClosureType__Group_1__0"
12600 // InternalSolverLanguage.g:4064:1: rule__ClosureType__Group_1__0 : rule__ClosureType__Group_1__0__Impl rule__ClosureType__Group_1__1 ;
12601 public final void rule__ClosureType__Group_1__0() throws RecognitionException {
12602
12603 int stackSize = keepStackSize();
12604
12605 try {
12606 // InternalSolverLanguage.g:4068:1: ( rule__ClosureType__Group_1__0__Impl rule__ClosureType__Group_1__1 )
12607 // InternalSolverLanguage.g:4069:2: rule__ClosureType__Group_1__0__Impl rule__ClosureType__Group_1__1
12608 {
12609 pushFollow(FOLLOW_29);
12610 rule__ClosureType__Group_1__0__Impl();
12611
12612 state._fsp--;
12613
12614 pushFollow(FOLLOW_2);
12615 rule__ClosureType__Group_1__1();
12616
12617 state._fsp--;
12618
12619
12620 }
12621
12622 }
12623 catch (RecognitionException re) {
12624 reportError(re);
12625 recover(input,re);
12626 }
12627 finally {
12628
12629 restoreStackSize(stackSize);
12630
12631 }
12632 return ;
12633 }
12634 // $ANTLR end "rule__ClosureType__Group_1__0"
12635
12636
12637 // $ANTLR start "rule__ClosureType__Group_1__0__Impl"
12638 // InternalSolverLanguage.g:4076:1: rule__ClosureType__Group_1__0__Impl : ( () ) ;
12639 public final void rule__ClosureType__Group_1__0__Impl() throws RecognitionException {
12640
12641 int stackSize = keepStackSize();
12642
12643 try {
12644 // InternalSolverLanguage.g:4080:1: ( ( () ) )
12645 // InternalSolverLanguage.g:4081:1: ( () )
12646 {
12647 // InternalSolverLanguage.g:4081:1: ( () )
12648 // InternalSolverLanguage.g:4082:2: ()
12649 {
12650 before(grammarAccess.getClosureTypeAccess().getIrreflexiveClosureAction_1_0());
12651 // InternalSolverLanguage.g:4083:2: ()
12652 // InternalSolverLanguage.g:4083:3:
12653 {
12654 }
12655
12656 after(grammarAccess.getClosureTypeAccess().getIrreflexiveClosureAction_1_0());
12657
12658 }
12659
12660
12661 }
12662
12663 }
12664 finally {
12665
12666 restoreStackSize(stackSize);
12667
12668 }
12669 return ;
12670 }
12671 // $ANTLR end "rule__ClosureType__Group_1__0__Impl"
12672
12673
12674 // $ANTLR start "rule__ClosureType__Group_1__1"
12675 // InternalSolverLanguage.g:4091:1: rule__ClosureType__Group_1__1 : rule__ClosureType__Group_1__1__Impl ;
12676 public final void rule__ClosureType__Group_1__1() throws RecognitionException {
12677
12678 int stackSize = keepStackSize();
12679
12680 try {
12681 // InternalSolverLanguage.g:4095:1: ( rule__ClosureType__Group_1__1__Impl )
12682 // InternalSolverLanguage.g:4096:2: rule__ClosureType__Group_1__1__Impl
12683 {
12684 pushFollow(FOLLOW_2);
12685 rule__ClosureType__Group_1__1__Impl();
12686
12687 state._fsp--;
12688
12689
12690 }
12691
12692 }
12693 catch (RecognitionException re) {
12694 reportError(re);
12695 recover(input,re);
12696 }
12697 finally {
12698
12699 restoreStackSize(stackSize);
12700
12701 }
12702 return ;
12703 }
12704 // $ANTLR end "rule__ClosureType__Group_1__1"
12705
12706
12707 // $ANTLR start "rule__ClosureType__Group_1__1__Impl"
12708 // InternalSolverLanguage.g:4102:1: rule__ClosureType__Group_1__1__Impl : ( '+' ) ;
12709 public final void rule__ClosureType__Group_1__1__Impl() throws RecognitionException {
12710
12711 int stackSize = keepStackSize();
12712
12713 try {
12714 // InternalSolverLanguage.g:4106:1: ( ( '+' ) )
12715 // InternalSolverLanguage.g:4107:1: ( '+' )
12716 {
12717 // InternalSolverLanguage.g:4107:1: ( '+' )
12718 // InternalSolverLanguage.g:4108:2: '+'
12719 {
12720 before(grammarAccess.getClosureTypeAccess().getPlusSignKeyword_1_1());
12721 match(input,29,FOLLOW_2);
12722 after(grammarAccess.getClosureTypeAccess().getPlusSignKeyword_1_1());
12723
12724 }
12725
12726
12727 }
12728
12729 }
12730 catch (RecognitionException re) {
12731 reportError(re);
12732 recover(input,re);
12733 }
12734 finally {
12735
12736 restoreStackSize(stackSize);
12737
12738 }
12739 return ;
12740 }
12741 // $ANTLR end "rule__ClosureType__Group_1__1__Impl"
12742
12743
12744 // $ANTLR start "rule__AllInstances__Group__0"
12745 // InternalSolverLanguage.g:4118:1: rule__AllInstances__Group__0 : rule__AllInstances__Group__0__Impl rule__AllInstances__Group__1 ;
12746 public final void rule__AllInstances__Group__0() throws RecognitionException {
12747
12748 int stackSize = keepStackSize();
12749
12750 try {
12751 // InternalSolverLanguage.g:4122:1: ( rule__AllInstances__Group__0__Impl rule__AllInstances__Group__1 )
12752 // InternalSolverLanguage.g:4123:2: rule__AllInstances__Group__0__Impl rule__AllInstances__Group__1
12753 {
12754 pushFollow(FOLLOW_25);
12755 rule__AllInstances__Group__0__Impl();
12756
12757 state._fsp--;
12758
12759 pushFollow(FOLLOW_2);
12760 rule__AllInstances__Group__1();
12761
12762 state._fsp--;
12763
12764
12765 }
12766
12767 }
12768 catch (RecognitionException re) {
12769 reportError(re);
12770 recover(input,re);
12771 }
12772 finally {
12773
12774 restoreStackSize(stackSize);
12775
12776 }
12777 return ;
12778 }
12779 // $ANTLR end "rule__AllInstances__Group__0"
12780
12781
12782 // $ANTLR start "rule__AllInstances__Group__0__Impl"
12783 // InternalSolverLanguage.g:4130:1: rule__AllInstances__Group__0__Impl : ( ':' ) ;
12784 public final void rule__AllInstances__Group__0__Impl() throws RecognitionException {
12785
12786 int stackSize = keepStackSize();
12787
12788 try {
12789 // InternalSolverLanguage.g:4134:1: ( ( ':' ) )
12790 // InternalSolverLanguage.g:4135:1: ( ':' )
12791 {
12792 // InternalSolverLanguage.g:4135:1: ( ':' )
12793 // InternalSolverLanguage.g:4136:2: ':'
12794 {
12795 before(grammarAccess.getAllInstancesAccess().getColonKeyword_0());
12796 match(input,19,FOLLOW_2);
12797 after(grammarAccess.getAllInstancesAccess().getColonKeyword_0());
12798
12799 }
12800
12801
12802 }
12803
12804 }
12805 catch (RecognitionException re) {
12806 reportError(re);
12807 recover(input,re);
12808 }
12809 finally {
12810
12811 restoreStackSize(stackSize);
12812
12813 }
12814 return ;
12815 }
12816 // $ANTLR end "rule__AllInstances__Group__0__Impl"
12817
12818
12819 // $ANTLR start "rule__AllInstances__Group__1"
12820 // InternalSolverLanguage.g:4145:1: rule__AllInstances__Group__1 : rule__AllInstances__Group__1__Impl ;
12821 public final void rule__AllInstances__Group__1() throws RecognitionException {
12822
12823 int stackSize = keepStackSize();
12824
12825 try {
12826 // InternalSolverLanguage.g:4149:1: ( rule__AllInstances__Group__1__Impl )
12827 // InternalSolverLanguage.g:4150:2: rule__AllInstances__Group__1__Impl
12828 {
12829 pushFollow(FOLLOW_2);
12830 rule__AllInstances__Group__1__Impl();
12831
12832 state._fsp--;
12833
12834
12835 }
12836
12837 }
12838 catch (RecognitionException re) {
12839 reportError(re);
12840 recover(input,re);
12841 }
12842 finally {
12843
12844 restoreStackSize(stackSize);
12845
12846 }
12847 return ;
12848 }
12849 // $ANTLR end "rule__AllInstances__Group__1"
12850
12851
12852 // $ANTLR start "rule__AllInstances__Group__1__Impl"
12853 // InternalSolverLanguage.g:4156:1: rule__AllInstances__Group__1__Impl : ( ( rule__AllInstances__SymbolAssignment_1 ) ) ;
12854 public final void rule__AllInstances__Group__1__Impl() throws RecognitionException {
12855
12856 int stackSize = keepStackSize();
12857
12858 try {
12859 // InternalSolverLanguage.g:4160:1: ( ( ( rule__AllInstances__SymbolAssignment_1 ) ) )
12860 // InternalSolverLanguage.g:4161:1: ( ( rule__AllInstances__SymbolAssignment_1 ) )
12861 {
12862 // InternalSolverLanguage.g:4161:1: ( ( rule__AllInstances__SymbolAssignment_1 ) )
12863 // InternalSolverLanguage.g:4162:2: ( rule__AllInstances__SymbolAssignment_1 )
12864 {
12865 before(grammarAccess.getAllInstancesAccess().getSymbolAssignment_1());
12866 // InternalSolverLanguage.g:4163:2: ( rule__AllInstances__SymbolAssignment_1 )
12867 // InternalSolverLanguage.g:4163:3: rule__AllInstances__SymbolAssignment_1
12868 {
12869 pushFollow(FOLLOW_2);
12870 rule__AllInstances__SymbolAssignment_1();
12871
12872 state._fsp--;
12873
12874
12875 }
12876
12877 after(grammarAccess.getAllInstancesAccess().getSymbolAssignment_1());
12878
12879 }
12880
12881
12882 }
12883
12884 }
12885 catch (RecognitionException re) {
12886 reportError(re);
12887 recover(input,re);
12888 }
12889 finally {
12890
12891 restoreStackSize(stackSize);
12892
12893 }
12894 return ;
12895 }
12896 // $ANTLR end "rule__AllInstances__Group__1__Impl"
12897
12898
12899 // $ANTLR start "rule__AllObjects__Group__0"
12900 // InternalSolverLanguage.g:4172:1: rule__AllObjects__Group__0 : rule__AllObjects__Group__0__Impl rule__AllObjects__Group__1 ;
12901 public final void rule__AllObjects__Group__0() throws RecognitionException {
12902
12903 int stackSize = keepStackSize();
12904
12905 try {
12906 // InternalSolverLanguage.g:4176:1: ( rule__AllObjects__Group__0__Impl rule__AllObjects__Group__1 )
12907 // InternalSolverLanguage.g:4177:2: rule__AllObjects__Group__0__Impl rule__AllObjects__Group__1
12908 {
12909 pushFollow(FOLLOW_35);
12910 rule__AllObjects__Group__0__Impl();
12911
12912 state._fsp--;
12913
12914 pushFollow(FOLLOW_2);
12915 rule__AllObjects__Group__1();
12916
12917 state._fsp--;
12918
12919
12920 }
12921
12922 }
12923 catch (RecognitionException re) {
12924 reportError(re);
12925 recover(input,re);
12926 }
12927 finally {
12928
12929 restoreStackSize(stackSize);
12930
12931 }
12932 return ;
12933 }
12934 // $ANTLR end "rule__AllObjects__Group__0"
12935
12936
12937 // $ANTLR start "rule__AllObjects__Group__0__Impl"
12938 // InternalSolverLanguage.g:4184:1: rule__AllObjects__Group__0__Impl : ( () ) ;
12939 public final void rule__AllObjects__Group__0__Impl() throws RecognitionException {
12940
12941 int stackSize = keepStackSize();
12942
12943 try {
12944 // InternalSolverLanguage.g:4188:1: ( ( () ) )
12945 // InternalSolverLanguage.g:4189:1: ( () )
12946 {
12947 // InternalSolverLanguage.g:4189:1: ( () )
12948 // InternalSolverLanguage.g:4190:2: ()
12949 {
12950 before(grammarAccess.getAllObjectsAccess().getAllObjectsAction_0());
12951 // InternalSolverLanguage.g:4191:2: ()
12952 // InternalSolverLanguage.g:4191:3:
12953 {
12954 }
12955
12956 after(grammarAccess.getAllObjectsAccess().getAllObjectsAction_0());
12957
12958 }
12959
12960
12961 }
12962
12963 }
12964 finally {
12965
12966 restoreStackSize(stackSize);
12967
12968 }
12969 return ;
12970 }
12971 // $ANTLR end "rule__AllObjects__Group__0__Impl"
12972
12973
12974 // $ANTLR start "rule__AllObjects__Group__1"
12975 // InternalSolverLanguage.g:4199:1: rule__AllObjects__Group__1 : rule__AllObjects__Group__1__Impl ;
12976 public final void rule__AllObjects__Group__1() throws RecognitionException {
12977
12978 int stackSize = keepStackSize();
12979
12980 try {
12981 // InternalSolverLanguage.g:4203:1: ( rule__AllObjects__Group__1__Impl )
12982 // InternalSolverLanguage.g:4204:2: rule__AllObjects__Group__1__Impl
12983 {
12984 pushFollow(FOLLOW_2);
12985 rule__AllObjects__Group__1__Impl();
12986
12987 state._fsp--;
12988
12989
12990 }
12991
12992 }
12993 catch (RecognitionException re) {
12994 reportError(re);
12995 recover(input,re);
12996 }
12997 finally {
12998
12999 restoreStackSize(stackSize);
13000
13001 }
13002 return ;
13003 }
13004 // $ANTLR end "rule__AllObjects__Group__1"
13005
13006
13007 // $ANTLR start "rule__AllObjects__Group__1__Impl"
13008 // InternalSolverLanguage.g:4210:1: rule__AllObjects__Group__1__Impl : ( '*' ) ;
13009 public final void rule__AllObjects__Group__1__Impl() throws RecognitionException {
13010
13011 int stackSize = keepStackSize();
13012
13013 try {
13014 // InternalSolverLanguage.g:4214:1: ( ( '*' ) )
13015 // InternalSolverLanguage.g:4215:1: ( '*' )
13016 {
13017 // InternalSolverLanguage.g:4215:1: ( '*' )
13018 // InternalSolverLanguage.g:4216:2: '*'
13019 {
13020 before(grammarAccess.getAllObjectsAccess().getAsteriskKeyword_1());
13021 match(input,30,FOLLOW_2);
13022 after(grammarAccess.getAllObjectsAccess().getAsteriskKeyword_1());
13023
13024 }
13025
13026
13027 }
13028
13029 }
13030 catch (RecognitionException re) {
13031 reportError(re);
13032 recover(input,re);
13033 }
13034 finally {
13035
13036 restoreStackSize(stackSize);
13037
13038 }
13039 return ;
13040 }
13041 // $ANTLR end "rule__AllObjects__Group__1__Impl"
13042
13043
13044 // $ANTLR start "rule__DefaultInterpretation__Group__0"
13045 // InternalSolverLanguage.g:4226:1: rule__DefaultInterpretation__Group__0 : rule__DefaultInterpretation__Group__0__Impl rule__DefaultInterpretation__Group__1 ;
13046 public final void rule__DefaultInterpretation__Group__0() throws RecognitionException {
13047
13048 int stackSize = keepStackSize();
13049
13050 try {
13051 // InternalSolverLanguage.g:4230:1: ( rule__DefaultInterpretation__Group__0__Impl rule__DefaultInterpretation__Group__1 )
13052 // InternalSolverLanguage.g:4231:2: rule__DefaultInterpretation__Group__0__Impl rule__DefaultInterpretation__Group__1
13053 {
13054 pushFollow(FOLLOW_25);
13055 rule__DefaultInterpretation__Group__0__Impl();
13056
13057 state._fsp--;
13058
13059 pushFollow(FOLLOW_2);
13060 rule__DefaultInterpretation__Group__1();
13061
13062 state._fsp--;
13063
13064
13065 }
13066
13067 }
13068 catch (RecognitionException re) {
13069 reportError(re);
13070 recover(input,re);
13071 }
13072 finally {
13073
13074 restoreStackSize(stackSize);
13075
13076 }
13077 return ;
13078 }
13079 // $ANTLR end "rule__DefaultInterpretation__Group__0"
13080
13081
13082 // $ANTLR start "rule__DefaultInterpretation__Group__0__Impl"
13083 // InternalSolverLanguage.g:4238:1: rule__DefaultInterpretation__Group__0__Impl : ( 'default' ) ;
13084 public final void rule__DefaultInterpretation__Group__0__Impl() throws RecognitionException {
13085
13086 int stackSize = keepStackSize();
13087
13088 try {
13089 // InternalSolverLanguage.g:4242:1: ( ( 'default' ) )
13090 // InternalSolverLanguage.g:4243:1: ( 'default' )
13091 {
13092 // InternalSolverLanguage.g:4243:1: ( 'default' )
13093 // InternalSolverLanguage.g:4244:2: 'default'
13094 {
13095 before(grammarAccess.getDefaultInterpretationAccess().getDefaultKeyword_0());
13096 match(input,31,FOLLOW_2);
13097 after(grammarAccess.getDefaultInterpretationAccess().getDefaultKeyword_0());
13098
13099 }
13100
13101
13102 }
13103
13104 }
13105 catch (RecognitionException re) {
13106 reportError(re);
13107 recover(input,re);
13108 }
13109 finally {
13110
13111 restoreStackSize(stackSize);
13112
13113 }
13114 return ;
13115 }
13116 // $ANTLR end "rule__DefaultInterpretation__Group__0__Impl"
13117
13118
13119 // $ANTLR start "rule__DefaultInterpretation__Group__1"
13120 // InternalSolverLanguage.g:4253:1: rule__DefaultInterpretation__Group__1 : rule__DefaultInterpretation__Group__1__Impl ;
13121 public final void rule__DefaultInterpretation__Group__1() throws RecognitionException {
13122
13123 int stackSize = keepStackSize();
13124
13125 try {
13126 // InternalSolverLanguage.g:4257:1: ( rule__DefaultInterpretation__Group__1__Impl )
13127 // InternalSolverLanguage.g:4258:2: rule__DefaultInterpretation__Group__1__Impl
13128 {
13129 pushFollow(FOLLOW_2);
13130 rule__DefaultInterpretation__Group__1__Impl();
13131
13132 state._fsp--;
13133
13134
13135 }
13136
13137 }
13138 catch (RecognitionException re) {
13139 reportError(re);
13140 recover(input,re);
13141 }
13142 finally {
13143
13144 restoreStackSize(stackSize);
13145
13146 }
13147 return ;
13148 }
13149 // $ANTLR end "rule__DefaultInterpretation__Group__1"
13150
13151
13152 // $ANTLR start "rule__DefaultInterpretation__Group__1__Impl"
13153 // InternalSolverLanguage.g:4264:1: rule__DefaultInterpretation__Group__1__Impl : ( ( rule__DefaultInterpretation__InterpretationAssignment_1 ) ) ;
13154 public final void rule__DefaultInterpretation__Group__1__Impl() throws RecognitionException {
13155
13156 int stackSize = keepStackSize();
13157
13158 try {
13159 // InternalSolverLanguage.g:4268:1: ( ( ( rule__DefaultInterpretation__InterpretationAssignment_1 ) ) )
13160 // InternalSolverLanguage.g:4269:1: ( ( rule__DefaultInterpretation__InterpretationAssignment_1 ) )
13161 {
13162 // InternalSolverLanguage.g:4269:1: ( ( rule__DefaultInterpretation__InterpretationAssignment_1 ) )
13163 // InternalSolverLanguage.g:4270:2: ( rule__DefaultInterpretation__InterpretationAssignment_1 )
13164 {
13165 before(grammarAccess.getDefaultInterpretationAccess().getInterpretationAssignment_1());
13166 // InternalSolverLanguage.g:4271:2: ( rule__DefaultInterpretation__InterpretationAssignment_1 )
13167 // InternalSolverLanguage.g:4271:3: rule__DefaultInterpretation__InterpretationAssignment_1
13168 {
13169 pushFollow(FOLLOW_2);
13170 rule__DefaultInterpretation__InterpretationAssignment_1();
13171
13172 state._fsp--;
13173
13174
13175 }
13176
13177 after(grammarAccess.getDefaultInterpretationAccess().getInterpretationAssignment_1());
13178
13179 }
13180
13181
13182 }
13183
13184 }
13185 catch (RecognitionException re) {
13186 reportError(re);
13187 recover(input,re);
13188 }
13189 finally {
13190
13191 restoreStackSize(stackSize);
13192
13193 }
13194 return ;
13195 }
13196 // $ANTLR end "rule__DefaultInterpretation__Group__1__Impl"
13197
13198
13199 // $ANTLR start "rule__ClassInterpretation__Group__0"
13200 // InternalSolverLanguage.g:4280:1: rule__ClassInterpretation__Group__0 : rule__ClassInterpretation__Group__0__Impl rule__ClassInterpretation__Group__1 ;
13201 public final void rule__ClassInterpretation__Group__0() throws RecognitionException {
13202
13203 int stackSize = keepStackSize();
13204
13205 try {
13206 // InternalSolverLanguage.g:4284:1: ( rule__ClassInterpretation__Group__0__Impl rule__ClassInterpretation__Group__1 )
13207 // InternalSolverLanguage.g:4285:2: rule__ClassInterpretation__Group__0__Impl rule__ClassInterpretation__Group__1
13208 {
13209 pushFollow(FOLLOW_36);
13210 rule__ClassInterpretation__Group__0__Impl();
13211
13212 state._fsp--;
13213
13214 pushFollow(FOLLOW_2);
13215 rule__ClassInterpretation__Group__1();
13216
13217 state._fsp--;
13218
13219
13220 }
13221
13222 }
13223 catch (RecognitionException re) {
13224 reportError(re);
13225 recover(input,re);
13226 }
13227 finally {
13228
13229 restoreStackSize(stackSize);
13230
13231 }
13232 return ;
13233 }
13234 // $ANTLR end "rule__ClassInterpretation__Group__0"
13235
13236
13237 // $ANTLR start "rule__ClassInterpretation__Group__0__Impl"
13238 // InternalSolverLanguage.g:4292:1: rule__ClassInterpretation__Group__0__Impl : ( ( rule__ClassInterpretation__AbstractAssignment_0 ) ) ;
13239 public final void rule__ClassInterpretation__Group__0__Impl() throws RecognitionException {
13240
13241 int stackSize = keepStackSize();
13242
13243 try {
13244 // InternalSolverLanguage.g:4296:1: ( ( ( rule__ClassInterpretation__AbstractAssignment_0 ) ) )
13245 // InternalSolverLanguage.g:4297:1: ( ( rule__ClassInterpretation__AbstractAssignment_0 ) )
13246 {
13247 // InternalSolverLanguage.g:4297:1: ( ( rule__ClassInterpretation__AbstractAssignment_0 ) )
13248 // InternalSolverLanguage.g:4298:2: ( rule__ClassInterpretation__AbstractAssignment_0 )
13249 {
13250 before(grammarAccess.getClassInterpretationAccess().getAbstractAssignment_0());
13251 // InternalSolverLanguage.g:4299:2: ( rule__ClassInterpretation__AbstractAssignment_0 )
13252 // InternalSolverLanguage.g:4299:3: rule__ClassInterpretation__AbstractAssignment_0
13253 {
13254 pushFollow(FOLLOW_2);
13255 rule__ClassInterpretation__AbstractAssignment_0();
13256
13257 state._fsp--;
13258
13259
13260 }
13261
13262 after(grammarAccess.getClassInterpretationAccess().getAbstractAssignment_0());
13263
13264 }
13265
13266
13267 }
13268
13269 }
13270 catch (RecognitionException re) {
13271 reportError(re);
13272 recover(input,re);
13273 }
13274 finally {
13275
13276 restoreStackSize(stackSize);
13277
13278 }
13279 return ;
13280 }
13281 // $ANTLR end "rule__ClassInterpretation__Group__0__Impl"
13282
13283
13284 // $ANTLR start "rule__ClassInterpretation__Group__1"
13285 // InternalSolverLanguage.g:4307:1: rule__ClassInterpretation__Group__1 : rule__ClassInterpretation__Group__1__Impl rule__ClassInterpretation__Group__2 ;
13286 public final void rule__ClassInterpretation__Group__1() throws RecognitionException {
13287
13288 int stackSize = keepStackSize();
13289
13290 try {
13291 // InternalSolverLanguage.g:4311:1: ( rule__ClassInterpretation__Group__1__Impl rule__ClassInterpretation__Group__2 )
13292 // InternalSolverLanguage.g:4312:2: rule__ClassInterpretation__Group__1__Impl rule__ClassInterpretation__Group__2
13293 {
13294 pushFollow(FOLLOW_16);
13295 rule__ClassInterpretation__Group__1__Impl();
13296
13297 state._fsp--;
13298
13299 pushFollow(FOLLOW_2);
13300 rule__ClassInterpretation__Group__2();
13301
13302 state._fsp--;
13303
13304
13305 }
13306
13307 }
13308 catch (RecognitionException re) {
13309 reportError(re);
13310 recover(input,re);
13311 }
13312 finally {
13313
13314 restoreStackSize(stackSize);
13315
13316 }
13317 return ;
13318 }
13319 // $ANTLR end "rule__ClassInterpretation__Group__1"
13320
13321
13322 // $ANTLR start "rule__ClassInterpretation__Group__1__Impl"
13323 // InternalSolverLanguage.g:4319:1: rule__ClassInterpretation__Group__1__Impl : ( 'class' ) ;
13324 public final void rule__ClassInterpretation__Group__1__Impl() throws RecognitionException {
13325
13326 int stackSize = keepStackSize();
13327
13328 try {
13329 // InternalSolverLanguage.g:4323:1: ( ( 'class' ) )
13330 // InternalSolverLanguage.g:4324:1: ( 'class' )
13331 {
13332 // InternalSolverLanguage.g:4324:1: ( 'class' )
13333 // InternalSolverLanguage.g:4325:2: 'class'
13334 {
13335 before(grammarAccess.getClassInterpretationAccess().getClassKeyword_1());
13336 match(input,32,FOLLOW_2);
13337 after(grammarAccess.getClassInterpretationAccess().getClassKeyword_1());
13338
13339 }
13340
13341
13342 }
13343
13344 }
13345 catch (RecognitionException re) {
13346 reportError(re);
13347 recover(input,re);
13348 }
13349 finally {
13350
13351 restoreStackSize(stackSize);
13352
13353 }
13354 return ;
13355 }
13356 // $ANTLR end "rule__ClassInterpretation__Group__1__Impl"
13357
13358
13359 // $ANTLR start "rule__ClassInterpretation__Group__2"
13360 // InternalSolverLanguage.g:4334:1: rule__ClassInterpretation__Group__2 : rule__ClassInterpretation__Group__2__Impl rule__ClassInterpretation__Group__3 ;
13361 public final void rule__ClassInterpretation__Group__2() throws RecognitionException {
13362
13363 int stackSize = keepStackSize();
13364
13365 try {
13366 // InternalSolverLanguage.g:4338:1: ( rule__ClassInterpretation__Group__2__Impl rule__ClassInterpretation__Group__3 )
13367 // InternalSolverLanguage.g:4339:2: rule__ClassInterpretation__Group__2__Impl rule__ClassInterpretation__Group__3
13368 {
13369 pushFollow(FOLLOW_37);
13370 rule__ClassInterpretation__Group__2__Impl();
13371
13372 state._fsp--;
13373
13374 pushFollow(FOLLOW_2);
13375 rule__ClassInterpretation__Group__3();
13376
13377 state._fsp--;
13378
13379
13380 }
13381
13382 }
13383 catch (RecognitionException re) {
13384 reportError(re);
13385 recover(input,re);
13386 }
13387 finally {
13388
13389 restoreStackSize(stackSize);
13390
13391 }
13392 return ;
13393 }
13394 // $ANTLR end "rule__ClassInterpretation__Group__2"
13395
13396
13397 // $ANTLR start "rule__ClassInterpretation__Group__2__Impl"
13398 // InternalSolverLanguage.g:4346:1: rule__ClassInterpretation__Group__2__Impl : ( ( rule__ClassInterpretation__SymbolAssignment_2 ) ) ;
13399 public final void rule__ClassInterpretation__Group__2__Impl() throws RecognitionException {
13400
13401 int stackSize = keepStackSize();
13402
13403 try {
13404 // InternalSolverLanguage.g:4350:1: ( ( ( rule__ClassInterpretation__SymbolAssignment_2 ) ) )
13405 // InternalSolverLanguage.g:4351:1: ( ( rule__ClassInterpretation__SymbolAssignment_2 ) )
13406 {
13407 // InternalSolverLanguage.g:4351:1: ( ( rule__ClassInterpretation__SymbolAssignment_2 ) )
13408 // InternalSolverLanguage.g:4352:2: ( rule__ClassInterpretation__SymbolAssignment_2 )
13409 {
13410 before(grammarAccess.getClassInterpretationAccess().getSymbolAssignment_2());
13411 // InternalSolverLanguage.g:4353:2: ( rule__ClassInterpretation__SymbolAssignment_2 )
13412 // InternalSolverLanguage.g:4353:3: rule__ClassInterpretation__SymbolAssignment_2
13413 {
13414 pushFollow(FOLLOW_2);
13415 rule__ClassInterpretation__SymbolAssignment_2();
13416
13417 state._fsp--;
13418
13419
13420 }
13421
13422 after(grammarAccess.getClassInterpretationAccess().getSymbolAssignment_2());
13423
13424 }
13425
13426
13427 }
13428
13429 }
13430 catch (RecognitionException re) {
13431 reportError(re);
13432 recover(input,re);
13433 }
13434 finally {
13435
13436 restoreStackSize(stackSize);
13437
13438 }
13439 return ;
13440 }
13441 // $ANTLR end "rule__ClassInterpretation__Group__2__Impl"
13442
13443
13444 // $ANTLR start "rule__ClassInterpretation__Group__3"
13445 // InternalSolverLanguage.g:4361:1: rule__ClassInterpretation__Group__3 : rule__ClassInterpretation__Group__3__Impl rule__ClassInterpretation__Group__4 ;
13446 public final void rule__ClassInterpretation__Group__3() throws RecognitionException {
13447
13448 int stackSize = keepStackSize();
13449
13450 try {
13451 // InternalSolverLanguage.g:4365:1: ( rule__ClassInterpretation__Group__3__Impl rule__ClassInterpretation__Group__4 )
13452 // InternalSolverLanguage.g:4366:2: rule__ClassInterpretation__Group__3__Impl rule__ClassInterpretation__Group__4
13453 {
13454 pushFollow(FOLLOW_37);
13455 rule__ClassInterpretation__Group__3__Impl();
13456
13457 state._fsp--;
13458
13459 pushFollow(FOLLOW_2);
13460 rule__ClassInterpretation__Group__4();
13461
13462 state._fsp--;
13463
13464
13465 }
13466
13467 }
13468 catch (RecognitionException re) {
13469 reportError(re);
13470 recover(input,re);
13471 }
13472 finally {
13473
13474 restoreStackSize(stackSize);
13475
13476 }
13477 return ;
13478 }
13479 // $ANTLR end "rule__ClassInterpretation__Group__3"
13480
13481
13482 // $ANTLR start "rule__ClassInterpretation__Group__3__Impl"
13483 // InternalSolverLanguage.g:4373:1: rule__ClassInterpretation__Group__3__Impl : ( ( rule__ClassInterpretation__Group_3__0 )? ) ;
13484 public final void rule__ClassInterpretation__Group__3__Impl() throws RecognitionException {
13485
13486 int stackSize = keepStackSize();
13487
13488 try {
13489 // InternalSolverLanguage.g:4377:1: ( ( ( rule__ClassInterpretation__Group_3__0 )? ) )
13490 // InternalSolverLanguage.g:4378:1: ( ( rule__ClassInterpretation__Group_3__0 )? )
13491 {
13492 // InternalSolverLanguage.g:4378:1: ( ( rule__ClassInterpretation__Group_3__0 )? )
13493 // InternalSolverLanguage.g:4379:2: ( rule__ClassInterpretation__Group_3__0 )?
13494 {
13495 before(grammarAccess.getClassInterpretationAccess().getGroup_3());
13496 // InternalSolverLanguage.g:4380:2: ( rule__ClassInterpretation__Group_3__0 )?
13497 int alt34=2;
13498 int LA34_0 = input.LA(1);
13499
13500 if ( (LA34_0==35) ) {
13501 alt34=1;
13502 }
13503 switch (alt34) {
13504 case 1 :
13505 // InternalSolverLanguage.g:4380:3: rule__ClassInterpretation__Group_3__0
13506 {
13507 pushFollow(FOLLOW_2);
13508 rule__ClassInterpretation__Group_3__0();
13509
13510 state._fsp--;
13511
13512
13513 }
13514 break;
13515
13516 }
13517
13518 after(grammarAccess.getClassInterpretationAccess().getGroup_3());
13519
13520 }
13521
13522
13523 }
13524
13525 }
13526 catch (RecognitionException re) {
13527 reportError(re);
13528 recover(input,re);
13529 }
13530 finally {
13531
13532 restoreStackSize(stackSize);
13533
13534 }
13535 return ;
13536 }
13537 // $ANTLR end "rule__ClassInterpretation__Group__3__Impl"
13538
13539
13540 // $ANTLR start "rule__ClassInterpretation__Group__4"
13541 // InternalSolverLanguage.g:4388:1: rule__ClassInterpretation__Group__4 : rule__ClassInterpretation__Group__4__Impl rule__ClassInterpretation__Group__5 ;
13542 public final void rule__ClassInterpretation__Group__4() throws RecognitionException {
13543
13544 int stackSize = keepStackSize();
13545
13546 try {
13547 // InternalSolverLanguage.g:4392:1: ( rule__ClassInterpretation__Group__4__Impl rule__ClassInterpretation__Group__5 )
13548 // InternalSolverLanguage.g:4393:2: rule__ClassInterpretation__Group__4__Impl rule__ClassInterpretation__Group__5
13549 {
13550 pushFollow(FOLLOW_38);
13551 rule__ClassInterpretation__Group__4__Impl();
13552
13553 state._fsp--;
13554
13555 pushFollow(FOLLOW_2);
13556 rule__ClassInterpretation__Group__5();
13557
13558 state._fsp--;
13559
13560
13561 }
13562
13563 }
13564 catch (RecognitionException re) {
13565 reportError(re);
13566 recover(input,re);
13567 }
13568 finally {
13569
13570 restoreStackSize(stackSize);
13571
13572 }
13573 return ;
13574 }
13575 // $ANTLR end "rule__ClassInterpretation__Group__4"
13576
13577
13578 // $ANTLR start "rule__ClassInterpretation__Group__4__Impl"
13579 // InternalSolverLanguage.g:4400:1: rule__ClassInterpretation__Group__4__Impl : ( '{' ) ;
13580 public final void rule__ClassInterpretation__Group__4__Impl() throws RecognitionException {
13581
13582 int stackSize = keepStackSize();
13583
13584 try {
13585 // InternalSolverLanguage.g:4404:1: ( ( '{' ) )
13586 // InternalSolverLanguage.g:4405:1: ( '{' )
13587 {
13588 // InternalSolverLanguage.g:4405:1: ( '{' )
13589 // InternalSolverLanguage.g:4406:2: '{'
13590 {
13591 before(grammarAccess.getClassInterpretationAccess().getLeftCurlyBracketKeyword_4());
13592 match(input,33,FOLLOW_2);
13593 after(grammarAccess.getClassInterpretationAccess().getLeftCurlyBracketKeyword_4());
13594
13595 }
13596
13597
13598 }
13599
13600 }
13601 catch (RecognitionException re) {
13602 reportError(re);
13603 recover(input,re);
13604 }
13605 finally {
13606
13607 restoreStackSize(stackSize);
13608
13609 }
13610 return ;
13611 }
13612 // $ANTLR end "rule__ClassInterpretation__Group__4__Impl"
13613
13614
13615 // $ANTLR start "rule__ClassInterpretation__Group__5"
13616 // InternalSolverLanguage.g:4415:1: rule__ClassInterpretation__Group__5 : rule__ClassInterpretation__Group__5__Impl rule__ClassInterpretation__Group__6 ;
13617 public final void rule__ClassInterpretation__Group__5() throws RecognitionException {
13618
13619 int stackSize = keepStackSize();
13620
13621 try {
13622 // InternalSolverLanguage.g:4419:1: ( rule__ClassInterpretation__Group__5__Impl rule__ClassInterpretation__Group__6 )
13623 // InternalSolverLanguage.g:4420:2: rule__ClassInterpretation__Group__5__Impl rule__ClassInterpretation__Group__6
13624 {
13625 pushFollow(FOLLOW_38);
13626 rule__ClassInterpretation__Group__5__Impl();
13627
13628 state._fsp--;
13629
13630 pushFollow(FOLLOW_2);
13631 rule__ClassInterpretation__Group__6();
13632
13633 state._fsp--;
13634
13635
13636 }
13637
13638 }
13639 catch (RecognitionException re) {
13640 reportError(re);
13641 recover(input,re);
13642 }
13643 finally {
13644
13645 restoreStackSize(stackSize);
13646
13647 }
13648 return ;
13649 }
13650 // $ANTLR end "rule__ClassInterpretation__Group__5"
13651
13652
13653 // $ANTLR start "rule__ClassInterpretation__Group__5__Impl"
13654 // InternalSolverLanguage.g:4427:1: rule__ClassInterpretation__Group__5__Impl : ( ( rule__ClassInterpretation__FieltAssignment_5 )* ) ;
13655 public final void rule__ClassInterpretation__Group__5__Impl() throws RecognitionException {
13656
13657 int stackSize = keepStackSize();
13658
13659 try {
13660 // InternalSolverLanguage.g:4431:1: ( ( ( rule__ClassInterpretation__FieltAssignment_5 )* ) )
13661 // InternalSolverLanguage.g:4432:1: ( ( rule__ClassInterpretation__FieltAssignment_5 )* )
13662 {
13663 // InternalSolverLanguage.g:4432:1: ( ( rule__ClassInterpretation__FieltAssignment_5 )* )
13664 // InternalSolverLanguage.g:4433:2: ( rule__ClassInterpretation__FieltAssignment_5 )*
13665 {
13666 before(grammarAccess.getClassInterpretationAccess().getFieltAssignment_5());
13667 // InternalSolverLanguage.g:4434:2: ( rule__ClassInterpretation__FieltAssignment_5 )*
13668 loop35:
13669 do {
13670 int alt35=2;
13671 int LA35_0 = input.LA(1);
13672
13673 if ( (LA35_0==40) ) {
13674 alt35=1;
13675 }
13676
13677
13678 switch (alt35) {
13679 case 1 :
13680 // InternalSolverLanguage.g:4434:3: rule__ClassInterpretation__FieltAssignment_5
13681 {
13682 pushFollow(FOLLOW_39);
13683 rule__ClassInterpretation__FieltAssignment_5();
13684
13685 state._fsp--;
13686
13687
13688 }
13689 break;
13690
13691 default :
13692 break loop35;
13693 }
13694 } while (true);
13695
13696 after(grammarAccess.getClassInterpretationAccess().getFieltAssignment_5());
13697
13698 }
13699
13700
13701 }
13702
13703 }
13704 catch (RecognitionException re) {
13705 reportError(re);
13706 recover(input,re);
13707 }
13708 finally {
13709
13710 restoreStackSize(stackSize);
13711
13712 }
13713 return ;
13714 }
13715 // $ANTLR end "rule__ClassInterpretation__Group__5__Impl"
13716
13717
13718 // $ANTLR start "rule__ClassInterpretation__Group__6"
13719 // InternalSolverLanguage.g:4442:1: rule__ClassInterpretation__Group__6 : rule__ClassInterpretation__Group__6__Impl ;
13720 public final void rule__ClassInterpretation__Group__6() throws RecognitionException {
13721
13722 int stackSize = keepStackSize();
13723
13724 try {
13725 // InternalSolverLanguage.g:4446:1: ( rule__ClassInterpretation__Group__6__Impl )
13726 // InternalSolverLanguage.g:4447:2: rule__ClassInterpretation__Group__6__Impl
13727 {
13728 pushFollow(FOLLOW_2);
13729 rule__ClassInterpretation__Group__6__Impl();
13730
13731 state._fsp--;
13732
13733
13734 }
13735
13736 }
13737 catch (RecognitionException re) {
13738 reportError(re);
13739 recover(input,re);
13740 }
13741 finally {
13742
13743 restoreStackSize(stackSize);
13744
13745 }
13746 return ;
13747 }
13748 // $ANTLR end "rule__ClassInterpretation__Group__6"
13749
13750
13751 // $ANTLR start "rule__ClassInterpretation__Group__6__Impl"
13752 // InternalSolverLanguage.g:4453:1: rule__ClassInterpretation__Group__6__Impl : ( '}' ) ;
13753 public final void rule__ClassInterpretation__Group__6__Impl() throws RecognitionException {
13754
13755 int stackSize = keepStackSize();
13756
13757 try {
13758 // InternalSolverLanguage.g:4457:1: ( ( '}' ) )
13759 // InternalSolverLanguage.g:4458:1: ( '}' )
13760 {
13761 // InternalSolverLanguage.g:4458:1: ( '}' )
13762 // InternalSolverLanguage.g:4459:2: '}'
13763 {
13764 before(grammarAccess.getClassInterpretationAccess().getRightCurlyBracketKeyword_6());
13765 match(input,34,FOLLOW_2);
13766 after(grammarAccess.getClassInterpretationAccess().getRightCurlyBracketKeyword_6());
13767
13768 }
13769
13770
13771 }
13772
13773 }
13774 catch (RecognitionException re) {
13775 reportError(re);
13776 recover(input,re);
13777 }
13778 finally {
13779
13780 restoreStackSize(stackSize);
13781
13782 }
13783 return ;
13784 }
13785 // $ANTLR end "rule__ClassInterpretation__Group__6__Impl"
13786
13787
13788 // $ANTLR start "rule__ClassInterpretation__Group_3__0"
13789 // InternalSolverLanguage.g:4469:1: rule__ClassInterpretation__Group_3__0 : rule__ClassInterpretation__Group_3__0__Impl rule__ClassInterpretation__Group_3__1 ;
13790 public final void rule__ClassInterpretation__Group_3__0() throws RecognitionException {
13791
13792 int stackSize = keepStackSize();
13793
13794 try {
13795 // InternalSolverLanguage.g:4473:1: ( rule__ClassInterpretation__Group_3__0__Impl rule__ClassInterpretation__Group_3__1 )
13796 // InternalSolverLanguage.g:4474:2: rule__ClassInterpretation__Group_3__0__Impl rule__ClassInterpretation__Group_3__1
13797 {
13798 pushFollow(FOLLOW_16);
13799 rule__ClassInterpretation__Group_3__0__Impl();
13800
13801 state._fsp--;
13802
13803 pushFollow(FOLLOW_2);
13804 rule__ClassInterpretation__Group_3__1();
13805
13806 state._fsp--;
13807
13808
13809 }
13810
13811 }
13812 catch (RecognitionException re) {
13813 reportError(re);
13814 recover(input,re);
13815 }
13816 finally {
13817
13818 restoreStackSize(stackSize);
13819
13820 }
13821 return ;
13822 }
13823 // $ANTLR end "rule__ClassInterpretation__Group_3__0"
13824
13825
13826 // $ANTLR start "rule__ClassInterpretation__Group_3__0__Impl"
13827 // InternalSolverLanguage.g:4481:1: rule__ClassInterpretation__Group_3__0__Impl : ( 'extends' ) ;
13828 public final void rule__ClassInterpretation__Group_3__0__Impl() throws RecognitionException {
13829
13830 int stackSize = keepStackSize();
13831
13832 try {
13833 // InternalSolverLanguage.g:4485:1: ( ( 'extends' ) )
13834 // InternalSolverLanguage.g:4486:1: ( 'extends' )
13835 {
13836 // InternalSolverLanguage.g:4486:1: ( 'extends' )
13837 // InternalSolverLanguage.g:4487:2: 'extends'
13838 {
13839 before(grammarAccess.getClassInterpretationAccess().getExtendsKeyword_3_0());
13840 match(input,35,FOLLOW_2);
13841 after(grammarAccess.getClassInterpretationAccess().getExtendsKeyword_3_0());
13842
13843 }
13844
13845
13846 }
13847
13848 }
13849 catch (RecognitionException re) {
13850 reportError(re);
13851 recover(input,re);
13852 }
13853 finally {
13854
13855 restoreStackSize(stackSize);
13856
13857 }
13858 return ;
13859 }
13860 // $ANTLR end "rule__ClassInterpretation__Group_3__0__Impl"
13861
13862
13863 // $ANTLR start "rule__ClassInterpretation__Group_3__1"
13864 // InternalSolverLanguage.g:4496:1: rule__ClassInterpretation__Group_3__1 : rule__ClassInterpretation__Group_3__1__Impl ;
13865 public final void rule__ClassInterpretation__Group_3__1() throws RecognitionException {
13866
13867 int stackSize = keepStackSize();
13868
13869 try {
13870 // InternalSolverLanguage.g:4500:1: ( rule__ClassInterpretation__Group_3__1__Impl )
13871 // InternalSolverLanguage.g:4501:2: rule__ClassInterpretation__Group_3__1__Impl
13872 {
13873 pushFollow(FOLLOW_2);
13874 rule__ClassInterpretation__Group_3__1__Impl();
13875
13876 state._fsp--;
13877
13878
13879 }
13880
13881 }
13882 catch (RecognitionException re) {
13883 reportError(re);
13884 recover(input,re);
13885 }
13886 finally {
13887
13888 restoreStackSize(stackSize);
13889
13890 }
13891 return ;
13892 }
13893 // $ANTLR end "rule__ClassInterpretation__Group_3__1"
13894
13895
13896 // $ANTLR start "rule__ClassInterpretation__Group_3__1__Impl"
13897 // InternalSolverLanguage.g:4507:1: rule__ClassInterpretation__Group_3__1__Impl : ( ( ( rule__ClassInterpretation__SupertypesAssignment_3_1 ) ) ( ( rule__ClassInterpretation__SupertypesAssignment_3_1 )* ) ) ;
13898 public final void rule__ClassInterpretation__Group_3__1__Impl() throws RecognitionException {
13899
13900 int stackSize = keepStackSize();
13901
13902 try {
13903 // InternalSolverLanguage.g:4511:1: ( ( ( ( rule__ClassInterpretation__SupertypesAssignment_3_1 ) ) ( ( rule__ClassInterpretation__SupertypesAssignment_3_1 )* ) ) )
13904 // InternalSolverLanguage.g:4512:1: ( ( ( rule__ClassInterpretation__SupertypesAssignment_3_1 ) ) ( ( rule__ClassInterpretation__SupertypesAssignment_3_1 )* ) )
13905 {
13906 // InternalSolverLanguage.g:4512:1: ( ( ( rule__ClassInterpretation__SupertypesAssignment_3_1 ) ) ( ( rule__ClassInterpretation__SupertypesAssignment_3_1 )* ) )
13907 // InternalSolverLanguage.g:4513:2: ( ( rule__ClassInterpretation__SupertypesAssignment_3_1 ) ) ( ( rule__ClassInterpretation__SupertypesAssignment_3_1 )* )
13908 {
13909 // InternalSolverLanguage.g:4513:2: ( ( rule__ClassInterpretation__SupertypesAssignment_3_1 ) )
13910 // InternalSolverLanguage.g:4514:3: ( rule__ClassInterpretation__SupertypesAssignment_3_1 )
13911 {
13912 before(grammarAccess.getClassInterpretationAccess().getSupertypesAssignment_3_1());
13913 // InternalSolverLanguage.g:4515:3: ( rule__ClassInterpretation__SupertypesAssignment_3_1 )
13914 // InternalSolverLanguage.g:4515:4: rule__ClassInterpretation__SupertypesAssignment_3_1
13915 {
13916 pushFollow(FOLLOW_19);
13917 rule__ClassInterpretation__SupertypesAssignment_3_1();
13918
13919 state._fsp--;
13920
13921
13922 }
13923
13924 after(grammarAccess.getClassInterpretationAccess().getSupertypesAssignment_3_1());
13925
13926 }
13927
13928 // InternalSolverLanguage.g:4518:2: ( ( rule__ClassInterpretation__SupertypesAssignment_3_1 )* )
13929 // InternalSolverLanguage.g:4519:3: ( rule__ClassInterpretation__SupertypesAssignment_3_1 )*
13930 {
13931 before(grammarAccess.getClassInterpretationAccess().getSupertypesAssignment_3_1());
13932 // InternalSolverLanguage.g:4520:3: ( rule__ClassInterpretation__SupertypesAssignment_3_1 )*
13933 loop36:
13934 do {
13935 int alt36=2;
13936 int LA36_0 = input.LA(1);
13937
13938 if ( (LA36_0==RULE_ID) ) {
13939 alt36=1;
13940 }
13941
13942
13943 switch (alt36) {
13944 case 1 :
13945 // InternalSolverLanguage.g:4520:4: rule__ClassInterpretation__SupertypesAssignment_3_1
13946 {
13947 pushFollow(FOLLOW_19);
13948 rule__ClassInterpretation__SupertypesAssignment_3_1();
13949
13950 state._fsp--;
13951
13952
13953 }
13954 break;
13955
13956 default :
13957 break loop36;
13958 }
13959 } while (true);
13960
13961 after(grammarAccess.getClassInterpretationAccess().getSupertypesAssignment_3_1());
13962
13963 }
13964
13965
13966 }
13967
13968
13969 }
13970
13971 }
13972 catch (RecognitionException re) {
13973 reportError(re);
13974 recover(input,re);
13975 }
13976 finally {
13977
13978 restoreStackSize(stackSize);
13979
13980 }
13981 return ;
13982 }
13983 // $ANTLR end "rule__ClassInterpretation__Group_3__1__Impl"
13984
13985
13986 // $ANTLR start "rule__EnumInterpretation__Group__0"
13987 // InternalSolverLanguage.g:4530:1: rule__EnumInterpretation__Group__0 : rule__EnumInterpretation__Group__0__Impl rule__EnumInterpretation__Group__1 ;
13988 public final void rule__EnumInterpretation__Group__0() throws RecognitionException {
13989
13990 int stackSize = keepStackSize();
13991
13992 try {
13993 // InternalSolverLanguage.g:4534:1: ( rule__EnumInterpretation__Group__0__Impl rule__EnumInterpretation__Group__1 )
13994 // InternalSolverLanguage.g:4535:2: rule__EnumInterpretation__Group__0__Impl rule__EnumInterpretation__Group__1
13995 {
13996 pushFollow(FOLLOW_16);
13997 rule__EnumInterpretation__Group__0__Impl();
13998
13999 state._fsp--;
14000
14001 pushFollow(FOLLOW_2);
14002 rule__EnumInterpretation__Group__1();
14003
14004 state._fsp--;
14005
14006
14007 }
14008
14009 }
14010 catch (RecognitionException re) {
14011 reportError(re);
14012 recover(input,re);
14013 }
14014 finally {
14015
14016 restoreStackSize(stackSize);
14017
14018 }
14019 return ;
14020 }
14021 // $ANTLR end "rule__EnumInterpretation__Group__0"
14022
14023
14024 // $ANTLR start "rule__EnumInterpretation__Group__0__Impl"
14025 // InternalSolverLanguage.g:4542:1: rule__EnumInterpretation__Group__0__Impl : ( 'enum' ) ;
14026 public final void rule__EnumInterpretation__Group__0__Impl() throws RecognitionException {
14027
14028 int stackSize = keepStackSize();
14029
14030 try {
14031 // InternalSolverLanguage.g:4546:1: ( ( 'enum' ) )
14032 // InternalSolverLanguage.g:4547:1: ( 'enum' )
14033 {
14034 // InternalSolverLanguage.g:4547:1: ( 'enum' )
14035 // InternalSolverLanguage.g:4548:2: 'enum'
14036 {
14037 before(grammarAccess.getEnumInterpretationAccess().getEnumKeyword_0());
14038 match(input,36,FOLLOW_2);
14039 after(grammarAccess.getEnumInterpretationAccess().getEnumKeyword_0());
14040
14041 }
14042
14043
14044 }
14045
14046 }
14047 catch (RecognitionException re) {
14048 reportError(re);
14049 recover(input,re);
14050 }
14051 finally {
14052
14053 restoreStackSize(stackSize);
14054
14055 }
14056 return ;
14057 }
14058 // $ANTLR end "rule__EnumInterpretation__Group__0__Impl"
14059
14060
14061 // $ANTLR start "rule__EnumInterpretation__Group__1"
14062 // InternalSolverLanguage.g:4557:1: rule__EnumInterpretation__Group__1 : rule__EnumInterpretation__Group__1__Impl rule__EnumInterpretation__Group__2 ;
14063 public final void rule__EnumInterpretation__Group__1() throws RecognitionException {
14064
14065 int stackSize = keepStackSize();
14066
14067 try {
14068 // InternalSolverLanguage.g:4561:1: ( rule__EnumInterpretation__Group__1__Impl rule__EnumInterpretation__Group__2 )
14069 // InternalSolverLanguage.g:4562:2: rule__EnumInterpretation__Group__1__Impl rule__EnumInterpretation__Group__2
14070 {
14071 pushFollow(FOLLOW_40);
14072 rule__EnumInterpretation__Group__1__Impl();
14073
14074 state._fsp--;
14075
14076 pushFollow(FOLLOW_2);
14077 rule__EnumInterpretation__Group__2();
14078
14079 state._fsp--;
14080
14081
14082 }
14083
14084 }
14085 catch (RecognitionException re) {
14086 reportError(re);
14087 recover(input,re);
14088 }
14089 finally {
14090
14091 restoreStackSize(stackSize);
14092
14093 }
14094 return ;
14095 }
14096 // $ANTLR end "rule__EnumInterpretation__Group__1"
14097
14098
14099 // $ANTLR start "rule__EnumInterpretation__Group__1__Impl"
14100 // InternalSolverLanguage.g:4569:1: rule__EnumInterpretation__Group__1__Impl : ( ( rule__EnumInterpretation__SymbolAssignment_1 ) ) ;
14101 public final void rule__EnumInterpretation__Group__1__Impl() throws RecognitionException {
14102
14103 int stackSize = keepStackSize();
14104
14105 try {
14106 // InternalSolverLanguage.g:4573:1: ( ( ( rule__EnumInterpretation__SymbolAssignment_1 ) ) )
14107 // InternalSolverLanguage.g:4574:1: ( ( rule__EnumInterpretation__SymbolAssignment_1 ) )
14108 {
14109 // InternalSolverLanguage.g:4574:1: ( ( rule__EnumInterpretation__SymbolAssignment_1 ) )
14110 // InternalSolverLanguage.g:4575:2: ( rule__EnumInterpretation__SymbolAssignment_1 )
14111 {
14112 before(grammarAccess.getEnumInterpretationAccess().getSymbolAssignment_1());
14113 // InternalSolverLanguage.g:4576:2: ( rule__EnumInterpretation__SymbolAssignment_1 )
14114 // InternalSolverLanguage.g:4576:3: rule__EnumInterpretation__SymbolAssignment_1
14115 {
14116 pushFollow(FOLLOW_2);
14117 rule__EnumInterpretation__SymbolAssignment_1();
14118
14119 state._fsp--;
14120
14121
14122 }
14123
14124 after(grammarAccess.getEnumInterpretationAccess().getSymbolAssignment_1());
14125
14126 }
14127
14128
14129 }
14130
14131 }
14132 catch (RecognitionException re) {
14133 reportError(re);
14134 recover(input,re);
14135 }
14136 finally {
14137
14138 restoreStackSize(stackSize);
14139
14140 }
14141 return ;
14142 }
14143 // $ANTLR end "rule__EnumInterpretation__Group__1__Impl"
14144
14145
14146 // $ANTLR start "rule__EnumInterpretation__Group__2"
14147 // InternalSolverLanguage.g:4584:1: rule__EnumInterpretation__Group__2 : rule__EnumInterpretation__Group__2__Impl rule__EnumInterpretation__Group__3 ;
14148 public final void rule__EnumInterpretation__Group__2() throws RecognitionException {
14149
14150 int stackSize = keepStackSize();
14151
14152 try {
14153 // InternalSolverLanguage.g:4588:1: ( rule__EnumInterpretation__Group__2__Impl rule__EnumInterpretation__Group__3 )
14154 // InternalSolverLanguage.g:4589:2: rule__EnumInterpretation__Group__2__Impl rule__EnumInterpretation__Group__3
14155 {
14156 pushFollow(FOLLOW_17);
14157 rule__EnumInterpretation__Group__2__Impl();
14158
14159 state._fsp--;
14160
14161 pushFollow(FOLLOW_2);
14162 rule__EnumInterpretation__Group__3();
14163
14164 state._fsp--;
14165
14166
14167 }
14168
14169 }
14170 catch (RecognitionException re) {
14171 reportError(re);
14172 recover(input,re);
14173 }
14174 finally {
14175
14176 restoreStackSize(stackSize);
14177
14178 }
14179 return ;
14180 }
14181 // $ANTLR end "rule__EnumInterpretation__Group__2"
14182
14183
14184 // $ANTLR start "rule__EnumInterpretation__Group__2__Impl"
14185 // InternalSolverLanguage.g:4596:1: rule__EnumInterpretation__Group__2__Impl : ( '{' ) ;
14186 public final void rule__EnumInterpretation__Group__2__Impl() throws RecognitionException {
14187
14188 int stackSize = keepStackSize();
14189
14190 try {
14191 // InternalSolverLanguage.g:4600:1: ( ( '{' ) )
14192 // InternalSolverLanguage.g:4601:1: ( '{' )
14193 {
14194 // InternalSolverLanguage.g:4601:1: ( '{' )
14195 // InternalSolverLanguage.g:4602:2: '{'
14196 {
14197 before(grammarAccess.getEnumInterpretationAccess().getLeftCurlyBracketKeyword_2());
14198 match(input,33,FOLLOW_2);
14199 after(grammarAccess.getEnumInterpretationAccess().getLeftCurlyBracketKeyword_2());
14200
14201 }
14202
14203
14204 }
14205
14206 }
14207 catch (RecognitionException re) {
14208 reportError(re);
14209 recover(input,re);
14210 }
14211 finally {
14212
14213 restoreStackSize(stackSize);
14214
14215 }
14216 return ;
14217 }
14218 // $ANTLR end "rule__EnumInterpretation__Group__2__Impl"
14219
14220
14221 // $ANTLR start "rule__EnumInterpretation__Group__3"
14222 // InternalSolverLanguage.g:4611:1: rule__EnumInterpretation__Group__3 : rule__EnumInterpretation__Group__3__Impl rule__EnumInterpretation__Group__4 ;
14223 public final void rule__EnumInterpretation__Group__3() throws RecognitionException {
14224
14225 int stackSize = keepStackSize();
14226
14227 try {
14228 // InternalSolverLanguage.g:4615:1: ( rule__EnumInterpretation__Group__3__Impl rule__EnumInterpretation__Group__4 )
14229 // InternalSolverLanguage.g:4616:2: rule__EnumInterpretation__Group__3__Impl rule__EnumInterpretation__Group__4
14230 {
14231 pushFollow(FOLLOW_41);
14232 rule__EnumInterpretation__Group__3__Impl();
14233
14234 state._fsp--;
14235
14236 pushFollow(FOLLOW_2);
14237 rule__EnumInterpretation__Group__4();
14238
14239 state._fsp--;
14240
14241
14242 }
14243
14244 }
14245 catch (RecognitionException re) {
14246 reportError(re);
14247 recover(input,re);
14248 }
14249 finally {
14250
14251 restoreStackSize(stackSize);
14252
14253 }
14254 return ;
14255 }
14256 // $ANTLR end "rule__EnumInterpretation__Group__3"
14257
14258
14259 // $ANTLR start "rule__EnumInterpretation__Group__3__Impl"
14260 // InternalSolverLanguage.g:4623:1: rule__EnumInterpretation__Group__3__Impl : ( ( ( rule__EnumInterpretation__ObjectsAssignment_3 ) ) ( ( rule__EnumInterpretation__ObjectsAssignment_3 )* ) ) ;
14261 public final void rule__EnumInterpretation__Group__3__Impl() throws RecognitionException {
14262
14263 int stackSize = keepStackSize();
14264
14265 try {
14266 // InternalSolverLanguage.g:4627:1: ( ( ( ( rule__EnumInterpretation__ObjectsAssignment_3 ) ) ( ( rule__EnumInterpretation__ObjectsAssignment_3 )* ) ) )
14267 // InternalSolverLanguage.g:4628:1: ( ( ( rule__EnumInterpretation__ObjectsAssignment_3 ) ) ( ( rule__EnumInterpretation__ObjectsAssignment_3 )* ) )
14268 {
14269 // InternalSolverLanguage.g:4628:1: ( ( ( rule__EnumInterpretation__ObjectsAssignment_3 ) ) ( ( rule__EnumInterpretation__ObjectsAssignment_3 )* ) )
14270 // InternalSolverLanguage.g:4629:2: ( ( rule__EnumInterpretation__ObjectsAssignment_3 ) ) ( ( rule__EnumInterpretation__ObjectsAssignment_3 )* )
14271 {
14272 // InternalSolverLanguage.g:4629:2: ( ( rule__EnumInterpretation__ObjectsAssignment_3 ) )
14273 // InternalSolverLanguage.g:4630:3: ( rule__EnumInterpretation__ObjectsAssignment_3 )
14274 {
14275 before(grammarAccess.getEnumInterpretationAccess().getObjectsAssignment_3());
14276 // InternalSolverLanguage.g:4631:3: ( rule__EnumInterpretation__ObjectsAssignment_3 )
14277 // InternalSolverLanguage.g:4631:4: rule__EnumInterpretation__ObjectsAssignment_3
14278 {
14279 pushFollow(FOLLOW_42);
14280 rule__EnumInterpretation__ObjectsAssignment_3();
14281
14282 state._fsp--;
14283
14284
14285 }
14286
14287 after(grammarAccess.getEnumInterpretationAccess().getObjectsAssignment_3());
14288
14289 }
14290
14291 // InternalSolverLanguage.g:4634:2: ( ( rule__EnumInterpretation__ObjectsAssignment_3 )* )
14292 // InternalSolverLanguage.g:4635:3: ( rule__EnumInterpretation__ObjectsAssignment_3 )*
14293 {
14294 before(grammarAccess.getEnumInterpretationAccess().getObjectsAssignment_3());
14295 // InternalSolverLanguage.g:4636:3: ( rule__EnumInterpretation__ObjectsAssignment_3 )*
14296 loop37:
14297 do {
14298 int alt37=2;
14299 int LA37_0 = input.LA(1);
14300
14301 if ( (LA37_0==26) ) {
14302 alt37=1;
14303 }
14304
14305
14306 switch (alt37) {
14307 case 1 :
14308 // InternalSolverLanguage.g:4636:4: rule__EnumInterpretation__ObjectsAssignment_3
14309 {
14310 pushFollow(FOLLOW_42);
14311 rule__EnumInterpretation__ObjectsAssignment_3();
14312
14313 state._fsp--;
14314
14315
14316 }
14317 break;
14318
14319 default :
14320 break loop37;
14321 }
14322 } while (true);
14323
14324 after(grammarAccess.getEnumInterpretationAccess().getObjectsAssignment_3());
14325
14326 }
14327
14328
14329 }
14330
14331
14332 }
14333
14334 }
14335 catch (RecognitionException re) {
14336 reportError(re);
14337 recover(input,re);
14338 }
14339 finally {
14340
14341 restoreStackSize(stackSize);
14342
14343 }
14344 return ;
14345 }
14346 // $ANTLR end "rule__EnumInterpretation__Group__3__Impl"
14347
14348
14349 // $ANTLR start "rule__EnumInterpretation__Group__4"
14350 // InternalSolverLanguage.g:4645:1: rule__EnumInterpretation__Group__4 : rule__EnumInterpretation__Group__4__Impl ;
14351 public final void rule__EnumInterpretation__Group__4() throws RecognitionException {
14352
14353 int stackSize = keepStackSize();
14354
14355 try {
14356 // InternalSolverLanguage.g:4649:1: ( rule__EnumInterpretation__Group__4__Impl )
14357 // InternalSolverLanguage.g:4650:2: rule__EnumInterpretation__Group__4__Impl
14358 {
14359 pushFollow(FOLLOW_2);
14360 rule__EnumInterpretation__Group__4__Impl();
14361
14362 state._fsp--;
14363
14364
14365 }
14366
14367 }
14368 catch (RecognitionException re) {
14369 reportError(re);
14370 recover(input,re);
14371 }
14372 finally {
14373
14374 restoreStackSize(stackSize);
14375
14376 }
14377 return ;
14378 }
14379 // $ANTLR end "rule__EnumInterpretation__Group__4"
14380
14381
14382 // $ANTLR start "rule__EnumInterpretation__Group__4__Impl"
14383 // InternalSolverLanguage.g:4656:1: rule__EnumInterpretation__Group__4__Impl : ( '}' ) ;
14384 public final void rule__EnumInterpretation__Group__4__Impl() throws RecognitionException {
14385
14386 int stackSize = keepStackSize();
14387
14388 try {
14389 // InternalSolverLanguage.g:4660:1: ( ( '}' ) )
14390 // InternalSolverLanguage.g:4661:1: ( '}' )
14391 {
14392 // InternalSolverLanguage.g:4661:1: ( '}' )
14393 // InternalSolverLanguage.g:4662:2: '}'
14394 {
14395 before(grammarAccess.getEnumInterpretationAccess().getRightCurlyBracketKeyword_4());
14396 match(input,34,FOLLOW_2);
14397 after(grammarAccess.getEnumInterpretationAccess().getRightCurlyBracketKeyword_4());
14398
14399 }
14400
14401
14402 }
14403
14404 }
14405 catch (RecognitionException re) {
14406 reportError(re);
14407 recover(input,re);
14408 }
14409 finally {
14410
14411 restoreStackSize(stackSize);
14412
14413 }
14414 return ;
14415 }
14416 // $ANTLR end "rule__EnumInterpretation__Group__4__Impl"
14417
14418
14419 // $ANTLR start "rule__FieldRelationInterpretation__Group__0"
14420 // InternalSolverLanguage.g:4672:1: rule__FieldRelationInterpretation__Group__0 : rule__FieldRelationInterpretation__Group__0__Impl rule__FieldRelationInterpretation__Group__1 ;
14421 public final void rule__FieldRelationInterpretation__Group__0() throws RecognitionException {
14422
14423 int stackSize = keepStackSize();
14424
14425 try {
14426 // InternalSolverLanguage.g:4676:1: ( rule__FieldRelationInterpretation__Group__0__Impl rule__FieldRelationInterpretation__Group__1 )
14427 // InternalSolverLanguage.g:4677:2: rule__FieldRelationInterpretation__Group__0__Impl rule__FieldRelationInterpretation__Group__1
14428 {
14429 pushFollow(FOLLOW_16);
14430 rule__FieldRelationInterpretation__Group__0__Impl();
14431
14432 state._fsp--;
14433
14434 pushFollow(FOLLOW_2);
14435 rule__FieldRelationInterpretation__Group__1();
14436
14437 state._fsp--;
14438
14439
14440 }
14441
14442 }
14443 catch (RecognitionException re) {
14444 reportError(re);
14445 recover(input,re);
14446 }
14447 finally {
14448
14449 restoreStackSize(stackSize);
14450
14451 }
14452 return ;
14453 }
14454 // $ANTLR end "rule__FieldRelationInterpretation__Group__0"
14455
14456
14457 // $ANTLR start "rule__FieldRelationInterpretation__Group__0__Impl"
14458 // InternalSolverLanguage.g:4684:1: rule__FieldRelationInterpretation__Group__0__Impl : ( ( rule__FieldRelationInterpretation__ContainmentAssignment_0 ) ) ;
14459 public final void rule__FieldRelationInterpretation__Group__0__Impl() throws RecognitionException {
14460
14461 int stackSize = keepStackSize();
14462
14463 try {
14464 // InternalSolverLanguage.g:4688:1: ( ( ( rule__FieldRelationInterpretation__ContainmentAssignment_0 ) ) )
14465 // InternalSolverLanguage.g:4689:1: ( ( rule__FieldRelationInterpretation__ContainmentAssignment_0 ) )
14466 {
14467 // InternalSolverLanguage.g:4689:1: ( ( rule__FieldRelationInterpretation__ContainmentAssignment_0 ) )
14468 // InternalSolverLanguage.g:4690:2: ( rule__FieldRelationInterpretation__ContainmentAssignment_0 )
14469 {
14470 before(grammarAccess.getFieldRelationInterpretationAccess().getContainmentAssignment_0());
14471 // InternalSolverLanguage.g:4691:2: ( rule__FieldRelationInterpretation__ContainmentAssignment_0 )
14472 // InternalSolverLanguage.g:4691:3: rule__FieldRelationInterpretation__ContainmentAssignment_0
14473 {
14474 pushFollow(FOLLOW_2);
14475 rule__FieldRelationInterpretation__ContainmentAssignment_0();
14476
14477 state._fsp--;
14478
14479
14480 }
14481
14482 after(grammarAccess.getFieldRelationInterpretationAccess().getContainmentAssignment_0());
14483
14484 }
14485
14486
14487 }
14488
14489 }
14490 catch (RecognitionException re) {
14491 reportError(re);
14492 recover(input,re);
14493 }
14494 finally {
14495
14496 restoreStackSize(stackSize);
14497
14498 }
14499 return ;
14500 }
14501 // $ANTLR end "rule__FieldRelationInterpretation__Group__0__Impl"
14502
14503
14504 // $ANTLR start "rule__FieldRelationInterpretation__Group__1"
14505 // InternalSolverLanguage.g:4699:1: rule__FieldRelationInterpretation__Group__1 : rule__FieldRelationInterpretation__Group__1__Impl rule__FieldRelationInterpretation__Group__2 ;
14506 public final void rule__FieldRelationInterpretation__Group__1() throws RecognitionException {
14507
14508 int stackSize = keepStackSize();
14509
14510 try {
14511 // InternalSolverLanguage.g:4703:1: ( rule__FieldRelationInterpretation__Group__1__Impl rule__FieldRelationInterpretation__Group__2 )
14512 // InternalSolverLanguage.g:4704:2: rule__FieldRelationInterpretation__Group__1__Impl rule__FieldRelationInterpretation__Group__2
14513 {
14514 pushFollow(FOLLOW_14);
14515 rule__FieldRelationInterpretation__Group__1__Impl();
14516
14517 state._fsp--;
14518
14519 pushFollow(FOLLOW_2);
14520 rule__FieldRelationInterpretation__Group__2();
14521
14522 state._fsp--;
14523
14524
14525 }
14526
14527 }
14528 catch (RecognitionException re) {
14529 reportError(re);
14530 recover(input,re);
14531 }
14532 finally {
14533
14534 restoreStackSize(stackSize);
14535
14536 }
14537 return ;
14538 }
14539 // $ANTLR end "rule__FieldRelationInterpretation__Group__1"
14540
14541
14542 // $ANTLR start "rule__FieldRelationInterpretation__Group__1__Impl"
14543 // InternalSolverLanguage.g:4711:1: rule__FieldRelationInterpretation__Group__1__Impl : ( ( rule__FieldRelationInterpretation__SymbolAssignment_1 ) ) ;
14544 public final void rule__FieldRelationInterpretation__Group__1__Impl() throws RecognitionException {
14545
14546 int stackSize = keepStackSize();
14547
14548 try {
14549 // InternalSolverLanguage.g:4715:1: ( ( ( rule__FieldRelationInterpretation__SymbolAssignment_1 ) ) )
14550 // InternalSolverLanguage.g:4716:1: ( ( rule__FieldRelationInterpretation__SymbolAssignment_1 ) )
14551 {
14552 // InternalSolverLanguage.g:4716:1: ( ( rule__FieldRelationInterpretation__SymbolAssignment_1 ) )
14553 // InternalSolverLanguage.g:4717:2: ( rule__FieldRelationInterpretation__SymbolAssignment_1 )
14554 {
14555 before(grammarAccess.getFieldRelationInterpretationAccess().getSymbolAssignment_1());
14556 // InternalSolverLanguage.g:4718:2: ( rule__FieldRelationInterpretation__SymbolAssignment_1 )
14557 // InternalSolverLanguage.g:4718:3: rule__FieldRelationInterpretation__SymbolAssignment_1
14558 {
14559 pushFollow(FOLLOW_2);
14560 rule__FieldRelationInterpretation__SymbolAssignment_1();
14561
14562 state._fsp--;
14563
14564
14565 }
14566
14567 after(grammarAccess.getFieldRelationInterpretationAccess().getSymbolAssignment_1());
14568
14569 }
14570
14571
14572 }
14573
14574 }
14575 catch (RecognitionException re) {
14576 reportError(re);
14577 recover(input,re);
14578 }
14579 finally {
14580
14581 restoreStackSize(stackSize);
14582
14583 }
14584 return ;
14585 }
14586 // $ANTLR end "rule__FieldRelationInterpretation__Group__1__Impl"
14587
14588
14589 // $ANTLR start "rule__FieldRelationInterpretation__Group__2"
14590 // InternalSolverLanguage.g:4726:1: rule__FieldRelationInterpretation__Group__2 : rule__FieldRelationInterpretation__Group__2__Impl rule__FieldRelationInterpretation__Group__3 ;
14591 public final void rule__FieldRelationInterpretation__Group__2() throws RecognitionException {
14592
14593 int stackSize = keepStackSize();
14594
14595 try {
14596 // InternalSolverLanguage.g:4730:1: ( rule__FieldRelationInterpretation__Group__2__Impl rule__FieldRelationInterpretation__Group__3 )
14597 // InternalSolverLanguage.g:4731:2: rule__FieldRelationInterpretation__Group__2__Impl rule__FieldRelationInterpretation__Group__3
14598 {
14599 pushFollow(FOLLOW_43);
14600 rule__FieldRelationInterpretation__Group__2__Impl();
14601
14602 state._fsp--;
14603
14604 pushFollow(FOLLOW_2);
14605 rule__FieldRelationInterpretation__Group__3();
14606
14607 state._fsp--;
14608
14609
14610 }
14611
14612 }
14613 catch (RecognitionException re) {
14614 reportError(re);
14615 recover(input,re);
14616 }
14617 finally {
14618
14619 restoreStackSize(stackSize);
14620
14621 }
14622 return ;
14623 }
14624 // $ANTLR end "rule__FieldRelationInterpretation__Group__2"
14625
14626
14627 // $ANTLR start "rule__FieldRelationInterpretation__Group__2__Impl"
14628 // InternalSolverLanguage.g:4738:1: rule__FieldRelationInterpretation__Group__2__Impl : ( ':' ) ;
14629 public final void rule__FieldRelationInterpretation__Group__2__Impl() throws RecognitionException {
14630
14631 int stackSize = keepStackSize();
14632
14633 try {
14634 // InternalSolverLanguage.g:4742:1: ( ( ':' ) )
14635 // InternalSolverLanguage.g:4743:1: ( ':' )
14636 {
14637 // InternalSolverLanguage.g:4743:1: ( ':' )
14638 // InternalSolverLanguage.g:4744:2: ':'
14639 {
14640 before(grammarAccess.getFieldRelationInterpretationAccess().getColonKeyword_2());
14641 match(input,19,FOLLOW_2);
14642 after(grammarAccess.getFieldRelationInterpretationAccess().getColonKeyword_2());
14643
14644 }
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__FieldRelationInterpretation__Group__2__Impl"
14662
14663
14664 // $ANTLR start "rule__FieldRelationInterpretation__Group__3"
14665 // InternalSolverLanguage.g:4753:1: rule__FieldRelationInterpretation__Group__3 : rule__FieldRelationInterpretation__Group__3__Impl rule__FieldRelationInterpretation__Group__4 ;
14666 public final void rule__FieldRelationInterpretation__Group__3() throws RecognitionException {
14667
14668 int stackSize = keepStackSize();
14669
14670 try {
14671 // InternalSolverLanguage.g:4757:1: ( rule__FieldRelationInterpretation__Group__3__Impl rule__FieldRelationInterpretation__Group__4 )
14672 // InternalSolverLanguage.g:4758:2: rule__FieldRelationInterpretation__Group__3__Impl rule__FieldRelationInterpretation__Group__4
14673 {
14674 pushFollow(FOLLOW_43);
14675 rule__FieldRelationInterpretation__Group__3__Impl();
14676
14677 state._fsp--;
14678
14679 pushFollow(FOLLOW_2);
14680 rule__FieldRelationInterpretation__Group__4();
14681
14682 state._fsp--;
14683
14684
14685 }
14686
14687 }
14688 catch (RecognitionException re) {
14689 reportError(re);
14690 recover(input,re);
14691 }
14692 finally {
14693
14694 restoreStackSize(stackSize);
14695
14696 }
14697 return ;
14698 }
14699 // $ANTLR end "rule__FieldRelationInterpretation__Group__3"
14700
14701
14702 // $ANTLR start "rule__FieldRelationInterpretation__Group__3__Impl"
14703 // InternalSolverLanguage.g:4765:1: rule__FieldRelationInterpretation__Group__3__Impl : ( ( rule__FieldRelationInterpretation__MultiplicityAssignment_3 )? ) ;
14704 public final void rule__FieldRelationInterpretation__Group__3__Impl() throws RecognitionException {
14705
14706 int stackSize = keepStackSize();
14707
14708 try {
14709 // InternalSolverLanguage.g:4769:1: ( ( ( rule__FieldRelationInterpretation__MultiplicityAssignment_3 )? ) )
14710 // InternalSolverLanguage.g:4770:1: ( ( rule__FieldRelationInterpretation__MultiplicityAssignment_3 )? )
14711 {
14712 // InternalSolverLanguage.g:4770:1: ( ( rule__FieldRelationInterpretation__MultiplicityAssignment_3 )? )
14713 // InternalSolverLanguage.g:4771:2: ( rule__FieldRelationInterpretation__MultiplicityAssignment_3 )?
14714 {
14715 before(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityAssignment_3());
14716 // InternalSolverLanguage.g:4772:2: ( rule__FieldRelationInterpretation__MultiplicityAssignment_3 )?
14717 int alt38=2;
14718 int LA38_0 = input.LA(1);
14719
14720 if ( (LA38_0==RULE_INT) ) {
14721 alt38=1;
14722 }
14723 switch (alt38) {
14724 case 1 :
14725 // InternalSolverLanguage.g:4772:3: rule__FieldRelationInterpretation__MultiplicityAssignment_3
14726 {
14727 pushFollow(FOLLOW_2);
14728 rule__FieldRelationInterpretation__MultiplicityAssignment_3();
14729
14730 state._fsp--;
14731
14732
14733 }
14734 break;
14735
14736 }
14737
14738 after(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityAssignment_3());
14739
14740 }
14741
14742
14743 }
14744
14745 }
14746 catch (RecognitionException re) {
14747 reportError(re);
14748 recover(input,re);
14749 }
14750 finally {
14751
14752 restoreStackSize(stackSize);
14753
14754 }
14755 return ;
14756 }
14757 // $ANTLR end "rule__FieldRelationInterpretation__Group__3__Impl"
14758
14759
14760 // $ANTLR start "rule__FieldRelationInterpretation__Group__4"
14761 // InternalSolverLanguage.g:4780:1: rule__FieldRelationInterpretation__Group__4 : rule__FieldRelationInterpretation__Group__4__Impl ;
14762 public final void rule__FieldRelationInterpretation__Group__4() throws RecognitionException {
14763
14764 int stackSize = keepStackSize();
14765
14766 try {
14767 // InternalSolverLanguage.g:4784:1: ( rule__FieldRelationInterpretation__Group__4__Impl )
14768 // InternalSolverLanguage.g:4785:2: rule__FieldRelationInterpretation__Group__4__Impl
14769 {
14770 pushFollow(FOLLOW_2);
14771 rule__FieldRelationInterpretation__Group__4__Impl();
14772
14773 state._fsp--;
14774
14775
14776 }
14777
14778 }
14779 catch (RecognitionException re) {
14780 reportError(re);
14781 recover(input,re);
14782 }
14783 finally {
14784
14785 restoreStackSize(stackSize);
14786
14787 }
14788 return ;
14789 }
14790 // $ANTLR end "rule__FieldRelationInterpretation__Group__4"
14791
14792
14793 // $ANTLR start "rule__FieldRelationInterpretation__Group__4__Impl"
14794 // InternalSolverLanguage.g:4791:1: rule__FieldRelationInterpretation__Group__4__Impl : ( ( rule__FieldRelationInterpretation__TargetAssignment_4 ) ) ;
14795 public final void rule__FieldRelationInterpretation__Group__4__Impl() throws RecognitionException {
14796
14797 int stackSize = keepStackSize();
14798
14799 try {
14800 // InternalSolverLanguage.g:4795:1: ( ( ( rule__FieldRelationInterpretation__TargetAssignment_4 ) ) )
14801 // InternalSolverLanguage.g:4796:1: ( ( rule__FieldRelationInterpretation__TargetAssignment_4 ) )
14802 {
14803 // InternalSolverLanguage.g:4796:1: ( ( rule__FieldRelationInterpretation__TargetAssignment_4 ) )
14804 // InternalSolverLanguage.g:4797:2: ( rule__FieldRelationInterpretation__TargetAssignment_4 )
14805 {
14806 before(grammarAccess.getFieldRelationInterpretationAccess().getTargetAssignment_4());
14807 // InternalSolverLanguage.g:4798:2: ( rule__FieldRelationInterpretation__TargetAssignment_4 )
14808 // InternalSolverLanguage.g:4798:3: rule__FieldRelationInterpretation__TargetAssignment_4
14809 {
14810 pushFollow(FOLLOW_2);
14811 rule__FieldRelationInterpretation__TargetAssignment_4();
14812
14813 state._fsp--;
14814
14815
14816 }
14817
14818 after(grammarAccess.getFieldRelationInterpretationAccess().getTargetAssignment_4());
14819
14820 }
14821
14822
14823 }
14824
14825 }
14826 catch (RecognitionException re) {
14827 reportError(re);
14828 recover(input,re);
14829 }
14830 finally {
14831
14832 restoreStackSize(stackSize);
14833
14834 }
14835 return ;
14836 }
14837 // $ANTLR end "rule__FieldRelationInterpretation__Group__4__Impl"
14838
14839
14840 // $ANTLR start "rule__GlobalRelationInterpretation__Group__0"
14841 // InternalSolverLanguage.g:4807:1: rule__GlobalRelationInterpretation__Group__0 : rule__GlobalRelationInterpretation__Group__0__Impl rule__GlobalRelationInterpretation__Group__1 ;
14842 public final void rule__GlobalRelationInterpretation__Group__0() throws RecognitionException {
14843
14844 int stackSize = keepStackSize();
14845
14846 try {
14847 // InternalSolverLanguage.g:4811:1: ( rule__GlobalRelationInterpretation__Group__0__Impl rule__GlobalRelationInterpretation__Group__1 )
14848 // InternalSolverLanguage.g:4812:2: rule__GlobalRelationInterpretation__Group__0__Impl rule__GlobalRelationInterpretation__Group__1
14849 {
14850 pushFollow(FOLLOW_44);
14851 rule__GlobalRelationInterpretation__Group__0__Impl();
14852
14853 state._fsp--;
14854
14855 pushFollow(FOLLOW_2);
14856 rule__GlobalRelationInterpretation__Group__1();
14857
14858 state._fsp--;
14859
14860
14861 }
14862
14863 }
14864 catch (RecognitionException re) {
14865 reportError(re);
14866 recover(input,re);
14867 }
14868 finally {
14869
14870 restoreStackSize(stackSize);
14871
14872 }
14873 return ;
14874 }
14875 // $ANTLR end "rule__GlobalRelationInterpretation__Group__0"
14876
14877
14878 // $ANTLR start "rule__GlobalRelationInterpretation__Group__0__Impl"
14879 // InternalSolverLanguage.g:4819:1: rule__GlobalRelationInterpretation__Group__0__Impl : ( ( rule__GlobalRelationInterpretation__ContainmentAssignment_0 ) ) ;
14880 public final void rule__GlobalRelationInterpretation__Group__0__Impl() throws RecognitionException {
14881
14882 int stackSize = keepStackSize();
14883
14884 try {
14885 // InternalSolverLanguage.g:4823:1: ( ( ( rule__GlobalRelationInterpretation__ContainmentAssignment_0 ) ) )
14886 // InternalSolverLanguage.g:4824:1: ( ( rule__GlobalRelationInterpretation__ContainmentAssignment_0 ) )
14887 {
14888 // InternalSolverLanguage.g:4824:1: ( ( rule__GlobalRelationInterpretation__ContainmentAssignment_0 ) )
14889 // InternalSolverLanguage.g:4825:2: ( rule__GlobalRelationInterpretation__ContainmentAssignment_0 )
14890 {
14891 before(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentAssignment_0());
14892 // InternalSolverLanguage.g:4826:2: ( rule__GlobalRelationInterpretation__ContainmentAssignment_0 )
14893 // InternalSolverLanguage.g:4826:3: rule__GlobalRelationInterpretation__ContainmentAssignment_0
14894 {
14895 pushFollow(FOLLOW_2);
14896 rule__GlobalRelationInterpretation__ContainmentAssignment_0();
14897
14898 state._fsp--;
14899
14900
14901 }
14902
14903 after(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentAssignment_0());
14904
14905 }
14906
14907
14908 }
14909
14910 }
14911 catch (RecognitionException re) {
14912 reportError(re);
14913 recover(input,re);
14914 }
14915 finally {
14916
14917 restoreStackSize(stackSize);
14918
14919 }
14920 return ;
14921 }
14922 // $ANTLR end "rule__GlobalRelationInterpretation__Group__0__Impl"
14923
14924
14925 // $ANTLR start "rule__GlobalRelationInterpretation__Group__1"
14926 // InternalSolverLanguage.g:4834:1: rule__GlobalRelationInterpretation__Group__1 : rule__GlobalRelationInterpretation__Group__1__Impl rule__GlobalRelationInterpretation__Group__2 ;
14927 public final void rule__GlobalRelationInterpretation__Group__1() throws RecognitionException {
14928
14929 int stackSize = keepStackSize();
14930
14931 try {
14932 // InternalSolverLanguage.g:4838:1: ( rule__GlobalRelationInterpretation__Group__1__Impl rule__GlobalRelationInterpretation__Group__2 )
14933 // InternalSolverLanguage.g:4839:2: rule__GlobalRelationInterpretation__Group__1__Impl rule__GlobalRelationInterpretation__Group__2
14934 {
14935 pushFollow(FOLLOW_16);
14936 rule__GlobalRelationInterpretation__Group__1__Impl();
14937
14938 state._fsp--;
14939
14940 pushFollow(FOLLOW_2);
14941 rule__GlobalRelationInterpretation__Group__2();
14942
14943 state._fsp--;
14944
14945
14946 }
14947
14948 }
14949 catch (RecognitionException re) {
14950 reportError(re);
14951 recover(input,re);
14952 }
14953 finally {
14954
14955 restoreStackSize(stackSize);
14956
14957 }
14958 return ;
14959 }
14960 // $ANTLR end "rule__GlobalRelationInterpretation__Group__1"
14961
14962
14963 // $ANTLR start "rule__GlobalRelationInterpretation__Group__1__Impl"
14964 // InternalSolverLanguage.g:4846:1: rule__GlobalRelationInterpretation__Group__1__Impl : ( 'relation' ) ;
14965 public final void rule__GlobalRelationInterpretation__Group__1__Impl() throws RecognitionException {
14966
14967 int stackSize = keepStackSize();
14968
14969 try {
14970 // InternalSolverLanguage.g:4850:1: ( ( 'relation' ) )
14971 // InternalSolverLanguage.g:4851:1: ( 'relation' )
14972 {
14973 // InternalSolverLanguage.g:4851:1: ( 'relation' )
14974 // InternalSolverLanguage.g:4852:2: 'relation'
14975 {
14976 before(grammarAccess.getGlobalRelationInterpretationAccess().getRelationKeyword_1());
14977 match(input,37,FOLLOW_2);
14978 after(grammarAccess.getGlobalRelationInterpretationAccess().getRelationKeyword_1());
14979
14980 }
14981
14982
14983 }
14984
14985 }
14986 catch (RecognitionException re) {
14987 reportError(re);
14988 recover(input,re);
14989 }
14990 finally {
14991
14992 restoreStackSize(stackSize);
14993
14994 }
14995 return ;
14996 }
14997 // $ANTLR end "rule__GlobalRelationInterpretation__Group__1__Impl"
14998
14999
15000 // $ANTLR start "rule__GlobalRelationInterpretation__Group__2"
15001 // InternalSolverLanguage.g:4861:1: rule__GlobalRelationInterpretation__Group__2 : rule__GlobalRelationInterpretation__Group__2__Impl rule__GlobalRelationInterpretation__Group__3 ;
15002 public final void rule__GlobalRelationInterpretation__Group__2() throws RecognitionException {
15003
15004 int stackSize = keepStackSize();
15005
15006 try {
15007 // InternalSolverLanguage.g:4865:1: ( rule__GlobalRelationInterpretation__Group__2__Impl rule__GlobalRelationInterpretation__Group__3 )
15008 // InternalSolverLanguage.g:4866:2: rule__GlobalRelationInterpretation__Group__2__Impl rule__GlobalRelationInterpretation__Group__3
15009 {
15010 pushFollow(FOLLOW_14);
15011 rule__GlobalRelationInterpretation__Group__2__Impl();
15012
15013 state._fsp--;
15014
15015 pushFollow(FOLLOW_2);
15016 rule__GlobalRelationInterpretation__Group__3();
15017
15018 state._fsp--;
15019
15020
15021 }
15022
15023 }
15024 catch (RecognitionException re) {
15025 reportError(re);
15026 recover(input,re);
15027 }
15028 finally {
15029
15030 restoreStackSize(stackSize);
15031
15032 }
15033 return ;
15034 }
15035 // $ANTLR end "rule__GlobalRelationInterpretation__Group__2"
15036
15037
15038 // $ANTLR start "rule__GlobalRelationInterpretation__Group__2__Impl"
15039 // InternalSolverLanguage.g:4873:1: rule__GlobalRelationInterpretation__Group__2__Impl : ( ( rule__GlobalRelationInterpretation__SymbolAssignment_2 ) ) ;
15040 public final void rule__GlobalRelationInterpretation__Group__2__Impl() throws RecognitionException {
15041
15042 int stackSize = keepStackSize();
15043
15044 try {
15045 // InternalSolverLanguage.g:4877:1: ( ( ( rule__GlobalRelationInterpretation__SymbolAssignment_2 ) ) )
15046 // InternalSolverLanguage.g:4878:1: ( ( rule__GlobalRelationInterpretation__SymbolAssignment_2 ) )
15047 {
15048 // InternalSolverLanguage.g:4878:1: ( ( rule__GlobalRelationInterpretation__SymbolAssignment_2 ) )
15049 // InternalSolverLanguage.g:4879:2: ( rule__GlobalRelationInterpretation__SymbolAssignment_2 )
15050 {
15051 before(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolAssignment_2());
15052 // InternalSolverLanguage.g:4880:2: ( rule__GlobalRelationInterpretation__SymbolAssignment_2 )
15053 // InternalSolverLanguage.g:4880:3: rule__GlobalRelationInterpretation__SymbolAssignment_2
15054 {
15055 pushFollow(FOLLOW_2);
15056 rule__GlobalRelationInterpretation__SymbolAssignment_2();
15057
15058 state._fsp--;
15059
15060
15061 }
15062
15063 after(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolAssignment_2());
15064
15065 }
15066
15067
15068 }
15069
15070 }
15071 catch (RecognitionException re) {
15072 reportError(re);
15073 recover(input,re);
15074 }
15075 finally {
15076
15077 restoreStackSize(stackSize);
15078
15079 }
15080 return ;
15081 }
15082 // $ANTLR end "rule__GlobalRelationInterpretation__Group__2__Impl"
15083
15084
15085 // $ANTLR start "rule__GlobalRelationInterpretation__Group__3"
15086 // InternalSolverLanguage.g:4888:1: rule__GlobalRelationInterpretation__Group__3 : rule__GlobalRelationInterpretation__Group__3__Impl rule__GlobalRelationInterpretation__Group__4 ;
15087 public final void rule__GlobalRelationInterpretation__Group__3() throws RecognitionException {
15088
15089 int stackSize = keepStackSize();
15090
15091 try {
15092 // InternalSolverLanguage.g:4892:1: ( rule__GlobalRelationInterpretation__Group__3__Impl rule__GlobalRelationInterpretation__Group__4 )
15093 // InternalSolverLanguage.g:4893:2: rule__GlobalRelationInterpretation__Group__3__Impl rule__GlobalRelationInterpretation__Group__4
15094 {
15095 pushFollow(FOLLOW_43);
15096 rule__GlobalRelationInterpretation__Group__3__Impl();
15097
15098 state._fsp--;
15099
15100 pushFollow(FOLLOW_2);
15101 rule__GlobalRelationInterpretation__Group__4();
15102
15103 state._fsp--;
15104
15105
15106 }
15107
15108 }
15109 catch (RecognitionException re) {
15110 reportError(re);
15111 recover(input,re);
15112 }
15113 finally {
15114
15115 restoreStackSize(stackSize);
15116
15117 }
15118 return ;
15119 }
15120 // $ANTLR end "rule__GlobalRelationInterpretation__Group__3"
15121
15122
15123 // $ANTLR start "rule__GlobalRelationInterpretation__Group__3__Impl"
15124 // InternalSolverLanguage.g:4900:1: rule__GlobalRelationInterpretation__Group__3__Impl : ( ':' ) ;
15125 public final void rule__GlobalRelationInterpretation__Group__3__Impl() throws RecognitionException {
15126
15127 int stackSize = keepStackSize();
15128
15129 try {
15130 // InternalSolverLanguage.g:4904:1: ( ( ':' ) )
15131 // InternalSolverLanguage.g:4905:1: ( ':' )
15132 {
15133 // InternalSolverLanguage.g:4905:1: ( ':' )
15134 // InternalSolverLanguage.g:4906:2: ':'
15135 {
15136 before(grammarAccess.getGlobalRelationInterpretationAccess().getColonKeyword_3());
15137 match(input,19,FOLLOW_2);
15138 after(grammarAccess.getGlobalRelationInterpretationAccess().getColonKeyword_3());
15139
15140 }
15141
15142
15143 }
15144
15145 }
15146 catch (RecognitionException re) {
15147 reportError(re);
15148 recover(input,re);
15149 }
15150 finally {
15151
15152 restoreStackSize(stackSize);
15153
15154 }
15155 return ;
15156 }
15157 // $ANTLR end "rule__GlobalRelationInterpretation__Group__3__Impl"
15158
15159
15160 // $ANTLR start "rule__GlobalRelationInterpretation__Group__4"
15161 // InternalSolverLanguage.g:4915:1: rule__GlobalRelationInterpretation__Group__4 : rule__GlobalRelationInterpretation__Group__4__Impl rule__GlobalRelationInterpretation__Group__5 ;
15162 public final void rule__GlobalRelationInterpretation__Group__4() throws RecognitionException {
15163
15164 int stackSize = keepStackSize();
15165
15166 try {
15167 // InternalSolverLanguage.g:4919:1: ( rule__GlobalRelationInterpretation__Group__4__Impl rule__GlobalRelationInterpretation__Group__5 )
15168 // InternalSolverLanguage.g:4920:2: rule__GlobalRelationInterpretation__Group__4__Impl rule__GlobalRelationInterpretation__Group__5
15169 {
15170 pushFollow(FOLLOW_43);
15171 rule__GlobalRelationInterpretation__Group__4__Impl();
15172
15173 state._fsp--;
15174
15175 pushFollow(FOLLOW_2);
15176 rule__GlobalRelationInterpretation__Group__5();
15177
15178 state._fsp--;
15179
15180
15181 }
15182
15183 }
15184 catch (RecognitionException re) {
15185 reportError(re);
15186 recover(input,re);
15187 }
15188 finally {
15189
15190 restoreStackSize(stackSize);
15191
15192 }
15193 return ;
15194 }
15195 // $ANTLR end "rule__GlobalRelationInterpretation__Group__4"
15196
15197
15198 // $ANTLR start "rule__GlobalRelationInterpretation__Group__4__Impl"
15199 // InternalSolverLanguage.g:4927:1: rule__GlobalRelationInterpretation__Group__4__Impl : ( ( rule__GlobalRelationInterpretation__SourceMultiplicityAssignment_4 )? ) ;
15200 public final void rule__GlobalRelationInterpretation__Group__4__Impl() throws RecognitionException {
15201
15202 int stackSize = keepStackSize();
15203
15204 try {
15205 // InternalSolverLanguage.g:4931:1: ( ( ( rule__GlobalRelationInterpretation__SourceMultiplicityAssignment_4 )? ) )
15206 // InternalSolverLanguage.g:4932:1: ( ( rule__GlobalRelationInterpretation__SourceMultiplicityAssignment_4 )? )
15207 {
15208 // InternalSolverLanguage.g:4932:1: ( ( rule__GlobalRelationInterpretation__SourceMultiplicityAssignment_4 )? )
15209 // InternalSolverLanguage.g:4933:2: ( rule__GlobalRelationInterpretation__SourceMultiplicityAssignment_4 )?
15210 {
15211 before(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityAssignment_4());
15212 // InternalSolverLanguage.g:4934:2: ( rule__GlobalRelationInterpretation__SourceMultiplicityAssignment_4 )?
15213 int alt39=2;
15214 int LA39_0 = input.LA(1);
15215
15216 if ( (LA39_0==RULE_INT) ) {
15217 alt39=1;
15218 }
15219 switch (alt39) {
15220 case 1 :
15221 // InternalSolverLanguage.g:4934:3: rule__GlobalRelationInterpretation__SourceMultiplicityAssignment_4
15222 {
15223 pushFollow(FOLLOW_2);
15224 rule__GlobalRelationInterpretation__SourceMultiplicityAssignment_4();
15225
15226 state._fsp--;
15227
15228
15229 }
15230 break;
15231
15232 }
15233
15234 after(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityAssignment_4());
15235
15236 }
15237
15238
15239 }
15240
15241 }
15242 catch (RecognitionException re) {
15243 reportError(re);
15244 recover(input,re);
15245 }
15246 finally {
15247
15248 restoreStackSize(stackSize);
15249
15250 }
15251 return ;
15252 }
15253 // $ANTLR end "rule__GlobalRelationInterpretation__Group__4__Impl"
15254
15255
15256 // $ANTLR start "rule__GlobalRelationInterpretation__Group__5"
15257 // InternalSolverLanguage.g:4942:1: rule__GlobalRelationInterpretation__Group__5 : rule__GlobalRelationInterpretation__Group__5__Impl rule__GlobalRelationInterpretation__Group__6 ;
15258 public final void rule__GlobalRelationInterpretation__Group__5() throws RecognitionException {
15259
15260 int stackSize = keepStackSize();
15261
15262 try {
15263 // InternalSolverLanguage.g:4946:1: ( rule__GlobalRelationInterpretation__Group__5__Impl rule__GlobalRelationInterpretation__Group__6 )
15264 // InternalSolverLanguage.g:4947:2: rule__GlobalRelationInterpretation__Group__5__Impl rule__GlobalRelationInterpretation__Group__6
15265 {
15266 pushFollow(FOLLOW_43);
15267 rule__GlobalRelationInterpretation__Group__5__Impl();
15268
15269 state._fsp--;
15270
15271 pushFollow(FOLLOW_2);
15272 rule__GlobalRelationInterpretation__Group__6();
15273
15274 state._fsp--;
15275
15276
15277 }
15278
15279 }
15280 catch (RecognitionException re) {
15281 reportError(re);
15282 recover(input,re);
15283 }
15284 finally {
15285
15286 restoreStackSize(stackSize);
15287
15288 }
15289 return ;
15290 }
15291 // $ANTLR end "rule__GlobalRelationInterpretation__Group__5"
15292
15293
15294 // $ANTLR start "rule__GlobalRelationInterpretation__Group__5__Impl"
15295 // InternalSolverLanguage.g:4954:1: rule__GlobalRelationInterpretation__Group__5__Impl : ( ( rule__GlobalRelationInterpretation__SourceAssignment_5 ) ) ;
15296 public final void rule__GlobalRelationInterpretation__Group__5__Impl() throws RecognitionException {
15297
15298 int stackSize = keepStackSize();
15299
15300 try {
15301 // InternalSolverLanguage.g:4958:1: ( ( ( rule__GlobalRelationInterpretation__SourceAssignment_5 ) ) )
15302 // InternalSolverLanguage.g:4959:1: ( ( rule__GlobalRelationInterpretation__SourceAssignment_5 ) )
15303 {
15304 // InternalSolverLanguage.g:4959:1: ( ( rule__GlobalRelationInterpretation__SourceAssignment_5 ) )
15305 // InternalSolverLanguage.g:4960:2: ( rule__GlobalRelationInterpretation__SourceAssignment_5 )
15306 {
15307 before(grammarAccess.getGlobalRelationInterpretationAccess().getSourceAssignment_5());
15308 // InternalSolverLanguage.g:4961:2: ( rule__GlobalRelationInterpretation__SourceAssignment_5 )
15309 // InternalSolverLanguage.g:4961:3: rule__GlobalRelationInterpretation__SourceAssignment_5
15310 {
15311 pushFollow(FOLLOW_2);
15312 rule__GlobalRelationInterpretation__SourceAssignment_5();
15313
15314 state._fsp--;
15315
15316
15317 }
15318
15319 after(grammarAccess.getGlobalRelationInterpretationAccess().getSourceAssignment_5());
15320
15321 }
15322
15323
15324 }
15325
15326 }
15327 catch (RecognitionException re) {
15328 reportError(re);
15329 recover(input,re);
15330 }
15331 finally {
15332
15333 restoreStackSize(stackSize);
15334
15335 }
15336 return ;
15337 }
15338 // $ANTLR end "rule__GlobalRelationInterpretation__Group__5__Impl"
15339
15340
15341 // $ANTLR start "rule__GlobalRelationInterpretation__Group__6"
15342 // InternalSolverLanguage.g:4969:1: rule__GlobalRelationInterpretation__Group__6 : rule__GlobalRelationInterpretation__Group__6__Impl rule__GlobalRelationInterpretation__Group__7 ;
15343 public final void rule__GlobalRelationInterpretation__Group__6() throws RecognitionException {
15344
15345 int stackSize = keepStackSize();
15346
15347 try {
15348 // InternalSolverLanguage.g:4973:1: ( rule__GlobalRelationInterpretation__Group__6__Impl rule__GlobalRelationInterpretation__Group__7 )
15349 // InternalSolverLanguage.g:4974:2: rule__GlobalRelationInterpretation__Group__6__Impl rule__GlobalRelationInterpretation__Group__7
15350 {
15351 pushFollow(FOLLOW_43);
15352 rule__GlobalRelationInterpretation__Group__6__Impl();
15353
15354 state._fsp--;
15355
15356 pushFollow(FOLLOW_2);
15357 rule__GlobalRelationInterpretation__Group__7();
15358
15359 state._fsp--;
15360
15361
15362 }
15363
15364 }
15365 catch (RecognitionException re) {
15366 reportError(re);
15367 recover(input,re);
15368 }
15369 finally {
15370
15371 restoreStackSize(stackSize);
15372
15373 }
15374 return ;
15375 }
15376 // $ANTLR end "rule__GlobalRelationInterpretation__Group__6"
15377
15378
15379 // $ANTLR start "rule__GlobalRelationInterpretation__Group__6__Impl"
15380 // InternalSolverLanguage.g:4981:1: rule__GlobalRelationInterpretation__Group__6__Impl : ( ( rule__GlobalRelationInterpretation__TargetMultiplicityAssignment_6 )? ) ;
15381 public final void rule__GlobalRelationInterpretation__Group__6__Impl() throws RecognitionException {
15382
15383 int stackSize = keepStackSize();
15384
15385 try {
15386 // InternalSolverLanguage.g:4985:1: ( ( ( rule__GlobalRelationInterpretation__TargetMultiplicityAssignment_6 )? ) )
15387 // InternalSolverLanguage.g:4986:1: ( ( rule__GlobalRelationInterpretation__TargetMultiplicityAssignment_6 )? )
15388 {
15389 // InternalSolverLanguage.g:4986:1: ( ( rule__GlobalRelationInterpretation__TargetMultiplicityAssignment_6 )? )
15390 // InternalSolverLanguage.g:4987:2: ( rule__GlobalRelationInterpretation__TargetMultiplicityAssignment_6 )?
15391 {
15392 before(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityAssignment_6());
15393 // InternalSolverLanguage.g:4988:2: ( rule__GlobalRelationInterpretation__TargetMultiplicityAssignment_6 )?
15394 int alt40=2;
15395 int LA40_0 = input.LA(1);
15396
15397 if ( (LA40_0==RULE_INT) ) {
15398 alt40=1;
15399 }
15400 switch (alt40) {
15401 case 1 :
15402 // InternalSolverLanguage.g:4988:3: rule__GlobalRelationInterpretation__TargetMultiplicityAssignment_6
15403 {
15404 pushFollow(FOLLOW_2);
15405 rule__GlobalRelationInterpretation__TargetMultiplicityAssignment_6();
15406
15407 state._fsp--;
15408
15409
15410 }
15411 break;
15412
15413 }
15414
15415 after(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityAssignment_6());
15416
15417 }
15418
15419
15420 }
15421
15422 }
15423 catch (RecognitionException re) {
15424 reportError(re);
15425 recover(input,re);
15426 }
15427 finally {
15428
15429 restoreStackSize(stackSize);
15430
15431 }
15432 return ;
15433 }
15434 // $ANTLR end "rule__GlobalRelationInterpretation__Group__6__Impl"
15435
15436
15437 // $ANTLR start "rule__GlobalRelationInterpretation__Group__7"
15438 // InternalSolverLanguage.g:4996:1: rule__GlobalRelationInterpretation__Group__7 : rule__GlobalRelationInterpretation__Group__7__Impl ;
15439 public final void rule__GlobalRelationInterpretation__Group__7() throws RecognitionException {
15440
15441 int stackSize = keepStackSize();
15442
15443 try {
15444 // InternalSolverLanguage.g:5000:1: ( rule__GlobalRelationInterpretation__Group__7__Impl )
15445 // InternalSolverLanguage.g:5001:2: rule__GlobalRelationInterpretation__Group__7__Impl
15446 {
15447 pushFollow(FOLLOW_2);
15448 rule__GlobalRelationInterpretation__Group__7__Impl();
15449
15450 state._fsp--;
15451
15452
15453 }
15454
15455 }
15456 catch (RecognitionException re) {
15457 reportError(re);
15458 recover(input,re);
15459 }
15460 finally {
15461
15462 restoreStackSize(stackSize);
15463
15464 }
15465 return ;
15466 }
15467 // $ANTLR end "rule__GlobalRelationInterpretation__Group__7"
15468
15469
15470 // $ANTLR start "rule__GlobalRelationInterpretation__Group__7__Impl"
15471 // InternalSolverLanguage.g:5007:1: rule__GlobalRelationInterpretation__Group__7__Impl : ( ( rule__GlobalRelationInterpretation__TargetAssignment_7 ) ) ;
15472 public final void rule__GlobalRelationInterpretation__Group__7__Impl() throws RecognitionException {
15473
15474 int stackSize = keepStackSize();
15475
15476 try {
15477 // InternalSolverLanguage.g:5011:1: ( ( ( rule__GlobalRelationInterpretation__TargetAssignment_7 ) ) )
15478 // InternalSolverLanguage.g:5012:1: ( ( rule__GlobalRelationInterpretation__TargetAssignment_7 ) )
15479 {
15480 // InternalSolverLanguage.g:5012:1: ( ( rule__GlobalRelationInterpretation__TargetAssignment_7 ) )
15481 // InternalSolverLanguage.g:5013:2: ( rule__GlobalRelationInterpretation__TargetAssignment_7 )
15482 {
15483 before(grammarAccess.getGlobalRelationInterpretationAccess().getTargetAssignment_7());
15484 // InternalSolverLanguage.g:5014:2: ( rule__GlobalRelationInterpretation__TargetAssignment_7 )
15485 // InternalSolverLanguage.g:5014:3: rule__GlobalRelationInterpretation__TargetAssignment_7
15486 {
15487 pushFollow(FOLLOW_2);
15488 rule__GlobalRelationInterpretation__TargetAssignment_7();
15489
15490 state._fsp--;
15491
15492
15493 }
15494
15495 after(grammarAccess.getGlobalRelationInterpretationAccess().getTargetAssignment_7());
15496
15497 }
15498
15499
15500 }
15501
15502 }
15503 catch (RecognitionException re) {
15504 reportError(re);
15505 recover(input,re);
15506 }
15507 finally {
15508
15509 restoreStackSize(stackSize);
15510
15511 }
15512 return ;
15513 }
15514 // $ANTLR end "rule__GlobalRelationInterpretation__Group__7__Impl"
15515
15516
15517 // $ANTLR start "rule__MultiplicityDefinition__Group__0"
15518 // InternalSolverLanguage.g:5023:1: rule__MultiplicityDefinition__Group__0 : rule__MultiplicityDefinition__Group__0__Impl rule__MultiplicityDefinition__Group__1 ;
15519 public final void rule__MultiplicityDefinition__Group__0() throws RecognitionException {
15520
15521 int stackSize = keepStackSize();
15522
15523 try {
15524 // InternalSolverLanguage.g:5027:1: ( rule__MultiplicityDefinition__Group__0__Impl rule__MultiplicityDefinition__Group__1 )
15525 // InternalSolverLanguage.g:5028:2: rule__MultiplicityDefinition__Group__0__Impl rule__MultiplicityDefinition__Group__1
15526 {
15527 pushFollow(FOLLOW_45);
15528 rule__MultiplicityDefinition__Group__0__Impl();
15529
15530 state._fsp--;
15531
15532 pushFollow(FOLLOW_2);
15533 rule__MultiplicityDefinition__Group__1();
15534
15535 state._fsp--;
15536
15537
15538 }
15539
15540 }
15541 catch (RecognitionException re) {
15542 reportError(re);
15543 recover(input,re);
15544 }
15545 finally {
15546
15547 restoreStackSize(stackSize);
15548
15549 }
15550 return ;
15551 }
15552 // $ANTLR end "rule__MultiplicityDefinition__Group__0"
15553
15554
15555 // $ANTLR start "rule__MultiplicityDefinition__Group__0__Impl"
15556 // InternalSolverLanguage.g:5035:1: rule__MultiplicityDefinition__Group__0__Impl : ( ( rule__MultiplicityDefinition__LowerAssignment_0 ) ) ;
15557 public final void rule__MultiplicityDefinition__Group__0__Impl() throws RecognitionException {
15558
15559 int stackSize = keepStackSize();
15560
15561 try {
15562 // InternalSolverLanguage.g:5039:1: ( ( ( rule__MultiplicityDefinition__LowerAssignment_0 ) ) )
15563 // InternalSolverLanguage.g:5040:1: ( ( rule__MultiplicityDefinition__LowerAssignment_0 ) )
15564 {
15565 // InternalSolverLanguage.g:5040:1: ( ( rule__MultiplicityDefinition__LowerAssignment_0 ) )
15566 // InternalSolverLanguage.g:5041:2: ( rule__MultiplicityDefinition__LowerAssignment_0 )
15567 {
15568 before(grammarAccess.getMultiplicityDefinitionAccess().getLowerAssignment_0());
15569 // InternalSolverLanguage.g:5042:2: ( rule__MultiplicityDefinition__LowerAssignment_0 )
15570 // InternalSolverLanguage.g:5042:3: rule__MultiplicityDefinition__LowerAssignment_0
15571 {
15572 pushFollow(FOLLOW_2);
15573 rule__MultiplicityDefinition__LowerAssignment_0();
15574
15575 state._fsp--;
15576
15577
15578 }
15579
15580 after(grammarAccess.getMultiplicityDefinitionAccess().getLowerAssignment_0());
15581
15582 }
15583
15584
15585 }
15586
15587 }
15588 catch (RecognitionException re) {
15589 reportError(re);
15590 recover(input,re);
15591 }
15592 finally {
15593
15594 restoreStackSize(stackSize);
15595
15596 }
15597 return ;
15598 }
15599 // $ANTLR end "rule__MultiplicityDefinition__Group__0__Impl"
15600
15601
15602 // $ANTLR start "rule__MultiplicityDefinition__Group__1"
15603 // InternalSolverLanguage.g:5050:1: rule__MultiplicityDefinition__Group__1 : rule__MultiplicityDefinition__Group__1__Impl rule__MultiplicityDefinition__Group__2 ;
15604 public final void rule__MultiplicityDefinition__Group__1() throws RecognitionException {
15605
15606 int stackSize = keepStackSize();
15607
15608 try {
15609 // InternalSolverLanguage.g:5054:1: ( rule__MultiplicityDefinition__Group__1__Impl rule__MultiplicityDefinition__Group__2 )
15610 // InternalSolverLanguage.g:5055:2: rule__MultiplicityDefinition__Group__1__Impl rule__MultiplicityDefinition__Group__2
15611 {
15612 pushFollow(FOLLOW_46);
15613 rule__MultiplicityDefinition__Group__1__Impl();
15614
15615 state._fsp--;
15616
15617 pushFollow(FOLLOW_2);
15618 rule__MultiplicityDefinition__Group__2();
15619
15620 state._fsp--;
15621
15622
15623 }
15624
15625 }
15626 catch (RecognitionException re) {
15627 reportError(re);
15628 recover(input,re);
15629 }
15630 finally {
15631
15632 restoreStackSize(stackSize);
15633
15634 }
15635 return ;
15636 }
15637 // $ANTLR end "rule__MultiplicityDefinition__Group__1"
15638
15639
15640 // $ANTLR start "rule__MultiplicityDefinition__Group__1__Impl"
15641 // InternalSolverLanguage.g:5062:1: rule__MultiplicityDefinition__Group__1__Impl : ( '..' ) ;
15642 public final void rule__MultiplicityDefinition__Group__1__Impl() throws RecognitionException {
15643
15644 int stackSize = keepStackSize();
15645
15646 try {
15647 // InternalSolverLanguage.g:5066:1: ( ( '..' ) )
15648 // InternalSolverLanguage.g:5067:1: ( '..' )
15649 {
15650 // InternalSolverLanguage.g:5067:1: ( '..' )
15651 // InternalSolverLanguage.g:5068:2: '..'
15652 {
15653 before(grammarAccess.getMultiplicityDefinitionAccess().getFullStopFullStopKeyword_1());
15654 match(input,38,FOLLOW_2);
15655 after(grammarAccess.getMultiplicityDefinitionAccess().getFullStopFullStopKeyword_1());
15656
15657 }
15658
15659
15660 }
15661
15662 }
15663 catch (RecognitionException re) {
15664 reportError(re);
15665 recover(input,re);
15666 }
15667 finally {
15668
15669 restoreStackSize(stackSize);
15670
15671 }
15672 return ;
15673 }
15674 // $ANTLR end "rule__MultiplicityDefinition__Group__1__Impl"
15675
15676
15677 // $ANTLR start "rule__MultiplicityDefinition__Group__2"
15678 // InternalSolverLanguage.g:5077:1: rule__MultiplicityDefinition__Group__2 : rule__MultiplicityDefinition__Group__2__Impl ;
15679 public final void rule__MultiplicityDefinition__Group__2() throws RecognitionException {
15680
15681 int stackSize = keepStackSize();
15682
15683 try {
15684 // InternalSolverLanguage.g:5081:1: ( rule__MultiplicityDefinition__Group__2__Impl )
15685 // InternalSolverLanguage.g:5082:2: rule__MultiplicityDefinition__Group__2__Impl
15686 {
15687 pushFollow(FOLLOW_2);
15688 rule__MultiplicityDefinition__Group__2__Impl();
15689
15690 state._fsp--;
15691
15692
15693 }
15694
15695 }
15696 catch (RecognitionException re) {
15697 reportError(re);
15698 recover(input,re);
15699 }
15700 finally {
15701
15702 restoreStackSize(stackSize);
15703
15704 }
15705 return ;
15706 }
15707 // $ANTLR end "rule__MultiplicityDefinition__Group__2"
15708
15709
15710 // $ANTLR start "rule__MultiplicityDefinition__Group__2__Impl"
15711 // InternalSolverLanguage.g:5088:1: rule__MultiplicityDefinition__Group__2__Impl : ( ( rule__MultiplicityDefinition__Alternatives_2 ) ) ;
15712 public final void rule__MultiplicityDefinition__Group__2__Impl() throws RecognitionException {
15713
15714 int stackSize = keepStackSize();
15715
15716 try {
15717 // InternalSolverLanguage.g:5092:1: ( ( ( rule__MultiplicityDefinition__Alternatives_2 ) ) )
15718 // InternalSolverLanguage.g:5093:1: ( ( rule__MultiplicityDefinition__Alternatives_2 ) )
15719 {
15720 // InternalSolverLanguage.g:5093:1: ( ( rule__MultiplicityDefinition__Alternatives_2 ) )
15721 // InternalSolverLanguage.g:5094:2: ( rule__MultiplicityDefinition__Alternatives_2 )
15722 {
15723 before(grammarAccess.getMultiplicityDefinitionAccess().getAlternatives_2());
15724 // InternalSolverLanguage.g:5095:2: ( rule__MultiplicityDefinition__Alternatives_2 )
15725 // InternalSolverLanguage.g:5095:3: rule__MultiplicityDefinition__Alternatives_2
15726 {
15727 pushFollow(FOLLOW_2);
15728 rule__MultiplicityDefinition__Alternatives_2();
15729
15730 state._fsp--;
15731
15732
15733 }
15734
15735 after(grammarAccess.getMultiplicityDefinitionAccess().getAlternatives_2());
15736
15737 }
15738
15739
15740 }
15741
15742 }
15743 catch (RecognitionException re) {
15744 reportError(re);
15745 recover(input,re);
15746 }
15747 finally {
15748
15749 restoreStackSize(stackSize);
15750
15751 }
15752 return ;
15753 }
15754 // $ANTLR end "rule__MultiplicityDefinition__Group__2__Impl"
15755
15756
15757 // $ANTLR start "rule__Problem__StatementsAssignment"
15758 // InternalSolverLanguage.g:5104:1: rule__Problem__StatementsAssignment : ( ruleStatement ) ;
15759 public final void rule__Problem__StatementsAssignment() throws RecognitionException {
15760
15761 int stackSize = keepStackSize();
15762
15763 try {
15764 // InternalSolverLanguage.g:5108:1: ( ( ruleStatement ) )
15765 // InternalSolverLanguage.g:5109:2: ( ruleStatement )
15766 {
15767 // InternalSolverLanguage.g:5109:2: ( ruleStatement )
15768 // InternalSolverLanguage.g:5110:3: ruleStatement
15769 {
15770 before(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0());
15771 pushFollow(FOLLOW_2);
15772 ruleStatement();
15773
15774 state._fsp--;
15775
15776 after(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0());
15777
15778 }
15779
15780
15781 }
15782
15783 }
15784 catch (RecognitionException re) {
15785 reportError(re);
15786 recover(input,re);
15787 }
15788 finally {
15789
15790 restoreStackSize(stackSize);
15791
15792 }
15793 return ;
15794 }
15795 // $ANTLR end "rule__Problem__StatementsAssignment"
15796
15797
15798 // $ANTLR start "rule__BasicInterpretation__SymbolAssignment_0"
15799 // InternalSolverLanguage.g:5119:1: rule__BasicInterpretation__SymbolAssignment_0 : ( ruleSymbol ) ;
15800 public final void rule__BasicInterpretation__SymbolAssignment_0() throws RecognitionException {
15801
15802 int stackSize = keepStackSize();
15803
15804 try {
15805 // InternalSolverLanguage.g:5123:1: ( ( ruleSymbol ) )
15806 // InternalSolverLanguage.g:5124:2: ( ruleSymbol )
15807 {
15808 // InternalSolverLanguage.g:5124:2: ( ruleSymbol )
15809 // InternalSolverLanguage.g:5125:3: ruleSymbol
15810 {
15811 before(grammarAccess.getBasicInterpretationAccess().getSymbolSymbolParserRuleCall_0_0());
15812 pushFollow(FOLLOW_2);
15813 ruleSymbol();
15814
15815 state._fsp--;
15816
15817 after(grammarAccess.getBasicInterpretationAccess().getSymbolSymbolParserRuleCall_0_0());
15818
15819 }
15820
15821
15822 }
15823
15824 }
15825 catch (RecognitionException re) {
15826 reportError(re);
15827 recover(input,re);
15828 }
15829 finally {
15830
15831 restoreStackSize(stackSize);
15832
15833 }
15834 return ;
15835 }
15836 // $ANTLR end "rule__BasicInterpretation__SymbolAssignment_0"
15837
15838
15839 // $ANTLR start "rule__BasicInterpretation__ObjectsAssignment_2"
15840 // InternalSolverLanguage.g:5134:1: rule__BasicInterpretation__ObjectsAssignment_2 : ( ruleComplexObject ) ;
15841 public final void rule__BasicInterpretation__ObjectsAssignment_2() throws RecognitionException {
15842
15843 int stackSize = keepStackSize();
15844
15845 try {
15846 // InternalSolverLanguage.g:5138:1: ( ( ruleComplexObject ) )
15847 // InternalSolverLanguage.g:5139:2: ( ruleComplexObject )
15848 {
15849 // InternalSolverLanguage.g:5139:2: ( ruleComplexObject )
15850 // InternalSolverLanguage.g:5140:3: ruleComplexObject
15851 {
15852 before(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_2_0());
15853 pushFollow(FOLLOW_2);
15854 ruleComplexObject();
15855
15856 state._fsp--;
15857
15858 after(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_2_0());
15859
15860 }
15861
15862
15863 }
15864
15865 }
15866 catch (RecognitionException re) {
15867 reportError(re);
15868 recover(input,re);
15869 }
15870 finally {
15871
15872 restoreStackSize(stackSize);
15873
15874 }
15875 return ;
15876 }
15877 // $ANTLR end "rule__BasicInterpretation__ObjectsAssignment_2"
15878
15879
15880 // $ANTLR start "rule__BasicInterpretation__ValueAssignment_5"
15881 // InternalSolverLanguage.g:5149:1: rule__BasicInterpretation__ValueAssignment_5 : ( ruleTruthValue ) ;
15882 public final void rule__BasicInterpretation__ValueAssignment_5() throws RecognitionException {
15883
15884 int stackSize = keepStackSize();
15885
15886 try {
15887 // InternalSolverLanguage.g:5153:1: ( ( ruleTruthValue ) )
15888 // InternalSolverLanguage.g:5154:2: ( ruleTruthValue )
15889 {
15890 // InternalSolverLanguage.g:5154:2: ( ruleTruthValue )
15891 // InternalSolverLanguage.g:5155:3: ruleTruthValue
15892 {
15893 before(grammarAccess.getBasicInterpretationAccess().getValueTruthValueParserRuleCall_5_0());
15894 pushFollow(FOLLOW_2);
15895 ruleTruthValue();
15896
15897 state._fsp--;
15898
15899 after(grammarAccess.getBasicInterpretationAccess().getValueTruthValueParserRuleCall_5_0());
15900
15901 }
15902
15903
15904 }
15905
15906 }
15907 catch (RecognitionException re) {
15908 reportError(re);
15909 recover(input,re);
15910 }
15911 finally {
15912
15913 restoreStackSize(stackSize);
15914
15915 }
15916 return ;
15917 }
15918 // $ANTLR end "rule__BasicInterpretation__ValueAssignment_5"
15919
15920
15921 // $ANTLR start "rule__ModelSymbol__NameAssignment"
15922 // InternalSolverLanguage.g:5164:1: rule__ModelSymbol__NameAssignment : ( RULE_ID ) ;
15923 public final void rule__ModelSymbol__NameAssignment() throws RecognitionException {
15924
15925 int stackSize = keepStackSize();
15926
15927 try {
15928 // InternalSolverLanguage.g:5168:1: ( ( RULE_ID ) )
15929 // InternalSolverLanguage.g:5169:2: ( RULE_ID )
15930 {
15931 // InternalSolverLanguage.g:5169:2: ( RULE_ID )
15932 // InternalSolverLanguage.g:5170:3: RULE_ID
15933 {
15934 before(grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0());
15935 match(input,RULE_ID,FOLLOW_2);
15936 after(grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0());
15937
15938 }
15939
15940
15941 }
15942
15943 }
15944 catch (RecognitionException re) {
15945 reportError(re);
15946 recover(input,re);
15947 }
15948 finally {
15949
15950 restoreStackSize(stackSize);
15951
15952 }
15953 return ;
15954 }
15955 // $ANTLR end "rule__ModelSymbol__NameAssignment"
15956
15957
15958 // $ANTLR start "rule__NamedObject__NameAssignment_1"
15959 // InternalSolverLanguage.g:5179:1: rule__NamedObject__NameAssignment_1 : ( RULE_ID ) ;
15960 public final void rule__NamedObject__NameAssignment_1() throws RecognitionException {
15961
15962 int stackSize = keepStackSize();
15963
15964 try {
15965 // InternalSolverLanguage.g:5183:1: ( ( RULE_ID ) )
15966 // InternalSolverLanguage.g:5184:2: ( RULE_ID )
15967 {
15968 // InternalSolverLanguage.g:5184:2: ( RULE_ID )
15969 // InternalSolverLanguage.g:5185:3: RULE_ID
15970 {
15971 before(grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0());
15972 match(input,RULE_ID,FOLLOW_2);
15973 after(grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0());
15974
15975 }
15976
15977
15978 }
15979
15980 }
15981 catch (RecognitionException re) {
15982 reportError(re);
15983 recover(input,re);
15984 }
15985 finally {
15986
15987 restoreStackSize(stackSize);
15988
15989 }
15990 return ;
15991 }
15992 // $ANTLR end "rule__NamedObject__NameAssignment_1"
15993
15994
15995 // $ANTLR start "rule__UnnamedObject__NameAssignment"
15996 // InternalSolverLanguage.g:5194:1: rule__UnnamedObject__NameAssignment : ( RULE_ID ) ;
15997 public final void rule__UnnamedObject__NameAssignment() throws RecognitionException {
15998
15999 int stackSize = keepStackSize();
16000
16001 try {
16002 // InternalSolverLanguage.g:5198:1: ( ( RULE_ID ) )
16003 // InternalSolverLanguage.g:5199:2: ( RULE_ID )
16004 {
16005 // InternalSolverLanguage.g:5199:2: ( RULE_ID )
16006 // InternalSolverLanguage.g:5200:3: RULE_ID
16007 {
16008 before(grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0());
16009 match(input,RULE_ID,FOLLOW_2);
16010 after(grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0());
16011
16012 }
16013
16014
16015 }
16016
16017 }
16018 catch (RecognitionException re) {
16019 reportError(re);
16020 recover(input,re);
16021 }
16022 finally {
16023
16024 restoreStackSize(stackSize);
16025
16026 }
16027 return ;
16028 }
16029 // $ANTLR end "rule__UnnamedObject__NameAssignment"
16030
16031
16032 // $ANTLR start "rule__BooleanObject__ValueAssignment"
16033 // InternalSolverLanguage.g:5209:1: rule__BooleanObject__ValueAssignment : ( ruleBooleanValue ) ;
16034 public final void rule__BooleanObject__ValueAssignment() throws RecognitionException {
16035
16036 int stackSize = keepStackSize();
16037
16038 try {
16039 // InternalSolverLanguage.g:5213:1: ( ( ruleBooleanValue ) )
16040 // InternalSolverLanguage.g:5214:2: ( ruleBooleanValue )
16041 {
16042 // InternalSolverLanguage.g:5214:2: ( ruleBooleanValue )
16043 // InternalSolverLanguage.g:5215:3: ruleBooleanValue
16044 {
16045 before(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0());
16046 pushFollow(FOLLOW_2);
16047 ruleBooleanValue();
16048
16049 state._fsp--;
16050
16051 after(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0());
16052
16053 }
16054
16055
16056 }
16057
16058 }
16059 catch (RecognitionException re) {
16060 reportError(re);
16061 recover(input,re);
16062 }
16063 finally {
16064
16065 restoreStackSize(stackSize);
16066
16067 }
16068 return ;
16069 }
16070 // $ANTLR end "rule__BooleanObject__ValueAssignment"
16071
16072
16073 // $ANTLR start "rule__IntObject__ValueAssignment"
16074 // InternalSolverLanguage.g:5224:1: rule__IntObject__ValueAssignment : ( ruleINTLiteral ) ;
16075 public final void rule__IntObject__ValueAssignment() throws RecognitionException {
16076
16077 int stackSize = keepStackSize();
16078
16079 try {
16080 // InternalSolverLanguage.g:5228:1: ( ( ruleINTLiteral ) )
16081 // InternalSolverLanguage.g:5229:2: ( ruleINTLiteral )
16082 {
16083 // InternalSolverLanguage.g:5229:2: ( ruleINTLiteral )
16084 // InternalSolverLanguage.g:5230:3: ruleINTLiteral
16085 {
16086 before(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0());
16087 pushFollow(FOLLOW_2);
16088 ruleINTLiteral();
16089
16090 state._fsp--;
16091
16092 after(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0());
16093
16094 }
16095
16096
16097 }
16098
16099 }
16100 catch (RecognitionException re) {
16101 reportError(re);
16102 recover(input,re);
16103 }
16104 finally {
16105
16106 restoreStackSize(stackSize);
16107
16108 }
16109 return ;
16110 }
16111 // $ANTLR end "rule__IntObject__ValueAssignment"
16112
16113
16114 // $ANTLR start "rule__RealObject__ValueAssignment"
16115 // InternalSolverLanguage.g:5239:1: rule__RealObject__ValueAssignment : ( ruleREALLiteral ) ;
16116 public final void rule__RealObject__ValueAssignment() throws RecognitionException {
16117
16118 int stackSize = keepStackSize();
16119
16120 try {
16121 // InternalSolverLanguage.g:5243:1: ( ( ruleREALLiteral ) )
16122 // InternalSolverLanguage.g:5244:2: ( ruleREALLiteral )
16123 {
16124 // InternalSolverLanguage.g:5244:2: ( ruleREALLiteral )
16125 // InternalSolverLanguage.g:5245:3: ruleREALLiteral
16126 {
16127 before(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0());
16128 pushFollow(FOLLOW_2);
16129 ruleREALLiteral();
16130
16131 state._fsp--;
16132
16133 after(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0());
16134
16135 }
16136
16137
16138 }
16139
16140 }
16141 catch (RecognitionException re) {
16142 reportError(re);
16143 recover(input,re);
16144 }
16145 finally {
16146
16147 restoreStackSize(stackSize);
16148
16149 }
16150 return ;
16151 }
16152 // $ANTLR end "rule__RealObject__ValueAssignment"
16153
16154
16155 // $ANTLR start "rule__StringObject__ValueAssignment"
16156 // InternalSolverLanguage.g:5254:1: rule__StringObject__ValueAssignment : ( RULE_STRING ) ;
16157 public final void rule__StringObject__ValueAssignment() throws RecognitionException {
16158
16159 int stackSize = keepStackSize();
16160
16161 try {
16162 // InternalSolverLanguage.g:5258:1: ( ( RULE_STRING ) )
16163 // InternalSolverLanguage.g:5259:2: ( RULE_STRING )
16164 {
16165 // InternalSolverLanguage.g:5259:2: ( RULE_STRING )
16166 // InternalSolverLanguage.g:5260:3: RULE_STRING
16167 {
16168 before(grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0());
16169 match(input,RULE_STRING,FOLLOW_2);
16170 after(grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0());
16171
16172 }
16173
16174
16175 }
16176
16177 }
16178 catch (RecognitionException re) {
16179 reportError(re);
16180 recover(input,re);
16181 }
16182 finally {
16183
16184 restoreStackSize(stackSize);
16185
16186 }
16187 return ;
16188 }
16189 // $ANTLR end "rule__StringObject__ValueAssignment"
16190
16191
16192 // $ANTLR start "rule__PredicateSymbol__SymbolAssignment_1"
16193 // InternalSolverLanguage.g:5269:1: rule__PredicateSymbol__SymbolAssignment_1 : ( ruleModelSymbol ) ;
16194 public final void rule__PredicateSymbol__SymbolAssignment_1() throws RecognitionException {
16195
16196 int stackSize = keepStackSize();
16197
16198 try {
16199 // InternalSolverLanguage.g:5273:1: ( ( ruleModelSymbol ) )
16200 // InternalSolverLanguage.g:5274:2: ( ruleModelSymbol )
16201 {
16202 // InternalSolverLanguage.g:5274:2: ( ruleModelSymbol )
16203 // InternalSolverLanguage.g:5275:3: ruleModelSymbol
16204 {
16205 before(grammarAccess.getPredicateSymbolAccess().getSymbolModelSymbolParserRuleCall_1_0());
16206 pushFollow(FOLLOW_2);
16207 ruleModelSymbol();
16208
16209 state._fsp--;
16210
16211 after(grammarAccess.getPredicateSymbolAccess().getSymbolModelSymbolParserRuleCall_1_0());
16212
16213 }
16214
16215
16216 }
16217
16218 }
16219 catch (RecognitionException re) {
16220 reportError(re);
16221 recover(input,re);
16222 }
16223 finally {
16224
16225 restoreStackSize(stackSize);
16226
16227 }
16228 return ;
16229 }
16230 // $ANTLR end "rule__PredicateSymbol__SymbolAssignment_1"
16231
16232
16233 // $ANTLR start "rule__PredicateSymbol__ParametersAssignment_3"
16234 // InternalSolverLanguage.g:5284:1: rule__PredicateSymbol__ParametersAssignment_3 : ( ruleParameter ) ;
16235 public final void rule__PredicateSymbol__ParametersAssignment_3() throws RecognitionException {
16236
16237 int stackSize = keepStackSize();
16238
16239 try {
16240 // InternalSolverLanguage.g:5288:1: ( ( ruleParameter ) )
16241 // InternalSolverLanguage.g:5289:2: ( ruleParameter )
16242 {
16243 // InternalSolverLanguage.g:5289:2: ( ruleParameter )
16244 // InternalSolverLanguage.g:5290:3: ruleParameter
16245 {
16246 before(grammarAccess.getPredicateSymbolAccess().getParametersParameterParserRuleCall_3_0());
16247 pushFollow(FOLLOW_2);
16248 ruleParameter();
16249
16250 state._fsp--;
16251
16252 after(grammarAccess.getPredicateSymbolAccess().getParametersParameterParserRuleCall_3_0());
16253
16254 }
16255
16256
16257 }
16258
16259 }
16260 catch (RecognitionException re) {
16261 reportError(re);
16262 recover(input,re);
16263 }
16264 finally {
16265
16266 restoreStackSize(stackSize);
16267
16268 }
16269 return ;
16270 }
16271 // $ANTLR end "rule__PredicateSymbol__ParametersAssignment_3"
16272
16273
16274 // $ANTLR start "rule__PredicateSymbol__BodiesAssignment_6_1_0"
16275 // InternalSolverLanguage.g:5299:1: rule__PredicateSymbol__BodiesAssignment_6_1_0 : ( rulePatternBody ) ;
16276 public final void rule__PredicateSymbol__BodiesAssignment_6_1_0() throws RecognitionException {
16277
16278 int stackSize = keepStackSize();
16279
16280 try {
16281 // InternalSolverLanguage.g:5303:1: ( ( rulePatternBody ) )
16282 // InternalSolverLanguage.g:5304:2: ( rulePatternBody )
16283 {
16284 // InternalSolverLanguage.g:5304:2: ( rulePatternBody )
16285 // InternalSolverLanguage.g:5305:3: rulePatternBody
16286 {
16287 before(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_0_0());
16288 pushFollow(FOLLOW_2);
16289 rulePatternBody();
16290
16291 state._fsp--;
16292
16293 after(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_0_0());
16294
16295 }
16296
16297
16298 }
16299
16300 }
16301 catch (RecognitionException re) {
16302 reportError(re);
16303 recover(input,re);
16304 }
16305 finally {
16306
16307 restoreStackSize(stackSize);
16308
16309 }
16310 return ;
16311 }
16312 // $ANTLR end "rule__PredicateSymbol__BodiesAssignment_6_1_0"
16313
16314
16315 // $ANTLR start "rule__PredicateSymbol__BodiesAssignment_6_1_1_1"
16316 // InternalSolverLanguage.g:5314:1: rule__PredicateSymbol__BodiesAssignment_6_1_1_1 : ( rulePatternBody ) ;
16317 public final void rule__PredicateSymbol__BodiesAssignment_6_1_1_1() throws RecognitionException {
16318
16319 int stackSize = keepStackSize();
16320
16321 try {
16322 // InternalSolverLanguage.g:5318:1: ( ( rulePatternBody ) )
16323 // InternalSolverLanguage.g:5319:2: ( rulePatternBody )
16324 {
16325 // InternalSolverLanguage.g:5319:2: ( rulePatternBody )
16326 // InternalSolverLanguage.g:5320:3: rulePatternBody
16327 {
16328 before(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_1_1_0());
16329 pushFollow(FOLLOW_2);
16330 rulePatternBody();
16331
16332 state._fsp--;
16333
16334 after(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_1_1_0());
16335
16336 }
16337
16338
16339 }
16340
16341 }
16342 catch (RecognitionException re) {
16343 reportError(re);
16344 recover(input,re);
16345 }
16346 finally {
16347
16348 restoreStackSize(stackSize);
16349
16350 }
16351 return ;
16352 }
16353 // $ANTLR end "rule__PredicateSymbol__BodiesAssignment_6_1_1_1"
16354
16355
16356 // $ANTLR start "rule__ErrorPredicate__NameAssignment_2"
16357 // InternalSolverLanguage.g:5329:1: rule__ErrorPredicate__NameAssignment_2 : ( RULE_ID ) ;
16358 public final void rule__ErrorPredicate__NameAssignment_2() throws RecognitionException {
16359
16360 int stackSize = keepStackSize();
16361
16362 try {
16363 // InternalSolverLanguage.g:5333:1: ( ( RULE_ID ) )
16364 // InternalSolverLanguage.g:5334:2: ( RULE_ID )
16365 {
16366 // InternalSolverLanguage.g:5334:2: ( RULE_ID )
16367 // InternalSolverLanguage.g:5335:3: RULE_ID
16368 {
16369 before(grammarAccess.getErrorPredicateAccess().getNameIDTerminalRuleCall_2_0());
16370 match(input,RULE_ID,FOLLOW_2);
16371 after(grammarAccess.getErrorPredicateAccess().getNameIDTerminalRuleCall_2_0());
16372
16373 }
16374
16375
16376 }
16377
16378 }
16379 catch (RecognitionException re) {
16380 reportError(re);
16381 recover(input,re);
16382 }
16383 finally {
16384
16385 restoreStackSize(stackSize);
16386
16387 }
16388 return ;
16389 }
16390 // $ANTLR end "rule__ErrorPredicate__NameAssignment_2"
16391
16392
16393 // $ANTLR start "rule__ErrorPredicate__ParametersAssignment_3_1"
16394 // InternalSolverLanguage.g:5344:1: rule__ErrorPredicate__ParametersAssignment_3_1 : ( ruleParameter ) ;
16395 public final void rule__ErrorPredicate__ParametersAssignment_3_1() throws RecognitionException {
16396
16397 int stackSize = keepStackSize();
16398
16399 try {
16400 // InternalSolverLanguage.g:5348:1: ( ( ruleParameter ) )
16401 // InternalSolverLanguage.g:5349:2: ( ruleParameter )
16402 {
16403 // InternalSolverLanguage.g:5349:2: ( ruleParameter )
16404 // InternalSolverLanguage.g:5350:3: ruleParameter
16405 {
16406 before(grammarAccess.getErrorPredicateAccess().getParametersParameterParserRuleCall_3_1_0());
16407 pushFollow(FOLLOW_2);
16408 ruleParameter();
16409
16410 state._fsp--;
16411
16412 after(grammarAccess.getErrorPredicateAccess().getParametersParameterParserRuleCall_3_1_0());
16413
16414 }
16415
16416
16417 }
16418
16419 }
16420 catch (RecognitionException re) {
16421 reportError(re);
16422 recover(input,re);
16423 }
16424 finally {
16425
16426 restoreStackSize(stackSize);
16427
16428 }
16429 return ;
16430 }
16431 // $ANTLR end "rule__ErrorPredicate__ParametersAssignment_3_1"
16432
16433
16434 // $ANTLR start "rule__ErrorPredicate__BodiesAssignment_5_1_0"
16435 // InternalSolverLanguage.g:5359:1: rule__ErrorPredicate__BodiesAssignment_5_1_0 : ( rulePatternBody ) ;
16436 public final void rule__ErrorPredicate__BodiesAssignment_5_1_0() throws RecognitionException {
16437
16438 int stackSize = keepStackSize();
16439
16440 try {
16441 // InternalSolverLanguage.g:5363:1: ( ( rulePatternBody ) )
16442 // InternalSolverLanguage.g:5364:2: ( rulePatternBody )
16443 {
16444 // InternalSolverLanguage.g:5364:2: ( rulePatternBody )
16445 // InternalSolverLanguage.g:5365:3: rulePatternBody
16446 {
16447 before(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_0_0());
16448 pushFollow(FOLLOW_2);
16449 rulePatternBody();
16450
16451 state._fsp--;
16452
16453 after(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_0_0());
16454
16455 }
16456
16457
16458 }
16459
16460 }
16461 catch (RecognitionException re) {
16462 reportError(re);
16463 recover(input,re);
16464 }
16465 finally {
16466
16467 restoreStackSize(stackSize);
16468
16469 }
16470 return ;
16471 }
16472 // $ANTLR end "rule__ErrorPredicate__BodiesAssignment_5_1_0"
16473
16474
16475 // $ANTLR start "rule__ErrorPredicate__BodiesAssignment_5_1_1_1"
16476 // InternalSolverLanguage.g:5374:1: rule__ErrorPredicate__BodiesAssignment_5_1_1_1 : ( rulePatternBody ) ;
16477 public final void rule__ErrorPredicate__BodiesAssignment_5_1_1_1() throws RecognitionException {
16478
16479 int stackSize = keepStackSize();
16480
16481 try {
16482 // InternalSolverLanguage.g:5378:1: ( ( rulePatternBody ) )
16483 // InternalSolverLanguage.g:5379:2: ( rulePatternBody )
16484 {
16485 // InternalSolverLanguage.g:5379:2: ( rulePatternBody )
16486 // InternalSolverLanguage.g:5380:3: rulePatternBody
16487 {
16488 before(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_1_1_0());
16489 pushFollow(FOLLOW_2);
16490 rulePatternBody();
16491
16492 state._fsp--;
16493
16494 after(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_1_1_0());
16495
16496 }
16497
16498
16499 }
16500
16501 }
16502 catch (RecognitionException re) {
16503 reportError(re);
16504 recover(input,re);
16505 }
16506 finally {
16507
16508 restoreStackSize(stackSize);
16509
16510 }
16511 return ;
16512 }
16513 // $ANTLR end "rule__ErrorPredicate__BodiesAssignment_5_1_1_1"
16514
16515
16516 // $ANTLR start "rule__Parameter__VariableAssignment_0"
16517 // InternalSolverLanguage.g:5389:1: rule__Parameter__VariableAssignment_0 : ( ruleVariable ) ;
16518 public final void rule__Parameter__VariableAssignment_0() throws RecognitionException {
16519
16520 int stackSize = keepStackSize();
16521
16522 try {
16523 // InternalSolverLanguage.g:5393:1: ( ( ruleVariable ) )
16524 // InternalSolverLanguage.g:5394:2: ( ruleVariable )
16525 {
16526 // InternalSolverLanguage.g:5394:2: ( ruleVariable )
16527 // InternalSolverLanguage.g:5395:3: ruleVariable
16528 {
16529 before(grammarAccess.getParameterAccess().getVariableVariableParserRuleCall_0_0());
16530 pushFollow(FOLLOW_2);
16531 ruleVariable();
16532
16533 state._fsp--;
16534
16535 after(grammarAccess.getParameterAccess().getVariableVariableParserRuleCall_0_0());
16536
16537 }
16538
16539
16540 }
16541
16542 }
16543 catch (RecognitionException re) {
16544 reportError(re);
16545 recover(input,re);
16546 }
16547 finally {
16548
16549 restoreStackSize(stackSize);
16550
16551 }
16552 return ;
16553 }
16554 // $ANTLR end "rule__Parameter__VariableAssignment_0"
16555
16556
16557 // $ANTLR start "rule__Parameter__TypeAssignment_1_1"
16558 // InternalSolverLanguage.g:5404:1: rule__Parameter__TypeAssignment_1_1 : ( ruleSymbol ) ;
16559 public final void rule__Parameter__TypeAssignment_1_1() throws RecognitionException {
16560
16561 int stackSize = keepStackSize();
16562
16563 try {
16564 // InternalSolverLanguage.g:5408:1: ( ( ruleSymbol ) )
16565 // InternalSolverLanguage.g:5409:2: ( ruleSymbol )
16566 {
16567 // InternalSolverLanguage.g:5409:2: ( ruleSymbol )
16568 // InternalSolverLanguage.g:5410:3: ruleSymbol
16569 {
16570 before(grammarAccess.getParameterAccess().getTypeSymbolParserRuleCall_1_1_0());
16571 pushFollow(FOLLOW_2);
16572 ruleSymbol();
16573
16574 state._fsp--;
16575
16576 after(grammarAccess.getParameterAccess().getTypeSymbolParserRuleCall_1_1_0());
16577
16578 }
16579
16580
16581 }
16582
16583 }
16584 catch (RecognitionException re) {
16585 reportError(re);
16586 recover(input,re);
16587 }
16588 finally {
16589
16590 restoreStackSize(stackSize);
16591
16592 }
16593 return ;
16594 }
16595 // $ANTLR end "rule__Parameter__TypeAssignment_1_1"
16596
16597
16598 // $ANTLR start "rule__PatternBody__ConstraintsAssignment_1_1"
16599 // InternalSolverLanguage.g:5419:1: rule__PatternBody__ConstraintsAssignment_1_1 : ( ruleConstraint ) ;
16600 public final void rule__PatternBody__ConstraintsAssignment_1_1() throws RecognitionException {
16601
16602 int stackSize = keepStackSize();
16603
16604 try {
16605 // InternalSolverLanguage.g:5423:1: ( ( ruleConstraint ) )
16606 // InternalSolverLanguage.g:5424:2: ( ruleConstraint )
16607 {
16608 // InternalSolverLanguage.g:5424:2: ( ruleConstraint )
16609 // InternalSolverLanguage.g:5425:3: ruleConstraint
16610 {
16611 before(grammarAccess.getPatternBodyAccess().getConstraintsConstraintParserRuleCall_1_1_0());
16612 pushFollow(FOLLOW_2);
16613 ruleConstraint();
16614
16615 state._fsp--;
16616
16617 after(grammarAccess.getPatternBodyAccess().getConstraintsConstraintParserRuleCall_1_1_0());
16618
16619 }
16620
16621
16622 }
16623
16624 }
16625 catch (RecognitionException re) {
16626 reportError(re);
16627 recover(input,re);
16628 }
16629 finally {
16630
16631 restoreStackSize(stackSize);
16632
16633 }
16634 return ;
16635 }
16636 // $ANTLR end "rule__PatternBody__ConstraintsAssignment_1_1"
16637
16638
16639 // $ANTLR start "rule__Constraint__PolarityAssignment_0"
16640 // InternalSolverLanguage.g:5434:1: rule__Constraint__PolarityAssignment_0 : ( rulePolarity ) ;
16641 public final void rule__Constraint__PolarityAssignment_0() throws RecognitionException {
16642
16643 int stackSize = keepStackSize();
16644
16645 try {
16646 // InternalSolverLanguage.g:5438:1: ( ( rulePolarity ) )
16647 // InternalSolverLanguage.g:5439:2: ( rulePolarity )
16648 {
16649 // InternalSolverLanguage.g:5439:2: ( rulePolarity )
16650 // InternalSolverLanguage.g:5440:3: rulePolarity
16651 {
16652 before(grammarAccess.getConstraintAccess().getPolarityPolarityParserRuleCall_0_0());
16653 pushFollow(FOLLOW_2);
16654 rulePolarity();
16655
16656 state._fsp--;
16657
16658 after(grammarAccess.getConstraintAccess().getPolarityPolarityParserRuleCall_0_0());
16659
16660 }
16661
16662
16663 }
16664
16665 }
16666 catch (RecognitionException re) {
16667 reportError(re);
16668 recover(input,re);
16669 }
16670 finally {
16671
16672 restoreStackSize(stackSize);
16673
16674 }
16675 return ;
16676 }
16677 // $ANTLR end "rule__Constraint__PolarityAssignment_0"
16678
16679
16680 // $ANTLR start "rule__Constraint__SymbolAssignment_1"
16681 // InternalSolverLanguage.g:5449:1: rule__Constraint__SymbolAssignment_1 : ( ruleModelSymbol ) ;
16682 public final void rule__Constraint__SymbolAssignment_1() throws RecognitionException {
16683
16684 int stackSize = keepStackSize();
16685
16686 try {
16687 // InternalSolverLanguage.g:5453:1: ( ( ruleModelSymbol ) )
16688 // InternalSolverLanguage.g:5454:2: ( ruleModelSymbol )
16689 {
16690 // InternalSolverLanguage.g:5454:2: ( ruleModelSymbol )
16691 // InternalSolverLanguage.g:5455:3: ruleModelSymbol
16692 {
16693 before(grammarAccess.getConstraintAccess().getSymbolModelSymbolParserRuleCall_1_0());
16694 pushFollow(FOLLOW_2);
16695 ruleModelSymbol();
16696
16697 state._fsp--;
16698
16699 after(grammarAccess.getConstraintAccess().getSymbolModelSymbolParserRuleCall_1_0());
16700
16701 }
16702
16703
16704 }
16705
16706 }
16707 catch (RecognitionException re) {
16708 reportError(re);
16709 recover(input,re);
16710 }
16711 finally {
16712
16713 restoreStackSize(stackSize);
16714
16715 }
16716 return ;
16717 }
16718 // $ANTLR end "rule__Constraint__SymbolAssignment_1"
16719
16720
16721 // $ANTLR start "rule__Constraint__ParamsAssignment_2_0_1"
16722 // InternalSolverLanguage.g:5464:1: rule__Constraint__ParamsAssignment_2_0_1 : ( ruleLiteral ) ;
16723 public final void rule__Constraint__ParamsAssignment_2_0_1() throws RecognitionException {
16724
16725 int stackSize = keepStackSize();
16726
16727 try {
16728 // InternalSolverLanguage.g:5468:1: ( ( ruleLiteral ) )
16729 // InternalSolverLanguage.g:5469:2: ( ruleLiteral )
16730 {
16731 // InternalSolverLanguage.g:5469:2: ( ruleLiteral )
16732 // InternalSolverLanguage.g:5470:3: ruleLiteral
16733 {
16734 before(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_0_1_0());
16735 pushFollow(FOLLOW_2);
16736 ruleLiteral();
16737
16738 state._fsp--;
16739
16740 after(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_0_1_0());
16741
16742 }
16743
16744
16745 }
16746
16747 }
16748 catch (RecognitionException re) {
16749 reportError(re);
16750 recover(input,re);
16751 }
16752 finally {
16753
16754 restoreStackSize(stackSize);
16755
16756 }
16757 return ;
16758 }
16759 // $ANTLR end "rule__Constraint__ParamsAssignment_2_0_1"
16760
16761
16762 // $ANTLR start "rule__Constraint__ClosureTypeAssignment_2_1_0"
16763 // InternalSolverLanguage.g:5479:1: rule__Constraint__ClosureTypeAssignment_2_1_0 : ( ruleClosureType ) ;
16764 public final void rule__Constraint__ClosureTypeAssignment_2_1_0() throws RecognitionException {
16765
16766 int stackSize = keepStackSize();
16767
16768 try {
16769 // InternalSolverLanguage.g:5483:1: ( ( ruleClosureType ) )
16770 // InternalSolverLanguage.g:5484:2: ( ruleClosureType )
16771 {
16772 // InternalSolverLanguage.g:5484:2: ( ruleClosureType )
16773 // InternalSolverLanguage.g:5485:3: ruleClosureType
16774 {
16775 before(grammarAccess.getConstraintAccess().getClosureTypeClosureTypeParserRuleCall_2_1_0_0());
16776 pushFollow(FOLLOW_2);
16777 ruleClosureType();
16778
16779 state._fsp--;
16780
16781 after(grammarAccess.getConstraintAccess().getClosureTypeClosureTypeParserRuleCall_2_1_0_0());
16782
16783 }
16784
16785
16786 }
16787
16788 }
16789 catch (RecognitionException re) {
16790 reportError(re);
16791 recover(input,re);
16792 }
16793 finally {
16794
16795 restoreStackSize(stackSize);
16796
16797 }
16798 return ;
16799 }
16800 // $ANTLR end "rule__Constraint__ClosureTypeAssignment_2_1_0"
16801
16802
16803 // $ANTLR start "rule__Constraint__ParamsAssignment_2_1_2"
16804 // InternalSolverLanguage.g:5494:1: rule__Constraint__ParamsAssignment_2_1_2 : ( ruleLiteral ) ;
16805 public final void rule__Constraint__ParamsAssignment_2_1_2() throws RecognitionException {
16806
16807 int stackSize = keepStackSize();
16808
16809 try {
16810 // InternalSolverLanguage.g:5498:1: ( ( ruleLiteral ) )
16811 // InternalSolverLanguage.g:5499:2: ( ruleLiteral )
16812 {
16813 // InternalSolverLanguage.g:5499:2: ( ruleLiteral )
16814 // InternalSolverLanguage.g:5500:3: ruleLiteral
16815 {
16816 before(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_2_0());
16817 pushFollow(FOLLOW_2);
16818 ruleLiteral();
16819
16820 state._fsp--;
16821
16822 after(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_2_0());
16823
16824 }
16825
16826
16827 }
16828
16829 }
16830 catch (RecognitionException re) {
16831 reportError(re);
16832 recover(input,re);
16833 }
16834 finally {
16835
16836 restoreStackSize(stackSize);
16837
16838 }
16839 return ;
16840 }
16841 // $ANTLR end "rule__Constraint__ParamsAssignment_2_1_2"
16842
16843
16844 // $ANTLR start "rule__Constraint__ParamsAssignment_2_1_3"
16845 // InternalSolverLanguage.g:5509:1: rule__Constraint__ParamsAssignment_2_1_3 : ( ruleLiteral ) ;
16846 public final void rule__Constraint__ParamsAssignment_2_1_3() throws RecognitionException {
16847
16848 int stackSize = keepStackSize();
16849
16850 try {
16851 // InternalSolverLanguage.g:5513:1: ( ( ruleLiteral ) )
16852 // InternalSolverLanguage.g:5514:2: ( ruleLiteral )
16853 {
16854 // InternalSolverLanguage.g:5514:2: ( ruleLiteral )
16855 // InternalSolverLanguage.g:5515:3: ruleLiteral
16856 {
16857 before(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_3_0());
16858 pushFollow(FOLLOW_2);
16859 ruleLiteral();
16860
16861 state._fsp--;
16862
16863 after(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_3_0());
16864
16865 }
16866
16867
16868 }
16869
16870 }
16871 catch (RecognitionException re) {
16872 reportError(re);
16873 recover(input,re);
16874 }
16875 finally {
16876
16877 restoreStackSize(stackSize);
16878
16879 }
16880 return ;
16881 }
16882 // $ANTLR end "rule__Constraint__ParamsAssignment_2_1_3"
16883
16884
16885 // $ANTLR start "rule__Variable__NameAssignment"
16886 // InternalSolverLanguage.g:5524:1: rule__Variable__NameAssignment : ( RULE_ID ) ;
16887 public final void rule__Variable__NameAssignment() throws RecognitionException {
16888
16889 int stackSize = keepStackSize();
16890
16891 try {
16892 // InternalSolverLanguage.g:5528:1: ( ( RULE_ID ) )
16893 // InternalSolverLanguage.g:5529:2: ( RULE_ID )
16894 {
16895 // InternalSolverLanguage.g:5529:2: ( RULE_ID )
16896 // InternalSolverLanguage.g:5530:3: RULE_ID
16897 {
16898 before(grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0());
16899 match(input,RULE_ID,FOLLOW_2);
16900 after(grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0());
16901
16902 }
16903
16904
16905 }
16906
16907 }
16908 catch (RecognitionException re) {
16909 reportError(re);
16910 recover(input,re);
16911 }
16912 finally {
16913
16914 restoreStackSize(stackSize);
16915
16916 }
16917 return ;
16918 }
16919 // $ANTLR end "rule__Variable__NameAssignment"
16920
16921
16922 // $ANTLR start "rule__AllInstances__SymbolAssignment_1"
16923 // InternalSolverLanguage.g:5539:1: rule__AllInstances__SymbolAssignment_1 : ( ruleSymbol ) ;
16924 public final void rule__AllInstances__SymbolAssignment_1() throws RecognitionException {
16925
16926 int stackSize = keepStackSize();
16927
16928 try {
16929 // InternalSolverLanguage.g:5543:1: ( ( ruleSymbol ) )
16930 // InternalSolverLanguage.g:5544:2: ( ruleSymbol )
16931 {
16932 // InternalSolverLanguage.g:5544:2: ( ruleSymbol )
16933 // InternalSolverLanguage.g:5545:3: ruleSymbol
16934 {
16935 before(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0());
16936 pushFollow(FOLLOW_2);
16937 ruleSymbol();
16938
16939 state._fsp--;
16940
16941 after(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0());
16942
16943 }
16944
16945
16946 }
16947
16948 }
16949 catch (RecognitionException re) {
16950 reportError(re);
16951 recover(input,re);
16952 }
16953 finally {
16954
16955 restoreStackSize(stackSize);
16956
16957 }
16958 return ;
16959 }
16960 // $ANTLR end "rule__AllInstances__SymbolAssignment_1"
16961
16962
16963 // $ANTLR start "rule__DefaultInterpretation__InterpretationAssignment_1"
16964 // InternalSolverLanguage.g:5554:1: rule__DefaultInterpretation__InterpretationAssignment_1 : ( ruleBasicInterpretation ) ;
16965 public final void rule__DefaultInterpretation__InterpretationAssignment_1() throws RecognitionException {
16966
16967 int stackSize = keepStackSize();
16968
16969 try {
16970 // InternalSolverLanguage.g:5558:1: ( ( ruleBasicInterpretation ) )
16971 // InternalSolverLanguage.g:5559:2: ( ruleBasicInterpretation )
16972 {
16973 // InternalSolverLanguage.g:5559:2: ( ruleBasicInterpretation )
16974 // InternalSolverLanguage.g:5560:3: ruleBasicInterpretation
16975 {
16976 before(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0());
16977 pushFollow(FOLLOW_2);
16978 ruleBasicInterpretation();
16979
16980 state._fsp--;
16981
16982 after(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0());
16983
16984 }
16985
16986
16987 }
16988
16989 }
16990 catch (RecognitionException re) {
16991 reportError(re);
16992 recover(input,re);
16993 }
16994 finally {
16995
16996 restoreStackSize(stackSize);
16997
16998 }
16999 return ;
17000 }
17001 // $ANTLR end "rule__DefaultInterpretation__InterpretationAssignment_1"
17002
17003
17004 // $ANTLR start "rule__ClassInterpretation__AbstractAssignment_0"
17005 // InternalSolverLanguage.g:5569:1: rule__ClassInterpretation__AbstractAssignment_0 : ( ( 'abstract' ) ) ;
17006 public final void rule__ClassInterpretation__AbstractAssignment_0() throws RecognitionException {
17007
17008 int stackSize = keepStackSize();
17009
17010 try {
17011 // InternalSolverLanguage.g:5573:1: ( ( ( 'abstract' ) ) )
17012 // InternalSolverLanguage.g:5574:2: ( ( 'abstract' ) )
17013 {
17014 // InternalSolverLanguage.g:5574:2: ( ( 'abstract' ) )
17015 // InternalSolverLanguage.g:5575:3: ( 'abstract' )
17016 {
17017 before(grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0());
17018 // InternalSolverLanguage.g:5576:3: ( 'abstract' )
17019 // InternalSolverLanguage.g:5577:4: 'abstract'
17020 {
17021 before(grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0());
17022 match(input,39,FOLLOW_2);
17023 after(grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0());
17024
17025 }
17026
17027 after(grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0());
17028
17029 }
17030
17031
17032 }
17033
17034 }
17035 catch (RecognitionException re) {
17036 reportError(re);
17037 recover(input,re);
17038 }
17039 finally {
17040
17041 restoreStackSize(stackSize);
17042
17043 }
17044 return ;
17045 }
17046 // $ANTLR end "rule__ClassInterpretation__AbstractAssignment_0"
17047
17048
17049 // $ANTLR start "rule__ClassInterpretation__SymbolAssignment_2"
17050 // InternalSolverLanguage.g:5588:1: rule__ClassInterpretation__SymbolAssignment_2 : ( ruleModelSymbol ) ;
17051 public final void rule__ClassInterpretation__SymbolAssignment_2() throws RecognitionException {
17052
17053 int stackSize = keepStackSize();
17054
17055 try {
17056 // InternalSolverLanguage.g:5592:1: ( ( ruleModelSymbol ) )
17057 // InternalSolverLanguage.g:5593:2: ( ruleModelSymbol )
17058 {
17059 // InternalSolverLanguage.g:5593:2: ( ruleModelSymbol )
17060 // InternalSolverLanguage.g:5594:3: ruleModelSymbol
17061 {
17062 before(grammarAccess.getClassInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0());
17063 pushFollow(FOLLOW_2);
17064 ruleModelSymbol();
17065
17066 state._fsp--;
17067
17068 after(grammarAccess.getClassInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0());
17069
17070 }
17071
17072
17073 }
17074
17075 }
17076 catch (RecognitionException re) {
17077 reportError(re);
17078 recover(input,re);
17079 }
17080 finally {
17081
17082 restoreStackSize(stackSize);
17083
17084 }
17085 return ;
17086 }
17087 // $ANTLR end "rule__ClassInterpretation__SymbolAssignment_2"
17088
17089
17090 // $ANTLR start "rule__ClassInterpretation__SupertypesAssignment_3_1"
17091 // InternalSolverLanguage.g:5603:1: rule__ClassInterpretation__SupertypesAssignment_3_1 : ( ruleModelSymbol ) ;
17092 public final void rule__ClassInterpretation__SupertypesAssignment_3_1() throws RecognitionException {
17093
17094 int stackSize = keepStackSize();
17095
17096 try {
17097 // InternalSolverLanguage.g:5607:1: ( ( ruleModelSymbol ) )
17098 // InternalSolverLanguage.g:5608:2: ( ruleModelSymbol )
17099 {
17100 // InternalSolverLanguage.g:5608:2: ( ruleModelSymbol )
17101 // InternalSolverLanguage.g:5609:3: ruleModelSymbol
17102 {
17103 before(grammarAccess.getClassInterpretationAccess().getSupertypesModelSymbolParserRuleCall_3_1_0());
17104 pushFollow(FOLLOW_2);
17105 ruleModelSymbol();
17106
17107 state._fsp--;
17108
17109 after(grammarAccess.getClassInterpretationAccess().getSupertypesModelSymbolParserRuleCall_3_1_0());
17110
17111 }
17112
17113
17114 }
17115
17116 }
17117 catch (RecognitionException re) {
17118 reportError(re);
17119 recover(input,re);
17120 }
17121 finally {
17122
17123 restoreStackSize(stackSize);
17124
17125 }
17126 return ;
17127 }
17128 // $ANTLR end "rule__ClassInterpretation__SupertypesAssignment_3_1"
17129
17130
17131 // $ANTLR start "rule__ClassInterpretation__FieltAssignment_5"
17132 // InternalSolverLanguage.g:5618:1: rule__ClassInterpretation__FieltAssignment_5 : ( ruleFieldRelationInterpretation ) ;
17133 public final void rule__ClassInterpretation__FieltAssignment_5() throws RecognitionException {
17134
17135 int stackSize = keepStackSize();
17136
17137 try {
17138 // InternalSolverLanguage.g:5622:1: ( ( ruleFieldRelationInterpretation ) )
17139 // InternalSolverLanguage.g:5623:2: ( ruleFieldRelationInterpretation )
17140 {
17141 // InternalSolverLanguage.g:5623:2: ( ruleFieldRelationInterpretation )
17142 // InternalSolverLanguage.g:5624:3: ruleFieldRelationInterpretation
17143 {
17144 before(grammarAccess.getClassInterpretationAccess().getFieltFieldRelationInterpretationParserRuleCall_5_0());
17145 pushFollow(FOLLOW_2);
17146 ruleFieldRelationInterpretation();
17147
17148 state._fsp--;
17149
17150 after(grammarAccess.getClassInterpretationAccess().getFieltFieldRelationInterpretationParserRuleCall_5_0());
17151
17152 }
17153
17154
17155 }
17156
17157 }
17158 catch (RecognitionException re) {
17159 reportError(re);
17160 recover(input,re);
17161 }
17162 finally {
17163
17164 restoreStackSize(stackSize);
17165
17166 }
17167 return ;
17168 }
17169 // $ANTLR end "rule__ClassInterpretation__FieltAssignment_5"
17170
17171
17172 // $ANTLR start "rule__EnumInterpretation__SymbolAssignment_1"
17173 // InternalSolverLanguage.g:5633:1: rule__EnumInterpretation__SymbolAssignment_1 : ( ruleModelSymbol ) ;
17174 public final void rule__EnumInterpretation__SymbolAssignment_1() throws RecognitionException {
17175
17176 int stackSize = keepStackSize();
17177
17178 try {
17179 // InternalSolverLanguage.g:5637:1: ( ( ruleModelSymbol ) )
17180 // InternalSolverLanguage.g:5638:2: ( ruleModelSymbol )
17181 {
17182 // InternalSolverLanguage.g:5638:2: ( ruleModelSymbol )
17183 // InternalSolverLanguage.g:5639:3: ruleModelSymbol
17184 {
17185 before(grammarAccess.getEnumInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0());
17186 pushFollow(FOLLOW_2);
17187 ruleModelSymbol();
17188
17189 state._fsp--;
17190
17191 after(grammarAccess.getEnumInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0());
17192
17193 }
17194
17195
17196 }
17197
17198 }
17199 catch (RecognitionException re) {
17200 reportError(re);
17201 recover(input,re);
17202 }
17203 finally {
17204
17205 restoreStackSize(stackSize);
17206
17207 }
17208 return ;
17209 }
17210 // $ANTLR end "rule__EnumInterpretation__SymbolAssignment_1"
17211
17212
17213 // $ANTLR start "rule__EnumInterpretation__ObjectsAssignment_3"
17214 // InternalSolverLanguage.g:5648:1: rule__EnumInterpretation__ObjectsAssignment_3 : ( ruleNamedObject ) ;
17215 public final void rule__EnumInterpretation__ObjectsAssignment_3() throws RecognitionException {
17216
17217 int stackSize = keepStackSize();
17218
17219 try {
17220 // InternalSolverLanguage.g:5652:1: ( ( ruleNamedObject ) )
17221 // InternalSolverLanguage.g:5653:2: ( ruleNamedObject )
17222 {
17223 // InternalSolverLanguage.g:5653:2: ( ruleNamedObject )
17224 // InternalSolverLanguage.g:5654:3: ruleNamedObject
17225 {
17226 before(grammarAccess.getEnumInterpretationAccess().getObjectsNamedObjectParserRuleCall_3_0());
17227 pushFollow(FOLLOW_2);
17228 ruleNamedObject();
17229
17230 state._fsp--;
17231
17232 after(grammarAccess.getEnumInterpretationAccess().getObjectsNamedObjectParserRuleCall_3_0());
17233
17234 }
17235
17236
17237 }
17238
17239 }
17240 catch (RecognitionException re) {
17241 reportError(re);
17242 recover(input,re);
17243 }
17244 finally {
17245
17246 restoreStackSize(stackSize);
17247
17248 }
17249 return ;
17250 }
17251 // $ANTLR end "rule__EnumInterpretation__ObjectsAssignment_3"
17252
17253
17254 // $ANTLR start "rule__FieldRelationInterpretation__ContainmentAssignment_0"
17255 // InternalSolverLanguage.g:5663:1: rule__FieldRelationInterpretation__ContainmentAssignment_0 : ( ( 'containment' ) ) ;
17256 public final void rule__FieldRelationInterpretation__ContainmentAssignment_0() throws RecognitionException {
17257
17258 int stackSize = keepStackSize();
17259
17260 try {
17261 // InternalSolverLanguage.g:5667:1: ( ( ( 'containment' ) ) )
17262 // InternalSolverLanguage.g:5668:2: ( ( 'containment' ) )
17263 {
17264 // InternalSolverLanguage.g:5668:2: ( ( 'containment' ) )
17265 // InternalSolverLanguage.g:5669:3: ( 'containment' )
17266 {
17267 before(grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0());
17268 // InternalSolverLanguage.g:5670:3: ( 'containment' )
17269 // InternalSolverLanguage.g:5671:4: 'containment'
17270 {
17271 before(grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0());
17272 match(input,40,FOLLOW_2);
17273 after(grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0());
17274
17275 }
17276
17277 after(grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0());
17278
17279 }
17280
17281
17282 }
17283
17284 }
17285 catch (RecognitionException re) {
17286 reportError(re);
17287 recover(input,re);
17288 }
17289 finally {
17290
17291 restoreStackSize(stackSize);
17292
17293 }
17294 return ;
17295 }
17296 // $ANTLR end "rule__FieldRelationInterpretation__ContainmentAssignment_0"
17297
17298
17299 // $ANTLR start "rule__FieldRelationInterpretation__SymbolAssignment_1"
17300 // InternalSolverLanguage.g:5682:1: rule__FieldRelationInterpretation__SymbolAssignment_1 : ( ruleModelSymbol ) ;
17301 public final void rule__FieldRelationInterpretation__SymbolAssignment_1() throws RecognitionException {
17302
17303 int stackSize = keepStackSize();
17304
17305 try {
17306 // InternalSolverLanguage.g:5686:1: ( ( ruleModelSymbol ) )
17307 // InternalSolverLanguage.g:5687:2: ( ruleModelSymbol )
17308 {
17309 // InternalSolverLanguage.g:5687:2: ( ruleModelSymbol )
17310 // InternalSolverLanguage.g:5688:3: ruleModelSymbol
17311 {
17312 before(grammarAccess.getFieldRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0());
17313 pushFollow(FOLLOW_2);
17314 ruleModelSymbol();
17315
17316 state._fsp--;
17317
17318 after(grammarAccess.getFieldRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0());
17319
17320 }
17321
17322
17323 }
17324
17325 }
17326 catch (RecognitionException re) {
17327 reportError(re);
17328 recover(input,re);
17329 }
17330 finally {
17331
17332 restoreStackSize(stackSize);
17333
17334 }
17335 return ;
17336 }
17337 // $ANTLR end "rule__FieldRelationInterpretation__SymbolAssignment_1"
17338
17339
17340 // $ANTLR start "rule__FieldRelationInterpretation__MultiplicityAssignment_3"
17341 // InternalSolverLanguage.g:5697:1: rule__FieldRelationInterpretation__MultiplicityAssignment_3 : ( ruleMultiplicityDefinition ) ;
17342 public final void rule__FieldRelationInterpretation__MultiplicityAssignment_3() throws RecognitionException {
17343
17344 int stackSize = keepStackSize();
17345
17346 try {
17347 // InternalSolverLanguage.g:5701:1: ( ( ruleMultiplicityDefinition ) )
17348 // InternalSolverLanguage.g:5702:2: ( ruleMultiplicityDefinition )
17349 {
17350 // InternalSolverLanguage.g:5702:2: ( ruleMultiplicityDefinition )
17351 // InternalSolverLanguage.g:5703:3: ruleMultiplicityDefinition
17352 {
17353 before(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityMultiplicityDefinitionParserRuleCall_3_0());
17354 pushFollow(FOLLOW_2);
17355 ruleMultiplicityDefinition();
17356
17357 state._fsp--;
17358
17359 after(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityMultiplicityDefinitionParserRuleCall_3_0());
17360
17361 }
17362
17363
17364 }
17365
17366 }
17367 catch (RecognitionException re) {
17368 reportError(re);
17369 recover(input,re);
17370 }
17371 finally {
17372
17373 restoreStackSize(stackSize);
17374
17375 }
17376 return ;
17377 }
17378 // $ANTLR end "rule__FieldRelationInterpretation__MultiplicityAssignment_3"
17379
17380
17381 // $ANTLR start "rule__FieldRelationInterpretation__TargetAssignment_4"
17382 // InternalSolverLanguage.g:5712:1: rule__FieldRelationInterpretation__TargetAssignment_4 : ( ruleSymbol ) ;
17383 public final void rule__FieldRelationInterpretation__TargetAssignment_4() throws RecognitionException {
17384
17385 int stackSize = keepStackSize();
17386
17387 try {
17388 // InternalSolverLanguage.g:5716:1: ( ( ruleSymbol ) )
17389 // InternalSolverLanguage.g:5717:2: ( ruleSymbol )
17390 {
17391 // InternalSolverLanguage.g:5717:2: ( ruleSymbol )
17392 // InternalSolverLanguage.g:5718:3: ruleSymbol
17393 {
17394 before(grammarAccess.getFieldRelationInterpretationAccess().getTargetSymbolParserRuleCall_4_0());
17395 pushFollow(FOLLOW_2);
17396 ruleSymbol();
17397
17398 state._fsp--;
17399
17400 after(grammarAccess.getFieldRelationInterpretationAccess().getTargetSymbolParserRuleCall_4_0());
17401
17402 }
17403
17404
17405 }
17406
17407 }
17408 catch (RecognitionException re) {
17409 reportError(re);
17410 recover(input,re);
17411 }
17412 finally {
17413
17414 restoreStackSize(stackSize);
17415
17416 }
17417 return ;
17418 }
17419 // $ANTLR end "rule__FieldRelationInterpretation__TargetAssignment_4"
17420
17421
17422 // $ANTLR start "rule__GlobalRelationInterpretation__ContainmentAssignment_0"
17423 // InternalSolverLanguage.g:5727:1: rule__GlobalRelationInterpretation__ContainmentAssignment_0 : ( ( 'containment' ) ) ;
17424 public final void rule__GlobalRelationInterpretation__ContainmentAssignment_0() throws RecognitionException {
17425
17426 int stackSize = keepStackSize();
17427
17428 try {
17429 // InternalSolverLanguage.g:5731:1: ( ( ( 'containment' ) ) )
17430 // InternalSolverLanguage.g:5732:2: ( ( 'containment' ) )
17431 {
17432 // InternalSolverLanguage.g:5732:2: ( ( 'containment' ) )
17433 // InternalSolverLanguage.g:5733:3: ( 'containment' )
17434 {
17435 before(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0());
17436 // InternalSolverLanguage.g:5734:3: ( 'containment' )
17437 // InternalSolverLanguage.g:5735:4: 'containment'
17438 {
17439 before(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0());
17440 match(input,40,FOLLOW_2);
17441 after(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0());
17442
17443 }
17444
17445 after(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0());
17446
17447 }
17448
17449
17450 }
17451
17452 }
17453 catch (RecognitionException re) {
17454 reportError(re);
17455 recover(input,re);
17456 }
17457 finally {
17458
17459 restoreStackSize(stackSize);
17460
17461 }
17462 return ;
17463 }
17464 // $ANTLR end "rule__GlobalRelationInterpretation__ContainmentAssignment_0"
17465
17466
17467 // $ANTLR start "rule__GlobalRelationInterpretation__SymbolAssignment_2"
17468 // InternalSolverLanguage.g:5746:1: rule__GlobalRelationInterpretation__SymbolAssignment_2 : ( ruleModelSymbol ) ;
17469 public final void rule__GlobalRelationInterpretation__SymbolAssignment_2() throws RecognitionException {
17470
17471 int stackSize = keepStackSize();
17472
17473 try {
17474 // InternalSolverLanguage.g:5750:1: ( ( ruleModelSymbol ) )
17475 // InternalSolverLanguage.g:5751:2: ( ruleModelSymbol )
17476 {
17477 // InternalSolverLanguage.g:5751:2: ( ruleModelSymbol )
17478 // InternalSolverLanguage.g:5752:3: ruleModelSymbol
17479 {
17480 before(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0());
17481 pushFollow(FOLLOW_2);
17482 ruleModelSymbol();
17483
17484 state._fsp--;
17485
17486 after(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0());
17487
17488 }
17489
17490
17491 }
17492
17493 }
17494 catch (RecognitionException re) {
17495 reportError(re);
17496 recover(input,re);
17497 }
17498 finally {
17499
17500 restoreStackSize(stackSize);
17501
17502 }
17503 return ;
17504 }
17505 // $ANTLR end "rule__GlobalRelationInterpretation__SymbolAssignment_2"
17506
17507
17508 // $ANTLR start "rule__GlobalRelationInterpretation__SourceMultiplicityAssignment_4"
17509 // InternalSolverLanguage.g:5761:1: rule__GlobalRelationInterpretation__SourceMultiplicityAssignment_4 : ( ruleMultiplicityDefinition ) ;
17510 public final void rule__GlobalRelationInterpretation__SourceMultiplicityAssignment_4() throws RecognitionException {
17511
17512 int stackSize = keepStackSize();
17513
17514 try {
17515 // InternalSolverLanguage.g:5765:1: ( ( ruleMultiplicityDefinition ) )
17516 // InternalSolverLanguage.g:5766:2: ( ruleMultiplicityDefinition )
17517 {
17518 // InternalSolverLanguage.g:5766:2: ( ruleMultiplicityDefinition )
17519 // InternalSolverLanguage.g:5767:3: ruleMultiplicityDefinition
17520 {
17521 before(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0());
17522 pushFollow(FOLLOW_2);
17523 ruleMultiplicityDefinition();
17524
17525 state._fsp--;
17526
17527 after(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0());
17528
17529 }
17530
17531
17532 }
17533
17534 }
17535 catch (RecognitionException re) {
17536 reportError(re);
17537 recover(input,re);
17538 }
17539 finally {
17540
17541 restoreStackSize(stackSize);
17542
17543 }
17544 return ;
17545 }
17546 // $ANTLR end "rule__GlobalRelationInterpretation__SourceMultiplicityAssignment_4"
17547
17548
17549 // $ANTLR start "rule__GlobalRelationInterpretation__SourceAssignment_5"
17550 // InternalSolverLanguage.g:5776:1: rule__GlobalRelationInterpretation__SourceAssignment_5 : ( ruleSymbol ) ;
17551 public final void rule__GlobalRelationInterpretation__SourceAssignment_5() throws RecognitionException {
17552
17553 int stackSize = keepStackSize();
17554
17555 try {
17556 // InternalSolverLanguage.g:5780:1: ( ( ruleSymbol ) )
17557 // InternalSolverLanguage.g:5781:2: ( ruleSymbol )
17558 {
17559 // InternalSolverLanguage.g:5781:2: ( ruleSymbol )
17560 // InternalSolverLanguage.g:5782:3: ruleSymbol
17561 {
17562 before(grammarAccess.getGlobalRelationInterpretationAccess().getSourceSymbolParserRuleCall_5_0());
17563 pushFollow(FOLLOW_2);
17564 ruleSymbol();
17565
17566 state._fsp--;
17567
17568 after(grammarAccess.getGlobalRelationInterpretationAccess().getSourceSymbolParserRuleCall_5_0());
17569
17570 }
17571
17572
17573 }
17574
17575 }
17576 catch (RecognitionException re) {
17577 reportError(re);
17578 recover(input,re);
17579 }
17580 finally {
17581
17582 restoreStackSize(stackSize);
17583
17584 }
17585 return ;
17586 }
17587 // $ANTLR end "rule__GlobalRelationInterpretation__SourceAssignment_5"
17588
17589
17590 // $ANTLR start "rule__GlobalRelationInterpretation__TargetMultiplicityAssignment_6"
17591 // InternalSolverLanguage.g:5791:1: rule__GlobalRelationInterpretation__TargetMultiplicityAssignment_6 : ( ruleMultiplicityDefinition ) ;
17592 public final void rule__GlobalRelationInterpretation__TargetMultiplicityAssignment_6() throws RecognitionException {
17593
17594 int stackSize = keepStackSize();
17595
17596 try {
17597 // InternalSolverLanguage.g:5795:1: ( ( ruleMultiplicityDefinition ) )
17598 // InternalSolverLanguage.g:5796:2: ( ruleMultiplicityDefinition )
17599 {
17600 // InternalSolverLanguage.g:5796:2: ( ruleMultiplicityDefinition )
17601 // InternalSolverLanguage.g:5797:3: ruleMultiplicityDefinition
17602 {
17603 before(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0());
17604 pushFollow(FOLLOW_2);
17605 ruleMultiplicityDefinition();
17606
17607 state._fsp--;
17608
17609 after(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0());
17610
17611 }
17612
17613
17614 }
17615
17616 }
17617 catch (RecognitionException re) {
17618 reportError(re);
17619 recover(input,re);
17620 }
17621 finally {
17622
17623 restoreStackSize(stackSize);
17624
17625 }
17626 return ;
17627 }
17628 // $ANTLR end "rule__GlobalRelationInterpretation__TargetMultiplicityAssignment_6"
17629
17630
17631 // $ANTLR start "rule__GlobalRelationInterpretation__TargetAssignment_7"
17632 // InternalSolverLanguage.g:5806:1: rule__GlobalRelationInterpretation__TargetAssignment_7 : ( ruleSymbol ) ;
17633 public final void rule__GlobalRelationInterpretation__TargetAssignment_7() throws RecognitionException {
17634
17635 int stackSize = keepStackSize();
17636
17637 try {
17638 // InternalSolverLanguage.g:5810:1: ( ( ruleSymbol ) )
17639 // InternalSolverLanguage.g:5811:2: ( ruleSymbol )
17640 {
17641 // InternalSolverLanguage.g:5811:2: ( ruleSymbol )
17642 // InternalSolverLanguage.g:5812:3: ruleSymbol
17643 {
17644 before(grammarAccess.getGlobalRelationInterpretationAccess().getTargetSymbolParserRuleCall_7_0());
17645 pushFollow(FOLLOW_2);
17646 ruleSymbol();
17647
17648 state._fsp--;
17649
17650 after(grammarAccess.getGlobalRelationInterpretationAccess().getTargetSymbolParserRuleCall_7_0());
17651
17652 }
17653
17654
17655 }
17656
17657 }
17658 catch (RecognitionException re) {
17659 reportError(re);
17660 recover(input,re);
17661 }
17662 finally {
17663
17664 restoreStackSize(stackSize);
17665
17666 }
17667 return ;
17668 }
17669 // $ANTLR end "rule__GlobalRelationInterpretation__TargetAssignment_7"
17670
17671
17672 // $ANTLR start "rule__MultiplicityDefinition__LowerAssignment_0"
17673 // InternalSolverLanguage.g:5821:1: rule__MultiplicityDefinition__LowerAssignment_0 : ( RULE_INT ) ;
17674 public final void rule__MultiplicityDefinition__LowerAssignment_0() throws RecognitionException {
17675
17676 int stackSize = keepStackSize();
17677
17678 try {
17679 // InternalSolverLanguage.g:5825:1: ( ( RULE_INT ) )
17680 // InternalSolverLanguage.g:5826:2: ( RULE_INT )
17681 {
17682 // InternalSolverLanguage.g:5826:2: ( RULE_INT )
17683 // InternalSolverLanguage.g:5827:3: RULE_INT
17684 {
17685 before(grammarAccess.getMultiplicityDefinitionAccess().getLowerINTTerminalRuleCall_0_0());
17686 match(input,RULE_INT,FOLLOW_2);
17687 after(grammarAccess.getMultiplicityDefinitionAccess().getLowerINTTerminalRuleCall_0_0());
17688
17689 }
17690
17691
17692 }
17693
17694 }
17695 catch (RecognitionException re) {
17696 reportError(re);
17697 recover(input,re);
17698 }
17699 finally {
17700
17701 restoreStackSize(stackSize);
17702
17703 }
17704 return ;
17705 }
17706 // $ANTLR end "rule__MultiplicityDefinition__LowerAssignment_0"
17707
17708
17709 // $ANTLR start "rule__MultiplicityDefinition__UpperAssignment_2_0"
17710 // InternalSolverLanguage.g:5836:1: rule__MultiplicityDefinition__UpperAssignment_2_0 : ( RULE_INT ) ;
17711 public final void rule__MultiplicityDefinition__UpperAssignment_2_0() throws RecognitionException {
17712
17713 int stackSize = keepStackSize();
17714
17715 try {
17716 // InternalSolverLanguage.g:5840:1: ( ( RULE_INT ) )
17717 // InternalSolverLanguage.g:5841:2: ( RULE_INT )
17718 {
17719 // InternalSolverLanguage.g:5841:2: ( RULE_INT )
17720 // InternalSolverLanguage.g:5842:3: RULE_INT
17721 {
17722 before(grammarAccess.getMultiplicityDefinitionAccess().getUpperINTTerminalRuleCall_2_0_0());
17723 match(input,RULE_INT,FOLLOW_2);
17724 after(grammarAccess.getMultiplicityDefinitionAccess().getUpperINTTerminalRuleCall_2_0_0());
17725
17726 }
17727
17728
17729 }
17730
17731 }
17732 catch (RecognitionException re) {
17733 reportError(re);
17734 recover(input,re);
17735 }
17736 finally {
17737
17738 restoreStackSize(stackSize);
17739
17740 }
17741 return ;
17742 }
17743 // $ANTLR end "rule__MultiplicityDefinition__UpperAssignment_2_0"
17744
17745
17746 // $ANTLR start "rule__MultiplicityDefinition__UnlimitedUpperAssignment_2_1"
17747 // InternalSolverLanguage.g:5851:1: rule__MultiplicityDefinition__UnlimitedUpperAssignment_2_1 : ( ( '*' ) ) ;
17748 public final void rule__MultiplicityDefinition__UnlimitedUpperAssignment_2_1() throws RecognitionException {
17749
17750 int stackSize = keepStackSize();
17751
17752 try {
17753 // InternalSolverLanguage.g:5855:1: ( ( ( '*' ) ) )
17754 // InternalSolverLanguage.g:5856:2: ( ( '*' ) )
17755 {
17756 // InternalSolverLanguage.g:5856:2: ( ( '*' ) )
17757 // InternalSolverLanguage.g:5857:3: ( '*' )
17758 {
17759 before(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0());
17760 // InternalSolverLanguage.g:5858:3: ( '*' )
17761 // InternalSolverLanguage.g:5859:4: '*'
17762 {
17763 before(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0());
17764 match(input,30,FOLLOW_2);
17765 after(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0());
17766
17767 }
17768
17769 after(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0());
17770
17771 }
17772
17773
17774 }
17775
17776 }
17777 catch (RecognitionException re) {
17778 reportError(re);
17779 recover(input,re);
17780 }
17781 finally {
17782
17783 restoreStackSize(stackSize);
17784
17785 }
17786 return ;
17787 }
17788 // $ANTLR end "rule__MultiplicityDefinition__UnlimitedUpperAssignment_2_1"
17789
17790 // Delegated rules
17791
17792
17793
17794
17795 public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L});
17796 public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L});
17797 public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x000001908BF10022L});
17798 public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000020002022L});
17799 public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000000010L});
17800 public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000004000L});
17801 public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000001000L});
17802 public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000000800L});
17803 public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000008000L});
17804 public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000010000L});
17805 public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000020000L});
17806 public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x00000000440C3870L});
17807 public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000044083872L});
17808 public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000080000L});
17809 public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000019800L});
17810 public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000000020L});
17811 public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000004000000L});
17812 public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000000040020L});
17813 public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000000000022L});
17814 public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000020003820L});
17815 public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000010000000L});
17816 public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000010000002L});
17817 public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x000001908BF10020L});
17818 public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000000020020L});
17819 public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000003F00020L});
17820 public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000020000000L});
17821 public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000020002000L});
17822 public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000020002020L});
17823 public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000060020000L});
17824 public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000004043870L});
17825 public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000004003872L});
17826 public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000004003870L});
17827 public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000000040000L});
17828 public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000040000000L});
17829 public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000044083870L});
17830 public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000100000000L});
17831 public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000A00000000L});
17832 public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000010400000000L});
17833 public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000010000000002L});
17834 public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000200000000L});
17835 public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000400000000L});
17836 public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000004000002L});
17837 public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000000003F00030L});
17838 public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000002000000000L});
17839 public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000004000000000L});
17840 public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000040000010L});
17841
17842} \ No newline at end of file
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src/org/eclipse/viatra/solver/language/ide/SolverLanguageIdeModule.xtend b/Application/org.eclipse.viatra.solver.language.ide/src/org/eclipse/viatra/solver/language/ide/SolverLanguageIdeModule.xtend
new file mode 100644
index 00000000..b251a682
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/src/org/eclipse/viatra/solver/language/ide/SolverLanguageIdeModule.xtend
@@ -0,0 +1,11 @@
1/*
2 * generated by Xtext 2.18.0.M3
3 */
4package org.eclipse.viatra.solver.language.ide
5
6
7/**
8 * Use this class to register ide components.
9 */
10class SolverLanguageIdeModule extends AbstractSolverLanguageIdeModule {
11}
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src/org/eclipse/viatra/solver/language/ide/SolverLanguageIdeSetup.xtend b/Application/org.eclipse.viatra.solver.language.ide/src/org/eclipse/viatra/solver/language/ide/SolverLanguageIdeSetup.xtend
new file mode 100644
index 00000000..e62468d1
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/src/org/eclipse/viatra/solver/language/ide/SolverLanguageIdeSetup.xtend
@@ -0,0 +1,20 @@
1/*
2 * generated by Xtext 2.18.0.M3
3 */
4package org.eclipse.viatra.solver.language.ide
5
6import com.google.inject.Guice
7import org.eclipse.viatra.solver.language.SolverLanguageRuntimeModule
8import org.eclipse.viatra.solver.language.SolverLanguageStandaloneSetup
9import org.eclipse.xtext.util.Modules2
10
11/**
12 * Initialization support for running Xtext languages as language servers.
13 */
14class SolverLanguageIdeSetup extends SolverLanguageStandaloneSetup {
15
16 override createInjector() {
17 Guice.createInjector(Modules2.mixin(new SolverLanguageRuntimeModule, new SolverLanguageIdeModule))
18 }
19
20}
diff --git a/Application/org.eclipse.viatra.solver.language.ide/xtend-gen/org/eclipse/viatra/solver/language/ide/.gitignore b/Application/org.eclipse.viatra.solver.language.ide/xtend-gen/org/eclipse/viatra/solver/language/ide/.gitignore
new file mode 100644
index 00000000..b11ea6c0
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language.ide/xtend-gen/org/eclipse/viatra/solver/language/ide/.gitignore
@@ -0,0 +1,6 @@
1/.SolverLanguageIdeModule.java._trace
2/.SolverLanguageIdeModule.xtendbin
3/.SolverLanguageIdeSetup.java._trace
4/.SolverLanguageIdeSetup.xtendbin
5/SolverLanguageIdeModule.java
6/SolverLanguageIdeSetup.java
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-06-30 20:53:41 +0000