From 07719e927f9d398765e661c84fd8778cefb39083 Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Sun, 27 Jun 2021 14:22:40 +0200 Subject: Simplify project layout --- language-ide/.classpath | 32 + language-ide/.gitignore | 1 + language-ide/.project | 29 + .../.settings/org.eclipse.core.resources.prefs | 2 + language-ide/build.gradle | 23 + .../solver/language/ide/ProblemIdeModule.java | 17 + .../solver/language/ide/ProblemIdeSetup.java | 22 + .../ProblemSemanticHighlightingCalculator.java | 160 + .../META-INF/services/org.eclipse.xtext.ISetup | 1 + .../language/ide/AbstractProblemIdeModule.java | 60 + .../antlr/PartialProblemContentAssistParser.java | 33 + .../ide/contentassist/antlr/ProblemParser.java | 181 + .../contentassist/antlr/internal/InternalProblem.g | 5038 ++++++ .../antlr/internal/InternalProblem.tokens | 72 + .../antlr/internal/InternalProblemLexer.java | 1797 +++ .../antlr/internal/InternalProblemParser.java | 15493 +++++++++++++++++++ 16 files changed, 22961 insertions(+) create mode 100644 language-ide/.classpath create mode 100644 language-ide/.gitignore create mode 100644 language-ide/.project create mode 100644 language-ide/.settings/org.eclipse.core.resources.prefs create mode 100644 language-ide/build.gradle create mode 100644 language-ide/src/main/java/org/eclipse/viatra/solver/language/ide/ProblemIdeModule.java create mode 100644 language-ide/src/main/java/org/eclipse/viatra/solver/language/ide/ProblemIdeSetup.java create mode 100644 language-ide/src/main/java/org/eclipse/viatra/solver/language/ide/syntaxcoloring/ProblemSemanticHighlightingCalculator.java create mode 100644 language-ide/src/main/xtext-gen/META-INF/services/org.eclipse.xtext.ISetup create mode 100644 language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/AbstractProblemIdeModule.java create mode 100644 language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/PartialProblemContentAssistParser.java create mode 100644 language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/ProblemParser.java create mode 100644 language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.g create mode 100644 language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.tokens create mode 100644 language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemLexer.java create mode 100644 language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemParser.java (limited to 'language-ide') diff --git a/language-ide/.classpath b/language-ide/.classpath new file mode 100644 index 00000000..c2583eb8 --- /dev/null +++ b/language-ide/.classpath @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/language-ide/.gitignore b/language-ide/.gitignore new file mode 100644 index 00000000..84c048a7 --- /dev/null +++ b/language-ide/.gitignore @@ -0,0 +1 @@ +/build/ diff --git a/language-ide/.project b/language-ide/.project new file mode 100644 index 00000000..55c47a3f --- /dev/null +++ b/language-ide/.project @@ -0,0 +1,29 @@ + + + language-ide + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.xtext.ui.shared.xtextBuilder + + + + + org.eclipse.buildship.core.gradleprojectbuilder + + + + + + org.eclipse.buildship.core.gradleprojectnature + org.eclipse.xtext.ui.shared.xtextNature + org.eclipse.jdt.core.javanature + + diff --git a/language-ide/.settings/org.eclipse.core.resources.prefs b/language-ide/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 00000000..99f26c02 --- /dev/null +++ b/language-ide/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,2 @@ +eclipse.preferences.version=1 +encoding/=UTF-8 diff --git a/language-ide/build.gradle b/language-ide/build.gradle new file mode 100644 index 00000000..9cc8cf52 --- /dev/null +++ b/language-ide/build.gradle @@ -0,0 +1,23 @@ +plugins { + id 'com.github.johnrengelman.shadow' version '5.2.0' +} + +dependencies { + compile project(':language') + compile "org.eclipse.xtext:org.eclipse.xtext.ide:${xtextVersion}" + compile "org.eclipse.xtext:org.eclipse.xtext.xbase.ide:${xtextVersion}" +} + +apply plugin: 'application' +apply plugin: 'com.github.johnrengelman.shadow' +mainClassName = "org.eclipse.xtext.ide.server.ServerLauncher" + +shadowJar { + from(project.convention.getPlugin(JavaPluginConvention).sourceSets.main.output) + configurations = [project.configurations.runtime] + exclude('META-INF/INDEX.LIST', 'META-INF/*.SF', 'META-INF/*.DSA', 'META-INF/*.RSA','schema/*', + '.options', '.api_description', '*.profile', '*.html', 'about.*', 'about_files/*', + 'plugin.xml', 'systembundle.properties', 'profile.list') + classifier = 'ls' + append('plugin.properties') +} diff --git a/language-ide/src/main/java/org/eclipse/viatra/solver/language/ide/ProblemIdeModule.java b/language-ide/src/main/java/org/eclipse/viatra/solver/language/ide/ProblemIdeModule.java new file mode 100644 index 00000000..c6e41049 --- /dev/null +++ b/language-ide/src/main/java/org/eclipse/viatra/solver/language/ide/ProblemIdeModule.java @@ -0,0 +1,17 @@ +/* + * generated by Xtext 2.25.0 + */ +package org.eclipse.viatra.solver.language.ide; + +import org.eclipse.viatra.solver.language.ide.syntaxcoloring.ProblemSemanticHighlightingCalculator; +import org.eclipse.xtext.ide.editor.syntaxcoloring.ISemanticHighlightingCalculator; + +/** + * Use this class to register ide components. + */ +public class ProblemIdeModule extends AbstractProblemIdeModule { + + public Class bindISemanticHighlightingCalculator() { + return ProblemSemanticHighlightingCalculator.class; + } +} diff --git a/language-ide/src/main/java/org/eclipse/viatra/solver/language/ide/ProblemIdeSetup.java b/language-ide/src/main/java/org/eclipse/viatra/solver/language/ide/ProblemIdeSetup.java new file mode 100644 index 00000000..ca1fec30 --- /dev/null +++ b/language-ide/src/main/java/org/eclipse/viatra/solver/language/ide/ProblemIdeSetup.java @@ -0,0 +1,22 @@ +/* + * generated by Xtext 2.25.0 + */ +package org.eclipse.viatra.solver.language.ide; + +import com.google.inject.Guice; +import com.google.inject.Injector; +import org.eclipse.viatra.solver.language.ProblemRuntimeModule; +import org.eclipse.viatra.solver.language.ProblemStandaloneSetup; +import org.eclipse.xtext.util.Modules2; + +/** + * Initialization support for running Xtext languages as language servers. + */ +public class ProblemIdeSetup extends ProblemStandaloneSetup { + + @Override + public Injector createInjector() { + return Guice.createInjector(Modules2.mixin(new ProblemRuntimeModule(), new ProblemIdeModule())); + } + +} diff --git a/language-ide/src/main/java/org/eclipse/viatra/solver/language/ide/syntaxcoloring/ProblemSemanticHighlightingCalculator.java b/language-ide/src/main/java/org/eclipse/viatra/solver/language/ide/syntaxcoloring/ProblemSemanticHighlightingCalculator.java new file mode 100644 index 00000000..eee5070b --- /dev/null +++ b/language-ide/src/main/java/org/eclipse/viatra/solver/language/ide/syntaxcoloring/ProblemSemanticHighlightingCalculator.java @@ -0,0 +1,160 @@ +package org.eclipse.viatra.solver.language.ide.syntaxcoloring; + +import java.util.List; + +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.ecore.EAttribute; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EReference; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.viatra.solver.language.ProblemUtil; +import org.eclipse.viatra.solver.language.model.problem.ClassDeclaration; +import org.eclipse.viatra.solver.language.model.problem.EnumDeclaration; +import org.eclipse.viatra.solver.language.model.problem.Node; +import org.eclipse.viatra.solver.language.model.problem.Parameter; +import org.eclipse.viatra.solver.language.model.problem.PredicateDefinition; +import org.eclipse.viatra.solver.language.model.problem.ReferenceDeclaration; +import org.eclipse.viatra.solver.language.model.problem.Variable; +import org.eclipse.viatra.solver.language.scoping.ProblemGlobalScopeProvider; +import org.eclipse.xtext.ide.editor.syntaxcoloring.DefaultSemanticHighlightingCalculator; +import org.eclipse.xtext.ide.editor.syntaxcoloring.IHighlightedPositionAcceptor; +import org.eclipse.xtext.nodemodel.INode; +import org.eclipse.xtext.nodemodel.util.NodeModelUtils; +import org.eclipse.xtext.service.OperationCanceledManager; +import org.eclipse.xtext.util.CancelIndicator; +import org.eclipse.xtext.util.SimpleAttributeResolver; + +import com.google.common.collect.ImmutableList; +import com.google.inject.Inject; + +public class ProblemSemanticHighlightingCalculator extends DefaultSemanticHighlightingCalculator { + private static final String BUILTIN_CLASS = "cm-keyword"; + private static final String CLASS_CLASS = "problem-class"; + private static final String ABSTRACT_CLASS = "problem-abstract"; + private static final String ENUM_CLASS = "problem-enum"; + private static final String REFERENCE_CLASS = "problem-reference"; + private static final String CONTAINMENT_CLASS = "problem-containment"; + private static final String PREDICATE_CLASS = "problem-predicate"; + private static final String ERROR_CLASS = "problem-error"; + private static final String NODE_CLASS = "problem-node"; + private static final String ENUM_NODE_CLASS = "problem-enum-node"; + private static final String NEW_NODE_CLASS = "problem-new-node"; + private static final String PARAMETER_CLASS = "problem-parameter"; + private static final String VARIABLE_CLASS = "problem-variable"; + private static final String SINGLETON_VARIABLE_CLASS = "problem-singleton-variable"; + + @Inject + private OperationCanceledManager operationCanceledManager; + + @Override + protected boolean highlightElement(EObject object, IHighlightedPositionAcceptor acceptor, + CancelIndicator cancelIndicator) { + highlightName(object, acceptor, cancelIndicator); + highlightCrossReferences(object, acceptor, cancelIndicator); + return false; + } + + protected void highlightName(EObject object, IHighlightedPositionAcceptor acceptor, + CancelIndicator cancelIndicator) { + String[] highlightClass = getHighlightClass(object); + if (highlightClass.length > 0) { + EAttribute nameAttribute = SimpleAttributeResolver.NAME_RESOLVER.getAttribute(object); + if (nameAttribute != null) { + highlightFeature(acceptor, object, nameAttribute, highlightClass); + } + } + } + + protected void highlightCrossReferences(EObject object, IHighlightedPositionAcceptor acceptor, + CancelIndicator cancelIndicator) { + for (EReference reference : object.eClass().getEAllReferences()) { + if (reference.isContainment()) { + continue; + } + operationCanceledManager.checkCanceled(cancelIndicator); + if (reference.isMany()) { + @SuppressWarnings("unchecked") + EList values = (EList) object.eGet(reference); + List nodes = NodeModelUtils.findNodesForFeature(object, reference); + int size = Math.min(values.size(), nodes.size()); + for (int i = 0; i < size; i++) { + EObject valueInList = values.get(i); + INode node = nodes.get(i); + String[] highlightClass = getHighlightClass(valueInList); + if (highlightClass.length > 0) { + highlightNode(acceptor, node, highlightClass); + } + } + } else { + EObject valueObj = (EObject) object.eGet(reference); + String[] highlightClass = getHighlightClass(valueObj); + if (highlightClass.length > 0) { + highlightFeature(acceptor, object, reference, highlightClass); + } + } + } + } + + protected String[] getHighlightClass(EObject eObject) { + if (isBuiltIn(eObject)) { + return new String[] { BUILTIN_CLASS }; + } + ImmutableList.Builder classesBuilder = ImmutableList.builder(); + if (eObject instanceof ClassDeclaration) { + classesBuilder.add(CLASS_CLASS); + ClassDeclaration classDeclaration = (ClassDeclaration) eObject; + if (classDeclaration.isAbstract()) { + classesBuilder.add(ABSTRACT_CLASS); + } + } + if (eObject instanceof EnumDeclaration) { + classesBuilder.add(ENUM_CLASS); + } + if (eObject instanceof ReferenceDeclaration) { + classesBuilder.add(REFERENCE_CLASS); + ReferenceDeclaration referenceDeclaration = (ReferenceDeclaration) eObject; + if (referenceDeclaration.isContainment()) { + classesBuilder.add(CONTAINMENT_CLASS); + } + } + if (eObject instanceof PredicateDefinition) { + classesBuilder.add(PREDICATE_CLASS); + PredicateDefinition predicateDefinition = (PredicateDefinition) eObject; + if (predicateDefinition.isError()) { + classesBuilder.add(ERROR_CLASS); + } + } + if (eObject instanceof Node) { + classesBuilder.add(NODE_CLASS); + Node node = (Node) eObject; + if (ProblemUtil.isEnumNode(node)) { + classesBuilder.add(ENUM_NODE_CLASS); + } + if (ProblemUtil.isNewNode(node)) { + classesBuilder.add(NEW_NODE_CLASS); + } + } + if (eObject instanceof Parameter) { + classesBuilder.add(PARAMETER_CLASS); + } + if (eObject instanceof Variable) { + classesBuilder.add(VARIABLE_CLASS); + Variable variable = (Variable) eObject; + if (ProblemUtil.isSingletonVariable(variable)) { + classesBuilder.add(SINGLETON_VARIABLE_CLASS); + } + } + List classes = classesBuilder.build(); + return classes.toArray(new String[0]); + } + + protected boolean isBuiltIn(EObject eObject) { + if (eObject != null) { + Resource eResource = eObject.eResource(); + if (eResource != null) { + return ProblemGlobalScopeProvider.BULTIN_LIBRARY_URI.equals(eResource.getURI()); + } + } + return false; + } +} diff --git a/language-ide/src/main/xtext-gen/META-INF/services/org.eclipse.xtext.ISetup b/language-ide/src/main/xtext-gen/META-INF/services/org.eclipse.xtext.ISetup new file mode 100644 index 00000000..8e9ec892 --- /dev/null +++ b/language-ide/src/main/xtext-gen/META-INF/services/org.eclipse.xtext.ISetup @@ -0,0 +1 @@ +org.eclipse.viatra.solver.language.ide.ProblemIdeSetup diff --git a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/AbstractProblemIdeModule.java b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/AbstractProblemIdeModule.java new file mode 100644 index 00000000..a44461f9 --- /dev/null +++ b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/AbstractProblemIdeModule.java @@ -0,0 +1,60 @@ +/* + * generated by Xtext 2.26.0.M1 + */ +package org.eclipse.viatra.solver.language.ide; + +import com.google.inject.Binder; +import com.google.inject.name.Names; +import org.eclipse.viatra.solver.language.ide.contentassist.antlr.ProblemParser; +import org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal.InternalProblemLexer; +import org.eclipse.xtext.ide.DefaultIdeModule; +import org.eclipse.xtext.ide.LexerIdeBindings; +import org.eclipse.xtext.ide.editor.contentassist.FQNPrefixMatcher; +import org.eclipse.xtext.ide.editor.contentassist.IPrefixMatcher; +import org.eclipse.xtext.ide.editor.contentassist.IProposalConflictHelper; +import org.eclipse.xtext.ide.editor.contentassist.antlr.AntlrProposalConflictHelper; +import org.eclipse.xtext.ide.editor.contentassist.antlr.IContentAssistParser; +import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer; +import org.eclipse.xtext.ide.refactoring.IRenameStrategy2; +import org.eclipse.xtext.ide.server.rename.IRenameService2; +import org.eclipse.xtext.ide.server.rename.RenameService2; + +/** + * Manual modifications go to {@link ProblemIdeModule}. + */ +@SuppressWarnings("all") +public abstract class AbstractProblemIdeModule extends DefaultIdeModule { + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public void configureContentAssistLexer(Binder binder) { + binder.bind(Lexer.class) + .annotatedWith(Names.named(LexerIdeBindings.CONTENT_ASSIST)) + .to(InternalProblemLexer.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindIContentAssistParser() { + return ProblemParser.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindIProposalConflictHelper() { + return AntlrProposalConflictHelper.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.exporting.QualifiedNamesFragment2 + public Class bindIPrefixMatcher() { + return FQNPrefixMatcher.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2 + public Class bindIRenameService2() { + return RenameService2.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2 + public Class bindIRenameStrategy2() { + return IRenameStrategy2.DefaultImpl.class; + } + +} diff --git a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/PartialProblemContentAssistParser.java b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/PartialProblemContentAssistParser.java new file mode 100644 index 00000000..890ab643 --- /dev/null +++ b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/PartialProblemContentAssistParser.java @@ -0,0 +1,33 @@ +/* + * generated by Xtext 2.26.0.M1 + */ +package org.eclipse.viatra.solver.language.ide.contentassist.antlr; + +import java.util.Collection; +import java.util.Collections; +import org.eclipse.xtext.AbstractRule; +import org.eclipse.xtext.ide.editor.contentassist.antlr.FollowElement; +import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; +import org.eclipse.xtext.util.PolymorphicDispatcher; + +public class PartialProblemContentAssistParser extends ProblemParser { + + private AbstractRule rule; + + @Override + public void initializeFor(AbstractRule rule) { + this.rule = rule; + } + + @Override + protected Collection getFollowElements(AbstractInternalContentAssistParser parser) { + if (rule == null || rule.eIsProxy()) + return Collections.emptyList(); + String methodName = "entryRule" + rule.getName(); + PolymorphicDispatcher> dispatcher = + new PolymorphicDispatcher>(methodName, 0, 0, Collections.singletonList(parser)); + dispatcher.invoke(); + return parser.getFollowElements(); + } + +} diff --git a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/ProblemParser.java b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/ProblemParser.java new file mode 100644 index 00000000..e4142d9f --- /dev/null +++ b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/ProblemParser.java @@ -0,0 +1,181 @@ +/* + * generated by Xtext 2.26.0.M1 + */ +package org.eclipse.viatra.solver.language.ide.contentassist.antlr; + +import com.google.common.collect.ImmutableMap; +import com.google.inject.Inject; +import com.google.inject.Singleton; +import java.util.Map; +import org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal.InternalProblemParser; +import org.eclipse.viatra.solver.language.services.ProblemGrammarAccess; +import org.eclipse.xtext.AbstractElement; +import org.eclipse.xtext.ide.editor.contentassist.antlr.AbstractContentAssistParser; + +public class ProblemParser extends AbstractContentAssistParser { + + @Singleton + public static final class NameMappings { + + private final Map mappings; + + @Inject + public NameMappings(ProblemGrammarAccess grammarAccess) { + ImmutableMap.Builder builder = ImmutableMap.builder(); + init(builder, grammarAccess); + this.mappings = builder.build(); + } + + public String getRuleName(AbstractElement element) { + return mappings.get(element); + } + + private static void init(ImmutableMap.Builder builder, ProblemGrammarAccess grammarAccess) { + builder.put(grammarAccess.getStatementAccess().getAlternatives(), "rule__Statement__Alternatives"); + builder.put(grammarAccess.getClassDeclarationAccess().getAlternatives_4(), "rule__ClassDeclaration__Alternatives_4"); + builder.put(grammarAccess.getEnumDeclarationAccess().getAlternatives_2(), "rule__EnumDeclaration__Alternatives_2"); + builder.put(grammarAccess.getEnumDeclarationAccess().getAlternatives_2_0_1_2(), "rule__EnumDeclaration__Alternatives_2_0_1_2"); + builder.put(grammarAccess.getReferenceDeclarationAccess().getAlternatives_0(), "rule__ReferenceDeclaration__Alternatives_0"); + builder.put(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0(), "rule__PredicateDefinition__Alternatives_0"); + builder.put(grammarAccess.getLiteralAccess().getAlternatives(), "rule__Literal__Alternatives"); + builder.put(grammarAccess.getAssertionAccess().getAlternatives_0(), "rule__Assertion__Alternatives_0"); + builder.put(grammarAccess.getTypeScopeAccess().getAlternatives_1(), "rule__TypeScope__Alternatives_1"); + builder.put(grammarAccess.getMultiplicityAccess().getAlternatives(), "rule__Multiplicity__Alternatives"); + builder.put(grammarAccess.getDefiniteMultiplicityAccess().getAlternatives(), "rule__DefiniteMultiplicity__Alternatives"); + builder.put(grammarAccess.getUpperBoundAccess().getAlternatives(), "rule__UpperBound__Alternatives"); + builder.put(grammarAccess.getQuotedOrUnquotedIdAccess().getAlternatives(), "rule__QuotedOrUnquotedId__Alternatives"); + builder.put(grammarAccess.getQualifiedNameAccess().getAlternatives(), "rule__QualifiedName__Alternatives"); + builder.put(grammarAccess.getIdentifierAccess().getAlternatives(), "rule__Identifier__Alternatives"); + builder.put(grammarAccess.getLogicValueAccess().getAlternatives(), "rule__LogicValue__Alternatives"); + builder.put(grammarAccess.getShortLogicValueAccess().getAlternatives(), "rule__ShortLogicValue__Alternatives"); + builder.put(grammarAccess.getProblemAccess().getGroup(), "rule__Problem__Group__0"); + builder.put(grammarAccess.getProblemAccess().getGroup_0(), "rule__Problem__Group_0__0"); + builder.put(grammarAccess.getClassDeclarationAccess().getGroup(), "rule__ClassDeclaration__Group__0"); + builder.put(grammarAccess.getClassDeclarationAccess().getGroup_3(), "rule__ClassDeclaration__Group_3__0"); + builder.put(grammarAccess.getClassDeclarationAccess().getGroup_3_2(), "rule__ClassDeclaration__Group_3_2__0"); + builder.put(grammarAccess.getClassDeclarationAccess().getGroup_4_0(), "rule__ClassDeclaration__Group_4_0__0"); + builder.put(grammarAccess.getClassDeclarationAccess().getGroup_4_0_1(), "rule__ClassDeclaration__Group_4_0_1__0"); + builder.put(grammarAccess.getEnumDeclarationAccess().getGroup(), "rule__EnumDeclaration__Group__0"); + builder.put(grammarAccess.getEnumDeclarationAccess().getGroup_2_0(), "rule__EnumDeclaration__Group_2_0__0"); + builder.put(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1(), "rule__EnumDeclaration__Group_2_0_1__0"); + builder.put(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1_1(), "rule__EnumDeclaration__Group_2_0_1_1__0"); + builder.put(grammarAccess.getReferenceDeclarationAccess().getGroup(), "rule__ReferenceDeclaration__Group__0"); + builder.put(grammarAccess.getReferenceDeclarationAccess().getGroup_2(), "rule__ReferenceDeclaration__Group_2__0"); + builder.put(grammarAccess.getReferenceDeclarationAccess().getGroup_4(), "rule__ReferenceDeclaration__Group_4__0"); + builder.put(grammarAccess.getPredicateDefinitionAccess().getGroup(), "rule__PredicateDefinition__Group__0"); + builder.put(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0(), "rule__PredicateDefinition__Group_0_0__0"); + builder.put(grammarAccess.getPredicateDefinitionAccess().getGroup_3(), "rule__PredicateDefinition__Group_3__0"); + builder.put(grammarAccess.getPredicateDefinitionAccess().getGroup_3_1(), "rule__PredicateDefinition__Group_3_1__0"); + builder.put(grammarAccess.getPredicateDefinitionAccess().getGroup_5(), "rule__PredicateDefinition__Group_5__0"); + builder.put(grammarAccess.getPredicateDefinitionAccess().getGroup_5_2(), "rule__PredicateDefinition__Group_5_2__0"); + builder.put(grammarAccess.getParameterAccess().getGroup(), "rule__Parameter__Group__0"); + builder.put(grammarAccess.getConjunctionAccess().getGroup(), "rule__Conjunction__Group__0"); + builder.put(grammarAccess.getConjunctionAccess().getGroup_1(), "rule__Conjunction__Group_1__0"); + builder.put(grammarAccess.getNegativeLiteralAccess().getGroup(), "rule__NegativeLiteral__Group__0"); + builder.put(grammarAccess.getAtomAccess().getGroup(), "rule__Atom__Group__0"); + builder.put(grammarAccess.getAtomAccess().getGroup_3(), "rule__Atom__Group_3__0"); + builder.put(grammarAccess.getAtomAccess().getGroup_3_1(), "rule__Atom__Group_3_1__0"); + builder.put(grammarAccess.getAssertionAccess().getGroup(), "rule__Assertion__Group__0"); + builder.put(grammarAccess.getAssertionAccess().getGroup_0_0(), "rule__Assertion__Group_0_0__0"); + builder.put(grammarAccess.getAssertionAccess().getGroup_0_0_2(), "rule__Assertion__Group_0_0_2__0"); + builder.put(grammarAccess.getAssertionAccess().getGroup_0_0_2_1(), "rule__Assertion__Group_0_0_2_1__0"); + builder.put(grammarAccess.getAssertionAccess().getGroup_0_1(), "rule__Assertion__Group_0_1__0"); + builder.put(grammarAccess.getAssertionAccess().getGroup_0_1_3(), "rule__Assertion__Group_0_1_3__0"); + builder.put(grammarAccess.getAssertionAccess().getGroup_0_1_3_1(), "rule__Assertion__Group_0_1_3_1__0"); + builder.put(grammarAccess.getScopeDeclarationAccess().getGroup(), "rule__ScopeDeclaration__Group__0"); + builder.put(grammarAccess.getScopeDeclarationAccess().getGroup_2(), "rule__ScopeDeclaration__Group_2__0"); + builder.put(grammarAccess.getTypeScopeAccess().getGroup(), "rule__TypeScope__Group__0"); + builder.put(grammarAccess.getRangeMultiplicityAccess().getGroup(), "rule__RangeMultiplicity__Group__0"); + builder.put(grammarAccess.getQualifiedNameAccess().getGroup_1(), "rule__QualifiedName__Group_1__0"); + builder.put(grammarAccess.getQualifiedNameAccess().getGroup_1_1(), "rule__QualifiedName__Group_1_1__0"); + builder.put(grammarAccess.getQualifiedNameAccess().getGroup_1_2(), "rule__QualifiedName__Group_1_2__0"); + builder.put(grammarAccess.getProblemAccess().getNameAssignment_0_1(), "rule__Problem__NameAssignment_0_1"); + builder.put(grammarAccess.getProblemAccess().getStatementsAssignment_1(), "rule__Problem__StatementsAssignment_1"); + builder.put(grammarAccess.getClassDeclarationAccess().getAbstractAssignment_0(), "rule__ClassDeclaration__AbstractAssignment_0"); + builder.put(grammarAccess.getClassDeclarationAccess().getNameAssignment_2(), "rule__ClassDeclaration__NameAssignment_2"); + builder.put(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_1(), "rule__ClassDeclaration__SuperTypesAssignment_3_1"); + builder.put(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_2_1(), "rule__ClassDeclaration__SuperTypesAssignment_3_2_1"); + builder.put(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsAssignment_4_0_1_0(), "rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0"); + builder.put(grammarAccess.getEnumDeclarationAccess().getNameAssignment_1(), "rule__EnumDeclaration__NameAssignment_1"); + builder.put(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_0(), "rule__EnumDeclaration__LiteralsAssignment_2_0_1_0"); + builder.put(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_1_1(), "rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1"); + builder.put(grammarAccess.getEnumLiteralAccess().getNameAssignment(), "rule__EnumLiteral__NameAssignment"); + builder.put(grammarAccess.getReferenceDeclarationAccess().getContainmentAssignment_0_0(), "rule__ReferenceDeclaration__ContainmentAssignment_0_0"); + builder.put(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeAssignment_1(), "rule__ReferenceDeclaration__ReferenceTypeAssignment_1"); + builder.put(grammarAccess.getReferenceDeclarationAccess().getMultiplicityAssignment_2_1(), "rule__ReferenceDeclaration__MultiplicityAssignment_2_1"); + builder.put(grammarAccess.getReferenceDeclarationAccess().getNameAssignment_3(), "rule__ReferenceDeclaration__NameAssignment_3"); + builder.put(grammarAccess.getReferenceDeclarationAccess().getOppositeAssignment_4_1(), "rule__ReferenceDeclaration__OppositeAssignment_4_1"); + builder.put(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_0(), "rule__PredicateDefinition__ErrorAssignment_0_0_0"); + builder.put(grammarAccess.getPredicateDefinitionAccess().getNameAssignment_1(), "rule__PredicateDefinition__NameAssignment_1"); + builder.put(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_0(), "rule__PredicateDefinition__ParametersAssignment_3_0"); + builder.put(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_1_1(), "rule__PredicateDefinition__ParametersAssignment_3_1_1"); + builder.put(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_1(), "rule__PredicateDefinition__BodiesAssignment_5_1"); + builder.put(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_2_1(), "rule__PredicateDefinition__BodiesAssignment_5_2_1"); + builder.put(grammarAccess.getParameterAccess().getParameterTypeAssignment_0(), "rule__Parameter__ParameterTypeAssignment_0"); + builder.put(grammarAccess.getParameterAccess().getNameAssignment_1(), "rule__Parameter__NameAssignment_1"); + builder.put(grammarAccess.getConjunctionAccess().getLiteralsAssignment_0(), "rule__Conjunction__LiteralsAssignment_0"); + builder.put(grammarAccess.getConjunctionAccess().getLiteralsAssignment_1_1(), "rule__Conjunction__LiteralsAssignment_1_1"); + builder.put(grammarAccess.getNegativeLiteralAccess().getAtomAssignment_1(), "rule__NegativeLiteral__AtomAssignment_1"); + builder.put(grammarAccess.getAtomAccess().getRelationAssignment_0(), "rule__Atom__RelationAssignment_0"); + builder.put(grammarAccess.getAtomAccess().getTransitiveClosureAssignment_1(), "rule__Atom__TransitiveClosureAssignment_1"); + builder.put(grammarAccess.getAtomAccess().getArgumentsAssignment_3_0(), "rule__Atom__ArgumentsAssignment_3_0"); + builder.put(grammarAccess.getAtomAccess().getArgumentsAssignment_3_1_1(), "rule__Atom__ArgumentsAssignment_3_1_1"); + builder.put(grammarAccess.getArgumentAccess().getVariableOrNodeAssignment(), "rule__Argument__VariableOrNodeAssignment"); + builder.put(grammarAccess.getAssertionAccess().getRelationAssignment_0_0_0(), "rule__Assertion__RelationAssignment_0_0_0"); + builder.put(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_0(), "rule__Assertion__ArgumentsAssignment_0_0_2_0"); + builder.put(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_1_1(), "rule__Assertion__ArgumentsAssignment_0_0_2_1_1"); + builder.put(grammarAccess.getAssertionAccess().getValueAssignment_0_0_5(), "rule__Assertion__ValueAssignment_0_0_5"); + builder.put(grammarAccess.getAssertionAccess().getValueAssignment_0_1_0(), "rule__Assertion__ValueAssignment_0_1_0"); + builder.put(grammarAccess.getAssertionAccess().getRelationAssignment_0_1_1(), "rule__Assertion__RelationAssignment_0_1_1"); + builder.put(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_0(), "rule__Assertion__ArgumentsAssignment_0_1_3_0"); + builder.put(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_1_1(), "rule__Assertion__ArgumentsAssignment_0_1_3_1_1"); + builder.put(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_1(), "rule__ScopeDeclaration__TypeScopesAssignment_1"); + builder.put(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_2_1(), "rule__ScopeDeclaration__TypeScopesAssignment_2_1"); + builder.put(grammarAccess.getTypeScopeAccess().getTargetTypeAssignment_0(), "rule__TypeScope__TargetTypeAssignment_0"); + builder.put(grammarAccess.getTypeScopeAccess().getIncrementAssignment_1_0(), "rule__TypeScope__IncrementAssignment_1_0"); + builder.put(grammarAccess.getTypeScopeAccess().getMultiplicityAssignment_2(), "rule__TypeScope__MultiplicityAssignment_2"); + builder.put(grammarAccess.getRangeMultiplicityAccess().getLowerBoundAssignment_0(), "rule__RangeMultiplicity__LowerBoundAssignment_0"); + builder.put(grammarAccess.getRangeMultiplicityAccess().getUpperBoundAssignment_2(), "rule__RangeMultiplicity__UpperBoundAssignment_2"); + builder.put(grammarAccess.getExactMultiplicityAccess().getExactValueAssignment(), "rule__ExactMultiplicity__ExactValueAssignment"); + } + } + + @Inject + private NameMappings nameMappings; + + @Inject + private ProblemGrammarAccess grammarAccess; + + @Override + protected InternalProblemParser createParser() { + InternalProblemParser result = new InternalProblemParser(null); + result.setGrammarAccess(grammarAccess); + return result; + } + + @Override + protected String getRuleName(AbstractElement element) { + return nameMappings.getRuleName(element); + } + + @Override + protected String[] getInitialHiddenTokens() { + return new String[] { "RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT" }; + } + + public ProblemGrammarAccess getGrammarAccess() { + return this.grammarAccess; + } + + public void setGrammarAccess(ProblemGrammarAccess grammarAccess) { + this.grammarAccess = grammarAccess; + } + + public NameMappings getNameMappings() { + return nameMappings; + } + + public void setNameMappings(NameMappings nameMappings) { + this.nameMappings = nameMappings; + } +} diff --git a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.g b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.g new file mode 100644 index 00000000..0a7c03ba --- /dev/null +++ b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.g @@ -0,0 +1,5038 @@ +/* + * generated by Xtext 2.26.0.M1 + */ +grammar InternalProblem; + +options { + superClass=AbstractInternalContentAssistParser; +} + +@lexer::header { +package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal; + +// Hack: Use our own Lexer superclass by means of import. +// Currently there is no other way to specify the superclass for the lexer. +import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer; +} + +@parser::header { +package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal; + +import java.io.InputStream; +import org.eclipse.xtext.*; +import org.eclipse.xtext.parser.*; +import org.eclipse.xtext.parser.impl.*; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; +import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; +import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; +import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA; +import org.eclipse.viatra.solver.language.services.ProblemGrammarAccess; + +} +@parser::members { + private ProblemGrammarAccess grammarAccess; + + public void setGrammarAccess(ProblemGrammarAccess grammarAccess) { + this.grammarAccess = grammarAccess; + } + + @Override + protected Grammar getGrammar() { + return grammarAccess.getGrammar(); + } + + @Override + protected String getValueForTokenName(String tokenName) { + return tokenName; + } +} + +// Entry rule entryRuleProblem +entryRuleProblem +: +{ before(grammarAccess.getProblemRule()); } + ruleProblem +{ after(grammarAccess.getProblemRule()); } + EOF +; + +// Rule Problem +ruleProblem + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getProblemAccess().getGroup()); } + (rule__Problem__Group__0) + { after(grammarAccess.getProblemAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleStatement +entryRuleStatement +: +{ before(grammarAccess.getStatementRule()); } + ruleStatement +{ after(grammarAccess.getStatementRule()); } + EOF +; + +// Rule Statement +ruleStatement + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getStatementAccess().getAlternatives()); } + (rule__Statement__Alternatives) + { after(grammarAccess.getStatementAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleClassDeclaration +entryRuleClassDeclaration +: +{ before(grammarAccess.getClassDeclarationRule()); } + ruleClassDeclaration +{ after(grammarAccess.getClassDeclarationRule()); } + EOF +; + +// Rule ClassDeclaration +ruleClassDeclaration + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getClassDeclarationAccess().getGroup()); } + (rule__ClassDeclaration__Group__0) + { after(grammarAccess.getClassDeclarationAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleEnumDeclaration +entryRuleEnumDeclaration +: +{ before(grammarAccess.getEnumDeclarationRule()); } + ruleEnumDeclaration +{ after(grammarAccess.getEnumDeclarationRule()); } + EOF +; + +// Rule EnumDeclaration +ruleEnumDeclaration + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getEnumDeclarationAccess().getGroup()); } + (rule__EnumDeclaration__Group__0) + { after(grammarAccess.getEnumDeclarationAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleEnumLiteral +entryRuleEnumLiteral +: +{ before(grammarAccess.getEnumLiteralRule()); } + ruleEnumLiteral +{ after(grammarAccess.getEnumLiteralRule()); } + EOF +; + +// Rule EnumLiteral +ruleEnumLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getEnumLiteralAccess().getNameAssignment()); } + (rule__EnumLiteral__NameAssignment) + { after(grammarAccess.getEnumLiteralAccess().getNameAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleReferenceDeclaration +entryRuleReferenceDeclaration +: +{ before(grammarAccess.getReferenceDeclarationRule()); } + ruleReferenceDeclaration +{ after(grammarAccess.getReferenceDeclarationRule()); } + EOF +; + +// Rule ReferenceDeclaration +ruleReferenceDeclaration + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getReferenceDeclarationAccess().getGroup()); } + (rule__ReferenceDeclaration__Group__0) + { after(grammarAccess.getReferenceDeclarationAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRulePredicateDefinition +entryRulePredicateDefinition +: +{ before(grammarAccess.getPredicateDefinitionRule()); } + rulePredicateDefinition +{ after(grammarAccess.getPredicateDefinitionRule()); } + EOF +; + +// Rule PredicateDefinition +rulePredicateDefinition + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getPredicateDefinitionAccess().getGroup()); } + (rule__PredicateDefinition__Group__0) + { after(grammarAccess.getPredicateDefinitionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleParameter +entryRuleParameter +: +{ before(grammarAccess.getParameterRule()); } + ruleParameter +{ after(grammarAccess.getParameterRule()); } + EOF +; + +// Rule Parameter +ruleParameter + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getParameterAccess().getGroup()); } + (rule__Parameter__Group__0) + { after(grammarAccess.getParameterAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleConjunction +entryRuleConjunction +: +{ before(grammarAccess.getConjunctionRule()); } + ruleConjunction +{ after(grammarAccess.getConjunctionRule()); } + EOF +; + +// Rule Conjunction +ruleConjunction + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getConjunctionAccess().getGroup()); } + (rule__Conjunction__Group__0) + { after(grammarAccess.getConjunctionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleLiteral +entryRuleLiteral +: +{ before(grammarAccess.getLiteralRule()); } + ruleLiteral +{ after(grammarAccess.getLiteralRule()); } + EOF +; + +// Rule Literal +ruleLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getLiteralAccess().getAlternatives()); } + (rule__Literal__Alternatives) + { after(grammarAccess.getLiteralAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleNegativeLiteral +entryRuleNegativeLiteral +: +{ before(grammarAccess.getNegativeLiteralRule()); } + ruleNegativeLiteral +{ after(grammarAccess.getNegativeLiteralRule()); } + EOF +; + +// Rule NegativeLiteral +ruleNegativeLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getNegativeLiteralAccess().getGroup()); } + (rule__NegativeLiteral__Group__0) + { after(grammarAccess.getNegativeLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleAtom +entryRuleAtom +: +{ before(grammarAccess.getAtomRule()); } + ruleAtom +{ after(grammarAccess.getAtomRule()); } + EOF +; + +// Rule Atom +ruleAtom + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getAtomAccess().getGroup()); } + (rule__Atom__Group__0) + { after(grammarAccess.getAtomAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleArgument +entryRuleArgument +: +{ before(grammarAccess.getArgumentRule()); } + ruleArgument +{ after(grammarAccess.getArgumentRule()); } + EOF +; + +// Rule Argument +ruleArgument + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getArgumentAccess().getVariableOrNodeAssignment()); } + (rule__Argument__VariableOrNodeAssignment) + { after(grammarAccess.getArgumentAccess().getVariableOrNodeAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleAssertion +entryRuleAssertion +: +{ before(grammarAccess.getAssertionRule()); } + ruleAssertion +{ after(grammarAccess.getAssertionRule()); } + EOF +; + +// Rule Assertion +ruleAssertion + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getAssertionAccess().getGroup()); } + (rule__Assertion__Group__0) + { after(grammarAccess.getAssertionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleScopeDeclaration +entryRuleScopeDeclaration +: +{ before(grammarAccess.getScopeDeclarationRule()); } + ruleScopeDeclaration +{ after(grammarAccess.getScopeDeclarationRule()); } + EOF +; + +// Rule ScopeDeclaration +ruleScopeDeclaration + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getScopeDeclarationAccess().getGroup()); } + (rule__ScopeDeclaration__Group__0) + { after(grammarAccess.getScopeDeclarationAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleTypeScope +entryRuleTypeScope +: +{ before(grammarAccess.getTypeScopeRule()); } + ruleTypeScope +{ after(grammarAccess.getTypeScopeRule()); } + EOF +; + +// Rule TypeScope +ruleTypeScope + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getTypeScopeAccess().getGroup()); } + (rule__TypeScope__Group__0) + { after(grammarAccess.getTypeScopeAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleMultiplicity +entryRuleMultiplicity +: +{ before(grammarAccess.getMultiplicityRule()); } + ruleMultiplicity +{ after(grammarAccess.getMultiplicityRule()); } + EOF +; + +// Rule Multiplicity +ruleMultiplicity + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getMultiplicityAccess().getAlternatives()); } + (rule__Multiplicity__Alternatives) + { after(grammarAccess.getMultiplicityAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleDefiniteMultiplicity +entryRuleDefiniteMultiplicity +: +{ before(grammarAccess.getDefiniteMultiplicityRule()); } + ruleDefiniteMultiplicity +{ after(grammarAccess.getDefiniteMultiplicityRule()); } + EOF +; + +// Rule DefiniteMultiplicity +ruleDefiniteMultiplicity + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getDefiniteMultiplicityAccess().getAlternatives()); } + (rule__DefiniteMultiplicity__Alternatives) + { after(grammarAccess.getDefiniteMultiplicityAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleUnboundedMultiplicity +entryRuleUnboundedMultiplicity +: +{ before(grammarAccess.getUnboundedMultiplicityRule()); } + ruleUnboundedMultiplicity +{ after(grammarAccess.getUnboundedMultiplicityRule()); } + EOF +; + +// Rule UnboundedMultiplicity +ruleUnboundedMultiplicity + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction()); } + () + { after(grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleRangeMultiplicity +entryRuleRangeMultiplicity +: +{ before(grammarAccess.getRangeMultiplicityRule()); } + ruleRangeMultiplicity +{ after(grammarAccess.getRangeMultiplicityRule()); } + EOF +; + +// Rule RangeMultiplicity +ruleRangeMultiplicity + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getRangeMultiplicityAccess().getGroup()); } + (rule__RangeMultiplicity__Group__0) + { after(grammarAccess.getRangeMultiplicityAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleExactMultiplicity +entryRuleExactMultiplicity +: +{ before(grammarAccess.getExactMultiplicityRule()); } + ruleExactMultiplicity +{ after(grammarAccess.getExactMultiplicityRule()); } + EOF +; + +// Rule ExactMultiplicity +ruleExactMultiplicity + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getExactMultiplicityAccess().getExactValueAssignment()); } + (rule__ExactMultiplicity__ExactValueAssignment) + { after(grammarAccess.getExactMultiplicityAccess().getExactValueAssignment()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleUpperBound +entryRuleUpperBound +: +{ before(grammarAccess.getUpperBoundRule()); } + ruleUpperBound +{ after(grammarAccess.getUpperBoundRule()); } + EOF +; + +// Rule UpperBound +ruleUpperBound + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getUpperBoundAccess().getAlternatives()); } + (rule__UpperBound__Alternatives) + { after(grammarAccess.getUpperBoundAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleQuotedOrUnquotedId +entryRuleQuotedOrUnquotedId +: +{ before(grammarAccess.getQuotedOrUnquotedIdRule()); } + ruleQuotedOrUnquotedId +{ after(grammarAccess.getQuotedOrUnquotedIdRule()); } + EOF +; + +// Rule QuotedOrUnquotedId +ruleQuotedOrUnquotedId + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getQuotedOrUnquotedIdAccess().getAlternatives()); } + (rule__QuotedOrUnquotedId__Alternatives) + { after(grammarAccess.getQuotedOrUnquotedIdAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleQualifiedName +entryRuleQualifiedName +: +{ before(grammarAccess.getQualifiedNameRule()); } + ruleQualifiedName +{ after(grammarAccess.getQualifiedNameRule()); } + EOF +; + +// Rule QualifiedName +ruleQualifiedName + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getQualifiedNameAccess().getAlternatives()); } + (rule__QualifiedName__Alternatives) + { after(grammarAccess.getQualifiedNameAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleIdentifier +entryRuleIdentifier +: +{ before(grammarAccess.getIdentifierRule()); } + ruleIdentifier +{ after(grammarAccess.getIdentifierRule()); } + EOF +; + +// Rule Identifier +ruleIdentifier + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getIdentifierAccess().getAlternatives()); } + (rule__Identifier__Alternatives) + { after(grammarAccess.getIdentifierAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Rule LogicValue +ruleLogicValue + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getLogicValueAccess().getAlternatives()); } + (rule__LogicValue__Alternatives) + { after(grammarAccess.getLogicValueAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Rule ShortLogicValue +ruleShortLogicValue + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getShortLogicValueAccess().getAlternatives()); } + (rule__ShortLogicValue__Alternatives) + { after(grammarAccess.getShortLogicValueAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Statement__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_0()); } + ruleClassDeclaration + { after(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_1()); } + ruleEnumDeclaration + { after(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_2()); } + rulePredicateDefinition + { after(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getStatementAccess().getAssertionParserRuleCall_3()); } + ruleAssertion + { after(grammarAccess.getStatementAccess().getAssertionParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_4()); } + ruleScopeDeclaration + { after(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_4()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Alternatives_4 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getClassDeclarationAccess().getGroup_4_0()); } + (rule__ClassDeclaration__Group_4_0__0) + { after(grammarAccess.getClassDeclarationAccess().getGroup_4_0()); } + ) + | + ( + { before(grammarAccess.getClassDeclarationAccess().getFullStopKeyword_4_1()); } + '.' + { after(grammarAccess.getClassDeclarationAccess().getFullStopKeyword_4_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Alternatives_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0()); } + (rule__EnumDeclaration__Group_2_0__0) + { after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0()); } + ) + | + ( + { before(grammarAccess.getEnumDeclarationAccess().getFullStopKeyword_2_1()); } + '.' + { after(grammarAccess.getEnumDeclarationAccess().getFullStopKeyword_2_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Alternatives_2_0_1_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_2_0()); } + ',' + { after(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_2_0()); } + ) + | + ( + { before(grammarAccess.getEnumDeclarationAccess().getSemicolonKeyword_2_0_1_2_1()); } + ';' + { after(grammarAccess.getEnumDeclarationAccess().getSemicolonKeyword_2_0_1_2_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Alternatives_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getReferenceDeclarationAccess().getContainmentAssignment_0_0()); } + (rule__ReferenceDeclaration__ContainmentAssignment_0_0) + { after(grammarAccess.getReferenceDeclarationAccess().getContainmentAssignment_0_0()); } + ) + | + ( + { before(grammarAccess.getReferenceDeclarationAccess().getRefersKeyword_0_1()); } + 'refers' + { after(grammarAccess.getReferenceDeclarationAccess().getRefersKeyword_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Alternatives_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); } + (rule__PredicateDefinition__Group_0_0__0) + { after(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); } + ) + | + ( + { before(grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_1()); } + 'pred' + { after(grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Literal__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getLiteralAccess().getAtomParserRuleCall_0()); } + ruleAtom + { after(grammarAccess.getLiteralAccess().getAtomParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getLiteralAccess().getNegativeLiteralParserRuleCall_1()); } + ruleNegativeLiteral + { after(grammarAccess.getLiteralAccess().getNegativeLiteralParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Alternatives_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAssertionAccess().getGroup_0_0()); } + (rule__Assertion__Group_0_0__0) + { after(grammarAccess.getAssertionAccess().getGroup_0_0()); } + ) + | + ( + { before(grammarAccess.getAssertionAccess().getGroup_0_1()); } + (rule__Assertion__Group_0_1__0) + { after(grammarAccess.getAssertionAccess().getGroup_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeScope__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getTypeScopeAccess().getIncrementAssignment_1_0()); } + (rule__TypeScope__IncrementAssignment_1_0) + { after(grammarAccess.getTypeScopeAccess().getIncrementAssignment_1_0()); } + ) + | + ( + { before(grammarAccess.getTypeScopeAccess().getEqualsSignKeyword_1_1()); } + '=' + { after(grammarAccess.getTypeScopeAccess().getEqualsSignKeyword_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Multiplicity__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); } + ruleUnboundedMultiplicity + { after(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getMultiplicityAccess().getDefiniteMultiplicityParserRuleCall_1()); } + ruleDefiniteMultiplicity + { after(grammarAccess.getMultiplicityAccess().getDefiniteMultiplicityParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__DefiniteMultiplicity__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getDefiniteMultiplicityAccess().getRangeMultiplicityParserRuleCall_0()); } + ruleRangeMultiplicity + { after(grammarAccess.getDefiniteMultiplicityAccess().getRangeMultiplicityParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getDefiniteMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); } + ruleExactMultiplicity + { after(grammarAccess.getDefiniteMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__UpperBound__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getUpperBoundAccess().getINTTerminalRuleCall_0()); } + RULE_INT + { after(grammarAccess.getUpperBoundAccess().getINTTerminalRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getUpperBoundAccess().getAsteriskKeyword_1()); } + '*' + { after(grammarAccess.getUpperBoundAccess().getAsteriskKeyword_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__QuotedOrUnquotedId__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getQuotedOrUnquotedIdAccess().getQUOTED_IDTerminalRuleCall_0()); } + RULE_QUOTED_ID + { after(grammarAccess.getQuotedOrUnquotedIdAccess().getQUOTED_IDTerminalRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getQuotedOrUnquotedIdAccess().getIdentifierParserRuleCall_1()); } + ruleIdentifier + { after(grammarAccess.getQuotedOrUnquotedIdAccess().getIdentifierParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedName__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_0()); } + RULE_QUOTED_ID + { after(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getQualifiedNameAccess().getGroup_1()); } + (rule__QualifiedName__Group_1__0) + { after(grammarAccess.getQualifiedNameAccess().getGroup_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Identifier__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getIdentifierAccess().getIDTerminalRuleCall_0()); } + RULE_ID + { after(grammarAccess.getIdentifierAccess().getIDTerminalRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getIdentifierAccess().getTrueKeyword_1()); } + 'true' + { after(grammarAccess.getIdentifierAccess().getTrueKeyword_1()); } + ) + | + ( + { before(grammarAccess.getIdentifierAccess().getFalseKeyword_2()); } + 'false' + { after(grammarAccess.getIdentifierAccess().getFalseKeyword_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__LogicValue__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); } + ('true') + { after(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); } + ) + | + ( + { before(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); } + ('false') + { after(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); } + ) + | + ( + { before(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); } + ('unknown') + { after(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ShortLogicValue__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getShortLogicValueAccess().getFALSEEnumLiteralDeclaration_0()); } + ('!') + { after(grammarAccess.getShortLogicValueAccess().getFALSEEnumLiteralDeclaration_0()); } + ) + | + ( + { before(grammarAccess.getShortLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_1()); } + ('?') + { after(grammarAccess.getShortLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Problem__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Problem__Group__0__Impl + rule__Problem__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Problem__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getProblemAccess().getGroup_0()); } + (rule__Problem__Group_0__0)? + { after(grammarAccess.getProblemAccess().getGroup_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Problem__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Problem__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Problem__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getProblemAccess().getStatementsAssignment_1()); } + (rule__Problem__StatementsAssignment_1)* + { after(grammarAccess.getProblemAccess().getStatementsAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Problem__Group_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Problem__Group_0__0__Impl + rule__Problem__Group_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Problem__Group_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getProblemAccess().getProblemKeyword_0_0()); } + 'problem' + { after(grammarAccess.getProblemAccess().getProblemKeyword_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Problem__Group_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Problem__Group_0__1__Impl + rule__Problem__Group_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Problem__Group_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getProblemAccess().getNameAssignment_0_1()); } + (rule__Problem__NameAssignment_0_1) + { after(grammarAccess.getProblemAccess().getNameAssignment_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Problem__Group_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Problem__Group_0__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Problem__Group_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getProblemAccess().getFullStopKeyword_0_2()); } + '.' + { after(grammarAccess.getProblemAccess().getFullStopKeyword_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ClassDeclaration__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ClassDeclaration__Group__0__Impl + rule__ClassDeclaration__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getClassDeclarationAccess().getAbstractAssignment_0()); } + (rule__ClassDeclaration__AbstractAssignment_0)? + { after(grammarAccess.getClassDeclarationAccess().getAbstractAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ClassDeclaration__Group__1__Impl + rule__ClassDeclaration__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); } + 'class' + { after(grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ClassDeclaration__Group__2__Impl + rule__ClassDeclaration__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getClassDeclarationAccess().getNameAssignment_2()); } + (rule__ClassDeclaration__NameAssignment_2) + { after(grammarAccess.getClassDeclarationAccess().getNameAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ClassDeclaration__Group__3__Impl + rule__ClassDeclaration__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getClassDeclarationAccess().getGroup_3()); } + (rule__ClassDeclaration__Group_3__0)? + { after(grammarAccess.getClassDeclarationAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ClassDeclaration__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getClassDeclarationAccess().getAlternatives_4()); } + (rule__ClassDeclaration__Alternatives_4) + { after(grammarAccess.getClassDeclarationAccess().getAlternatives_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ClassDeclaration__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ClassDeclaration__Group_3__0__Impl + rule__ClassDeclaration__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); } + 'extends' + { after(grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ClassDeclaration__Group_3__1__Impl + rule__ClassDeclaration__Group_3__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_1()); } + (rule__ClassDeclaration__SuperTypesAssignment_3_1) + { after(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group_3__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ClassDeclaration__Group_3__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group_3__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getClassDeclarationAccess().getGroup_3_2()); } + (rule__ClassDeclaration__Group_3_2__0)* + { after(grammarAccess.getClassDeclarationAccess().getGroup_3_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ClassDeclaration__Group_3_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ClassDeclaration__Group_3_2__0__Impl + rule__ClassDeclaration__Group_3_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group_3_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); } + ',' + { after(grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group_3_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ClassDeclaration__Group_3_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group_3_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_2_1()); } + (rule__ClassDeclaration__SuperTypesAssignment_3_2_1) + { after(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ClassDeclaration__Group_4_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ClassDeclaration__Group_4_0__0__Impl + rule__ClassDeclaration__Group_4_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group_4_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); } + '{' + { after(grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group_4_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ClassDeclaration__Group_4_0__1__Impl + rule__ClassDeclaration__Group_4_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group_4_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getClassDeclarationAccess().getGroup_4_0_1()); } + (rule__ClassDeclaration__Group_4_0_1__0)* + { after(grammarAccess.getClassDeclarationAccess().getGroup_4_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group_4_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ClassDeclaration__Group_4_0__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group_4_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); } + '}' + { after(grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ClassDeclaration__Group_4_0_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ClassDeclaration__Group_4_0_1__0__Impl + rule__ClassDeclaration__Group_4_0_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group_4_0_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsAssignment_4_0_1_0()); } + (rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0) + { after(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsAssignment_4_0_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group_4_0_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ClassDeclaration__Group_4_0_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__Group_4_0_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getClassDeclarationAccess().getSemicolonKeyword_4_0_1_1()); } + (';')? + { after(grammarAccess.getClassDeclarationAccess().getSemicolonKeyword_4_0_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__EnumDeclaration__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__EnumDeclaration__Group__0__Impl + rule__EnumDeclaration__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); } + 'enum' + { after(grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__EnumDeclaration__Group__1__Impl + rule__EnumDeclaration__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getEnumDeclarationAccess().getNameAssignment_1()); } + (rule__EnumDeclaration__NameAssignment_1) + { after(grammarAccess.getEnumDeclarationAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__EnumDeclaration__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getEnumDeclarationAccess().getAlternatives_2()); } + (rule__EnumDeclaration__Alternatives_2) + { after(grammarAccess.getEnumDeclarationAccess().getAlternatives_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__EnumDeclaration__Group_2_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__EnumDeclaration__Group_2_0__0__Impl + rule__EnumDeclaration__Group_2_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group_2_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); } + '{' + { after(grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group_2_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__EnumDeclaration__Group_2_0__1__Impl + rule__EnumDeclaration__Group_2_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group_2_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1()); } + (rule__EnumDeclaration__Group_2_0_1__0)? + { after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group_2_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__EnumDeclaration__Group_2_0__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group_2_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); } + '}' + { after(grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__EnumDeclaration__Group_2_0_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__EnumDeclaration__Group_2_0_1__0__Impl + rule__EnumDeclaration__Group_2_0_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group_2_0_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_0()); } + (rule__EnumDeclaration__LiteralsAssignment_2_0_1_0) + { after(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group_2_0_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__EnumDeclaration__Group_2_0_1__1__Impl + rule__EnumDeclaration__Group_2_0_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group_2_0_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1_1()); } + (rule__EnumDeclaration__Group_2_0_1_1__0)* + { after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group_2_0_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__EnumDeclaration__Group_2_0_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group_2_0_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getEnumDeclarationAccess().getAlternatives_2_0_1_2()); } + (rule__EnumDeclaration__Alternatives_2_0_1_2)? + { after(grammarAccess.getEnumDeclarationAccess().getAlternatives_2_0_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__EnumDeclaration__Group_2_0_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__EnumDeclaration__Group_2_0_1_1__0__Impl + rule__EnumDeclaration__Group_2_0_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group_2_0_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); } + ',' + { after(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group_2_0_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__EnumDeclaration__Group_2_0_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__Group_2_0_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_1_1()); } + (rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1) + { after(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ReferenceDeclaration__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ReferenceDeclaration__Group__0__Impl + rule__ReferenceDeclaration__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getReferenceDeclarationAccess().getAlternatives_0()); } + (rule__ReferenceDeclaration__Alternatives_0)? + { after(grammarAccess.getReferenceDeclarationAccess().getAlternatives_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ReferenceDeclaration__Group__1__Impl + rule__ReferenceDeclaration__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeAssignment_1()); } + (rule__ReferenceDeclaration__ReferenceTypeAssignment_1) + { after(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ReferenceDeclaration__Group__2__Impl + rule__ReferenceDeclaration__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getReferenceDeclarationAccess().getGroup_2()); } + (rule__ReferenceDeclaration__Group_2__0)? + { after(grammarAccess.getReferenceDeclarationAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ReferenceDeclaration__Group__3__Impl + rule__ReferenceDeclaration__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getReferenceDeclarationAccess().getNameAssignment_3()); } + (rule__ReferenceDeclaration__NameAssignment_3) + { after(grammarAccess.getReferenceDeclarationAccess().getNameAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ReferenceDeclaration__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getReferenceDeclarationAccess().getGroup_4()); } + (rule__ReferenceDeclaration__Group_4__0)? + { after(grammarAccess.getReferenceDeclarationAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ReferenceDeclaration__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ReferenceDeclaration__Group_2__0__Impl + rule__ReferenceDeclaration__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getReferenceDeclarationAccess().getLeftSquareBracketKeyword_2_0()); } + '[' + { after(grammarAccess.getReferenceDeclarationAccess().getLeftSquareBracketKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ReferenceDeclaration__Group_2__1__Impl + rule__ReferenceDeclaration__Group_2__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getReferenceDeclarationAccess().getMultiplicityAssignment_2_1()); } + (rule__ReferenceDeclaration__MultiplicityAssignment_2_1) + { after(grammarAccess.getReferenceDeclarationAccess().getMultiplicityAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Group_2__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ReferenceDeclaration__Group_2__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Group_2__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getReferenceDeclarationAccess().getRightSquareBracketKeyword_2_2()); } + ']' + { after(grammarAccess.getReferenceDeclarationAccess().getRightSquareBracketKeyword_2_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ReferenceDeclaration__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ReferenceDeclaration__Group_4__0__Impl + rule__ReferenceDeclaration__Group_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getReferenceDeclarationAccess().getOppositeKeyword_4_0()); } + 'opposite' + { after(grammarAccess.getReferenceDeclarationAccess().getOppositeKeyword_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Group_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ReferenceDeclaration__Group_4__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__Group_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getReferenceDeclarationAccess().getOppositeAssignment_4_1()); } + (rule__ReferenceDeclaration__OppositeAssignment_4_1) + { after(grammarAccess.getReferenceDeclarationAccess().getOppositeAssignment_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__PredicateDefinition__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group__0__Impl + rule__PredicateDefinition__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); } + (rule__PredicateDefinition__Alternatives_0) + { after(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group__1__Impl + rule__PredicateDefinition__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getNameAssignment_1()); } + (rule__PredicateDefinition__NameAssignment_1) + { after(grammarAccess.getPredicateDefinitionAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group__2__Impl + rule__PredicateDefinition__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getLeftParenthesisKeyword_2()); } + '(' + { after(grammarAccess.getPredicateDefinitionAccess().getLeftParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group__3__Impl + rule__PredicateDefinition__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getGroup_3()); } + (rule__PredicateDefinition__Group_3__0)? + { after(grammarAccess.getPredicateDefinitionAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group__4__Impl + rule__PredicateDefinition__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getRightParenthesisKeyword_4()); } + ')' + { after(grammarAccess.getPredicateDefinitionAccess().getRightParenthesisKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group__5__Impl + rule__PredicateDefinition__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getGroup_5()); } + (rule__PredicateDefinition__Group_5__0)? + { after(grammarAccess.getPredicateDefinitionAccess().getGroup_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getFullStopKeyword_6()); } + '.' + { after(grammarAccess.getPredicateDefinitionAccess().getFullStopKeyword_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__PredicateDefinition__Group_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group_0_0__0__Impl + rule__PredicateDefinition__Group_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_0()); } + (rule__PredicateDefinition__ErrorAssignment_0_0_0) + { after(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_0_1()); } + ('pred')? + { after(grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__PredicateDefinition__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group_3__0__Impl + rule__PredicateDefinition__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_0()); } + (rule__PredicateDefinition__ParametersAssignment_3_0) + { after(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getGroup_3_1()); } + (rule__PredicateDefinition__Group_3_1__0)* + { after(grammarAccess.getPredicateDefinitionAccess().getGroup_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__PredicateDefinition__Group_3_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group_3_1__0__Impl + rule__PredicateDefinition__Group_3_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group_3_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getCommaKeyword_3_1_0()); } + ',' + { after(grammarAccess.getPredicateDefinitionAccess().getCommaKeyword_3_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group_3_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group_3_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group_3_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_1_1()); } + (rule__PredicateDefinition__ParametersAssignment_3_1_1) + { after(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__PredicateDefinition__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group_5__0__Impl + rule__PredicateDefinition__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_5_0()); } + ':-' + { after(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group_5__1__Impl + rule__PredicateDefinition__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_1()); } + (rule__PredicateDefinition__BodiesAssignment_5_1) + { after(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group_5__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getGroup_5_2()); } + (rule__PredicateDefinition__Group_5_2__0)* + { after(grammarAccess.getPredicateDefinitionAccess().getGroup_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__PredicateDefinition__Group_5_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group_5_2__0__Impl + rule__PredicateDefinition__Group_5_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group_5_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getSemicolonKeyword_5_2_0()); } + ';' + { after(grammarAccess.getPredicateDefinitionAccess().getSemicolonKeyword_5_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group_5_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__PredicateDefinition__Group_5_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__Group_5_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_2_1()); } + (rule__PredicateDefinition__BodiesAssignment_5_2_1) + { after(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Parameter__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group__0__Impl + rule__Parameter__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getParameterTypeAssignment_0()); } + (rule__Parameter__ParameterTypeAssignment_0)? + { after(grammarAccess.getParameterAccess().getParameterTypeAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Parameter__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParameterAccess().getNameAssignment_1()); } + (rule__Parameter__NameAssignment_1) + { after(grammarAccess.getParameterAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Conjunction__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Conjunction__Group__0__Impl + rule__Conjunction__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Conjunction__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getConjunctionAccess().getLiteralsAssignment_0()); } + (rule__Conjunction__LiteralsAssignment_0) + { after(grammarAccess.getConjunctionAccess().getLiteralsAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Conjunction__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Conjunction__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Conjunction__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getConjunctionAccess().getGroup_1()); } + (rule__Conjunction__Group_1__0)* + { after(grammarAccess.getConjunctionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Conjunction__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Conjunction__Group_1__0__Impl + rule__Conjunction__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Conjunction__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getConjunctionAccess().getCommaKeyword_1_0()); } + ',' + { after(grammarAccess.getConjunctionAccess().getCommaKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Conjunction__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Conjunction__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Conjunction__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getConjunctionAccess().getLiteralsAssignment_1_1()); } + (rule__Conjunction__LiteralsAssignment_1_1) + { after(grammarAccess.getConjunctionAccess().getLiteralsAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__NegativeLiteral__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__NegativeLiteral__Group__0__Impl + rule__NegativeLiteral__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__NegativeLiteral__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNegativeLiteralAccess().getExclamationMarkKeyword_0()); } + '!' + { after(grammarAccess.getNegativeLiteralAccess().getExclamationMarkKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__NegativeLiteral__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__NegativeLiteral__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__NegativeLiteral__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNegativeLiteralAccess().getAtomAssignment_1()); } + (rule__NegativeLiteral__AtomAssignment_1) + { after(grammarAccess.getNegativeLiteralAccess().getAtomAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Atom__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Atom__Group__0__Impl + rule__Atom__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAtomAccess().getRelationAssignment_0()); } + (rule__Atom__RelationAssignment_0) + { after(grammarAccess.getAtomAccess().getRelationAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Atom__Group__1__Impl + rule__Atom__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAtomAccess().getTransitiveClosureAssignment_1()); } + (rule__Atom__TransitiveClosureAssignment_1)? + { after(grammarAccess.getAtomAccess().getTransitiveClosureAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Atom__Group__2__Impl + rule__Atom__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAtomAccess().getLeftParenthesisKeyword_2()); } + '(' + { after(grammarAccess.getAtomAccess().getLeftParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Atom__Group__3__Impl + rule__Atom__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAtomAccess().getGroup_3()); } + (rule__Atom__Group_3__0)? + { after(grammarAccess.getAtomAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__Atom__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAtomAccess().getRightParenthesisKeyword_4()); } + ')' + { after(grammarAccess.getAtomAccess().getRightParenthesisKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Atom__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Atom__Group_3__0__Impl + rule__Atom__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAtomAccess().getArgumentsAssignment_3_0()); } + (rule__Atom__ArgumentsAssignment_3_0) + { after(grammarAccess.getAtomAccess().getArgumentsAssignment_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Atom__Group_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAtomAccess().getGroup_3_1()); } + (rule__Atom__Group_3_1__0)* + { after(grammarAccess.getAtomAccess().getGroup_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Atom__Group_3_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Atom__Group_3_1__0__Impl + rule__Atom__Group_3_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__Group_3_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAtomAccess().getCommaKeyword_3_1_0()); } + ',' + { after(grammarAccess.getAtomAccess().getCommaKeyword_3_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__Group_3_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Atom__Group_3_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__Group_3_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAtomAccess().getArgumentsAssignment_3_1_1()); } + (rule__Atom__ArgumentsAssignment_3_1_1) + { after(grammarAccess.getAtomAccess().getArgumentsAssignment_3_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Assertion__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group__0__Impl + rule__Assertion__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getAlternatives_0()); } + (rule__Assertion__Alternatives_0) + { after(grammarAccess.getAssertionAccess().getAlternatives_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getFullStopKeyword_1()); } + '.' + { after(grammarAccess.getAssertionAccess().getFullStopKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Assertion__Group_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_0__0__Impl + rule__Assertion__Group_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getRelationAssignment_0_0_0()); } + (rule__Assertion__RelationAssignment_0_0_0) + { after(grammarAccess.getAssertionAccess().getRelationAssignment_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_0__1__Impl + rule__Assertion__Group_0_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_0_1()); } + '(' + { after(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_0__2__Impl + rule__Assertion__Group_0_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getGroup_0_0_2()); } + (rule__Assertion__Group_0_0_2__0)? + { after(grammarAccess.getAssertionAccess().getGroup_0_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_0__3__Impl + rule__Assertion__Group_0_0__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_0_3()); } + ')' + { after(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_0__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_0__4__Impl + rule__Assertion__Group_0_0__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_0__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getColonKeyword_0_0_4()); } + ':' + { after(grammarAccess.getAssertionAccess().getColonKeyword_0_0_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_0__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_0__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_0__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getValueAssignment_0_0_5()); } + (rule__Assertion__ValueAssignment_0_0_5) + { after(grammarAccess.getAssertionAccess().getValueAssignment_0_0_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Assertion__Group_0_0_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_0_2__0__Impl + rule__Assertion__Group_0_0_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_0_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_0()); } + (rule__Assertion__ArgumentsAssignment_0_0_2_0) + { after(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_0_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_0_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_0_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getGroup_0_0_2_1()); } + (rule__Assertion__Group_0_0_2_1__0)* + { after(grammarAccess.getAssertionAccess().getGroup_0_0_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Assertion__Group_0_0_2_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_0_2_1__0__Impl + rule__Assertion__Group_0_0_2_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_0_2_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getCommaKeyword_0_0_2_1_0()); } + ',' + { after(grammarAccess.getAssertionAccess().getCommaKeyword_0_0_2_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_0_2_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_0_2_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_0_2_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_1_1()); } + (rule__Assertion__ArgumentsAssignment_0_0_2_1_1) + { after(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Assertion__Group_0_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_1__0__Impl + rule__Assertion__Group_0_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getValueAssignment_0_1_0()); } + (rule__Assertion__ValueAssignment_0_1_0)? + { after(grammarAccess.getAssertionAccess().getValueAssignment_0_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_1__1__Impl + rule__Assertion__Group_0_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getRelationAssignment_0_1_1()); } + (rule__Assertion__RelationAssignment_0_1_1) + { after(grammarAccess.getAssertionAccess().getRelationAssignment_0_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_1__2__Impl + rule__Assertion__Group_0_1__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_1_2()); } + '(' + { after(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_1__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_1__3__Impl + rule__Assertion__Group_0_1__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_1__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getGroup_0_1_3()); } + (rule__Assertion__Group_0_1_3__0)? + { after(grammarAccess.getAssertionAccess().getGroup_0_1_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_1__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_1__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_1__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_1_4()); } + ')' + { after(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_1_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Assertion__Group_0_1_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_1_3__0__Impl + rule__Assertion__Group_0_1_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_1_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_0()); } + (rule__Assertion__ArgumentsAssignment_0_1_3_0) + { after(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_1_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_1_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_1_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getGroup_0_1_3_1()); } + (rule__Assertion__Group_0_1_3_1__0)* + { after(grammarAccess.getAssertionAccess().getGroup_0_1_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Assertion__Group_0_1_3_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_1_3_1__0__Impl + rule__Assertion__Group_0_1_3_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_1_3_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getCommaKeyword_0_1_3_1_0()); } + ',' + { after(grammarAccess.getAssertionAccess().getCommaKeyword_0_1_3_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_1_3_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Assertion__Group_0_1_3_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__Group_0_1_3_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_1_1()); } + (rule__Assertion__ArgumentsAssignment_0_1_3_1_1) + { after(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ScopeDeclaration__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDeclaration__Group__0__Impl + rule__ScopeDeclaration__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDeclaration__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); } + 'scope' + { after(grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDeclaration__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDeclaration__Group__1__Impl + rule__ScopeDeclaration__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDeclaration__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_1()); } + (rule__ScopeDeclaration__TypeScopesAssignment_1) + { after(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDeclaration__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDeclaration__Group__2__Impl + rule__ScopeDeclaration__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDeclaration__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDeclarationAccess().getGroup_2()); } + (rule__ScopeDeclaration__Group_2__0)* + { after(grammarAccess.getScopeDeclarationAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDeclaration__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDeclaration__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDeclaration__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDeclarationAccess().getFullStopKeyword_3()); } + '.' + { after(grammarAccess.getScopeDeclarationAccess().getFullStopKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ScopeDeclaration__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDeclaration__Group_2__0__Impl + rule__ScopeDeclaration__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDeclaration__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDeclarationAccess().getCommaKeyword_2_0()); } + ',' + { after(grammarAccess.getScopeDeclarationAccess().getCommaKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDeclaration__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDeclaration__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDeclaration__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_2_1()); } + (rule__ScopeDeclaration__TypeScopesAssignment_2_1) + { after(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__TypeScope__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__TypeScope__Group__0__Impl + rule__TypeScope__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeScope__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTypeScopeAccess().getTargetTypeAssignment_0()); } + (rule__TypeScope__TargetTypeAssignment_0) + { after(grammarAccess.getTypeScopeAccess().getTargetTypeAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeScope__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__TypeScope__Group__1__Impl + rule__TypeScope__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeScope__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTypeScopeAccess().getAlternatives_1()); } + (rule__TypeScope__Alternatives_1) + { after(grammarAccess.getTypeScopeAccess().getAlternatives_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeScope__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__TypeScope__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeScope__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTypeScopeAccess().getMultiplicityAssignment_2()); } + (rule__TypeScope__MultiplicityAssignment_2) + { after(grammarAccess.getTypeScopeAccess().getMultiplicityAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__RangeMultiplicity__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__RangeMultiplicity__Group__0__Impl + rule__RangeMultiplicity__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__RangeMultiplicity__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRangeMultiplicityAccess().getLowerBoundAssignment_0()); } + (rule__RangeMultiplicity__LowerBoundAssignment_0) + { after(grammarAccess.getRangeMultiplicityAccess().getLowerBoundAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RangeMultiplicity__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__RangeMultiplicity__Group__1__Impl + rule__RangeMultiplicity__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__RangeMultiplicity__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRangeMultiplicityAccess().getFullStopFullStopKeyword_1()); } + '..' + { after(grammarAccess.getRangeMultiplicityAccess().getFullStopFullStopKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RangeMultiplicity__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__RangeMultiplicity__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__RangeMultiplicity__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRangeMultiplicityAccess().getUpperBoundAssignment_2()); } + (rule__RangeMultiplicity__UpperBoundAssignment_2) + { after(grammarAccess.getRangeMultiplicityAccess().getUpperBoundAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__QualifiedName__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__QualifiedName__Group_1__0__Impl + rule__QualifiedName__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedName__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_0()); } + ruleIdentifier + { after(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedName__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__QualifiedName__Group_1__1__Impl + rule__QualifiedName__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedName__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getQualifiedNameAccess().getGroup_1_1()); } + (rule__QualifiedName__Group_1_1__0)* + { after(grammarAccess.getQualifiedNameAccess().getGroup_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedName__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__QualifiedName__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedName__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getQualifiedNameAccess().getGroup_1_2()); } + (rule__QualifiedName__Group_1_2__0)? + { after(grammarAccess.getQualifiedNameAccess().getGroup_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__QualifiedName__Group_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__QualifiedName__Group_1_1__0__Impl + rule__QualifiedName__Group_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedName__Group_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getQualifiedNameAccess().getColonKeyword_1_1_0()); } + ':' + { after(grammarAccess.getQualifiedNameAccess().getColonKeyword_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedName__Group_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__QualifiedName__Group_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedName__Group_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_1_1()); } + ruleIdentifier + { after(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__QualifiedName__Group_1_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__QualifiedName__Group_1_2__0__Impl + rule__QualifiedName__Group_1_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedName__Group_1_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getQualifiedNameAccess().getColonKeyword_1_2_0()); } + ':' + { after(grammarAccess.getQualifiedNameAccess().getColonKeyword_1_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedName__Group_1_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__QualifiedName__Group_1_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedName__Group_1_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1_2_1()); } + RULE_QUOTED_ID + { after(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Problem__NameAssignment_0_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getProblemAccess().getNameIdentifierParserRuleCall_0_1_0()); } + ruleIdentifier + { after(grammarAccess.getProblemAccess().getNameIdentifierParserRuleCall_0_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Problem__StatementsAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_1_0()); } + ruleStatement + { after(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__AbstractAssignment_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); } + ( + { before(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); } + 'abstract' + { after(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); } + ) + { after(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__NameAssignment_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getClassDeclarationAccess().getNameIdentifierParserRuleCall_2_0()); } + ruleIdentifier + { after(grammarAccess.getClassDeclarationAccess().getNameIdentifierParserRuleCall_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__SuperTypesAssignment_3_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_1_0()); } + ( + { before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationQualifiedNameParserRuleCall_3_1_0_1()); } + ruleQualifiedName + { after(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationQualifiedNameParserRuleCall_3_1_0_1()); } + ) + { after(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__SuperTypesAssignment_3_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_2_1_0()); } + ( + { before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationQualifiedNameParserRuleCall_3_2_1_0_1()); } + ruleQualifiedName + { after(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationQualifiedNameParserRuleCall_3_2_1_0_1()); } + ) + { after(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsReferenceDeclarationParserRuleCall_4_0_1_0_0()); } + ruleReferenceDeclaration + { after(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsReferenceDeclarationParserRuleCall_4_0_1_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getEnumDeclarationAccess().getNameIdentifierParserRuleCall_1_0()); } + ruleIdentifier + { after(grammarAccess.getEnumDeclarationAccess().getNameIdentifierParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); } + ruleEnumLiteral + { after(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); } + ruleEnumLiteral + { after(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__EnumLiteral__NameAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getEnumLiteralAccess().getNameQuotedOrUnquotedIdParserRuleCall_0()); } + ruleQuotedOrUnquotedId + { after(grammarAccess.getEnumLiteralAccess().getNameQuotedOrUnquotedIdParserRuleCall_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__ContainmentAssignment_0_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); } + ( + { before(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); } + 'contains' + { after(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); } + ) + { after(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__ReferenceTypeAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationCrossReference_1_0()); } + ( + { before(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationQualifiedNameParserRuleCall_1_0_1()); } + ruleQualifiedName + { after(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationQualifiedNameParserRuleCall_1_0_1()); } + ) + { after(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationCrossReference_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__MultiplicityAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getReferenceDeclarationAccess().getMultiplicityMultiplicityParserRuleCall_2_1_0()); } + ruleMultiplicity + { after(grammarAccess.getReferenceDeclarationAccess().getMultiplicityMultiplicityParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__NameAssignment_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getReferenceDeclarationAccess().getNameIdentifierParserRuleCall_3_0()); } + ruleIdentifier + { after(grammarAccess.getReferenceDeclarationAccess().getNameIdentifierParserRuleCall_3_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ReferenceDeclaration__OppositeAssignment_4_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationCrossReference_4_1_0()); } + ( + { before(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationQualifiedNameParserRuleCall_4_1_0_1()); } + ruleQualifiedName + { after(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationQualifiedNameParserRuleCall_4_1_0_1()); } + ) + { after(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationCrossReference_4_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__ErrorAssignment_0_0_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); } + ( + { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); } + 'error' + { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); } + ) + { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPredicateDefinitionAccess().getNameIdentifierParserRuleCall_1_0()); } + ruleIdentifier + { after(grammarAccess.getPredicateDefinitionAccess().getNameIdentifierParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__ParametersAssignment_3_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_0_0()); } + ruleParameter + { after(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__ParametersAssignment_3_1_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_1_1_0()); } + ruleParameter + { after(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_1_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__BodiesAssignment_5_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_1_0()); } + ruleConjunction + { after(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__PredicateDefinition__BodiesAssignment_5_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_2_1_0()); } + ruleConjunction + { after(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__ParameterTypeAssignment_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterAccess().getParameterTypeRelationCrossReference_0_0()); } + ( + { before(grammarAccess.getParameterAccess().getParameterTypeRelationQualifiedNameParserRuleCall_0_0_1()); } + ruleQualifiedName + { after(grammarAccess.getParameterAccess().getParameterTypeRelationQualifiedNameParserRuleCall_0_0_1()); } + ) + { after(grammarAccess.getParameterAccess().getParameterTypeRelationCrossReference_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Parameter__NameAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getParameterAccess().getNameIdentifierParserRuleCall_1_0()); } + ruleIdentifier + { after(grammarAccess.getParameterAccess().getNameIdentifierParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Conjunction__LiteralsAssignment_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_0_0()); } + ruleLiteral + { after(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Conjunction__LiteralsAssignment_1_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_1_1_0()); } + ruleLiteral + { after(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_1_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__NegativeLiteral__AtomAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNegativeLiteralAccess().getAtomAtomParserRuleCall_1_0()); } + ruleAtom + { after(grammarAccess.getNegativeLiteralAccess().getAtomAtomParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__RelationAssignment_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAtomAccess().getRelationRelationCrossReference_0_0()); } + ( + { before(grammarAccess.getAtomAccess().getRelationRelationQualifiedNameParserRuleCall_0_0_1()); } + ruleQualifiedName + { after(grammarAccess.getAtomAccess().getRelationRelationQualifiedNameParserRuleCall_0_0_1()); } + ) + { after(grammarAccess.getAtomAccess().getRelationRelationCrossReference_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__TransitiveClosureAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); } + ( + { before(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); } + '+' + { after(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); } + ) + { after(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__ArgumentsAssignment_3_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_0_0()); } + ruleArgument + { after(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Atom__ArgumentsAssignment_3_1_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_1_1_0()); } + ruleArgument + { after(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_1_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Argument__VariableOrNodeAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); } + ( + { before(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1()); } + ruleQualifiedName + { after(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1()); } + ) + { after(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__RelationAssignment_0_0_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_0_0_0()); } + ( + { before(grammarAccess.getAssertionAccess().getRelationRelationQualifiedNameParserRuleCall_0_0_0_0_1()); } + ruleQualifiedName + { after(grammarAccess.getAssertionAccess().getRelationRelationQualifiedNameParserRuleCall_0_0_0_0_1()); } + ) + { after(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_0_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__ArgumentsAssignment_0_0_2_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_0_0()); } + ( + { before(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_0_0_1()); } + ruleQualifiedName + { after(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_0_0_1()); } + ) + { after(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__ArgumentsAssignment_0_0_2_1_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_1_1_0()); } + ( + { before(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_1_1_0_1()); } + ruleQualifiedName + { after(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_1_1_0_1()); } + ) + { after(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_1_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__ValueAssignment_0_0_5 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAssertionAccess().getValueLogicValueEnumRuleCall_0_0_5_0()); } + ruleLogicValue + { after(grammarAccess.getAssertionAccess().getValueLogicValueEnumRuleCall_0_0_5_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__ValueAssignment_0_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAssertionAccess().getValueShortLogicValueEnumRuleCall_0_1_0_0()); } + ruleShortLogicValue + { after(grammarAccess.getAssertionAccess().getValueShortLogicValueEnumRuleCall_0_1_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__RelationAssignment_0_1_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_1_1_0()); } + ( + { before(grammarAccess.getAssertionAccess().getRelationRelationQualifiedNameParserRuleCall_0_1_1_0_1()); } + ruleQualifiedName + { after(grammarAccess.getAssertionAccess().getRelationRelationQualifiedNameParserRuleCall_0_1_1_0_1()); } + ) + { after(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_1_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__ArgumentsAssignment_0_1_3_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_0_0()); } + ( + { before(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_0_0_1()); } + ruleQualifiedName + { after(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_0_0_1()); } + ) + { after(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Assertion__ArgumentsAssignment_0_1_3_1_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_1_1_0()); } + ( + { before(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_1_1_0_1()); } + ruleQualifiedName + { after(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_1_1_0_1()); } + ) + { after(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_1_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDeclaration__TypeScopesAssignment_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_1_0()); } + ruleTypeScope + { after(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDeclaration__TypeScopesAssignment_2_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_2_1_0()); } + ruleTypeScope + { after(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_2_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeScope__TargetTypeAssignment_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationCrossReference_0_0()); } + ( + { before(grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationIDTerminalRuleCall_0_0_1()); } + RULE_ID + { after(grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationIDTerminalRuleCall_0_0_1()); } + ) + { after(grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationCrossReference_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeScope__IncrementAssignment_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); } + ( + { before(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); } + '+=' + { after(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); } + ) + { after(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeScope__MultiplicityAssignment_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getTypeScopeAccess().getMultiplicityDefiniteMultiplicityParserRuleCall_2_0()); } + ruleDefiniteMultiplicity + { after(grammarAccess.getTypeScopeAccess().getMultiplicityDefiniteMultiplicityParserRuleCall_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__RangeMultiplicity__LowerBoundAssignment_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getRangeMultiplicityAccess().getLowerBoundINTTerminalRuleCall_0_0()); } + RULE_INT + { after(grammarAccess.getRangeMultiplicityAccess().getLowerBoundINTTerminalRuleCall_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__RangeMultiplicity__UpperBoundAssignment_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getRangeMultiplicityAccess().getUpperBoundUpperBoundParserRuleCall_2_0()); } + ruleUpperBound + { after(grammarAccess.getRangeMultiplicityAccess().getUpperBoundUpperBoundParserRuleCall_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ExactMultiplicity__ExactValueAssignment + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getExactMultiplicityAccess().getExactValueINTTerminalRuleCall_0()); } + RULE_INT + { after(grammarAccess.getExactMultiplicityAccess().getExactValueINTTerminalRuleCall_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"'; + +RULE_QUOTED_ID : '\'' ('\\' .|~(('\\'|'\'')))* '\''; + +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; + +RULE_INT : ('0'..'9')+; + +RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; + +RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?; + +RULE_WS : (' '|'\t'|'\r'|'\n')+; + +RULE_ANY_OTHER : .; diff --git a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.tokens b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.tokens new file mode 100644 index 00000000..c0cdd3c6 --- /dev/null +++ b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblem.tokens @@ -0,0 +1,72 @@ +'!'=22 +'('=33 +')'=34 +'*'=18 +'+'=42 +'+='=43 +','=13 +'.'=12 +'..'=38 +':'=36 +':-'=35 +';'=14 +'='=17 +'?'=23 +'['=30 +']'=31 +'abstract'=39 +'class'=25 +'contains'=40 +'enum'=29 +'error'=41 +'extends'=26 +'false'=20 +'opposite'=32 +'pred'=16 +'problem'=24 +'refers'=15 +'scope'=37 +'true'=19 +'unknown'=21 +'{'=27 +'}'=28 +RULE_ANY_OTHER=11 +RULE_ID=6 +RULE_INT=4 +RULE_ML_COMMENT=8 +RULE_QUOTED_ID=5 +RULE_SL_COMMENT=9 +RULE_STRING=7 +RULE_WS=10 +T__12=12 +T__13=13 +T__14=14 +T__15=15 +T__16=16 +T__17=17 +T__18=18 +T__19=19 +T__20=20 +T__21=21 +T__22=22 +T__23=23 +T__24=24 +T__25=25 +T__26=26 +T__27=27 +T__28=28 +T__29=29 +T__30=30 +T__31=31 +T__32=32 +T__33=33 +T__34=34 +T__35=35 +T__36=36 +T__37=37 +T__38=38 +T__39=39 +T__40=40 +T__41=41 +T__42=42 +T__43=43 diff --git a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemLexer.java b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemLexer.java new file mode 100644 index 00000000..e8f6f12d --- /dev/null +++ b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemLexer.java @@ -0,0 +1,1797 @@ +package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal; + +// Hack: Use our own Lexer superclass by means of import. +// Currently there is no other way to specify the superclass for the lexer. +import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer; + + +import org.antlr.runtime.*; +import java.util.Stack; +import java.util.List; +import java.util.ArrayList; + +@SuppressWarnings("all") +public class InternalProblemLexer extends Lexer { + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__12=12; + public static final int T__13=13; + public static final int T__14=14; + public static final int RULE_ID=6; + public static final int RULE_QUOTED_ID=5; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int RULE_INT=4; + public static final int T__29=29; + public static final int T__22=22; + public static final int RULE_ML_COMMENT=8; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int RULE_STRING=7; + public static final int RULE_SL_COMMENT=9; + public static final int T__37=37; + public static final int T__38=38; + public static final int T__39=39; + public static final int T__33=33; + public static final int T__34=34; + public static final int T__35=35; + public static final int T__36=36; + public static final int EOF=-1; + public static final int T__30=30; + public static final int T__31=31; + public static final int T__32=32; + public static final int RULE_WS=10; + public static final int RULE_ANY_OTHER=11; + public static final int T__40=40; + public static final int T__41=41; + public static final int T__42=42; + public static final int T__43=43; + + // delegates + // delegators + + public InternalProblemLexer() {;} + public InternalProblemLexer(CharStream input) { + this(input, new RecognizerSharedState()); + } + public InternalProblemLexer(CharStream input, RecognizerSharedState state) { + super(input,state); + + } + public String getGrammarFileName() { return "InternalProblem.g"; } + + // $ANTLR start "T__12" + public final void mT__12() throws RecognitionException { + try { + int _type = T__12; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:11:7: ( '.' ) + // InternalProblem.g:11:9: '.' + { + match('.'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__12" + + // $ANTLR start "T__13" + public final void mT__13() throws RecognitionException { + try { + int _type = T__13; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:12:7: ( ',' ) + // InternalProblem.g:12:9: ',' + { + match(','); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__13" + + // $ANTLR start "T__14" + public final void mT__14() throws RecognitionException { + try { + int _type = T__14; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:13:7: ( ';' ) + // InternalProblem.g:13:9: ';' + { + match(';'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__14" + + // $ANTLR start "T__15" + public final void mT__15() throws RecognitionException { + try { + int _type = T__15; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:14:7: ( 'refers' ) + // InternalProblem.g:14:9: 'refers' + { + match("refers"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__15" + + // $ANTLR start "T__16" + public final void mT__16() throws RecognitionException { + try { + int _type = T__16; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:15:7: ( 'pred' ) + // InternalProblem.g:15:9: 'pred' + { + match("pred"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__16" + + // $ANTLR start "T__17" + public final void mT__17() throws RecognitionException { + try { + int _type = T__17; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:16:7: ( '=' ) + // InternalProblem.g:16:9: '=' + { + match('='); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__17" + + // $ANTLR start "T__18" + public final void mT__18() throws RecognitionException { + try { + int _type = T__18; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:17:7: ( '*' ) + // InternalProblem.g:17:9: '*' + { + match('*'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__18" + + // $ANTLR start "T__19" + public final void mT__19() throws RecognitionException { + try { + int _type = T__19; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:18:7: ( 'true' ) + // InternalProblem.g:18:9: 'true' + { + match("true"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__19" + + // $ANTLR start "T__20" + public final void mT__20() throws RecognitionException { + try { + int _type = T__20; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:19:7: ( 'false' ) + // InternalProblem.g:19:9: 'false' + { + match("false"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__20" + + // $ANTLR start "T__21" + public final void mT__21() throws RecognitionException { + try { + int _type = T__21; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:20:7: ( 'unknown' ) + // InternalProblem.g:20:9: 'unknown' + { + match("unknown"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__21" + + // $ANTLR start "T__22" + public final void mT__22() throws RecognitionException { + try { + int _type = T__22; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:21:7: ( '!' ) + // InternalProblem.g:21:9: '!' + { + match('!'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__22" + + // $ANTLR start "T__23" + public final void mT__23() throws RecognitionException { + try { + int _type = T__23; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:22:7: ( '?' ) + // InternalProblem.g:22:9: '?' + { + match('?'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__23" + + // $ANTLR start "T__24" + public final void mT__24() throws RecognitionException { + try { + int _type = T__24; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:23:7: ( 'problem' ) + // InternalProblem.g:23:9: 'problem' + { + match("problem"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__24" + + // $ANTLR start "T__25" + public final void mT__25() throws RecognitionException { + try { + int _type = T__25; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:24:7: ( 'class' ) + // InternalProblem.g:24:9: 'class' + { + match("class"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__25" + + // $ANTLR start "T__26" + public final void mT__26() throws RecognitionException { + try { + int _type = T__26; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:25:7: ( 'extends' ) + // InternalProblem.g:25:9: 'extends' + { + match("extends"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__26" + + // $ANTLR start "T__27" + public final void mT__27() throws RecognitionException { + try { + int _type = T__27; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:26:7: ( '{' ) + // InternalProblem.g:26:9: '{' + { + match('{'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__27" + + // $ANTLR start "T__28" + public final void mT__28() throws RecognitionException { + try { + int _type = T__28; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:27:7: ( '}' ) + // InternalProblem.g:27:9: '}' + { + match('}'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__28" + + // $ANTLR start "T__29" + public final void mT__29() throws RecognitionException { + try { + int _type = T__29; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:28:7: ( 'enum' ) + // InternalProblem.g:28:9: 'enum' + { + match("enum"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__29" + + // $ANTLR start "T__30" + public final void mT__30() throws RecognitionException { + try { + int _type = T__30; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:29:7: ( '[' ) + // InternalProblem.g:29:9: '[' + { + match('['); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__30" + + // $ANTLR start "T__31" + public final void mT__31() throws RecognitionException { + try { + int _type = T__31; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:30:7: ( ']' ) + // InternalProblem.g:30:9: ']' + { + match(']'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__31" + + // $ANTLR start "T__32" + public final void mT__32() throws RecognitionException { + try { + int _type = T__32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:31:7: ( 'opposite' ) + // InternalProblem.g:31:9: 'opposite' + { + match("opposite"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__32" + + // $ANTLR start "T__33" + public final void mT__33() throws RecognitionException { + try { + int _type = T__33; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:32:7: ( '(' ) + // InternalProblem.g:32:9: '(' + { + match('('); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__33" + + // $ANTLR start "T__34" + public final void mT__34() throws RecognitionException { + try { + int _type = T__34; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:33:7: ( ')' ) + // InternalProblem.g:33:9: ')' + { + match(')'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__34" + + // $ANTLR start "T__35" + public final void mT__35() throws RecognitionException { + try { + int _type = T__35; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:34:7: ( ':-' ) + // InternalProblem.g:34:9: ':-' + { + match(":-"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__35" + + // $ANTLR start "T__36" + public final void mT__36() throws RecognitionException { + try { + int _type = T__36; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:35:7: ( ':' ) + // InternalProblem.g:35:9: ':' + { + match(':'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__36" + + // $ANTLR start "T__37" + public final void mT__37() throws RecognitionException { + try { + int _type = T__37; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:36:7: ( 'scope' ) + // InternalProblem.g:36:9: 'scope' + { + match("scope"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__37" + + // $ANTLR start "T__38" + public final void mT__38() throws RecognitionException { + try { + int _type = T__38; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:37:7: ( '..' ) + // InternalProblem.g:37:9: '..' + { + match(".."); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__38" + + // $ANTLR start "T__39" + public final void mT__39() throws RecognitionException { + try { + int _type = T__39; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:38:7: ( 'abstract' ) + // InternalProblem.g:38:9: 'abstract' + { + match("abstract"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__39" + + // $ANTLR start "T__40" + public final void mT__40() throws RecognitionException { + try { + int _type = T__40; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:39:7: ( 'contains' ) + // InternalProblem.g:39:9: 'contains' + { + match("contains"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__40" + + // $ANTLR start "T__41" + public final void mT__41() throws RecognitionException { + try { + int _type = T__41; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:40:7: ( 'error' ) + // InternalProblem.g:40:9: 'error' + { + match("error"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__41" + + // $ANTLR start "T__42" + public final void mT__42() throws RecognitionException { + try { + int _type = T__42; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:41:7: ( '+' ) + // InternalProblem.g:41:9: '+' + { + match('+'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__42" + + // $ANTLR start "T__43" + public final void mT__43() throws RecognitionException { + try { + int _type = T__43; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:42:7: ( '+=' ) + // InternalProblem.g:42:9: '+=' + { + match("+="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__43" + + // $ANTLR start "RULE_STRING" + public final void mRULE_STRING() throws RecognitionException { + try { + int _type = RULE_STRING; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:5024:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' ) + // InternalProblem.g:5024:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' + { + match('\"'); + // InternalProblem.g:5024:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop1: + do { + int alt1=3; + int LA1_0 = input.LA(1); + + if ( (LA1_0=='\\') ) { + alt1=1; + } + else if ( ((LA1_0>='\u0000' && LA1_0<='!')||(LA1_0>='#' && LA1_0<='[')||(LA1_0>=']' && LA1_0<='\uFFFF')) ) { + alt1=2; + } + + + switch (alt1) { + case 1 : + // InternalProblem.g:5024:20: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalProblem.g:5024:27: ~ ( ( '\\\\' | '\"' ) ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop1; + } + } while (true); + + match('\"'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_STRING" + + // $ANTLR start "RULE_QUOTED_ID" + public final void mRULE_QUOTED_ID() throws RecognitionException { + try { + int _type = RULE_QUOTED_ID; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:5026:16: ( '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + // InternalProblem.g:5026:18: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' + { + match('\''); + // InternalProblem.g:5026:23: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* + loop2: + do { + int alt2=3; + int LA2_0 = input.LA(1); + + if ( (LA2_0=='\\') ) { + alt2=1; + } + else if ( ((LA2_0>='\u0000' && LA2_0<='&')||(LA2_0>='(' && LA2_0<='[')||(LA2_0>=']' && LA2_0<='\uFFFF')) ) { + alt2=2; + } + + + switch (alt2) { + case 1 : + // InternalProblem.g:5026:24: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalProblem.g:5026:31: ~ ( ( '\\\\' | '\\'' ) ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop2; + } + } while (true); + + match('\''); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_QUOTED_ID" + + // $ANTLR start "RULE_ID" + public final void mRULE_ID() throws RecognitionException { + try { + int _type = RULE_ID; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:5028:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) + // InternalProblem.g:5028:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + { + // InternalProblem.g:5028:11: ( '^' )? + int alt3=2; + int LA3_0 = input.LA(1); + + if ( (LA3_0=='^') ) { + alt3=1; + } + switch (alt3) { + case 1 : + // InternalProblem.g:5028:11: '^' + { + match('^'); + + } + break; + + } + + if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalProblem.g:5028:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + loop4: + do { + int alt4=2; + int LA4_0 = input.LA(1); + + if ( ((LA4_0>='0' && LA4_0<='9')||(LA4_0>='A' && LA4_0<='Z')||LA4_0=='_'||(LA4_0>='a' && LA4_0<='z')) ) { + alt4=1; + } + + + switch (alt4) { + case 1 : + // InternalProblem.g: + { + 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') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop4; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ID" + + // $ANTLR start "RULE_INT" + public final void mRULE_INT() throws RecognitionException { + try { + int _type = RULE_INT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:5030:10: ( ( '0' .. '9' )+ ) + // InternalProblem.g:5030:12: ( '0' .. '9' )+ + { + // InternalProblem.g:5030:12: ( '0' .. '9' )+ + int cnt5=0; + loop5: + do { + int alt5=2; + int LA5_0 = input.LA(1); + + if ( ((LA5_0>='0' && LA5_0<='9')) ) { + alt5=1; + } + + + switch (alt5) { + case 1 : + // InternalProblem.g:5030:13: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + if ( cnt5 >= 1 ) break loop5; + EarlyExitException eee = + new EarlyExitException(5, input); + throw eee; + } + cnt5++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_INT" + + // $ANTLR start "RULE_ML_COMMENT" + public final void mRULE_ML_COMMENT() throws RecognitionException { + try { + int _type = RULE_ML_COMMENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:5032:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalProblem.g:5032:19: '/*' ( options {greedy=false; } : . )* '*/' + { + match("/*"); + + // InternalProblem.g:5032:24: ( options {greedy=false; } : . )* + loop6: + do { + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='*') ) { + int LA6_1 = input.LA(2); + + if ( (LA6_1=='/') ) { + alt6=2; + } + else if ( ((LA6_1>='\u0000' && LA6_1<='.')||(LA6_1>='0' && LA6_1<='\uFFFF')) ) { + alt6=1; + } + + + } + else if ( ((LA6_0>='\u0000' && LA6_0<=')')||(LA6_0>='+' && LA6_0<='\uFFFF')) ) { + alt6=1; + } + + + switch (alt6) { + case 1 : + // InternalProblem.g:5032:52: . + { + matchAny(); + + } + break; + + default : + break loop6; + } + } while (true); + + match("*/"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ML_COMMENT" + + // $ANTLR start "RULE_SL_COMMENT" + public final void mRULE_SL_COMMENT() throws RecognitionException { + try { + int _type = RULE_SL_COMMENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:5034:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) + // InternalProblem.g:5034:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? + { + match("//"); + + // InternalProblem.g:5034:24: (~ ( ( '\\n' | '\\r' ) ) )* + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( ((LA7_0>='\u0000' && LA7_0<='\t')||(LA7_0>='\u000B' && LA7_0<='\f')||(LA7_0>='\u000E' && LA7_0<='\uFFFF')) ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // InternalProblem.g:5034:24: ~ ( ( '\\n' | '\\r' ) ) + { + 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') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop7; + } + } while (true); + + // InternalProblem.g:5034:40: ( ( '\\r' )? '\\n' )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0=='\n'||LA9_0=='\r') ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalProblem.g:5034:41: ( '\\r' )? '\\n' + { + // InternalProblem.g:5034:41: ( '\\r' )? + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0=='\r') ) { + alt8=1; + } + switch (alt8) { + case 1 : + // InternalProblem.g:5034:41: '\\r' + { + match('\r'); + + } + break; + + } + + match('\n'); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_SL_COMMENT" + + // $ANTLR start "RULE_WS" + public final void mRULE_WS() throws RecognitionException { + try { + int _type = RULE_WS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:5036:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalProblem.g:5036:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + { + // InternalProblem.g:5036:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt10=0; + loop10: + do { + int alt10=2; + int LA10_0 = input.LA(1); + + if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) { + alt10=1; + } + + + switch (alt10) { + case 1 : + // InternalProblem.g: + { + if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt10 >= 1 ) break loop10; + EarlyExitException eee = + new EarlyExitException(10, input); + throw eee; + } + cnt10++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_WS" + + // $ANTLR start "RULE_ANY_OTHER" + public final void mRULE_ANY_OTHER() throws RecognitionException { + try { + int _type = RULE_ANY_OTHER; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:5038:16: ( . ) + // InternalProblem.g:5038:18: . + { + matchAny(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ANY_OTHER" + + public void mTokens() throws RecognitionException { + // InternalProblem.g:1:8: ( 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 | T__41 | T__42 | T__43 | RULE_STRING | RULE_QUOTED_ID | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt11=40; + alt11 = dfa11.predict(input); + switch (alt11) { + case 1 : + // InternalProblem.g:1:10: T__12 + { + mT__12(); + + } + break; + case 2 : + // InternalProblem.g:1:16: T__13 + { + mT__13(); + + } + break; + case 3 : + // InternalProblem.g:1:22: T__14 + { + mT__14(); + + } + break; + case 4 : + // InternalProblem.g:1:28: T__15 + { + mT__15(); + + } + break; + case 5 : + // InternalProblem.g:1:34: T__16 + { + mT__16(); + + } + break; + case 6 : + // InternalProblem.g:1:40: T__17 + { + mT__17(); + + } + break; + case 7 : + // InternalProblem.g:1:46: T__18 + { + mT__18(); + + } + break; + case 8 : + // InternalProblem.g:1:52: T__19 + { + mT__19(); + + } + break; + case 9 : + // InternalProblem.g:1:58: T__20 + { + mT__20(); + + } + break; + case 10 : + // InternalProblem.g:1:64: T__21 + { + mT__21(); + + } + break; + case 11 : + // InternalProblem.g:1:70: T__22 + { + mT__22(); + + } + break; + case 12 : + // InternalProblem.g:1:76: T__23 + { + mT__23(); + + } + break; + case 13 : + // InternalProblem.g:1:82: T__24 + { + mT__24(); + + } + break; + case 14 : + // InternalProblem.g:1:88: T__25 + { + mT__25(); + + } + break; + case 15 : + // InternalProblem.g:1:94: T__26 + { + mT__26(); + + } + break; + case 16 : + // InternalProblem.g:1:100: T__27 + { + mT__27(); + + } + break; + case 17 : + // InternalProblem.g:1:106: T__28 + { + mT__28(); + + } + break; + case 18 : + // InternalProblem.g:1:112: T__29 + { + mT__29(); + + } + break; + case 19 : + // InternalProblem.g:1:118: T__30 + { + mT__30(); + + } + break; + case 20 : + // InternalProblem.g:1:124: T__31 + { + mT__31(); + + } + break; + case 21 : + // InternalProblem.g:1:130: T__32 + { + mT__32(); + + } + break; + case 22 : + // InternalProblem.g:1:136: T__33 + { + mT__33(); + + } + break; + case 23 : + // InternalProblem.g:1:142: T__34 + { + mT__34(); + + } + break; + case 24 : + // InternalProblem.g:1:148: T__35 + { + mT__35(); + + } + break; + case 25 : + // InternalProblem.g:1:154: T__36 + { + mT__36(); + + } + break; + case 26 : + // InternalProblem.g:1:160: T__37 + { + mT__37(); + + } + break; + case 27 : + // InternalProblem.g:1:166: T__38 + { + mT__38(); + + } + break; + case 28 : + // InternalProblem.g:1:172: T__39 + { + mT__39(); + + } + break; + case 29 : + // InternalProblem.g:1:178: T__40 + { + mT__40(); + + } + break; + case 30 : + // InternalProblem.g:1:184: T__41 + { + mT__41(); + + } + break; + case 31 : + // InternalProblem.g:1:190: T__42 + { + mT__42(); + + } + break; + case 32 : + // InternalProblem.g:1:196: T__43 + { + mT__43(); + + } + break; + case 33 : + // InternalProblem.g:1:202: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 34 : + // InternalProblem.g:1:214: RULE_QUOTED_ID + { + mRULE_QUOTED_ID(); + + } + break; + case 35 : + // InternalProblem.g:1:229: RULE_ID + { + mRULE_ID(); + + } + break; + case 36 : + // InternalProblem.g:1:237: RULE_INT + { + mRULE_INT(); + + } + break; + case 37 : + // InternalProblem.g:1:246: RULE_ML_COMMENT + { + mRULE_ML_COMMENT(); + + } + break; + case 38 : + // InternalProblem.g:1:262: RULE_SL_COMMENT + { + mRULE_SL_COMMENT(); + + } + break; + case 39 : + // InternalProblem.g:1:278: RULE_WS + { + mRULE_WS(); + + } + break; + case 40 : + // InternalProblem.g:1:286: RULE_ANY_OTHER + { + mRULE_ANY_OTHER(); + + } + break; + + } + + } + + + protected DFA11 dfa11 = new DFA11(this); + static final String DFA11_eotS = + "\1\uffff\1\43\2\uffff\2\47\2\uffff\3\47\2\uffff\2\47\4\uffff\1\47\2\uffff\1\75\2\47\1\101\3\41\2\uffff\1\41\6\uffff\1\47\1\uffff\1\47\2\uffff\3\47\2\uffff\5\47\4\uffff\1\47\4\uffff\2\47\10\uffff\17\47\1\145\1\47\1\147\5\47\1\155\5\47\1\uffff\1\47\1\uffff\1\164\1\47\1\166\2\47\1\uffff\1\171\1\47\1\173\1\47\1\175\1\47\1\uffff\1\47\1\uffff\2\47\1\uffff\1\47\1\uffff\1\47\1\uffff\1\u0084\1\u0085\1\47\1\u0087\2\47\2\uffff\1\u008a\1\uffff\1\u008b\1\u008c\3\uffff"; + static final String DFA11_eofS = + "\u008d\uffff"; + static final String DFA11_minS = + "\1\0\1\56\2\uffff\1\145\1\162\2\uffff\1\162\1\141\1\156\2\uffff\1\154\1\156\4\uffff\1\160\2\uffff\1\55\1\143\1\142\1\75\2\0\1\101\2\uffff\1\52\6\uffff\1\146\1\uffff\1\145\2\uffff\1\165\1\154\1\153\2\uffff\1\141\1\156\1\164\1\165\1\162\4\uffff\1\160\4\uffff\1\157\1\163\10\uffff\1\145\1\144\1\142\1\145\1\163\1\156\1\163\1\164\1\145\1\155\2\157\1\160\1\164\1\162\1\60\1\154\1\60\1\145\1\157\1\163\1\141\1\156\1\60\1\162\1\163\1\145\1\162\1\163\1\uffff\1\145\1\uffff\1\60\1\167\1\60\1\151\1\144\1\uffff\1\60\1\151\1\60\1\141\1\60\1\155\1\uffff\1\156\1\uffff\1\156\1\163\1\uffff\1\164\1\uffff\1\143\1\uffff\2\60\1\163\1\60\1\145\1\164\2\uffff\1\60\1\uffff\2\60\3\uffff"; + static final String DFA11_maxS = + "\1\uffff\1\56\2\uffff\1\145\1\162\2\uffff\1\162\1\141\1\156\2\uffff\1\157\1\170\4\uffff\1\160\2\uffff\1\55\1\143\1\142\1\75\2\uffff\1\172\2\uffff\1\57\6\uffff\1\146\1\uffff\1\157\2\uffff\1\165\1\154\1\153\2\uffff\1\141\1\156\1\164\1\165\1\162\4\uffff\1\160\4\uffff\1\157\1\163\10\uffff\1\145\1\144\1\142\1\145\1\163\1\156\1\163\1\164\1\145\1\155\2\157\1\160\1\164\1\162\1\172\1\154\1\172\1\145\1\157\1\163\1\141\1\156\1\172\1\162\1\163\1\145\1\162\1\163\1\uffff\1\145\1\uffff\1\172\1\167\1\172\1\151\1\144\1\uffff\1\172\1\151\1\172\1\141\1\172\1\155\1\uffff\1\156\1\uffff\1\156\1\163\1\uffff\1\164\1\uffff\1\143\1\uffff\2\172\1\163\1\172\1\145\1\164\2\uffff\1\172\1\uffff\2\172\3\uffff"; + static final String DFA11_acceptS = + "\2\uffff\1\2\1\3\2\uffff\1\6\1\7\3\uffff\1\13\1\14\2\uffff\1\20\1\21\1\23\1\24\1\uffff\1\26\1\27\7\uffff\1\43\1\44\1\uffff\1\47\1\50\1\33\1\1\1\2\1\3\1\uffff\1\43\1\uffff\1\6\1\7\3\uffff\1\13\1\14\5\uffff\1\20\1\21\1\23\1\24\1\uffff\1\26\1\27\1\30\1\31\2\uffff\1\40\1\37\1\41\1\42\1\44\1\45\1\46\1\47\35\uffff\1\5\1\uffff\1\10\5\uffff\1\22\6\uffff\1\11\1\uffff\1\16\2\uffff\1\36\1\uffff\1\32\1\uffff\1\4\6\uffff\1\15\1\12\1\uffff\1\17\2\uffff\1\35\1\25\1\34"; + static final String DFA11_specialS = + "\1\2\31\uffff\1\1\1\0\161\uffff}>"; + static final String[] DFA11_transitionS = { + "\11\41\2\40\2\41\1\40\22\41\1\40\1\13\1\32\4\41\1\33\1\24\1\25\1\7\1\31\1\2\1\41\1\1\1\37\12\36\1\26\1\3\1\41\1\6\1\41\1\14\1\41\32\35\1\21\1\41\1\22\1\34\1\35\1\41\1\30\1\35\1\15\1\35\1\16\1\11\10\35\1\23\1\5\1\35\1\4\1\27\1\10\1\12\5\35\1\17\1\41\1\20\uff82\41", + "\1\42", + "", + "", + "\1\46", + "\1\50", + "", + "", + "\1\53", + "\1\54", + "\1\55", + "", + "", + "\1\60\2\uffff\1\61", + "\1\63\3\uffff\1\64\5\uffff\1\62", + "", + "", + "", + "", + "\1\71", + "", + "", + "\1\74", + "\1\76", + "\1\77", + "\1\100", + "\0\102", + "\0\103", + "\32\47\4\uffff\1\47\1\uffff\32\47", + "", + "", + "\1\105\4\uffff\1\106", + "", + "", + "", + "", + "", + "", + "\1\110", + "", + "\1\111\11\uffff\1\112", + "", + "", + "\1\113", + "\1\114", + "\1\115", + "", + "", + "\1\116", + "\1\117", + "\1\120", + "\1\121", + "\1\122", + "", + "", + "", + "", + "\1\123", + "", + "", + "", + "", + "\1\124", + "\1\125", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\126", + "\1\127", + "\1\130", + "\1\131", + "\1\132", + "\1\133", + "\1\134", + "\1\135", + "\1\136", + "\1\137", + "\1\140", + "\1\141", + "\1\142", + "\1\143", + "\1\144", + "\12\47\7\uffff\32\47\4\uffff\1\47\1\uffff\32\47", + "\1\146", + "\12\47\7\uffff\32\47\4\uffff\1\47\1\uffff\32\47", + "\1\150", + "\1\151", + "\1\152", + "\1\153", + "\1\154", + "\12\47\7\uffff\32\47\4\uffff\1\47\1\uffff\32\47", + "\1\156", + "\1\157", + "\1\160", + "\1\161", + "\1\162", + "", + "\1\163", + "", + "\12\47\7\uffff\32\47\4\uffff\1\47\1\uffff\32\47", + "\1\165", + "\12\47\7\uffff\32\47\4\uffff\1\47\1\uffff\32\47", + "\1\167", + "\1\170", + "", + "\12\47\7\uffff\32\47\4\uffff\1\47\1\uffff\32\47", + "\1\172", + "\12\47\7\uffff\32\47\4\uffff\1\47\1\uffff\32\47", + "\1\174", + "\12\47\7\uffff\32\47\4\uffff\1\47\1\uffff\32\47", + "\1\176", + "", + "\1\177", + "", + "\1\u0080", + "\1\u0081", + "", + "\1\u0082", + "", + "\1\u0083", + "", + "\12\47\7\uffff\32\47\4\uffff\1\47\1\uffff\32\47", + "\12\47\7\uffff\32\47\4\uffff\1\47\1\uffff\32\47", + "\1\u0086", + "\12\47\7\uffff\32\47\4\uffff\1\47\1\uffff\32\47", + "\1\u0088", + "\1\u0089", + "", + "", + "\12\47\7\uffff\32\47\4\uffff\1\47\1\uffff\32\47", + "", + "\12\47\7\uffff\32\47\4\uffff\1\47\1\uffff\32\47", + "\12\47\7\uffff\32\47\4\uffff\1\47\1\uffff\32\47", + "", + "", + "" + }; + + static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS); + static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS); + static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS); + static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS); + static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS); + static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS); + static final short[][] DFA11_transition; + + static { + int numStates = DFA11_transitionS.length; + DFA11_transition = new short[numStates][]; + for (int i=0; i='\u0000' && LA11_27<='\uFFFF')) ) {s = 67;} + + else s = 33; + + if ( s>=0 ) return s; + break; + case 1 : + int LA11_26 = input.LA(1); + + s = -1; + if ( ((LA11_26>='\u0000' && LA11_26<='\uFFFF')) ) {s = 66;} + + else s = 33; + + if ( s>=0 ) return s; + break; + case 2 : + int LA11_0 = input.LA(1); + + s = -1; + if ( (LA11_0=='.') ) {s = 1;} + + else if ( (LA11_0==',') ) {s = 2;} + + else if ( (LA11_0==';') ) {s = 3;} + + else if ( (LA11_0=='r') ) {s = 4;} + + else if ( (LA11_0=='p') ) {s = 5;} + + else if ( (LA11_0=='=') ) {s = 6;} + + else if ( (LA11_0=='*') ) {s = 7;} + + else if ( (LA11_0=='t') ) {s = 8;} + + else if ( (LA11_0=='f') ) {s = 9;} + + else if ( (LA11_0=='u') ) {s = 10;} + + else if ( (LA11_0=='!') ) {s = 11;} + + else if ( (LA11_0=='?') ) {s = 12;} + + else if ( (LA11_0=='c') ) {s = 13;} + + else if ( (LA11_0=='e') ) {s = 14;} + + else if ( (LA11_0=='{') ) {s = 15;} + + else if ( (LA11_0=='}') ) {s = 16;} + + else if ( (LA11_0=='[') ) {s = 17;} + + else if ( (LA11_0==']') ) {s = 18;} + + else if ( (LA11_0=='o') ) {s = 19;} + + else if ( (LA11_0=='(') ) {s = 20;} + + else if ( (LA11_0==')') ) {s = 21;} + + else if ( (LA11_0==':') ) {s = 22;} + + else if ( (LA11_0=='s') ) {s = 23;} + + else if ( (LA11_0=='a') ) {s = 24;} + + else if ( (LA11_0=='+') ) {s = 25;} + + else if ( (LA11_0=='\"') ) {s = 26;} + + else if ( (LA11_0=='\'') ) {s = 27;} + + else if ( (LA11_0=='^') ) {s = 28;} + + else if ( ((LA11_0>='A' && LA11_0<='Z')||LA11_0=='_'||LA11_0=='b'||LA11_0=='d'||(LA11_0>='g' && LA11_0<='n')||LA11_0=='q'||(LA11_0>='v' && LA11_0<='z')) ) {s = 29;} + + else if ( ((LA11_0>='0' && LA11_0<='9')) ) {s = 30;} + + else if ( (LA11_0=='/') ) {s = 31;} + + else if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) {s = 32;} + + else if ( ((LA11_0>='\u0000' && LA11_0<='\b')||(LA11_0>='\u000B' && LA11_0<='\f')||(LA11_0>='\u000E' && LA11_0<='\u001F')||(LA11_0>='#' && LA11_0<='&')||LA11_0=='-'||LA11_0=='<'||LA11_0=='>'||LA11_0=='@'||LA11_0=='\\'||LA11_0=='`'||LA11_0=='|'||(LA11_0>='~' && LA11_0<='\uFFFF')) ) {s = 33;} + + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 11, _s, input); + error(nvae); + throw nvae; + } + } + + +} \ No newline at end of file diff --git a/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemParser.java b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemParser.java new file mode 100644 index 00000000..0f70a158 --- /dev/null +++ b/language-ide/src/main/xtext-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalProblemParser.java @@ -0,0 +1,15493 @@ +package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal; + +import java.io.InputStream; +import org.eclipse.xtext.*; +import org.eclipse.xtext.parser.*; +import org.eclipse.xtext.parser.impl.*; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; +import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; +import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; +import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA; +import org.eclipse.viatra.solver.language.services.ProblemGrammarAccess; + + + +import org.antlr.runtime.*; +import java.util.Stack; +import java.util.List; +import java.util.ArrayList; + +@SuppressWarnings("all") +public class InternalProblemParser extends AbstractInternalContentAssistParser { + public static final String[] tokenNames = new String[] { + "", "", "", "", "RULE_INT", "RULE_QUOTED_ID", "RULE_ID", "RULE_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'.'", "','", "';'", "'refers'", "'pred'", "'='", "'*'", "'true'", "'false'", "'unknown'", "'!'", "'?'", "'problem'", "'class'", "'extends'", "'{'", "'}'", "'enum'", "'['", "']'", "'opposite'", "'('", "')'", "':-'", "':'", "'scope'", "'..'", "'abstract'", "'contains'", "'error'", "'+'", "'+='" + }; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__12=12; + public static final int T__13=13; + public static final int T__14=14; + public static final int RULE_ID=6; + public static final int RULE_QUOTED_ID=5; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int RULE_INT=4; + public static final int T__29=29; + public static final int T__22=22; + public static final int RULE_ML_COMMENT=8; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int RULE_STRING=7; + public static final int RULE_SL_COMMENT=9; + public static final int T__37=37; + public static final int T__38=38; + public static final int T__39=39; + public static final int T__33=33; + public static final int T__34=34; + public static final int T__35=35; + public static final int T__36=36; + public static final int EOF=-1; + public static final int T__30=30; + public static final int T__31=31; + public static final int T__32=32; + public static final int RULE_WS=10; + public static final int RULE_ANY_OTHER=11; + public static final int T__40=40; + public static final int T__41=41; + public static final int T__42=42; + public static final int T__43=43; + + // delegates + // delegators + + + public InternalProblemParser(TokenStream input) { + this(input, new RecognizerSharedState()); + } + public InternalProblemParser(TokenStream input, RecognizerSharedState state) { + super(input, state); + + } + + + public String[] getTokenNames() { return InternalProblemParser.tokenNames; } + public String getGrammarFileName() { return "InternalProblem.g"; } + + + private ProblemGrammarAccess grammarAccess; + + public void setGrammarAccess(ProblemGrammarAccess grammarAccess) { + this.grammarAccess = grammarAccess; + } + + @Override + protected Grammar getGrammar() { + return grammarAccess.getGrammar(); + } + + @Override + protected String getValueForTokenName(String tokenName) { + return tokenName; + } + + + + // $ANTLR start "entryRuleProblem" + // InternalProblem.g:53:1: entryRuleProblem : ruleProblem EOF ; + public final void entryRuleProblem() throws RecognitionException { + try { + // InternalProblem.g:54:1: ( ruleProblem EOF ) + // InternalProblem.g:55:1: ruleProblem EOF + { + before(grammarAccess.getProblemRule()); + pushFollow(FOLLOW_1); + ruleProblem(); + + state._fsp--; + + after(grammarAccess.getProblemRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleProblem" + + + // $ANTLR start "ruleProblem" + // InternalProblem.g:62:1: ruleProblem : ( ( rule__Problem__Group__0 ) ) ; + public final void ruleProblem() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:66:2: ( ( ( rule__Problem__Group__0 ) ) ) + // InternalProblem.g:67:2: ( ( rule__Problem__Group__0 ) ) + { + // InternalProblem.g:67:2: ( ( rule__Problem__Group__0 ) ) + // InternalProblem.g:68:3: ( rule__Problem__Group__0 ) + { + before(grammarAccess.getProblemAccess().getGroup()); + // InternalProblem.g:69:3: ( rule__Problem__Group__0 ) + // InternalProblem.g:69:4: rule__Problem__Group__0 + { + pushFollow(FOLLOW_2); + rule__Problem__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getProblemAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleProblem" + + + // $ANTLR start "entryRuleStatement" + // InternalProblem.g:78:1: entryRuleStatement : ruleStatement EOF ; + public final void entryRuleStatement() throws RecognitionException { + try { + // InternalProblem.g:79:1: ( ruleStatement EOF ) + // InternalProblem.g:80:1: ruleStatement EOF + { + before(grammarAccess.getStatementRule()); + pushFollow(FOLLOW_1); + ruleStatement(); + + state._fsp--; + + after(grammarAccess.getStatementRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleStatement" + + + // $ANTLR start "ruleStatement" + // InternalProblem.g:87:1: ruleStatement : ( ( rule__Statement__Alternatives ) ) ; + public final void ruleStatement() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:91:2: ( ( ( rule__Statement__Alternatives ) ) ) + // InternalProblem.g:92:2: ( ( rule__Statement__Alternatives ) ) + { + // InternalProblem.g:92:2: ( ( rule__Statement__Alternatives ) ) + // InternalProblem.g:93:3: ( rule__Statement__Alternatives ) + { + before(grammarAccess.getStatementAccess().getAlternatives()); + // InternalProblem.g:94:3: ( rule__Statement__Alternatives ) + // InternalProblem.g:94:4: rule__Statement__Alternatives + { + pushFollow(FOLLOW_2); + rule__Statement__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getStatementAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleStatement" + + + // $ANTLR start "entryRuleClassDeclaration" + // InternalProblem.g:103:1: entryRuleClassDeclaration : ruleClassDeclaration EOF ; + public final void entryRuleClassDeclaration() throws RecognitionException { + try { + // InternalProblem.g:104:1: ( ruleClassDeclaration EOF ) + // InternalProblem.g:105:1: ruleClassDeclaration EOF + { + before(grammarAccess.getClassDeclarationRule()); + pushFollow(FOLLOW_1); + ruleClassDeclaration(); + + state._fsp--; + + after(grammarAccess.getClassDeclarationRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleClassDeclaration" + + + // $ANTLR start "ruleClassDeclaration" + // InternalProblem.g:112:1: ruleClassDeclaration : ( ( rule__ClassDeclaration__Group__0 ) ) ; + public final void ruleClassDeclaration() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:116:2: ( ( ( rule__ClassDeclaration__Group__0 ) ) ) + // InternalProblem.g:117:2: ( ( rule__ClassDeclaration__Group__0 ) ) + { + // InternalProblem.g:117:2: ( ( rule__ClassDeclaration__Group__0 ) ) + // InternalProblem.g:118:3: ( rule__ClassDeclaration__Group__0 ) + { + before(grammarAccess.getClassDeclarationAccess().getGroup()); + // InternalProblem.g:119:3: ( rule__ClassDeclaration__Group__0 ) + // InternalProblem.g:119:4: rule__ClassDeclaration__Group__0 + { + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getClassDeclarationAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleClassDeclaration" + + + // $ANTLR start "entryRuleEnumDeclaration" + // InternalProblem.g:128:1: entryRuleEnumDeclaration : ruleEnumDeclaration EOF ; + public final void entryRuleEnumDeclaration() throws RecognitionException { + try { + // InternalProblem.g:129:1: ( ruleEnumDeclaration EOF ) + // InternalProblem.g:130:1: ruleEnumDeclaration EOF + { + before(grammarAccess.getEnumDeclarationRule()); + pushFollow(FOLLOW_1); + ruleEnumDeclaration(); + + state._fsp--; + + after(grammarAccess.getEnumDeclarationRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleEnumDeclaration" + + + // $ANTLR start "ruleEnumDeclaration" + // InternalProblem.g:137:1: ruleEnumDeclaration : ( ( rule__EnumDeclaration__Group__0 ) ) ; + public final void ruleEnumDeclaration() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:141:2: ( ( ( rule__EnumDeclaration__Group__0 ) ) ) + // InternalProblem.g:142:2: ( ( rule__EnumDeclaration__Group__0 ) ) + { + // InternalProblem.g:142:2: ( ( rule__EnumDeclaration__Group__0 ) ) + // InternalProblem.g:143:3: ( rule__EnumDeclaration__Group__0 ) + { + before(grammarAccess.getEnumDeclarationAccess().getGroup()); + // InternalProblem.g:144:3: ( rule__EnumDeclaration__Group__0 ) + // InternalProblem.g:144:4: rule__EnumDeclaration__Group__0 + { + pushFollow(FOLLOW_2); + rule__EnumDeclaration__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getEnumDeclarationAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleEnumDeclaration" + + + // $ANTLR start "entryRuleEnumLiteral" + // InternalProblem.g:153:1: entryRuleEnumLiteral : ruleEnumLiteral EOF ; + public final void entryRuleEnumLiteral() throws RecognitionException { + try { + // InternalProblem.g:154:1: ( ruleEnumLiteral EOF ) + // InternalProblem.g:155:1: ruleEnumLiteral EOF + { + before(grammarAccess.getEnumLiteralRule()); + pushFollow(FOLLOW_1); + ruleEnumLiteral(); + + state._fsp--; + + after(grammarAccess.getEnumLiteralRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleEnumLiteral" + + + // $ANTLR start "ruleEnumLiteral" + // InternalProblem.g:162:1: ruleEnumLiteral : ( ( rule__EnumLiteral__NameAssignment ) ) ; + public final void ruleEnumLiteral() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:166:2: ( ( ( rule__EnumLiteral__NameAssignment ) ) ) + // InternalProblem.g:167:2: ( ( rule__EnumLiteral__NameAssignment ) ) + { + // InternalProblem.g:167:2: ( ( rule__EnumLiteral__NameAssignment ) ) + // InternalProblem.g:168:3: ( rule__EnumLiteral__NameAssignment ) + { + before(grammarAccess.getEnumLiteralAccess().getNameAssignment()); + // InternalProblem.g:169:3: ( rule__EnumLiteral__NameAssignment ) + // InternalProblem.g:169:4: rule__EnumLiteral__NameAssignment + { + pushFollow(FOLLOW_2); + rule__EnumLiteral__NameAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getEnumLiteralAccess().getNameAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleEnumLiteral" + + + // $ANTLR start "entryRuleReferenceDeclaration" + // InternalProblem.g:178:1: entryRuleReferenceDeclaration : ruleReferenceDeclaration EOF ; + public final void entryRuleReferenceDeclaration() throws RecognitionException { + try { + // InternalProblem.g:179:1: ( ruleReferenceDeclaration EOF ) + // InternalProblem.g:180:1: ruleReferenceDeclaration EOF + { + before(grammarAccess.getReferenceDeclarationRule()); + pushFollow(FOLLOW_1); + ruleReferenceDeclaration(); + + state._fsp--; + + after(grammarAccess.getReferenceDeclarationRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleReferenceDeclaration" + + + // $ANTLR start "ruleReferenceDeclaration" + // InternalProblem.g:187:1: ruleReferenceDeclaration : ( ( rule__ReferenceDeclaration__Group__0 ) ) ; + public final void ruleReferenceDeclaration() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:191:2: ( ( ( rule__ReferenceDeclaration__Group__0 ) ) ) + // InternalProblem.g:192:2: ( ( rule__ReferenceDeclaration__Group__0 ) ) + { + // InternalProblem.g:192:2: ( ( rule__ReferenceDeclaration__Group__0 ) ) + // InternalProblem.g:193:3: ( rule__ReferenceDeclaration__Group__0 ) + { + before(grammarAccess.getReferenceDeclarationAccess().getGroup()); + // InternalProblem.g:194:3: ( rule__ReferenceDeclaration__Group__0 ) + // InternalProblem.g:194:4: rule__ReferenceDeclaration__Group__0 + { + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getReferenceDeclarationAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleReferenceDeclaration" + + + // $ANTLR start "entryRulePredicateDefinition" + // InternalProblem.g:203:1: entryRulePredicateDefinition : rulePredicateDefinition EOF ; + public final void entryRulePredicateDefinition() throws RecognitionException { + try { + // InternalProblem.g:204:1: ( rulePredicateDefinition EOF ) + // InternalProblem.g:205:1: rulePredicateDefinition EOF + { + before(grammarAccess.getPredicateDefinitionRule()); + pushFollow(FOLLOW_1); + rulePredicateDefinition(); + + state._fsp--; + + after(grammarAccess.getPredicateDefinitionRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRulePredicateDefinition" + + + // $ANTLR start "rulePredicateDefinition" + // InternalProblem.g:212:1: rulePredicateDefinition : ( ( rule__PredicateDefinition__Group__0 ) ) ; + public final void rulePredicateDefinition() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:216:2: ( ( ( rule__PredicateDefinition__Group__0 ) ) ) + // InternalProblem.g:217:2: ( ( rule__PredicateDefinition__Group__0 ) ) + { + // InternalProblem.g:217:2: ( ( rule__PredicateDefinition__Group__0 ) ) + // InternalProblem.g:218:3: ( rule__PredicateDefinition__Group__0 ) + { + before(grammarAccess.getPredicateDefinitionAccess().getGroup()); + // InternalProblem.g:219:3: ( rule__PredicateDefinition__Group__0 ) + // InternalProblem.g:219:4: rule__PredicateDefinition__Group__0 + { + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getPredicateDefinitionAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rulePredicateDefinition" + + + // $ANTLR start "entryRuleParameter" + // InternalProblem.g:228:1: entryRuleParameter : ruleParameter EOF ; + public final void entryRuleParameter() throws RecognitionException { + try { + // InternalProblem.g:229:1: ( ruleParameter EOF ) + // InternalProblem.g:230:1: ruleParameter EOF + { + before(grammarAccess.getParameterRule()); + pushFollow(FOLLOW_1); + ruleParameter(); + + state._fsp--; + + after(grammarAccess.getParameterRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleParameter" + + + // $ANTLR start "ruleParameter" + // InternalProblem.g:237:1: ruleParameter : ( ( rule__Parameter__Group__0 ) ) ; + public final void ruleParameter() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:241:2: ( ( ( rule__Parameter__Group__0 ) ) ) + // InternalProblem.g:242:2: ( ( rule__Parameter__Group__0 ) ) + { + // InternalProblem.g:242:2: ( ( rule__Parameter__Group__0 ) ) + // InternalProblem.g:243:3: ( rule__Parameter__Group__0 ) + { + before(grammarAccess.getParameterAccess().getGroup()); + // InternalProblem.g:244:3: ( rule__Parameter__Group__0 ) + // InternalProblem.g:244:4: rule__Parameter__Group__0 + { + pushFollow(FOLLOW_2); + rule__Parameter__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleParameter" + + + // $ANTLR start "entryRuleConjunction" + // InternalProblem.g:253:1: entryRuleConjunction : ruleConjunction EOF ; + public final void entryRuleConjunction() throws RecognitionException { + try { + // InternalProblem.g:254:1: ( ruleConjunction EOF ) + // InternalProblem.g:255:1: ruleConjunction EOF + { + before(grammarAccess.getConjunctionRule()); + pushFollow(FOLLOW_1); + ruleConjunction(); + + state._fsp--; + + after(grammarAccess.getConjunctionRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleConjunction" + + + // $ANTLR start "ruleConjunction" + // InternalProblem.g:262:1: ruleConjunction : ( ( rule__Conjunction__Group__0 ) ) ; + public final void ruleConjunction() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:266:2: ( ( ( rule__Conjunction__Group__0 ) ) ) + // InternalProblem.g:267:2: ( ( rule__Conjunction__Group__0 ) ) + { + // InternalProblem.g:267:2: ( ( rule__Conjunction__Group__0 ) ) + // InternalProblem.g:268:3: ( rule__Conjunction__Group__0 ) + { + before(grammarAccess.getConjunctionAccess().getGroup()); + // InternalProblem.g:269:3: ( rule__Conjunction__Group__0 ) + // InternalProblem.g:269:4: rule__Conjunction__Group__0 + { + pushFollow(FOLLOW_2); + rule__Conjunction__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getConjunctionAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleConjunction" + + + // $ANTLR start "entryRuleLiteral" + // InternalProblem.g:278:1: entryRuleLiteral : ruleLiteral EOF ; + public final void entryRuleLiteral() throws RecognitionException { + try { + // InternalProblem.g:279:1: ( ruleLiteral EOF ) + // InternalProblem.g:280:1: ruleLiteral EOF + { + before(grammarAccess.getLiteralRule()); + pushFollow(FOLLOW_1); + ruleLiteral(); + + state._fsp--; + + after(grammarAccess.getLiteralRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleLiteral" + + + // $ANTLR start "ruleLiteral" + // InternalProblem.g:287:1: ruleLiteral : ( ( rule__Literal__Alternatives ) ) ; + public final void ruleLiteral() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:291:2: ( ( ( rule__Literal__Alternatives ) ) ) + // InternalProblem.g:292:2: ( ( rule__Literal__Alternatives ) ) + { + // InternalProblem.g:292:2: ( ( rule__Literal__Alternatives ) ) + // InternalProblem.g:293:3: ( rule__Literal__Alternatives ) + { + before(grammarAccess.getLiteralAccess().getAlternatives()); + // InternalProblem.g:294:3: ( rule__Literal__Alternatives ) + // InternalProblem.g:294:4: rule__Literal__Alternatives + { + pushFollow(FOLLOW_2); + rule__Literal__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getLiteralAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleLiteral" + + + // $ANTLR start "entryRuleNegativeLiteral" + // InternalProblem.g:303:1: entryRuleNegativeLiteral : ruleNegativeLiteral EOF ; + public final void entryRuleNegativeLiteral() throws RecognitionException { + try { + // InternalProblem.g:304:1: ( ruleNegativeLiteral EOF ) + // InternalProblem.g:305:1: ruleNegativeLiteral EOF + { + before(grammarAccess.getNegativeLiteralRule()); + pushFollow(FOLLOW_1); + ruleNegativeLiteral(); + + state._fsp--; + + after(grammarAccess.getNegativeLiteralRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleNegativeLiteral" + + + // $ANTLR start "ruleNegativeLiteral" + // InternalProblem.g:312:1: ruleNegativeLiteral : ( ( rule__NegativeLiteral__Group__0 ) ) ; + public final void ruleNegativeLiteral() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:316:2: ( ( ( rule__NegativeLiteral__Group__0 ) ) ) + // InternalProblem.g:317:2: ( ( rule__NegativeLiteral__Group__0 ) ) + { + // InternalProblem.g:317:2: ( ( rule__NegativeLiteral__Group__0 ) ) + // InternalProblem.g:318:3: ( rule__NegativeLiteral__Group__0 ) + { + before(grammarAccess.getNegativeLiteralAccess().getGroup()); + // InternalProblem.g:319:3: ( rule__NegativeLiteral__Group__0 ) + // InternalProblem.g:319:4: rule__NegativeLiteral__Group__0 + { + pushFollow(FOLLOW_2); + rule__NegativeLiteral__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getNegativeLiteralAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleNegativeLiteral" + + + // $ANTLR start "entryRuleAtom" + // InternalProblem.g:328:1: entryRuleAtom : ruleAtom EOF ; + public final void entryRuleAtom() throws RecognitionException { + try { + // InternalProblem.g:329:1: ( ruleAtom EOF ) + // InternalProblem.g:330:1: ruleAtom EOF + { + before(grammarAccess.getAtomRule()); + pushFollow(FOLLOW_1); + ruleAtom(); + + state._fsp--; + + after(grammarAccess.getAtomRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleAtom" + + + // $ANTLR start "ruleAtom" + // InternalProblem.g:337:1: ruleAtom : ( ( rule__Atom__Group__0 ) ) ; + public final void ruleAtom() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:341:2: ( ( ( rule__Atom__Group__0 ) ) ) + // InternalProblem.g:342:2: ( ( rule__Atom__Group__0 ) ) + { + // InternalProblem.g:342:2: ( ( rule__Atom__Group__0 ) ) + // InternalProblem.g:343:3: ( rule__Atom__Group__0 ) + { + before(grammarAccess.getAtomAccess().getGroup()); + // InternalProblem.g:344:3: ( rule__Atom__Group__0 ) + // InternalProblem.g:344:4: rule__Atom__Group__0 + { + pushFollow(FOLLOW_2); + rule__Atom__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getAtomAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleAtom" + + + // $ANTLR start "entryRuleArgument" + // InternalProblem.g:353:1: entryRuleArgument : ruleArgument EOF ; + public final void entryRuleArgument() throws RecognitionException { + try { + // InternalProblem.g:354:1: ( ruleArgument EOF ) + // InternalProblem.g:355:1: ruleArgument EOF + { + before(grammarAccess.getArgumentRule()); + pushFollow(FOLLOW_1); + ruleArgument(); + + state._fsp--; + + after(grammarAccess.getArgumentRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleArgument" + + + // $ANTLR start "ruleArgument" + // InternalProblem.g:362:1: ruleArgument : ( ( rule__Argument__VariableOrNodeAssignment ) ) ; + public final void ruleArgument() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:366:2: ( ( ( rule__Argument__VariableOrNodeAssignment ) ) ) + // InternalProblem.g:367:2: ( ( rule__Argument__VariableOrNodeAssignment ) ) + { + // InternalProblem.g:367:2: ( ( rule__Argument__VariableOrNodeAssignment ) ) + // InternalProblem.g:368:3: ( rule__Argument__VariableOrNodeAssignment ) + { + before(grammarAccess.getArgumentAccess().getVariableOrNodeAssignment()); + // InternalProblem.g:369:3: ( rule__Argument__VariableOrNodeAssignment ) + // InternalProblem.g:369:4: rule__Argument__VariableOrNodeAssignment + { + pushFollow(FOLLOW_2); + rule__Argument__VariableOrNodeAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getArgumentAccess().getVariableOrNodeAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleArgument" + + + // $ANTLR start "entryRuleAssertion" + // InternalProblem.g:378:1: entryRuleAssertion : ruleAssertion EOF ; + public final void entryRuleAssertion() throws RecognitionException { + try { + // InternalProblem.g:379:1: ( ruleAssertion EOF ) + // InternalProblem.g:380:1: ruleAssertion EOF + { + before(grammarAccess.getAssertionRule()); + pushFollow(FOLLOW_1); + ruleAssertion(); + + state._fsp--; + + after(grammarAccess.getAssertionRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleAssertion" + + + // $ANTLR start "ruleAssertion" + // InternalProblem.g:387:1: ruleAssertion : ( ( rule__Assertion__Group__0 ) ) ; + public final void ruleAssertion() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:391:2: ( ( ( rule__Assertion__Group__0 ) ) ) + // InternalProblem.g:392:2: ( ( rule__Assertion__Group__0 ) ) + { + // InternalProblem.g:392:2: ( ( rule__Assertion__Group__0 ) ) + // InternalProblem.g:393:3: ( rule__Assertion__Group__0 ) + { + before(grammarAccess.getAssertionAccess().getGroup()); + // InternalProblem.g:394:3: ( rule__Assertion__Group__0 ) + // InternalProblem.g:394:4: rule__Assertion__Group__0 + { + pushFollow(FOLLOW_2); + rule__Assertion__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getAssertionAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleAssertion" + + + // $ANTLR start "entryRuleScopeDeclaration" + // InternalProblem.g:403:1: entryRuleScopeDeclaration : ruleScopeDeclaration EOF ; + public final void entryRuleScopeDeclaration() throws RecognitionException { + try { + // InternalProblem.g:404:1: ( ruleScopeDeclaration EOF ) + // InternalProblem.g:405:1: ruleScopeDeclaration EOF + { + before(grammarAccess.getScopeDeclarationRule()); + pushFollow(FOLLOW_1); + ruleScopeDeclaration(); + + state._fsp--; + + after(grammarAccess.getScopeDeclarationRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleScopeDeclaration" + + + // $ANTLR start "ruleScopeDeclaration" + // InternalProblem.g:412:1: ruleScopeDeclaration : ( ( rule__ScopeDeclaration__Group__0 ) ) ; + public final void ruleScopeDeclaration() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:416:2: ( ( ( rule__ScopeDeclaration__Group__0 ) ) ) + // InternalProblem.g:417:2: ( ( rule__ScopeDeclaration__Group__0 ) ) + { + // InternalProblem.g:417:2: ( ( rule__ScopeDeclaration__Group__0 ) ) + // InternalProblem.g:418:3: ( rule__ScopeDeclaration__Group__0 ) + { + before(grammarAccess.getScopeDeclarationAccess().getGroup()); + // InternalProblem.g:419:3: ( rule__ScopeDeclaration__Group__0 ) + // InternalProblem.g:419:4: rule__ScopeDeclaration__Group__0 + { + pushFollow(FOLLOW_2); + rule__ScopeDeclaration__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getScopeDeclarationAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleScopeDeclaration" + + + // $ANTLR start "entryRuleTypeScope" + // InternalProblem.g:428:1: entryRuleTypeScope : ruleTypeScope EOF ; + public final void entryRuleTypeScope() throws RecognitionException { + try { + // InternalProblem.g:429:1: ( ruleTypeScope EOF ) + // InternalProblem.g:430:1: ruleTypeScope EOF + { + before(grammarAccess.getTypeScopeRule()); + pushFollow(FOLLOW_1); + ruleTypeScope(); + + state._fsp--; + + after(grammarAccess.getTypeScopeRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleTypeScope" + + + // $ANTLR start "ruleTypeScope" + // InternalProblem.g:437:1: ruleTypeScope : ( ( rule__TypeScope__Group__0 ) ) ; + public final void ruleTypeScope() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:441:2: ( ( ( rule__TypeScope__Group__0 ) ) ) + // InternalProblem.g:442:2: ( ( rule__TypeScope__Group__0 ) ) + { + // InternalProblem.g:442:2: ( ( rule__TypeScope__Group__0 ) ) + // InternalProblem.g:443:3: ( rule__TypeScope__Group__0 ) + { + before(grammarAccess.getTypeScopeAccess().getGroup()); + // InternalProblem.g:444:3: ( rule__TypeScope__Group__0 ) + // InternalProblem.g:444:4: rule__TypeScope__Group__0 + { + pushFollow(FOLLOW_2); + rule__TypeScope__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getTypeScopeAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleTypeScope" + + + // $ANTLR start "entryRuleMultiplicity" + // InternalProblem.g:453:1: entryRuleMultiplicity : ruleMultiplicity EOF ; + public final void entryRuleMultiplicity() throws RecognitionException { + try { + // InternalProblem.g:454:1: ( ruleMultiplicity EOF ) + // InternalProblem.g:455:1: ruleMultiplicity EOF + { + before(grammarAccess.getMultiplicityRule()); + pushFollow(FOLLOW_1); + ruleMultiplicity(); + + state._fsp--; + + after(grammarAccess.getMultiplicityRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleMultiplicity" + + + // $ANTLR start "ruleMultiplicity" + // InternalProblem.g:462:1: ruleMultiplicity : ( ( rule__Multiplicity__Alternatives ) ) ; + public final void ruleMultiplicity() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:466:2: ( ( ( rule__Multiplicity__Alternatives ) ) ) + // InternalProblem.g:467:2: ( ( rule__Multiplicity__Alternatives ) ) + { + // InternalProblem.g:467:2: ( ( rule__Multiplicity__Alternatives ) ) + // InternalProblem.g:468:3: ( rule__Multiplicity__Alternatives ) + { + before(grammarAccess.getMultiplicityAccess().getAlternatives()); + // InternalProblem.g:469:3: ( rule__Multiplicity__Alternatives ) + // InternalProblem.g:469:4: rule__Multiplicity__Alternatives + { + pushFollow(FOLLOW_2); + rule__Multiplicity__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getMultiplicityAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleMultiplicity" + + + // $ANTLR start "entryRuleDefiniteMultiplicity" + // InternalProblem.g:478:1: entryRuleDefiniteMultiplicity : ruleDefiniteMultiplicity EOF ; + public final void entryRuleDefiniteMultiplicity() throws RecognitionException { + try { + // InternalProblem.g:479:1: ( ruleDefiniteMultiplicity EOF ) + // InternalProblem.g:480:1: ruleDefiniteMultiplicity EOF + { + before(grammarAccess.getDefiniteMultiplicityRule()); + pushFollow(FOLLOW_1); + ruleDefiniteMultiplicity(); + + state._fsp--; + + after(grammarAccess.getDefiniteMultiplicityRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleDefiniteMultiplicity" + + + // $ANTLR start "ruleDefiniteMultiplicity" + // InternalProblem.g:487:1: ruleDefiniteMultiplicity : ( ( rule__DefiniteMultiplicity__Alternatives ) ) ; + public final void ruleDefiniteMultiplicity() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:491:2: ( ( ( rule__DefiniteMultiplicity__Alternatives ) ) ) + // InternalProblem.g:492:2: ( ( rule__DefiniteMultiplicity__Alternatives ) ) + { + // InternalProblem.g:492:2: ( ( rule__DefiniteMultiplicity__Alternatives ) ) + // InternalProblem.g:493:3: ( rule__DefiniteMultiplicity__Alternatives ) + { + before(grammarAccess.getDefiniteMultiplicityAccess().getAlternatives()); + // InternalProblem.g:494:3: ( rule__DefiniteMultiplicity__Alternatives ) + // InternalProblem.g:494:4: rule__DefiniteMultiplicity__Alternatives + { + pushFollow(FOLLOW_2); + rule__DefiniteMultiplicity__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getDefiniteMultiplicityAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleDefiniteMultiplicity" + + + // $ANTLR start "entryRuleUnboundedMultiplicity" + // InternalProblem.g:503:1: entryRuleUnboundedMultiplicity : ruleUnboundedMultiplicity EOF ; + public final void entryRuleUnboundedMultiplicity() throws RecognitionException { + try { + // InternalProblem.g:504:1: ( ruleUnboundedMultiplicity EOF ) + // InternalProblem.g:505:1: ruleUnboundedMultiplicity EOF + { + before(grammarAccess.getUnboundedMultiplicityRule()); + pushFollow(FOLLOW_1); + ruleUnboundedMultiplicity(); + + state._fsp--; + + after(grammarAccess.getUnboundedMultiplicityRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleUnboundedMultiplicity" + + + // $ANTLR start "ruleUnboundedMultiplicity" + // InternalProblem.g:512:1: ruleUnboundedMultiplicity : ( () ) ; + public final void ruleUnboundedMultiplicity() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:516:2: ( ( () ) ) + // InternalProblem.g:517:2: ( () ) + { + // InternalProblem.g:517:2: ( () ) + // InternalProblem.g:518:3: () + { + before(grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction()); + // InternalProblem.g:519:3: () + // InternalProblem.g:519:4: + { + } + + after(grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction()); + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleUnboundedMultiplicity" + + + // $ANTLR start "entryRuleRangeMultiplicity" + // InternalProblem.g:528:1: entryRuleRangeMultiplicity : ruleRangeMultiplicity EOF ; + public final void entryRuleRangeMultiplicity() throws RecognitionException { + try { + // InternalProblem.g:529:1: ( ruleRangeMultiplicity EOF ) + // InternalProblem.g:530:1: ruleRangeMultiplicity EOF + { + before(grammarAccess.getRangeMultiplicityRule()); + pushFollow(FOLLOW_1); + ruleRangeMultiplicity(); + + state._fsp--; + + after(grammarAccess.getRangeMultiplicityRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleRangeMultiplicity" + + + // $ANTLR start "ruleRangeMultiplicity" + // InternalProblem.g:537:1: ruleRangeMultiplicity : ( ( rule__RangeMultiplicity__Group__0 ) ) ; + public final void ruleRangeMultiplicity() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:541:2: ( ( ( rule__RangeMultiplicity__Group__0 ) ) ) + // InternalProblem.g:542:2: ( ( rule__RangeMultiplicity__Group__0 ) ) + { + // InternalProblem.g:542:2: ( ( rule__RangeMultiplicity__Group__0 ) ) + // InternalProblem.g:543:3: ( rule__RangeMultiplicity__Group__0 ) + { + before(grammarAccess.getRangeMultiplicityAccess().getGroup()); + // InternalProblem.g:544:3: ( rule__RangeMultiplicity__Group__0 ) + // InternalProblem.g:544:4: rule__RangeMultiplicity__Group__0 + { + pushFollow(FOLLOW_2); + rule__RangeMultiplicity__Group__0(); + + state._fsp--; + + + } + + after(grammarAccess.getRangeMultiplicityAccess().getGroup()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleRangeMultiplicity" + + + // $ANTLR start "entryRuleExactMultiplicity" + // InternalProblem.g:553:1: entryRuleExactMultiplicity : ruleExactMultiplicity EOF ; + public final void entryRuleExactMultiplicity() throws RecognitionException { + try { + // InternalProblem.g:554:1: ( ruleExactMultiplicity EOF ) + // InternalProblem.g:555:1: ruleExactMultiplicity EOF + { + before(grammarAccess.getExactMultiplicityRule()); + pushFollow(FOLLOW_1); + ruleExactMultiplicity(); + + state._fsp--; + + after(grammarAccess.getExactMultiplicityRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleExactMultiplicity" + + + // $ANTLR start "ruleExactMultiplicity" + // InternalProblem.g:562:1: ruleExactMultiplicity : ( ( rule__ExactMultiplicity__ExactValueAssignment ) ) ; + public final void ruleExactMultiplicity() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:566:2: ( ( ( rule__ExactMultiplicity__ExactValueAssignment ) ) ) + // InternalProblem.g:567:2: ( ( rule__ExactMultiplicity__ExactValueAssignment ) ) + { + // InternalProblem.g:567:2: ( ( rule__ExactMultiplicity__ExactValueAssignment ) ) + // InternalProblem.g:568:3: ( rule__ExactMultiplicity__ExactValueAssignment ) + { + before(grammarAccess.getExactMultiplicityAccess().getExactValueAssignment()); + // InternalProblem.g:569:3: ( rule__ExactMultiplicity__ExactValueAssignment ) + // InternalProblem.g:569:4: rule__ExactMultiplicity__ExactValueAssignment + { + pushFollow(FOLLOW_2); + rule__ExactMultiplicity__ExactValueAssignment(); + + state._fsp--; + + + } + + after(grammarAccess.getExactMultiplicityAccess().getExactValueAssignment()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleExactMultiplicity" + + + // $ANTLR start "entryRuleUpperBound" + // InternalProblem.g:578:1: entryRuleUpperBound : ruleUpperBound EOF ; + public final void entryRuleUpperBound() throws RecognitionException { + try { + // InternalProblem.g:579:1: ( ruleUpperBound EOF ) + // InternalProblem.g:580:1: ruleUpperBound EOF + { + before(grammarAccess.getUpperBoundRule()); + pushFollow(FOLLOW_1); + ruleUpperBound(); + + state._fsp--; + + after(grammarAccess.getUpperBoundRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleUpperBound" + + + // $ANTLR start "ruleUpperBound" + // InternalProblem.g:587:1: ruleUpperBound : ( ( rule__UpperBound__Alternatives ) ) ; + public final void ruleUpperBound() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:591:2: ( ( ( rule__UpperBound__Alternatives ) ) ) + // InternalProblem.g:592:2: ( ( rule__UpperBound__Alternatives ) ) + { + // InternalProblem.g:592:2: ( ( rule__UpperBound__Alternatives ) ) + // InternalProblem.g:593:3: ( rule__UpperBound__Alternatives ) + { + before(grammarAccess.getUpperBoundAccess().getAlternatives()); + // InternalProblem.g:594:3: ( rule__UpperBound__Alternatives ) + // InternalProblem.g:594:4: rule__UpperBound__Alternatives + { + pushFollow(FOLLOW_2); + rule__UpperBound__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getUpperBoundAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleUpperBound" + + + // $ANTLR start "entryRuleQuotedOrUnquotedId" + // InternalProblem.g:603:1: entryRuleQuotedOrUnquotedId : ruleQuotedOrUnquotedId EOF ; + public final void entryRuleQuotedOrUnquotedId() throws RecognitionException { + try { + // InternalProblem.g:604:1: ( ruleQuotedOrUnquotedId EOF ) + // InternalProblem.g:605:1: ruleQuotedOrUnquotedId EOF + { + before(grammarAccess.getQuotedOrUnquotedIdRule()); + pushFollow(FOLLOW_1); + ruleQuotedOrUnquotedId(); + + state._fsp--; + + after(grammarAccess.getQuotedOrUnquotedIdRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleQuotedOrUnquotedId" + + + // $ANTLR start "ruleQuotedOrUnquotedId" + // InternalProblem.g:612:1: ruleQuotedOrUnquotedId : ( ( rule__QuotedOrUnquotedId__Alternatives ) ) ; + public final void ruleQuotedOrUnquotedId() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:616:2: ( ( ( rule__QuotedOrUnquotedId__Alternatives ) ) ) + // InternalProblem.g:617:2: ( ( rule__QuotedOrUnquotedId__Alternatives ) ) + { + // InternalProblem.g:617:2: ( ( rule__QuotedOrUnquotedId__Alternatives ) ) + // InternalProblem.g:618:3: ( rule__QuotedOrUnquotedId__Alternatives ) + { + before(grammarAccess.getQuotedOrUnquotedIdAccess().getAlternatives()); + // InternalProblem.g:619:3: ( rule__QuotedOrUnquotedId__Alternatives ) + // InternalProblem.g:619:4: rule__QuotedOrUnquotedId__Alternatives + { + pushFollow(FOLLOW_2); + rule__QuotedOrUnquotedId__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getQuotedOrUnquotedIdAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleQuotedOrUnquotedId" + + + // $ANTLR start "entryRuleQualifiedName" + // InternalProblem.g:628:1: entryRuleQualifiedName : ruleQualifiedName EOF ; + public final void entryRuleQualifiedName() throws RecognitionException { + try { + // InternalProblem.g:629:1: ( ruleQualifiedName EOF ) + // InternalProblem.g:630:1: ruleQualifiedName EOF + { + before(grammarAccess.getQualifiedNameRule()); + pushFollow(FOLLOW_1); + ruleQualifiedName(); + + state._fsp--; + + after(grammarAccess.getQualifiedNameRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleQualifiedName" + + + // $ANTLR start "ruleQualifiedName" + // InternalProblem.g:637:1: ruleQualifiedName : ( ( rule__QualifiedName__Alternatives ) ) ; + public final void ruleQualifiedName() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:641:2: ( ( ( rule__QualifiedName__Alternatives ) ) ) + // InternalProblem.g:642:2: ( ( rule__QualifiedName__Alternatives ) ) + { + // InternalProblem.g:642:2: ( ( rule__QualifiedName__Alternatives ) ) + // InternalProblem.g:643:3: ( rule__QualifiedName__Alternatives ) + { + before(grammarAccess.getQualifiedNameAccess().getAlternatives()); + // InternalProblem.g:644:3: ( rule__QualifiedName__Alternatives ) + // InternalProblem.g:644:4: rule__QualifiedName__Alternatives + { + pushFollow(FOLLOW_2); + rule__QualifiedName__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getQualifiedNameAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleQualifiedName" + + + // $ANTLR start "entryRuleIdentifier" + // InternalProblem.g:653:1: entryRuleIdentifier : ruleIdentifier EOF ; + public final void entryRuleIdentifier() throws RecognitionException { + try { + // InternalProblem.g:654:1: ( ruleIdentifier EOF ) + // InternalProblem.g:655:1: ruleIdentifier EOF + { + before(grammarAccess.getIdentifierRule()); + pushFollow(FOLLOW_1); + ruleIdentifier(); + + state._fsp--; + + after(grammarAccess.getIdentifierRule()); + match(input,EOF,FOLLOW_2); + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleIdentifier" + + + // $ANTLR start "ruleIdentifier" + // InternalProblem.g:662:1: ruleIdentifier : ( ( rule__Identifier__Alternatives ) ) ; + public final void ruleIdentifier() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:666:2: ( ( ( rule__Identifier__Alternatives ) ) ) + // InternalProblem.g:667:2: ( ( rule__Identifier__Alternatives ) ) + { + // InternalProblem.g:667:2: ( ( rule__Identifier__Alternatives ) ) + // InternalProblem.g:668:3: ( rule__Identifier__Alternatives ) + { + before(grammarAccess.getIdentifierAccess().getAlternatives()); + // InternalProblem.g:669:3: ( rule__Identifier__Alternatives ) + // InternalProblem.g:669:4: rule__Identifier__Alternatives + { + pushFollow(FOLLOW_2); + rule__Identifier__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getIdentifierAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleIdentifier" + + + // $ANTLR start "ruleLogicValue" + // InternalProblem.g:678:1: ruleLogicValue : ( ( rule__LogicValue__Alternatives ) ) ; + public final void ruleLogicValue() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:682:1: ( ( ( rule__LogicValue__Alternatives ) ) ) + // InternalProblem.g:683:2: ( ( rule__LogicValue__Alternatives ) ) + { + // InternalProblem.g:683:2: ( ( rule__LogicValue__Alternatives ) ) + // InternalProblem.g:684:3: ( rule__LogicValue__Alternatives ) + { + before(grammarAccess.getLogicValueAccess().getAlternatives()); + // InternalProblem.g:685:3: ( rule__LogicValue__Alternatives ) + // InternalProblem.g:685:4: rule__LogicValue__Alternatives + { + pushFollow(FOLLOW_2); + rule__LogicValue__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getLogicValueAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleLogicValue" + + + // $ANTLR start "ruleShortLogicValue" + // InternalProblem.g:694:1: ruleShortLogicValue : ( ( rule__ShortLogicValue__Alternatives ) ) ; + public final void ruleShortLogicValue() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:698:1: ( ( ( rule__ShortLogicValue__Alternatives ) ) ) + // InternalProblem.g:699:2: ( ( rule__ShortLogicValue__Alternatives ) ) + { + // InternalProblem.g:699:2: ( ( rule__ShortLogicValue__Alternatives ) ) + // InternalProblem.g:700:3: ( rule__ShortLogicValue__Alternatives ) + { + before(grammarAccess.getShortLogicValueAccess().getAlternatives()); + // InternalProblem.g:701:3: ( rule__ShortLogicValue__Alternatives ) + // InternalProblem.g:701:4: rule__ShortLogicValue__Alternatives + { + pushFollow(FOLLOW_2); + rule__ShortLogicValue__Alternatives(); + + state._fsp--; + + + } + + after(grammarAccess.getShortLogicValueAccess().getAlternatives()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleShortLogicValue" + + + // $ANTLR start "rule__Statement__Alternatives" + // InternalProblem.g:709:1: rule__Statement__Alternatives : ( ( ruleClassDeclaration ) | ( ruleEnumDeclaration ) | ( rulePredicateDefinition ) | ( ruleAssertion ) | ( ruleScopeDeclaration ) ); + public final void rule__Statement__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:713:1: ( ( ruleClassDeclaration ) | ( ruleEnumDeclaration ) | ( rulePredicateDefinition ) | ( ruleAssertion ) | ( ruleScopeDeclaration ) ) + int alt1=5; + switch ( input.LA(1) ) { + case 25: + case 39: + { + alt1=1; + } + break; + case 29: + { + alt1=2; + } + break; + case 16: + case 41: + { + alt1=3; + } + break; + case RULE_QUOTED_ID: + case RULE_ID: + case 19: + case 20: + case 22: + case 23: + { + alt1=4; + } + break; + case 37: + { + alt1=5; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 1, 0, input); + + throw nvae; + } + + switch (alt1) { + case 1 : + // InternalProblem.g:714:2: ( ruleClassDeclaration ) + { + // InternalProblem.g:714:2: ( ruleClassDeclaration ) + // InternalProblem.g:715:3: ruleClassDeclaration + { + before(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleClassDeclaration(); + + state._fsp--; + + after(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalProblem.g:720:2: ( ruleEnumDeclaration ) + { + // InternalProblem.g:720:2: ( ruleEnumDeclaration ) + // InternalProblem.g:721:3: ruleEnumDeclaration + { + before(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleEnumDeclaration(); + + state._fsp--; + + after(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_1()); + + } + + + } + break; + case 3 : + // InternalProblem.g:726:2: ( rulePredicateDefinition ) + { + // InternalProblem.g:726:2: ( rulePredicateDefinition ) + // InternalProblem.g:727:3: rulePredicateDefinition + { + before(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_2()); + pushFollow(FOLLOW_2); + rulePredicateDefinition(); + + state._fsp--; + + after(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_2()); + + } + + + } + break; + case 4 : + // InternalProblem.g:732:2: ( ruleAssertion ) + { + // InternalProblem.g:732:2: ( ruleAssertion ) + // InternalProblem.g:733:3: ruleAssertion + { + before(grammarAccess.getStatementAccess().getAssertionParserRuleCall_3()); + pushFollow(FOLLOW_2); + ruleAssertion(); + + state._fsp--; + + after(grammarAccess.getStatementAccess().getAssertionParserRuleCall_3()); + + } + + + } + break; + case 5 : + // InternalProblem.g:738:2: ( ruleScopeDeclaration ) + { + // InternalProblem.g:738:2: ( ruleScopeDeclaration ) + // InternalProblem.g:739:3: ruleScopeDeclaration + { + before(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_4()); + pushFollow(FOLLOW_2); + ruleScopeDeclaration(); + + state._fsp--; + + after(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_4()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Statement__Alternatives" + + + // $ANTLR start "rule__ClassDeclaration__Alternatives_4" + // InternalProblem.g:748:1: rule__ClassDeclaration__Alternatives_4 : ( ( ( rule__ClassDeclaration__Group_4_0__0 ) ) | ( '.' ) ); + public final void rule__ClassDeclaration__Alternatives_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:752:1: ( ( ( rule__ClassDeclaration__Group_4_0__0 ) ) | ( '.' ) ) + int alt2=2; + int LA2_0 = input.LA(1); + + if ( (LA2_0==27) ) { + alt2=1; + } + else if ( (LA2_0==12) ) { + alt2=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 2, 0, input); + + throw nvae; + } + switch (alt2) { + case 1 : + // InternalProblem.g:753:2: ( ( rule__ClassDeclaration__Group_4_0__0 ) ) + { + // InternalProblem.g:753:2: ( ( rule__ClassDeclaration__Group_4_0__0 ) ) + // InternalProblem.g:754:3: ( rule__ClassDeclaration__Group_4_0__0 ) + { + before(grammarAccess.getClassDeclarationAccess().getGroup_4_0()); + // InternalProblem.g:755:3: ( rule__ClassDeclaration__Group_4_0__0 ) + // InternalProblem.g:755:4: rule__ClassDeclaration__Group_4_0__0 + { + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group_4_0__0(); + + state._fsp--; + + + } + + after(grammarAccess.getClassDeclarationAccess().getGroup_4_0()); + + } + + + } + break; + case 2 : + // InternalProblem.g:759:2: ( '.' ) + { + // InternalProblem.g:759:2: ( '.' ) + // InternalProblem.g:760:3: '.' + { + before(grammarAccess.getClassDeclarationAccess().getFullStopKeyword_4_1()); + match(input,12,FOLLOW_2); + after(grammarAccess.getClassDeclarationAccess().getFullStopKeyword_4_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Alternatives_4" + + + // $ANTLR start "rule__EnumDeclaration__Alternatives_2" + // InternalProblem.g:769:1: rule__EnumDeclaration__Alternatives_2 : ( ( ( rule__EnumDeclaration__Group_2_0__0 ) ) | ( '.' ) ); + public final void rule__EnumDeclaration__Alternatives_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:773:1: ( ( ( rule__EnumDeclaration__Group_2_0__0 ) ) | ( '.' ) ) + int alt3=2; + int LA3_0 = input.LA(1); + + if ( (LA3_0==27) ) { + alt3=1; + } + else if ( (LA3_0==12) ) { + alt3=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 3, 0, input); + + throw nvae; + } + switch (alt3) { + case 1 : + // InternalProblem.g:774:2: ( ( rule__EnumDeclaration__Group_2_0__0 ) ) + { + // InternalProblem.g:774:2: ( ( rule__EnumDeclaration__Group_2_0__0 ) ) + // InternalProblem.g:775:3: ( rule__EnumDeclaration__Group_2_0__0 ) + { + before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0()); + // InternalProblem.g:776:3: ( rule__EnumDeclaration__Group_2_0__0 ) + // InternalProblem.g:776:4: rule__EnumDeclaration__Group_2_0__0 + { + pushFollow(FOLLOW_2); + rule__EnumDeclaration__Group_2_0__0(); + + state._fsp--; + + + } + + after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0()); + + } + + + } + break; + case 2 : + // InternalProblem.g:780:2: ( '.' ) + { + // InternalProblem.g:780:2: ( '.' ) + // InternalProblem.g:781:3: '.' + { + before(grammarAccess.getEnumDeclarationAccess().getFullStopKeyword_2_1()); + match(input,12,FOLLOW_2); + after(grammarAccess.getEnumDeclarationAccess().getFullStopKeyword_2_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Alternatives_2" + + + // $ANTLR start "rule__EnumDeclaration__Alternatives_2_0_1_2" + // InternalProblem.g:790:1: rule__EnumDeclaration__Alternatives_2_0_1_2 : ( ( ',' ) | ( ';' ) ); + public final void rule__EnumDeclaration__Alternatives_2_0_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:794:1: ( ( ',' ) | ( ';' ) ) + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0==13) ) { + alt4=1; + } + else if ( (LA4_0==14) ) { + alt4=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 4, 0, input); + + throw nvae; + } + switch (alt4) { + case 1 : + // InternalProblem.g:795:2: ( ',' ) + { + // InternalProblem.g:795:2: ( ',' ) + // InternalProblem.g:796:3: ',' + { + before(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_2_0()); + match(input,13,FOLLOW_2); + after(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_2_0()); + + } + + + } + break; + case 2 : + // InternalProblem.g:801:2: ( ';' ) + { + // InternalProblem.g:801:2: ( ';' ) + // InternalProblem.g:802:3: ';' + { + before(grammarAccess.getEnumDeclarationAccess().getSemicolonKeyword_2_0_1_2_1()); + match(input,14,FOLLOW_2); + after(grammarAccess.getEnumDeclarationAccess().getSemicolonKeyword_2_0_1_2_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Alternatives_2_0_1_2" + + + // $ANTLR start "rule__ReferenceDeclaration__Alternatives_0" + // InternalProblem.g:811:1: rule__ReferenceDeclaration__Alternatives_0 : ( ( ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) ) | ( 'refers' ) ); + public final void rule__ReferenceDeclaration__Alternatives_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:815:1: ( ( ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) ) | ( 'refers' ) ) + int alt5=2; + int LA5_0 = input.LA(1); + + if ( (LA5_0==40) ) { + alt5=1; + } + else if ( (LA5_0==15) ) { + alt5=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 5, 0, input); + + throw nvae; + } + switch (alt5) { + case 1 : + // InternalProblem.g:816:2: ( ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) ) + { + // InternalProblem.g:816:2: ( ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) ) + // InternalProblem.g:817:3: ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) + { + before(grammarAccess.getReferenceDeclarationAccess().getContainmentAssignment_0_0()); + // InternalProblem.g:818:3: ( rule__ReferenceDeclaration__ContainmentAssignment_0_0 ) + // InternalProblem.g:818:4: rule__ReferenceDeclaration__ContainmentAssignment_0_0 + { + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__ContainmentAssignment_0_0(); + + state._fsp--; + + + } + + after(grammarAccess.getReferenceDeclarationAccess().getContainmentAssignment_0_0()); + + } + + + } + break; + case 2 : + // InternalProblem.g:822:2: ( 'refers' ) + { + // InternalProblem.g:822:2: ( 'refers' ) + // InternalProblem.g:823:3: 'refers' + { + before(grammarAccess.getReferenceDeclarationAccess().getRefersKeyword_0_1()); + match(input,15,FOLLOW_2); + after(grammarAccess.getReferenceDeclarationAccess().getRefersKeyword_0_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Alternatives_0" + + + // $ANTLR start "rule__PredicateDefinition__Alternatives_0" + // InternalProblem.g:832:1: rule__PredicateDefinition__Alternatives_0 : ( ( ( rule__PredicateDefinition__Group_0_0__0 ) ) | ( 'pred' ) ); + public final void rule__PredicateDefinition__Alternatives_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:836:1: ( ( ( rule__PredicateDefinition__Group_0_0__0 ) ) | ( 'pred' ) ) + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0==41) ) { + alt6=1; + } + else if ( (LA6_0==16) ) { + alt6=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 6, 0, input); + + throw nvae; + } + switch (alt6) { + case 1 : + // InternalProblem.g:837:2: ( ( rule__PredicateDefinition__Group_0_0__0 ) ) + { + // InternalProblem.g:837:2: ( ( rule__PredicateDefinition__Group_0_0__0 ) ) + // InternalProblem.g:838:3: ( rule__PredicateDefinition__Group_0_0__0 ) + { + before(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); + // InternalProblem.g:839:3: ( rule__PredicateDefinition__Group_0_0__0 ) + // InternalProblem.g:839:4: rule__PredicateDefinition__Group_0_0__0 + { + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group_0_0__0(); + + state._fsp--; + + + } + + after(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); + + } + + + } + break; + case 2 : + // InternalProblem.g:843:2: ( 'pred' ) + { + // InternalProblem.g:843:2: ( 'pred' ) + // InternalProblem.g:844:3: 'pred' + { + before(grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_1()); + match(input,16,FOLLOW_2); + after(grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Alternatives_0" + + + // $ANTLR start "rule__Literal__Alternatives" + // InternalProblem.g:853:1: rule__Literal__Alternatives : ( ( ruleAtom ) | ( ruleNegativeLiteral ) ); + public final void rule__Literal__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:857:1: ( ( ruleAtom ) | ( ruleNegativeLiteral ) ) + int alt7=2; + int LA7_0 = input.LA(1); + + if ( ((LA7_0>=RULE_QUOTED_ID && LA7_0<=RULE_ID)||(LA7_0>=19 && LA7_0<=20)) ) { + alt7=1; + } + else if ( (LA7_0==22) ) { + alt7=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 7, 0, input); + + throw nvae; + } + switch (alt7) { + case 1 : + // InternalProblem.g:858:2: ( ruleAtom ) + { + // InternalProblem.g:858:2: ( ruleAtom ) + // InternalProblem.g:859:3: ruleAtom + { + before(grammarAccess.getLiteralAccess().getAtomParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleAtom(); + + state._fsp--; + + after(grammarAccess.getLiteralAccess().getAtomParserRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalProblem.g:864:2: ( ruleNegativeLiteral ) + { + // InternalProblem.g:864:2: ( ruleNegativeLiteral ) + // InternalProblem.g:865:3: ruleNegativeLiteral + { + before(grammarAccess.getLiteralAccess().getNegativeLiteralParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleNegativeLiteral(); + + state._fsp--; + + after(grammarAccess.getLiteralAccess().getNegativeLiteralParserRuleCall_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Literal__Alternatives" + + + // $ANTLR start "rule__Assertion__Alternatives_0" + // InternalProblem.g:874:1: rule__Assertion__Alternatives_0 : ( ( ( rule__Assertion__Group_0_0__0 ) ) | ( ( rule__Assertion__Group_0_1__0 ) ) ); + public final void rule__Assertion__Alternatives_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:878:1: ( ( ( rule__Assertion__Group_0_0__0 ) ) | ( ( rule__Assertion__Group_0_1__0 ) ) ) + int alt8=2; + alt8 = dfa8.predict(input); + switch (alt8) { + case 1 : + // InternalProblem.g:879:2: ( ( rule__Assertion__Group_0_0__0 ) ) + { + // InternalProblem.g:879:2: ( ( rule__Assertion__Group_0_0__0 ) ) + // InternalProblem.g:880:3: ( rule__Assertion__Group_0_0__0 ) + { + before(grammarAccess.getAssertionAccess().getGroup_0_0()); + // InternalProblem.g:881:3: ( rule__Assertion__Group_0_0__0 ) + // InternalProblem.g:881:4: rule__Assertion__Group_0_0__0 + { + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_0__0(); + + state._fsp--; + + + } + + after(grammarAccess.getAssertionAccess().getGroup_0_0()); + + } + + + } + break; + case 2 : + // InternalProblem.g:885:2: ( ( rule__Assertion__Group_0_1__0 ) ) + { + // InternalProblem.g:885:2: ( ( rule__Assertion__Group_0_1__0 ) ) + // InternalProblem.g:886:3: ( rule__Assertion__Group_0_1__0 ) + { + before(grammarAccess.getAssertionAccess().getGroup_0_1()); + // InternalProblem.g:887:3: ( rule__Assertion__Group_0_1__0 ) + // InternalProblem.g:887:4: rule__Assertion__Group_0_1__0 + { + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_1__0(); + + state._fsp--; + + + } + + after(grammarAccess.getAssertionAccess().getGroup_0_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Alternatives_0" + + + // $ANTLR start "rule__TypeScope__Alternatives_1" + // InternalProblem.g:895:1: rule__TypeScope__Alternatives_1 : ( ( ( rule__TypeScope__IncrementAssignment_1_0 ) ) | ( '=' ) ); + public final void rule__TypeScope__Alternatives_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:899:1: ( ( ( rule__TypeScope__IncrementAssignment_1_0 ) ) | ( '=' ) ) + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0==43) ) { + alt9=1; + } + else if ( (LA9_0==17) ) { + alt9=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 9, 0, input); + + throw nvae; + } + switch (alt9) { + case 1 : + // InternalProblem.g:900:2: ( ( rule__TypeScope__IncrementAssignment_1_0 ) ) + { + // InternalProblem.g:900:2: ( ( rule__TypeScope__IncrementAssignment_1_0 ) ) + // InternalProblem.g:901:3: ( rule__TypeScope__IncrementAssignment_1_0 ) + { + before(grammarAccess.getTypeScopeAccess().getIncrementAssignment_1_0()); + // InternalProblem.g:902:3: ( rule__TypeScope__IncrementAssignment_1_0 ) + // InternalProblem.g:902:4: rule__TypeScope__IncrementAssignment_1_0 + { + pushFollow(FOLLOW_2); + rule__TypeScope__IncrementAssignment_1_0(); + + state._fsp--; + + + } + + after(grammarAccess.getTypeScopeAccess().getIncrementAssignment_1_0()); + + } + + + } + break; + case 2 : + // InternalProblem.g:906:2: ( '=' ) + { + // InternalProblem.g:906:2: ( '=' ) + // InternalProblem.g:907:3: '=' + { + before(grammarAccess.getTypeScopeAccess().getEqualsSignKeyword_1_1()); + match(input,17,FOLLOW_2); + after(grammarAccess.getTypeScopeAccess().getEqualsSignKeyword_1_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeScope__Alternatives_1" + + + // $ANTLR start "rule__Multiplicity__Alternatives" + // InternalProblem.g:916:1: rule__Multiplicity__Alternatives : ( ( ruleUnboundedMultiplicity ) | ( ruleDefiniteMultiplicity ) ); + public final void rule__Multiplicity__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:920:1: ( ( ruleUnboundedMultiplicity ) | ( ruleDefiniteMultiplicity ) ) + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0==EOF||LA10_0==31) ) { + alt10=1; + } + else if ( (LA10_0==RULE_INT) ) { + alt10=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 10, 0, input); + + throw nvae; + } + switch (alt10) { + case 1 : + // InternalProblem.g:921:2: ( ruleUnboundedMultiplicity ) + { + // InternalProblem.g:921:2: ( ruleUnboundedMultiplicity ) + // InternalProblem.g:922:3: ruleUnboundedMultiplicity + { + before(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleUnboundedMultiplicity(); + + state._fsp--; + + after(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalProblem.g:927:2: ( ruleDefiniteMultiplicity ) + { + // InternalProblem.g:927:2: ( ruleDefiniteMultiplicity ) + // InternalProblem.g:928:3: ruleDefiniteMultiplicity + { + before(grammarAccess.getMultiplicityAccess().getDefiniteMultiplicityParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleDefiniteMultiplicity(); + + state._fsp--; + + after(grammarAccess.getMultiplicityAccess().getDefiniteMultiplicityParserRuleCall_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Multiplicity__Alternatives" + + + // $ANTLR start "rule__DefiniteMultiplicity__Alternatives" + // InternalProblem.g:937:1: rule__DefiniteMultiplicity__Alternatives : ( ( ruleRangeMultiplicity ) | ( ruleExactMultiplicity ) ); + public final void rule__DefiniteMultiplicity__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:941:1: ( ( ruleRangeMultiplicity ) | ( ruleExactMultiplicity ) ) + int alt11=2; + int LA11_0 = input.LA(1); + + if ( (LA11_0==RULE_INT) ) { + int LA11_1 = input.LA(2); + + if ( (LA11_1==38) ) { + alt11=1; + } + else if ( (LA11_1==EOF||(LA11_1>=12 && LA11_1<=13)||LA11_1==31) ) { + alt11=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 11, 1, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 11, 0, input); + + throw nvae; + } + switch (alt11) { + case 1 : + // InternalProblem.g:942:2: ( ruleRangeMultiplicity ) + { + // InternalProblem.g:942:2: ( ruleRangeMultiplicity ) + // InternalProblem.g:943:3: ruleRangeMultiplicity + { + before(grammarAccess.getDefiniteMultiplicityAccess().getRangeMultiplicityParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleRangeMultiplicity(); + + state._fsp--; + + after(grammarAccess.getDefiniteMultiplicityAccess().getRangeMultiplicityParserRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalProblem.g:948:2: ( ruleExactMultiplicity ) + { + // InternalProblem.g:948:2: ( ruleExactMultiplicity ) + // InternalProblem.g:949:3: ruleExactMultiplicity + { + before(grammarAccess.getDefiniteMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleExactMultiplicity(); + + state._fsp--; + + after(grammarAccess.getDefiniteMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__DefiniteMultiplicity__Alternatives" + + + // $ANTLR start "rule__UpperBound__Alternatives" + // InternalProblem.g:958:1: rule__UpperBound__Alternatives : ( ( RULE_INT ) | ( '*' ) ); + public final void rule__UpperBound__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:962:1: ( ( RULE_INT ) | ( '*' ) ) + int alt12=2; + int LA12_0 = input.LA(1); + + if ( (LA12_0==RULE_INT) ) { + alt12=1; + } + else if ( (LA12_0==18) ) { + alt12=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 12, 0, input); + + throw nvae; + } + switch (alt12) { + case 1 : + // InternalProblem.g:963:2: ( RULE_INT ) + { + // InternalProblem.g:963:2: ( RULE_INT ) + // InternalProblem.g:964:3: RULE_INT + { + before(grammarAccess.getUpperBoundAccess().getINTTerminalRuleCall_0()); + match(input,RULE_INT,FOLLOW_2); + after(grammarAccess.getUpperBoundAccess().getINTTerminalRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalProblem.g:969:2: ( '*' ) + { + // InternalProblem.g:969:2: ( '*' ) + // InternalProblem.g:970:3: '*' + { + before(grammarAccess.getUpperBoundAccess().getAsteriskKeyword_1()); + match(input,18,FOLLOW_2); + after(grammarAccess.getUpperBoundAccess().getAsteriskKeyword_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__UpperBound__Alternatives" + + + // $ANTLR start "rule__QuotedOrUnquotedId__Alternatives" + // InternalProblem.g:979:1: rule__QuotedOrUnquotedId__Alternatives : ( ( RULE_QUOTED_ID ) | ( ruleIdentifier ) ); + public final void rule__QuotedOrUnquotedId__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:983:1: ( ( RULE_QUOTED_ID ) | ( ruleIdentifier ) ) + int alt13=2; + int LA13_0 = input.LA(1); + + if ( (LA13_0==RULE_QUOTED_ID) ) { + alt13=1; + } + else if ( (LA13_0==RULE_ID||(LA13_0>=19 && LA13_0<=20)) ) { + alt13=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 13, 0, input); + + throw nvae; + } + switch (alt13) { + case 1 : + // InternalProblem.g:984:2: ( RULE_QUOTED_ID ) + { + // InternalProblem.g:984:2: ( RULE_QUOTED_ID ) + // InternalProblem.g:985:3: RULE_QUOTED_ID + { + before(grammarAccess.getQuotedOrUnquotedIdAccess().getQUOTED_IDTerminalRuleCall_0()); + match(input,RULE_QUOTED_ID,FOLLOW_2); + after(grammarAccess.getQuotedOrUnquotedIdAccess().getQUOTED_IDTerminalRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalProblem.g:990:2: ( ruleIdentifier ) + { + // InternalProblem.g:990:2: ( ruleIdentifier ) + // InternalProblem.g:991:3: ruleIdentifier + { + before(grammarAccess.getQuotedOrUnquotedIdAccess().getIdentifierParserRuleCall_1()); + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + + after(grammarAccess.getQuotedOrUnquotedIdAccess().getIdentifierParserRuleCall_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QuotedOrUnquotedId__Alternatives" + + + // $ANTLR start "rule__QualifiedName__Alternatives" + // InternalProblem.g:1000:1: rule__QualifiedName__Alternatives : ( ( RULE_QUOTED_ID ) | ( ( rule__QualifiedName__Group_1__0 ) ) ); + public final void rule__QualifiedName__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1004:1: ( ( RULE_QUOTED_ID ) | ( ( rule__QualifiedName__Group_1__0 ) ) ) + int alt14=2; + int LA14_0 = input.LA(1); + + if ( (LA14_0==RULE_QUOTED_ID) ) { + alt14=1; + } + else if ( (LA14_0==RULE_ID||(LA14_0>=19 && LA14_0<=20)) ) { + alt14=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 14, 0, input); + + throw nvae; + } + switch (alt14) { + case 1 : + // InternalProblem.g:1005:2: ( RULE_QUOTED_ID ) + { + // InternalProblem.g:1005:2: ( RULE_QUOTED_ID ) + // InternalProblem.g:1006:3: RULE_QUOTED_ID + { + before(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_0()); + match(input,RULE_QUOTED_ID,FOLLOW_2); + after(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalProblem.g:1011:2: ( ( rule__QualifiedName__Group_1__0 ) ) + { + // InternalProblem.g:1011:2: ( ( rule__QualifiedName__Group_1__0 ) ) + // InternalProblem.g:1012:3: ( rule__QualifiedName__Group_1__0 ) + { + before(grammarAccess.getQualifiedNameAccess().getGroup_1()); + // InternalProblem.g:1013:3: ( rule__QualifiedName__Group_1__0 ) + // InternalProblem.g:1013:4: rule__QualifiedName__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1__0(); + + state._fsp--; + + + } + + after(grammarAccess.getQualifiedNameAccess().getGroup_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Alternatives" + + + // $ANTLR start "rule__Identifier__Alternatives" + // InternalProblem.g:1021:1: rule__Identifier__Alternatives : ( ( RULE_ID ) | ( 'true' ) | ( 'false' ) ); + public final void rule__Identifier__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1025:1: ( ( RULE_ID ) | ( 'true' ) | ( 'false' ) ) + int alt15=3; + switch ( input.LA(1) ) { + case RULE_ID: + { + alt15=1; + } + break; + case 19: + { + alt15=2; + } + break; + case 20: + { + alt15=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 15, 0, input); + + throw nvae; + } + + switch (alt15) { + case 1 : + // InternalProblem.g:1026:2: ( RULE_ID ) + { + // InternalProblem.g:1026:2: ( RULE_ID ) + // InternalProblem.g:1027:3: RULE_ID + { + before(grammarAccess.getIdentifierAccess().getIDTerminalRuleCall_0()); + match(input,RULE_ID,FOLLOW_2); + after(grammarAccess.getIdentifierAccess().getIDTerminalRuleCall_0()); + + } + + + } + break; + case 2 : + // InternalProblem.g:1032:2: ( 'true' ) + { + // InternalProblem.g:1032:2: ( 'true' ) + // InternalProblem.g:1033:3: 'true' + { + before(grammarAccess.getIdentifierAccess().getTrueKeyword_1()); + match(input,19,FOLLOW_2); + after(grammarAccess.getIdentifierAccess().getTrueKeyword_1()); + + } + + + } + break; + case 3 : + // InternalProblem.g:1038:2: ( 'false' ) + { + // InternalProblem.g:1038:2: ( 'false' ) + // InternalProblem.g:1039:3: 'false' + { + before(grammarAccess.getIdentifierAccess().getFalseKeyword_2()); + match(input,20,FOLLOW_2); + after(grammarAccess.getIdentifierAccess().getFalseKeyword_2()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Identifier__Alternatives" + + + // $ANTLR start "rule__LogicValue__Alternatives" + // InternalProblem.g:1048:1: rule__LogicValue__Alternatives : ( ( ( 'true' ) ) | ( ( 'false' ) ) | ( ( 'unknown' ) ) ); + public final void rule__LogicValue__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1052:1: ( ( ( 'true' ) ) | ( ( 'false' ) ) | ( ( 'unknown' ) ) ) + int alt16=3; + switch ( input.LA(1) ) { + case 19: + { + alt16=1; + } + break; + case 20: + { + alt16=2; + } + break; + case 21: + { + alt16=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 16, 0, input); + + throw nvae; + } + + switch (alt16) { + case 1 : + // InternalProblem.g:1053:2: ( ( 'true' ) ) + { + // InternalProblem.g:1053:2: ( ( 'true' ) ) + // InternalProblem.g:1054:3: ( 'true' ) + { + before(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); + // InternalProblem.g:1055:3: ( 'true' ) + // InternalProblem.g:1055:4: 'true' + { + match(input,19,FOLLOW_2); + + } + + after(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); + + } + + + } + break; + case 2 : + // InternalProblem.g:1059:2: ( ( 'false' ) ) + { + // InternalProblem.g:1059:2: ( ( 'false' ) ) + // InternalProblem.g:1060:3: ( 'false' ) + { + before(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); + // InternalProblem.g:1061:3: ( 'false' ) + // InternalProblem.g:1061:4: 'false' + { + match(input,20,FOLLOW_2); + + } + + after(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); + + } + + + } + break; + case 3 : + // InternalProblem.g:1065:2: ( ( 'unknown' ) ) + { + // InternalProblem.g:1065:2: ( ( 'unknown' ) ) + // InternalProblem.g:1066:3: ( 'unknown' ) + { + before(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); + // InternalProblem.g:1067:3: ( 'unknown' ) + // InternalProblem.g:1067:4: 'unknown' + { + match(input,21,FOLLOW_2); + + } + + after(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__LogicValue__Alternatives" + + + // $ANTLR start "rule__ShortLogicValue__Alternatives" + // InternalProblem.g:1075:1: rule__ShortLogicValue__Alternatives : ( ( ( '!' ) ) | ( ( '?' ) ) ); + public final void rule__ShortLogicValue__Alternatives() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1079:1: ( ( ( '!' ) ) | ( ( '?' ) ) ) + int alt17=2; + int LA17_0 = input.LA(1); + + if ( (LA17_0==22) ) { + alt17=1; + } + else if ( (LA17_0==23) ) { + alt17=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 17, 0, input); + + throw nvae; + } + switch (alt17) { + case 1 : + // InternalProblem.g:1080:2: ( ( '!' ) ) + { + // InternalProblem.g:1080:2: ( ( '!' ) ) + // InternalProblem.g:1081:3: ( '!' ) + { + before(grammarAccess.getShortLogicValueAccess().getFALSEEnumLiteralDeclaration_0()); + // InternalProblem.g:1082:3: ( '!' ) + // InternalProblem.g:1082:4: '!' + { + match(input,22,FOLLOW_2); + + } + + after(grammarAccess.getShortLogicValueAccess().getFALSEEnumLiteralDeclaration_0()); + + } + + + } + break; + case 2 : + // InternalProblem.g:1086:2: ( ( '?' ) ) + { + // InternalProblem.g:1086:2: ( ( '?' ) ) + // InternalProblem.g:1087:3: ( '?' ) + { + before(grammarAccess.getShortLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_1()); + // InternalProblem.g:1088:3: ( '?' ) + // InternalProblem.g:1088:4: '?' + { + match(input,23,FOLLOW_2); + + } + + after(grammarAccess.getShortLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_1()); + + } + + + } + break; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ShortLogicValue__Alternatives" + + + // $ANTLR start "rule__Problem__Group__0" + // InternalProblem.g:1096:1: rule__Problem__Group__0 : rule__Problem__Group__0__Impl rule__Problem__Group__1 ; + public final void rule__Problem__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1100:1: ( rule__Problem__Group__0__Impl rule__Problem__Group__1 ) + // InternalProblem.g:1101:2: rule__Problem__Group__0__Impl rule__Problem__Group__1 + { + pushFollow(FOLLOW_3); + rule__Problem__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Problem__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Problem__Group__0" + + + // $ANTLR start "rule__Problem__Group__0__Impl" + // InternalProblem.g:1108:1: rule__Problem__Group__0__Impl : ( ( rule__Problem__Group_0__0 )? ) ; + public final void rule__Problem__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1112:1: ( ( ( rule__Problem__Group_0__0 )? ) ) + // InternalProblem.g:1113:1: ( ( rule__Problem__Group_0__0 )? ) + { + // InternalProblem.g:1113:1: ( ( rule__Problem__Group_0__0 )? ) + // InternalProblem.g:1114:2: ( rule__Problem__Group_0__0 )? + { + before(grammarAccess.getProblemAccess().getGroup_0()); + // InternalProblem.g:1115:2: ( rule__Problem__Group_0__0 )? + int alt18=2; + int LA18_0 = input.LA(1); + + if ( (LA18_0==24) ) { + alt18=1; + } + switch (alt18) { + case 1 : + // InternalProblem.g:1115:3: rule__Problem__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__Problem__Group_0__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getProblemAccess().getGroup_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Problem__Group__0__Impl" + + + // $ANTLR start "rule__Problem__Group__1" + // InternalProblem.g:1123:1: rule__Problem__Group__1 : rule__Problem__Group__1__Impl ; + public final void rule__Problem__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1127:1: ( rule__Problem__Group__1__Impl ) + // InternalProblem.g:1128:2: rule__Problem__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Problem__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Problem__Group__1" + + + // $ANTLR start "rule__Problem__Group__1__Impl" + // InternalProblem.g:1134:1: rule__Problem__Group__1__Impl : ( ( rule__Problem__StatementsAssignment_1 )* ) ; + public final void rule__Problem__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1138:1: ( ( ( rule__Problem__StatementsAssignment_1 )* ) ) + // InternalProblem.g:1139:1: ( ( rule__Problem__StatementsAssignment_1 )* ) + { + // InternalProblem.g:1139:1: ( ( rule__Problem__StatementsAssignment_1 )* ) + // InternalProblem.g:1140:2: ( rule__Problem__StatementsAssignment_1 )* + { + before(grammarAccess.getProblemAccess().getStatementsAssignment_1()); + // InternalProblem.g:1141:2: ( rule__Problem__StatementsAssignment_1 )* + loop19: + do { + int alt19=2; + int LA19_0 = input.LA(1); + + if ( ((LA19_0>=RULE_QUOTED_ID && LA19_0<=RULE_ID)||LA19_0==16||(LA19_0>=19 && LA19_0<=20)||(LA19_0>=22 && LA19_0<=23)||LA19_0==25||LA19_0==29||LA19_0==37||LA19_0==39||LA19_0==41) ) { + alt19=1; + } + + + switch (alt19) { + case 1 : + // InternalProblem.g:1141:3: rule__Problem__StatementsAssignment_1 + { + pushFollow(FOLLOW_4); + rule__Problem__StatementsAssignment_1(); + + state._fsp--; + + + } + break; + + default : + break loop19; + } + } while (true); + + after(grammarAccess.getProblemAccess().getStatementsAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Problem__Group__1__Impl" + + + // $ANTLR start "rule__Problem__Group_0__0" + // InternalProblem.g:1150:1: rule__Problem__Group_0__0 : rule__Problem__Group_0__0__Impl rule__Problem__Group_0__1 ; + public final void rule__Problem__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1154:1: ( rule__Problem__Group_0__0__Impl rule__Problem__Group_0__1 ) + // InternalProblem.g:1155:2: rule__Problem__Group_0__0__Impl rule__Problem__Group_0__1 + { + pushFollow(FOLLOW_5); + rule__Problem__Group_0__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Problem__Group_0__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Problem__Group_0__0" + + + // $ANTLR start "rule__Problem__Group_0__0__Impl" + // InternalProblem.g:1162:1: rule__Problem__Group_0__0__Impl : ( 'problem' ) ; + public final void rule__Problem__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1166:1: ( ( 'problem' ) ) + // InternalProblem.g:1167:1: ( 'problem' ) + { + // InternalProblem.g:1167:1: ( 'problem' ) + // InternalProblem.g:1168:2: 'problem' + { + before(grammarAccess.getProblemAccess().getProblemKeyword_0_0()); + match(input,24,FOLLOW_2); + after(grammarAccess.getProblemAccess().getProblemKeyword_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Problem__Group_0__0__Impl" + + + // $ANTLR start "rule__Problem__Group_0__1" + // InternalProblem.g:1177:1: rule__Problem__Group_0__1 : rule__Problem__Group_0__1__Impl rule__Problem__Group_0__2 ; + public final void rule__Problem__Group_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1181:1: ( rule__Problem__Group_0__1__Impl rule__Problem__Group_0__2 ) + // InternalProblem.g:1182:2: rule__Problem__Group_0__1__Impl rule__Problem__Group_0__2 + { + pushFollow(FOLLOW_6); + rule__Problem__Group_0__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Problem__Group_0__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Problem__Group_0__1" + + + // $ANTLR start "rule__Problem__Group_0__1__Impl" + // InternalProblem.g:1189:1: rule__Problem__Group_0__1__Impl : ( ( rule__Problem__NameAssignment_0_1 ) ) ; + public final void rule__Problem__Group_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1193:1: ( ( ( rule__Problem__NameAssignment_0_1 ) ) ) + // InternalProblem.g:1194:1: ( ( rule__Problem__NameAssignment_0_1 ) ) + { + // InternalProblem.g:1194:1: ( ( rule__Problem__NameAssignment_0_1 ) ) + // InternalProblem.g:1195:2: ( rule__Problem__NameAssignment_0_1 ) + { + before(grammarAccess.getProblemAccess().getNameAssignment_0_1()); + // InternalProblem.g:1196:2: ( rule__Problem__NameAssignment_0_1 ) + // InternalProblem.g:1196:3: rule__Problem__NameAssignment_0_1 + { + pushFollow(FOLLOW_2); + rule__Problem__NameAssignment_0_1(); + + state._fsp--; + + + } + + after(grammarAccess.getProblemAccess().getNameAssignment_0_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Problem__Group_0__1__Impl" + + + // $ANTLR start "rule__Problem__Group_0__2" + // InternalProblem.g:1204:1: rule__Problem__Group_0__2 : rule__Problem__Group_0__2__Impl ; + public final void rule__Problem__Group_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1208:1: ( rule__Problem__Group_0__2__Impl ) + // InternalProblem.g:1209:2: rule__Problem__Group_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__Problem__Group_0__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Problem__Group_0__2" + + + // $ANTLR start "rule__Problem__Group_0__2__Impl" + // InternalProblem.g:1215:1: rule__Problem__Group_0__2__Impl : ( '.' ) ; + public final void rule__Problem__Group_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1219:1: ( ( '.' ) ) + // InternalProblem.g:1220:1: ( '.' ) + { + // InternalProblem.g:1220:1: ( '.' ) + // InternalProblem.g:1221:2: '.' + { + before(grammarAccess.getProblemAccess().getFullStopKeyword_0_2()); + match(input,12,FOLLOW_2); + after(grammarAccess.getProblemAccess().getFullStopKeyword_0_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Problem__Group_0__2__Impl" + + + // $ANTLR start "rule__ClassDeclaration__Group__0" + // InternalProblem.g:1231:1: rule__ClassDeclaration__Group__0 : rule__ClassDeclaration__Group__0__Impl rule__ClassDeclaration__Group__1 ; + public final void rule__ClassDeclaration__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1235:1: ( rule__ClassDeclaration__Group__0__Impl rule__ClassDeclaration__Group__1 ) + // InternalProblem.g:1236:2: rule__ClassDeclaration__Group__0__Impl rule__ClassDeclaration__Group__1 + { + pushFollow(FOLLOW_7); + rule__ClassDeclaration__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group__0" + + + // $ANTLR start "rule__ClassDeclaration__Group__0__Impl" + // InternalProblem.g:1243:1: rule__ClassDeclaration__Group__0__Impl : ( ( rule__ClassDeclaration__AbstractAssignment_0 )? ) ; + public final void rule__ClassDeclaration__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1247:1: ( ( ( rule__ClassDeclaration__AbstractAssignment_0 )? ) ) + // InternalProblem.g:1248:1: ( ( rule__ClassDeclaration__AbstractAssignment_0 )? ) + { + // InternalProblem.g:1248:1: ( ( rule__ClassDeclaration__AbstractAssignment_0 )? ) + // InternalProblem.g:1249:2: ( rule__ClassDeclaration__AbstractAssignment_0 )? + { + before(grammarAccess.getClassDeclarationAccess().getAbstractAssignment_0()); + // InternalProblem.g:1250:2: ( rule__ClassDeclaration__AbstractAssignment_0 )? + int alt20=2; + int LA20_0 = input.LA(1); + + if ( (LA20_0==39) ) { + alt20=1; + } + switch (alt20) { + case 1 : + // InternalProblem.g:1250:3: rule__ClassDeclaration__AbstractAssignment_0 + { + pushFollow(FOLLOW_2); + rule__ClassDeclaration__AbstractAssignment_0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getClassDeclarationAccess().getAbstractAssignment_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group__0__Impl" + + + // $ANTLR start "rule__ClassDeclaration__Group__1" + // InternalProblem.g:1258:1: rule__ClassDeclaration__Group__1 : rule__ClassDeclaration__Group__1__Impl rule__ClassDeclaration__Group__2 ; + public final void rule__ClassDeclaration__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1262:1: ( rule__ClassDeclaration__Group__1__Impl rule__ClassDeclaration__Group__2 ) + // InternalProblem.g:1263:2: rule__ClassDeclaration__Group__1__Impl rule__ClassDeclaration__Group__2 + { + pushFollow(FOLLOW_5); + rule__ClassDeclaration__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group__1" + + + // $ANTLR start "rule__ClassDeclaration__Group__1__Impl" + // InternalProblem.g:1270:1: rule__ClassDeclaration__Group__1__Impl : ( 'class' ) ; + public final void rule__ClassDeclaration__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1274:1: ( ( 'class' ) ) + // InternalProblem.g:1275:1: ( 'class' ) + { + // InternalProblem.g:1275:1: ( 'class' ) + // InternalProblem.g:1276:2: 'class' + { + before(grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); + match(input,25,FOLLOW_2); + after(grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group__1__Impl" + + + // $ANTLR start "rule__ClassDeclaration__Group__2" + // InternalProblem.g:1285:1: rule__ClassDeclaration__Group__2 : rule__ClassDeclaration__Group__2__Impl rule__ClassDeclaration__Group__3 ; + public final void rule__ClassDeclaration__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1289:1: ( rule__ClassDeclaration__Group__2__Impl rule__ClassDeclaration__Group__3 ) + // InternalProblem.g:1290:2: rule__ClassDeclaration__Group__2__Impl rule__ClassDeclaration__Group__3 + { + pushFollow(FOLLOW_8); + rule__ClassDeclaration__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group__2" + + + // $ANTLR start "rule__ClassDeclaration__Group__2__Impl" + // InternalProblem.g:1297:1: rule__ClassDeclaration__Group__2__Impl : ( ( rule__ClassDeclaration__NameAssignment_2 ) ) ; + public final void rule__ClassDeclaration__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1301:1: ( ( ( rule__ClassDeclaration__NameAssignment_2 ) ) ) + // InternalProblem.g:1302:1: ( ( rule__ClassDeclaration__NameAssignment_2 ) ) + { + // InternalProblem.g:1302:1: ( ( rule__ClassDeclaration__NameAssignment_2 ) ) + // InternalProblem.g:1303:2: ( rule__ClassDeclaration__NameAssignment_2 ) + { + before(grammarAccess.getClassDeclarationAccess().getNameAssignment_2()); + // InternalProblem.g:1304:2: ( rule__ClassDeclaration__NameAssignment_2 ) + // InternalProblem.g:1304:3: rule__ClassDeclaration__NameAssignment_2 + { + pushFollow(FOLLOW_2); + rule__ClassDeclaration__NameAssignment_2(); + + state._fsp--; + + + } + + after(grammarAccess.getClassDeclarationAccess().getNameAssignment_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group__2__Impl" + + + // $ANTLR start "rule__ClassDeclaration__Group__3" + // InternalProblem.g:1312:1: rule__ClassDeclaration__Group__3 : rule__ClassDeclaration__Group__3__Impl rule__ClassDeclaration__Group__4 ; + public final void rule__ClassDeclaration__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1316:1: ( rule__ClassDeclaration__Group__3__Impl rule__ClassDeclaration__Group__4 ) + // InternalProblem.g:1317:2: rule__ClassDeclaration__Group__3__Impl rule__ClassDeclaration__Group__4 + { + pushFollow(FOLLOW_8); + rule__ClassDeclaration__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group__3" + + + // $ANTLR start "rule__ClassDeclaration__Group__3__Impl" + // InternalProblem.g:1324:1: rule__ClassDeclaration__Group__3__Impl : ( ( rule__ClassDeclaration__Group_3__0 )? ) ; + public final void rule__ClassDeclaration__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1328:1: ( ( ( rule__ClassDeclaration__Group_3__0 )? ) ) + // InternalProblem.g:1329:1: ( ( rule__ClassDeclaration__Group_3__0 )? ) + { + // InternalProblem.g:1329:1: ( ( rule__ClassDeclaration__Group_3__0 )? ) + // InternalProblem.g:1330:2: ( rule__ClassDeclaration__Group_3__0 )? + { + before(grammarAccess.getClassDeclarationAccess().getGroup_3()); + // InternalProblem.g:1331:2: ( rule__ClassDeclaration__Group_3__0 )? + int alt21=2; + int LA21_0 = input.LA(1); + + if ( (LA21_0==26) ) { + alt21=1; + } + switch (alt21) { + case 1 : + // InternalProblem.g:1331:3: rule__ClassDeclaration__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group_3__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getClassDeclarationAccess().getGroup_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group__3__Impl" + + + // $ANTLR start "rule__ClassDeclaration__Group__4" + // InternalProblem.g:1339:1: rule__ClassDeclaration__Group__4 : rule__ClassDeclaration__Group__4__Impl ; + public final void rule__ClassDeclaration__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1343:1: ( rule__ClassDeclaration__Group__4__Impl ) + // InternalProblem.g:1344:2: rule__ClassDeclaration__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group__4__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group__4" + + + // $ANTLR start "rule__ClassDeclaration__Group__4__Impl" + // InternalProblem.g:1350:1: rule__ClassDeclaration__Group__4__Impl : ( ( rule__ClassDeclaration__Alternatives_4 ) ) ; + public final void rule__ClassDeclaration__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1354:1: ( ( ( rule__ClassDeclaration__Alternatives_4 ) ) ) + // InternalProblem.g:1355:1: ( ( rule__ClassDeclaration__Alternatives_4 ) ) + { + // InternalProblem.g:1355:1: ( ( rule__ClassDeclaration__Alternatives_4 ) ) + // InternalProblem.g:1356:2: ( rule__ClassDeclaration__Alternatives_4 ) + { + before(grammarAccess.getClassDeclarationAccess().getAlternatives_4()); + // InternalProblem.g:1357:2: ( rule__ClassDeclaration__Alternatives_4 ) + // InternalProblem.g:1357:3: rule__ClassDeclaration__Alternatives_4 + { + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Alternatives_4(); + + state._fsp--; + + + } + + after(grammarAccess.getClassDeclarationAccess().getAlternatives_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group__4__Impl" + + + // $ANTLR start "rule__ClassDeclaration__Group_3__0" + // InternalProblem.g:1366:1: rule__ClassDeclaration__Group_3__0 : rule__ClassDeclaration__Group_3__0__Impl rule__ClassDeclaration__Group_3__1 ; + public final void rule__ClassDeclaration__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1370:1: ( rule__ClassDeclaration__Group_3__0__Impl rule__ClassDeclaration__Group_3__1 ) + // InternalProblem.g:1371:2: rule__ClassDeclaration__Group_3__0__Impl rule__ClassDeclaration__Group_3__1 + { + pushFollow(FOLLOW_5); + rule__ClassDeclaration__Group_3__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group_3__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_3__0" + + + // $ANTLR start "rule__ClassDeclaration__Group_3__0__Impl" + // InternalProblem.g:1378:1: rule__ClassDeclaration__Group_3__0__Impl : ( 'extends' ) ; + public final void rule__ClassDeclaration__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1382:1: ( ( 'extends' ) ) + // InternalProblem.g:1383:1: ( 'extends' ) + { + // InternalProblem.g:1383:1: ( 'extends' ) + // InternalProblem.g:1384:2: 'extends' + { + before(grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); + match(input,26,FOLLOW_2); + after(grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_3__0__Impl" + + + // $ANTLR start "rule__ClassDeclaration__Group_3__1" + // InternalProblem.g:1393:1: rule__ClassDeclaration__Group_3__1 : rule__ClassDeclaration__Group_3__1__Impl rule__ClassDeclaration__Group_3__2 ; + public final void rule__ClassDeclaration__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1397:1: ( rule__ClassDeclaration__Group_3__1__Impl rule__ClassDeclaration__Group_3__2 ) + // InternalProblem.g:1398:2: rule__ClassDeclaration__Group_3__1__Impl rule__ClassDeclaration__Group_3__2 + { + pushFollow(FOLLOW_9); + rule__ClassDeclaration__Group_3__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group_3__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_3__1" + + + // $ANTLR start "rule__ClassDeclaration__Group_3__1__Impl" + // InternalProblem.g:1405:1: rule__ClassDeclaration__Group_3__1__Impl : ( ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) ) ; + public final void rule__ClassDeclaration__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1409:1: ( ( ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) ) ) + // InternalProblem.g:1410:1: ( ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) ) + { + // InternalProblem.g:1410:1: ( ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) ) + // InternalProblem.g:1411:2: ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) + { + before(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_1()); + // InternalProblem.g:1412:2: ( rule__ClassDeclaration__SuperTypesAssignment_3_1 ) + // InternalProblem.g:1412:3: rule__ClassDeclaration__SuperTypesAssignment_3_1 + { + pushFollow(FOLLOW_2); + rule__ClassDeclaration__SuperTypesAssignment_3_1(); + + state._fsp--; + + + } + + after(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_3__1__Impl" + + + // $ANTLR start "rule__ClassDeclaration__Group_3__2" + // InternalProblem.g:1420:1: rule__ClassDeclaration__Group_3__2 : rule__ClassDeclaration__Group_3__2__Impl ; + public final void rule__ClassDeclaration__Group_3__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1424:1: ( rule__ClassDeclaration__Group_3__2__Impl ) + // InternalProblem.g:1425:2: rule__ClassDeclaration__Group_3__2__Impl + { + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group_3__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_3__2" + + + // $ANTLR start "rule__ClassDeclaration__Group_3__2__Impl" + // InternalProblem.g:1431:1: rule__ClassDeclaration__Group_3__2__Impl : ( ( rule__ClassDeclaration__Group_3_2__0 )* ) ; + public final void rule__ClassDeclaration__Group_3__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1435:1: ( ( ( rule__ClassDeclaration__Group_3_2__0 )* ) ) + // InternalProblem.g:1436:1: ( ( rule__ClassDeclaration__Group_3_2__0 )* ) + { + // InternalProblem.g:1436:1: ( ( rule__ClassDeclaration__Group_3_2__0 )* ) + // InternalProblem.g:1437:2: ( rule__ClassDeclaration__Group_3_2__0 )* + { + before(grammarAccess.getClassDeclarationAccess().getGroup_3_2()); + // InternalProblem.g:1438:2: ( rule__ClassDeclaration__Group_3_2__0 )* + loop22: + do { + int alt22=2; + int LA22_0 = input.LA(1); + + if ( (LA22_0==13) ) { + alt22=1; + } + + + switch (alt22) { + case 1 : + // InternalProblem.g:1438:3: rule__ClassDeclaration__Group_3_2__0 + { + pushFollow(FOLLOW_10); + rule__ClassDeclaration__Group_3_2__0(); + + state._fsp--; + + + } + break; + + default : + break loop22; + } + } while (true); + + after(grammarAccess.getClassDeclarationAccess().getGroup_3_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_3__2__Impl" + + + // $ANTLR start "rule__ClassDeclaration__Group_3_2__0" + // InternalProblem.g:1447:1: rule__ClassDeclaration__Group_3_2__0 : rule__ClassDeclaration__Group_3_2__0__Impl rule__ClassDeclaration__Group_3_2__1 ; + public final void rule__ClassDeclaration__Group_3_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1451:1: ( rule__ClassDeclaration__Group_3_2__0__Impl rule__ClassDeclaration__Group_3_2__1 ) + // InternalProblem.g:1452:2: rule__ClassDeclaration__Group_3_2__0__Impl rule__ClassDeclaration__Group_3_2__1 + { + pushFollow(FOLLOW_5); + rule__ClassDeclaration__Group_3_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group_3_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_3_2__0" + + + // $ANTLR start "rule__ClassDeclaration__Group_3_2__0__Impl" + // InternalProblem.g:1459:1: rule__ClassDeclaration__Group_3_2__0__Impl : ( ',' ) ; + public final void rule__ClassDeclaration__Group_3_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1463:1: ( ( ',' ) ) + // InternalProblem.g:1464:1: ( ',' ) + { + // InternalProblem.g:1464:1: ( ',' ) + // InternalProblem.g:1465:2: ',' + { + before(grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); + match(input,13,FOLLOW_2); + after(grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_3_2__0__Impl" + + + // $ANTLR start "rule__ClassDeclaration__Group_3_2__1" + // InternalProblem.g:1474:1: rule__ClassDeclaration__Group_3_2__1 : rule__ClassDeclaration__Group_3_2__1__Impl ; + public final void rule__ClassDeclaration__Group_3_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1478:1: ( rule__ClassDeclaration__Group_3_2__1__Impl ) + // InternalProblem.g:1479:2: rule__ClassDeclaration__Group_3_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group_3_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_3_2__1" + + + // $ANTLR start "rule__ClassDeclaration__Group_3_2__1__Impl" + // InternalProblem.g:1485:1: rule__ClassDeclaration__Group_3_2__1__Impl : ( ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) ) ; + public final void rule__ClassDeclaration__Group_3_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1489:1: ( ( ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) ) ) + // InternalProblem.g:1490:1: ( ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) ) + { + // InternalProblem.g:1490:1: ( ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) ) + // InternalProblem.g:1491:2: ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) + { + before(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_2_1()); + // InternalProblem.g:1492:2: ( rule__ClassDeclaration__SuperTypesAssignment_3_2_1 ) + // InternalProblem.g:1492:3: rule__ClassDeclaration__SuperTypesAssignment_3_2_1 + { + pushFollow(FOLLOW_2); + rule__ClassDeclaration__SuperTypesAssignment_3_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getClassDeclarationAccess().getSuperTypesAssignment_3_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_3_2__1__Impl" + + + // $ANTLR start "rule__ClassDeclaration__Group_4_0__0" + // InternalProblem.g:1501:1: rule__ClassDeclaration__Group_4_0__0 : rule__ClassDeclaration__Group_4_0__0__Impl rule__ClassDeclaration__Group_4_0__1 ; + public final void rule__ClassDeclaration__Group_4_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1505:1: ( rule__ClassDeclaration__Group_4_0__0__Impl rule__ClassDeclaration__Group_4_0__1 ) + // InternalProblem.g:1506:2: rule__ClassDeclaration__Group_4_0__0__Impl rule__ClassDeclaration__Group_4_0__1 + { + pushFollow(FOLLOW_11); + rule__ClassDeclaration__Group_4_0__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group_4_0__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_4_0__0" + + + // $ANTLR start "rule__ClassDeclaration__Group_4_0__0__Impl" + // InternalProblem.g:1513:1: rule__ClassDeclaration__Group_4_0__0__Impl : ( '{' ) ; + public final void rule__ClassDeclaration__Group_4_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1517:1: ( ( '{' ) ) + // InternalProblem.g:1518:1: ( '{' ) + { + // InternalProblem.g:1518:1: ( '{' ) + // InternalProblem.g:1519:2: '{' + { + before(grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); + match(input,27,FOLLOW_2); + after(grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_4_0__0__Impl" + + + // $ANTLR start "rule__ClassDeclaration__Group_4_0__1" + // InternalProblem.g:1528:1: rule__ClassDeclaration__Group_4_0__1 : rule__ClassDeclaration__Group_4_0__1__Impl rule__ClassDeclaration__Group_4_0__2 ; + public final void rule__ClassDeclaration__Group_4_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1532:1: ( rule__ClassDeclaration__Group_4_0__1__Impl rule__ClassDeclaration__Group_4_0__2 ) + // InternalProblem.g:1533:2: rule__ClassDeclaration__Group_4_0__1__Impl rule__ClassDeclaration__Group_4_0__2 + { + pushFollow(FOLLOW_11); + rule__ClassDeclaration__Group_4_0__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group_4_0__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_4_0__1" + + + // $ANTLR start "rule__ClassDeclaration__Group_4_0__1__Impl" + // InternalProblem.g:1540:1: rule__ClassDeclaration__Group_4_0__1__Impl : ( ( rule__ClassDeclaration__Group_4_0_1__0 )* ) ; + public final void rule__ClassDeclaration__Group_4_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1544:1: ( ( ( rule__ClassDeclaration__Group_4_0_1__0 )* ) ) + // InternalProblem.g:1545:1: ( ( rule__ClassDeclaration__Group_4_0_1__0 )* ) + { + // InternalProblem.g:1545:1: ( ( rule__ClassDeclaration__Group_4_0_1__0 )* ) + // InternalProblem.g:1546:2: ( rule__ClassDeclaration__Group_4_0_1__0 )* + { + before(grammarAccess.getClassDeclarationAccess().getGroup_4_0_1()); + // InternalProblem.g:1547:2: ( rule__ClassDeclaration__Group_4_0_1__0 )* + loop23: + do { + int alt23=2; + int LA23_0 = input.LA(1); + + if ( ((LA23_0>=RULE_QUOTED_ID && LA23_0<=RULE_ID)||LA23_0==15||(LA23_0>=19 && LA23_0<=20)||LA23_0==40) ) { + alt23=1; + } + + + switch (alt23) { + case 1 : + // InternalProblem.g:1547:3: rule__ClassDeclaration__Group_4_0_1__0 + { + pushFollow(FOLLOW_12); + rule__ClassDeclaration__Group_4_0_1__0(); + + state._fsp--; + + + } + break; + + default : + break loop23; + } + } while (true); + + after(grammarAccess.getClassDeclarationAccess().getGroup_4_0_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_4_0__1__Impl" + + + // $ANTLR start "rule__ClassDeclaration__Group_4_0__2" + // InternalProblem.g:1555:1: rule__ClassDeclaration__Group_4_0__2 : rule__ClassDeclaration__Group_4_0__2__Impl ; + public final void rule__ClassDeclaration__Group_4_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1559:1: ( rule__ClassDeclaration__Group_4_0__2__Impl ) + // InternalProblem.g:1560:2: rule__ClassDeclaration__Group_4_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group_4_0__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_4_0__2" + + + // $ANTLR start "rule__ClassDeclaration__Group_4_0__2__Impl" + // InternalProblem.g:1566:1: rule__ClassDeclaration__Group_4_0__2__Impl : ( '}' ) ; + public final void rule__ClassDeclaration__Group_4_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1570:1: ( ( '}' ) ) + // InternalProblem.g:1571:1: ( '}' ) + { + // InternalProblem.g:1571:1: ( '}' ) + // InternalProblem.g:1572:2: '}' + { + before(grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); + match(input,28,FOLLOW_2); + after(grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_4_0__2__Impl" + + + // $ANTLR start "rule__ClassDeclaration__Group_4_0_1__0" + // InternalProblem.g:1582:1: rule__ClassDeclaration__Group_4_0_1__0 : rule__ClassDeclaration__Group_4_0_1__0__Impl rule__ClassDeclaration__Group_4_0_1__1 ; + public final void rule__ClassDeclaration__Group_4_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1586:1: ( rule__ClassDeclaration__Group_4_0_1__0__Impl rule__ClassDeclaration__Group_4_0_1__1 ) + // InternalProblem.g:1587:2: rule__ClassDeclaration__Group_4_0_1__0__Impl rule__ClassDeclaration__Group_4_0_1__1 + { + pushFollow(FOLLOW_13); + rule__ClassDeclaration__Group_4_0_1__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group_4_0_1__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_4_0_1__0" + + + // $ANTLR start "rule__ClassDeclaration__Group_4_0_1__0__Impl" + // InternalProblem.g:1594:1: rule__ClassDeclaration__Group_4_0_1__0__Impl : ( ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) ) ; + public final void rule__ClassDeclaration__Group_4_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1598:1: ( ( ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) ) ) + // InternalProblem.g:1599:1: ( ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) ) + { + // InternalProblem.g:1599:1: ( ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) ) + // InternalProblem.g:1600:2: ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) + { + before(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsAssignment_4_0_1_0()); + // InternalProblem.g:1601:2: ( rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 ) + // InternalProblem.g:1601:3: rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 + { + pushFollow(FOLLOW_2); + rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0(); + + state._fsp--; + + + } + + after(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsAssignment_4_0_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_4_0_1__0__Impl" + + + // $ANTLR start "rule__ClassDeclaration__Group_4_0_1__1" + // InternalProblem.g:1609:1: rule__ClassDeclaration__Group_4_0_1__1 : rule__ClassDeclaration__Group_4_0_1__1__Impl ; + public final void rule__ClassDeclaration__Group_4_0_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1613:1: ( rule__ClassDeclaration__Group_4_0_1__1__Impl ) + // InternalProblem.g:1614:2: rule__ClassDeclaration__Group_4_0_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__ClassDeclaration__Group_4_0_1__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_4_0_1__1" + + + // $ANTLR start "rule__ClassDeclaration__Group_4_0_1__1__Impl" + // InternalProblem.g:1620:1: rule__ClassDeclaration__Group_4_0_1__1__Impl : ( ( ';' )? ) ; + public final void rule__ClassDeclaration__Group_4_0_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1624:1: ( ( ( ';' )? ) ) + // InternalProblem.g:1625:1: ( ( ';' )? ) + { + // InternalProblem.g:1625:1: ( ( ';' )? ) + // InternalProblem.g:1626:2: ( ';' )? + { + before(grammarAccess.getClassDeclarationAccess().getSemicolonKeyword_4_0_1_1()); + // InternalProblem.g:1627:2: ( ';' )? + int alt24=2; + int LA24_0 = input.LA(1); + + if ( (LA24_0==14) ) { + alt24=1; + } + switch (alt24) { + case 1 : + // InternalProblem.g:1627:3: ';' + { + match(input,14,FOLLOW_2); + + } + break; + + } + + after(grammarAccess.getClassDeclarationAccess().getSemicolonKeyword_4_0_1_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__Group_4_0_1__1__Impl" + + + // $ANTLR start "rule__EnumDeclaration__Group__0" + // InternalProblem.g:1636:1: rule__EnumDeclaration__Group__0 : rule__EnumDeclaration__Group__0__Impl rule__EnumDeclaration__Group__1 ; + public final void rule__EnumDeclaration__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1640:1: ( rule__EnumDeclaration__Group__0__Impl rule__EnumDeclaration__Group__1 ) + // InternalProblem.g:1641:2: rule__EnumDeclaration__Group__0__Impl rule__EnumDeclaration__Group__1 + { + pushFollow(FOLLOW_5); + rule__EnumDeclaration__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__EnumDeclaration__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group__0" + + + // $ANTLR start "rule__EnumDeclaration__Group__0__Impl" + // InternalProblem.g:1648:1: rule__EnumDeclaration__Group__0__Impl : ( 'enum' ) ; + public final void rule__EnumDeclaration__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1652:1: ( ( 'enum' ) ) + // InternalProblem.g:1653:1: ( 'enum' ) + { + // InternalProblem.g:1653:1: ( 'enum' ) + // InternalProblem.g:1654:2: 'enum' + { + before(grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); + match(input,29,FOLLOW_2); + after(grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group__0__Impl" + + + // $ANTLR start "rule__EnumDeclaration__Group__1" + // InternalProblem.g:1663:1: rule__EnumDeclaration__Group__1 : rule__EnumDeclaration__Group__1__Impl rule__EnumDeclaration__Group__2 ; + public final void rule__EnumDeclaration__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1667:1: ( rule__EnumDeclaration__Group__1__Impl rule__EnumDeclaration__Group__2 ) + // InternalProblem.g:1668:2: rule__EnumDeclaration__Group__1__Impl rule__EnumDeclaration__Group__2 + { + pushFollow(FOLLOW_14); + rule__EnumDeclaration__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__EnumDeclaration__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group__1" + + + // $ANTLR start "rule__EnumDeclaration__Group__1__Impl" + // InternalProblem.g:1675:1: rule__EnumDeclaration__Group__1__Impl : ( ( rule__EnumDeclaration__NameAssignment_1 ) ) ; + public final void rule__EnumDeclaration__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1679:1: ( ( ( rule__EnumDeclaration__NameAssignment_1 ) ) ) + // InternalProblem.g:1680:1: ( ( rule__EnumDeclaration__NameAssignment_1 ) ) + { + // InternalProblem.g:1680:1: ( ( rule__EnumDeclaration__NameAssignment_1 ) ) + // InternalProblem.g:1681:2: ( rule__EnumDeclaration__NameAssignment_1 ) + { + before(grammarAccess.getEnumDeclarationAccess().getNameAssignment_1()); + // InternalProblem.g:1682:2: ( rule__EnumDeclaration__NameAssignment_1 ) + // InternalProblem.g:1682:3: rule__EnumDeclaration__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__EnumDeclaration__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getEnumDeclarationAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group__1__Impl" + + + // $ANTLR start "rule__EnumDeclaration__Group__2" + // InternalProblem.g:1690:1: rule__EnumDeclaration__Group__2 : rule__EnumDeclaration__Group__2__Impl ; + public final void rule__EnumDeclaration__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1694:1: ( rule__EnumDeclaration__Group__2__Impl ) + // InternalProblem.g:1695:2: rule__EnumDeclaration__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__EnumDeclaration__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group__2" + + + // $ANTLR start "rule__EnumDeclaration__Group__2__Impl" + // InternalProblem.g:1701:1: rule__EnumDeclaration__Group__2__Impl : ( ( rule__EnumDeclaration__Alternatives_2 ) ) ; + public final void rule__EnumDeclaration__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1705:1: ( ( ( rule__EnumDeclaration__Alternatives_2 ) ) ) + // InternalProblem.g:1706:1: ( ( rule__EnumDeclaration__Alternatives_2 ) ) + { + // InternalProblem.g:1706:1: ( ( rule__EnumDeclaration__Alternatives_2 ) ) + // InternalProblem.g:1707:2: ( rule__EnumDeclaration__Alternatives_2 ) + { + before(grammarAccess.getEnumDeclarationAccess().getAlternatives_2()); + // InternalProblem.g:1708:2: ( rule__EnumDeclaration__Alternatives_2 ) + // InternalProblem.g:1708:3: rule__EnumDeclaration__Alternatives_2 + { + pushFollow(FOLLOW_2); + rule__EnumDeclaration__Alternatives_2(); + + state._fsp--; + + + } + + after(grammarAccess.getEnumDeclarationAccess().getAlternatives_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group__2__Impl" + + + // $ANTLR start "rule__EnumDeclaration__Group_2_0__0" + // InternalProblem.g:1717:1: rule__EnumDeclaration__Group_2_0__0 : rule__EnumDeclaration__Group_2_0__0__Impl rule__EnumDeclaration__Group_2_0__1 ; + public final void rule__EnumDeclaration__Group_2_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1721:1: ( rule__EnumDeclaration__Group_2_0__0__Impl rule__EnumDeclaration__Group_2_0__1 ) + // InternalProblem.g:1722:2: rule__EnumDeclaration__Group_2_0__0__Impl rule__EnumDeclaration__Group_2_0__1 + { + pushFollow(FOLLOW_15); + rule__EnumDeclaration__Group_2_0__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__EnumDeclaration__Group_2_0__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group_2_0__0" + + + // $ANTLR start "rule__EnumDeclaration__Group_2_0__0__Impl" + // InternalProblem.g:1729:1: rule__EnumDeclaration__Group_2_0__0__Impl : ( '{' ) ; + public final void rule__EnumDeclaration__Group_2_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1733:1: ( ( '{' ) ) + // InternalProblem.g:1734:1: ( '{' ) + { + // InternalProblem.g:1734:1: ( '{' ) + // InternalProblem.g:1735:2: '{' + { + before(grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); + match(input,27,FOLLOW_2); + after(grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group_2_0__0__Impl" + + + // $ANTLR start "rule__EnumDeclaration__Group_2_0__1" + // InternalProblem.g:1744:1: rule__EnumDeclaration__Group_2_0__1 : rule__EnumDeclaration__Group_2_0__1__Impl rule__EnumDeclaration__Group_2_0__2 ; + public final void rule__EnumDeclaration__Group_2_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1748:1: ( rule__EnumDeclaration__Group_2_0__1__Impl rule__EnumDeclaration__Group_2_0__2 ) + // InternalProblem.g:1749:2: rule__EnumDeclaration__Group_2_0__1__Impl rule__EnumDeclaration__Group_2_0__2 + { + pushFollow(FOLLOW_15); + rule__EnumDeclaration__Group_2_0__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__EnumDeclaration__Group_2_0__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group_2_0__1" + + + // $ANTLR start "rule__EnumDeclaration__Group_2_0__1__Impl" + // InternalProblem.g:1756:1: rule__EnumDeclaration__Group_2_0__1__Impl : ( ( rule__EnumDeclaration__Group_2_0_1__0 )? ) ; + public final void rule__EnumDeclaration__Group_2_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1760:1: ( ( ( rule__EnumDeclaration__Group_2_0_1__0 )? ) ) + // InternalProblem.g:1761:1: ( ( rule__EnumDeclaration__Group_2_0_1__0 )? ) + { + // InternalProblem.g:1761:1: ( ( rule__EnumDeclaration__Group_2_0_1__0 )? ) + // InternalProblem.g:1762:2: ( rule__EnumDeclaration__Group_2_0_1__0 )? + { + before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1()); + // InternalProblem.g:1763:2: ( rule__EnumDeclaration__Group_2_0_1__0 )? + int alt25=2; + int LA25_0 = input.LA(1); + + if ( ((LA25_0>=RULE_QUOTED_ID && LA25_0<=RULE_ID)||(LA25_0>=19 && LA25_0<=20)) ) { + alt25=1; + } + switch (alt25) { + case 1 : + // InternalProblem.g:1763:3: rule__EnumDeclaration__Group_2_0_1__0 + { + pushFollow(FOLLOW_2); + rule__EnumDeclaration__Group_2_0_1__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group_2_0__1__Impl" + + + // $ANTLR start "rule__EnumDeclaration__Group_2_0__2" + // InternalProblem.g:1771:1: rule__EnumDeclaration__Group_2_0__2 : rule__EnumDeclaration__Group_2_0__2__Impl ; + public final void rule__EnumDeclaration__Group_2_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1775:1: ( rule__EnumDeclaration__Group_2_0__2__Impl ) + // InternalProblem.g:1776:2: rule__EnumDeclaration__Group_2_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__EnumDeclaration__Group_2_0__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group_2_0__2" + + + // $ANTLR start "rule__EnumDeclaration__Group_2_0__2__Impl" + // InternalProblem.g:1782:1: rule__EnumDeclaration__Group_2_0__2__Impl : ( '}' ) ; + public final void rule__EnumDeclaration__Group_2_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1786:1: ( ( '}' ) ) + // InternalProblem.g:1787:1: ( '}' ) + { + // InternalProblem.g:1787:1: ( '}' ) + // InternalProblem.g:1788:2: '}' + { + before(grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); + match(input,28,FOLLOW_2); + after(grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group_2_0__2__Impl" + + + // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__0" + // InternalProblem.g:1798:1: rule__EnumDeclaration__Group_2_0_1__0 : rule__EnumDeclaration__Group_2_0_1__0__Impl rule__EnumDeclaration__Group_2_0_1__1 ; + public final void rule__EnumDeclaration__Group_2_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1802:1: ( rule__EnumDeclaration__Group_2_0_1__0__Impl rule__EnumDeclaration__Group_2_0_1__1 ) + // InternalProblem.g:1803:2: rule__EnumDeclaration__Group_2_0_1__0__Impl rule__EnumDeclaration__Group_2_0_1__1 + { + pushFollow(FOLLOW_16); + rule__EnumDeclaration__Group_2_0_1__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__EnumDeclaration__Group_2_0_1__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group_2_0_1__0" + + + // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__0__Impl" + // InternalProblem.g:1810:1: rule__EnumDeclaration__Group_2_0_1__0__Impl : ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) ) ; + public final void rule__EnumDeclaration__Group_2_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1814:1: ( ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) ) ) + // InternalProblem.g:1815:1: ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) ) + { + // InternalProblem.g:1815:1: ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) ) + // InternalProblem.g:1816:2: ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) + { + before(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_0()); + // InternalProblem.g:1817:2: ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 ) + // InternalProblem.g:1817:3: rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 + { + pushFollow(FOLLOW_2); + rule__EnumDeclaration__LiteralsAssignment_2_0_1_0(); + + state._fsp--; + + + } + + after(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group_2_0_1__0__Impl" + + + // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__1" + // InternalProblem.g:1825:1: rule__EnumDeclaration__Group_2_0_1__1 : rule__EnumDeclaration__Group_2_0_1__1__Impl rule__EnumDeclaration__Group_2_0_1__2 ; + public final void rule__EnumDeclaration__Group_2_0_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1829:1: ( rule__EnumDeclaration__Group_2_0_1__1__Impl rule__EnumDeclaration__Group_2_0_1__2 ) + // InternalProblem.g:1830:2: rule__EnumDeclaration__Group_2_0_1__1__Impl rule__EnumDeclaration__Group_2_0_1__2 + { + pushFollow(FOLLOW_16); + rule__EnumDeclaration__Group_2_0_1__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__EnumDeclaration__Group_2_0_1__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group_2_0_1__1" + + + // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__1__Impl" + // InternalProblem.g:1837:1: rule__EnumDeclaration__Group_2_0_1__1__Impl : ( ( rule__EnumDeclaration__Group_2_0_1_1__0 )* ) ; + public final void rule__EnumDeclaration__Group_2_0_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1841:1: ( ( ( rule__EnumDeclaration__Group_2_0_1_1__0 )* ) ) + // InternalProblem.g:1842:1: ( ( rule__EnumDeclaration__Group_2_0_1_1__0 )* ) + { + // InternalProblem.g:1842:1: ( ( rule__EnumDeclaration__Group_2_0_1_1__0 )* ) + // InternalProblem.g:1843:2: ( rule__EnumDeclaration__Group_2_0_1_1__0 )* + { + before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1_1()); + // InternalProblem.g:1844:2: ( rule__EnumDeclaration__Group_2_0_1_1__0 )* + loop26: + do { + int alt26=2; + int LA26_0 = input.LA(1); + + if ( (LA26_0==13) ) { + int LA26_1 = input.LA(2); + + if ( ((LA26_1>=RULE_QUOTED_ID && LA26_1<=RULE_ID)||(LA26_1>=19 && LA26_1<=20)) ) { + alt26=1; + } + + + } + + + switch (alt26) { + case 1 : + // InternalProblem.g:1844:3: rule__EnumDeclaration__Group_2_0_1_1__0 + { + pushFollow(FOLLOW_10); + rule__EnumDeclaration__Group_2_0_1_1__0(); + + state._fsp--; + + + } + break; + + default : + break loop26; + } + } while (true); + + after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group_2_0_1__1__Impl" + + + // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__2" + // InternalProblem.g:1852:1: rule__EnumDeclaration__Group_2_0_1__2 : rule__EnumDeclaration__Group_2_0_1__2__Impl ; + public final void rule__EnumDeclaration__Group_2_0_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1856:1: ( rule__EnumDeclaration__Group_2_0_1__2__Impl ) + // InternalProblem.g:1857:2: rule__EnumDeclaration__Group_2_0_1__2__Impl + { + pushFollow(FOLLOW_2); + rule__EnumDeclaration__Group_2_0_1__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group_2_0_1__2" + + + // $ANTLR start "rule__EnumDeclaration__Group_2_0_1__2__Impl" + // InternalProblem.g:1863:1: rule__EnumDeclaration__Group_2_0_1__2__Impl : ( ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? ) ; + public final void rule__EnumDeclaration__Group_2_0_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1867:1: ( ( ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? ) ) + // InternalProblem.g:1868:1: ( ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? ) + { + // InternalProblem.g:1868:1: ( ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? ) + // InternalProblem.g:1869:2: ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? + { + before(grammarAccess.getEnumDeclarationAccess().getAlternatives_2_0_1_2()); + // InternalProblem.g:1870:2: ( rule__EnumDeclaration__Alternatives_2_0_1_2 )? + int alt27=2; + int LA27_0 = input.LA(1); + + if ( ((LA27_0>=13 && LA27_0<=14)) ) { + alt27=1; + } + switch (alt27) { + case 1 : + // InternalProblem.g:1870:3: rule__EnumDeclaration__Alternatives_2_0_1_2 + { + pushFollow(FOLLOW_2); + rule__EnumDeclaration__Alternatives_2_0_1_2(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getEnumDeclarationAccess().getAlternatives_2_0_1_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group_2_0_1__2__Impl" + + + // $ANTLR start "rule__EnumDeclaration__Group_2_0_1_1__0" + // InternalProblem.g:1879:1: rule__EnumDeclaration__Group_2_0_1_1__0 : rule__EnumDeclaration__Group_2_0_1_1__0__Impl rule__EnumDeclaration__Group_2_0_1_1__1 ; + public final void rule__EnumDeclaration__Group_2_0_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1883:1: ( rule__EnumDeclaration__Group_2_0_1_1__0__Impl rule__EnumDeclaration__Group_2_0_1_1__1 ) + // InternalProblem.g:1884:2: rule__EnumDeclaration__Group_2_0_1_1__0__Impl rule__EnumDeclaration__Group_2_0_1_1__1 + { + pushFollow(FOLLOW_5); + rule__EnumDeclaration__Group_2_0_1_1__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__EnumDeclaration__Group_2_0_1_1__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group_2_0_1_1__0" + + + // $ANTLR start "rule__EnumDeclaration__Group_2_0_1_1__0__Impl" + // InternalProblem.g:1891:1: rule__EnumDeclaration__Group_2_0_1_1__0__Impl : ( ',' ) ; + public final void rule__EnumDeclaration__Group_2_0_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1895:1: ( ( ',' ) ) + // InternalProblem.g:1896:1: ( ',' ) + { + // InternalProblem.g:1896:1: ( ',' ) + // InternalProblem.g:1897:2: ',' + { + before(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); + match(input,13,FOLLOW_2); + after(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group_2_0_1_1__0__Impl" + + + // $ANTLR start "rule__EnumDeclaration__Group_2_0_1_1__1" + // InternalProblem.g:1906:1: rule__EnumDeclaration__Group_2_0_1_1__1 : rule__EnumDeclaration__Group_2_0_1_1__1__Impl ; + public final void rule__EnumDeclaration__Group_2_0_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1910:1: ( rule__EnumDeclaration__Group_2_0_1_1__1__Impl ) + // InternalProblem.g:1911:2: rule__EnumDeclaration__Group_2_0_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__EnumDeclaration__Group_2_0_1_1__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group_2_0_1_1__1" + + + // $ANTLR start "rule__EnumDeclaration__Group_2_0_1_1__1__Impl" + // InternalProblem.g:1917:1: rule__EnumDeclaration__Group_2_0_1_1__1__Impl : ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) ) ; + public final void rule__EnumDeclaration__Group_2_0_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1921:1: ( ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) ) ) + // InternalProblem.g:1922:1: ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) ) + { + // InternalProblem.g:1922:1: ( ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) ) + // InternalProblem.g:1923:2: ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) + { + before(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_1_1()); + // InternalProblem.g:1924:2: ( rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 ) + // InternalProblem.g:1924:3: rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 + { + pushFollow(FOLLOW_2); + rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1(); + + state._fsp--; + + + } + + after(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_1_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__Group_2_0_1_1__1__Impl" + + + // $ANTLR start "rule__ReferenceDeclaration__Group__0" + // InternalProblem.g:1933:1: rule__ReferenceDeclaration__Group__0 : rule__ReferenceDeclaration__Group__0__Impl rule__ReferenceDeclaration__Group__1 ; + public final void rule__ReferenceDeclaration__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1937:1: ( rule__ReferenceDeclaration__Group__0__Impl rule__ReferenceDeclaration__Group__1 ) + // InternalProblem.g:1938:2: rule__ReferenceDeclaration__Group__0__Impl rule__ReferenceDeclaration__Group__1 + { + pushFollow(FOLLOW_17); + rule__ReferenceDeclaration__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group__0" + + + // $ANTLR start "rule__ReferenceDeclaration__Group__0__Impl" + // InternalProblem.g:1945:1: rule__ReferenceDeclaration__Group__0__Impl : ( ( rule__ReferenceDeclaration__Alternatives_0 )? ) ; + public final void rule__ReferenceDeclaration__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1949:1: ( ( ( rule__ReferenceDeclaration__Alternatives_0 )? ) ) + // InternalProblem.g:1950:1: ( ( rule__ReferenceDeclaration__Alternatives_0 )? ) + { + // InternalProblem.g:1950:1: ( ( rule__ReferenceDeclaration__Alternatives_0 )? ) + // InternalProblem.g:1951:2: ( rule__ReferenceDeclaration__Alternatives_0 )? + { + before(grammarAccess.getReferenceDeclarationAccess().getAlternatives_0()); + // InternalProblem.g:1952:2: ( rule__ReferenceDeclaration__Alternatives_0 )? + int alt28=2; + int LA28_0 = input.LA(1); + + if ( (LA28_0==15||LA28_0==40) ) { + alt28=1; + } + switch (alt28) { + case 1 : + // InternalProblem.g:1952:3: rule__ReferenceDeclaration__Alternatives_0 + { + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__Alternatives_0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getReferenceDeclarationAccess().getAlternatives_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group__0__Impl" + + + // $ANTLR start "rule__ReferenceDeclaration__Group__1" + // InternalProblem.g:1960:1: rule__ReferenceDeclaration__Group__1 : rule__ReferenceDeclaration__Group__1__Impl rule__ReferenceDeclaration__Group__2 ; + public final void rule__ReferenceDeclaration__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1964:1: ( rule__ReferenceDeclaration__Group__1__Impl rule__ReferenceDeclaration__Group__2 ) + // InternalProblem.g:1965:2: rule__ReferenceDeclaration__Group__1__Impl rule__ReferenceDeclaration__Group__2 + { + pushFollow(FOLLOW_18); + rule__ReferenceDeclaration__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group__1" + + + // $ANTLR start "rule__ReferenceDeclaration__Group__1__Impl" + // InternalProblem.g:1972:1: rule__ReferenceDeclaration__Group__1__Impl : ( ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) ) ; + public final void rule__ReferenceDeclaration__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1976:1: ( ( ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) ) ) + // InternalProblem.g:1977:1: ( ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) ) + { + // InternalProblem.g:1977:1: ( ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) ) + // InternalProblem.g:1978:2: ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) + { + before(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeAssignment_1()); + // InternalProblem.g:1979:2: ( rule__ReferenceDeclaration__ReferenceTypeAssignment_1 ) + // InternalProblem.g:1979:3: rule__ReferenceDeclaration__ReferenceTypeAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__ReferenceTypeAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group__1__Impl" + + + // $ANTLR start "rule__ReferenceDeclaration__Group__2" + // InternalProblem.g:1987:1: rule__ReferenceDeclaration__Group__2 : rule__ReferenceDeclaration__Group__2__Impl rule__ReferenceDeclaration__Group__3 ; + public final void rule__ReferenceDeclaration__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:1991:1: ( rule__ReferenceDeclaration__Group__2__Impl rule__ReferenceDeclaration__Group__3 ) + // InternalProblem.g:1992:2: rule__ReferenceDeclaration__Group__2__Impl rule__ReferenceDeclaration__Group__3 + { + pushFollow(FOLLOW_18); + rule__ReferenceDeclaration__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group__2" + + + // $ANTLR start "rule__ReferenceDeclaration__Group__2__Impl" + // InternalProblem.g:1999:1: rule__ReferenceDeclaration__Group__2__Impl : ( ( rule__ReferenceDeclaration__Group_2__0 )? ) ; + public final void rule__ReferenceDeclaration__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2003:1: ( ( ( rule__ReferenceDeclaration__Group_2__0 )? ) ) + // InternalProblem.g:2004:1: ( ( rule__ReferenceDeclaration__Group_2__0 )? ) + { + // InternalProblem.g:2004:1: ( ( rule__ReferenceDeclaration__Group_2__0 )? ) + // InternalProblem.g:2005:2: ( rule__ReferenceDeclaration__Group_2__0 )? + { + before(grammarAccess.getReferenceDeclarationAccess().getGroup_2()); + // InternalProblem.g:2006:2: ( rule__ReferenceDeclaration__Group_2__0 )? + int alt29=2; + int LA29_0 = input.LA(1); + + if ( (LA29_0==30) ) { + alt29=1; + } + switch (alt29) { + case 1 : + // InternalProblem.g:2006:3: rule__ReferenceDeclaration__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__Group_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getReferenceDeclarationAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group__2__Impl" + + + // $ANTLR start "rule__ReferenceDeclaration__Group__3" + // InternalProblem.g:2014:1: rule__ReferenceDeclaration__Group__3 : rule__ReferenceDeclaration__Group__3__Impl rule__ReferenceDeclaration__Group__4 ; + public final void rule__ReferenceDeclaration__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2018:1: ( rule__ReferenceDeclaration__Group__3__Impl rule__ReferenceDeclaration__Group__4 ) + // InternalProblem.g:2019:2: rule__ReferenceDeclaration__Group__3__Impl rule__ReferenceDeclaration__Group__4 + { + pushFollow(FOLLOW_19); + rule__ReferenceDeclaration__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group__3" + + + // $ANTLR start "rule__ReferenceDeclaration__Group__3__Impl" + // InternalProblem.g:2026:1: rule__ReferenceDeclaration__Group__3__Impl : ( ( rule__ReferenceDeclaration__NameAssignment_3 ) ) ; + public final void rule__ReferenceDeclaration__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2030:1: ( ( ( rule__ReferenceDeclaration__NameAssignment_3 ) ) ) + // InternalProblem.g:2031:1: ( ( rule__ReferenceDeclaration__NameAssignment_3 ) ) + { + // InternalProblem.g:2031:1: ( ( rule__ReferenceDeclaration__NameAssignment_3 ) ) + // InternalProblem.g:2032:2: ( rule__ReferenceDeclaration__NameAssignment_3 ) + { + before(grammarAccess.getReferenceDeclarationAccess().getNameAssignment_3()); + // InternalProblem.g:2033:2: ( rule__ReferenceDeclaration__NameAssignment_3 ) + // InternalProblem.g:2033:3: rule__ReferenceDeclaration__NameAssignment_3 + { + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__NameAssignment_3(); + + state._fsp--; + + + } + + after(grammarAccess.getReferenceDeclarationAccess().getNameAssignment_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group__3__Impl" + + + // $ANTLR start "rule__ReferenceDeclaration__Group__4" + // InternalProblem.g:2041:1: rule__ReferenceDeclaration__Group__4 : rule__ReferenceDeclaration__Group__4__Impl ; + public final void rule__ReferenceDeclaration__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2045:1: ( rule__ReferenceDeclaration__Group__4__Impl ) + // InternalProblem.g:2046:2: rule__ReferenceDeclaration__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__Group__4__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group__4" + + + // $ANTLR start "rule__ReferenceDeclaration__Group__4__Impl" + // InternalProblem.g:2052:1: rule__ReferenceDeclaration__Group__4__Impl : ( ( rule__ReferenceDeclaration__Group_4__0 )? ) ; + public final void rule__ReferenceDeclaration__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2056:1: ( ( ( rule__ReferenceDeclaration__Group_4__0 )? ) ) + // InternalProblem.g:2057:1: ( ( rule__ReferenceDeclaration__Group_4__0 )? ) + { + // InternalProblem.g:2057:1: ( ( rule__ReferenceDeclaration__Group_4__0 )? ) + // InternalProblem.g:2058:2: ( rule__ReferenceDeclaration__Group_4__0 )? + { + before(grammarAccess.getReferenceDeclarationAccess().getGroup_4()); + // InternalProblem.g:2059:2: ( rule__ReferenceDeclaration__Group_4__0 )? + int alt30=2; + int LA30_0 = input.LA(1); + + if ( (LA30_0==32) ) { + alt30=1; + } + switch (alt30) { + case 1 : + // InternalProblem.g:2059:3: rule__ReferenceDeclaration__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__Group_4__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getReferenceDeclarationAccess().getGroup_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group__4__Impl" + + + // $ANTLR start "rule__ReferenceDeclaration__Group_2__0" + // InternalProblem.g:2068:1: rule__ReferenceDeclaration__Group_2__0 : rule__ReferenceDeclaration__Group_2__0__Impl rule__ReferenceDeclaration__Group_2__1 ; + public final void rule__ReferenceDeclaration__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2072:1: ( rule__ReferenceDeclaration__Group_2__0__Impl rule__ReferenceDeclaration__Group_2__1 ) + // InternalProblem.g:2073:2: rule__ReferenceDeclaration__Group_2__0__Impl rule__ReferenceDeclaration__Group_2__1 + { + pushFollow(FOLLOW_20); + rule__ReferenceDeclaration__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group_2__0" + + + // $ANTLR start "rule__ReferenceDeclaration__Group_2__0__Impl" + // InternalProblem.g:2080:1: rule__ReferenceDeclaration__Group_2__0__Impl : ( '[' ) ; + public final void rule__ReferenceDeclaration__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2084:1: ( ( '[' ) ) + // InternalProblem.g:2085:1: ( '[' ) + { + // InternalProblem.g:2085:1: ( '[' ) + // InternalProblem.g:2086:2: '[' + { + before(grammarAccess.getReferenceDeclarationAccess().getLeftSquareBracketKeyword_2_0()); + match(input,30,FOLLOW_2); + after(grammarAccess.getReferenceDeclarationAccess().getLeftSquareBracketKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group_2__0__Impl" + + + // $ANTLR start "rule__ReferenceDeclaration__Group_2__1" + // InternalProblem.g:2095:1: rule__ReferenceDeclaration__Group_2__1 : rule__ReferenceDeclaration__Group_2__1__Impl rule__ReferenceDeclaration__Group_2__2 ; + public final void rule__ReferenceDeclaration__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2099:1: ( rule__ReferenceDeclaration__Group_2__1__Impl rule__ReferenceDeclaration__Group_2__2 ) + // InternalProblem.g:2100:2: rule__ReferenceDeclaration__Group_2__1__Impl rule__ReferenceDeclaration__Group_2__2 + { + pushFollow(FOLLOW_21); + rule__ReferenceDeclaration__Group_2__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__Group_2__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group_2__1" + + + // $ANTLR start "rule__ReferenceDeclaration__Group_2__1__Impl" + // InternalProblem.g:2107:1: rule__ReferenceDeclaration__Group_2__1__Impl : ( ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) ) ; + public final void rule__ReferenceDeclaration__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2111:1: ( ( ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) ) ) + // InternalProblem.g:2112:1: ( ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) ) + { + // InternalProblem.g:2112:1: ( ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) ) + // InternalProblem.g:2113:2: ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) + { + before(grammarAccess.getReferenceDeclarationAccess().getMultiplicityAssignment_2_1()); + // InternalProblem.g:2114:2: ( rule__ReferenceDeclaration__MultiplicityAssignment_2_1 ) + // InternalProblem.g:2114:3: rule__ReferenceDeclaration__MultiplicityAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__MultiplicityAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getReferenceDeclarationAccess().getMultiplicityAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group_2__1__Impl" + + + // $ANTLR start "rule__ReferenceDeclaration__Group_2__2" + // InternalProblem.g:2122:1: rule__ReferenceDeclaration__Group_2__2 : rule__ReferenceDeclaration__Group_2__2__Impl ; + public final void rule__ReferenceDeclaration__Group_2__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2126:1: ( rule__ReferenceDeclaration__Group_2__2__Impl ) + // InternalProblem.g:2127:2: rule__ReferenceDeclaration__Group_2__2__Impl + { + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__Group_2__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group_2__2" + + + // $ANTLR start "rule__ReferenceDeclaration__Group_2__2__Impl" + // InternalProblem.g:2133:1: rule__ReferenceDeclaration__Group_2__2__Impl : ( ']' ) ; + public final void rule__ReferenceDeclaration__Group_2__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2137:1: ( ( ']' ) ) + // InternalProblem.g:2138:1: ( ']' ) + { + // InternalProblem.g:2138:1: ( ']' ) + // InternalProblem.g:2139:2: ']' + { + before(grammarAccess.getReferenceDeclarationAccess().getRightSquareBracketKeyword_2_2()); + match(input,31,FOLLOW_2); + after(grammarAccess.getReferenceDeclarationAccess().getRightSquareBracketKeyword_2_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group_2__2__Impl" + + + // $ANTLR start "rule__ReferenceDeclaration__Group_4__0" + // InternalProblem.g:2149:1: rule__ReferenceDeclaration__Group_4__0 : rule__ReferenceDeclaration__Group_4__0__Impl rule__ReferenceDeclaration__Group_4__1 ; + public final void rule__ReferenceDeclaration__Group_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2153:1: ( rule__ReferenceDeclaration__Group_4__0__Impl rule__ReferenceDeclaration__Group_4__1 ) + // InternalProblem.g:2154:2: rule__ReferenceDeclaration__Group_4__0__Impl rule__ReferenceDeclaration__Group_4__1 + { + pushFollow(FOLLOW_5); + rule__ReferenceDeclaration__Group_4__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__Group_4__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group_4__0" + + + // $ANTLR start "rule__ReferenceDeclaration__Group_4__0__Impl" + // InternalProblem.g:2161:1: rule__ReferenceDeclaration__Group_4__0__Impl : ( 'opposite' ) ; + public final void rule__ReferenceDeclaration__Group_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2165:1: ( ( 'opposite' ) ) + // InternalProblem.g:2166:1: ( 'opposite' ) + { + // InternalProblem.g:2166:1: ( 'opposite' ) + // InternalProblem.g:2167:2: 'opposite' + { + before(grammarAccess.getReferenceDeclarationAccess().getOppositeKeyword_4_0()); + match(input,32,FOLLOW_2); + after(grammarAccess.getReferenceDeclarationAccess().getOppositeKeyword_4_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group_4__0__Impl" + + + // $ANTLR start "rule__ReferenceDeclaration__Group_4__1" + // InternalProblem.g:2176:1: rule__ReferenceDeclaration__Group_4__1 : rule__ReferenceDeclaration__Group_4__1__Impl ; + public final void rule__ReferenceDeclaration__Group_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2180:1: ( rule__ReferenceDeclaration__Group_4__1__Impl ) + // InternalProblem.g:2181:2: rule__ReferenceDeclaration__Group_4__1__Impl + { + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__Group_4__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group_4__1" + + + // $ANTLR start "rule__ReferenceDeclaration__Group_4__1__Impl" + // InternalProblem.g:2187:1: rule__ReferenceDeclaration__Group_4__1__Impl : ( ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) ) ; + public final void rule__ReferenceDeclaration__Group_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2191:1: ( ( ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) ) ) + // InternalProblem.g:2192:1: ( ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) ) + { + // InternalProblem.g:2192:1: ( ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) ) + // InternalProblem.g:2193:2: ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) + { + before(grammarAccess.getReferenceDeclarationAccess().getOppositeAssignment_4_1()); + // InternalProblem.g:2194:2: ( rule__ReferenceDeclaration__OppositeAssignment_4_1 ) + // InternalProblem.g:2194:3: rule__ReferenceDeclaration__OppositeAssignment_4_1 + { + pushFollow(FOLLOW_2); + rule__ReferenceDeclaration__OppositeAssignment_4_1(); + + state._fsp--; + + + } + + after(grammarAccess.getReferenceDeclarationAccess().getOppositeAssignment_4_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__Group_4__1__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group__0" + // InternalProblem.g:2203:1: rule__PredicateDefinition__Group__0 : rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1 ; + public final void rule__PredicateDefinition__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2207:1: ( rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1 ) + // InternalProblem.g:2208:2: rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1 + { + pushFollow(FOLLOW_5); + rule__PredicateDefinition__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group__0" + + + // $ANTLR start "rule__PredicateDefinition__Group__0__Impl" + // InternalProblem.g:2215:1: rule__PredicateDefinition__Group__0__Impl : ( ( rule__PredicateDefinition__Alternatives_0 ) ) ; + public final void rule__PredicateDefinition__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2219:1: ( ( ( rule__PredicateDefinition__Alternatives_0 ) ) ) + // InternalProblem.g:2220:1: ( ( rule__PredicateDefinition__Alternatives_0 ) ) + { + // InternalProblem.g:2220:1: ( ( rule__PredicateDefinition__Alternatives_0 ) ) + // InternalProblem.g:2221:2: ( rule__PredicateDefinition__Alternatives_0 ) + { + before(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); + // InternalProblem.g:2222:2: ( rule__PredicateDefinition__Alternatives_0 ) + // InternalProblem.g:2222:3: rule__PredicateDefinition__Alternatives_0 + { + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Alternatives_0(); + + state._fsp--; + + + } + + after(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group__0__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group__1" + // InternalProblem.g:2230:1: rule__PredicateDefinition__Group__1 : rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2 ; + public final void rule__PredicateDefinition__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2234:1: ( rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2 ) + // InternalProblem.g:2235:2: rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2 + { + pushFollow(FOLLOW_22); + rule__PredicateDefinition__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group__1" + + + // $ANTLR start "rule__PredicateDefinition__Group__1__Impl" + // InternalProblem.g:2242:1: rule__PredicateDefinition__Group__1__Impl : ( ( rule__PredicateDefinition__NameAssignment_1 ) ) ; + public final void rule__PredicateDefinition__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2246:1: ( ( ( rule__PredicateDefinition__NameAssignment_1 ) ) ) + // InternalProblem.g:2247:1: ( ( rule__PredicateDefinition__NameAssignment_1 ) ) + { + // InternalProblem.g:2247:1: ( ( rule__PredicateDefinition__NameAssignment_1 ) ) + // InternalProblem.g:2248:2: ( rule__PredicateDefinition__NameAssignment_1 ) + { + before(grammarAccess.getPredicateDefinitionAccess().getNameAssignment_1()); + // InternalProblem.g:2249:2: ( rule__PredicateDefinition__NameAssignment_1 ) + // InternalProblem.g:2249:3: rule__PredicateDefinition__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__PredicateDefinition__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPredicateDefinitionAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group__1__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group__2" + // InternalProblem.g:2257:1: rule__PredicateDefinition__Group__2 : rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3 ; + public final void rule__PredicateDefinition__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2261:1: ( rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3 ) + // InternalProblem.g:2262:2: rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3 + { + pushFollow(FOLLOW_23); + rule__PredicateDefinition__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group__2" + + + // $ANTLR start "rule__PredicateDefinition__Group__2__Impl" + // InternalProblem.g:2269:1: rule__PredicateDefinition__Group__2__Impl : ( '(' ) ; + public final void rule__PredicateDefinition__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2273:1: ( ( '(' ) ) + // InternalProblem.g:2274:1: ( '(' ) + { + // InternalProblem.g:2274:1: ( '(' ) + // InternalProblem.g:2275:2: '(' + { + before(grammarAccess.getPredicateDefinitionAccess().getLeftParenthesisKeyword_2()); + match(input,33,FOLLOW_2); + after(grammarAccess.getPredicateDefinitionAccess().getLeftParenthesisKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group__2__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group__3" + // InternalProblem.g:2284:1: rule__PredicateDefinition__Group__3 : rule__PredicateDefinition__Group__3__Impl rule__PredicateDefinition__Group__4 ; + public final void rule__PredicateDefinition__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2288:1: ( rule__PredicateDefinition__Group__3__Impl rule__PredicateDefinition__Group__4 ) + // InternalProblem.g:2289:2: rule__PredicateDefinition__Group__3__Impl rule__PredicateDefinition__Group__4 + { + pushFollow(FOLLOW_23); + rule__PredicateDefinition__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group__3" + + + // $ANTLR start "rule__PredicateDefinition__Group__3__Impl" + // InternalProblem.g:2296:1: rule__PredicateDefinition__Group__3__Impl : ( ( rule__PredicateDefinition__Group_3__0 )? ) ; + public final void rule__PredicateDefinition__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2300:1: ( ( ( rule__PredicateDefinition__Group_3__0 )? ) ) + // InternalProblem.g:2301:1: ( ( rule__PredicateDefinition__Group_3__0 )? ) + { + // InternalProblem.g:2301:1: ( ( rule__PredicateDefinition__Group_3__0 )? ) + // InternalProblem.g:2302:2: ( rule__PredicateDefinition__Group_3__0 )? + { + before(grammarAccess.getPredicateDefinitionAccess().getGroup_3()); + // InternalProblem.g:2303:2: ( rule__PredicateDefinition__Group_3__0 )? + int alt31=2; + int LA31_0 = input.LA(1); + + if ( ((LA31_0>=RULE_QUOTED_ID && LA31_0<=RULE_ID)||(LA31_0>=19 && LA31_0<=20)) ) { + alt31=1; + } + switch (alt31) { + case 1 : + // InternalProblem.g:2303:3: rule__PredicateDefinition__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group_3__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getPredicateDefinitionAccess().getGroup_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group__3__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group__4" + // InternalProblem.g:2311:1: rule__PredicateDefinition__Group__4 : rule__PredicateDefinition__Group__4__Impl rule__PredicateDefinition__Group__5 ; + public final void rule__PredicateDefinition__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2315:1: ( rule__PredicateDefinition__Group__4__Impl rule__PredicateDefinition__Group__5 ) + // InternalProblem.g:2316:2: rule__PredicateDefinition__Group__4__Impl rule__PredicateDefinition__Group__5 + { + pushFollow(FOLLOW_24); + rule__PredicateDefinition__Group__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group__4" + + + // $ANTLR start "rule__PredicateDefinition__Group__4__Impl" + // InternalProblem.g:2323:1: rule__PredicateDefinition__Group__4__Impl : ( ')' ) ; + public final void rule__PredicateDefinition__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2327:1: ( ( ')' ) ) + // InternalProblem.g:2328:1: ( ')' ) + { + // InternalProblem.g:2328:1: ( ')' ) + // InternalProblem.g:2329:2: ')' + { + before(grammarAccess.getPredicateDefinitionAccess().getRightParenthesisKeyword_4()); + match(input,34,FOLLOW_2); + after(grammarAccess.getPredicateDefinitionAccess().getRightParenthesisKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group__4__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group__5" + // InternalProblem.g:2338:1: rule__PredicateDefinition__Group__5 : rule__PredicateDefinition__Group__5__Impl rule__PredicateDefinition__Group__6 ; + public final void rule__PredicateDefinition__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2342:1: ( rule__PredicateDefinition__Group__5__Impl rule__PredicateDefinition__Group__6 ) + // InternalProblem.g:2343:2: rule__PredicateDefinition__Group__5__Impl rule__PredicateDefinition__Group__6 + { + pushFollow(FOLLOW_24); + rule__PredicateDefinition__Group__5__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group__6(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group__5" + + + // $ANTLR start "rule__PredicateDefinition__Group__5__Impl" + // InternalProblem.g:2350:1: rule__PredicateDefinition__Group__5__Impl : ( ( rule__PredicateDefinition__Group_5__0 )? ) ; + public final void rule__PredicateDefinition__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2354:1: ( ( ( rule__PredicateDefinition__Group_5__0 )? ) ) + // InternalProblem.g:2355:1: ( ( rule__PredicateDefinition__Group_5__0 )? ) + { + // InternalProblem.g:2355:1: ( ( rule__PredicateDefinition__Group_5__0 )? ) + // InternalProblem.g:2356:2: ( rule__PredicateDefinition__Group_5__0 )? + { + before(grammarAccess.getPredicateDefinitionAccess().getGroup_5()); + // InternalProblem.g:2357:2: ( rule__PredicateDefinition__Group_5__0 )? + int alt32=2; + int LA32_0 = input.LA(1); + + if ( (LA32_0==35) ) { + alt32=1; + } + switch (alt32) { + case 1 : + // InternalProblem.g:2357:3: rule__PredicateDefinition__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group_5__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getPredicateDefinitionAccess().getGroup_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group__5__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group__6" + // InternalProblem.g:2365:1: rule__PredicateDefinition__Group__6 : rule__PredicateDefinition__Group__6__Impl ; + public final void rule__PredicateDefinition__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2369:1: ( rule__PredicateDefinition__Group__6__Impl ) + // InternalProblem.g:2370:2: rule__PredicateDefinition__Group__6__Impl + { + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group__6__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group__6" + + + // $ANTLR start "rule__PredicateDefinition__Group__6__Impl" + // InternalProblem.g:2376:1: rule__PredicateDefinition__Group__6__Impl : ( '.' ) ; + public final void rule__PredicateDefinition__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2380:1: ( ( '.' ) ) + // InternalProblem.g:2381:1: ( '.' ) + { + // InternalProblem.g:2381:1: ( '.' ) + // InternalProblem.g:2382:2: '.' + { + before(grammarAccess.getPredicateDefinitionAccess().getFullStopKeyword_6()); + match(input,12,FOLLOW_2); + after(grammarAccess.getPredicateDefinitionAccess().getFullStopKeyword_6()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group__6__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group_0_0__0" + // InternalProblem.g:2392:1: rule__PredicateDefinition__Group_0_0__0 : rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1 ; + public final void rule__PredicateDefinition__Group_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2396:1: ( rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1 ) + // InternalProblem.g:2397:2: rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1 + { + pushFollow(FOLLOW_25); + rule__PredicateDefinition__Group_0_0__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group_0_0__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_0_0__0" + + + // $ANTLR start "rule__PredicateDefinition__Group_0_0__0__Impl" + // InternalProblem.g:2404:1: rule__PredicateDefinition__Group_0_0__0__Impl : ( ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) ) ; + public final void rule__PredicateDefinition__Group_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2408:1: ( ( ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) ) ) + // InternalProblem.g:2409:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) ) + { + // InternalProblem.g:2409:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) ) + // InternalProblem.g:2410:2: ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) + { + before(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_0()); + // InternalProblem.g:2411:2: ( rule__PredicateDefinition__ErrorAssignment_0_0_0 ) + // InternalProblem.g:2411:3: rule__PredicateDefinition__ErrorAssignment_0_0_0 + { + pushFollow(FOLLOW_2); + rule__PredicateDefinition__ErrorAssignment_0_0_0(); + + state._fsp--; + + + } + + after(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_0_0__0__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group_0_0__1" + // InternalProblem.g:2419:1: rule__PredicateDefinition__Group_0_0__1 : rule__PredicateDefinition__Group_0_0__1__Impl ; + public final void rule__PredicateDefinition__Group_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2423:1: ( rule__PredicateDefinition__Group_0_0__1__Impl ) + // InternalProblem.g:2424:2: rule__PredicateDefinition__Group_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group_0_0__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_0_0__1" + + + // $ANTLR start "rule__PredicateDefinition__Group_0_0__1__Impl" + // InternalProblem.g:2430:1: rule__PredicateDefinition__Group_0_0__1__Impl : ( ( 'pred' )? ) ; + public final void rule__PredicateDefinition__Group_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2434:1: ( ( ( 'pred' )? ) ) + // InternalProblem.g:2435:1: ( ( 'pred' )? ) + { + // InternalProblem.g:2435:1: ( ( 'pred' )? ) + // InternalProblem.g:2436:2: ( 'pred' )? + { + before(grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_0_1()); + // InternalProblem.g:2437:2: ( 'pred' )? + int alt33=2; + int LA33_0 = input.LA(1); + + if ( (LA33_0==16) ) { + alt33=1; + } + switch (alt33) { + case 1 : + // InternalProblem.g:2437:3: 'pred' + { + match(input,16,FOLLOW_2); + + } + break; + + } + + after(grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_0_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_0_0__1__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group_3__0" + // InternalProblem.g:2446:1: rule__PredicateDefinition__Group_3__0 : rule__PredicateDefinition__Group_3__0__Impl rule__PredicateDefinition__Group_3__1 ; + public final void rule__PredicateDefinition__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2450:1: ( rule__PredicateDefinition__Group_3__0__Impl rule__PredicateDefinition__Group_3__1 ) + // InternalProblem.g:2451:2: rule__PredicateDefinition__Group_3__0__Impl rule__PredicateDefinition__Group_3__1 + { + pushFollow(FOLLOW_9); + rule__PredicateDefinition__Group_3__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group_3__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_3__0" + + + // $ANTLR start "rule__PredicateDefinition__Group_3__0__Impl" + // InternalProblem.g:2458:1: rule__PredicateDefinition__Group_3__0__Impl : ( ( rule__PredicateDefinition__ParametersAssignment_3_0 ) ) ; + public final void rule__PredicateDefinition__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2462:1: ( ( ( rule__PredicateDefinition__ParametersAssignment_3_0 ) ) ) + // InternalProblem.g:2463:1: ( ( rule__PredicateDefinition__ParametersAssignment_3_0 ) ) + { + // InternalProblem.g:2463:1: ( ( rule__PredicateDefinition__ParametersAssignment_3_0 ) ) + // InternalProblem.g:2464:2: ( rule__PredicateDefinition__ParametersAssignment_3_0 ) + { + before(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_0()); + // InternalProblem.g:2465:2: ( rule__PredicateDefinition__ParametersAssignment_3_0 ) + // InternalProblem.g:2465:3: rule__PredicateDefinition__ParametersAssignment_3_0 + { + pushFollow(FOLLOW_2); + rule__PredicateDefinition__ParametersAssignment_3_0(); + + state._fsp--; + + + } + + after(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_3__0__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group_3__1" + // InternalProblem.g:2473:1: rule__PredicateDefinition__Group_3__1 : rule__PredicateDefinition__Group_3__1__Impl ; + public final void rule__PredicateDefinition__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2477:1: ( rule__PredicateDefinition__Group_3__1__Impl ) + // InternalProblem.g:2478:2: rule__PredicateDefinition__Group_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group_3__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_3__1" + + + // $ANTLR start "rule__PredicateDefinition__Group_3__1__Impl" + // InternalProblem.g:2484:1: rule__PredicateDefinition__Group_3__1__Impl : ( ( rule__PredicateDefinition__Group_3_1__0 )* ) ; + public final void rule__PredicateDefinition__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2488:1: ( ( ( rule__PredicateDefinition__Group_3_1__0 )* ) ) + // InternalProblem.g:2489:1: ( ( rule__PredicateDefinition__Group_3_1__0 )* ) + { + // InternalProblem.g:2489:1: ( ( rule__PredicateDefinition__Group_3_1__0 )* ) + // InternalProblem.g:2490:2: ( rule__PredicateDefinition__Group_3_1__0 )* + { + before(grammarAccess.getPredicateDefinitionAccess().getGroup_3_1()); + // InternalProblem.g:2491:2: ( rule__PredicateDefinition__Group_3_1__0 )* + loop34: + do { + int alt34=2; + int LA34_0 = input.LA(1); + + if ( (LA34_0==13) ) { + alt34=1; + } + + + switch (alt34) { + case 1 : + // InternalProblem.g:2491:3: rule__PredicateDefinition__Group_3_1__0 + { + pushFollow(FOLLOW_10); + rule__PredicateDefinition__Group_3_1__0(); + + state._fsp--; + + + } + break; + + default : + break loop34; + } + } while (true); + + after(grammarAccess.getPredicateDefinitionAccess().getGroup_3_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_3__1__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group_3_1__0" + // InternalProblem.g:2500:1: rule__PredicateDefinition__Group_3_1__0 : rule__PredicateDefinition__Group_3_1__0__Impl rule__PredicateDefinition__Group_3_1__1 ; + public final void rule__PredicateDefinition__Group_3_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2504:1: ( rule__PredicateDefinition__Group_3_1__0__Impl rule__PredicateDefinition__Group_3_1__1 ) + // InternalProblem.g:2505:2: rule__PredicateDefinition__Group_3_1__0__Impl rule__PredicateDefinition__Group_3_1__1 + { + pushFollow(FOLLOW_5); + rule__PredicateDefinition__Group_3_1__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group_3_1__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_3_1__0" + + + // $ANTLR start "rule__PredicateDefinition__Group_3_1__0__Impl" + // InternalProblem.g:2512:1: rule__PredicateDefinition__Group_3_1__0__Impl : ( ',' ) ; + public final void rule__PredicateDefinition__Group_3_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2516:1: ( ( ',' ) ) + // InternalProblem.g:2517:1: ( ',' ) + { + // InternalProblem.g:2517:1: ( ',' ) + // InternalProblem.g:2518:2: ',' + { + before(grammarAccess.getPredicateDefinitionAccess().getCommaKeyword_3_1_0()); + match(input,13,FOLLOW_2); + after(grammarAccess.getPredicateDefinitionAccess().getCommaKeyword_3_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_3_1__0__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group_3_1__1" + // InternalProblem.g:2527:1: rule__PredicateDefinition__Group_3_1__1 : rule__PredicateDefinition__Group_3_1__1__Impl ; + public final void rule__PredicateDefinition__Group_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2531:1: ( rule__PredicateDefinition__Group_3_1__1__Impl ) + // InternalProblem.g:2532:2: rule__PredicateDefinition__Group_3_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group_3_1__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_3_1__1" + + + // $ANTLR start "rule__PredicateDefinition__Group_3_1__1__Impl" + // InternalProblem.g:2538:1: rule__PredicateDefinition__Group_3_1__1__Impl : ( ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) ) ; + public final void rule__PredicateDefinition__Group_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2542:1: ( ( ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) ) ) + // InternalProblem.g:2543:1: ( ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) ) + { + // InternalProblem.g:2543:1: ( ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) ) + // InternalProblem.g:2544:2: ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) + { + before(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_1_1()); + // InternalProblem.g:2545:2: ( rule__PredicateDefinition__ParametersAssignment_3_1_1 ) + // InternalProblem.g:2545:3: rule__PredicateDefinition__ParametersAssignment_3_1_1 + { + pushFollow(FOLLOW_2); + rule__PredicateDefinition__ParametersAssignment_3_1_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPredicateDefinitionAccess().getParametersAssignment_3_1_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_3_1__1__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group_5__0" + // InternalProblem.g:2554:1: rule__PredicateDefinition__Group_5__0 : rule__PredicateDefinition__Group_5__0__Impl rule__PredicateDefinition__Group_5__1 ; + public final void rule__PredicateDefinition__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2558:1: ( rule__PredicateDefinition__Group_5__0__Impl rule__PredicateDefinition__Group_5__1 ) + // InternalProblem.g:2559:2: rule__PredicateDefinition__Group_5__0__Impl rule__PredicateDefinition__Group_5__1 + { + pushFollow(FOLLOW_26); + rule__PredicateDefinition__Group_5__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group_5__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_5__0" + + + // $ANTLR start "rule__PredicateDefinition__Group_5__0__Impl" + // InternalProblem.g:2566:1: rule__PredicateDefinition__Group_5__0__Impl : ( ':-' ) ; + public final void rule__PredicateDefinition__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2570:1: ( ( ':-' ) ) + // InternalProblem.g:2571:1: ( ':-' ) + { + // InternalProblem.g:2571:1: ( ':-' ) + // InternalProblem.g:2572:2: ':-' + { + before(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_5_0()); + match(input,35,FOLLOW_2); + after(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_5__0__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group_5__1" + // InternalProblem.g:2581:1: rule__PredicateDefinition__Group_5__1 : rule__PredicateDefinition__Group_5__1__Impl rule__PredicateDefinition__Group_5__2 ; + public final void rule__PredicateDefinition__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2585:1: ( rule__PredicateDefinition__Group_5__1__Impl rule__PredicateDefinition__Group_5__2 ) + // InternalProblem.g:2586:2: rule__PredicateDefinition__Group_5__1__Impl rule__PredicateDefinition__Group_5__2 + { + pushFollow(FOLLOW_13); + rule__PredicateDefinition__Group_5__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group_5__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_5__1" + + + // $ANTLR start "rule__PredicateDefinition__Group_5__1__Impl" + // InternalProblem.g:2593:1: rule__PredicateDefinition__Group_5__1__Impl : ( ( rule__PredicateDefinition__BodiesAssignment_5_1 ) ) ; + public final void rule__PredicateDefinition__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2597:1: ( ( ( rule__PredicateDefinition__BodiesAssignment_5_1 ) ) ) + // InternalProblem.g:2598:1: ( ( rule__PredicateDefinition__BodiesAssignment_5_1 ) ) + { + // InternalProblem.g:2598:1: ( ( rule__PredicateDefinition__BodiesAssignment_5_1 ) ) + // InternalProblem.g:2599:2: ( rule__PredicateDefinition__BodiesAssignment_5_1 ) + { + before(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_1()); + // InternalProblem.g:2600:2: ( rule__PredicateDefinition__BodiesAssignment_5_1 ) + // InternalProblem.g:2600:3: rule__PredicateDefinition__BodiesAssignment_5_1 + { + pushFollow(FOLLOW_2); + rule__PredicateDefinition__BodiesAssignment_5_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_5__1__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group_5__2" + // InternalProblem.g:2608:1: rule__PredicateDefinition__Group_5__2 : rule__PredicateDefinition__Group_5__2__Impl ; + public final void rule__PredicateDefinition__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2612:1: ( rule__PredicateDefinition__Group_5__2__Impl ) + // InternalProblem.g:2613:2: rule__PredicateDefinition__Group_5__2__Impl + { + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group_5__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_5__2" + + + // $ANTLR start "rule__PredicateDefinition__Group_5__2__Impl" + // InternalProblem.g:2619:1: rule__PredicateDefinition__Group_5__2__Impl : ( ( rule__PredicateDefinition__Group_5_2__0 )* ) ; + public final void rule__PredicateDefinition__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2623:1: ( ( ( rule__PredicateDefinition__Group_5_2__0 )* ) ) + // InternalProblem.g:2624:1: ( ( rule__PredicateDefinition__Group_5_2__0 )* ) + { + // InternalProblem.g:2624:1: ( ( rule__PredicateDefinition__Group_5_2__0 )* ) + // InternalProblem.g:2625:2: ( rule__PredicateDefinition__Group_5_2__0 )* + { + before(grammarAccess.getPredicateDefinitionAccess().getGroup_5_2()); + // InternalProblem.g:2626:2: ( rule__PredicateDefinition__Group_5_2__0 )* + loop35: + do { + int alt35=2; + int LA35_0 = input.LA(1); + + if ( (LA35_0==14) ) { + alt35=1; + } + + + switch (alt35) { + case 1 : + // InternalProblem.g:2626:3: rule__PredicateDefinition__Group_5_2__0 + { + pushFollow(FOLLOW_27); + rule__PredicateDefinition__Group_5_2__0(); + + state._fsp--; + + + } + break; + + default : + break loop35; + } + } while (true); + + after(grammarAccess.getPredicateDefinitionAccess().getGroup_5_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_5__2__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group_5_2__0" + // InternalProblem.g:2635:1: rule__PredicateDefinition__Group_5_2__0 : rule__PredicateDefinition__Group_5_2__0__Impl rule__PredicateDefinition__Group_5_2__1 ; + public final void rule__PredicateDefinition__Group_5_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2639:1: ( rule__PredicateDefinition__Group_5_2__0__Impl rule__PredicateDefinition__Group_5_2__1 ) + // InternalProblem.g:2640:2: rule__PredicateDefinition__Group_5_2__0__Impl rule__PredicateDefinition__Group_5_2__1 + { + pushFollow(FOLLOW_26); + rule__PredicateDefinition__Group_5_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group_5_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_5_2__0" + + + // $ANTLR start "rule__PredicateDefinition__Group_5_2__0__Impl" + // InternalProblem.g:2647:1: rule__PredicateDefinition__Group_5_2__0__Impl : ( ';' ) ; + public final void rule__PredicateDefinition__Group_5_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2651:1: ( ( ';' ) ) + // InternalProblem.g:2652:1: ( ';' ) + { + // InternalProblem.g:2652:1: ( ';' ) + // InternalProblem.g:2653:2: ';' + { + before(grammarAccess.getPredicateDefinitionAccess().getSemicolonKeyword_5_2_0()); + match(input,14,FOLLOW_2); + after(grammarAccess.getPredicateDefinitionAccess().getSemicolonKeyword_5_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_5_2__0__Impl" + + + // $ANTLR start "rule__PredicateDefinition__Group_5_2__1" + // InternalProblem.g:2662:1: rule__PredicateDefinition__Group_5_2__1 : rule__PredicateDefinition__Group_5_2__1__Impl ; + public final void rule__PredicateDefinition__Group_5_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2666:1: ( rule__PredicateDefinition__Group_5_2__1__Impl ) + // InternalProblem.g:2667:2: rule__PredicateDefinition__Group_5_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__PredicateDefinition__Group_5_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_5_2__1" + + + // $ANTLR start "rule__PredicateDefinition__Group_5_2__1__Impl" + // InternalProblem.g:2673:1: rule__PredicateDefinition__Group_5_2__1__Impl : ( ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) ) ; + public final void rule__PredicateDefinition__Group_5_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2677:1: ( ( ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) ) ) + // InternalProblem.g:2678:1: ( ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) ) + { + // InternalProblem.g:2678:1: ( ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) ) + // InternalProblem.g:2679:2: ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) + { + before(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_2_1()); + // InternalProblem.g:2680:2: ( rule__PredicateDefinition__BodiesAssignment_5_2_1 ) + // InternalProblem.g:2680:3: rule__PredicateDefinition__BodiesAssignment_5_2_1 + { + pushFollow(FOLLOW_2); + rule__PredicateDefinition__BodiesAssignment_5_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getPredicateDefinitionAccess().getBodiesAssignment_5_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__Group_5_2__1__Impl" + + + // $ANTLR start "rule__Parameter__Group__0" + // InternalProblem.g:2689:1: rule__Parameter__Group__0 : rule__Parameter__Group__0__Impl rule__Parameter__Group__1 ; + public final void rule__Parameter__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2693:1: ( rule__Parameter__Group__0__Impl rule__Parameter__Group__1 ) + // InternalProblem.g:2694:2: rule__Parameter__Group__0__Impl rule__Parameter__Group__1 + { + pushFollow(FOLLOW_5); + rule__Parameter__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Parameter__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__0" + + + // $ANTLR start "rule__Parameter__Group__0__Impl" + // InternalProblem.g:2701:1: rule__Parameter__Group__0__Impl : ( ( rule__Parameter__ParameterTypeAssignment_0 )? ) ; + public final void rule__Parameter__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2705:1: ( ( ( rule__Parameter__ParameterTypeAssignment_0 )? ) ) + // InternalProblem.g:2706:1: ( ( rule__Parameter__ParameterTypeAssignment_0 )? ) + { + // InternalProblem.g:2706:1: ( ( rule__Parameter__ParameterTypeAssignment_0 )? ) + // InternalProblem.g:2707:2: ( rule__Parameter__ParameterTypeAssignment_0 )? + { + before(grammarAccess.getParameterAccess().getParameterTypeAssignment_0()); + // InternalProblem.g:2708:2: ( rule__Parameter__ParameterTypeAssignment_0 )? + int alt36=2; + switch ( input.LA(1) ) { + case RULE_QUOTED_ID: + { + alt36=1; + } + break; + case RULE_ID: + { + int LA36_2 = input.LA(2); + + if ( (LA36_2==RULE_ID||(LA36_2>=19 && LA36_2<=20)||LA36_2==36) ) { + alt36=1; + } + } + break; + case 19: + { + int LA36_3 = input.LA(2); + + if ( (LA36_3==RULE_ID||(LA36_3>=19 && LA36_3<=20)||LA36_3==36) ) { + alt36=1; + } + } + break; + case 20: + { + int LA36_4 = input.LA(2); + + if ( (LA36_4==RULE_ID||(LA36_4>=19 && LA36_4<=20)||LA36_4==36) ) { + alt36=1; + } + } + break; + } + + switch (alt36) { + case 1 : + // InternalProblem.g:2708:3: rule__Parameter__ParameterTypeAssignment_0 + { + pushFollow(FOLLOW_2); + rule__Parameter__ParameterTypeAssignment_0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getParameterAccess().getParameterTypeAssignment_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__0__Impl" + + + // $ANTLR start "rule__Parameter__Group__1" + // InternalProblem.g:2716:1: rule__Parameter__Group__1 : rule__Parameter__Group__1__Impl ; + public final void rule__Parameter__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2720:1: ( rule__Parameter__Group__1__Impl ) + // InternalProblem.g:2721:2: rule__Parameter__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Parameter__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__1" + + + // $ANTLR start "rule__Parameter__Group__1__Impl" + // InternalProblem.g:2727:1: rule__Parameter__Group__1__Impl : ( ( rule__Parameter__NameAssignment_1 ) ) ; + public final void rule__Parameter__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2731:1: ( ( ( rule__Parameter__NameAssignment_1 ) ) ) + // InternalProblem.g:2732:1: ( ( rule__Parameter__NameAssignment_1 ) ) + { + // InternalProblem.g:2732:1: ( ( rule__Parameter__NameAssignment_1 ) ) + // InternalProblem.g:2733:2: ( rule__Parameter__NameAssignment_1 ) + { + before(grammarAccess.getParameterAccess().getNameAssignment_1()); + // InternalProblem.g:2734:2: ( rule__Parameter__NameAssignment_1 ) + // InternalProblem.g:2734:3: rule__Parameter__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__Parameter__NameAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getParameterAccess().getNameAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__Group__1__Impl" + + + // $ANTLR start "rule__Conjunction__Group__0" + // InternalProblem.g:2743:1: rule__Conjunction__Group__0 : rule__Conjunction__Group__0__Impl rule__Conjunction__Group__1 ; + public final void rule__Conjunction__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2747:1: ( rule__Conjunction__Group__0__Impl rule__Conjunction__Group__1 ) + // InternalProblem.g:2748:2: rule__Conjunction__Group__0__Impl rule__Conjunction__Group__1 + { + pushFollow(FOLLOW_9); + rule__Conjunction__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Conjunction__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Conjunction__Group__0" + + + // $ANTLR start "rule__Conjunction__Group__0__Impl" + // InternalProblem.g:2755:1: rule__Conjunction__Group__0__Impl : ( ( rule__Conjunction__LiteralsAssignment_0 ) ) ; + public final void rule__Conjunction__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2759:1: ( ( ( rule__Conjunction__LiteralsAssignment_0 ) ) ) + // InternalProblem.g:2760:1: ( ( rule__Conjunction__LiteralsAssignment_0 ) ) + { + // InternalProblem.g:2760:1: ( ( rule__Conjunction__LiteralsAssignment_0 ) ) + // InternalProblem.g:2761:2: ( rule__Conjunction__LiteralsAssignment_0 ) + { + before(grammarAccess.getConjunctionAccess().getLiteralsAssignment_0()); + // InternalProblem.g:2762:2: ( rule__Conjunction__LiteralsAssignment_0 ) + // InternalProblem.g:2762:3: rule__Conjunction__LiteralsAssignment_0 + { + pushFollow(FOLLOW_2); + rule__Conjunction__LiteralsAssignment_0(); + + state._fsp--; + + + } + + after(grammarAccess.getConjunctionAccess().getLiteralsAssignment_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Conjunction__Group__0__Impl" + + + // $ANTLR start "rule__Conjunction__Group__1" + // InternalProblem.g:2770:1: rule__Conjunction__Group__1 : rule__Conjunction__Group__1__Impl ; + public final void rule__Conjunction__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2774:1: ( rule__Conjunction__Group__1__Impl ) + // InternalProblem.g:2775:2: rule__Conjunction__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Conjunction__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Conjunction__Group__1" + + + // $ANTLR start "rule__Conjunction__Group__1__Impl" + // InternalProblem.g:2781:1: rule__Conjunction__Group__1__Impl : ( ( rule__Conjunction__Group_1__0 )* ) ; + public final void rule__Conjunction__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2785:1: ( ( ( rule__Conjunction__Group_1__0 )* ) ) + // InternalProblem.g:2786:1: ( ( rule__Conjunction__Group_1__0 )* ) + { + // InternalProblem.g:2786:1: ( ( rule__Conjunction__Group_1__0 )* ) + // InternalProblem.g:2787:2: ( rule__Conjunction__Group_1__0 )* + { + before(grammarAccess.getConjunctionAccess().getGroup_1()); + // InternalProblem.g:2788:2: ( rule__Conjunction__Group_1__0 )* + loop37: + do { + int alt37=2; + int LA37_0 = input.LA(1); + + if ( (LA37_0==13) ) { + alt37=1; + } + + + switch (alt37) { + case 1 : + // InternalProblem.g:2788:3: rule__Conjunction__Group_1__0 + { + pushFollow(FOLLOW_10); + rule__Conjunction__Group_1__0(); + + state._fsp--; + + + } + break; + + default : + break loop37; + } + } while (true); + + after(grammarAccess.getConjunctionAccess().getGroup_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Conjunction__Group__1__Impl" + + + // $ANTLR start "rule__Conjunction__Group_1__0" + // InternalProblem.g:2797:1: rule__Conjunction__Group_1__0 : rule__Conjunction__Group_1__0__Impl rule__Conjunction__Group_1__1 ; + public final void rule__Conjunction__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2801:1: ( rule__Conjunction__Group_1__0__Impl rule__Conjunction__Group_1__1 ) + // InternalProblem.g:2802:2: rule__Conjunction__Group_1__0__Impl rule__Conjunction__Group_1__1 + { + pushFollow(FOLLOW_26); + rule__Conjunction__Group_1__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Conjunction__Group_1__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Conjunction__Group_1__0" + + + // $ANTLR start "rule__Conjunction__Group_1__0__Impl" + // InternalProblem.g:2809:1: rule__Conjunction__Group_1__0__Impl : ( ',' ) ; + public final void rule__Conjunction__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2813:1: ( ( ',' ) ) + // InternalProblem.g:2814:1: ( ',' ) + { + // InternalProblem.g:2814:1: ( ',' ) + // InternalProblem.g:2815:2: ',' + { + before(grammarAccess.getConjunctionAccess().getCommaKeyword_1_0()); + match(input,13,FOLLOW_2); + after(grammarAccess.getConjunctionAccess().getCommaKeyword_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Conjunction__Group_1__0__Impl" + + + // $ANTLR start "rule__Conjunction__Group_1__1" + // InternalProblem.g:2824:1: rule__Conjunction__Group_1__1 : rule__Conjunction__Group_1__1__Impl ; + public final void rule__Conjunction__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2828:1: ( rule__Conjunction__Group_1__1__Impl ) + // InternalProblem.g:2829:2: rule__Conjunction__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__Conjunction__Group_1__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Conjunction__Group_1__1" + + + // $ANTLR start "rule__Conjunction__Group_1__1__Impl" + // InternalProblem.g:2835:1: rule__Conjunction__Group_1__1__Impl : ( ( rule__Conjunction__LiteralsAssignment_1_1 ) ) ; + public final void rule__Conjunction__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2839:1: ( ( ( rule__Conjunction__LiteralsAssignment_1_1 ) ) ) + // InternalProblem.g:2840:1: ( ( rule__Conjunction__LiteralsAssignment_1_1 ) ) + { + // InternalProblem.g:2840:1: ( ( rule__Conjunction__LiteralsAssignment_1_1 ) ) + // InternalProblem.g:2841:2: ( rule__Conjunction__LiteralsAssignment_1_1 ) + { + before(grammarAccess.getConjunctionAccess().getLiteralsAssignment_1_1()); + // InternalProblem.g:2842:2: ( rule__Conjunction__LiteralsAssignment_1_1 ) + // InternalProblem.g:2842:3: rule__Conjunction__LiteralsAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__Conjunction__LiteralsAssignment_1_1(); + + state._fsp--; + + + } + + after(grammarAccess.getConjunctionAccess().getLiteralsAssignment_1_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Conjunction__Group_1__1__Impl" + + + // $ANTLR start "rule__NegativeLiteral__Group__0" + // InternalProblem.g:2851:1: rule__NegativeLiteral__Group__0 : rule__NegativeLiteral__Group__0__Impl rule__NegativeLiteral__Group__1 ; + public final void rule__NegativeLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2855:1: ( rule__NegativeLiteral__Group__0__Impl rule__NegativeLiteral__Group__1 ) + // InternalProblem.g:2856:2: rule__NegativeLiteral__Group__0__Impl rule__NegativeLiteral__Group__1 + { + pushFollow(FOLLOW_5); + rule__NegativeLiteral__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__NegativeLiteral__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NegativeLiteral__Group__0" + + + // $ANTLR start "rule__NegativeLiteral__Group__0__Impl" + // InternalProblem.g:2863:1: rule__NegativeLiteral__Group__0__Impl : ( '!' ) ; + public final void rule__NegativeLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2867:1: ( ( '!' ) ) + // InternalProblem.g:2868:1: ( '!' ) + { + // InternalProblem.g:2868:1: ( '!' ) + // InternalProblem.g:2869:2: '!' + { + before(grammarAccess.getNegativeLiteralAccess().getExclamationMarkKeyword_0()); + match(input,22,FOLLOW_2); + after(grammarAccess.getNegativeLiteralAccess().getExclamationMarkKeyword_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NegativeLiteral__Group__0__Impl" + + + // $ANTLR start "rule__NegativeLiteral__Group__1" + // InternalProblem.g:2878:1: rule__NegativeLiteral__Group__1 : rule__NegativeLiteral__Group__1__Impl ; + public final void rule__NegativeLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2882:1: ( rule__NegativeLiteral__Group__1__Impl ) + // InternalProblem.g:2883:2: rule__NegativeLiteral__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__NegativeLiteral__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NegativeLiteral__Group__1" + + + // $ANTLR start "rule__NegativeLiteral__Group__1__Impl" + // InternalProblem.g:2889:1: rule__NegativeLiteral__Group__1__Impl : ( ( rule__NegativeLiteral__AtomAssignment_1 ) ) ; + public final void rule__NegativeLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2893:1: ( ( ( rule__NegativeLiteral__AtomAssignment_1 ) ) ) + // InternalProblem.g:2894:1: ( ( rule__NegativeLiteral__AtomAssignment_1 ) ) + { + // InternalProblem.g:2894:1: ( ( rule__NegativeLiteral__AtomAssignment_1 ) ) + // InternalProblem.g:2895:2: ( rule__NegativeLiteral__AtomAssignment_1 ) + { + before(grammarAccess.getNegativeLiteralAccess().getAtomAssignment_1()); + // InternalProblem.g:2896:2: ( rule__NegativeLiteral__AtomAssignment_1 ) + // InternalProblem.g:2896:3: rule__NegativeLiteral__AtomAssignment_1 + { + pushFollow(FOLLOW_2); + rule__NegativeLiteral__AtomAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getNegativeLiteralAccess().getAtomAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NegativeLiteral__Group__1__Impl" + + + // $ANTLR start "rule__Atom__Group__0" + // InternalProblem.g:2905:1: rule__Atom__Group__0 : rule__Atom__Group__0__Impl rule__Atom__Group__1 ; + public final void rule__Atom__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2909:1: ( rule__Atom__Group__0__Impl rule__Atom__Group__1 ) + // InternalProblem.g:2910:2: rule__Atom__Group__0__Impl rule__Atom__Group__1 + { + pushFollow(FOLLOW_28); + rule__Atom__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Atom__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group__0" + + + // $ANTLR start "rule__Atom__Group__0__Impl" + // InternalProblem.g:2917:1: rule__Atom__Group__0__Impl : ( ( rule__Atom__RelationAssignment_0 ) ) ; + public final void rule__Atom__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2921:1: ( ( ( rule__Atom__RelationAssignment_0 ) ) ) + // InternalProblem.g:2922:1: ( ( rule__Atom__RelationAssignment_0 ) ) + { + // InternalProblem.g:2922:1: ( ( rule__Atom__RelationAssignment_0 ) ) + // InternalProblem.g:2923:2: ( rule__Atom__RelationAssignment_0 ) + { + before(grammarAccess.getAtomAccess().getRelationAssignment_0()); + // InternalProblem.g:2924:2: ( rule__Atom__RelationAssignment_0 ) + // InternalProblem.g:2924:3: rule__Atom__RelationAssignment_0 + { + pushFollow(FOLLOW_2); + rule__Atom__RelationAssignment_0(); + + state._fsp--; + + + } + + after(grammarAccess.getAtomAccess().getRelationAssignment_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group__0__Impl" + + + // $ANTLR start "rule__Atom__Group__1" + // InternalProblem.g:2932:1: rule__Atom__Group__1 : rule__Atom__Group__1__Impl rule__Atom__Group__2 ; + public final void rule__Atom__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2936:1: ( rule__Atom__Group__1__Impl rule__Atom__Group__2 ) + // InternalProblem.g:2937:2: rule__Atom__Group__1__Impl rule__Atom__Group__2 + { + pushFollow(FOLLOW_28); + rule__Atom__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Atom__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group__1" + + + // $ANTLR start "rule__Atom__Group__1__Impl" + // InternalProblem.g:2944:1: rule__Atom__Group__1__Impl : ( ( rule__Atom__TransitiveClosureAssignment_1 )? ) ; + public final void rule__Atom__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2948:1: ( ( ( rule__Atom__TransitiveClosureAssignment_1 )? ) ) + // InternalProblem.g:2949:1: ( ( rule__Atom__TransitiveClosureAssignment_1 )? ) + { + // InternalProblem.g:2949:1: ( ( rule__Atom__TransitiveClosureAssignment_1 )? ) + // InternalProblem.g:2950:2: ( rule__Atom__TransitiveClosureAssignment_1 )? + { + before(grammarAccess.getAtomAccess().getTransitiveClosureAssignment_1()); + // InternalProblem.g:2951:2: ( rule__Atom__TransitiveClosureAssignment_1 )? + int alt38=2; + int LA38_0 = input.LA(1); + + if ( (LA38_0==42) ) { + alt38=1; + } + switch (alt38) { + case 1 : + // InternalProblem.g:2951:3: rule__Atom__TransitiveClosureAssignment_1 + { + pushFollow(FOLLOW_2); + rule__Atom__TransitiveClosureAssignment_1(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getAtomAccess().getTransitiveClosureAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group__1__Impl" + + + // $ANTLR start "rule__Atom__Group__2" + // InternalProblem.g:2959:1: rule__Atom__Group__2 : rule__Atom__Group__2__Impl rule__Atom__Group__3 ; + public final void rule__Atom__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2963:1: ( rule__Atom__Group__2__Impl rule__Atom__Group__3 ) + // InternalProblem.g:2964:2: rule__Atom__Group__2__Impl rule__Atom__Group__3 + { + pushFollow(FOLLOW_23); + rule__Atom__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Atom__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group__2" + + + // $ANTLR start "rule__Atom__Group__2__Impl" + // InternalProblem.g:2971:1: rule__Atom__Group__2__Impl : ( '(' ) ; + public final void rule__Atom__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2975:1: ( ( '(' ) ) + // InternalProblem.g:2976:1: ( '(' ) + { + // InternalProblem.g:2976:1: ( '(' ) + // InternalProblem.g:2977:2: '(' + { + before(grammarAccess.getAtomAccess().getLeftParenthesisKeyword_2()); + match(input,33,FOLLOW_2); + after(grammarAccess.getAtomAccess().getLeftParenthesisKeyword_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group__2__Impl" + + + // $ANTLR start "rule__Atom__Group__3" + // InternalProblem.g:2986:1: rule__Atom__Group__3 : rule__Atom__Group__3__Impl rule__Atom__Group__4 ; + public final void rule__Atom__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:2990:1: ( rule__Atom__Group__3__Impl rule__Atom__Group__4 ) + // InternalProblem.g:2991:2: rule__Atom__Group__3__Impl rule__Atom__Group__4 + { + pushFollow(FOLLOW_23); + rule__Atom__Group__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Atom__Group__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group__3" + + + // $ANTLR start "rule__Atom__Group__3__Impl" + // InternalProblem.g:2998:1: rule__Atom__Group__3__Impl : ( ( rule__Atom__Group_3__0 )? ) ; + public final void rule__Atom__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3002:1: ( ( ( rule__Atom__Group_3__0 )? ) ) + // InternalProblem.g:3003:1: ( ( rule__Atom__Group_3__0 )? ) + { + // InternalProblem.g:3003:1: ( ( rule__Atom__Group_3__0 )? ) + // InternalProblem.g:3004:2: ( rule__Atom__Group_3__0 )? + { + before(grammarAccess.getAtomAccess().getGroup_3()); + // InternalProblem.g:3005:2: ( rule__Atom__Group_3__0 )? + int alt39=2; + int LA39_0 = input.LA(1); + + if ( ((LA39_0>=RULE_QUOTED_ID && LA39_0<=RULE_ID)||(LA39_0>=19 && LA39_0<=20)) ) { + alt39=1; + } + switch (alt39) { + case 1 : + // InternalProblem.g:3005:3: rule__Atom__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__Atom__Group_3__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getAtomAccess().getGroup_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group__3__Impl" + + + // $ANTLR start "rule__Atom__Group__4" + // InternalProblem.g:3013:1: rule__Atom__Group__4 : rule__Atom__Group__4__Impl ; + public final void rule__Atom__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3017:1: ( rule__Atom__Group__4__Impl ) + // InternalProblem.g:3018:2: rule__Atom__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__Atom__Group__4__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group__4" + + + // $ANTLR start "rule__Atom__Group__4__Impl" + // InternalProblem.g:3024:1: rule__Atom__Group__4__Impl : ( ')' ) ; + public final void rule__Atom__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3028:1: ( ( ')' ) ) + // InternalProblem.g:3029:1: ( ')' ) + { + // InternalProblem.g:3029:1: ( ')' ) + // InternalProblem.g:3030:2: ')' + { + before(grammarAccess.getAtomAccess().getRightParenthesisKeyword_4()); + match(input,34,FOLLOW_2); + after(grammarAccess.getAtomAccess().getRightParenthesisKeyword_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group__4__Impl" + + + // $ANTLR start "rule__Atom__Group_3__0" + // InternalProblem.g:3040:1: rule__Atom__Group_3__0 : rule__Atom__Group_3__0__Impl rule__Atom__Group_3__1 ; + public final void rule__Atom__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3044:1: ( rule__Atom__Group_3__0__Impl rule__Atom__Group_3__1 ) + // InternalProblem.g:3045:2: rule__Atom__Group_3__0__Impl rule__Atom__Group_3__1 + { + pushFollow(FOLLOW_9); + rule__Atom__Group_3__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Atom__Group_3__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group_3__0" + + + // $ANTLR start "rule__Atom__Group_3__0__Impl" + // InternalProblem.g:3052:1: rule__Atom__Group_3__0__Impl : ( ( rule__Atom__ArgumentsAssignment_3_0 ) ) ; + public final void rule__Atom__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3056:1: ( ( ( rule__Atom__ArgumentsAssignment_3_0 ) ) ) + // InternalProblem.g:3057:1: ( ( rule__Atom__ArgumentsAssignment_3_0 ) ) + { + // InternalProblem.g:3057:1: ( ( rule__Atom__ArgumentsAssignment_3_0 ) ) + // InternalProblem.g:3058:2: ( rule__Atom__ArgumentsAssignment_3_0 ) + { + before(grammarAccess.getAtomAccess().getArgumentsAssignment_3_0()); + // InternalProblem.g:3059:2: ( rule__Atom__ArgumentsAssignment_3_0 ) + // InternalProblem.g:3059:3: rule__Atom__ArgumentsAssignment_3_0 + { + pushFollow(FOLLOW_2); + rule__Atom__ArgumentsAssignment_3_0(); + + state._fsp--; + + + } + + after(grammarAccess.getAtomAccess().getArgumentsAssignment_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group_3__0__Impl" + + + // $ANTLR start "rule__Atom__Group_3__1" + // InternalProblem.g:3067:1: rule__Atom__Group_3__1 : rule__Atom__Group_3__1__Impl ; + public final void rule__Atom__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3071:1: ( rule__Atom__Group_3__1__Impl ) + // InternalProblem.g:3072:2: rule__Atom__Group_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__Atom__Group_3__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group_3__1" + + + // $ANTLR start "rule__Atom__Group_3__1__Impl" + // InternalProblem.g:3078:1: rule__Atom__Group_3__1__Impl : ( ( rule__Atom__Group_3_1__0 )* ) ; + public final void rule__Atom__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3082:1: ( ( ( rule__Atom__Group_3_1__0 )* ) ) + // InternalProblem.g:3083:1: ( ( rule__Atom__Group_3_1__0 )* ) + { + // InternalProblem.g:3083:1: ( ( rule__Atom__Group_3_1__0 )* ) + // InternalProblem.g:3084:2: ( rule__Atom__Group_3_1__0 )* + { + before(grammarAccess.getAtomAccess().getGroup_3_1()); + // InternalProblem.g:3085:2: ( rule__Atom__Group_3_1__0 )* + loop40: + do { + int alt40=2; + int LA40_0 = input.LA(1); + + if ( (LA40_0==13) ) { + alt40=1; + } + + + switch (alt40) { + case 1 : + // InternalProblem.g:3085:3: rule__Atom__Group_3_1__0 + { + pushFollow(FOLLOW_10); + rule__Atom__Group_3_1__0(); + + state._fsp--; + + + } + break; + + default : + break loop40; + } + } while (true); + + after(grammarAccess.getAtomAccess().getGroup_3_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group_3__1__Impl" + + + // $ANTLR start "rule__Atom__Group_3_1__0" + // InternalProblem.g:3094:1: rule__Atom__Group_3_1__0 : rule__Atom__Group_3_1__0__Impl rule__Atom__Group_3_1__1 ; + public final void rule__Atom__Group_3_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3098:1: ( rule__Atom__Group_3_1__0__Impl rule__Atom__Group_3_1__1 ) + // InternalProblem.g:3099:2: rule__Atom__Group_3_1__0__Impl rule__Atom__Group_3_1__1 + { + pushFollow(FOLLOW_5); + rule__Atom__Group_3_1__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Atom__Group_3_1__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group_3_1__0" + + + // $ANTLR start "rule__Atom__Group_3_1__0__Impl" + // InternalProblem.g:3106:1: rule__Atom__Group_3_1__0__Impl : ( ',' ) ; + public final void rule__Atom__Group_3_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3110:1: ( ( ',' ) ) + // InternalProblem.g:3111:1: ( ',' ) + { + // InternalProblem.g:3111:1: ( ',' ) + // InternalProblem.g:3112:2: ',' + { + before(grammarAccess.getAtomAccess().getCommaKeyword_3_1_0()); + match(input,13,FOLLOW_2); + after(grammarAccess.getAtomAccess().getCommaKeyword_3_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group_3_1__0__Impl" + + + // $ANTLR start "rule__Atom__Group_3_1__1" + // InternalProblem.g:3121:1: rule__Atom__Group_3_1__1 : rule__Atom__Group_3_1__1__Impl ; + public final void rule__Atom__Group_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3125:1: ( rule__Atom__Group_3_1__1__Impl ) + // InternalProblem.g:3126:2: rule__Atom__Group_3_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__Atom__Group_3_1__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group_3_1__1" + + + // $ANTLR start "rule__Atom__Group_3_1__1__Impl" + // InternalProblem.g:3132:1: rule__Atom__Group_3_1__1__Impl : ( ( rule__Atom__ArgumentsAssignment_3_1_1 ) ) ; + public final void rule__Atom__Group_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3136:1: ( ( ( rule__Atom__ArgumentsAssignment_3_1_1 ) ) ) + // InternalProblem.g:3137:1: ( ( rule__Atom__ArgumentsAssignment_3_1_1 ) ) + { + // InternalProblem.g:3137:1: ( ( rule__Atom__ArgumentsAssignment_3_1_1 ) ) + // InternalProblem.g:3138:2: ( rule__Atom__ArgumentsAssignment_3_1_1 ) + { + before(grammarAccess.getAtomAccess().getArgumentsAssignment_3_1_1()); + // InternalProblem.g:3139:2: ( rule__Atom__ArgumentsAssignment_3_1_1 ) + // InternalProblem.g:3139:3: rule__Atom__ArgumentsAssignment_3_1_1 + { + pushFollow(FOLLOW_2); + rule__Atom__ArgumentsAssignment_3_1_1(); + + state._fsp--; + + + } + + after(grammarAccess.getAtomAccess().getArgumentsAssignment_3_1_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__Group_3_1__1__Impl" + + + // $ANTLR start "rule__Assertion__Group__0" + // InternalProblem.g:3148:1: rule__Assertion__Group__0 : rule__Assertion__Group__0__Impl rule__Assertion__Group__1 ; + public final void rule__Assertion__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3152:1: ( rule__Assertion__Group__0__Impl rule__Assertion__Group__1 ) + // InternalProblem.g:3153:2: rule__Assertion__Group__0__Impl rule__Assertion__Group__1 + { + pushFollow(FOLLOW_6); + rule__Assertion__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Assertion__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group__0" + + + // $ANTLR start "rule__Assertion__Group__0__Impl" + // InternalProblem.g:3160:1: rule__Assertion__Group__0__Impl : ( ( rule__Assertion__Alternatives_0 ) ) ; + public final void rule__Assertion__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3164:1: ( ( ( rule__Assertion__Alternatives_0 ) ) ) + // InternalProblem.g:3165:1: ( ( rule__Assertion__Alternatives_0 ) ) + { + // InternalProblem.g:3165:1: ( ( rule__Assertion__Alternatives_0 ) ) + // InternalProblem.g:3166:2: ( rule__Assertion__Alternatives_0 ) + { + before(grammarAccess.getAssertionAccess().getAlternatives_0()); + // InternalProblem.g:3167:2: ( rule__Assertion__Alternatives_0 ) + // InternalProblem.g:3167:3: rule__Assertion__Alternatives_0 + { + pushFollow(FOLLOW_2); + rule__Assertion__Alternatives_0(); + + state._fsp--; + + + } + + after(grammarAccess.getAssertionAccess().getAlternatives_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group__0__Impl" + + + // $ANTLR start "rule__Assertion__Group__1" + // InternalProblem.g:3175:1: rule__Assertion__Group__1 : rule__Assertion__Group__1__Impl ; + public final void rule__Assertion__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3179:1: ( rule__Assertion__Group__1__Impl ) + // InternalProblem.g:3180:2: rule__Assertion__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__Assertion__Group__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group__1" + + + // $ANTLR start "rule__Assertion__Group__1__Impl" + // InternalProblem.g:3186:1: rule__Assertion__Group__1__Impl : ( '.' ) ; + public final void rule__Assertion__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3190:1: ( ( '.' ) ) + // InternalProblem.g:3191:1: ( '.' ) + { + // InternalProblem.g:3191:1: ( '.' ) + // InternalProblem.g:3192:2: '.' + { + before(grammarAccess.getAssertionAccess().getFullStopKeyword_1()); + match(input,12,FOLLOW_2); + after(grammarAccess.getAssertionAccess().getFullStopKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group__1__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_0__0" + // InternalProblem.g:3202:1: rule__Assertion__Group_0_0__0 : rule__Assertion__Group_0_0__0__Impl rule__Assertion__Group_0_0__1 ; + public final void rule__Assertion__Group_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3206:1: ( rule__Assertion__Group_0_0__0__Impl rule__Assertion__Group_0_0__1 ) + // InternalProblem.g:3207:2: rule__Assertion__Group_0_0__0__Impl rule__Assertion__Group_0_0__1 + { + pushFollow(FOLLOW_22); + rule__Assertion__Group_0_0__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_0__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0__0" + + + // $ANTLR start "rule__Assertion__Group_0_0__0__Impl" + // InternalProblem.g:3214:1: rule__Assertion__Group_0_0__0__Impl : ( ( rule__Assertion__RelationAssignment_0_0_0 ) ) ; + public final void rule__Assertion__Group_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3218:1: ( ( ( rule__Assertion__RelationAssignment_0_0_0 ) ) ) + // InternalProblem.g:3219:1: ( ( rule__Assertion__RelationAssignment_0_0_0 ) ) + { + // InternalProblem.g:3219:1: ( ( rule__Assertion__RelationAssignment_0_0_0 ) ) + // InternalProblem.g:3220:2: ( rule__Assertion__RelationAssignment_0_0_0 ) + { + before(grammarAccess.getAssertionAccess().getRelationAssignment_0_0_0()); + // InternalProblem.g:3221:2: ( rule__Assertion__RelationAssignment_0_0_0 ) + // InternalProblem.g:3221:3: rule__Assertion__RelationAssignment_0_0_0 + { + pushFollow(FOLLOW_2); + rule__Assertion__RelationAssignment_0_0_0(); + + state._fsp--; + + + } + + after(grammarAccess.getAssertionAccess().getRelationAssignment_0_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0__0__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_0__1" + // InternalProblem.g:3229:1: rule__Assertion__Group_0_0__1 : rule__Assertion__Group_0_0__1__Impl rule__Assertion__Group_0_0__2 ; + public final void rule__Assertion__Group_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3233:1: ( rule__Assertion__Group_0_0__1__Impl rule__Assertion__Group_0_0__2 ) + // InternalProblem.g:3234:2: rule__Assertion__Group_0_0__1__Impl rule__Assertion__Group_0_0__2 + { + pushFollow(FOLLOW_23); + rule__Assertion__Group_0_0__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_0__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0__1" + + + // $ANTLR start "rule__Assertion__Group_0_0__1__Impl" + // InternalProblem.g:3241:1: rule__Assertion__Group_0_0__1__Impl : ( '(' ) ; + public final void rule__Assertion__Group_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3245:1: ( ( '(' ) ) + // InternalProblem.g:3246:1: ( '(' ) + { + // InternalProblem.g:3246:1: ( '(' ) + // InternalProblem.g:3247:2: '(' + { + before(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_0_1()); + match(input,33,FOLLOW_2); + after(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_0_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0__1__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_0__2" + // InternalProblem.g:3256:1: rule__Assertion__Group_0_0__2 : rule__Assertion__Group_0_0__2__Impl rule__Assertion__Group_0_0__3 ; + public final void rule__Assertion__Group_0_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3260:1: ( rule__Assertion__Group_0_0__2__Impl rule__Assertion__Group_0_0__3 ) + // InternalProblem.g:3261:2: rule__Assertion__Group_0_0__2__Impl rule__Assertion__Group_0_0__3 + { + pushFollow(FOLLOW_23); + rule__Assertion__Group_0_0__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_0__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0__2" + + + // $ANTLR start "rule__Assertion__Group_0_0__2__Impl" + // InternalProblem.g:3268:1: rule__Assertion__Group_0_0__2__Impl : ( ( rule__Assertion__Group_0_0_2__0 )? ) ; + public final void rule__Assertion__Group_0_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3272:1: ( ( ( rule__Assertion__Group_0_0_2__0 )? ) ) + // InternalProblem.g:3273:1: ( ( rule__Assertion__Group_0_0_2__0 )? ) + { + // InternalProblem.g:3273:1: ( ( rule__Assertion__Group_0_0_2__0 )? ) + // InternalProblem.g:3274:2: ( rule__Assertion__Group_0_0_2__0 )? + { + before(grammarAccess.getAssertionAccess().getGroup_0_0_2()); + // InternalProblem.g:3275:2: ( rule__Assertion__Group_0_0_2__0 )? + int alt41=2; + int LA41_0 = input.LA(1); + + if ( ((LA41_0>=RULE_QUOTED_ID && LA41_0<=RULE_ID)||(LA41_0>=19 && LA41_0<=20)) ) { + alt41=1; + } + switch (alt41) { + case 1 : + // InternalProblem.g:3275:3: rule__Assertion__Group_0_0_2__0 + { + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_0_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getAssertionAccess().getGroup_0_0_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0__2__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_0__3" + // InternalProblem.g:3283:1: rule__Assertion__Group_0_0__3 : rule__Assertion__Group_0_0__3__Impl rule__Assertion__Group_0_0__4 ; + public final void rule__Assertion__Group_0_0__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3287:1: ( rule__Assertion__Group_0_0__3__Impl rule__Assertion__Group_0_0__4 ) + // InternalProblem.g:3288:2: rule__Assertion__Group_0_0__3__Impl rule__Assertion__Group_0_0__4 + { + pushFollow(FOLLOW_29); + rule__Assertion__Group_0_0__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_0__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0__3" + + + // $ANTLR start "rule__Assertion__Group_0_0__3__Impl" + // InternalProblem.g:3295:1: rule__Assertion__Group_0_0__3__Impl : ( ')' ) ; + public final void rule__Assertion__Group_0_0__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3299:1: ( ( ')' ) ) + // InternalProblem.g:3300:1: ( ')' ) + { + // InternalProblem.g:3300:1: ( ')' ) + // InternalProblem.g:3301:2: ')' + { + before(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_0_3()); + match(input,34,FOLLOW_2); + after(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_0_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0__3__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_0__4" + // InternalProblem.g:3310:1: rule__Assertion__Group_0_0__4 : rule__Assertion__Group_0_0__4__Impl rule__Assertion__Group_0_0__5 ; + public final void rule__Assertion__Group_0_0__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3314:1: ( rule__Assertion__Group_0_0__4__Impl rule__Assertion__Group_0_0__5 ) + // InternalProblem.g:3315:2: rule__Assertion__Group_0_0__4__Impl rule__Assertion__Group_0_0__5 + { + pushFollow(FOLLOW_30); + rule__Assertion__Group_0_0__4__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_0__5(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0__4" + + + // $ANTLR start "rule__Assertion__Group_0_0__4__Impl" + // InternalProblem.g:3322:1: rule__Assertion__Group_0_0__4__Impl : ( ':' ) ; + public final void rule__Assertion__Group_0_0__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3326:1: ( ( ':' ) ) + // InternalProblem.g:3327:1: ( ':' ) + { + // InternalProblem.g:3327:1: ( ':' ) + // InternalProblem.g:3328:2: ':' + { + before(grammarAccess.getAssertionAccess().getColonKeyword_0_0_4()); + match(input,36,FOLLOW_2); + after(grammarAccess.getAssertionAccess().getColonKeyword_0_0_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0__4__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_0__5" + // InternalProblem.g:3337:1: rule__Assertion__Group_0_0__5 : rule__Assertion__Group_0_0__5__Impl ; + public final void rule__Assertion__Group_0_0__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3341:1: ( rule__Assertion__Group_0_0__5__Impl ) + // InternalProblem.g:3342:2: rule__Assertion__Group_0_0__5__Impl + { + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_0__5__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0__5" + + + // $ANTLR start "rule__Assertion__Group_0_0__5__Impl" + // InternalProblem.g:3348:1: rule__Assertion__Group_0_0__5__Impl : ( ( rule__Assertion__ValueAssignment_0_0_5 ) ) ; + public final void rule__Assertion__Group_0_0__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3352:1: ( ( ( rule__Assertion__ValueAssignment_0_0_5 ) ) ) + // InternalProblem.g:3353:1: ( ( rule__Assertion__ValueAssignment_0_0_5 ) ) + { + // InternalProblem.g:3353:1: ( ( rule__Assertion__ValueAssignment_0_0_5 ) ) + // InternalProblem.g:3354:2: ( rule__Assertion__ValueAssignment_0_0_5 ) + { + before(grammarAccess.getAssertionAccess().getValueAssignment_0_0_5()); + // InternalProblem.g:3355:2: ( rule__Assertion__ValueAssignment_0_0_5 ) + // InternalProblem.g:3355:3: rule__Assertion__ValueAssignment_0_0_5 + { + pushFollow(FOLLOW_2); + rule__Assertion__ValueAssignment_0_0_5(); + + state._fsp--; + + + } + + after(grammarAccess.getAssertionAccess().getValueAssignment_0_0_5()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0__5__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_0_2__0" + // InternalProblem.g:3364:1: rule__Assertion__Group_0_0_2__0 : rule__Assertion__Group_0_0_2__0__Impl rule__Assertion__Group_0_0_2__1 ; + public final void rule__Assertion__Group_0_0_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3368:1: ( rule__Assertion__Group_0_0_2__0__Impl rule__Assertion__Group_0_0_2__1 ) + // InternalProblem.g:3369:2: rule__Assertion__Group_0_0_2__0__Impl rule__Assertion__Group_0_0_2__1 + { + pushFollow(FOLLOW_9); + rule__Assertion__Group_0_0_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_0_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0_2__0" + + + // $ANTLR start "rule__Assertion__Group_0_0_2__0__Impl" + // InternalProblem.g:3376:1: rule__Assertion__Group_0_0_2__0__Impl : ( ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) ) ; + public final void rule__Assertion__Group_0_0_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3380:1: ( ( ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) ) ) + // InternalProblem.g:3381:1: ( ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) ) + { + // InternalProblem.g:3381:1: ( ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) ) + // InternalProblem.g:3382:2: ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) + { + before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_0()); + // InternalProblem.g:3383:2: ( rule__Assertion__ArgumentsAssignment_0_0_2_0 ) + // InternalProblem.g:3383:3: rule__Assertion__ArgumentsAssignment_0_0_2_0 + { + pushFollow(FOLLOW_2); + rule__Assertion__ArgumentsAssignment_0_0_2_0(); + + state._fsp--; + + + } + + after(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0_2__0__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_0_2__1" + // InternalProblem.g:3391:1: rule__Assertion__Group_0_0_2__1 : rule__Assertion__Group_0_0_2__1__Impl ; + public final void rule__Assertion__Group_0_0_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3395:1: ( rule__Assertion__Group_0_0_2__1__Impl ) + // InternalProblem.g:3396:2: rule__Assertion__Group_0_0_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_0_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0_2__1" + + + // $ANTLR start "rule__Assertion__Group_0_0_2__1__Impl" + // InternalProblem.g:3402:1: rule__Assertion__Group_0_0_2__1__Impl : ( ( rule__Assertion__Group_0_0_2_1__0 )* ) ; + public final void rule__Assertion__Group_0_0_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3406:1: ( ( ( rule__Assertion__Group_0_0_2_1__0 )* ) ) + // InternalProblem.g:3407:1: ( ( rule__Assertion__Group_0_0_2_1__0 )* ) + { + // InternalProblem.g:3407:1: ( ( rule__Assertion__Group_0_0_2_1__0 )* ) + // InternalProblem.g:3408:2: ( rule__Assertion__Group_0_0_2_1__0 )* + { + before(grammarAccess.getAssertionAccess().getGroup_0_0_2_1()); + // InternalProblem.g:3409:2: ( rule__Assertion__Group_0_0_2_1__0 )* + loop42: + do { + int alt42=2; + int LA42_0 = input.LA(1); + + if ( (LA42_0==13) ) { + alt42=1; + } + + + switch (alt42) { + case 1 : + // InternalProblem.g:3409:3: rule__Assertion__Group_0_0_2_1__0 + { + pushFollow(FOLLOW_10); + rule__Assertion__Group_0_0_2_1__0(); + + state._fsp--; + + + } + break; + + default : + break loop42; + } + } while (true); + + after(grammarAccess.getAssertionAccess().getGroup_0_0_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0_2__1__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_0_2_1__0" + // InternalProblem.g:3418:1: rule__Assertion__Group_0_0_2_1__0 : rule__Assertion__Group_0_0_2_1__0__Impl rule__Assertion__Group_0_0_2_1__1 ; + public final void rule__Assertion__Group_0_0_2_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3422:1: ( rule__Assertion__Group_0_0_2_1__0__Impl rule__Assertion__Group_0_0_2_1__1 ) + // InternalProblem.g:3423:2: rule__Assertion__Group_0_0_2_1__0__Impl rule__Assertion__Group_0_0_2_1__1 + { + pushFollow(FOLLOW_5); + rule__Assertion__Group_0_0_2_1__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_0_2_1__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0_2_1__0" + + + // $ANTLR start "rule__Assertion__Group_0_0_2_1__0__Impl" + // InternalProblem.g:3430:1: rule__Assertion__Group_0_0_2_1__0__Impl : ( ',' ) ; + public final void rule__Assertion__Group_0_0_2_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3434:1: ( ( ',' ) ) + // InternalProblem.g:3435:1: ( ',' ) + { + // InternalProblem.g:3435:1: ( ',' ) + // InternalProblem.g:3436:2: ',' + { + before(grammarAccess.getAssertionAccess().getCommaKeyword_0_0_2_1_0()); + match(input,13,FOLLOW_2); + after(grammarAccess.getAssertionAccess().getCommaKeyword_0_0_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0_2_1__0__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_0_2_1__1" + // InternalProblem.g:3445:1: rule__Assertion__Group_0_0_2_1__1 : rule__Assertion__Group_0_0_2_1__1__Impl ; + public final void rule__Assertion__Group_0_0_2_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3449:1: ( rule__Assertion__Group_0_0_2_1__1__Impl ) + // InternalProblem.g:3450:2: rule__Assertion__Group_0_0_2_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_0_2_1__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0_2_1__1" + + + // $ANTLR start "rule__Assertion__Group_0_0_2_1__1__Impl" + // InternalProblem.g:3456:1: rule__Assertion__Group_0_0_2_1__1__Impl : ( ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) ) ; + public final void rule__Assertion__Group_0_0_2_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3460:1: ( ( ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) ) ) + // InternalProblem.g:3461:1: ( ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) ) + { + // InternalProblem.g:3461:1: ( ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) ) + // InternalProblem.g:3462:2: ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) + { + before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_1_1()); + // InternalProblem.g:3463:2: ( rule__Assertion__ArgumentsAssignment_0_0_2_1_1 ) + // InternalProblem.g:3463:3: rule__Assertion__ArgumentsAssignment_0_0_2_1_1 + { + pushFollow(FOLLOW_2); + rule__Assertion__ArgumentsAssignment_0_0_2_1_1(); + + state._fsp--; + + + } + + after(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_0_2_1_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_0_2_1__1__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_1__0" + // InternalProblem.g:3472:1: rule__Assertion__Group_0_1__0 : rule__Assertion__Group_0_1__0__Impl rule__Assertion__Group_0_1__1 ; + public final void rule__Assertion__Group_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3476:1: ( rule__Assertion__Group_0_1__0__Impl rule__Assertion__Group_0_1__1 ) + // InternalProblem.g:3477:2: rule__Assertion__Group_0_1__0__Impl rule__Assertion__Group_0_1__1 + { + pushFollow(FOLLOW_31); + rule__Assertion__Group_0_1__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_1__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1__0" + + + // $ANTLR start "rule__Assertion__Group_0_1__0__Impl" + // InternalProblem.g:3484:1: rule__Assertion__Group_0_1__0__Impl : ( ( rule__Assertion__ValueAssignment_0_1_0 )? ) ; + public final void rule__Assertion__Group_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3488:1: ( ( ( rule__Assertion__ValueAssignment_0_1_0 )? ) ) + // InternalProblem.g:3489:1: ( ( rule__Assertion__ValueAssignment_0_1_0 )? ) + { + // InternalProblem.g:3489:1: ( ( rule__Assertion__ValueAssignment_0_1_0 )? ) + // InternalProblem.g:3490:2: ( rule__Assertion__ValueAssignment_0_1_0 )? + { + before(grammarAccess.getAssertionAccess().getValueAssignment_0_1_0()); + // InternalProblem.g:3491:2: ( rule__Assertion__ValueAssignment_0_1_0 )? + int alt43=2; + int LA43_0 = input.LA(1); + + if ( ((LA43_0>=22 && LA43_0<=23)) ) { + alt43=1; + } + switch (alt43) { + case 1 : + // InternalProblem.g:3491:3: rule__Assertion__ValueAssignment_0_1_0 + { + pushFollow(FOLLOW_2); + rule__Assertion__ValueAssignment_0_1_0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getAssertionAccess().getValueAssignment_0_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1__0__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_1__1" + // InternalProblem.g:3499:1: rule__Assertion__Group_0_1__1 : rule__Assertion__Group_0_1__1__Impl rule__Assertion__Group_0_1__2 ; + public final void rule__Assertion__Group_0_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3503:1: ( rule__Assertion__Group_0_1__1__Impl rule__Assertion__Group_0_1__2 ) + // InternalProblem.g:3504:2: rule__Assertion__Group_0_1__1__Impl rule__Assertion__Group_0_1__2 + { + pushFollow(FOLLOW_22); + rule__Assertion__Group_0_1__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_1__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1__1" + + + // $ANTLR start "rule__Assertion__Group_0_1__1__Impl" + // InternalProblem.g:3511:1: rule__Assertion__Group_0_1__1__Impl : ( ( rule__Assertion__RelationAssignment_0_1_1 ) ) ; + public final void rule__Assertion__Group_0_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3515:1: ( ( ( rule__Assertion__RelationAssignment_0_1_1 ) ) ) + // InternalProblem.g:3516:1: ( ( rule__Assertion__RelationAssignment_0_1_1 ) ) + { + // InternalProblem.g:3516:1: ( ( rule__Assertion__RelationAssignment_0_1_1 ) ) + // InternalProblem.g:3517:2: ( rule__Assertion__RelationAssignment_0_1_1 ) + { + before(grammarAccess.getAssertionAccess().getRelationAssignment_0_1_1()); + // InternalProblem.g:3518:2: ( rule__Assertion__RelationAssignment_0_1_1 ) + // InternalProblem.g:3518:3: rule__Assertion__RelationAssignment_0_1_1 + { + pushFollow(FOLLOW_2); + rule__Assertion__RelationAssignment_0_1_1(); + + state._fsp--; + + + } + + after(grammarAccess.getAssertionAccess().getRelationAssignment_0_1_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1__1__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_1__2" + // InternalProblem.g:3526:1: rule__Assertion__Group_0_1__2 : rule__Assertion__Group_0_1__2__Impl rule__Assertion__Group_0_1__3 ; + public final void rule__Assertion__Group_0_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3530:1: ( rule__Assertion__Group_0_1__2__Impl rule__Assertion__Group_0_1__3 ) + // InternalProblem.g:3531:2: rule__Assertion__Group_0_1__2__Impl rule__Assertion__Group_0_1__3 + { + pushFollow(FOLLOW_23); + rule__Assertion__Group_0_1__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_1__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1__2" + + + // $ANTLR start "rule__Assertion__Group_0_1__2__Impl" + // InternalProblem.g:3538:1: rule__Assertion__Group_0_1__2__Impl : ( '(' ) ; + public final void rule__Assertion__Group_0_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3542:1: ( ( '(' ) ) + // InternalProblem.g:3543:1: ( '(' ) + { + // InternalProblem.g:3543:1: ( '(' ) + // InternalProblem.g:3544:2: '(' + { + before(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_1_2()); + match(input,33,FOLLOW_2); + after(grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_1_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1__2__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_1__3" + // InternalProblem.g:3553:1: rule__Assertion__Group_0_1__3 : rule__Assertion__Group_0_1__3__Impl rule__Assertion__Group_0_1__4 ; + public final void rule__Assertion__Group_0_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3557:1: ( rule__Assertion__Group_0_1__3__Impl rule__Assertion__Group_0_1__4 ) + // InternalProblem.g:3558:2: rule__Assertion__Group_0_1__3__Impl rule__Assertion__Group_0_1__4 + { + pushFollow(FOLLOW_23); + rule__Assertion__Group_0_1__3__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_1__4(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1__3" + + + // $ANTLR start "rule__Assertion__Group_0_1__3__Impl" + // InternalProblem.g:3565:1: rule__Assertion__Group_0_1__3__Impl : ( ( rule__Assertion__Group_0_1_3__0 )? ) ; + public final void rule__Assertion__Group_0_1__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3569:1: ( ( ( rule__Assertion__Group_0_1_3__0 )? ) ) + // InternalProblem.g:3570:1: ( ( rule__Assertion__Group_0_1_3__0 )? ) + { + // InternalProblem.g:3570:1: ( ( rule__Assertion__Group_0_1_3__0 )? ) + // InternalProblem.g:3571:2: ( rule__Assertion__Group_0_1_3__0 )? + { + before(grammarAccess.getAssertionAccess().getGroup_0_1_3()); + // InternalProblem.g:3572:2: ( rule__Assertion__Group_0_1_3__0 )? + int alt44=2; + int LA44_0 = input.LA(1); + + if ( ((LA44_0>=RULE_QUOTED_ID && LA44_0<=RULE_ID)||(LA44_0>=19 && LA44_0<=20)) ) { + alt44=1; + } + switch (alt44) { + case 1 : + // InternalProblem.g:3572:3: rule__Assertion__Group_0_1_3__0 + { + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_1_3__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getAssertionAccess().getGroup_0_1_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1__3__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_1__4" + // InternalProblem.g:3580:1: rule__Assertion__Group_0_1__4 : rule__Assertion__Group_0_1__4__Impl ; + public final void rule__Assertion__Group_0_1__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3584:1: ( rule__Assertion__Group_0_1__4__Impl ) + // InternalProblem.g:3585:2: rule__Assertion__Group_0_1__4__Impl + { + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_1__4__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1__4" + + + // $ANTLR start "rule__Assertion__Group_0_1__4__Impl" + // InternalProblem.g:3591:1: rule__Assertion__Group_0_1__4__Impl : ( ')' ) ; + public final void rule__Assertion__Group_0_1__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3595:1: ( ( ')' ) ) + // InternalProblem.g:3596:1: ( ')' ) + { + // InternalProblem.g:3596:1: ( ')' ) + // InternalProblem.g:3597:2: ')' + { + before(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_1_4()); + match(input,34,FOLLOW_2); + after(grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_1_4()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1__4__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_1_3__0" + // InternalProblem.g:3607:1: rule__Assertion__Group_0_1_3__0 : rule__Assertion__Group_0_1_3__0__Impl rule__Assertion__Group_0_1_3__1 ; + public final void rule__Assertion__Group_0_1_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3611:1: ( rule__Assertion__Group_0_1_3__0__Impl rule__Assertion__Group_0_1_3__1 ) + // InternalProblem.g:3612:2: rule__Assertion__Group_0_1_3__0__Impl rule__Assertion__Group_0_1_3__1 + { + pushFollow(FOLLOW_9); + rule__Assertion__Group_0_1_3__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_1_3__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1_3__0" + + + // $ANTLR start "rule__Assertion__Group_0_1_3__0__Impl" + // InternalProblem.g:3619:1: rule__Assertion__Group_0_1_3__0__Impl : ( ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) ) ; + public final void rule__Assertion__Group_0_1_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3623:1: ( ( ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) ) ) + // InternalProblem.g:3624:1: ( ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) ) + { + // InternalProblem.g:3624:1: ( ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) ) + // InternalProblem.g:3625:2: ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) + { + before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_0()); + // InternalProblem.g:3626:2: ( rule__Assertion__ArgumentsAssignment_0_1_3_0 ) + // InternalProblem.g:3626:3: rule__Assertion__ArgumentsAssignment_0_1_3_0 + { + pushFollow(FOLLOW_2); + rule__Assertion__ArgumentsAssignment_0_1_3_0(); + + state._fsp--; + + + } + + after(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1_3__0__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_1_3__1" + // InternalProblem.g:3634:1: rule__Assertion__Group_0_1_3__1 : rule__Assertion__Group_0_1_3__1__Impl ; + public final void rule__Assertion__Group_0_1_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3638:1: ( rule__Assertion__Group_0_1_3__1__Impl ) + // InternalProblem.g:3639:2: rule__Assertion__Group_0_1_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_1_3__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1_3__1" + + + // $ANTLR start "rule__Assertion__Group_0_1_3__1__Impl" + // InternalProblem.g:3645:1: rule__Assertion__Group_0_1_3__1__Impl : ( ( rule__Assertion__Group_0_1_3_1__0 )* ) ; + public final void rule__Assertion__Group_0_1_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3649:1: ( ( ( rule__Assertion__Group_0_1_3_1__0 )* ) ) + // InternalProblem.g:3650:1: ( ( rule__Assertion__Group_0_1_3_1__0 )* ) + { + // InternalProblem.g:3650:1: ( ( rule__Assertion__Group_0_1_3_1__0 )* ) + // InternalProblem.g:3651:2: ( rule__Assertion__Group_0_1_3_1__0 )* + { + before(grammarAccess.getAssertionAccess().getGroup_0_1_3_1()); + // InternalProblem.g:3652:2: ( rule__Assertion__Group_0_1_3_1__0 )* + loop45: + do { + int alt45=2; + int LA45_0 = input.LA(1); + + if ( (LA45_0==13) ) { + alt45=1; + } + + + switch (alt45) { + case 1 : + // InternalProblem.g:3652:3: rule__Assertion__Group_0_1_3_1__0 + { + pushFollow(FOLLOW_10); + rule__Assertion__Group_0_1_3_1__0(); + + state._fsp--; + + + } + break; + + default : + break loop45; + } + } while (true); + + after(grammarAccess.getAssertionAccess().getGroup_0_1_3_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1_3__1__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_1_3_1__0" + // InternalProblem.g:3661:1: rule__Assertion__Group_0_1_3_1__0 : rule__Assertion__Group_0_1_3_1__0__Impl rule__Assertion__Group_0_1_3_1__1 ; + public final void rule__Assertion__Group_0_1_3_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3665:1: ( rule__Assertion__Group_0_1_3_1__0__Impl rule__Assertion__Group_0_1_3_1__1 ) + // InternalProblem.g:3666:2: rule__Assertion__Group_0_1_3_1__0__Impl rule__Assertion__Group_0_1_3_1__1 + { + pushFollow(FOLLOW_5); + rule__Assertion__Group_0_1_3_1__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_1_3_1__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1_3_1__0" + + + // $ANTLR start "rule__Assertion__Group_0_1_3_1__0__Impl" + // InternalProblem.g:3673:1: rule__Assertion__Group_0_1_3_1__0__Impl : ( ',' ) ; + public final void rule__Assertion__Group_0_1_3_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3677:1: ( ( ',' ) ) + // InternalProblem.g:3678:1: ( ',' ) + { + // InternalProblem.g:3678:1: ( ',' ) + // InternalProblem.g:3679:2: ',' + { + before(grammarAccess.getAssertionAccess().getCommaKeyword_0_1_3_1_0()); + match(input,13,FOLLOW_2); + after(grammarAccess.getAssertionAccess().getCommaKeyword_0_1_3_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1_3_1__0__Impl" + + + // $ANTLR start "rule__Assertion__Group_0_1_3_1__1" + // InternalProblem.g:3688:1: rule__Assertion__Group_0_1_3_1__1 : rule__Assertion__Group_0_1_3_1__1__Impl ; + public final void rule__Assertion__Group_0_1_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3692:1: ( rule__Assertion__Group_0_1_3_1__1__Impl ) + // InternalProblem.g:3693:2: rule__Assertion__Group_0_1_3_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__Assertion__Group_0_1_3_1__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1_3_1__1" + + + // $ANTLR start "rule__Assertion__Group_0_1_3_1__1__Impl" + // InternalProblem.g:3699:1: rule__Assertion__Group_0_1_3_1__1__Impl : ( ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) ) ; + public final void rule__Assertion__Group_0_1_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3703:1: ( ( ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) ) ) + // InternalProblem.g:3704:1: ( ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) ) + { + // InternalProblem.g:3704:1: ( ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) ) + // InternalProblem.g:3705:2: ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) + { + before(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_1_1()); + // InternalProblem.g:3706:2: ( rule__Assertion__ArgumentsAssignment_0_1_3_1_1 ) + // InternalProblem.g:3706:3: rule__Assertion__ArgumentsAssignment_0_1_3_1_1 + { + pushFollow(FOLLOW_2); + rule__Assertion__ArgumentsAssignment_0_1_3_1_1(); + + state._fsp--; + + + } + + after(grammarAccess.getAssertionAccess().getArgumentsAssignment_0_1_3_1_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__Group_0_1_3_1__1__Impl" + + + // $ANTLR start "rule__ScopeDeclaration__Group__0" + // InternalProblem.g:3715:1: rule__ScopeDeclaration__Group__0 : rule__ScopeDeclaration__Group__0__Impl rule__ScopeDeclaration__Group__1 ; + public final void rule__ScopeDeclaration__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3719:1: ( rule__ScopeDeclaration__Group__0__Impl rule__ScopeDeclaration__Group__1 ) + // InternalProblem.g:3720:2: rule__ScopeDeclaration__Group__0__Impl rule__ScopeDeclaration__Group__1 + { + pushFollow(FOLLOW_32); + rule__ScopeDeclaration__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ScopeDeclaration__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDeclaration__Group__0" + + + // $ANTLR start "rule__ScopeDeclaration__Group__0__Impl" + // InternalProblem.g:3727:1: rule__ScopeDeclaration__Group__0__Impl : ( 'scope' ) ; + public final void rule__ScopeDeclaration__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3731:1: ( ( 'scope' ) ) + // InternalProblem.g:3732:1: ( 'scope' ) + { + // InternalProblem.g:3732:1: ( 'scope' ) + // InternalProblem.g:3733:2: 'scope' + { + before(grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); + match(input,37,FOLLOW_2); + after(grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDeclaration__Group__0__Impl" + + + // $ANTLR start "rule__ScopeDeclaration__Group__1" + // InternalProblem.g:3742:1: rule__ScopeDeclaration__Group__1 : rule__ScopeDeclaration__Group__1__Impl rule__ScopeDeclaration__Group__2 ; + public final void rule__ScopeDeclaration__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3746:1: ( rule__ScopeDeclaration__Group__1__Impl rule__ScopeDeclaration__Group__2 ) + // InternalProblem.g:3747:2: rule__ScopeDeclaration__Group__1__Impl rule__ScopeDeclaration__Group__2 + { + pushFollow(FOLLOW_33); + rule__ScopeDeclaration__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ScopeDeclaration__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDeclaration__Group__1" + + + // $ANTLR start "rule__ScopeDeclaration__Group__1__Impl" + // InternalProblem.g:3754:1: rule__ScopeDeclaration__Group__1__Impl : ( ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) ) ; + public final void rule__ScopeDeclaration__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3758:1: ( ( ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) ) ) + // InternalProblem.g:3759:1: ( ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) ) + { + // InternalProblem.g:3759:1: ( ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) ) + // InternalProblem.g:3760:2: ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) + { + before(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_1()); + // InternalProblem.g:3761:2: ( rule__ScopeDeclaration__TypeScopesAssignment_1 ) + // InternalProblem.g:3761:3: rule__ScopeDeclaration__TypeScopesAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ScopeDeclaration__TypeScopesAssignment_1(); + + state._fsp--; + + + } + + after(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDeclaration__Group__1__Impl" + + + // $ANTLR start "rule__ScopeDeclaration__Group__2" + // InternalProblem.g:3769:1: rule__ScopeDeclaration__Group__2 : rule__ScopeDeclaration__Group__2__Impl rule__ScopeDeclaration__Group__3 ; + public final void rule__ScopeDeclaration__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3773:1: ( rule__ScopeDeclaration__Group__2__Impl rule__ScopeDeclaration__Group__3 ) + // InternalProblem.g:3774:2: rule__ScopeDeclaration__Group__2__Impl rule__ScopeDeclaration__Group__3 + { + pushFollow(FOLLOW_33); + rule__ScopeDeclaration__Group__2__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ScopeDeclaration__Group__3(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDeclaration__Group__2" + + + // $ANTLR start "rule__ScopeDeclaration__Group__2__Impl" + // InternalProblem.g:3781:1: rule__ScopeDeclaration__Group__2__Impl : ( ( rule__ScopeDeclaration__Group_2__0 )* ) ; + public final void rule__ScopeDeclaration__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3785:1: ( ( ( rule__ScopeDeclaration__Group_2__0 )* ) ) + // InternalProblem.g:3786:1: ( ( rule__ScopeDeclaration__Group_2__0 )* ) + { + // InternalProblem.g:3786:1: ( ( rule__ScopeDeclaration__Group_2__0 )* ) + // InternalProblem.g:3787:2: ( rule__ScopeDeclaration__Group_2__0 )* + { + before(grammarAccess.getScopeDeclarationAccess().getGroup_2()); + // InternalProblem.g:3788:2: ( rule__ScopeDeclaration__Group_2__0 )* + loop46: + do { + int alt46=2; + int LA46_0 = input.LA(1); + + if ( (LA46_0==13) ) { + alt46=1; + } + + + switch (alt46) { + case 1 : + // InternalProblem.g:3788:3: rule__ScopeDeclaration__Group_2__0 + { + pushFollow(FOLLOW_10); + rule__ScopeDeclaration__Group_2__0(); + + state._fsp--; + + + } + break; + + default : + break loop46; + } + } while (true); + + after(grammarAccess.getScopeDeclarationAccess().getGroup_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDeclaration__Group__2__Impl" + + + // $ANTLR start "rule__ScopeDeclaration__Group__3" + // InternalProblem.g:3796:1: rule__ScopeDeclaration__Group__3 : rule__ScopeDeclaration__Group__3__Impl ; + public final void rule__ScopeDeclaration__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3800:1: ( rule__ScopeDeclaration__Group__3__Impl ) + // InternalProblem.g:3801:2: rule__ScopeDeclaration__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__ScopeDeclaration__Group__3__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDeclaration__Group__3" + + + // $ANTLR start "rule__ScopeDeclaration__Group__3__Impl" + // InternalProblem.g:3807:1: rule__ScopeDeclaration__Group__3__Impl : ( '.' ) ; + public final void rule__ScopeDeclaration__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3811:1: ( ( '.' ) ) + // InternalProblem.g:3812:1: ( '.' ) + { + // InternalProblem.g:3812:1: ( '.' ) + // InternalProblem.g:3813:2: '.' + { + before(grammarAccess.getScopeDeclarationAccess().getFullStopKeyword_3()); + match(input,12,FOLLOW_2); + after(grammarAccess.getScopeDeclarationAccess().getFullStopKeyword_3()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDeclaration__Group__3__Impl" + + + // $ANTLR start "rule__ScopeDeclaration__Group_2__0" + // InternalProblem.g:3823:1: rule__ScopeDeclaration__Group_2__0 : rule__ScopeDeclaration__Group_2__0__Impl rule__ScopeDeclaration__Group_2__1 ; + public final void rule__ScopeDeclaration__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3827:1: ( rule__ScopeDeclaration__Group_2__0__Impl rule__ScopeDeclaration__Group_2__1 ) + // InternalProblem.g:3828:2: rule__ScopeDeclaration__Group_2__0__Impl rule__ScopeDeclaration__Group_2__1 + { + pushFollow(FOLLOW_32); + rule__ScopeDeclaration__Group_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__ScopeDeclaration__Group_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDeclaration__Group_2__0" + + + // $ANTLR start "rule__ScopeDeclaration__Group_2__0__Impl" + // InternalProblem.g:3835:1: rule__ScopeDeclaration__Group_2__0__Impl : ( ',' ) ; + public final void rule__ScopeDeclaration__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3839:1: ( ( ',' ) ) + // InternalProblem.g:3840:1: ( ',' ) + { + // InternalProblem.g:3840:1: ( ',' ) + // InternalProblem.g:3841:2: ',' + { + before(grammarAccess.getScopeDeclarationAccess().getCommaKeyword_2_0()); + match(input,13,FOLLOW_2); + after(grammarAccess.getScopeDeclarationAccess().getCommaKeyword_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDeclaration__Group_2__0__Impl" + + + // $ANTLR start "rule__ScopeDeclaration__Group_2__1" + // InternalProblem.g:3850:1: rule__ScopeDeclaration__Group_2__1 : rule__ScopeDeclaration__Group_2__1__Impl ; + public final void rule__ScopeDeclaration__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3854:1: ( rule__ScopeDeclaration__Group_2__1__Impl ) + // InternalProblem.g:3855:2: rule__ScopeDeclaration__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__ScopeDeclaration__Group_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDeclaration__Group_2__1" + + + // $ANTLR start "rule__ScopeDeclaration__Group_2__1__Impl" + // InternalProblem.g:3861:1: rule__ScopeDeclaration__Group_2__1__Impl : ( ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) ) ; + public final void rule__ScopeDeclaration__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3865:1: ( ( ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) ) ) + // InternalProblem.g:3866:1: ( ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) ) + { + // InternalProblem.g:3866:1: ( ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) ) + // InternalProblem.g:3867:2: ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) + { + before(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_2_1()); + // InternalProblem.g:3868:2: ( rule__ScopeDeclaration__TypeScopesAssignment_2_1 ) + // InternalProblem.g:3868:3: rule__ScopeDeclaration__TypeScopesAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__ScopeDeclaration__TypeScopesAssignment_2_1(); + + state._fsp--; + + + } + + after(grammarAccess.getScopeDeclarationAccess().getTypeScopesAssignment_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDeclaration__Group_2__1__Impl" + + + // $ANTLR start "rule__TypeScope__Group__0" + // InternalProblem.g:3877:1: rule__TypeScope__Group__0 : rule__TypeScope__Group__0__Impl rule__TypeScope__Group__1 ; + public final void rule__TypeScope__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3881:1: ( rule__TypeScope__Group__0__Impl rule__TypeScope__Group__1 ) + // InternalProblem.g:3882:2: rule__TypeScope__Group__0__Impl rule__TypeScope__Group__1 + { + pushFollow(FOLLOW_34); + rule__TypeScope__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TypeScope__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeScope__Group__0" + + + // $ANTLR start "rule__TypeScope__Group__0__Impl" + // InternalProblem.g:3889:1: rule__TypeScope__Group__0__Impl : ( ( rule__TypeScope__TargetTypeAssignment_0 ) ) ; + public final void rule__TypeScope__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3893:1: ( ( ( rule__TypeScope__TargetTypeAssignment_0 ) ) ) + // InternalProblem.g:3894:1: ( ( rule__TypeScope__TargetTypeAssignment_0 ) ) + { + // InternalProblem.g:3894:1: ( ( rule__TypeScope__TargetTypeAssignment_0 ) ) + // InternalProblem.g:3895:2: ( rule__TypeScope__TargetTypeAssignment_0 ) + { + before(grammarAccess.getTypeScopeAccess().getTargetTypeAssignment_0()); + // InternalProblem.g:3896:2: ( rule__TypeScope__TargetTypeAssignment_0 ) + // InternalProblem.g:3896:3: rule__TypeScope__TargetTypeAssignment_0 + { + pushFollow(FOLLOW_2); + rule__TypeScope__TargetTypeAssignment_0(); + + state._fsp--; + + + } + + after(grammarAccess.getTypeScopeAccess().getTargetTypeAssignment_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeScope__Group__0__Impl" + + + // $ANTLR start "rule__TypeScope__Group__1" + // InternalProblem.g:3904:1: rule__TypeScope__Group__1 : rule__TypeScope__Group__1__Impl rule__TypeScope__Group__2 ; + public final void rule__TypeScope__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3908:1: ( rule__TypeScope__Group__1__Impl rule__TypeScope__Group__2 ) + // InternalProblem.g:3909:2: rule__TypeScope__Group__1__Impl rule__TypeScope__Group__2 + { + pushFollow(FOLLOW_20); + rule__TypeScope__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__TypeScope__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeScope__Group__1" + + + // $ANTLR start "rule__TypeScope__Group__1__Impl" + // InternalProblem.g:3916:1: rule__TypeScope__Group__1__Impl : ( ( rule__TypeScope__Alternatives_1 ) ) ; + public final void rule__TypeScope__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3920:1: ( ( ( rule__TypeScope__Alternatives_1 ) ) ) + // InternalProblem.g:3921:1: ( ( rule__TypeScope__Alternatives_1 ) ) + { + // InternalProblem.g:3921:1: ( ( rule__TypeScope__Alternatives_1 ) ) + // InternalProblem.g:3922:2: ( rule__TypeScope__Alternatives_1 ) + { + before(grammarAccess.getTypeScopeAccess().getAlternatives_1()); + // InternalProblem.g:3923:2: ( rule__TypeScope__Alternatives_1 ) + // InternalProblem.g:3923:3: rule__TypeScope__Alternatives_1 + { + pushFollow(FOLLOW_2); + rule__TypeScope__Alternatives_1(); + + state._fsp--; + + + } + + after(grammarAccess.getTypeScopeAccess().getAlternatives_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeScope__Group__1__Impl" + + + // $ANTLR start "rule__TypeScope__Group__2" + // InternalProblem.g:3931:1: rule__TypeScope__Group__2 : rule__TypeScope__Group__2__Impl ; + public final void rule__TypeScope__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3935:1: ( rule__TypeScope__Group__2__Impl ) + // InternalProblem.g:3936:2: rule__TypeScope__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__TypeScope__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeScope__Group__2" + + + // $ANTLR start "rule__TypeScope__Group__2__Impl" + // InternalProblem.g:3942:1: rule__TypeScope__Group__2__Impl : ( ( rule__TypeScope__MultiplicityAssignment_2 ) ) ; + public final void rule__TypeScope__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3946:1: ( ( ( rule__TypeScope__MultiplicityAssignment_2 ) ) ) + // InternalProblem.g:3947:1: ( ( rule__TypeScope__MultiplicityAssignment_2 ) ) + { + // InternalProblem.g:3947:1: ( ( rule__TypeScope__MultiplicityAssignment_2 ) ) + // InternalProblem.g:3948:2: ( rule__TypeScope__MultiplicityAssignment_2 ) + { + before(grammarAccess.getTypeScopeAccess().getMultiplicityAssignment_2()); + // InternalProblem.g:3949:2: ( rule__TypeScope__MultiplicityAssignment_2 ) + // InternalProblem.g:3949:3: rule__TypeScope__MultiplicityAssignment_2 + { + pushFollow(FOLLOW_2); + rule__TypeScope__MultiplicityAssignment_2(); + + state._fsp--; + + + } + + after(grammarAccess.getTypeScopeAccess().getMultiplicityAssignment_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeScope__Group__2__Impl" + + + // $ANTLR start "rule__RangeMultiplicity__Group__0" + // InternalProblem.g:3958:1: rule__RangeMultiplicity__Group__0 : rule__RangeMultiplicity__Group__0__Impl rule__RangeMultiplicity__Group__1 ; + public final void rule__RangeMultiplicity__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3962:1: ( rule__RangeMultiplicity__Group__0__Impl rule__RangeMultiplicity__Group__1 ) + // InternalProblem.g:3963:2: rule__RangeMultiplicity__Group__0__Impl rule__RangeMultiplicity__Group__1 + { + pushFollow(FOLLOW_35); + rule__RangeMultiplicity__Group__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__RangeMultiplicity__Group__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RangeMultiplicity__Group__0" + + + // $ANTLR start "rule__RangeMultiplicity__Group__0__Impl" + // InternalProblem.g:3970:1: rule__RangeMultiplicity__Group__0__Impl : ( ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) ) ; + public final void rule__RangeMultiplicity__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3974:1: ( ( ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) ) ) + // InternalProblem.g:3975:1: ( ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) ) + { + // InternalProblem.g:3975:1: ( ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) ) + // InternalProblem.g:3976:2: ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) + { + before(grammarAccess.getRangeMultiplicityAccess().getLowerBoundAssignment_0()); + // InternalProblem.g:3977:2: ( rule__RangeMultiplicity__LowerBoundAssignment_0 ) + // InternalProblem.g:3977:3: rule__RangeMultiplicity__LowerBoundAssignment_0 + { + pushFollow(FOLLOW_2); + rule__RangeMultiplicity__LowerBoundAssignment_0(); + + state._fsp--; + + + } + + after(grammarAccess.getRangeMultiplicityAccess().getLowerBoundAssignment_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RangeMultiplicity__Group__0__Impl" + + + // $ANTLR start "rule__RangeMultiplicity__Group__1" + // InternalProblem.g:3985:1: rule__RangeMultiplicity__Group__1 : rule__RangeMultiplicity__Group__1__Impl rule__RangeMultiplicity__Group__2 ; + public final void rule__RangeMultiplicity__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:3989:1: ( rule__RangeMultiplicity__Group__1__Impl rule__RangeMultiplicity__Group__2 ) + // InternalProblem.g:3990:2: rule__RangeMultiplicity__Group__1__Impl rule__RangeMultiplicity__Group__2 + { + pushFollow(FOLLOW_36); + rule__RangeMultiplicity__Group__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__RangeMultiplicity__Group__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RangeMultiplicity__Group__1" + + + // $ANTLR start "rule__RangeMultiplicity__Group__1__Impl" + // InternalProblem.g:3997:1: rule__RangeMultiplicity__Group__1__Impl : ( '..' ) ; + public final void rule__RangeMultiplicity__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4001:1: ( ( '..' ) ) + // InternalProblem.g:4002:1: ( '..' ) + { + // InternalProblem.g:4002:1: ( '..' ) + // InternalProblem.g:4003:2: '..' + { + before(grammarAccess.getRangeMultiplicityAccess().getFullStopFullStopKeyword_1()); + match(input,38,FOLLOW_2); + after(grammarAccess.getRangeMultiplicityAccess().getFullStopFullStopKeyword_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RangeMultiplicity__Group__1__Impl" + + + // $ANTLR start "rule__RangeMultiplicity__Group__2" + // InternalProblem.g:4012:1: rule__RangeMultiplicity__Group__2 : rule__RangeMultiplicity__Group__2__Impl ; + public final void rule__RangeMultiplicity__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4016:1: ( rule__RangeMultiplicity__Group__2__Impl ) + // InternalProblem.g:4017:2: rule__RangeMultiplicity__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__RangeMultiplicity__Group__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RangeMultiplicity__Group__2" + + + // $ANTLR start "rule__RangeMultiplicity__Group__2__Impl" + // InternalProblem.g:4023:1: rule__RangeMultiplicity__Group__2__Impl : ( ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) ) ; + public final void rule__RangeMultiplicity__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4027:1: ( ( ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) ) ) + // InternalProblem.g:4028:1: ( ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) ) + { + // InternalProblem.g:4028:1: ( ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) ) + // InternalProblem.g:4029:2: ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) + { + before(grammarAccess.getRangeMultiplicityAccess().getUpperBoundAssignment_2()); + // InternalProblem.g:4030:2: ( rule__RangeMultiplicity__UpperBoundAssignment_2 ) + // InternalProblem.g:4030:3: rule__RangeMultiplicity__UpperBoundAssignment_2 + { + pushFollow(FOLLOW_2); + rule__RangeMultiplicity__UpperBoundAssignment_2(); + + state._fsp--; + + + } + + after(grammarAccess.getRangeMultiplicityAccess().getUpperBoundAssignment_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RangeMultiplicity__Group__2__Impl" + + + // $ANTLR start "rule__QualifiedName__Group_1__0" + // InternalProblem.g:4039:1: rule__QualifiedName__Group_1__0 : rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ; + public final void rule__QualifiedName__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4043:1: ( rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ) + // InternalProblem.g:4044:2: rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 + { + pushFollow(FOLLOW_29); + rule__QualifiedName__Group_1__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__0" + + + // $ANTLR start "rule__QualifiedName__Group_1__0__Impl" + // InternalProblem.g:4051:1: rule__QualifiedName__Group_1__0__Impl : ( ruleIdentifier ) ; + public final void rule__QualifiedName__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4055:1: ( ( ruleIdentifier ) ) + // InternalProblem.g:4056:1: ( ruleIdentifier ) + { + // InternalProblem.g:4056:1: ( ruleIdentifier ) + // InternalProblem.g:4057:2: ruleIdentifier + { + before(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + + after(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__0__Impl" + + + // $ANTLR start "rule__QualifiedName__Group_1__1" + // InternalProblem.g:4066:1: rule__QualifiedName__Group_1__1 : rule__QualifiedName__Group_1__1__Impl rule__QualifiedName__Group_1__2 ; + public final void rule__QualifiedName__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4070:1: ( rule__QualifiedName__Group_1__1__Impl rule__QualifiedName__Group_1__2 ) + // InternalProblem.g:4071:2: rule__QualifiedName__Group_1__1__Impl rule__QualifiedName__Group_1__2 + { + pushFollow(FOLLOW_29); + rule__QualifiedName__Group_1__1__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1__2(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__1" + + + // $ANTLR start "rule__QualifiedName__Group_1__1__Impl" + // InternalProblem.g:4078:1: rule__QualifiedName__Group_1__1__Impl : ( ( rule__QualifiedName__Group_1_1__0 )* ) ; + public final void rule__QualifiedName__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4082:1: ( ( ( rule__QualifiedName__Group_1_1__0 )* ) ) + // InternalProblem.g:4083:1: ( ( rule__QualifiedName__Group_1_1__0 )* ) + { + // InternalProblem.g:4083:1: ( ( rule__QualifiedName__Group_1_1__0 )* ) + // InternalProblem.g:4084:2: ( rule__QualifiedName__Group_1_1__0 )* + { + before(grammarAccess.getQualifiedNameAccess().getGroup_1_1()); + // InternalProblem.g:4085:2: ( rule__QualifiedName__Group_1_1__0 )* + loop47: + do { + int alt47=2; + int LA47_0 = input.LA(1); + + if ( (LA47_0==36) ) { + int LA47_1 = input.LA(2); + + if ( (LA47_1==RULE_ID||(LA47_1>=19 && LA47_1<=20)) ) { + alt47=1; + } + + + } + + + switch (alt47) { + case 1 : + // InternalProblem.g:4085:3: rule__QualifiedName__Group_1_1__0 + { + pushFollow(FOLLOW_37); + rule__QualifiedName__Group_1_1__0(); + + state._fsp--; + + + } + break; + + default : + break loop47; + } + } while (true); + + after(grammarAccess.getQualifiedNameAccess().getGroup_1_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__1__Impl" + + + // $ANTLR start "rule__QualifiedName__Group_1__2" + // InternalProblem.g:4093:1: rule__QualifiedName__Group_1__2 : rule__QualifiedName__Group_1__2__Impl ; + public final void rule__QualifiedName__Group_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4097:1: ( rule__QualifiedName__Group_1__2__Impl ) + // InternalProblem.g:4098:2: rule__QualifiedName__Group_1__2__Impl + { + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1__2__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__2" + + + // $ANTLR start "rule__QualifiedName__Group_1__2__Impl" + // InternalProblem.g:4104:1: rule__QualifiedName__Group_1__2__Impl : ( ( rule__QualifiedName__Group_1_2__0 )? ) ; + public final void rule__QualifiedName__Group_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4108:1: ( ( ( rule__QualifiedName__Group_1_2__0 )? ) ) + // InternalProblem.g:4109:1: ( ( rule__QualifiedName__Group_1_2__0 )? ) + { + // InternalProblem.g:4109:1: ( ( rule__QualifiedName__Group_1_2__0 )? ) + // InternalProblem.g:4110:2: ( rule__QualifiedName__Group_1_2__0 )? + { + before(grammarAccess.getQualifiedNameAccess().getGroup_1_2()); + // InternalProblem.g:4111:2: ( rule__QualifiedName__Group_1_2__0 )? + int alt48=2; + int LA48_0 = input.LA(1); + + if ( (LA48_0==36) ) { + alt48=1; + } + switch (alt48) { + case 1 : + // InternalProblem.g:4111:3: rule__QualifiedName__Group_1_2__0 + { + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1_2__0(); + + state._fsp--; + + + } + break; + + } + + after(grammarAccess.getQualifiedNameAccess().getGroup_1_2()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__2__Impl" + + + // $ANTLR start "rule__QualifiedName__Group_1_1__0" + // InternalProblem.g:4120:1: rule__QualifiedName__Group_1_1__0 : rule__QualifiedName__Group_1_1__0__Impl rule__QualifiedName__Group_1_1__1 ; + public final void rule__QualifiedName__Group_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4124:1: ( rule__QualifiedName__Group_1_1__0__Impl rule__QualifiedName__Group_1_1__1 ) + // InternalProblem.g:4125:2: rule__QualifiedName__Group_1_1__0__Impl rule__QualifiedName__Group_1_1__1 + { + pushFollow(FOLLOW_5); + rule__QualifiedName__Group_1_1__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1_1__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1_1__0" + + + // $ANTLR start "rule__QualifiedName__Group_1_1__0__Impl" + // InternalProblem.g:4132:1: rule__QualifiedName__Group_1_1__0__Impl : ( ':' ) ; + public final void rule__QualifiedName__Group_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4136:1: ( ( ':' ) ) + // InternalProblem.g:4137:1: ( ':' ) + { + // InternalProblem.g:4137:1: ( ':' ) + // InternalProblem.g:4138:2: ':' + { + before(grammarAccess.getQualifiedNameAccess().getColonKeyword_1_1_0()); + match(input,36,FOLLOW_2); + after(grammarAccess.getQualifiedNameAccess().getColonKeyword_1_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1_1__0__Impl" + + + // $ANTLR start "rule__QualifiedName__Group_1_1__1" + // InternalProblem.g:4147:1: rule__QualifiedName__Group_1_1__1 : rule__QualifiedName__Group_1_1__1__Impl ; + public final void rule__QualifiedName__Group_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4151:1: ( rule__QualifiedName__Group_1_1__1__Impl ) + // InternalProblem.g:4152:2: rule__QualifiedName__Group_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1_1__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1_1__1" + + + // $ANTLR start "rule__QualifiedName__Group_1_1__1__Impl" + // InternalProblem.g:4158:1: rule__QualifiedName__Group_1_1__1__Impl : ( ruleIdentifier ) ; + public final void rule__QualifiedName__Group_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4162:1: ( ( ruleIdentifier ) ) + // InternalProblem.g:4163:1: ( ruleIdentifier ) + { + // InternalProblem.g:4163:1: ( ruleIdentifier ) + // InternalProblem.g:4164:2: ruleIdentifier + { + before(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_1_1()); + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + + after(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_1_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1_1__1__Impl" + + + // $ANTLR start "rule__QualifiedName__Group_1_2__0" + // InternalProblem.g:4174:1: rule__QualifiedName__Group_1_2__0 : rule__QualifiedName__Group_1_2__0__Impl rule__QualifiedName__Group_1_2__1 ; + public final void rule__QualifiedName__Group_1_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4178:1: ( rule__QualifiedName__Group_1_2__0__Impl rule__QualifiedName__Group_1_2__1 ) + // InternalProblem.g:4179:2: rule__QualifiedName__Group_1_2__0__Impl rule__QualifiedName__Group_1_2__1 + { + pushFollow(FOLLOW_38); + rule__QualifiedName__Group_1_2__0__Impl(); + + state._fsp--; + + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1_2__1(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1_2__0" + + + // $ANTLR start "rule__QualifiedName__Group_1_2__0__Impl" + // InternalProblem.g:4186:1: rule__QualifiedName__Group_1_2__0__Impl : ( ':' ) ; + public final void rule__QualifiedName__Group_1_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4190:1: ( ( ':' ) ) + // InternalProblem.g:4191:1: ( ':' ) + { + // InternalProblem.g:4191:1: ( ':' ) + // InternalProblem.g:4192:2: ':' + { + before(grammarAccess.getQualifiedNameAccess().getColonKeyword_1_2_0()); + match(input,36,FOLLOW_2); + after(grammarAccess.getQualifiedNameAccess().getColonKeyword_1_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1_2__0__Impl" + + + // $ANTLR start "rule__QualifiedName__Group_1_2__1" + // InternalProblem.g:4201:1: rule__QualifiedName__Group_1_2__1 : rule__QualifiedName__Group_1_2__1__Impl ; + public final void rule__QualifiedName__Group_1_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4205:1: ( rule__QualifiedName__Group_1_2__1__Impl ) + // InternalProblem.g:4206:2: rule__QualifiedName__Group_1_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1_2__1__Impl(); + + state._fsp--; + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1_2__1" + + + // $ANTLR start "rule__QualifiedName__Group_1_2__1__Impl" + // InternalProblem.g:4212:1: rule__QualifiedName__Group_1_2__1__Impl : ( RULE_QUOTED_ID ) ; + public final void rule__QualifiedName__Group_1_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4216:1: ( ( RULE_QUOTED_ID ) ) + // InternalProblem.g:4217:1: ( RULE_QUOTED_ID ) + { + // InternalProblem.g:4217:1: ( RULE_QUOTED_ID ) + // InternalProblem.g:4218:2: RULE_QUOTED_ID + { + before(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1_2_1()); + match(input,RULE_QUOTED_ID,FOLLOW_2); + after(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1_2_1()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1_2__1__Impl" + + + // $ANTLR start "rule__Problem__NameAssignment_0_1" + // InternalProblem.g:4228:1: rule__Problem__NameAssignment_0_1 : ( ruleIdentifier ) ; + public final void rule__Problem__NameAssignment_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4232:1: ( ( ruleIdentifier ) ) + // InternalProblem.g:4233:2: ( ruleIdentifier ) + { + // InternalProblem.g:4233:2: ( ruleIdentifier ) + // InternalProblem.g:4234:3: ruleIdentifier + { + before(grammarAccess.getProblemAccess().getNameIdentifierParserRuleCall_0_1_0()); + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + + after(grammarAccess.getProblemAccess().getNameIdentifierParserRuleCall_0_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Problem__NameAssignment_0_1" + + + // $ANTLR start "rule__Problem__StatementsAssignment_1" + // InternalProblem.g:4243:1: rule__Problem__StatementsAssignment_1 : ( ruleStatement ) ; + public final void rule__Problem__StatementsAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4247:1: ( ( ruleStatement ) ) + // InternalProblem.g:4248:2: ( ruleStatement ) + { + // InternalProblem.g:4248:2: ( ruleStatement ) + // InternalProblem.g:4249:3: ruleStatement + { + before(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleStatement(); + + state._fsp--; + + after(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Problem__StatementsAssignment_1" + + + // $ANTLR start "rule__ClassDeclaration__AbstractAssignment_0" + // InternalProblem.g:4258:1: rule__ClassDeclaration__AbstractAssignment_0 : ( ( 'abstract' ) ) ; + public final void rule__ClassDeclaration__AbstractAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4262:1: ( ( ( 'abstract' ) ) ) + // InternalProblem.g:4263:2: ( ( 'abstract' ) ) + { + // InternalProblem.g:4263:2: ( ( 'abstract' ) ) + // InternalProblem.g:4264:3: ( 'abstract' ) + { + before(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); + // InternalProblem.g:4265:3: ( 'abstract' ) + // InternalProblem.g:4266:4: 'abstract' + { + before(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); + match(input,39,FOLLOW_2); + after(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); + + } + + after(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__AbstractAssignment_0" + + + // $ANTLR start "rule__ClassDeclaration__NameAssignment_2" + // InternalProblem.g:4277:1: rule__ClassDeclaration__NameAssignment_2 : ( ruleIdentifier ) ; + public final void rule__ClassDeclaration__NameAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4281:1: ( ( ruleIdentifier ) ) + // InternalProblem.g:4282:2: ( ruleIdentifier ) + { + // InternalProblem.g:4282:2: ( ruleIdentifier ) + // InternalProblem.g:4283:3: ruleIdentifier + { + before(grammarAccess.getClassDeclarationAccess().getNameIdentifierParserRuleCall_2_0()); + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + + after(grammarAccess.getClassDeclarationAccess().getNameIdentifierParserRuleCall_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__NameAssignment_2" + + + // $ANTLR start "rule__ClassDeclaration__SuperTypesAssignment_3_1" + // InternalProblem.g:4292:1: rule__ClassDeclaration__SuperTypesAssignment_3_1 : ( ( ruleQualifiedName ) ) ; + public final void rule__ClassDeclaration__SuperTypesAssignment_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4296:1: ( ( ( ruleQualifiedName ) ) ) + // InternalProblem.g:4297:2: ( ( ruleQualifiedName ) ) + { + // InternalProblem.g:4297:2: ( ( ruleQualifiedName ) ) + // InternalProblem.g:4298:3: ( ruleQualifiedName ) + { + before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_1_0()); + // InternalProblem.g:4299:3: ( ruleQualifiedName ) + // InternalProblem.g:4300:4: ruleQualifiedName + { + before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationQualifiedNameParserRuleCall_3_1_0_1()); + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + + after(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationQualifiedNameParserRuleCall_3_1_0_1()); + + } + + after(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__SuperTypesAssignment_3_1" + + + // $ANTLR start "rule__ClassDeclaration__SuperTypesAssignment_3_2_1" + // InternalProblem.g:4311:1: rule__ClassDeclaration__SuperTypesAssignment_3_2_1 : ( ( ruleQualifiedName ) ) ; + public final void rule__ClassDeclaration__SuperTypesAssignment_3_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4315:1: ( ( ( ruleQualifiedName ) ) ) + // InternalProblem.g:4316:2: ( ( ruleQualifiedName ) ) + { + // InternalProblem.g:4316:2: ( ( ruleQualifiedName ) ) + // InternalProblem.g:4317:3: ( ruleQualifiedName ) + { + before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_2_1_0()); + // InternalProblem.g:4318:3: ( ruleQualifiedName ) + // InternalProblem.g:4319:4: ruleQualifiedName + { + before(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationQualifiedNameParserRuleCall_3_2_1_0_1()); + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + + after(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationQualifiedNameParserRuleCall_3_2_1_0_1()); + + } + + after(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__SuperTypesAssignment_3_2_1" + + + // $ANTLR start "rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0" + // InternalProblem.g:4330:1: rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0 : ( ruleReferenceDeclaration ) ; + public final void rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4334:1: ( ( ruleReferenceDeclaration ) ) + // InternalProblem.g:4335:2: ( ruleReferenceDeclaration ) + { + // InternalProblem.g:4335:2: ( ruleReferenceDeclaration ) + // InternalProblem.g:4336:3: ruleReferenceDeclaration + { + before(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsReferenceDeclarationParserRuleCall_4_0_1_0_0()); + pushFollow(FOLLOW_2); + ruleReferenceDeclaration(); + + state._fsp--; + + after(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsReferenceDeclarationParserRuleCall_4_0_1_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ClassDeclaration__ReferenceDeclarationsAssignment_4_0_1_0" + + + // $ANTLR start "rule__EnumDeclaration__NameAssignment_1" + // InternalProblem.g:4345:1: rule__EnumDeclaration__NameAssignment_1 : ( ruleIdentifier ) ; + public final void rule__EnumDeclaration__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4349:1: ( ( ruleIdentifier ) ) + // InternalProblem.g:4350:2: ( ruleIdentifier ) + { + // InternalProblem.g:4350:2: ( ruleIdentifier ) + // InternalProblem.g:4351:3: ruleIdentifier + { + before(grammarAccess.getEnumDeclarationAccess().getNameIdentifierParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + + after(grammarAccess.getEnumDeclarationAccess().getNameIdentifierParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__NameAssignment_1" + + + // $ANTLR start "rule__EnumDeclaration__LiteralsAssignment_2_0_1_0" + // InternalProblem.g:4360:1: rule__EnumDeclaration__LiteralsAssignment_2_0_1_0 : ( ruleEnumLiteral ) ; + public final void rule__EnumDeclaration__LiteralsAssignment_2_0_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4364:1: ( ( ruleEnumLiteral ) ) + // InternalProblem.g:4365:2: ( ruleEnumLiteral ) + { + // InternalProblem.g:4365:2: ( ruleEnumLiteral ) + // InternalProblem.g:4366:3: ruleEnumLiteral + { + before(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); + pushFollow(FOLLOW_2); + ruleEnumLiteral(); + + state._fsp--; + + after(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__LiteralsAssignment_2_0_1_0" + + + // $ANTLR start "rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1" + // InternalProblem.g:4375:1: rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1 : ( ruleEnumLiteral ) ; + public final void rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4379:1: ( ( ruleEnumLiteral ) ) + // InternalProblem.g:4380:2: ( ruleEnumLiteral ) + { + // InternalProblem.g:4380:2: ( ruleEnumLiteral ) + // InternalProblem.g:4381:3: ruleEnumLiteral + { + before(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); + pushFollow(FOLLOW_2); + ruleEnumLiteral(); + + state._fsp--; + + after(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1" + + + // $ANTLR start "rule__EnumLiteral__NameAssignment" + // InternalProblem.g:4390:1: rule__EnumLiteral__NameAssignment : ( ruleQuotedOrUnquotedId ) ; + public final void rule__EnumLiteral__NameAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4394:1: ( ( ruleQuotedOrUnquotedId ) ) + // InternalProblem.g:4395:2: ( ruleQuotedOrUnquotedId ) + { + // InternalProblem.g:4395:2: ( ruleQuotedOrUnquotedId ) + // InternalProblem.g:4396:3: ruleQuotedOrUnquotedId + { + before(grammarAccess.getEnumLiteralAccess().getNameQuotedOrUnquotedIdParserRuleCall_0()); + pushFollow(FOLLOW_2); + ruleQuotedOrUnquotedId(); + + state._fsp--; + + after(grammarAccess.getEnumLiteralAccess().getNameQuotedOrUnquotedIdParserRuleCall_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__EnumLiteral__NameAssignment" + + + // $ANTLR start "rule__ReferenceDeclaration__ContainmentAssignment_0_0" + // InternalProblem.g:4405:1: rule__ReferenceDeclaration__ContainmentAssignment_0_0 : ( ( 'contains' ) ) ; + public final void rule__ReferenceDeclaration__ContainmentAssignment_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4409:1: ( ( ( 'contains' ) ) ) + // InternalProblem.g:4410:2: ( ( 'contains' ) ) + { + // InternalProblem.g:4410:2: ( ( 'contains' ) ) + // InternalProblem.g:4411:3: ( 'contains' ) + { + before(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); + // InternalProblem.g:4412:3: ( 'contains' ) + // InternalProblem.g:4413:4: 'contains' + { + before(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); + match(input,40,FOLLOW_2); + after(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); + + } + + after(grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__ContainmentAssignment_0_0" + + + // $ANTLR start "rule__ReferenceDeclaration__ReferenceTypeAssignment_1" + // InternalProblem.g:4424:1: rule__ReferenceDeclaration__ReferenceTypeAssignment_1 : ( ( ruleQualifiedName ) ) ; + public final void rule__ReferenceDeclaration__ReferenceTypeAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4428:1: ( ( ( ruleQualifiedName ) ) ) + // InternalProblem.g:4429:2: ( ( ruleQualifiedName ) ) + { + // InternalProblem.g:4429:2: ( ( ruleQualifiedName ) ) + // InternalProblem.g:4430:3: ( ruleQualifiedName ) + { + before(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationCrossReference_1_0()); + // InternalProblem.g:4431:3: ( ruleQualifiedName ) + // InternalProblem.g:4432:4: ruleQualifiedName + { + before(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationQualifiedNameParserRuleCall_1_0_1()); + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + + after(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationQualifiedNameParserRuleCall_1_0_1()); + + } + + after(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationCrossReference_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__ReferenceTypeAssignment_1" + + + // $ANTLR start "rule__ReferenceDeclaration__MultiplicityAssignment_2_1" + // InternalProblem.g:4443:1: rule__ReferenceDeclaration__MultiplicityAssignment_2_1 : ( ruleMultiplicity ) ; + public final void rule__ReferenceDeclaration__MultiplicityAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4447:1: ( ( ruleMultiplicity ) ) + // InternalProblem.g:4448:2: ( ruleMultiplicity ) + { + // InternalProblem.g:4448:2: ( ruleMultiplicity ) + // InternalProblem.g:4449:3: ruleMultiplicity + { + before(grammarAccess.getReferenceDeclarationAccess().getMultiplicityMultiplicityParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleMultiplicity(); + + state._fsp--; + + after(grammarAccess.getReferenceDeclarationAccess().getMultiplicityMultiplicityParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__MultiplicityAssignment_2_1" + + + // $ANTLR start "rule__ReferenceDeclaration__NameAssignment_3" + // InternalProblem.g:4458:1: rule__ReferenceDeclaration__NameAssignment_3 : ( ruleIdentifier ) ; + public final void rule__ReferenceDeclaration__NameAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4462:1: ( ( ruleIdentifier ) ) + // InternalProblem.g:4463:2: ( ruleIdentifier ) + { + // InternalProblem.g:4463:2: ( ruleIdentifier ) + // InternalProblem.g:4464:3: ruleIdentifier + { + before(grammarAccess.getReferenceDeclarationAccess().getNameIdentifierParserRuleCall_3_0()); + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + + after(grammarAccess.getReferenceDeclarationAccess().getNameIdentifierParserRuleCall_3_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__NameAssignment_3" + + + // $ANTLR start "rule__ReferenceDeclaration__OppositeAssignment_4_1" + // InternalProblem.g:4473:1: rule__ReferenceDeclaration__OppositeAssignment_4_1 : ( ( ruleQualifiedName ) ) ; + public final void rule__ReferenceDeclaration__OppositeAssignment_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4477:1: ( ( ( ruleQualifiedName ) ) ) + // InternalProblem.g:4478:2: ( ( ruleQualifiedName ) ) + { + // InternalProblem.g:4478:2: ( ( ruleQualifiedName ) ) + // InternalProblem.g:4479:3: ( ruleQualifiedName ) + { + before(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationCrossReference_4_1_0()); + // InternalProblem.g:4480:3: ( ruleQualifiedName ) + // InternalProblem.g:4481:4: ruleQualifiedName + { + before(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationQualifiedNameParserRuleCall_4_1_0_1()); + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + + after(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationQualifiedNameParserRuleCall_4_1_0_1()); + + } + + after(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationCrossReference_4_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ReferenceDeclaration__OppositeAssignment_4_1" + + + // $ANTLR start "rule__PredicateDefinition__ErrorAssignment_0_0_0" + // InternalProblem.g:4492:1: rule__PredicateDefinition__ErrorAssignment_0_0_0 : ( ( 'error' ) ) ; + public final void rule__PredicateDefinition__ErrorAssignment_0_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4496:1: ( ( ( 'error' ) ) ) + // InternalProblem.g:4497:2: ( ( 'error' ) ) + { + // InternalProblem.g:4497:2: ( ( 'error' ) ) + // InternalProblem.g:4498:3: ( 'error' ) + { + before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); + // InternalProblem.g:4499:3: ( 'error' ) + // InternalProblem.g:4500:4: 'error' + { + before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); + match(input,41,FOLLOW_2); + after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); + + } + + after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__ErrorAssignment_0_0_0" + + + // $ANTLR start "rule__PredicateDefinition__NameAssignment_1" + // InternalProblem.g:4511:1: rule__PredicateDefinition__NameAssignment_1 : ( ruleIdentifier ) ; + public final void rule__PredicateDefinition__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4515:1: ( ( ruleIdentifier ) ) + // InternalProblem.g:4516:2: ( ruleIdentifier ) + { + // InternalProblem.g:4516:2: ( ruleIdentifier ) + // InternalProblem.g:4517:3: ruleIdentifier + { + before(grammarAccess.getPredicateDefinitionAccess().getNameIdentifierParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + + after(grammarAccess.getPredicateDefinitionAccess().getNameIdentifierParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__NameAssignment_1" + + + // $ANTLR start "rule__PredicateDefinition__ParametersAssignment_3_0" + // InternalProblem.g:4526:1: rule__PredicateDefinition__ParametersAssignment_3_0 : ( ruleParameter ) ; + public final void rule__PredicateDefinition__ParametersAssignment_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4530:1: ( ( ruleParameter ) ) + // InternalProblem.g:4531:2: ( ruleParameter ) + { + // InternalProblem.g:4531:2: ( ruleParameter ) + // InternalProblem.g:4532:3: ruleParameter + { + before(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_0_0()); + pushFollow(FOLLOW_2); + ruleParameter(); + + state._fsp--; + + after(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__ParametersAssignment_3_0" + + + // $ANTLR start "rule__PredicateDefinition__ParametersAssignment_3_1_1" + // InternalProblem.g:4541:1: rule__PredicateDefinition__ParametersAssignment_3_1_1 : ( ruleParameter ) ; + public final void rule__PredicateDefinition__ParametersAssignment_3_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4545:1: ( ( ruleParameter ) ) + // InternalProblem.g:4546:2: ( ruleParameter ) + { + // InternalProblem.g:4546:2: ( ruleParameter ) + // InternalProblem.g:4547:3: ruleParameter + { + before(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_1_1_0()); + pushFollow(FOLLOW_2); + ruleParameter(); + + state._fsp--; + + after(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_1_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__ParametersAssignment_3_1_1" + + + // $ANTLR start "rule__PredicateDefinition__BodiesAssignment_5_1" + // InternalProblem.g:4556:1: rule__PredicateDefinition__BodiesAssignment_5_1 : ( ruleConjunction ) ; + public final void rule__PredicateDefinition__BodiesAssignment_5_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4560:1: ( ( ruleConjunction ) ) + // InternalProblem.g:4561:2: ( ruleConjunction ) + { + // InternalProblem.g:4561:2: ( ruleConjunction ) + // InternalProblem.g:4562:3: ruleConjunction + { + before(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_1_0()); + pushFollow(FOLLOW_2); + ruleConjunction(); + + state._fsp--; + + after(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__BodiesAssignment_5_1" + + + // $ANTLR start "rule__PredicateDefinition__BodiesAssignment_5_2_1" + // InternalProblem.g:4571:1: rule__PredicateDefinition__BodiesAssignment_5_2_1 : ( ruleConjunction ) ; + public final void rule__PredicateDefinition__BodiesAssignment_5_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4575:1: ( ( ruleConjunction ) ) + // InternalProblem.g:4576:2: ( ruleConjunction ) + { + // InternalProblem.g:4576:2: ( ruleConjunction ) + // InternalProblem.g:4577:3: ruleConjunction + { + before(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_2_1_0()); + pushFollow(FOLLOW_2); + ruleConjunction(); + + state._fsp--; + + after(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__PredicateDefinition__BodiesAssignment_5_2_1" + + + // $ANTLR start "rule__Parameter__ParameterTypeAssignment_0" + // InternalProblem.g:4586:1: rule__Parameter__ParameterTypeAssignment_0 : ( ( ruleQualifiedName ) ) ; + public final void rule__Parameter__ParameterTypeAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4590:1: ( ( ( ruleQualifiedName ) ) ) + // InternalProblem.g:4591:2: ( ( ruleQualifiedName ) ) + { + // InternalProblem.g:4591:2: ( ( ruleQualifiedName ) ) + // InternalProblem.g:4592:3: ( ruleQualifiedName ) + { + before(grammarAccess.getParameterAccess().getParameterTypeRelationCrossReference_0_0()); + // InternalProblem.g:4593:3: ( ruleQualifiedName ) + // InternalProblem.g:4594:4: ruleQualifiedName + { + before(grammarAccess.getParameterAccess().getParameterTypeRelationQualifiedNameParserRuleCall_0_0_1()); + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + + after(grammarAccess.getParameterAccess().getParameterTypeRelationQualifiedNameParserRuleCall_0_0_1()); + + } + + after(grammarAccess.getParameterAccess().getParameterTypeRelationCrossReference_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__ParameterTypeAssignment_0" + + + // $ANTLR start "rule__Parameter__NameAssignment_1" + // InternalProblem.g:4605:1: rule__Parameter__NameAssignment_1 : ( ruleIdentifier ) ; + public final void rule__Parameter__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4609:1: ( ( ruleIdentifier ) ) + // InternalProblem.g:4610:2: ( ruleIdentifier ) + { + // InternalProblem.g:4610:2: ( ruleIdentifier ) + // InternalProblem.g:4611:3: ruleIdentifier + { + before(grammarAccess.getParameterAccess().getNameIdentifierParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + + after(grammarAccess.getParameterAccess().getNameIdentifierParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Parameter__NameAssignment_1" + + + // $ANTLR start "rule__Conjunction__LiteralsAssignment_0" + // InternalProblem.g:4620:1: rule__Conjunction__LiteralsAssignment_0 : ( ruleLiteral ) ; + public final void rule__Conjunction__LiteralsAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4624:1: ( ( ruleLiteral ) ) + // InternalProblem.g:4625:2: ( ruleLiteral ) + { + // InternalProblem.g:4625:2: ( ruleLiteral ) + // InternalProblem.g:4626:3: ruleLiteral + { + before(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_0_0()); + pushFollow(FOLLOW_2); + ruleLiteral(); + + state._fsp--; + + after(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Conjunction__LiteralsAssignment_0" + + + // $ANTLR start "rule__Conjunction__LiteralsAssignment_1_1" + // InternalProblem.g:4635:1: rule__Conjunction__LiteralsAssignment_1_1 : ( ruleLiteral ) ; + public final void rule__Conjunction__LiteralsAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4639:1: ( ( ruleLiteral ) ) + // InternalProblem.g:4640:2: ( ruleLiteral ) + { + // InternalProblem.g:4640:2: ( ruleLiteral ) + // InternalProblem.g:4641:3: ruleLiteral + { + before(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_1_1_0()); + pushFollow(FOLLOW_2); + ruleLiteral(); + + state._fsp--; + + after(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_1_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Conjunction__LiteralsAssignment_1_1" + + + // $ANTLR start "rule__NegativeLiteral__AtomAssignment_1" + // InternalProblem.g:4650:1: rule__NegativeLiteral__AtomAssignment_1 : ( ruleAtom ) ; + public final void rule__NegativeLiteral__AtomAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4654:1: ( ( ruleAtom ) ) + // InternalProblem.g:4655:2: ( ruleAtom ) + { + // InternalProblem.g:4655:2: ( ruleAtom ) + // InternalProblem.g:4656:3: ruleAtom + { + before(grammarAccess.getNegativeLiteralAccess().getAtomAtomParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleAtom(); + + state._fsp--; + + after(grammarAccess.getNegativeLiteralAccess().getAtomAtomParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NegativeLiteral__AtomAssignment_1" + + + // $ANTLR start "rule__Atom__RelationAssignment_0" + // InternalProblem.g:4665:1: rule__Atom__RelationAssignment_0 : ( ( ruleQualifiedName ) ) ; + public final void rule__Atom__RelationAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4669:1: ( ( ( ruleQualifiedName ) ) ) + // InternalProblem.g:4670:2: ( ( ruleQualifiedName ) ) + { + // InternalProblem.g:4670:2: ( ( ruleQualifiedName ) ) + // InternalProblem.g:4671:3: ( ruleQualifiedName ) + { + before(grammarAccess.getAtomAccess().getRelationRelationCrossReference_0_0()); + // InternalProblem.g:4672:3: ( ruleQualifiedName ) + // InternalProblem.g:4673:4: ruleQualifiedName + { + before(grammarAccess.getAtomAccess().getRelationRelationQualifiedNameParserRuleCall_0_0_1()); + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + + after(grammarAccess.getAtomAccess().getRelationRelationQualifiedNameParserRuleCall_0_0_1()); + + } + + after(grammarAccess.getAtomAccess().getRelationRelationCrossReference_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__RelationAssignment_0" + + + // $ANTLR start "rule__Atom__TransitiveClosureAssignment_1" + // InternalProblem.g:4684:1: rule__Atom__TransitiveClosureAssignment_1 : ( ( '+' ) ) ; + public final void rule__Atom__TransitiveClosureAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4688:1: ( ( ( '+' ) ) ) + // InternalProblem.g:4689:2: ( ( '+' ) ) + { + // InternalProblem.g:4689:2: ( ( '+' ) ) + // InternalProblem.g:4690:3: ( '+' ) + { + before(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); + // InternalProblem.g:4691:3: ( '+' ) + // InternalProblem.g:4692:4: '+' + { + before(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); + match(input,42,FOLLOW_2); + after(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); + + } + + after(grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__TransitiveClosureAssignment_1" + + + // $ANTLR start "rule__Atom__ArgumentsAssignment_3_0" + // InternalProblem.g:4703:1: rule__Atom__ArgumentsAssignment_3_0 : ( ruleArgument ) ; + public final void rule__Atom__ArgumentsAssignment_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4707:1: ( ( ruleArgument ) ) + // InternalProblem.g:4708:2: ( ruleArgument ) + { + // InternalProblem.g:4708:2: ( ruleArgument ) + // InternalProblem.g:4709:3: ruleArgument + { + before(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_0_0()); + pushFollow(FOLLOW_2); + ruleArgument(); + + state._fsp--; + + after(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__ArgumentsAssignment_3_0" + + + // $ANTLR start "rule__Atom__ArgumentsAssignment_3_1_1" + // InternalProblem.g:4718:1: rule__Atom__ArgumentsAssignment_3_1_1 : ( ruleArgument ) ; + public final void rule__Atom__ArgumentsAssignment_3_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4722:1: ( ( ruleArgument ) ) + // InternalProblem.g:4723:2: ( ruleArgument ) + { + // InternalProblem.g:4723:2: ( ruleArgument ) + // InternalProblem.g:4724:3: ruleArgument + { + before(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_1_1_0()); + pushFollow(FOLLOW_2); + ruleArgument(); + + state._fsp--; + + after(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_1_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Atom__ArgumentsAssignment_3_1_1" + + + // $ANTLR start "rule__Argument__VariableOrNodeAssignment" + // InternalProblem.g:4733:1: rule__Argument__VariableOrNodeAssignment : ( ( ruleQualifiedName ) ) ; + public final void rule__Argument__VariableOrNodeAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4737:1: ( ( ( ruleQualifiedName ) ) ) + // InternalProblem.g:4738:2: ( ( ruleQualifiedName ) ) + { + // InternalProblem.g:4738:2: ( ( ruleQualifiedName ) ) + // InternalProblem.g:4739:3: ( ruleQualifiedName ) + { + before(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); + // InternalProblem.g:4740:3: ( ruleQualifiedName ) + // InternalProblem.g:4741:4: ruleQualifiedName + { + before(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1()); + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + + after(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1()); + + } + + after(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Argument__VariableOrNodeAssignment" + + + // $ANTLR start "rule__Assertion__RelationAssignment_0_0_0" + // InternalProblem.g:4752:1: rule__Assertion__RelationAssignment_0_0_0 : ( ( ruleQualifiedName ) ) ; + public final void rule__Assertion__RelationAssignment_0_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4756:1: ( ( ( ruleQualifiedName ) ) ) + // InternalProblem.g:4757:2: ( ( ruleQualifiedName ) ) + { + // InternalProblem.g:4757:2: ( ( ruleQualifiedName ) ) + // InternalProblem.g:4758:3: ( ruleQualifiedName ) + { + before(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_0_0_0()); + // InternalProblem.g:4759:3: ( ruleQualifiedName ) + // InternalProblem.g:4760:4: ruleQualifiedName + { + before(grammarAccess.getAssertionAccess().getRelationRelationQualifiedNameParserRuleCall_0_0_0_0_1()); + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + + after(grammarAccess.getAssertionAccess().getRelationRelationQualifiedNameParserRuleCall_0_0_0_0_1()); + + } + + after(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_0_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__RelationAssignment_0_0_0" + + + // $ANTLR start "rule__Assertion__ArgumentsAssignment_0_0_2_0" + // InternalProblem.g:4771:1: rule__Assertion__ArgumentsAssignment_0_0_2_0 : ( ( ruleQualifiedName ) ) ; + public final void rule__Assertion__ArgumentsAssignment_0_0_2_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4775:1: ( ( ( ruleQualifiedName ) ) ) + // InternalProblem.g:4776:2: ( ( ruleQualifiedName ) ) + { + // InternalProblem.g:4776:2: ( ( ruleQualifiedName ) ) + // InternalProblem.g:4777:3: ( ruleQualifiedName ) + { + before(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_0_0()); + // InternalProblem.g:4778:3: ( ruleQualifiedName ) + // InternalProblem.g:4779:4: ruleQualifiedName + { + before(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_0_0_1()); + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + + after(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_0_0_1()); + + } + + after(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__ArgumentsAssignment_0_0_2_0" + + + // $ANTLR start "rule__Assertion__ArgumentsAssignment_0_0_2_1_1" + // InternalProblem.g:4790:1: rule__Assertion__ArgumentsAssignment_0_0_2_1_1 : ( ( ruleQualifiedName ) ) ; + public final void rule__Assertion__ArgumentsAssignment_0_0_2_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4794:1: ( ( ( ruleQualifiedName ) ) ) + // InternalProblem.g:4795:2: ( ( ruleQualifiedName ) ) + { + // InternalProblem.g:4795:2: ( ( ruleQualifiedName ) ) + // InternalProblem.g:4796:3: ( ruleQualifiedName ) + { + before(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_1_1_0()); + // InternalProblem.g:4797:3: ( ruleQualifiedName ) + // InternalProblem.g:4798:4: ruleQualifiedName + { + before(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_1_1_0_1()); + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + + after(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_1_1_0_1()); + + } + + after(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_1_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__ArgumentsAssignment_0_0_2_1_1" + + + // $ANTLR start "rule__Assertion__ValueAssignment_0_0_5" + // InternalProblem.g:4809:1: rule__Assertion__ValueAssignment_0_0_5 : ( ruleLogicValue ) ; + public final void rule__Assertion__ValueAssignment_0_0_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4813:1: ( ( ruleLogicValue ) ) + // InternalProblem.g:4814:2: ( ruleLogicValue ) + { + // InternalProblem.g:4814:2: ( ruleLogicValue ) + // InternalProblem.g:4815:3: ruleLogicValue + { + before(grammarAccess.getAssertionAccess().getValueLogicValueEnumRuleCall_0_0_5_0()); + pushFollow(FOLLOW_2); + ruleLogicValue(); + + state._fsp--; + + after(grammarAccess.getAssertionAccess().getValueLogicValueEnumRuleCall_0_0_5_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__ValueAssignment_0_0_5" + + + // $ANTLR start "rule__Assertion__ValueAssignment_0_1_0" + // InternalProblem.g:4824:1: rule__Assertion__ValueAssignment_0_1_0 : ( ruleShortLogicValue ) ; + public final void rule__Assertion__ValueAssignment_0_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4828:1: ( ( ruleShortLogicValue ) ) + // InternalProblem.g:4829:2: ( ruleShortLogicValue ) + { + // InternalProblem.g:4829:2: ( ruleShortLogicValue ) + // InternalProblem.g:4830:3: ruleShortLogicValue + { + before(grammarAccess.getAssertionAccess().getValueShortLogicValueEnumRuleCall_0_1_0_0()); + pushFollow(FOLLOW_2); + ruleShortLogicValue(); + + state._fsp--; + + after(grammarAccess.getAssertionAccess().getValueShortLogicValueEnumRuleCall_0_1_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__ValueAssignment_0_1_0" + + + // $ANTLR start "rule__Assertion__RelationAssignment_0_1_1" + // InternalProblem.g:4839:1: rule__Assertion__RelationAssignment_0_1_1 : ( ( ruleQualifiedName ) ) ; + public final void rule__Assertion__RelationAssignment_0_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4843:1: ( ( ( ruleQualifiedName ) ) ) + // InternalProblem.g:4844:2: ( ( ruleQualifiedName ) ) + { + // InternalProblem.g:4844:2: ( ( ruleQualifiedName ) ) + // InternalProblem.g:4845:3: ( ruleQualifiedName ) + { + before(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_1_1_0()); + // InternalProblem.g:4846:3: ( ruleQualifiedName ) + // InternalProblem.g:4847:4: ruleQualifiedName + { + before(grammarAccess.getAssertionAccess().getRelationRelationQualifiedNameParserRuleCall_0_1_1_0_1()); + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + + after(grammarAccess.getAssertionAccess().getRelationRelationQualifiedNameParserRuleCall_0_1_1_0_1()); + + } + + after(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_1_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__RelationAssignment_0_1_1" + + + // $ANTLR start "rule__Assertion__ArgumentsAssignment_0_1_3_0" + // InternalProblem.g:4858:1: rule__Assertion__ArgumentsAssignment_0_1_3_0 : ( ( ruleQualifiedName ) ) ; + public final void rule__Assertion__ArgumentsAssignment_0_1_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4862:1: ( ( ( ruleQualifiedName ) ) ) + // InternalProblem.g:4863:2: ( ( ruleQualifiedName ) ) + { + // InternalProblem.g:4863:2: ( ( ruleQualifiedName ) ) + // InternalProblem.g:4864:3: ( ruleQualifiedName ) + { + before(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_0_0()); + // InternalProblem.g:4865:3: ( ruleQualifiedName ) + // InternalProblem.g:4866:4: ruleQualifiedName + { + before(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_0_0_1()); + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + + after(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_0_0_1()); + + } + + after(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__ArgumentsAssignment_0_1_3_0" + + + // $ANTLR start "rule__Assertion__ArgumentsAssignment_0_1_3_1_1" + // InternalProblem.g:4877:1: rule__Assertion__ArgumentsAssignment_0_1_3_1_1 : ( ( ruleQualifiedName ) ) ; + public final void rule__Assertion__ArgumentsAssignment_0_1_3_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4881:1: ( ( ( ruleQualifiedName ) ) ) + // InternalProblem.g:4882:2: ( ( ruleQualifiedName ) ) + { + // InternalProblem.g:4882:2: ( ( ruleQualifiedName ) ) + // InternalProblem.g:4883:3: ( ruleQualifiedName ) + { + before(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_1_1_0()); + // InternalProblem.g:4884:3: ( ruleQualifiedName ) + // InternalProblem.g:4885:4: ruleQualifiedName + { + before(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_1_1_0_1()); + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + + after(grammarAccess.getAssertionAccess().getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_1_1_0_1()); + + } + + after(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_1_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Assertion__ArgumentsAssignment_0_1_3_1_1" + + + // $ANTLR start "rule__ScopeDeclaration__TypeScopesAssignment_1" + // InternalProblem.g:4896:1: rule__ScopeDeclaration__TypeScopesAssignment_1 : ( ruleTypeScope ) ; + public final void rule__ScopeDeclaration__TypeScopesAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4900:1: ( ( ruleTypeScope ) ) + // InternalProblem.g:4901:2: ( ruleTypeScope ) + { + // InternalProblem.g:4901:2: ( ruleTypeScope ) + // InternalProblem.g:4902:3: ruleTypeScope + { + before(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_1_0()); + pushFollow(FOLLOW_2); + ruleTypeScope(); + + state._fsp--; + + after(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDeclaration__TypeScopesAssignment_1" + + + // $ANTLR start "rule__ScopeDeclaration__TypeScopesAssignment_2_1" + // InternalProblem.g:4911:1: rule__ScopeDeclaration__TypeScopesAssignment_2_1 : ( ruleTypeScope ) ; + public final void rule__ScopeDeclaration__TypeScopesAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4915:1: ( ( ruleTypeScope ) ) + // InternalProblem.g:4916:2: ( ruleTypeScope ) + { + // InternalProblem.g:4916:2: ( ruleTypeScope ) + // InternalProblem.g:4917:3: ruleTypeScope + { + before(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_2_1_0()); + pushFollow(FOLLOW_2); + ruleTypeScope(); + + state._fsp--; + + after(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_2_1_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDeclaration__TypeScopesAssignment_2_1" + + + // $ANTLR start "rule__TypeScope__TargetTypeAssignment_0" + // InternalProblem.g:4926:1: rule__TypeScope__TargetTypeAssignment_0 : ( ( RULE_ID ) ) ; + public final void rule__TypeScope__TargetTypeAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4930:1: ( ( ( RULE_ID ) ) ) + // InternalProblem.g:4931:2: ( ( RULE_ID ) ) + { + // InternalProblem.g:4931:2: ( ( RULE_ID ) ) + // InternalProblem.g:4932:3: ( RULE_ID ) + { + before(grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationCrossReference_0_0()); + // InternalProblem.g:4933:3: ( RULE_ID ) + // InternalProblem.g:4934:4: RULE_ID + { + before(grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationIDTerminalRuleCall_0_0_1()); + match(input,RULE_ID,FOLLOW_2); + after(grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationIDTerminalRuleCall_0_0_1()); + + } + + after(grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationCrossReference_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeScope__TargetTypeAssignment_0" + + + // $ANTLR start "rule__TypeScope__IncrementAssignment_1_0" + // InternalProblem.g:4945:1: rule__TypeScope__IncrementAssignment_1_0 : ( ( '+=' ) ) ; + public final void rule__TypeScope__IncrementAssignment_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4949:1: ( ( ( '+=' ) ) ) + // InternalProblem.g:4950:2: ( ( '+=' ) ) + { + // InternalProblem.g:4950:2: ( ( '+=' ) ) + // InternalProblem.g:4951:3: ( '+=' ) + { + before(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); + // InternalProblem.g:4952:3: ( '+=' ) + // InternalProblem.g:4953:4: '+=' + { + before(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); + match(input,43,FOLLOW_2); + after(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); + + } + + after(grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeScope__IncrementAssignment_1_0" + + + // $ANTLR start "rule__TypeScope__MultiplicityAssignment_2" + // InternalProblem.g:4964:1: rule__TypeScope__MultiplicityAssignment_2 : ( ruleDefiniteMultiplicity ) ; + public final void rule__TypeScope__MultiplicityAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4968:1: ( ( ruleDefiniteMultiplicity ) ) + // InternalProblem.g:4969:2: ( ruleDefiniteMultiplicity ) + { + // InternalProblem.g:4969:2: ( ruleDefiniteMultiplicity ) + // InternalProblem.g:4970:3: ruleDefiniteMultiplicity + { + before(grammarAccess.getTypeScopeAccess().getMultiplicityDefiniteMultiplicityParserRuleCall_2_0()); + pushFollow(FOLLOW_2); + ruleDefiniteMultiplicity(); + + state._fsp--; + + after(grammarAccess.getTypeScopeAccess().getMultiplicityDefiniteMultiplicityParserRuleCall_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeScope__MultiplicityAssignment_2" + + + // $ANTLR start "rule__RangeMultiplicity__LowerBoundAssignment_0" + // InternalProblem.g:4979:1: rule__RangeMultiplicity__LowerBoundAssignment_0 : ( RULE_INT ) ; + public final void rule__RangeMultiplicity__LowerBoundAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4983:1: ( ( RULE_INT ) ) + // InternalProblem.g:4984:2: ( RULE_INT ) + { + // InternalProblem.g:4984:2: ( RULE_INT ) + // InternalProblem.g:4985:3: RULE_INT + { + before(grammarAccess.getRangeMultiplicityAccess().getLowerBoundINTTerminalRuleCall_0_0()); + match(input,RULE_INT,FOLLOW_2); + after(grammarAccess.getRangeMultiplicityAccess().getLowerBoundINTTerminalRuleCall_0_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RangeMultiplicity__LowerBoundAssignment_0" + + + // $ANTLR start "rule__RangeMultiplicity__UpperBoundAssignment_2" + // InternalProblem.g:4994:1: rule__RangeMultiplicity__UpperBoundAssignment_2 : ( ruleUpperBound ) ; + public final void rule__RangeMultiplicity__UpperBoundAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:4998:1: ( ( ruleUpperBound ) ) + // InternalProblem.g:4999:2: ( ruleUpperBound ) + { + // InternalProblem.g:4999:2: ( ruleUpperBound ) + // InternalProblem.g:5000:3: ruleUpperBound + { + before(grammarAccess.getRangeMultiplicityAccess().getUpperBoundUpperBoundParserRuleCall_2_0()); + pushFollow(FOLLOW_2); + ruleUpperBound(); + + state._fsp--; + + after(grammarAccess.getRangeMultiplicityAccess().getUpperBoundUpperBoundParserRuleCall_2_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RangeMultiplicity__UpperBoundAssignment_2" + + + // $ANTLR start "rule__ExactMultiplicity__ExactValueAssignment" + // InternalProblem.g:5009:1: rule__ExactMultiplicity__ExactValueAssignment : ( RULE_INT ) ; + public final void rule__ExactMultiplicity__ExactValueAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalProblem.g:5013:1: ( ( RULE_INT ) ) + // InternalProblem.g:5014:2: ( RULE_INT ) + { + // InternalProblem.g:5014:2: ( RULE_INT ) + // InternalProblem.g:5015:3: RULE_INT + { + before(grammarAccess.getExactMultiplicityAccess().getExactValueINTTerminalRuleCall_0()); + match(input,RULE_INT,FOLLOW_2); + after(grammarAccess.getExactMultiplicityAccess().getExactValueINTTerminalRuleCall_0()); + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ExactMultiplicity__ExactValueAssignment" + + // Delegated rules + + + protected DFA8 dfa8 = new DFA8(this); + static final String dfa_1s = "\41\uffff"; + static final String dfa_2s = "\1\5\4\41\1\uffff\2\5\4\15\1\14\4\41\2\5\1\uffff\10\15\1\5\4\15"; + static final String dfa_3s = "\1\27\1\41\3\44\1\uffff\1\42\1\24\1\42\4\44\1\41\3\44\2\24\1\uffff\1\42\6\44\1\42\1\24\1\42\3\44"; + static final String dfa_4s = "\5\uffff\1\2\15\uffff\1\1\15\uffff"; + static final String dfa_5s = "\41\uffff}>"; + static final String[] dfa_6s = { + "\1\1\1\2\14\uffff\1\3\1\4\1\uffff\2\5", + "\1\6", + "\1\6\2\uffff\1\7", + "\1\6\2\uffff\1\7", + "\1\6\2\uffff\1\7", + "", + "\1\10\1\11\14\uffff\1\12\1\13\15\uffff\1\14", + "\1\15\1\16\14\uffff\1\17\1\20", + "\1\21\24\uffff\1\14", + "\1\21\24\uffff\1\14\1\uffff\1\22", + "\1\21\24\uffff\1\14\1\uffff\1\22", + "\1\21\24\uffff\1\14\1\uffff\1\22", + "\1\5\27\uffff\1\23", + "\1\6", + "\1\6\2\uffff\1\7", + "\1\6\2\uffff\1\7", + "\1\6\2\uffff\1\7", + "\1\24\1\25\14\uffff\1\26\1\27", + "\1\33\1\30\14\uffff\1\31\1\32", + "", + "\1\21\24\uffff\1\14", + "\1\21\24\uffff\1\14\1\uffff\1\34", + "\1\21\24\uffff\1\14\1\uffff\1\34", + "\1\21\24\uffff\1\14\1\uffff\1\34", + "\1\21\24\uffff\1\14\1\uffff\1\22", + "\1\21\24\uffff\1\14\1\uffff\1\22", + "\1\21\24\uffff\1\14\1\uffff\1\22", + "\1\21\24\uffff\1\14", + "\1\35\1\36\14\uffff\1\37\1\40", + "\1\21\24\uffff\1\14", + "\1\21\24\uffff\1\14\1\uffff\1\34", + "\1\21\24\uffff\1\14\1\uffff\1\34", + "\1\21\24\uffff\1\14\1\uffff\1\34" + }; + + static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); + static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s); + static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); + static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s); + static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); + static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); + + class DFA8 extends DFA { + + public DFA8(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 8; + this.eot = dfa_1; + this.eof = dfa_1; + this.min = dfa_2; + this.max = dfa_3; + this.accept = dfa_4; + this.special = dfa_5; + this.transition = dfa_6; + } + public String getDescription() { + return "874:1: rule__Assertion__Alternatives_0 : ( ( ( rule__Assertion__Group_0_0__0 ) ) | ( ( rule__Assertion__Group_0_1__0 ) ) );"; + } + } + + + public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); + public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x000002A022D90060L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x000002A022D90062L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000180060L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000001000L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000008002000000L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x000000000C001000L}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000002000L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000002002L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000010010188060L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000010000188062L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000004000L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000008001000L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000010180060L}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000006000L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000010000188060L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000040180060L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000100000000L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000000010L}); + public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000080000000L}); + public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000200000000L}); + public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000400180060L}); + public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000800001000L}); + public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000000010000L}); + public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000580060L}); + public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000004002L}); + public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000040200000000L}); + public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000001000000000L}); + public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000000380000L}); + public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000000D80060L}); + public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000000000040L}); + public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000000003000L}); + public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000080000020000L}); + public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000004000000000L}); + public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000000040010L}); + public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000001000000002L}); + public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000000000020L}); + +} \ No newline at end of file -- cgit v1.2.3-54-g00ecf