initial commit

author: Oszkar Semerath <semerath@mit.bme.hu> 2020-04-28 20:43:04 +0200
committer: Oszkar Semerath <semerath@mit.bme.hu> 2020-04-28 20:43:04 +0200
commit: 8a7b9b436b31e6d2f5a0521a077c960ebdeb4cbe (patch)
tree: d525bef75519f364d637e0779f8e63d4199dee31 /Application/org.eclipse.viatra.solver.language/src-gen
parent: check expressions are mapped to WF constraints (diff)
download: VIATRA-Generator-8a7b9b436b31e6d2f5a0521a077c960ebdeb4cbe.tar.gz
VIATRA-Generator-8a7b9b436b31e6d2f5a0521a077c960ebdeb4cbe.tar.zst
VIATRA-Generator-8a7b9b436b31e6d2f5a0521a077c960ebdeb4cbe.zip
129 files changed, 33382 insertions, 0 deletions
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/AbstractSolverLanguageRuntimeModule.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/AbstractSolverLanguageRuntimeModule.java
new file mode 100644
index 00000000..cbf67ff9
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/AbstractSolverLanguageRuntimeModule.java
@@ -0,0 +1,201 @@
+/*
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language;
+import com.google.inject.Binder;
+import com.google.inject.Provider;
+import com.google.inject.name.Names;
+import java.util.Properties;
+import org.eclipse.viatra.solver.language.generator.SolverLanguageGenerator;
+import org.eclipse.viatra.solver.language.parser.antlr.SolverLanguageAntlrTokenFileProvider;
+import org.eclipse.viatra.solver.language.parser.antlr.SolverLanguageParser;
+import org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageLexer;
+import org.eclipse.viatra.solver.language.scoping.SolverLanguageScopeProvider;
+import org.eclipse.viatra.solver.language.serializer.SolverLanguageSemanticSequencer;
+import org.eclipse.viatra.solver.language.serializer.SolverLanguageSyntacticSequencer;
+import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
+import org.eclipse.viatra.solver.language.validation.SolverLanguageConfigurableIssueCodesProvider;
+import org.eclipse.viatra.solver.language.validation.SolverLanguageValidator;
+import org.eclipse.xtext.Constants;
+import org.eclipse.xtext.IGrammarAccess;
+import org.eclipse.xtext.generator.IGenerator2;
+import org.eclipse.xtext.naming.DefaultDeclarativeQualifiedNameProvider;
+import org.eclipse.xtext.naming.IQualifiedNameProvider;
+import org.eclipse.xtext.parser.IParser;
+import org.eclipse.xtext.parser.ITokenToStringConverter;
+import org.eclipse.xtext.parser.antlr.AntlrTokenDefProvider;
+import org.eclipse.xtext.parser.antlr.AntlrTokenToStringConverter;
+import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider;
+import org.eclipse.xtext.parser.antlr.ITokenDefProvider;
+import org.eclipse.xtext.parser.antlr.Lexer;
+import org.eclipse.xtext.parser.antlr.LexerBindings;
+import org.eclipse.xtext.parser.antlr.LexerProvider;
+import org.eclipse.xtext.resource.IContainer;
+import org.eclipse.xtext.resource.IResourceDescriptions;
+import org.eclipse.xtext.resource.containers.IAllContainersState;
+import org.eclipse.xtext.resource.containers.ResourceSetBasedAllContainersStateProvider;
+import org.eclipse.xtext.resource.containers.StateBasedContainerManager;
+import org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider;
+import org.eclipse.xtext.resource.impl.ResourceSetBasedResourceDescriptions;
+import org.eclipse.xtext.scoping.IGlobalScopeProvider;
+import org.eclipse.xtext.scoping.IScopeProvider;
+import org.eclipse.xtext.scoping.IgnoreCaseLinking;
+import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider;
+import org.eclipse.xtext.scoping.impl.DefaultGlobalScopeProvider;
+import org.eclipse.xtext.scoping.impl.ImportedNamespaceAwareLocalScopeProvider;
+import org.eclipse.xtext.serializer.ISerializer;
+import org.eclipse.xtext.serializer.impl.Serializer;
+import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
+import org.eclipse.xtext.serializer.sequencer.ISyntacticSequencer;
+import org.eclipse.xtext.service.DefaultRuntimeModule;
+import org.eclipse.xtext.service.SingletonBinding;
+import org.eclipse.xtext.validation.ConfigurableIssueCodesProvider;
+/**
+ * Manual modifications go to {@link SolverLanguageRuntimeModule}.
+ */
+@SuppressWarnings("all")
+public abstract class AbstractSolverLanguageRuntimeModule extends DefaultRuntimeModule {
+        protected Properties properties = null;
+        @Override
+        public void configure(Binder binder) {
+                properties = tryBindProperties(binder, "org/eclipse/viatra/solver/language/SolverLanguage.properties");
+                super.configure(binder);
+        }
+        
+        public void configureLanguageName(Binder binder) {
+                binder.bind(String.class).annotatedWith(Names.named(Constants.LANGUAGE_NAME)).toInstance("org.eclipse.viatra.solver.language.SolverLanguage");
+        }
+        
+        public void configureFileExtensions(Binder binder) {
+                if (properties == null || properties.getProperty(Constants.FILE_EXTENSIONS) == null)
+                        binder.bind(String.class).annotatedWith(Names.named(Constants.FILE_EXTENSIONS)).toInstance("vsc");
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2
+        public ClassLoader bindClassLoaderToInstance() {
+                return getClass().getClassLoader();
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2
+        public Class<? extends IGrammarAccess> bindIGrammarAccess() {
+                return SolverLanguageGrammarAccess.class;
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2
+        public Class<? extends ISemanticSequencer> bindISemanticSequencer() {
+                return SolverLanguageSemanticSequencer.class;
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2
+        public Class<? extends ISyntacticSequencer> bindISyntacticSequencer() {
+                return SolverLanguageSyntacticSequencer.class;
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2
+        public Class<? extends ISerializer> bindISerializer() {
+                return Serializer.class;
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+        public Class<? extends IParser> bindIParser() {
+                return SolverLanguageParser.class;
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+        public Class<? extends ITokenToStringConverter> bindITokenToStringConverter() {
+                return AntlrTokenToStringConverter.class;
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+        public Class<? extends IAntlrTokenFileProvider> bindIAntlrTokenFileProvider() {
+                return SolverLanguageAntlrTokenFileProvider.class;
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+        public Class<? extends Lexer> bindLexer() {
+                return InternalSolverLanguageLexer.class;
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+        public Class<? extends ITokenDefProvider> bindITokenDefProvider() {
+                return AntlrTokenDefProvider.class;
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+        public Provider<? extends InternalSolverLanguageLexer> provideInternalSolverLanguageLexer() {
+                return LexerProvider.create(InternalSolverLanguageLexer.class);
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+        public void configureRuntimeLexer(Binder binder) {
+                binder.bind(Lexer.class)
+                        .annotatedWith(Names.named(LexerBindings.RUNTIME))
+                        .to(InternalSolverLanguageLexer.class);
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2
+        @SingletonBinding(eager=true)
+        public Class<? extends SolverLanguageValidator> bindSolverLanguageValidator() {
+                return SolverLanguageValidator.class;
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2
+        public Class<? extends ConfigurableIssueCodesProvider> bindConfigurableIssueCodesProvider() {
+                return SolverLanguageConfigurableIssueCodesProvider.class;
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2
+        public Class<? extends IScopeProvider> bindIScopeProvider() {
+                return SolverLanguageScopeProvider.class;
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2
+        public void configureIScopeProviderDelegate(Binder binder) {
+                binder.bind(IScopeProvider.class).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(ImportedNamespaceAwareLocalScopeProvider.class);
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2
+        public Class<? extends IGlobalScopeProvider> bindIGlobalScopeProvider() {
+                return DefaultGlobalScopeProvider.class;
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2
+        public void configureIgnoreCaseLinking(Binder binder) {
+                binder.bindConstant().annotatedWith(IgnoreCaseLinking.class).to(false);
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.exporting.QualifiedNamesFragment2
+        public Class<? extends IQualifiedNameProvider> bindIQualifiedNameProvider() {
+                return DefaultDeclarativeQualifiedNameProvider.class;
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+        public Class<? extends IContainer.Manager> bindIContainer$Manager() {
+                return StateBasedContainerManager.class;
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+        public Class<? extends IAllContainersState.Provider> bindIAllContainersState$Provider() {
+                return ResourceSetBasedAllContainersStateProvider.class;
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+        public void configureIResourceDescriptions(Binder binder) {
+                binder.bind(IResourceDescriptions.class).to(ResourceSetBasedResourceDescriptions.class);
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+        public void configureIResourceDescriptionsPersisted(Binder binder) {
+                binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.PERSISTED_DESCRIPTIONS)).to(ResourceSetBasedResourceDescriptions.class);
+        }
+        
+        // contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2
+        public Class<? extends IGenerator2> bindIGenerator2() {
+                return SolverLanguageGenerator.class;
+        }
+        
+}
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguage.xtextbin b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguage.xtextbin
new file mode 100644
index 00000000..20f3e983
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguage.xtextbin
Binary files differ
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguageStandaloneSetupGenerated.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguageStandaloneSetupGenerated.java
new file mode 100644
index 00000000..91347850
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguageStandaloneSetupGenerated.java
@@ -0,0 +1,42 @@
+/*
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.xtext.ISetup;
+import org.eclipse.xtext.common.TerminalsStandaloneSetup;
+import org.eclipse.xtext.resource.IResourceFactory;
+import org.eclipse.xtext.resource.IResourceServiceProvider;
+@SuppressWarnings("all")
+public class SolverLanguageStandaloneSetupGenerated implements ISetup {
+        @Override
+        public Injector createInjectorAndDoEMFRegistration() {
+                TerminalsStandaloneSetup.doSetup();
+                Injector injector = createInjector();
+                register(injector);
+                return injector;
+        }
+        
+        public Injector createInjector() {
+                return Guice.createInjector(new SolverLanguageRuntimeModule());
+        }
+        
+        public void register(Injector injector) {
+                if (!EPackage.Registry.INSTANCE.containsKey("http://www.eclipse.org/viatra/solver/language/SolverLanguage")) {
+                        EPackage.Registry.INSTANCE.put("http://www.eclipse.org/viatra/solver/language/SolverLanguage", SolverLanguagePackage.eINSTANCE);
+                }
+                IResourceFactory resourceFactory = injector.getInstance(IResourceFactory.class);
+                IResourceServiceProvider serviceProvider = injector.getInstance(IResourceServiceProvider.class);
+                
+                Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("vsc", resourceFactory);
+                IResourceServiceProvider.Registry.INSTANCE.getExtensionToFactoryMap().put("vsc", serviceProvider);
+        }
+}
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageAntlrTokenFileProvider.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageAntlrTokenFileProvider.java
new file mode 100644
index 00000000..059473c8
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageAntlrTokenFileProvider.java
@@ -0,0 +1,16 @@
+/*
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.parser.antlr;
+import java.io.InputStream;
+import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider;
+public class SolverLanguageAntlrTokenFileProvider implements IAntlrTokenFileProvider {
+        @Override
+        public InputStream getAntlrTokenFile() {
+                ClassLoader classLoader = getClass().getClassLoader();
+                return classLoader.getResourceAsStream("org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens");
+        }
+}
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageParser.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageParser.java
new file mode 100644
index 00000000..7155770e
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageParser.java
@@ -0,0 +1,40 @@
+/*
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.parser.antlr;
+import com.google.inject.Inject;
+import org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageParser;
+import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
+import org.eclipse.xtext.parser.antlr.AbstractAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+public class SolverLanguageParser extends AbstractAntlrParser {
+        @Inject
+        private SolverLanguageGrammarAccess grammarAccess;
+        @Override
+        protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
+                tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
+        }
+        
+        @Override
+        protected InternalSolverLanguageParser createParser(XtextTokenStream stream) {
+                return new InternalSolverLanguageParser(stream, getGrammarAccess());
+        }
+        @Override 
+        protected String getDefaultRuleName() {
+                return "Problem";
+        }
+        public SolverLanguageGrammarAccess getGrammarAccess() {
+                return this.grammarAccess;
+        }
+        public void setGrammarAccess(SolverLanguageGrammarAccess grammarAccess) {
+                this.grammarAccess = grammarAccess;
+        }
+}
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g
new file mode 100644
index 00000000..afd73c2d
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g
@@ -0,0 +1,2575 @@
+/*
+ * generated by Xtext 2.18.0.M3
+ */
+grammar InternalSolverLanguage;
+options {
+        superClass=AbstractInternalAntlrParser;
+}
+@lexer::header {
+package org.eclipse.viatra.solver.language.parser.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.parser.antlr.Lexer;
+}
+@parser::header {
+package org.eclipse.viatra.solver.language.parser.antlr.internal;
+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.AbstractInternalAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
+import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
+}
+@parser::members {
+        private SolverLanguageGrammarAccess grammarAccess;
+    public InternalSolverLanguageParser(TokenStream input, SolverLanguageGrammarAccess grammarAccess) {
+        this(input);
+        this.grammarAccess = grammarAccess;
+        registerRules(grammarAccess.getGrammar());
+    }
+    @Override
+    protected String getFirstRuleName() {
+        return "Problem";
+        }
+        @Override
+        protected SolverLanguageGrammarAccess getGrammarAccess() {
+                return grammarAccess;
+        }
+}
+@rulecatch {
+    catch (RecognitionException re) {
+        recover(input,re);
+        appendSkippedTokens();
+    }
+}
+// Entry rule entryRuleProblem
+entryRuleProblem returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getProblemRule()); }
+        iv_ruleProblem=ruleProblem
+        { $current=$iv_ruleProblem.current; }
+        EOF;
+// Rule Problem
+ruleProblem returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        {
+                                newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0());
+                        }
+                        lv_statements_0_0=ruleStatement
+                        {
+                                if ($current==null) {
+                                        $current = createModelElementForParent(grammarAccess.getProblemRule());
+                                }
+                                add(
+                                        $current,
+                                        "statements",
+                                        lv_statements_0_0,
+                                        "org.eclipse.viatra.solver.language.SolverLanguage.Statement");
+                                afterParserOrEnumRuleCall();
+                        }
+                )
+        )*
+;
+// Entry rule entryRuleStatement
+entryRuleStatement returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getStatementRule()); }
+        iv_ruleStatement=ruleStatement
+        { $current=$iv_ruleStatement.current; }
+        EOF;
+// Rule Statement
+ruleStatement returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                {
+                        newCompositeNode(grammarAccess.getStatementAccess().getInterpretationParserRuleCall_0());
+                }
+                this_Interpretation_0=ruleInterpretation
+                {
+                        $current = $this_Interpretation_0.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getStatementAccess().getPredicateParserRuleCall_1());
+                }
+                this_Predicate_1=rulePredicate
+                {
+                        $current = $this_Predicate_1.current;
+                        afterParserOrEnumRuleCall();
+                }
+        )
+;
+// Entry rule entryRuleREALLiteral
+entryRuleREALLiteral returns [String current=null]:
+        { newCompositeNode(grammarAccess.getREALLiteralRule()); }
+        iv_ruleREALLiteral=ruleREALLiteral
+        { $current=$iv_ruleREALLiteral.current.getText(); }
+        EOF;
+// Rule REALLiteral
+ruleREALLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        kw='-'
+                        {
+                                $current.merge(kw);
+                                newLeafNode(kw, grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0());
+                        }
+                )?
+                this_INT_1=RULE_INT
+                {
+                        $current.merge(this_INT_1);
+                }
+                {
+                        newLeafNode(this_INT_1, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1());
+                }
+                kw='.'
+                {
+                        $current.merge(kw);
+                        newLeafNode(kw, grammarAccess.getREALLiteralAccess().getFullStopKeyword_2());
+                }
+                this_INT_3=RULE_INT
+                {
+                        $current.merge(this_INT_3);
+                }
+                {
+                        newLeafNode(this_INT_3, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3());
+                }
+        )
+;
+// Entry rule entryRuleINTLiteral
+entryRuleINTLiteral returns [String current=null]:
+        { newCompositeNode(grammarAccess.getINTLiteralRule()); }
+        iv_ruleINTLiteral=ruleINTLiteral
+        { $current=$iv_ruleINTLiteral.current.getText(); }
+        EOF;
+// Rule INTLiteral
+ruleINTLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        kw='-'
+                        {
+                                $current.merge(kw);
+                                newLeafNode(kw, grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0());
+                        }
+                )?
+                this_INT_1=RULE_INT
+                {
+                        $current.merge(this_INT_1);
+                }
+                {
+                        newLeafNode(this_INT_1, grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1());
+                }
+        )
+;
+// Entry rule entryRuleBooleanValue
+entryRuleBooleanValue returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getBooleanValueRule()); }
+        iv_ruleBooleanValue=ruleBooleanValue
+        { $current=$iv_ruleBooleanValue.current; }
+        EOF;
+// Rule BooleanValue
+ruleBooleanValue returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        (
+                                {
+                                        $current = forceCreateModelElement(
+                                                grammarAccess.getBooleanValueAccess().getBooleanTrueAction_0_0(),
+                                                $current);
+                                }
+                        )
+                        otherlv_1='true'
+                        {
+                                newLeafNode(otherlv_1, grammarAccess.getBooleanValueAccess().getTrueKeyword_0_1());
+                        }
+                )
+                    |
+                (
+                        otherlv_2='false'
+                        {
+                                newLeafNode(otherlv_2, grammarAccess.getBooleanValueAccess().getFalseKeyword_1_0());
+                        }
+                        (
+                                {
+                                        $current = forceCreateModelElement(
+                                                grammarAccess.getBooleanValueAccess().getBooleanFalseAction_1_1(),
+                                                $current);
+                                }
+                        )
+                )
+        )
+;
+// Entry rule entryRuleTruthValue
+entryRuleTruthValue returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getTruthValueRule()); }
+        iv_ruleTruthValue=ruleTruthValue
+        { $current=$iv_ruleTruthValue.current; }
+        EOF;
+// Rule TruthValue
+ruleTruthValue returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        (
+                                {
+                                        $current = forceCreateModelElement(
+                                                grammarAccess.getTruthValueAccess().getTrueAction_0_0(),
+                                                $current);
+                                }
+                        )
+                        otherlv_1='true'
+                        {
+                                newLeafNode(otherlv_1, grammarAccess.getTruthValueAccess().getTrueKeyword_0_1());
+                        }
+                )
+                    |
+                (
+                        (
+                                {
+                                        $current = forceCreateModelElement(
+                                                grammarAccess.getTruthValueAccess().getFalseAction_1_0(),
+                                                $current);
+                                }
+                        )
+                        otherlv_3='false'
+                        {
+                                newLeafNode(otherlv_3, grammarAccess.getTruthValueAccess().getFalseKeyword_1_1());
+                        }
+                )
+                    |
+                (
+                        (
+                                {
+                                        $current = forceCreateModelElement(
+                                                grammarAccess.getTruthValueAccess().getUnknownAction_2_0(),
+                                                $current);
+                                }
+                        )
+                        otherlv_5='unknown'
+                        {
+                                newLeafNode(otherlv_5, grammarAccess.getTruthValueAccess().getUnknownKeyword_2_1());
+                        }
+                )
+                    |
+                (
+                        (
+                                {
+                                        $current = forceCreateModelElement(
+                                                grammarAccess.getTruthValueAccess().getErrorAction_3_0(),
+                                                $current);
+                                }
+                        )
+                        otherlv_7='error'
+                        {
+                                newLeafNode(otherlv_7, grammarAccess.getTruthValueAccess().getErrorKeyword_3_1());
+                        }
+                )
+        )
+;
+// Entry rule entryRuleInterpretation
+entryRuleInterpretation returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getInterpretationRule()); }
+        iv_ruleInterpretation=ruleInterpretation
+        { $current=$iv_ruleInterpretation.current; }
+        EOF;
+// Rule Interpretation
+ruleInterpretation returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                {
+                        newCompositeNode(grammarAccess.getInterpretationAccess().getBasicInterpretationParserRuleCall_0());
+                }
+                this_BasicInterpretation_0=ruleBasicInterpretation
+                {
+                        $current = $this_BasicInterpretation_0.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getInterpretationAccess().getDefaultInterpretationParserRuleCall_1());
+                }
+                this_DefaultInterpretation_1=ruleDefaultInterpretation
+                {
+                        $current = $this_DefaultInterpretation_1.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getInterpretationAccess().getCDInterpretationParserRuleCall_2());
+                }
+                this_CDInterpretation_2=ruleCDInterpretation
+                {
+                        $current = $this_CDInterpretation_2.current;
+                        afterParserOrEnumRuleCall();
+                }
+        )
+;
+// Entry rule entryRuleBasicInterpretation
+entryRuleBasicInterpretation returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getBasicInterpretationRule()); }
+        iv_ruleBasicInterpretation=ruleBasicInterpretation
+        { $current=$iv_ruleBasicInterpretation.current; }
+        EOF;
+// Rule BasicInterpretation
+ruleBasicInterpretation returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getBasicInterpretationAccess().getSymbolSymbolParserRuleCall_0_0());
+                                }
+                                lv_symbol_0_0=ruleSymbol
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getBasicInterpretationRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "symbol",
+                                                lv_symbol_0_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )
+                otherlv_1='('
+                {
+                        newLeafNode(otherlv_1, grammarAccess.getBasicInterpretationAccess().getLeftParenthesisKeyword_1());
+                }
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_2_0());
+                                }
+                                lv_objects_2_0=ruleComplexObject
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getBasicInterpretationRule());
+                                        }
+                                        add(
+                                                $current,
+                                                "objects",
+                                                lv_objects_2_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.ComplexObject");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )*
+                otherlv_3=')'
+                {
+                        newLeafNode(otherlv_3, grammarAccess.getBasicInterpretationAccess().getRightParenthesisKeyword_3());
+                }
+                otherlv_4=':'
+                {
+                        newLeafNode(otherlv_4, grammarAccess.getBasicInterpretationAccess().getColonKeyword_4());
+                }
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getBasicInterpretationAccess().getValueTruthValueParserRuleCall_5_0());
+                                }
+                                lv_value_5_0=ruleTruthValue
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getBasicInterpretationRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "value",
+                                                lv_value_5_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.TruthValue");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )
+        )
+;
+// Entry rule entryRuleSymbol
+entryRuleSymbol returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getSymbolRule()); }
+        iv_ruleSymbol=ruleSymbol
+        { $current=$iv_ruleSymbol.current; }
+        EOF;
+// Rule Symbol
+ruleSymbol returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                {
+                        newCompositeNode(grammarAccess.getSymbolAccess().getModelSymbolParserRuleCall_0());
+                }
+                this_ModelSymbol_0=ruleModelSymbol
+                {
+                        $current = $this_ModelSymbol_0.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getSymbolAccess().getPartialitySymbolParserRuleCall_1());
+                }
+                this_PartialitySymbol_1=rulePartialitySymbol
+                {
+                        $current = $this_PartialitySymbol_1.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getSymbolAccess().getDataSymbolParserRuleCall_2());
+                }
+                this_DataSymbol_2=ruleDataSymbol
+                {
+                        $current = $this_DataSymbol_2.current;
+                        afterParserOrEnumRuleCall();
+                }
+        )
+;
+// Entry rule entryRuleModelSymbol
+entryRuleModelSymbol returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getModelSymbolRule()); }
+        iv_ruleModelSymbol=ruleModelSymbol
+        { $current=$iv_ruleModelSymbol.current; }
+        EOF;
+// Rule ModelSymbol
+ruleModelSymbol returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        lv_name_0_0=RULE_ID
+                        {
+                                newLeafNode(lv_name_0_0, grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0());
+                        }
+                        {
+                                if ($current==null) {
+                                        $current = createModelElement(grammarAccess.getModelSymbolRule());
+                                }
+                                setWithLastConsumed(
+                                        $current,
+                                        "name",
+                                        lv_name_0_0,
+                                        "org.eclipse.xtext.common.Terminals.ID");
+                        }
+                )
+        )
+;
+// Entry rule entryRulePartialitySymbol
+entryRulePartialitySymbol returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getPartialitySymbolRule()); }
+        iv_rulePartialitySymbol=rulePartialitySymbol
+        { $current=$iv_rulePartialitySymbol.current; }
+        EOF;
+// Rule PartialitySymbol
+rulePartialitySymbol returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                {
+                        newCompositeNode(grammarAccess.getPartialitySymbolAccess().getExistSymbolParserRuleCall_0());
+                }
+                this_ExistSymbol_0=ruleExistSymbol
+                {
+                        $current = $this_ExistSymbol_0.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getPartialitySymbolAccess().getEqualsSymbolParserRuleCall_1());
+                }
+                this_EqualsSymbol_1=ruleEqualsSymbol
+                {
+                        $current = $this_EqualsSymbol_1.current;
+                        afterParserOrEnumRuleCall();
+                }
+        )
+;
+// Entry rule entryRuleExistSymbol
+entryRuleExistSymbol returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getExistSymbolRule()); }
+        iv_ruleExistSymbol=ruleExistSymbol
+        { $current=$iv_ruleExistSymbol.current; }
+        EOF;
+// Rule ExistSymbol
+ruleExistSymbol returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                otherlv_0='exists'
+                {
+                        newLeafNode(otherlv_0, grammarAccess.getExistSymbolAccess().getExistsKeyword_0());
+                }
+                (
+                        {
+                                $current = forceCreateModelElement(
+                                        grammarAccess.getExistSymbolAccess().getExistSymbolAction_1(),
+                                        $current);
+                        }
+                )
+        )
+;
+// Entry rule entryRuleEqualsSymbol
+entryRuleEqualsSymbol returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getEqualsSymbolRule()); }
+        iv_ruleEqualsSymbol=ruleEqualsSymbol
+        { $current=$iv_ruleEqualsSymbol.current; }
+        EOF;
+// Rule EqualsSymbol
+ruleEqualsSymbol returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                otherlv_0='equals'
+                {
+                        newLeafNode(otherlv_0, grammarAccess.getEqualsSymbolAccess().getEqualsKeyword_0());
+                }
+                (
+                        {
+                                $current = forceCreateModelElement(
+                                        grammarAccess.getEqualsSymbolAccess().getEqualsSymbolAction_1(),
+                                        $current);
+                        }
+                )
+        )
+;
+// Entry rule entryRuleDataSymbol
+entryRuleDataSymbol returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getDataSymbolRule()); }
+        iv_ruleDataSymbol=ruleDataSymbol
+        { $current=$iv_ruleDataSymbol.current; }
+        EOF;
+// Rule DataSymbol
+ruleDataSymbol returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                {
+                        newCompositeNode(grammarAccess.getDataSymbolAccess().getBooleanSymbolParserRuleCall_0());
+                }
+                this_BooleanSymbol_0=ruleBooleanSymbol
+                {
+                        $current = $this_BooleanSymbol_0.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getDataSymbolAccess().getIntegerSymbolParserRuleCall_1());
+                }
+                this_IntegerSymbol_1=ruleIntegerSymbol
+                {
+                        $current = $this_IntegerSymbol_1.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getDataSymbolAccess().getRealSymbolParserRuleCall_2());
+                }
+                this_RealSymbol_2=ruleRealSymbol
+                {
+                        $current = $this_RealSymbol_2.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getDataSymbolAccess().getStringSymbolParserRuleCall_3());
+                }
+                this_StringSymbol_3=ruleStringSymbol
+                {
+                        $current = $this_StringSymbol_3.current;
+                        afterParserOrEnumRuleCall();
+                }
+        )
+;
+// Entry rule entryRuleBooleanSymbol
+entryRuleBooleanSymbol returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getBooleanSymbolRule()); }
+        iv_ruleBooleanSymbol=ruleBooleanSymbol
+        { $current=$iv_ruleBooleanSymbol.current; }
+        EOF;
+// Rule BooleanSymbol
+ruleBooleanSymbol returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                otherlv_0='bool'
+                {
+                        newLeafNode(otherlv_0, grammarAccess.getBooleanSymbolAccess().getBoolKeyword_0());
+                }
+                (
+                        {
+                                $current = forceCreateModelElement(
+                                        grammarAccess.getBooleanSymbolAccess().getBooleanSymbolAction_1(),
+                                        $current);
+                        }
+                )
+        )
+;
+// Entry rule entryRuleIntegerSymbol
+entryRuleIntegerSymbol returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getIntegerSymbolRule()); }
+        iv_ruleIntegerSymbol=ruleIntegerSymbol
+        { $current=$iv_ruleIntegerSymbol.current; }
+        EOF;
+// Rule IntegerSymbol
+ruleIntegerSymbol returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                otherlv_0='int'
+                {
+                        newLeafNode(otherlv_0, grammarAccess.getIntegerSymbolAccess().getIntKeyword_0());
+                }
+                (
+                        {
+                                $current = forceCreateModelElement(
+                                        grammarAccess.getIntegerSymbolAccess().getIntegerSymbolAction_1(),
+                                        $current);
+                        }
+                )
+        )
+;
+// Entry rule entryRuleRealSymbol
+entryRuleRealSymbol returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getRealSymbolRule()); }
+        iv_ruleRealSymbol=ruleRealSymbol
+        { $current=$iv_ruleRealSymbol.current; }
+        EOF;
+// Rule RealSymbol
+ruleRealSymbol returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                otherlv_0='real'
+                {
+                        newLeafNode(otherlv_0, grammarAccess.getRealSymbolAccess().getRealKeyword_0());
+                }
+                (
+                        {
+                                $current = forceCreateModelElement(
+                                        grammarAccess.getRealSymbolAccess().getRealSymbolAction_1(),
+                                        $current);
+                        }
+                )
+        )
+;
+// Entry rule entryRuleStringSymbol
+entryRuleStringSymbol returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getStringSymbolRule()); }
+        iv_ruleStringSymbol=ruleStringSymbol
+        { $current=$iv_ruleStringSymbol.current; }
+        EOF;
+// Rule StringSymbol
+ruleStringSymbol returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                otherlv_0='string'
+                {
+                        newLeafNode(otherlv_0, grammarAccess.getStringSymbolAccess().getStringKeyword_0());
+                }
+                (
+                        {
+                                $current = forceCreateModelElement(
+                                        grammarAccess.getStringSymbolAccess().getStringSymbolAction_1(),
+                                        $current);
+                        }
+                )
+        )
+;
+// Entry rule entryRuleComplexObject
+entryRuleComplexObject returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getComplexObjectRule()); }
+        iv_ruleComplexObject=ruleComplexObject
+        { $current=$iv_ruleComplexObject.current; }
+        EOF;
+// Rule ComplexObject
+ruleComplexObject returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                {
+                        newCompositeNode(grammarAccess.getComplexObjectAccess().getObjectParserRuleCall_0());
+                }
+                this_Object_0=ruleObject
+                {
+                        $current = $this_Object_0.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getComplexObjectAccess().getAllInstancesParserRuleCall_1());
+                }
+                this_AllInstances_1=ruleAllInstances
+                {
+                        $current = $this_AllInstances_1.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getComplexObjectAccess().getAllObjectsParserRuleCall_2());
+                }
+                this_AllObjects_2=ruleAllObjects
+                {
+                        $current = $this_AllObjects_2.current;
+                        afterParserOrEnumRuleCall();
+                }
+        )
+;
+// Entry rule entryRuleObject
+entryRuleObject returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getObjectRule()); }
+        iv_ruleObject=ruleObject
+        { $current=$iv_ruleObject.current; }
+        EOF;
+// Rule Object
+ruleObject returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                {
+                        newCompositeNode(grammarAccess.getObjectAccess().getNamedObjectParserRuleCall_0());
+                }
+                this_NamedObject_0=ruleNamedObject
+                {
+                        $current = $this_NamedObject_0.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getObjectAccess().getUnnamedObjectParserRuleCall_1());
+                }
+                this_UnnamedObject_1=ruleUnnamedObject
+                {
+                        $current = $this_UnnamedObject_1.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getObjectAccess().getDataObjectParserRuleCall_2());
+                }
+                this_DataObject_2=ruleDataObject
+                {
+                        $current = $this_DataObject_2.current;
+                        afterParserOrEnumRuleCall();
+                }
+        )
+;
+// Entry rule entryRuleNamedObject
+entryRuleNamedObject returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getNamedObjectRule()); }
+        iv_ruleNamedObject=ruleNamedObject
+        { $current=$iv_ruleNamedObject.current; }
+        EOF;
+// Rule NamedObject
+ruleNamedObject returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                otherlv_0='\''
+                {
+                        newLeafNode(otherlv_0, grammarAccess.getNamedObjectAccess().getApostropheKeyword_0());
+                }
+                (
+                        (
+                                lv_name_1_0=RULE_ID
+                                {
+                                        newLeafNode(lv_name_1_0, grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0());
+                                }
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElement(grammarAccess.getNamedObjectRule());
+                                        }
+                                        setWithLastConsumed(
+                                                $current,
+                                                "name",
+                                                lv_name_1_0,
+                                                "org.eclipse.xtext.common.Terminals.ID");
+                                }
+                        )
+                )
+                otherlv_2='\''
+                {
+                        newLeafNode(otherlv_2, grammarAccess.getNamedObjectAccess().getApostropheKeyword_2());
+                }
+        )
+;
+// Entry rule entryRuleUnnamedObject
+entryRuleUnnamedObject returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getUnnamedObjectRule()); }
+        iv_ruleUnnamedObject=ruleUnnamedObject
+        { $current=$iv_ruleUnnamedObject.current; }
+        EOF;
+// Rule UnnamedObject
+ruleUnnamedObject returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        lv_name_0_0=RULE_ID
+                        {
+                                newLeafNode(lv_name_0_0, grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0());
+                        }
+                        {
+                                if ($current==null) {
+                                        $current = createModelElement(grammarAccess.getUnnamedObjectRule());
+                                }
+                                setWithLastConsumed(
+                                        $current,
+                                        "name",
+                                        lv_name_0_0,
+                                        "org.eclipse.xtext.common.Terminals.ID");
+                        }
+                )
+        )
+;
+// Entry rule entryRuleDataObject
+entryRuleDataObject returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getDataObjectRule()); }
+        iv_ruleDataObject=ruleDataObject
+        { $current=$iv_ruleDataObject.current; }
+        EOF;
+// Rule DataObject
+ruleDataObject returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                {
+                        newCompositeNode(grammarAccess.getDataObjectAccess().getBooleanObjectParserRuleCall_0());
+                }
+                this_BooleanObject_0=ruleBooleanObject
+                {
+                        $current = $this_BooleanObject_0.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getDataObjectAccess().getIntObjectParserRuleCall_1());
+                }
+                this_IntObject_1=ruleIntObject
+                {
+                        $current = $this_IntObject_1.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getDataObjectAccess().getRealObjectParserRuleCall_2());
+                }
+                this_RealObject_2=ruleRealObject
+                {
+                        $current = $this_RealObject_2.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getDataObjectAccess().getStringObjectParserRuleCall_3());
+                }
+                this_StringObject_3=ruleStringObject
+                {
+                        $current = $this_StringObject_3.current;
+                        afterParserOrEnumRuleCall();
+                }
+        )
+;
+// Entry rule entryRuleBooleanObject
+entryRuleBooleanObject returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getBooleanObjectRule()); }
+        iv_ruleBooleanObject=ruleBooleanObject
+        { $current=$iv_ruleBooleanObject.current; }
+        EOF;
+// Rule BooleanObject
+ruleBooleanObject returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        {
+                                newCompositeNode(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0());
+                        }
+                        lv_value_0_0=ruleBooleanValue
+                        {
+                                if ($current==null) {
+                                        $current = createModelElementForParent(grammarAccess.getBooleanObjectRule());
+                                }
+                                set(
+                                        $current,
+                                        "value",
+                                        lv_value_0_0,
+                                        "org.eclipse.viatra.solver.language.SolverLanguage.BooleanValue");
+                                afterParserOrEnumRuleCall();
+                        }
+                )
+        )
+;
+// Entry rule entryRuleIntObject
+entryRuleIntObject returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getIntObjectRule()); }
+        iv_ruleIntObject=ruleIntObject
+        { $current=$iv_ruleIntObject.current; }
+        EOF;
+// Rule IntObject
+ruleIntObject returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        {
+                                newCompositeNode(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0());
+                        }
+                        lv_value_0_0=ruleINTLiteral
+                        {
+                                if ($current==null) {
+                                        $current = createModelElementForParent(grammarAccess.getIntObjectRule());
+                                }
+                                set(
+                                        $current,
+                                        "value",
+                                        lv_value_0_0,
+                                        "org.eclipse.viatra.solver.language.SolverLanguage.INTLiteral");
+                                afterParserOrEnumRuleCall();
+                        }
+                )
+        )
+;
+// Entry rule entryRuleRealObject
+entryRuleRealObject returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getRealObjectRule()); }
+        iv_ruleRealObject=ruleRealObject
+        { $current=$iv_ruleRealObject.current; }
+        EOF;
+// Rule RealObject
+ruleRealObject returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        {
+                                newCompositeNode(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0());
+                        }
+                        lv_value_0_0=ruleREALLiteral
+                        {
+                                if ($current==null) {
+                                        $current = createModelElementForParent(grammarAccess.getRealObjectRule());
+                                }
+                                set(
+                                        $current,
+                                        "value",
+                                        lv_value_0_0,
+                                        "org.eclipse.viatra.solver.language.SolverLanguage.REALLiteral");
+                                afterParserOrEnumRuleCall();
+                        }
+                )
+        )
+;
+// Entry rule entryRuleStringObject
+entryRuleStringObject returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getStringObjectRule()); }
+        iv_ruleStringObject=ruleStringObject
+        { $current=$iv_ruleStringObject.current; }
+        EOF;
+// Rule StringObject
+ruleStringObject returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        lv_value_0_0=RULE_STRING
+                        {
+                                newLeafNode(lv_value_0_0, grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0());
+                        }
+                        {
+                                if ($current==null) {
+                                        $current = createModelElement(grammarAccess.getStringObjectRule());
+                                }
+                                setWithLastConsumed(
+                                        $current,
+                                        "value",
+                                        lv_value_0_0,
+                                        "org.eclipse.viatra.solver.language.SolverLanguage.STRING");
+                        }
+                )
+        )
+;
+// Entry rule entryRulePredicate
+entryRulePredicate returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getPredicateRule()); }
+        iv_rulePredicate=rulePredicate
+        { $current=$iv_rulePredicate.current; }
+        EOF;
+// Rule Predicate
+rulePredicate returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                {
+                        newCompositeNode(grammarAccess.getPredicateAccess().getPredicateSymbolParserRuleCall_0());
+                }
+                this_PredicateSymbol_0=rulePredicateSymbol
+                {
+                        $current = $this_PredicateSymbol_0.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getPredicateAccess().getErrorPredicateParserRuleCall_1());
+                }
+                this_ErrorPredicate_1=ruleErrorPredicate
+                {
+                        $current = $this_ErrorPredicate_1.current;
+                        afterParserOrEnumRuleCall();
+                }
+        )
+;
+// Entry rule entryRulePredicateSymbol
+entryRulePredicateSymbol returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getPredicateSymbolRule()); }
+        iv_rulePredicateSymbol=rulePredicateSymbol
+        { $current=$iv_rulePredicateSymbol.current; }
+        EOF;
+// Rule PredicateSymbol
+rulePredicateSymbol returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                otherlv_0='predicate'
+                {
+                        newLeafNode(otherlv_0, grammarAccess.getPredicateSymbolAccess().getPredicateKeyword_0());
+                }
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getPredicateSymbolAccess().getSymbolModelSymbolParserRuleCall_1_0());
+                                }
+                                lv_symbol_1_0=ruleModelSymbol
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getPredicateSymbolRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "symbol",
+                                                lv_symbol_1_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )
+                otherlv_2='('
+                {
+                        newLeafNode(otherlv_2, grammarAccess.getPredicateSymbolAccess().getLeftParenthesisKeyword_2());
+                }
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getPredicateSymbolAccess().getParametersParameterParserRuleCall_3_0());
+                                }
+                                lv_parameters_3_0=ruleParameter
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getPredicateSymbolRule());
+                                        }
+                                        add(
+                                                $current,
+                                                "parameters",
+                                                lv_parameters_3_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.Parameter");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )*
+                otherlv_4=')'
+                {
+                        newLeafNode(otherlv_4, grammarAccess.getPredicateSymbolAccess().getRightParenthesisKeyword_4());
+                }
+                otherlv_5=':'
+                {
+                        newLeafNode(otherlv_5, grammarAccess.getPredicateSymbolAccess().getColonKeyword_5());
+                }
+                (
+                        otherlv_6='false'
+                        {
+                                newLeafNode(otherlv_6, grammarAccess.getPredicateSymbolAccess().getFalseKeyword_6_0());
+                        }
+                            |
+                        (
+                                (
+                                        (
+                                                {
+                                                        newCompositeNode(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_0_0());
+                                                }
+                                                lv_bodies_7_0=rulePatternBody
+                                                {
+                                                        if ($current==null) {
+                                                                $current = createModelElementForParent(grammarAccess.getPredicateSymbolRule());
+                                                        }
+                                                        add(
+                                                                $current,
+                                                                "bodies",
+                                                                lv_bodies_7_0,
+                                                                "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody");
+                                                        afterParserOrEnumRuleCall();
+                                                }
+                                        )
+                                )
+                                (
+                                        otherlv_8='|'
+                                        {
+                                                newLeafNode(otherlv_8, grammarAccess.getPredicateSymbolAccess().getVerticalLineKeyword_6_1_1_0());
+                                        }
+                                        (
+                                                (
+                                                        {
+                                                                newCompositeNode(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_1_1_0());
+                                                        }
+                                                        lv_bodies_9_0=rulePatternBody
+                                                        {
+                                                                if ($current==null) {
+                                                                        $current = createModelElementForParent(grammarAccess.getPredicateSymbolRule());
+                                                                }
+                                                                add(
+                                                                        $current,
+                                                                        "bodies",
+                                                                        lv_bodies_9_0,
+                                                                        "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody");
+                                                                afterParserOrEnumRuleCall();
+                                                        }
+                                                )
+                                        )
+                                )*
+                        )
+                )
+                otherlv_10='.'
+                {
+                        newLeafNode(otherlv_10, grammarAccess.getPredicateSymbolAccess().getFullStopKeyword_7());
+                }
+        )
+;
+// Entry rule entryRuleErrorPredicate
+entryRuleErrorPredicate returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getErrorPredicateRule()); }
+        iv_ruleErrorPredicate=ruleErrorPredicate
+        { $current=$iv_ruleErrorPredicate.current; }
+        EOF;
+// Rule ErrorPredicate
+ruleErrorPredicate returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        {
+                                $current = forceCreateModelElement(
+                                        grammarAccess.getErrorPredicateAccess().getErrorPredicateAction_0(),
+                                        $current);
+                        }
+                )
+                otherlv_1='error'
+                {
+                        newLeafNode(otherlv_1, grammarAccess.getErrorPredicateAccess().getErrorKeyword_1());
+                }
+                (
+                        (
+                                lv_name_2_0=RULE_ID
+                                {
+                                        newLeafNode(lv_name_2_0, grammarAccess.getErrorPredicateAccess().getNameIDTerminalRuleCall_2_0());
+                                }
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElement(grammarAccess.getErrorPredicateRule());
+                                        }
+                                        setWithLastConsumed(
+                                                $current,
+                                                "name",
+                                                lv_name_2_0,
+                                                "org.eclipse.xtext.common.Terminals.ID");
+                                }
+                        )
+                )?
+                (
+                        otherlv_3='('
+                        {
+                                newLeafNode(otherlv_3, grammarAccess.getErrorPredicateAccess().getLeftParenthesisKeyword_3_0());
+                        }
+                        (
+                                (
+                                        {
+                                                newCompositeNode(grammarAccess.getErrorPredicateAccess().getParametersParameterParserRuleCall_3_1_0());
+                                        }
+                                        lv_parameters_4_0=ruleParameter
+                                        {
+                                                if ($current==null) {
+                                                        $current = createModelElementForParent(grammarAccess.getErrorPredicateRule());
+                                                }
+                                                add(
+                                                        $current,
+                                                        "parameters",
+                                                        lv_parameters_4_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.Parameter");
+                                                afterParserOrEnumRuleCall();
+                                        }
+                                )
+                        )*
+                        otherlv_5=')'
+                        {
+                                newLeafNode(otherlv_5, grammarAccess.getErrorPredicateAccess().getRightParenthesisKeyword_3_2());
+                        }
+                )
+                otherlv_6=':'
+                {
+                        newLeafNode(otherlv_6, grammarAccess.getErrorPredicateAccess().getColonKeyword_4());
+                }
+                (
+                        otherlv_7='false'
+                        {
+                                newLeafNode(otherlv_7, grammarAccess.getErrorPredicateAccess().getFalseKeyword_5_0());
+                        }
+                            |
+                        (
+                                (
+                                        (
+                                                {
+                                                        newCompositeNode(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_0_0());
+                                                }
+                                                lv_bodies_8_0=rulePatternBody
+                                                {
+                                                        if ($current==null) {
+                                                                $current = createModelElementForParent(grammarAccess.getErrorPredicateRule());
+                                                        }
+                                                        add(
+                                                                $current,
+                                                                "bodies",
+                                                                lv_bodies_8_0,
+                                                                "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody");
+                                                        afterParserOrEnumRuleCall();
+                                                }
+                                        )
+                                )
+                                (
+                                        otherlv_9='|'
+                                        {
+                                                newLeafNode(otherlv_9, grammarAccess.getErrorPredicateAccess().getVerticalLineKeyword_5_1_1_0());
+                                        }
+                                        (
+                                                (
+                                                        {
+                                                                newCompositeNode(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_1_1_0());
+                                                        }
+                                                        lv_bodies_10_0=rulePatternBody
+                                                        {
+                                                                if ($current==null) {
+                                                                        $current = createModelElementForParent(grammarAccess.getErrorPredicateRule());
+                                                                }
+                                                                add(
+                                                                        $current,
+                                                                        "bodies",
+                                                                        lv_bodies_10_0,
+                                                                        "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody");
+                                                                afterParserOrEnumRuleCall();
+                                                        }
+                                                )
+                                        )
+                                )*
+                        )
+                )
+                otherlv_11='.'
+                {
+                        newLeafNode(otherlv_11, grammarAccess.getErrorPredicateAccess().getFullStopKeyword_6());
+                }
+        )
+;
+// Entry rule entryRuleParameter
+entryRuleParameter returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getParameterRule()); }
+        iv_ruleParameter=ruleParameter
+        { $current=$iv_ruleParameter.current; }
+        EOF;
+// Rule Parameter
+ruleParameter returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getParameterAccess().getVariableVariableParserRuleCall_0_0());
+                                }
+                                lv_variable_0_0=ruleVariable
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getParameterRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "variable",
+                                                lv_variable_0_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.Variable");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )
+                (
+                        otherlv_1=':'
+                        {
+                                newLeafNode(otherlv_1, grammarAccess.getParameterAccess().getColonKeyword_1_0());
+                        }
+                        (
+                                (
+                                        {
+                                                newCompositeNode(grammarAccess.getParameterAccess().getTypeSymbolParserRuleCall_1_1_0());
+                                        }
+                                        lv_type_2_0=ruleSymbol
+                                        {
+                                                if ($current==null) {
+                                                        $current = createModelElementForParent(grammarAccess.getParameterRule());
+                                                }
+                                                set(
+                                                        $current,
+                                                        "type",
+                                                        lv_type_2_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
+                                                afterParserOrEnumRuleCall();
+                                        }
+                                )
+                        )
+                )?
+        )
+;
+// Entry rule entryRulePatternBody
+entryRulePatternBody returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getPatternBodyRule()); }
+        iv_rulePatternBody=rulePatternBody
+        { $current=$iv_rulePatternBody.current; }
+        EOF;
+// Rule PatternBody
+rulePatternBody returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        {
+                                $current = forceCreateModelElement(
+                                        grammarAccess.getPatternBodyAccess().getPatternBodyAction_0(),
+                                        $current);
+                        }
+                )
+                (
+                        otherlv_1='true'
+                        {
+                                newLeafNode(otherlv_1, grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0());
+                        }
+                            |
+                        (
+                                (
+                                        {
+                                                newCompositeNode(grammarAccess.getPatternBodyAccess().getConstraintsConstraintParserRuleCall_1_1_0());
+                                        }
+                                        lv_constraints_2_0=ruleConstraint
+                                        {
+                                                if ($current==null) {
+                                                        $current = createModelElementForParent(grammarAccess.getPatternBodyRule());
+                                                }
+                                                add(
+                                                        $current,
+                                                        "constraints",
+                                                        lv_constraints_2_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.Constraint");
+                                                afterParserOrEnumRuleCall();
+                                        }
+                                )
+                        )*
+                )
+        )
+;
+// Entry rule entryRulePolarity
+entryRulePolarity returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getPolarityRule()); }
+        iv_rulePolarity=rulePolarity
+        { $current=$iv_rulePolarity.current; }
+        EOF;
+// Rule Polarity
+rulePolarity returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        (
+                                {
+                                        $current = forceCreateModelElement(
+                                                grammarAccess.getPolarityAccess().getPositiveAction_0_0(),
+                                                $current);
+                                }
+                        )
+                        otherlv_1='+'
+                        {
+                                newLeafNode(otherlv_1, grammarAccess.getPolarityAccess().getPlusSignKeyword_0_1());
+                        }
+                )
+                    |
+                (
+                        (
+                                {
+                                        $current = forceCreateModelElement(
+                                                grammarAccess.getPolarityAccess().getNegativeAction_1_0(),
+                                                $current);
+                                }
+                        )
+                        otherlv_3='-'
+                        {
+                                newLeafNode(otherlv_3, grammarAccess.getPolarityAccess().getHyphenMinusKeyword_1_1());
+                        }
+                )
+        )
+;
+// Entry rule entryRuleConstraint
+entryRuleConstraint returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getConstraintRule()); }
+        iv_ruleConstraint=ruleConstraint
+        { $current=$iv_ruleConstraint.current; }
+        EOF;
+// Rule Constraint
+ruleConstraint returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getConstraintAccess().getPolarityPolarityParserRuleCall_0_0());
+                                }
+                                lv_polarity_0_0=rulePolarity
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getConstraintRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "polarity",
+                                                lv_polarity_0_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.Polarity");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )?
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getConstraintAccess().getSymbolModelSymbolParserRuleCall_1_0());
+                                }
+                                lv_symbol_1_0=ruleModelSymbol
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getConstraintRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "symbol",
+                                                lv_symbol_1_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )
+                (
+                        (
+                                otherlv_2='('
+                                {
+                                        newLeafNode(otherlv_2, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_0_0());
+                                }
+                                (
+                                        (
+                                                {
+                                                        newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_0_1_0());
+                                                }
+                                                lv_params_3_0=ruleLiteral
+                                                {
+                                                        if ($current==null) {
+                                                                $current = createModelElementForParent(grammarAccess.getConstraintRule());
+                                                        }
+                                                        add(
+                                                                $current,
+                                                                "params",
+                                                                lv_params_3_0,
+                                                                "org.eclipse.viatra.solver.language.SolverLanguage.Literal");
+                                                        afterParserOrEnumRuleCall();
+                                                }
+                                        )
+                                )*
+                                otherlv_4=')'
+                                {
+                                        newLeafNode(otherlv_4, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_0_2());
+                                }
+                        )
+                            |
+                        (
+                                (
+                                        (
+                                                {
+                                                        newCompositeNode(grammarAccess.getConstraintAccess().getClosureTypeClosureTypeParserRuleCall_2_1_0_0());
+                                                }
+                                                lv_closureType_5_0=ruleClosureType
+                                                {
+                                                        if ($current==null) {
+                                                                $current = createModelElementForParent(grammarAccess.getConstraintRule());
+                                                        }
+                                                        set(
+                                                                $current,
+                                                                "closureType",
+                                                                lv_closureType_5_0,
+                                                                "org.eclipse.viatra.solver.language.SolverLanguage.ClosureType");
+                                                        afterParserOrEnumRuleCall();
+                                                }
+                                        )
+                                )
+                                otherlv_6='('
+                                {
+                                        newLeafNode(otherlv_6, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_1_1());
+                                }
+                                (
+                                        (
+                                                {
+                                                        newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_2_0());
+                                                }
+                                                lv_params_7_0=ruleLiteral
+                                                {
+                                                        if ($current==null) {
+                                                                $current = createModelElementForParent(grammarAccess.getConstraintRule());
+                                                        }
+                                                        add(
+                                                                $current,
+                                                                "params",
+                                                                lv_params_7_0,
+                                                                "org.eclipse.viatra.solver.language.SolverLanguage.Literal");
+                                                        afterParserOrEnumRuleCall();
+                                                }
+                                        )
+                                )
+                                (
+                                        (
+                                                {
+                                                        newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_3_0());
+                                                }
+                                                lv_params_8_0=ruleLiteral
+                                                {
+                                                        if ($current==null) {
+                                                                $current = createModelElementForParent(grammarAccess.getConstraintRule());
+                                                        }
+                                                        add(
+                                                                $current,
+                                                                "params",
+                                                                lv_params_8_0,
+                                                                "org.eclipse.viatra.solver.language.SolverLanguage.Literal");
+                                                        afterParserOrEnumRuleCall();
+                                                }
+                                        )
+                                )
+                                otherlv_9=')'
+                                {
+                                        newLeafNode(otherlv_9, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_1_4());
+                                }
+                        )
+                )
+        )
+;
+// Entry rule entryRuleClosureType
+entryRuleClosureType returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getClosureTypeRule()); }
+        iv_ruleClosureType=ruleClosureType
+        { $current=$iv_ruleClosureType.current; }
+        EOF;
+// Rule ClosureType
+ruleClosureType returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        (
+                                {
+                                        $current = forceCreateModelElement(
+                                                grammarAccess.getClosureTypeAccess().getReflexiveClosureAction_0_0(),
+                                                $current);
+                                }
+                        )
+                        otherlv_1='*'
+                        {
+                                newLeafNode(otherlv_1, grammarAccess.getClosureTypeAccess().getAsteriskKeyword_0_1());
+                        }
+                )
+                    |
+                (
+                        (
+                                {
+                                        $current = forceCreateModelElement(
+                                                grammarAccess.getClosureTypeAccess().getIrreflexiveClosureAction_1_0(),
+                                                $current);
+                                }
+                        )
+                        otherlv_3='+'
+                        {
+                                newLeafNode(otherlv_3, grammarAccess.getClosureTypeAccess().getPlusSignKeyword_1_1());
+                        }
+                )
+        )
+;
+// Entry rule entryRuleLiteral
+entryRuleLiteral returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getLiteralRule()); }
+        iv_ruleLiteral=ruleLiteral
+        { $current=$iv_ruleLiteral.current; }
+        EOF;
+// Rule Literal
+ruleLiteral returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                {
+                        newCompositeNode(grammarAccess.getLiteralAccess().getVariableParserRuleCall_0());
+                }
+                this_Variable_0=ruleVariable
+                {
+                        $current = $this_Variable_0.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getLiteralAccess().getDataObjectParserRuleCall_1());
+                }
+                this_DataObject_1=ruleDataObject
+                {
+                        $current = $this_DataObject_1.current;
+                        afterParserOrEnumRuleCall();
+                }
+        )
+;
+// Entry rule entryRuleVariable
+entryRuleVariable returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getVariableRule()); }
+        iv_ruleVariable=ruleVariable
+        { $current=$iv_ruleVariable.current; }
+        EOF;
+// Rule Variable
+ruleVariable returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        lv_name_0_0=RULE_ID
+                        {
+                                newLeafNode(lv_name_0_0, grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0());
+                        }
+                        {
+                                if ($current==null) {
+                                        $current = createModelElement(grammarAccess.getVariableRule());
+                                }
+                                setWithLastConsumed(
+                                        $current,
+                                        "name",
+                                        lv_name_0_0,
+                                        "org.eclipse.xtext.common.Terminals.ID");
+                        }
+                )
+        )
+;
+// Entry rule entryRuleAllInstances
+entryRuleAllInstances returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getAllInstancesRule()); }
+        iv_ruleAllInstances=ruleAllInstances
+        { $current=$iv_ruleAllInstances.current; }
+        EOF;
+// Rule AllInstances
+ruleAllInstances returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                otherlv_0=':'
+                {
+                        newLeafNode(otherlv_0, grammarAccess.getAllInstancesAccess().getColonKeyword_0());
+                }
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0());
+                                }
+                                lv_symbol_1_0=ruleSymbol
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getAllInstancesRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "symbol",
+                                                lv_symbol_1_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )
+        )
+;
+// Entry rule entryRuleAllObjects
+entryRuleAllObjects returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getAllObjectsRule()); }
+        iv_ruleAllObjects=ruleAllObjects
+        { $current=$iv_ruleAllObjects.current; }
+        EOF;
+// Rule AllObjects
+ruleAllObjects returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        {
+                                $current = forceCreateModelElement(
+                                        grammarAccess.getAllObjectsAccess().getAllObjectsAction_0(),
+                                        $current);
+                        }
+                )
+                otherlv_1='*'
+                {
+                        newLeafNode(otherlv_1, grammarAccess.getAllObjectsAccess().getAsteriskKeyword_1());
+                }
+        )
+;
+// Entry rule entryRuleDefaultInterpretation
+entryRuleDefaultInterpretation returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getDefaultInterpretationRule()); }
+        iv_ruleDefaultInterpretation=ruleDefaultInterpretation
+        { $current=$iv_ruleDefaultInterpretation.current; }
+        EOF;
+// Rule DefaultInterpretation
+ruleDefaultInterpretation returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                otherlv_0='default'
+                {
+                        newLeafNode(otherlv_0, grammarAccess.getDefaultInterpretationAccess().getDefaultKeyword_0());
+                }
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0());
+                                }
+                                lv_interpretation_1_0=ruleBasicInterpretation
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getDefaultInterpretationRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "interpretation",
+                                                lv_interpretation_1_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.BasicInterpretation");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )
+        )
+;
+// Entry rule entryRuleCDInterpretation
+entryRuleCDInterpretation returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getCDInterpretationRule()); }
+        iv_ruleCDInterpretation=ruleCDInterpretation
+        { $current=$iv_ruleCDInterpretation.current; }
+        EOF;
+// Rule CDInterpretation
+ruleCDInterpretation returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                {
+                        newCompositeNode(grammarAccess.getCDInterpretationAccess().getClassInterpretationParserRuleCall_0());
+                }
+                this_ClassInterpretation_0=ruleClassInterpretation
+                {
+                        $current = $this_ClassInterpretation_0.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getCDInterpretationAccess().getEnumInterpretationParserRuleCall_1());
+                }
+                this_EnumInterpretation_1=ruleEnumInterpretation
+                {
+                        $current = $this_EnumInterpretation_1.current;
+                        afterParserOrEnumRuleCall();
+                }
+                    |
+                {
+                        newCompositeNode(grammarAccess.getCDInterpretationAccess().getGlobalRelationInterpretationParserRuleCall_2());
+                }
+                this_GlobalRelationInterpretation_2=ruleGlobalRelationInterpretation
+                {
+                        $current = $this_GlobalRelationInterpretation_2.current;
+                        afterParserOrEnumRuleCall();
+                }
+        )
+;
+// Entry rule entryRuleClassInterpretation
+entryRuleClassInterpretation returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getClassInterpretationRule()); }
+        iv_ruleClassInterpretation=ruleClassInterpretation
+        { $current=$iv_ruleClassInterpretation.current; }
+        EOF;
+// Rule ClassInterpretation
+ruleClassInterpretation returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        (
+                                lv_abstract_0_0='abstract'
+                                {
+                                        newLeafNode(lv_abstract_0_0, grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0());
+                                }
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElement(grammarAccess.getClassInterpretationRule());
+                                        }
+                                        setWithLastConsumed($current, "abstract", true, "abstract");
+                                }
+                        )
+                )
+                otherlv_1='class'
+                {
+                        newLeafNode(otherlv_1, grammarAccess.getClassInterpretationAccess().getClassKeyword_1());
+                }
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getClassInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0());
+                                }
+                                lv_symbol_2_0=ruleModelSymbol
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getClassInterpretationRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "symbol",
+                                                lv_symbol_2_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )
+                (
+                        otherlv_3='extends'
+                        {
+                                newLeafNode(otherlv_3, grammarAccess.getClassInterpretationAccess().getExtendsKeyword_3_0());
+                        }
+                        (
+                                (
+                                        {
+                                                newCompositeNode(grammarAccess.getClassInterpretationAccess().getSupertypesModelSymbolParserRuleCall_3_1_0());
+                                        }
+                                        lv_supertypes_4_0=ruleModelSymbol
+                                        {
+                                                if ($current==null) {
+                                                        $current = createModelElementForParent(grammarAccess.getClassInterpretationRule());
+                                                }
+                                                add(
+                                                        $current,
+                                                        "supertypes",
+                                                        lv_supertypes_4_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
+                                                afterParserOrEnumRuleCall();
+                                        }
+                                )
+                        )+
+                )?
+                otherlv_5='{'
+                {
+                        newLeafNode(otherlv_5, grammarAccess.getClassInterpretationAccess().getLeftCurlyBracketKeyword_4());
+                }
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getClassInterpretationAccess().getFieltFieldRelationInterpretationParserRuleCall_5_0());
+                                }
+                                lv_fielt_6_0=ruleFieldRelationInterpretation
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getClassInterpretationRule());
+                                        }
+                                        add(
+                                                $current,
+                                                "fielt",
+                                                lv_fielt_6_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.FieldRelationInterpretation");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )*
+                otherlv_7='}'
+                {
+                        newLeafNode(otherlv_7, grammarAccess.getClassInterpretationAccess().getRightCurlyBracketKeyword_6());
+                }
+        )
+;
+// Entry rule entryRuleEnumInterpretation
+entryRuleEnumInterpretation returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getEnumInterpretationRule()); }
+        iv_ruleEnumInterpretation=ruleEnumInterpretation
+        { $current=$iv_ruleEnumInterpretation.current; }
+        EOF;
+// Rule EnumInterpretation
+ruleEnumInterpretation returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                otherlv_0='enum'
+                {
+                        newLeafNode(otherlv_0, grammarAccess.getEnumInterpretationAccess().getEnumKeyword_0());
+                }
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getEnumInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0());
+                                }
+                                lv_Symbol_1_0=ruleModelSymbol
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getEnumInterpretationRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "Symbol",
+                                                lv_Symbol_1_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )
+                otherlv_2='{'
+                {
+                        newLeafNode(otherlv_2, grammarAccess.getEnumInterpretationAccess().getLeftCurlyBracketKeyword_2());
+                }
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getEnumInterpretationAccess().getObjectsNamedObjectParserRuleCall_3_0());
+                                }
+                                lv_objects_3_0=ruleNamedObject
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getEnumInterpretationRule());
+                                        }
+                                        add(
+                                                $current,
+                                                "objects",
+                                                lv_objects_3_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.NamedObject");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )+
+                otherlv_4='}'
+                {
+                        newLeafNode(otherlv_4, grammarAccess.getEnumInterpretationAccess().getRightCurlyBracketKeyword_4());
+                }
+        )
+;
+// Entry rule entryRuleFieldRelationInterpretation
+entryRuleFieldRelationInterpretation returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getFieldRelationInterpretationRule()); }
+        iv_ruleFieldRelationInterpretation=ruleFieldRelationInterpretation
+        { $current=$iv_ruleFieldRelationInterpretation.current; }
+        EOF;
+// Rule FieldRelationInterpretation
+ruleFieldRelationInterpretation returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        (
+                                lv_containment_0_0='containment'
+                                {
+                                        newLeafNode(lv_containment_0_0, grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0());
+                                }
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElement(grammarAccess.getFieldRelationInterpretationRule());
+                                        }
+                                        setWithLastConsumed($current, "containment", true, "containment");
+                                }
+                        )
+                )
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0());
+                                }
+                                lv_symbol_1_0=ruleModelSymbol
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "symbol",
+                                                lv_symbol_1_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )
+                otherlv_2=':'
+                {
+                        newLeafNode(otherlv_2, grammarAccess.getFieldRelationInterpretationAccess().getColonKeyword_2());
+                }
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityMultiplicityDefinitionParserRuleCall_3_0());
+                                }
+                                lv_multiplicity_3_0=ruleMultiplicityDefinition
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "multiplicity",
+                                                lv_multiplicity_3_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )?
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getTargetSymbolParserRuleCall_4_0());
+                                }
+                                lv_target_4_0=ruleSymbol
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "target",
+                                                lv_target_4_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )
+        )
+;
+// Entry rule entryRuleGlobalRelationInterpretation
+entryRuleGlobalRelationInterpretation returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getGlobalRelationInterpretationRule()); }
+        iv_ruleGlobalRelationInterpretation=ruleGlobalRelationInterpretation
+        { $current=$iv_ruleGlobalRelationInterpretation.current; }
+        EOF;
+// Rule GlobalRelationInterpretation
+ruleGlobalRelationInterpretation returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        (
+                                lv_containment_0_0='containment'
+                                {
+                                        newLeafNode(lv_containment_0_0, grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0());
+                                }
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElement(grammarAccess.getGlobalRelationInterpretationRule());
+                                        }
+                                        setWithLastConsumed($current, "containment", true, "containment");
+                                }
+                        )
+                )
+                otherlv_1='relation'
+                {
+                        newLeafNode(otherlv_1, grammarAccess.getGlobalRelationInterpretationAccess().getRelationKeyword_1());
+                }
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0());
+                                }
+                                lv_symbol_2_0=ruleModelSymbol
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "symbol",
+                                                lv_symbol_2_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )
+                otherlv_3=':'
+                {
+                        newLeafNode(otherlv_3, grammarAccess.getGlobalRelationInterpretationAccess().getColonKeyword_3());
+                }
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0());
+                                }
+                                lv_sourceMultiplicity_4_0=ruleMultiplicityDefinition
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "sourceMultiplicity",
+                                                lv_sourceMultiplicity_4_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )?
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceSymbolParserRuleCall_5_0());
+                                }
+                                lv_source_5_0=ruleSymbol
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "source",
+                                                lv_source_5_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0());
+                                }
+                                lv_targetMultiplicity_6_0=ruleMultiplicityDefinition
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "targetMultiplicity",
+                                                lv_targetMultiplicity_6_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )?
+                (
+                        (
+                                {
+                                        newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetSymbolParserRuleCall_7_0());
+                                }
+                                lv_target_7_0=ruleSymbol
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule());
+                                        }
+                                        set(
+                                                $current,
+                                                "target",
+                                                lv_target_7_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
+                                        afterParserOrEnumRuleCall();
+                                }
+                        )
+                )
+        )
+;
+// Entry rule entryRuleMultiplicityDefinition
+entryRuleMultiplicityDefinition returns [EObject current=null]:
+        { newCompositeNode(grammarAccess.getMultiplicityDefinitionRule()); }
+        iv_ruleMultiplicityDefinition=ruleMultiplicityDefinition
+        { $current=$iv_ruleMultiplicityDefinition.current; }
+        EOF;
+// Rule MultiplicityDefinition
+ruleMultiplicityDefinition returns [EObject current=null]
+@init {
+        enterRule();
+}
+@after {
+        leaveRule();
+}:
+        (
+                (
+                        (
+                                lv_lower_0_0=RULE_INT
+                                {
+                                        newLeafNode(lv_lower_0_0, grammarAccess.getMultiplicityDefinitionAccess().getLowerINTTerminalRuleCall_0_0());
+                                }
+                                {
+                                        if ($current==null) {
+                                                $current = createModelElement(grammarAccess.getMultiplicityDefinitionRule());
+                                        }
+                                        setWithLastConsumed(
+                                                $current,
+                                                "lower",
+                                                lv_lower_0_0,
+                                                "org.eclipse.xtext.common.Terminals.INT");
+                                }
+                        )
+                )
+                otherlv_1='..'
+                {
+                        newLeafNode(otherlv_1, grammarAccess.getMultiplicityDefinitionAccess().getFullStopFullStopKeyword_1());
+                }
+                (
+                        (
+                                (
+                                        lv_upper_2_0=RULE_INT
+                                        {
+                                                newLeafNode(lv_upper_2_0, grammarAccess.getMultiplicityDefinitionAccess().getUpperINTTerminalRuleCall_2_0_0());
+                                        }
+                                        {
+                                                if ($current==null) {
+                                                        $current = createModelElement(grammarAccess.getMultiplicityDefinitionRule());
+                                                }
+                                                setWithLastConsumed(
+                                                        $current,
+                                                        "upper",
+                                                        lv_upper_2_0,
+                                                        "org.eclipse.xtext.common.Terminals.INT");
+                                        }
+                                )
+                        )
+                            |
+                        (
+                                (
+                                        lv_unlimitedUpper_3_0='*'
+                                        {
+                                                newLeafNode(lv_unlimitedUpper_3_0, grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0());
+                                        }
+                                        {
+                                                if ($current==null) {
+                                                        $current = createModelElement(grammarAccess.getMultiplicityDefinitionRule());
+                                                }
+                                                setWithLastConsumed($current, "unlimitedUpper", true, "*");
+                                        }
+                                )
+                        )
+                )
+        )
+;
+RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"';
+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/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens
new file mode 100644
index 00000000..1abe7de4
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens
@@ -0,0 +1,67 @@
+'('=17
+')'=18
+'*'=30
+'+'=29
+'-'=11
+'.'=12
+'..'=40
+':'=19
+'\''=26
+'abstract'=32
+'bool'=22
+'class'=33
+'containment'=38
+'default'=31
+'enum'=37
+'equals'=21
+'error'=16
+'exists'=20
+'extends'=34
+'false'=14
+'int'=23
+'predicate'=27
+'real'=24
+'relation'=39
+'string'=25
+'true'=13
+'unknown'=15
+'{'=35
+'|'=28
+'}'=36
+RULE_ANY_OTHER=10
+RULE_ID=5
+RULE_INT=4
+RULE_ML_COMMENT=7
+RULE_SL_COMMENT=8
+RULE_STRING=6
+RULE_WS=9
+T__11=11
+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
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageLexer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageLexer.java
new file mode 100644
index 00000000..f8cb627c
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageLexer.java
@@ -0,0 +1,1669 @@
+package org.eclipse.viatra.solver.language.parser.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.parser.antlr.Lexer;
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+@SuppressWarnings("all")
+public class InternalSolverLanguageLexer extends Lexer {
+    public static final int RULE_STRING=6;
+    public static final int RULE_SL_COMMENT=8;
+    public static final int T__19=19;
+    public static final int T__15=15;
+    public static final int T__37=37;
+    public static final int T__16=16;
+    public static final int T__38=38;
+    public static final int T__17=17;
+    public static final int T__39=39;
+    public static final int T__18=18;
+    public static final int T__11=11;
+    public static final int T__33=33;
+    public static final int T__12=12;
+    public static final int T__34=34;
+    public static final int T__13=13;
+    public static final int T__35=35;
+    public static final int T__14=14;
+    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_ID=5;
+    public static final int RULE_WS=9;
+    public static final int RULE_ANY_OTHER=10;
+    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=7;
+    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__40=40;
+    public static final int T__20=20;
+    public static final int T__21=21;
+    // delegates
+    // delegators
+    public InternalSolverLanguageLexer() {;} 
+    public InternalSolverLanguageLexer(CharStream input) {
+        this(input, new RecognizerSharedState());
+    }
+    public InternalSolverLanguageLexer(CharStream input, RecognizerSharedState state) {
+        super(input,state);
+    }
+    public String getGrammarFileName() { return "InternalSolverLanguage.g"; }
+    // $ANTLR start "T__11"
+    public final void mT__11() throws RecognitionException {
+        try {
+            int _type = T__11;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // InternalSolverLanguage.g:11:7: ( '-' )
+            // InternalSolverLanguage.g:11:9: '-'
+            {
+            match('-'); 
+            }
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__11"
+    // $ANTLR start "T__12"
+    public final void mT__12() throws RecognitionException {
+        try {
+            int _type = T__12;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // InternalSolverLanguage.g:12:7: ( '.' )
+            // InternalSolverLanguage.g:12: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;
+            // InternalSolverLanguage.g:13:7: ( 'true' )
+            // InternalSolverLanguage.g:13:9: 'true'
+            {
+            match("true"); 
+            }
+            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;
+            // InternalSolverLanguage.g:14:7: ( 'false' )
+            // InternalSolverLanguage.g:14:9: 'false'
+            {
+            match("false"); 
+            }
+            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;
+            // InternalSolverLanguage.g:15:7: ( 'unknown' )
+            // InternalSolverLanguage.g:15:9: 'unknown'
+            {
+            match("unknown"); 
+            }
+            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;
+            // InternalSolverLanguage.g:16:7: ( 'error' )
+            // InternalSolverLanguage.g:16:9: 'error'
+            {
+            match("error"); 
+            }
+            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;
+            // InternalSolverLanguage.g:17:7: ( '(' )
+            // InternalSolverLanguage.g:17: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;
+            // InternalSolverLanguage.g:18:7: ( ')' )
+            // InternalSolverLanguage.g:18: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;
+            // InternalSolverLanguage.g:19:7: ( ':' )
+            // InternalSolverLanguage.g:19:9: ':'
+            {
+            match(':'); 
+            }
+            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;
+            // InternalSolverLanguage.g:20:7: ( 'exists' )
+            // InternalSolverLanguage.g:20:9: 'exists'
+            {
+            match("exists"); 
+            }
+            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;
+            // InternalSolverLanguage.g:21:7: ( 'equals' )
+            // InternalSolverLanguage.g:21:9: 'equals'
+            {
+            match("equals"); 
+            }
+            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;
+            // InternalSolverLanguage.g:22:7: ( 'bool' )
+            // InternalSolverLanguage.g:22:9: 'bool'
+            {
+            match("bool"); 
+            }
+            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;
+            // InternalSolverLanguage.g:23:7: ( 'int' )
+            // InternalSolverLanguage.g:23:9: 'int'
+            {
+            match("int"); 
+            }
+            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;
+            // InternalSolverLanguage.g:24:7: ( 'real' )
+            // InternalSolverLanguage.g:24:9: 'real'
+            {
+            match("real"); 
+            }
+            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;
+            // InternalSolverLanguage.g:25:7: ( 'string' )
+            // InternalSolverLanguage.g:25:9: 'string'
+            {
+            match("string"); 
+            }
+            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;
+            // InternalSolverLanguage.g:26:7: ( '\\'' )
+            // InternalSolverLanguage.g:26:9: '\\''
+            {
+            match('\''); 
+            }
+            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;
+            // InternalSolverLanguage.g:27:7: ( 'predicate' )
+            // InternalSolverLanguage.g:27:9: 'predicate'
+            {
+            match("predicate"); 
+            }
+            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;
+            // InternalSolverLanguage.g:28:7: ( '|' )
+            // InternalSolverLanguage.g:28: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;
+            // InternalSolverLanguage.g:29:7: ( '+' )
+            // InternalSolverLanguage.g:29:9: '+'
+            {
+            match('+'); 
+            }
+            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;
+            // InternalSolverLanguage.g:30:7: ( '*' )
+            // InternalSolverLanguage.g:30: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;
+            // InternalSolverLanguage.g:31:7: ( 'default' )
+            // InternalSolverLanguage.g:31:9: 'default'
+            {
+            match("default"); 
+            }
+            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;
+            // InternalSolverLanguage.g:32:7: ( 'abstract' )
+            // InternalSolverLanguage.g:32:9: 'abstract'
+            {
+            match("abstract"); 
+            }
+            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;
+            // InternalSolverLanguage.g:33:7: ( 'class' )
+            // InternalSolverLanguage.g:33:9: 'class'
+            {
+            match("class"); 
+            }
+            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;
+            // InternalSolverLanguage.g:34:7: ( 'extends' )
+            // InternalSolverLanguage.g:34:9: 'extends'
+            {
+            match("extends"); 
+            }
+            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;
+            // InternalSolverLanguage.g:35:7: ( '{' )
+            // InternalSolverLanguage.g:35: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;
+            // InternalSolverLanguage.g:36:7: ( '}' )
+            // InternalSolverLanguage.g:36: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;
+            // InternalSolverLanguage.g:37:7: ( 'enum' )
+            // InternalSolverLanguage.g:37:9: 'enum'
+            {
+            match("enum"); 
+            }
+            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;
+            // InternalSolverLanguage.g:38:7: ( 'containment' )
+            // InternalSolverLanguage.g:38:9: 'containment'
+            {
+            match("containment"); 
+            }
+            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;
+            // InternalSolverLanguage.g:39:7: ( 'relation' )
+            // InternalSolverLanguage.g:39:9: 'relation'
+            {
+            match("relation"); 
+            }
+            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;
+            // InternalSolverLanguage.g:40:7: ( '..' )
+            // InternalSolverLanguage.g:40:9: '..'
+            {
+            match(".."); 
+            }
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__40"
+    // $ANTLR start "RULE_STRING"
+    public final void mRULE_STRING() throws RecognitionException {
+        try {
+            int _type = RULE_STRING;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // InternalSolverLanguage.g:2563:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' )
+            // InternalSolverLanguage.g:2563:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"'
+            {
+            match('\"'); 
+            // InternalSolverLanguage.g:2563: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 :
+                    // InternalSolverLanguage.g:2563:20: '\\\\' .
+                    {
+                    match('\\'); 
+                    matchAny(); 
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:2563: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_ID"
+    public final void mRULE_ID() throws RecognitionException {
+        try {
+            int _type = RULE_ID;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // InternalSolverLanguage.g:2565:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
+            // InternalSolverLanguage.g:2565:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+            {
+            // InternalSolverLanguage.g:2565:11: ( '^' )?
+            int alt2=2;
+            int LA2_0 = input.LA(1);
+            if ( (LA2_0=='^') ) {
+                alt2=1;
+            }
+            switch (alt2) {
+                case 1 :
+                    // InternalSolverLanguage.g:2565: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;}
+            // InternalSolverLanguage.g:2565:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+            loop3:
+            do {
+                int alt3=2;
+                int LA3_0 = input.LA(1);
+                if ( ((LA3_0>='0' && LA3_0<='9')||(LA3_0>='A' && LA3_0<='Z')||LA3_0=='_'||(LA3_0>='a' && LA3_0<='z')) ) {
+                    alt3=1;
+                }
+                switch (alt3) {
+                case 1 :
+                    // InternalSolverLanguage.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 loop3;
+                }
+            } 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;
+            // InternalSolverLanguage.g:2567:10: ( ( '0' .. '9' )+ )
+            // InternalSolverLanguage.g:2567:12: ( '0' .. '9' )+
+            {
+            // InternalSolverLanguage.g:2567:12: ( '0' .. '9' )+
+            int cnt4=0;
+            loop4:
+            do {
+                int alt4=2;
+                int LA4_0 = input.LA(1);
+                if ( ((LA4_0>='0' && LA4_0<='9')) ) {
+                    alt4=1;
+                }
+                switch (alt4) {
+                case 1 :
+                    // InternalSolverLanguage.g:2567:13: '0' .. '9'
+                    {
+                    matchRange('0','9'); 
+                    }
+                    break;
+                default :
+                    if ( cnt4 >= 1 ) break loop4;
+                        EarlyExitException eee =
+                            new EarlyExitException(4, input);
+                        throw eee;
+                }
+                cnt4++;
+            } 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;
+            // InternalSolverLanguage.g:2569:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
+            // InternalSolverLanguage.g:2569:19: '/*' ( options {greedy=false; } : . )* '*/'
+            {
+            match("/*"); 
+            // InternalSolverLanguage.g:2569:24: ( options {greedy=false; } : . )*
+            loop5:
+            do {
+                int alt5=2;
+                int LA5_0 = input.LA(1);
+                if ( (LA5_0=='*') ) {
+                    int LA5_1 = input.LA(2);
+                    if ( (LA5_1=='/') ) {
+                        alt5=2;
+                    }
+                    else if ( ((LA5_1>='\u0000' && LA5_1<='.')||(LA5_1>='0' && LA5_1<='\uFFFF')) ) {
+                        alt5=1;
+                    }
+                }
+                else if ( ((LA5_0>='\u0000' && LA5_0<=')')||(LA5_0>='+' && LA5_0<='\uFFFF')) ) {
+                    alt5=1;
+                }
+                switch (alt5) {
+                case 1 :
+                    // InternalSolverLanguage.g:2569:52: .
+                    {
+                    matchAny(); 
+                    }
+                    break;
+                default :
+                    break loop5;
+                }
+            } 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;
+            // InternalSolverLanguage.g:2571:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
+            // InternalSolverLanguage.g:2571:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
+            {
+            match("//"); 
+            // InternalSolverLanguage.g:2571:24: (~ ( ( '\\n' | '\\r' ) ) )*
+            loop6:
+            do {
+                int alt6=2;
+                int LA6_0 = input.LA(1);
+                if ( ((LA6_0>='\u0000' && LA6_0<='\t')||(LA6_0>='\u000B' && LA6_0<='\f')||(LA6_0>='\u000E' && LA6_0<='\uFFFF')) ) {
+                    alt6=1;
+                }
+                switch (alt6) {
+                case 1 :
+                    // InternalSolverLanguage.g:2571: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 loop6;
+                }
+            } while (true);
+            // InternalSolverLanguage.g:2571:40: ( ( '\\r' )? '\\n' )?
+            int alt8=2;
+            int LA8_0 = input.LA(1);
+            if ( (LA8_0=='\n'||LA8_0=='\r') ) {
+                alt8=1;
+            }
+            switch (alt8) {
+                case 1 :
+                    // InternalSolverLanguage.g:2571:41: ( '\\r' )? '\\n'
+                    {
+                    // InternalSolverLanguage.g:2571:41: ( '\\r' )?
+                    int alt7=2;
+                    int LA7_0 = input.LA(1);
+                    if ( (LA7_0=='\r') ) {
+                        alt7=1;
+                    }
+                    switch (alt7) {
+                        case 1 :
+                            // InternalSolverLanguage.g:2571: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;
+            // InternalSolverLanguage.g:2573:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
+            // InternalSolverLanguage.g:2573:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+            {
+            // InternalSolverLanguage.g:2573:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+            int cnt9=0;
+            loop9:
+            do {
+                int alt9=2;
+                int LA9_0 = input.LA(1);
+                if ( ((LA9_0>='\t' && LA9_0<='\n')||LA9_0=='\r'||LA9_0==' ') ) {
+                    alt9=1;
+                }
+                switch (alt9) {
+                case 1 :
+                    // InternalSolverLanguage.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 ( cnt9 >= 1 ) break loop9;
+                        EarlyExitException eee =
+                            new EarlyExitException(9, input);
+                        throw eee;
+                }
+                cnt9++;
+            } 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;
+            // InternalSolverLanguage.g:2575:16: ( . )
+            // InternalSolverLanguage.g:2575:18: .
+            {
+            matchAny(); 
+            }
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "RULE_ANY_OTHER"
+    public void mTokens() throws RecognitionException {
+        // InternalSolverLanguage.g:1:8: ( T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | RULE_STRING | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER )
+        int alt10=37;
+        alt10 = dfa10.predict(input);
+        switch (alt10) {
+            case 1 :
+                // InternalSolverLanguage.g:1:10: T__11
+                {
+                mT__11(); 
+                }
+                break;
+            case 2 :
+                // InternalSolverLanguage.g:1:16: T__12
+                {
+                mT__12(); 
+                }
+                break;
+            case 3 :
+                // InternalSolverLanguage.g:1:22: T__13
+                {
+                mT__13(); 
+                }
+                break;
+            case 4 :
+                // InternalSolverLanguage.g:1:28: T__14
+                {
+                mT__14(); 
+                }
+                break;
+            case 5 :
+                // InternalSolverLanguage.g:1:34: T__15
+                {
+                mT__15(); 
+                }
+                break;
+            case 6 :
+                // InternalSolverLanguage.g:1:40: T__16
+                {
+                mT__16(); 
+                }
+                break;
+            case 7 :
+                // InternalSolverLanguage.g:1:46: T__17
+                {
+                mT__17(); 
+                }
+                break;
+            case 8 :
+                // InternalSolverLanguage.g:1:52: T__18
+                {
+                mT__18(); 
+                }
+                break;
+            case 9 :
+                // InternalSolverLanguage.g:1:58: T__19
+                {
+                mT__19(); 
+                }
+                break;
+            case 10 :
+                // InternalSolverLanguage.g:1:64: T__20
+                {
+                mT__20(); 
+                }
+                break;
+            case 11 :
+                // InternalSolverLanguage.g:1:70: T__21
+                {
+                mT__21(); 
+                }
+                break;
+            case 12 :
+                // InternalSolverLanguage.g:1:76: T__22
+                {
+                mT__22(); 
+                }
+                break;
+            case 13 :
+                // InternalSolverLanguage.g:1:82: T__23
+                {
+                mT__23(); 
+                }
+                break;
+            case 14 :
+                // InternalSolverLanguage.g:1:88: T__24
+                {
+                mT__24(); 
+                }
+                break;
+            case 15 :
+                // InternalSolverLanguage.g:1:94: T__25
+                {
+                mT__25(); 
+                }
+                break;
+            case 16 :
+                // InternalSolverLanguage.g:1:100: T__26
+                {
+                mT__26(); 
+                }
+                break;
+            case 17 :
+                // InternalSolverLanguage.g:1:106: T__27
+                {
+                mT__27(); 
+                }
+                break;
+            case 18 :
+                // InternalSolverLanguage.g:1:112: T__28
+                {
+                mT__28(); 
+                }
+                break;
+            case 19 :
+                // InternalSolverLanguage.g:1:118: T__29
+                {
+                mT__29(); 
+                }
+                break;
+            case 20 :
+                // InternalSolverLanguage.g:1:124: T__30
+                {
+                mT__30(); 
+                }
+                break;
+            case 21 :
+                // InternalSolverLanguage.g:1:130: T__31
+                {
+                mT__31(); 
+                }
+                break;
+            case 22 :
+                // InternalSolverLanguage.g:1:136: T__32
+                {
+                mT__32(); 
+                }
+                break;
+            case 23 :
+                // InternalSolverLanguage.g:1:142: T__33
+                {
+                mT__33(); 
+                }
+                break;
+            case 24 :
+                // InternalSolverLanguage.g:1:148: T__34
+                {
+                mT__34(); 
+                }
+                break;
+            case 25 :
+                // InternalSolverLanguage.g:1:154: T__35
+                {
+                mT__35(); 
+                }
+                break;
+            case 26 :
+                // InternalSolverLanguage.g:1:160: T__36
+                {
+                mT__36(); 
+                }
+                break;
+            case 27 :
+                // InternalSolverLanguage.g:1:166: T__37
+                {
+                mT__37(); 
+                }
+                break;
+            case 28 :
+                // InternalSolverLanguage.g:1:172: T__38
+                {
+                mT__38(); 
+                }
+                break;
+            case 29 :
+                // InternalSolverLanguage.g:1:178: T__39
+                {
+                mT__39(); 
+                }
+                break;
+            case 30 :
+                // InternalSolverLanguage.g:1:184: T__40
+                {
+                mT__40(); 
+                }
+                break;
+            case 31 :
+                // InternalSolverLanguage.g:1:190: RULE_STRING
+                {
+                mRULE_STRING(); 
+                }
+                break;
+            case 32 :
+                // InternalSolverLanguage.g:1:202: RULE_ID
+                {
+                mRULE_ID(); 
+                }
+                break;
+            case 33 :
+                // InternalSolverLanguage.g:1:210: RULE_INT
+                {
+                mRULE_INT(); 
+                }
+                break;
+            case 34 :
+                // InternalSolverLanguage.g:1:219: RULE_ML_COMMENT
+                {
+                mRULE_ML_COMMENT(); 
+                }
+                break;
+            case 35 :
+                // InternalSolverLanguage.g:1:235: RULE_SL_COMMENT
+                {
+                mRULE_SL_COMMENT(); 
+                }
+                break;
+            case 36 :
+                // InternalSolverLanguage.g:1:251: RULE_WS
+                {
+                mRULE_WS(); 
+                }
+                break;
+            case 37 :
+                // InternalSolverLanguage.g:1:259: RULE_ANY_OTHER
+                {
+                mRULE_ANY_OTHER(); 
+                }
+                break;
+        }
+    }
+    protected DFA10 dfa10 = new DFA10(this);
+    static final String DFA10_eotS =
+        "\2\uffff\1\41\4\43\3\uffff\4\43\1\uffff\1\43\3\uffff\3\43\2\uffff\2\36\2\uffff\1\36\5\uffff\1\43\1\uffff\6\43\3\uffff\4\43\1\uffff\1\43\3\uffff\4\43\7\uffff\11\43\1\134\10\43\1\145\6\43\1\154\1\155\1\uffff\1\156\7\43\1\uffff\1\166\1\43\1\170\3\43\3\uffff\5\43\1\u0081\1\43\1\uffff\1\43\1\uffff\1\u0084\1\43\1\u0086\1\43\1\u0088\3\43\1\uffff\1\43\1\u008d\1\uffff\1\u008e\1\uffff\1\43\1\uffff\1\43\1\u0091\2\43\2\uffff\1\u0094\1\43\1\uffff\1\u0096\1\43\1\uffff\1\u0098\1\uffff\1\43\1\uffff\1\43\1\u009b\1\uffff";
+    static final String DFA10_eofS =
+        "\u009c\uffff";
+    static final String DFA10_minS =
+        "\1\0\1\uffff\1\56\1\162\1\141\2\156\3\uffff\1\157\1\156\1\145\1\164\1\uffff\1\162\3\uffff\1\145\1\142\1\154\2\uffff\1\0\1\101\2\uffff\1\52\5\uffff\1\165\1\uffff\1\154\1\153\1\162\1\151\2\165\3\uffff\1\157\1\164\1\141\1\162\1\uffff\1\145\3\uffff\1\146\1\163\1\141\1\156\7\uffff\1\145\1\163\1\156\1\157\1\163\1\145\1\141\1\155\1\154\1\60\1\154\1\141\1\151\1\144\1\141\1\164\1\163\1\164\1\60\1\145\1\157\1\162\1\164\1\156\1\154\2\60\1\uffff\1\60\1\164\1\156\1\151\1\165\1\162\1\163\1\141\1\uffff\1\60\1\167\1\60\1\163\1\144\1\163\3\uffff\1\151\1\147\1\143\1\154\1\141\1\60\1\151\1\uffff\1\156\1\uffff\1\60\1\163\1\60\1\157\1\60\1\141\1\164\1\143\1\uffff\1\156\1\60\1\uffff\1\60\1\uffff\1\156\1\uffff\1\164\1\60\1\164\1\155\2\uffff\1\60\1\145\1\uffff\1\60\1\145\1\uffff\1\60\1\uffff\1\156\1\uffff\1\164\1\60\1\uffff";
+    static final String DFA10_maxS =
+        "\1\uffff\1\uffff\1\56\1\162\1\141\1\156\1\170\3\uffff\1\157\1\156\1\145\1\164\1\uffff\1\162\3\uffff\1\145\1\142\1\157\2\uffff\1\uffff\1\172\2\uffff\1\57\5\uffff\1\165\1\uffff\1\154\1\153\1\162\1\164\2\165\3\uffff\1\157\1\164\1\154\1\162\1\uffff\1\145\3\uffff\1\146\1\163\1\141\1\156\7\uffff\1\145\1\163\1\156\1\157\1\163\1\145\1\141\1\155\1\154\1\172\1\154\1\141\1\151\1\144\1\141\1\164\1\163\1\164\1\172\1\145\1\157\1\162\1\164\1\156\1\154\2\172\1\uffff\1\172\1\164\1\156\1\151\1\165\1\162\1\163\1\141\1\uffff\1\172\1\167\1\172\1\163\1\144\1\163\3\uffff\1\151\1\147\1\143\1\154\1\141\1\172\1\151\1\uffff\1\156\1\uffff\1\172\1\163\1\172\1\157\1\172\1\141\1\164\1\143\1\uffff\1\156\1\172\1\uffff\1\172\1\uffff\1\156\1\uffff\1\164\1\172\1\164\1\155\2\uffff\1\172\1\145\1\uffff\1\172\1\145\1\uffff\1\172\1\uffff\1\156\1\uffff\1\164\1\172\1\uffff";
+    static final String DFA10_acceptS =
+        "\1\uffff\1\1\5\uffff\1\7\1\10\1\11\4\uffff\1\20\1\uffff\1\22\1\23\1\24\3\uffff\1\31\1\32\2\uffff\1\40\1\41\1\uffff\1\44\1\45\1\1\1\36\1\2\1\uffff\1\40\6\uffff\1\7\1\10\1\11\4\uffff\1\20\1\uffff\1\22\1\23\1\24\4\uffff\1\31\1\32\1\37\1\41\1\42\1\43\1\44\33\uffff\1\15\10\uffff\1\3\6\uffff\1\33\1\14\1\16\7\uffff\1\4\1\uffff\1\6\10\uffff\1\27\2\uffff\1\12\1\uffff\1\13\1\uffff\1\17\4\uffff\1\5\1\30\2\uffff\1\25\2\uffff\1\35\1\uffff\1\26\1\uffff\1\21\2\uffff\1\34";
+    static final String DFA10_specialS =
+        "\1\1\27\uffff\1\0\u0083\uffff}>";
+    static final String[] DFA10_transitionS = {
+            "\11\36\2\35\2\36\1\35\22\36\1\35\1\36\1\30\4\36\1\16\1\7\1\10\1\22\1\21\1\36\1\1\1\2\1\34\12\33\1\11\6\36\32\32\3\36\1\31\1\32\1\36\1\24\1\12\1\25\1\23\1\6\1\4\2\32\1\13\6\32\1\17\1\32\1\14\1\15\1\3\1\5\5\32\1\26\1\20\1\27\uff82\36",
+            "",
+            "\1\40",
+            "\1\42",
+            "\1\44",
+            "\1\45",
+            "\1\51\2\uffff\1\50\1\46\5\uffff\1\47",
+            "",
+            "",
+            "",
+            "\1\55",
+            "\1\56",
+            "\1\57",
+            "\1\60",
+            "",
+            "\1\62",
+            "",
+            "",
+            "",
+            "\1\66",
+            "\1\67",
+            "\1\70\2\uffff\1\71",
+            "",
+            "",
+            "\0\74",
+            "\32\43\4\uffff\1\43\1\uffff\32\43",
+            "",
+            "",
+            "\1\76\4\uffff\1\77",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "\1\101",
+            "",
+            "\1\102",
+            "\1\103",
+            "\1\104",
+            "\1\105\12\uffff\1\106",
+            "\1\107",
+            "\1\110",
+            "",
+            "",
+            "",
+            "\1\111",
+            "\1\112",
+            "\1\113\12\uffff\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",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            "\1\135",
+            "\1\136",
+            "\1\137",
+            "\1\140",
+            "\1\141",
+            "\1\142",
+            "\1\143",
+            "\1\144",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            "\1\146",
+            "\1\147",
+            "\1\150",
+            "\1\151",
+            "\1\152",
+            "\1\153",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            "",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            "\1\157",
+            "\1\160",
+            "\1\161",
+            "\1\162",
+            "\1\163",
+            "\1\164",
+            "\1\165",
+            "",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            "\1\167",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            "\1\171",
+            "\1\172",
+            "\1\173",
+            "",
+            "",
+            "",
+            "\1\174",
+            "\1\175",
+            "\1\176",
+            "\1\177",
+            "\1\u0080",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            "\1\u0082",
+            "",
+            "\1\u0083",
+            "",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            "\1\u0085",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            "\1\u0087",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            "\1\u0089",
+            "\1\u008a",
+            "\1\u008b",
+            "",
+            "\1\u008c",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            "",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            "",
+            "\1\u008f",
+            "",
+            "\1\u0090",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            "\1\u0092",
+            "\1\u0093",
+            "",
+            "",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            "\1\u0095",
+            "",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            "\1\u0097",
+            "",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            "",
+            "\1\u0099",
+            "",
+            "\1\u009a",
+            "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43",
+            ""
+    };
+    static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS);
+    static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS);
+    static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS);
+    static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS);
+    static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS);
+    static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS);
+    static final short[][] DFA10_transition;
+    static {
+        int numStates = DFA10_transitionS.length;
+        DFA10_transition = new short[numStates][];
+        for (int i=0; i<numStates; i++) {
+            DFA10_transition[i] = DFA.unpackEncodedString(DFA10_transitionS[i]);
+        }
+    }
+    class DFA10 extends DFA {
+        public DFA10(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 10;
+            this.eot = DFA10_eot;
+            this.eof = DFA10_eof;
+            this.min = DFA10_min;
+            this.max = DFA10_max;
+            this.accept = DFA10_accept;
+            this.special = DFA10_special;
+            this.transition = DFA10_transition;
+        }
+        public String getDescription() {
+            return "1:1: Tokens : ( T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | RULE_STRING | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER );";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            IntStream input = _input;
+                int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA10_24 = input.LA(1);
+                        s = -1;
+                        if ( ((LA10_24>='\u0000' && LA10_24<='\uFFFF')) ) {s = 60;}
+                        else s = 30;
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA10_0 = input.LA(1);
+                        s = -1;
+                        if ( (LA10_0=='-') ) {s = 1;}
+                        else if ( (LA10_0=='.') ) {s = 2;}
+                        else if ( (LA10_0=='t') ) {s = 3;}
+                        else if ( (LA10_0=='f') ) {s = 4;}
+                        else if ( (LA10_0=='u') ) {s = 5;}
+                        else if ( (LA10_0=='e') ) {s = 6;}
+                        else if ( (LA10_0=='(') ) {s = 7;}
+                        else if ( (LA10_0==')') ) {s = 8;}
+                        else if ( (LA10_0==':') ) {s = 9;}
+                        else if ( (LA10_0=='b') ) {s = 10;}
+                        else if ( (LA10_0=='i') ) {s = 11;}
+                        else if ( (LA10_0=='r') ) {s = 12;}
+                        else if ( (LA10_0=='s') ) {s = 13;}
+                        else if ( (LA10_0=='\'') ) {s = 14;}
+                        else if ( (LA10_0=='p') ) {s = 15;}
+                        else if ( (LA10_0=='|') ) {s = 16;}
+                        else if ( (LA10_0=='+') ) {s = 17;}
+                        else if ( (LA10_0=='*') ) {s = 18;}
+                        else if ( (LA10_0=='d') ) {s = 19;}
+                        else if ( (LA10_0=='a') ) {s = 20;}
+                        else if ( (LA10_0=='c') ) {s = 21;}
+                        else if ( (LA10_0=='{') ) {s = 22;}
+                        else if ( (LA10_0=='}') ) {s = 23;}
+                        else if ( (LA10_0=='\"') ) {s = 24;}
+                        else if ( (LA10_0=='^') ) {s = 25;}
+                        else if ( ((LA10_0>='A' && LA10_0<='Z')||LA10_0=='_'||(LA10_0>='g' && LA10_0<='h')||(LA10_0>='j' && LA10_0<='o')||LA10_0=='q'||(LA10_0>='v' && LA10_0<='z')) ) {s = 26;}
+                        else if ( ((LA10_0>='0' && LA10_0<='9')) ) {s = 27;}
+                        else if ( (LA10_0=='/') ) {s = 28;}
+                        else if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) {s = 29;}
+                        else if ( ((LA10_0>='\u0000' && LA10_0<='\b')||(LA10_0>='\u000B' && LA10_0<='\f')||(LA10_0>='\u000E' && LA10_0<='\u001F')||LA10_0=='!'||(LA10_0>='#' && LA10_0<='&')||LA10_0==','||(LA10_0>=';' && LA10_0<='@')||(LA10_0>='[' && LA10_0<=']')||LA10_0=='`'||(LA10_0>='~' && LA10_0<='\uFFFF')) ) {s = 30;}
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 10, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+ 
+}
+\ No newline at end of file
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java
new file mode 100644
index 00000000..c1c632f3
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java
@@ -0,0 +1,7214 @@
+package org.eclipse.viatra.solver.language.parser.antlr.internal;
+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.AbstractInternalAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
+import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+@SuppressWarnings("all")
+public class InternalSolverLanguageParser extends AbstractInternalAntlrParser {
+    public static final String[] tokenNames = new String[] {
+        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_INT", "RULE_ID", "RULE_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'-'", "'.'", "'true'", "'false'", "'unknown'", "'error'", "'('", "')'", "':'", "'exists'", "'equals'", "'bool'", "'int'", "'real'", "'string'", "'\\''", "'predicate'", "'|'", "'+'", "'*'", "'default'", "'abstract'", "'class'", "'extends'", "'{'", "'}'", "'enum'", "'containment'", "'relation'", "'..'"
+    };
+    public static final int RULE_STRING=6;
+    public static final int RULE_SL_COMMENT=8;
+    public static final int T__19=19;
+    public static final int T__15=15;
+    public static final int T__37=37;
+    public static final int T__16=16;
+    public static final int T__38=38;
+    public static final int T__17=17;
+    public static final int T__39=39;
+    public static final int T__18=18;
+    public static final int T__11=11;
+    public static final int T__33=33;
+    public static final int T__12=12;
+    public static final int T__34=34;
+    public static final int T__13=13;
+    public static final int T__35=35;
+    public static final int T__14=14;
+    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_ID=5;
+    public static final int RULE_WS=9;
+    public static final int RULE_ANY_OTHER=10;
+    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=7;
+    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__40=40;
+    public static final int T__20=20;
+    public static final int T__21=21;
+    // delegates
+    // delegators
+        public InternalSolverLanguageParser(TokenStream input) {
+            this(input, new RecognizerSharedState());
+        }
+        public InternalSolverLanguageParser(TokenStream input, RecognizerSharedState state) {
+            super(input, state);
+             
+        }
+        
+    public String[] getTokenNames() { return InternalSolverLanguageParser.tokenNames; }
+    public String getGrammarFileName() { return "InternalSolverLanguage.g"; }
+        private SolverLanguageGrammarAccess grammarAccess;
+        public InternalSolverLanguageParser(TokenStream input, SolverLanguageGrammarAccess grammarAccess) {
+            this(input);
+            this.grammarAccess = grammarAccess;
+            registerRules(grammarAccess.getGrammar());
+        }
+        @Override
+        protected String getFirstRuleName() {
+                return "Problem";
+        }
+        @Override
+        protected SolverLanguageGrammarAccess getGrammarAccess() {
+                return grammarAccess;
+        }
+    // $ANTLR start "entryRuleProblem"
+    // InternalSolverLanguage.g:64:1: entryRuleProblem returns [EObject current=null] : iv_ruleProblem= ruleProblem EOF ;
+    public final EObject entryRuleProblem() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleProblem = null;
+        try {
+            // InternalSolverLanguage.g:64:48: (iv_ruleProblem= ruleProblem EOF )
+            // InternalSolverLanguage.g:65:2: iv_ruleProblem= ruleProblem EOF
+            {
+             newCompositeNode(grammarAccess.getProblemRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleProblem=ruleProblem();
+            state._fsp--;
+             current =iv_ruleProblem; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleProblem"
+    // $ANTLR start "ruleProblem"
+    // InternalSolverLanguage.g:71:1: ruleProblem returns [EObject current=null] : ( (lv_statements_0_0= ruleStatement ) )* ;
+    public final EObject ruleProblem() throws RecognitionException {
+        EObject current = null;
+        EObject lv_statements_0_0 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:77:2: ( ( (lv_statements_0_0= ruleStatement ) )* )
+            // InternalSolverLanguage.g:78:2: ( (lv_statements_0_0= ruleStatement ) )*
+            {
+            // InternalSolverLanguage.g:78:2: ( (lv_statements_0_0= ruleStatement ) )*
+            loop1:
+            do {
+                int alt1=2;
+                int LA1_0 = input.LA(1);
+                if ( (LA1_0==RULE_ID||LA1_0==16||(LA1_0>=20 && LA1_0<=25)||LA1_0==27||(LA1_0>=31 && LA1_0<=32)||(LA1_0>=37 && LA1_0<=38)) ) {
+                    alt1=1;
+                }
+                switch (alt1) {
+                case 1 :
+                    // InternalSolverLanguage.g:79:3: (lv_statements_0_0= ruleStatement )
+                    {
+                    // InternalSolverLanguage.g:79:3: (lv_statements_0_0= ruleStatement )
+                    // InternalSolverLanguage.g:80:4: lv_statements_0_0= ruleStatement
+                    {
+                                                newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0());
+                                        
+                    pushFollow(FOLLOW_3);
+                    lv_statements_0_0=ruleStatement();
+                    state._fsp--;
+                                                if (current==null) {
+                                                        current = createModelElementForParent(grammarAccess.getProblemRule());
+                                                }
+                                                add(
+                                                        current,
+                                                        "statements",
+                                                        lv_statements_0_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.Statement");
+                                                afterParserOrEnumRuleCall();
+                                        
+                    }
+                    }
+                    break;
+                default :
+                    break loop1;
+                }
+            } while (true);
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleProblem"
+    // $ANTLR start "entryRuleStatement"
+    // InternalSolverLanguage.g:100:1: entryRuleStatement returns [EObject current=null] : iv_ruleStatement= ruleStatement EOF ;
+    public final EObject entryRuleStatement() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleStatement = null;
+        try {
+            // InternalSolverLanguage.g:100:50: (iv_ruleStatement= ruleStatement EOF )
+            // InternalSolverLanguage.g:101:2: iv_ruleStatement= ruleStatement EOF
+            {
+             newCompositeNode(grammarAccess.getStatementRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleStatement=ruleStatement();
+            state._fsp--;
+             current =iv_ruleStatement; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleStatement"
+    // $ANTLR start "ruleStatement"
+    // InternalSolverLanguage.g:107:1: ruleStatement returns [EObject current=null] : (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate ) ;
+    public final EObject ruleStatement() throws RecognitionException {
+        EObject current = null;
+        EObject this_Interpretation_0 = null;
+        EObject this_Predicate_1 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:113:2: ( (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate ) )
+            // InternalSolverLanguage.g:114:2: (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate )
+            {
+            // InternalSolverLanguage.g:114:2: (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate )
+            int alt2=2;
+            int LA2_0 = input.LA(1);
+            if ( (LA2_0==RULE_ID||(LA2_0>=20 && LA2_0<=25)||(LA2_0>=31 && LA2_0<=32)||(LA2_0>=37 && LA2_0<=38)) ) {
+                alt2=1;
+            }
+            else if ( (LA2_0==16||LA2_0==27) ) {
+                alt2=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 2, 0, input);
+                throw nvae;
+            }
+            switch (alt2) {
+                case 1 :
+                    // InternalSolverLanguage.g:115:3: this_Interpretation_0= ruleInterpretation
+                    {
+                                        newCompositeNode(grammarAccess.getStatementAccess().getInterpretationParserRuleCall_0());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_Interpretation_0=ruleInterpretation();
+                    state._fsp--;
+                                        current = this_Interpretation_0;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:124:3: this_Predicate_1= rulePredicate
+                    {
+                                        newCompositeNode(grammarAccess.getStatementAccess().getPredicateParserRuleCall_1());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_Predicate_1=rulePredicate();
+                    state._fsp--;
+                                        current = this_Predicate_1;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleStatement"
+    // $ANTLR start "entryRuleREALLiteral"
+    // InternalSolverLanguage.g:136:1: entryRuleREALLiteral returns [String current=null] : iv_ruleREALLiteral= ruleREALLiteral EOF ;
+    public final String entryRuleREALLiteral() throws RecognitionException {
+        String current = null;
+        AntlrDatatypeRuleToken iv_ruleREALLiteral = null;
+        try {
+            // InternalSolverLanguage.g:136:51: (iv_ruleREALLiteral= ruleREALLiteral EOF )
+            // InternalSolverLanguage.g:137:2: iv_ruleREALLiteral= ruleREALLiteral EOF
+            {
+             newCompositeNode(grammarAccess.getREALLiteralRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleREALLiteral=ruleREALLiteral();
+            state._fsp--;
+             current =iv_ruleREALLiteral.getText(); 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleREALLiteral"
+    // $ANTLR start "ruleREALLiteral"
+    // InternalSolverLanguage.g:143:1: ruleREALLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT ) ;
+    public final AntlrDatatypeRuleToken ruleREALLiteral() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+        Token kw=null;
+        Token this_INT_1=null;
+        Token this_INT_3=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:149:2: ( ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT ) )
+            // InternalSolverLanguage.g:150:2: ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT )
+            {
+            // InternalSolverLanguage.g:150:2: ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT )
+            // InternalSolverLanguage.g:151:3: (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT
+            {
+            // InternalSolverLanguage.g:151:3: (kw= '-' )?
+            int alt3=2;
+            int LA3_0 = input.LA(1);
+            if ( (LA3_0==11) ) {
+                alt3=1;
+            }
+            switch (alt3) {
+                case 1 :
+                    // InternalSolverLanguage.g:152:4: kw= '-'
+                    {
+                    kw=(Token)match(input,11,FOLLOW_4); 
+                                                current.merge(kw);
+                                                newLeafNode(kw, grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0());
+                                        
+                    }
+                    break;
+            }
+            this_INT_1=(Token)match(input,RULE_INT,FOLLOW_5); 
+                                current.merge(this_INT_1);
+                        
+                                newLeafNode(this_INT_1, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1());
+                        
+            kw=(Token)match(input,12,FOLLOW_4); 
+                                current.merge(kw);
+                                newLeafNode(kw, grammarAccess.getREALLiteralAccess().getFullStopKeyword_2());
+                        
+            this_INT_3=(Token)match(input,RULE_INT,FOLLOW_2); 
+                                current.merge(this_INT_3);
+                        
+                                newLeafNode(this_INT_3, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3());
+                        
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleREALLiteral"
+    // $ANTLR start "entryRuleINTLiteral"
+    // InternalSolverLanguage.g:181:1: entryRuleINTLiteral returns [String current=null] : iv_ruleINTLiteral= ruleINTLiteral EOF ;
+    public final String entryRuleINTLiteral() throws RecognitionException {
+        String current = null;
+        AntlrDatatypeRuleToken iv_ruleINTLiteral = null;
+        try {
+            // InternalSolverLanguage.g:181:50: (iv_ruleINTLiteral= ruleINTLiteral EOF )
+            // InternalSolverLanguage.g:182:2: iv_ruleINTLiteral= ruleINTLiteral EOF
+            {
+             newCompositeNode(grammarAccess.getINTLiteralRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleINTLiteral=ruleINTLiteral();
+            state._fsp--;
+             current =iv_ruleINTLiteral.getText(); 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleINTLiteral"
+    // $ANTLR start "ruleINTLiteral"
+    // InternalSolverLanguage.g:188:1: ruleINTLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '-' )? this_INT_1= RULE_INT ) ;
+    public final AntlrDatatypeRuleToken ruleINTLiteral() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+        Token kw=null;
+        Token this_INT_1=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:194:2: ( ( (kw= '-' )? this_INT_1= RULE_INT ) )
+            // InternalSolverLanguage.g:195:2: ( (kw= '-' )? this_INT_1= RULE_INT )
+            {
+            // InternalSolverLanguage.g:195:2: ( (kw= '-' )? this_INT_1= RULE_INT )
+            // InternalSolverLanguage.g:196:3: (kw= '-' )? this_INT_1= RULE_INT
+            {
+            // InternalSolverLanguage.g:196:3: (kw= '-' )?
+            int alt4=2;
+            int LA4_0 = input.LA(1);
+            if ( (LA4_0==11) ) {
+                alt4=1;
+            }
+            switch (alt4) {
+                case 1 :
+                    // InternalSolverLanguage.g:197:4: kw= '-'
+                    {
+                    kw=(Token)match(input,11,FOLLOW_4); 
+                                                current.merge(kw);
+                                                newLeafNode(kw, grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0());
+                                        
+                    }
+                    break;
+            }
+            this_INT_1=(Token)match(input,RULE_INT,FOLLOW_2); 
+                                current.merge(this_INT_1);
+                        
+                                newLeafNode(this_INT_1, grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1());
+                        
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleINTLiteral"
+    // $ANTLR start "entryRuleBooleanValue"
+    // InternalSolverLanguage.g:214:1: entryRuleBooleanValue returns [EObject current=null] : iv_ruleBooleanValue= ruleBooleanValue EOF ;
+    public final EObject entryRuleBooleanValue() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleBooleanValue = null;
+        try {
+            // InternalSolverLanguage.g:214:53: (iv_ruleBooleanValue= ruleBooleanValue EOF )
+            // InternalSolverLanguage.g:215:2: iv_ruleBooleanValue= ruleBooleanValue EOF
+            {
+             newCompositeNode(grammarAccess.getBooleanValueRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleBooleanValue=ruleBooleanValue();
+            state._fsp--;
+             current =iv_ruleBooleanValue; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleBooleanValue"
+    // $ANTLR start "ruleBooleanValue"
+    // InternalSolverLanguage.g:221:1: ruleBooleanValue returns [EObject current=null] : ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) ) ;
+    public final EObject ruleBooleanValue() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_1=null;
+        Token otherlv_2=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:227:2: ( ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) ) )
+            // InternalSolverLanguage.g:228:2: ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) )
+            {
+            // InternalSolverLanguage.g:228:2: ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) )
+            int alt5=2;
+            int LA5_0 = input.LA(1);
+            if ( (LA5_0==13) ) {
+                alt5=1;
+            }
+            else if ( (LA5_0==14) ) {
+                alt5=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 5, 0, input);
+                throw nvae;
+            }
+            switch (alt5) {
+                case 1 :
+                    // InternalSolverLanguage.g:229:3: ( () otherlv_1= 'true' )
+                    {
+                    // InternalSolverLanguage.g:229:3: ( () otherlv_1= 'true' )
+                    // InternalSolverLanguage.g:230:4: () otherlv_1= 'true'
+                    {
+                    // InternalSolverLanguage.g:230:4: ()
+                    // InternalSolverLanguage.g:231:5: 
+                    {
+                                                        current = forceCreateModelElement(
+                                                                grammarAccess.getBooleanValueAccess().getBooleanTrueAction_0_0(),
+                                                                current);
+                                                
+                    }
+                    otherlv_1=(Token)match(input,13,FOLLOW_2); 
+                                                newLeafNode(otherlv_1, grammarAccess.getBooleanValueAccess().getTrueKeyword_0_1());
+                                        
+                    }
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:243:3: (otherlv_2= 'false' () )
+                    {
+                    // InternalSolverLanguage.g:243:3: (otherlv_2= 'false' () )
+                    // InternalSolverLanguage.g:244:4: otherlv_2= 'false' ()
+                    {
+                    otherlv_2=(Token)match(input,14,FOLLOW_2); 
+                                                newLeafNode(otherlv_2, grammarAccess.getBooleanValueAccess().getFalseKeyword_1_0());
+                                        
+                    // InternalSolverLanguage.g:248:4: ()
+                    // InternalSolverLanguage.g:249:5: 
+                    {
+                                                        current = forceCreateModelElement(
+                                                                grammarAccess.getBooleanValueAccess().getBooleanFalseAction_1_1(),
+                                                                current);
+                                                
+                    }
+                    }
+                    }
+                    break;
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleBooleanValue"
+    // $ANTLR start "entryRuleTruthValue"
+    // InternalSolverLanguage.g:260:1: entryRuleTruthValue returns [EObject current=null] : iv_ruleTruthValue= ruleTruthValue EOF ;
+    public final EObject entryRuleTruthValue() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleTruthValue = null;
+        try {
+            // InternalSolverLanguage.g:260:51: (iv_ruleTruthValue= ruleTruthValue EOF )
+            // InternalSolverLanguage.g:261:2: iv_ruleTruthValue= ruleTruthValue EOF
+            {
+             newCompositeNode(grammarAccess.getTruthValueRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleTruthValue=ruleTruthValue();
+            state._fsp--;
+             current =iv_ruleTruthValue; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleTruthValue"
+    // $ANTLR start "ruleTruthValue"
+    // InternalSolverLanguage.g:267:1: ruleTruthValue returns [EObject current=null] : ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) ) ;
+    public final EObject ruleTruthValue() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_1=null;
+        Token otherlv_3=null;
+        Token otherlv_5=null;
+        Token otherlv_7=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:273:2: ( ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) ) )
+            // InternalSolverLanguage.g:274:2: ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) )
+            {
+            // InternalSolverLanguage.g:274:2: ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) )
+            int alt6=4;
+            switch ( input.LA(1) ) {
+            case 13:
+                {
+                alt6=1;
+                }
+                break;
+            case 14:
+                {
+                alt6=2;
+                }
+                break;
+            case 15:
+                {
+                alt6=3;
+                }
+                break;
+            case 16:
+                {
+                alt6=4;
+                }
+                break;
+            default:
+                NoViableAltException nvae =
+                    new NoViableAltException("", 6, 0, input);
+                throw nvae;
+            }
+            switch (alt6) {
+                case 1 :
+                    // InternalSolverLanguage.g:275:3: ( () otherlv_1= 'true' )
+                    {
+                    // InternalSolverLanguage.g:275:3: ( () otherlv_1= 'true' )
+                    // InternalSolverLanguage.g:276:4: () otherlv_1= 'true'
+                    {
+                    // InternalSolverLanguage.g:276:4: ()
+                    // InternalSolverLanguage.g:277:5: 
+                    {
+                                                        current = forceCreateModelElement(
+                                                                grammarAccess.getTruthValueAccess().getTrueAction_0_0(),
+                                                                current);
+                                                
+                    }
+                    otherlv_1=(Token)match(input,13,FOLLOW_2); 
+                                                newLeafNode(otherlv_1, grammarAccess.getTruthValueAccess().getTrueKeyword_0_1());
+                                        
+                    }
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:289:3: ( () otherlv_3= 'false' )
+                    {
+                    // InternalSolverLanguage.g:289:3: ( () otherlv_3= 'false' )
+                    // InternalSolverLanguage.g:290:4: () otherlv_3= 'false'
+                    {
+                    // InternalSolverLanguage.g:290:4: ()
+                    // InternalSolverLanguage.g:291:5: 
+                    {
+                                                        current = forceCreateModelElement(
+                                                                grammarAccess.getTruthValueAccess().getFalseAction_1_0(),
+                                                                current);
+                                                
+                    }
+                    otherlv_3=(Token)match(input,14,FOLLOW_2); 
+                                                newLeafNode(otherlv_3, grammarAccess.getTruthValueAccess().getFalseKeyword_1_1());
+                                        
+                    }
+                    }
+                    break;
+                case 3 :
+                    // InternalSolverLanguage.g:303:3: ( () otherlv_5= 'unknown' )
+                    {
+                    // InternalSolverLanguage.g:303:3: ( () otherlv_5= 'unknown' )
+                    // InternalSolverLanguage.g:304:4: () otherlv_5= 'unknown'
+                    {
+                    // InternalSolverLanguage.g:304:4: ()
+                    // InternalSolverLanguage.g:305:5: 
+                    {
+                                                        current = forceCreateModelElement(
+                                                                grammarAccess.getTruthValueAccess().getUnknownAction_2_0(),
+                                                                current);
+                                                
+                    }
+                    otherlv_5=(Token)match(input,15,FOLLOW_2); 
+                                                newLeafNode(otherlv_5, grammarAccess.getTruthValueAccess().getUnknownKeyword_2_1());
+                                        
+                    }
+                    }
+                    break;
+                case 4 :
+                    // InternalSolverLanguage.g:317:3: ( () otherlv_7= 'error' )
+                    {
+                    // InternalSolverLanguage.g:317:3: ( () otherlv_7= 'error' )
+                    // InternalSolverLanguage.g:318:4: () otherlv_7= 'error'
+                    {
+                    // InternalSolverLanguage.g:318:4: ()
+                    // InternalSolverLanguage.g:319:5: 
+                    {
+                                                        current = forceCreateModelElement(
+                                                                grammarAccess.getTruthValueAccess().getErrorAction_3_0(),
+                                                                current);
+                                                
+                    }
+                    otherlv_7=(Token)match(input,16,FOLLOW_2); 
+                                                newLeafNode(otherlv_7, grammarAccess.getTruthValueAccess().getErrorKeyword_3_1());
+                                        
+                    }
+                    }
+                    break;
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleTruthValue"
+    // $ANTLR start "entryRuleInterpretation"
+    // InternalSolverLanguage.g:334:1: entryRuleInterpretation returns [EObject current=null] : iv_ruleInterpretation= ruleInterpretation EOF ;
+    public final EObject entryRuleInterpretation() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleInterpretation = null;
+        try {
+            // InternalSolverLanguage.g:334:55: (iv_ruleInterpretation= ruleInterpretation EOF )
+            // InternalSolverLanguage.g:335:2: iv_ruleInterpretation= ruleInterpretation EOF
+            {
+             newCompositeNode(grammarAccess.getInterpretationRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleInterpretation=ruleInterpretation();
+            state._fsp--;
+             current =iv_ruleInterpretation; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleInterpretation"
+    // $ANTLR start "ruleInterpretation"
+    // InternalSolverLanguage.g:341:1: ruleInterpretation returns [EObject current=null] : (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation ) ;
+    public final EObject ruleInterpretation() throws RecognitionException {
+        EObject current = null;
+        EObject this_BasicInterpretation_0 = null;
+        EObject this_DefaultInterpretation_1 = null;
+        EObject this_CDInterpretation_2 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:347:2: ( (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation ) )
+            // InternalSolverLanguage.g:348:2: (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation )
+            {
+            // InternalSolverLanguage.g:348:2: (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation )
+            int alt7=3;
+            switch ( input.LA(1) ) {
+            case RULE_ID:
+            case 20:
+            case 21:
+            case 22:
+            case 23:
+            case 24:
+            case 25:
+                {
+                alt7=1;
+                }
+                break;
+            case 31:
+                {
+                alt7=2;
+                }
+                break;
+            case 32:
+            case 37:
+            case 38:
+                {
+                alt7=3;
+                }
+                break;
+            default:
+                NoViableAltException nvae =
+                    new NoViableAltException("", 7, 0, input);
+                throw nvae;
+            }
+            switch (alt7) {
+                case 1 :
+                    // InternalSolverLanguage.g:349:3: this_BasicInterpretation_0= ruleBasicInterpretation
+                    {
+                                        newCompositeNode(grammarAccess.getInterpretationAccess().getBasicInterpretationParserRuleCall_0());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_BasicInterpretation_0=ruleBasicInterpretation();
+                    state._fsp--;
+                                        current = this_BasicInterpretation_0;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:358:3: this_DefaultInterpretation_1= ruleDefaultInterpretation
+                    {
+                                        newCompositeNode(grammarAccess.getInterpretationAccess().getDefaultInterpretationParserRuleCall_1());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_DefaultInterpretation_1=ruleDefaultInterpretation();
+                    state._fsp--;
+                                        current = this_DefaultInterpretation_1;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 3 :
+                    // InternalSolverLanguage.g:367:3: this_CDInterpretation_2= ruleCDInterpretation
+                    {
+                                        newCompositeNode(grammarAccess.getInterpretationAccess().getCDInterpretationParserRuleCall_2());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_CDInterpretation_2=ruleCDInterpretation();
+                    state._fsp--;
+                                        current = this_CDInterpretation_2;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleInterpretation"
+    // $ANTLR start "entryRuleBasicInterpretation"
+    // InternalSolverLanguage.g:379:1: entryRuleBasicInterpretation returns [EObject current=null] : iv_ruleBasicInterpretation= ruleBasicInterpretation EOF ;
+    public final EObject entryRuleBasicInterpretation() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleBasicInterpretation = null;
+        try {
+            // InternalSolverLanguage.g:379:60: (iv_ruleBasicInterpretation= ruleBasicInterpretation EOF )
+            // InternalSolverLanguage.g:380:2: iv_ruleBasicInterpretation= ruleBasicInterpretation EOF
+            {
+             newCompositeNode(grammarAccess.getBasicInterpretationRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleBasicInterpretation=ruleBasicInterpretation();
+            state._fsp--;
+             current =iv_ruleBasicInterpretation; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleBasicInterpretation"
+    // $ANTLR start "ruleBasicInterpretation"
+    // InternalSolverLanguage.g:386:1: ruleBasicInterpretation returns [EObject current=null] : ( ( (lv_symbol_0_0= ruleSymbol ) ) otherlv_1= '(' ( (lv_objects_2_0= ruleComplexObject ) )* otherlv_3= ')' otherlv_4= ':' ( (lv_value_5_0= ruleTruthValue ) ) ) ;
+    public final EObject ruleBasicInterpretation() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_1=null;
+        Token otherlv_3=null;
+        Token otherlv_4=null;
+        EObject lv_symbol_0_0 = null;
+        EObject lv_objects_2_0 = null;
+        EObject lv_value_5_0 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:392:2: ( ( ( (lv_symbol_0_0= ruleSymbol ) ) otherlv_1= '(' ( (lv_objects_2_0= ruleComplexObject ) )* otherlv_3= ')' otherlv_4= ':' ( (lv_value_5_0= ruleTruthValue ) ) ) )
+            // InternalSolverLanguage.g:393:2: ( ( (lv_symbol_0_0= ruleSymbol ) ) otherlv_1= '(' ( (lv_objects_2_0= ruleComplexObject ) )* otherlv_3= ')' otherlv_4= ':' ( (lv_value_5_0= ruleTruthValue ) ) )
+            {
+            // InternalSolverLanguage.g:393:2: ( ( (lv_symbol_0_0= ruleSymbol ) ) otherlv_1= '(' ( (lv_objects_2_0= ruleComplexObject ) )* otherlv_3= ')' otherlv_4= ':' ( (lv_value_5_0= ruleTruthValue ) ) )
+            // InternalSolverLanguage.g:394:3: ( (lv_symbol_0_0= ruleSymbol ) ) otherlv_1= '(' ( (lv_objects_2_0= ruleComplexObject ) )* otherlv_3= ')' otherlv_4= ':' ( (lv_value_5_0= ruleTruthValue ) )
+            {
+            // InternalSolverLanguage.g:394:3: ( (lv_symbol_0_0= ruleSymbol ) )
+            // InternalSolverLanguage.g:395:4: (lv_symbol_0_0= ruleSymbol )
+            {
+            // InternalSolverLanguage.g:395:4: (lv_symbol_0_0= ruleSymbol )
+            // InternalSolverLanguage.g:396:5: lv_symbol_0_0= ruleSymbol
+            {
+                                                newCompositeNode(grammarAccess.getBasicInterpretationAccess().getSymbolSymbolParserRuleCall_0_0());
+                                        
+            pushFollow(FOLLOW_6);
+            lv_symbol_0_0=ruleSymbol();
+            state._fsp--;
+                                                if (current==null) {
+                                                        current = createModelElementForParent(grammarAccess.getBasicInterpretationRule());
+                                                }
+                                                set(
+                                                        current,
+                                                        "symbol",
+                                                        lv_symbol_0_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
+                                                afterParserOrEnumRuleCall();
+                                        
+            }
+            }
+            otherlv_1=(Token)match(input,17,FOLLOW_7); 
+                                newLeafNode(otherlv_1, grammarAccess.getBasicInterpretationAccess().getLeftParenthesisKeyword_1());
+                        
+            // InternalSolverLanguage.g:417:3: ( (lv_objects_2_0= ruleComplexObject ) )*
+            loop8:
+            do {
+                int alt8=2;
+                int LA8_0 = input.LA(1);
+                if ( ((LA8_0>=RULE_INT && LA8_0<=RULE_STRING)||LA8_0==11||(LA8_0>=13 && LA8_0<=14)||LA8_0==19||LA8_0==26||LA8_0==30) ) {
+                    alt8=1;
+                }
+                switch (alt8) {
+                case 1 :
+                    // InternalSolverLanguage.g:418:4: (lv_objects_2_0= ruleComplexObject )
+                    {
+                    // InternalSolverLanguage.g:418:4: (lv_objects_2_0= ruleComplexObject )
+                    // InternalSolverLanguage.g:419:5: lv_objects_2_0= ruleComplexObject
+                    {
+                                                        newCompositeNode(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_2_0());
+                                                
+                    pushFollow(FOLLOW_7);
+                    lv_objects_2_0=ruleComplexObject();
+                    state._fsp--;
+                                                        if (current==null) {
+                                                                current = createModelElementForParent(grammarAccess.getBasicInterpretationRule());
+                                                        }
+                                                        add(
+                                                                current,
+                                                                "objects",
+                                                                lv_objects_2_0,
+                                                                "org.eclipse.viatra.solver.language.SolverLanguage.ComplexObject");
+                                                        afterParserOrEnumRuleCall();
+                                                
+                    }
+                    }
+                    break;
+                default :
+                    break loop8;
+                }
+            } while (true);
+            otherlv_3=(Token)match(input,18,FOLLOW_8); 
+                                newLeafNode(otherlv_3, grammarAccess.getBasicInterpretationAccess().getRightParenthesisKeyword_3());
+                        
+            otherlv_4=(Token)match(input,19,FOLLOW_9); 
+                                newLeafNode(otherlv_4, grammarAccess.getBasicInterpretationAccess().getColonKeyword_4());
+                        
+            // InternalSolverLanguage.g:444:3: ( (lv_value_5_0= ruleTruthValue ) )
+            // InternalSolverLanguage.g:445:4: (lv_value_5_0= ruleTruthValue )
+            {
+            // InternalSolverLanguage.g:445:4: (lv_value_5_0= ruleTruthValue )
+            // InternalSolverLanguage.g:446:5: lv_value_5_0= ruleTruthValue
+            {
+                                                newCompositeNode(grammarAccess.getBasicInterpretationAccess().getValueTruthValueParserRuleCall_5_0());
+                                        
+            pushFollow(FOLLOW_2);
+            lv_value_5_0=ruleTruthValue();
+            state._fsp--;
+                                                if (current==null) {
+                                                        current = createModelElementForParent(grammarAccess.getBasicInterpretationRule());
+                                                }
+                                                set(
+                                                        current,
+                                                        "value",
+                                                        lv_value_5_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.TruthValue");
+                                                afterParserOrEnumRuleCall();
+                                        
+            }
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleBasicInterpretation"
+    // $ANTLR start "entryRuleSymbol"
+    // InternalSolverLanguage.g:467:1: entryRuleSymbol returns [EObject current=null] : iv_ruleSymbol= ruleSymbol EOF ;
+    public final EObject entryRuleSymbol() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleSymbol = null;
+        try {
+            // InternalSolverLanguage.g:467:47: (iv_ruleSymbol= ruleSymbol EOF )
+            // InternalSolverLanguage.g:468:2: iv_ruleSymbol= ruleSymbol EOF
+            {
+             newCompositeNode(grammarAccess.getSymbolRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleSymbol=ruleSymbol();
+            state._fsp--;
+             current =iv_ruleSymbol; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleSymbol"
+    // $ANTLR start "ruleSymbol"
+    // InternalSolverLanguage.g:474:1: ruleSymbol returns [EObject current=null] : (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol ) ;
+    public final EObject ruleSymbol() throws RecognitionException {
+        EObject current = null;
+        EObject this_ModelSymbol_0 = null;
+        EObject this_PartialitySymbol_1 = null;
+        EObject this_DataSymbol_2 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:480:2: ( (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol ) )
+            // InternalSolverLanguage.g:481:2: (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol )
+            {
+            // InternalSolverLanguage.g:481:2: (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol )
+            int alt9=3;
+            switch ( input.LA(1) ) {
+            case RULE_ID:
+                {
+                alt9=1;
+                }
+                break;
+            case 20:
+            case 21:
+                {
+                alt9=2;
+                }
+                break;
+            case 22:
+            case 23:
+            case 24:
+            case 25:
+                {
+                alt9=3;
+                }
+                break;
+            default:
+                NoViableAltException nvae =
+                    new NoViableAltException("", 9, 0, input);
+                throw nvae;
+            }
+            switch (alt9) {
+                case 1 :
+                    // InternalSolverLanguage.g:482:3: this_ModelSymbol_0= ruleModelSymbol
+                    {
+                                        newCompositeNode(grammarAccess.getSymbolAccess().getModelSymbolParserRuleCall_0());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_ModelSymbol_0=ruleModelSymbol();
+                    state._fsp--;
+                                        current = this_ModelSymbol_0;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:491:3: this_PartialitySymbol_1= rulePartialitySymbol
+                    {
+                                        newCompositeNode(grammarAccess.getSymbolAccess().getPartialitySymbolParserRuleCall_1());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_PartialitySymbol_1=rulePartialitySymbol();
+                    state._fsp--;
+                                        current = this_PartialitySymbol_1;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 3 :
+                    // InternalSolverLanguage.g:500:3: this_DataSymbol_2= ruleDataSymbol
+                    {
+                                        newCompositeNode(grammarAccess.getSymbolAccess().getDataSymbolParserRuleCall_2());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_DataSymbol_2=ruleDataSymbol();
+                    state._fsp--;
+                                        current = this_DataSymbol_2;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleSymbol"
+    // $ANTLR start "entryRuleModelSymbol"
+    // InternalSolverLanguage.g:512:1: entryRuleModelSymbol returns [EObject current=null] : iv_ruleModelSymbol= ruleModelSymbol EOF ;
+    public final EObject entryRuleModelSymbol() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleModelSymbol = null;
+        try {
+            // InternalSolverLanguage.g:512:52: (iv_ruleModelSymbol= ruleModelSymbol EOF )
+            // InternalSolverLanguage.g:513:2: iv_ruleModelSymbol= ruleModelSymbol EOF
+            {
+             newCompositeNode(grammarAccess.getModelSymbolRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleModelSymbol=ruleModelSymbol();
+            state._fsp--;
+             current =iv_ruleModelSymbol; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleModelSymbol"
+    // $ANTLR start "ruleModelSymbol"
+    // InternalSolverLanguage.g:519:1: ruleModelSymbol returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ;
+    public final EObject ruleModelSymbol() throws RecognitionException {
+        EObject current = null;
+        Token lv_name_0_0=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:525:2: ( ( (lv_name_0_0= RULE_ID ) ) )
+            // InternalSolverLanguage.g:526:2: ( (lv_name_0_0= RULE_ID ) )
+            {
+            // InternalSolverLanguage.g:526:2: ( (lv_name_0_0= RULE_ID ) )
+            // InternalSolverLanguage.g:527:3: (lv_name_0_0= RULE_ID )
+            {
+            // InternalSolverLanguage.g:527:3: (lv_name_0_0= RULE_ID )
+            // InternalSolverLanguage.g:528:4: lv_name_0_0= RULE_ID
+            {
+            lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_2); 
+                                        newLeafNode(lv_name_0_0, grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0());
+                                
+                                        if (current==null) {
+                                                current = createModelElement(grammarAccess.getModelSymbolRule());
+                                        }
+                                        setWithLastConsumed(
+                                                current,
+                                                "name",
+                                                lv_name_0_0,
+                                                "org.eclipse.xtext.common.Terminals.ID");
+                                
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleModelSymbol"
+    // $ANTLR start "entryRulePartialitySymbol"
+    // InternalSolverLanguage.g:547:1: entryRulePartialitySymbol returns [EObject current=null] : iv_rulePartialitySymbol= rulePartialitySymbol EOF ;
+    public final EObject entryRulePartialitySymbol() throws RecognitionException {
+        EObject current = null;
+        EObject iv_rulePartialitySymbol = null;
+        try {
+            // InternalSolverLanguage.g:547:57: (iv_rulePartialitySymbol= rulePartialitySymbol EOF )
+            // InternalSolverLanguage.g:548:2: iv_rulePartialitySymbol= rulePartialitySymbol EOF
+            {
+             newCompositeNode(grammarAccess.getPartialitySymbolRule()); 
+            pushFollow(FOLLOW_1);
+            iv_rulePartialitySymbol=rulePartialitySymbol();
+            state._fsp--;
+             current =iv_rulePartialitySymbol; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRulePartialitySymbol"
+    // $ANTLR start "rulePartialitySymbol"
+    // InternalSolverLanguage.g:554:1: rulePartialitySymbol returns [EObject current=null] : (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol ) ;
+    public final EObject rulePartialitySymbol() throws RecognitionException {
+        EObject current = null;
+        EObject this_ExistSymbol_0 = null;
+        EObject this_EqualsSymbol_1 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:560:2: ( (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol ) )
+            // InternalSolverLanguage.g:561:2: (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol )
+            {
+            // InternalSolverLanguage.g:561:2: (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol )
+            int alt10=2;
+            int LA10_0 = input.LA(1);
+            if ( (LA10_0==20) ) {
+                alt10=1;
+            }
+            else if ( (LA10_0==21) ) {
+                alt10=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 10, 0, input);
+                throw nvae;
+            }
+            switch (alt10) {
+                case 1 :
+                    // InternalSolverLanguage.g:562:3: this_ExistSymbol_0= ruleExistSymbol
+                    {
+                                        newCompositeNode(grammarAccess.getPartialitySymbolAccess().getExistSymbolParserRuleCall_0());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_ExistSymbol_0=ruleExistSymbol();
+                    state._fsp--;
+                                        current = this_ExistSymbol_0;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:571:3: this_EqualsSymbol_1= ruleEqualsSymbol
+                    {
+                                        newCompositeNode(grammarAccess.getPartialitySymbolAccess().getEqualsSymbolParserRuleCall_1());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_EqualsSymbol_1=ruleEqualsSymbol();
+                    state._fsp--;
+                                        current = this_EqualsSymbol_1;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "rulePartialitySymbol"
+    // $ANTLR start "entryRuleExistSymbol"
+    // InternalSolverLanguage.g:583:1: entryRuleExistSymbol returns [EObject current=null] : iv_ruleExistSymbol= ruleExistSymbol EOF ;
+    public final EObject entryRuleExistSymbol() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleExistSymbol = null;
+        try {
+            // InternalSolverLanguage.g:583:52: (iv_ruleExistSymbol= ruleExistSymbol EOF )
+            // InternalSolverLanguage.g:584:2: iv_ruleExistSymbol= ruleExistSymbol EOF
+            {
+             newCompositeNode(grammarAccess.getExistSymbolRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleExistSymbol=ruleExistSymbol();
+            state._fsp--;
+             current =iv_ruleExistSymbol; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleExistSymbol"
+    // $ANTLR start "ruleExistSymbol"
+    // InternalSolverLanguage.g:590:1: ruleExistSymbol returns [EObject current=null] : (otherlv_0= 'exists' () ) ;
+    public final EObject ruleExistSymbol() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_0=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:596:2: ( (otherlv_0= 'exists' () ) )
+            // InternalSolverLanguage.g:597:2: (otherlv_0= 'exists' () )
+            {
+            // InternalSolverLanguage.g:597:2: (otherlv_0= 'exists' () )
+            // InternalSolverLanguage.g:598:3: otherlv_0= 'exists' ()
+            {
+            otherlv_0=(Token)match(input,20,FOLLOW_2); 
+                                newLeafNode(otherlv_0, grammarAccess.getExistSymbolAccess().getExistsKeyword_0());
+                        
+            // InternalSolverLanguage.g:602:3: ()
+            // InternalSolverLanguage.g:603:4: 
+            {
+                                        current = forceCreateModelElement(
+                                                grammarAccess.getExistSymbolAccess().getExistSymbolAction_1(),
+                                                current);
+                                
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleExistSymbol"
+    // $ANTLR start "entryRuleEqualsSymbol"
+    // InternalSolverLanguage.g:613:1: entryRuleEqualsSymbol returns [EObject current=null] : iv_ruleEqualsSymbol= ruleEqualsSymbol EOF ;
+    public final EObject entryRuleEqualsSymbol() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleEqualsSymbol = null;
+        try {
+            // InternalSolverLanguage.g:613:53: (iv_ruleEqualsSymbol= ruleEqualsSymbol EOF )
+            // InternalSolverLanguage.g:614:2: iv_ruleEqualsSymbol= ruleEqualsSymbol EOF
+            {
+             newCompositeNode(grammarAccess.getEqualsSymbolRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleEqualsSymbol=ruleEqualsSymbol();
+            state._fsp--;
+             current =iv_ruleEqualsSymbol; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleEqualsSymbol"
+    // $ANTLR start "ruleEqualsSymbol"
+    // InternalSolverLanguage.g:620:1: ruleEqualsSymbol returns [EObject current=null] : (otherlv_0= 'equals' () ) ;
+    public final EObject ruleEqualsSymbol() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_0=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:626:2: ( (otherlv_0= 'equals' () ) )
+            // InternalSolverLanguage.g:627:2: (otherlv_0= 'equals' () )
+            {
+            // InternalSolverLanguage.g:627:2: (otherlv_0= 'equals' () )
+            // InternalSolverLanguage.g:628:3: otherlv_0= 'equals' ()
+            {
+            otherlv_0=(Token)match(input,21,FOLLOW_2); 
+                                newLeafNode(otherlv_0, grammarAccess.getEqualsSymbolAccess().getEqualsKeyword_0());
+                        
+            // InternalSolverLanguage.g:632:3: ()
+            // InternalSolverLanguage.g:633:4: 
+            {
+                                        current = forceCreateModelElement(
+                                                grammarAccess.getEqualsSymbolAccess().getEqualsSymbolAction_1(),
+                                                current);
+                                
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleEqualsSymbol"
+    // $ANTLR start "entryRuleDataSymbol"
+    // InternalSolverLanguage.g:643:1: entryRuleDataSymbol returns [EObject current=null] : iv_ruleDataSymbol= ruleDataSymbol EOF ;
+    public final EObject entryRuleDataSymbol() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleDataSymbol = null;
+        try {
+            // InternalSolverLanguage.g:643:51: (iv_ruleDataSymbol= ruleDataSymbol EOF )
+            // InternalSolverLanguage.g:644:2: iv_ruleDataSymbol= ruleDataSymbol EOF
+            {
+             newCompositeNode(grammarAccess.getDataSymbolRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleDataSymbol=ruleDataSymbol();
+            state._fsp--;
+             current =iv_ruleDataSymbol; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleDataSymbol"
+    // $ANTLR start "ruleDataSymbol"
+    // InternalSolverLanguage.g:650:1: ruleDataSymbol returns [EObject current=null] : (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol ) ;
+    public final EObject ruleDataSymbol() throws RecognitionException {
+        EObject current = null;
+        EObject this_BooleanSymbol_0 = null;
+        EObject this_IntegerSymbol_1 = null;
+        EObject this_RealSymbol_2 = null;
+        EObject this_StringSymbol_3 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:656:2: ( (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol ) )
+            // InternalSolverLanguage.g:657:2: (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol )
+            {
+            // InternalSolverLanguage.g:657:2: (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol )
+            int alt11=4;
+            switch ( input.LA(1) ) {
+            case 22:
+                {
+                alt11=1;
+                }
+                break;
+            case 23:
+                {
+                alt11=2;
+                }
+                break;
+            case 24:
+                {
+                alt11=3;
+                }
+                break;
+            case 25:
+                {
+                alt11=4;
+                }
+                break;
+            default:
+                NoViableAltException nvae =
+                    new NoViableAltException("", 11, 0, input);
+                throw nvae;
+            }
+            switch (alt11) {
+                case 1 :
+                    // InternalSolverLanguage.g:658:3: this_BooleanSymbol_0= ruleBooleanSymbol
+                    {
+                                        newCompositeNode(grammarAccess.getDataSymbolAccess().getBooleanSymbolParserRuleCall_0());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_BooleanSymbol_0=ruleBooleanSymbol();
+                    state._fsp--;
+                                        current = this_BooleanSymbol_0;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:667:3: this_IntegerSymbol_1= ruleIntegerSymbol
+                    {
+                                        newCompositeNode(grammarAccess.getDataSymbolAccess().getIntegerSymbolParserRuleCall_1());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_IntegerSymbol_1=ruleIntegerSymbol();
+                    state._fsp--;
+                                        current = this_IntegerSymbol_1;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 3 :
+                    // InternalSolverLanguage.g:676:3: this_RealSymbol_2= ruleRealSymbol
+                    {
+                                        newCompositeNode(grammarAccess.getDataSymbolAccess().getRealSymbolParserRuleCall_2());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_RealSymbol_2=ruleRealSymbol();
+                    state._fsp--;
+                                        current = this_RealSymbol_2;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 4 :
+                    // InternalSolverLanguage.g:685:3: this_StringSymbol_3= ruleStringSymbol
+                    {
+                                        newCompositeNode(grammarAccess.getDataSymbolAccess().getStringSymbolParserRuleCall_3());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_StringSymbol_3=ruleStringSymbol();
+                    state._fsp--;
+                                        current = this_StringSymbol_3;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleDataSymbol"
+    // $ANTLR start "entryRuleBooleanSymbol"
+    // InternalSolverLanguage.g:697:1: entryRuleBooleanSymbol returns [EObject current=null] : iv_ruleBooleanSymbol= ruleBooleanSymbol EOF ;
+    public final EObject entryRuleBooleanSymbol() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleBooleanSymbol = null;
+        try {
+            // InternalSolverLanguage.g:697:54: (iv_ruleBooleanSymbol= ruleBooleanSymbol EOF )
+            // InternalSolverLanguage.g:698:2: iv_ruleBooleanSymbol= ruleBooleanSymbol EOF
+            {
+             newCompositeNode(grammarAccess.getBooleanSymbolRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleBooleanSymbol=ruleBooleanSymbol();
+            state._fsp--;
+             current =iv_ruleBooleanSymbol; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleBooleanSymbol"
+    // $ANTLR start "ruleBooleanSymbol"
+    // InternalSolverLanguage.g:704:1: ruleBooleanSymbol returns [EObject current=null] : (otherlv_0= 'bool' () ) ;
+    public final EObject ruleBooleanSymbol() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_0=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:710:2: ( (otherlv_0= 'bool' () ) )
+            // InternalSolverLanguage.g:711:2: (otherlv_0= 'bool' () )
+            {
+            // InternalSolverLanguage.g:711:2: (otherlv_0= 'bool' () )
+            // InternalSolverLanguage.g:712:3: otherlv_0= 'bool' ()
+            {
+            otherlv_0=(Token)match(input,22,FOLLOW_2); 
+                                newLeafNode(otherlv_0, grammarAccess.getBooleanSymbolAccess().getBoolKeyword_0());
+                        
+            // InternalSolverLanguage.g:716:3: ()
+            // InternalSolverLanguage.g:717:4: 
+            {
+                                        current = forceCreateModelElement(
+                                                grammarAccess.getBooleanSymbolAccess().getBooleanSymbolAction_1(),
+                                                current);
+                                
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleBooleanSymbol"
+    // $ANTLR start "entryRuleIntegerSymbol"
+    // InternalSolverLanguage.g:727:1: entryRuleIntegerSymbol returns [EObject current=null] : iv_ruleIntegerSymbol= ruleIntegerSymbol EOF ;
+    public final EObject entryRuleIntegerSymbol() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleIntegerSymbol = null;
+        try {
+            // InternalSolverLanguage.g:727:54: (iv_ruleIntegerSymbol= ruleIntegerSymbol EOF )
+            // InternalSolverLanguage.g:728:2: iv_ruleIntegerSymbol= ruleIntegerSymbol EOF
+            {
+             newCompositeNode(grammarAccess.getIntegerSymbolRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleIntegerSymbol=ruleIntegerSymbol();
+            state._fsp--;
+             current =iv_ruleIntegerSymbol; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleIntegerSymbol"
+    // $ANTLR start "ruleIntegerSymbol"
+    // InternalSolverLanguage.g:734:1: ruleIntegerSymbol returns [EObject current=null] : (otherlv_0= 'int' () ) ;
+    public final EObject ruleIntegerSymbol() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_0=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:740:2: ( (otherlv_0= 'int' () ) )
+            // InternalSolverLanguage.g:741:2: (otherlv_0= 'int' () )
+            {
+            // InternalSolverLanguage.g:741:2: (otherlv_0= 'int' () )
+            // InternalSolverLanguage.g:742:3: otherlv_0= 'int' ()
+            {
+            otherlv_0=(Token)match(input,23,FOLLOW_2); 
+                                newLeafNode(otherlv_0, grammarAccess.getIntegerSymbolAccess().getIntKeyword_0());
+                        
+            // InternalSolverLanguage.g:746:3: ()
+            // InternalSolverLanguage.g:747:4: 
+            {
+                                        current = forceCreateModelElement(
+                                                grammarAccess.getIntegerSymbolAccess().getIntegerSymbolAction_1(),
+                                                current);
+                                
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleIntegerSymbol"
+    // $ANTLR start "entryRuleRealSymbol"
+    // InternalSolverLanguage.g:757:1: entryRuleRealSymbol returns [EObject current=null] : iv_ruleRealSymbol= ruleRealSymbol EOF ;
+    public final EObject entryRuleRealSymbol() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleRealSymbol = null;
+        try {
+            // InternalSolverLanguage.g:757:51: (iv_ruleRealSymbol= ruleRealSymbol EOF )
+            // InternalSolverLanguage.g:758:2: iv_ruleRealSymbol= ruleRealSymbol EOF
+            {
+             newCompositeNode(grammarAccess.getRealSymbolRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleRealSymbol=ruleRealSymbol();
+            state._fsp--;
+             current =iv_ruleRealSymbol; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleRealSymbol"
+    // $ANTLR start "ruleRealSymbol"
+    // InternalSolverLanguage.g:764:1: ruleRealSymbol returns [EObject current=null] : (otherlv_0= 'real' () ) ;
+    public final EObject ruleRealSymbol() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_0=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:770:2: ( (otherlv_0= 'real' () ) )
+            // InternalSolverLanguage.g:771:2: (otherlv_0= 'real' () )
+            {
+            // InternalSolverLanguage.g:771:2: (otherlv_0= 'real' () )
+            // InternalSolverLanguage.g:772:3: otherlv_0= 'real' ()
+            {
+            otherlv_0=(Token)match(input,24,FOLLOW_2); 
+                                newLeafNode(otherlv_0, grammarAccess.getRealSymbolAccess().getRealKeyword_0());
+                        
+            // InternalSolverLanguage.g:776:3: ()
+            // InternalSolverLanguage.g:777:4: 
+            {
+                                        current = forceCreateModelElement(
+                                                grammarAccess.getRealSymbolAccess().getRealSymbolAction_1(),
+                                                current);
+                                
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleRealSymbol"
+    // $ANTLR start "entryRuleStringSymbol"
+    // InternalSolverLanguage.g:787:1: entryRuleStringSymbol returns [EObject current=null] : iv_ruleStringSymbol= ruleStringSymbol EOF ;
+    public final EObject entryRuleStringSymbol() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleStringSymbol = null;
+        try {
+            // InternalSolverLanguage.g:787:53: (iv_ruleStringSymbol= ruleStringSymbol EOF )
+            // InternalSolverLanguage.g:788:2: iv_ruleStringSymbol= ruleStringSymbol EOF
+            {
+             newCompositeNode(grammarAccess.getStringSymbolRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleStringSymbol=ruleStringSymbol();
+            state._fsp--;
+             current =iv_ruleStringSymbol; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleStringSymbol"
+    // $ANTLR start "ruleStringSymbol"
+    // InternalSolverLanguage.g:794:1: ruleStringSymbol returns [EObject current=null] : (otherlv_0= 'string' () ) ;
+    public final EObject ruleStringSymbol() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_0=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:800:2: ( (otherlv_0= 'string' () ) )
+            // InternalSolverLanguage.g:801:2: (otherlv_0= 'string' () )
+            {
+            // InternalSolverLanguage.g:801:2: (otherlv_0= 'string' () )
+            // InternalSolverLanguage.g:802:3: otherlv_0= 'string' ()
+            {
+            otherlv_0=(Token)match(input,25,FOLLOW_2); 
+                                newLeafNode(otherlv_0, grammarAccess.getStringSymbolAccess().getStringKeyword_0());
+                        
+            // InternalSolverLanguage.g:806:3: ()
+            // InternalSolverLanguage.g:807:4: 
+            {
+                                        current = forceCreateModelElement(
+                                                grammarAccess.getStringSymbolAccess().getStringSymbolAction_1(),
+                                                current);
+                                
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleStringSymbol"
+    // $ANTLR start "entryRuleComplexObject"
+    // InternalSolverLanguage.g:817:1: entryRuleComplexObject returns [EObject current=null] : iv_ruleComplexObject= ruleComplexObject EOF ;
+    public final EObject entryRuleComplexObject() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleComplexObject = null;
+        try {
+            // InternalSolverLanguage.g:817:54: (iv_ruleComplexObject= ruleComplexObject EOF )
+            // InternalSolverLanguage.g:818:2: iv_ruleComplexObject= ruleComplexObject EOF
+            {
+             newCompositeNode(grammarAccess.getComplexObjectRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleComplexObject=ruleComplexObject();
+            state._fsp--;
+             current =iv_ruleComplexObject; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleComplexObject"
+    // $ANTLR start "ruleComplexObject"
+    // InternalSolverLanguage.g:824:1: ruleComplexObject returns [EObject current=null] : (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects ) ;
+    public final EObject ruleComplexObject() throws RecognitionException {
+        EObject current = null;
+        EObject this_Object_0 = null;
+        EObject this_AllInstances_1 = null;
+        EObject this_AllObjects_2 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:830:2: ( (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects ) )
+            // InternalSolverLanguage.g:831:2: (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects )
+            {
+            // InternalSolverLanguage.g:831:2: (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects )
+            int alt12=3;
+            switch ( input.LA(1) ) {
+            case RULE_INT:
+            case RULE_ID:
+            case RULE_STRING:
+            case 11:
+            case 13:
+            case 14:
+            case 26:
+                {
+                alt12=1;
+                }
+                break;
+            case 19:
+                {
+                alt12=2;
+                }
+                break;
+            case 30:
+                {
+                alt12=3;
+                }
+                break;
+            default:
+                NoViableAltException nvae =
+                    new NoViableAltException("", 12, 0, input);
+                throw nvae;
+            }
+            switch (alt12) {
+                case 1 :
+                    // InternalSolverLanguage.g:832:3: this_Object_0= ruleObject
+                    {
+                                        newCompositeNode(grammarAccess.getComplexObjectAccess().getObjectParserRuleCall_0());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_Object_0=ruleObject();
+                    state._fsp--;
+                                        current = this_Object_0;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:841:3: this_AllInstances_1= ruleAllInstances
+                    {
+                                        newCompositeNode(grammarAccess.getComplexObjectAccess().getAllInstancesParserRuleCall_1());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_AllInstances_1=ruleAllInstances();
+                    state._fsp--;
+                                        current = this_AllInstances_1;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 3 :
+                    // InternalSolverLanguage.g:850:3: this_AllObjects_2= ruleAllObjects
+                    {
+                                        newCompositeNode(grammarAccess.getComplexObjectAccess().getAllObjectsParserRuleCall_2());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_AllObjects_2=ruleAllObjects();
+                    state._fsp--;
+                                        current = this_AllObjects_2;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleComplexObject"
+    // $ANTLR start "entryRuleObject"
+    // InternalSolverLanguage.g:862:1: entryRuleObject returns [EObject current=null] : iv_ruleObject= ruleObject EOF ;
+    public final EObject entryRuleObject() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleObject = null;
+        try {
+            // InternalSolverLanguage.g:862:47: (iv_ruleObject= ruleObject EOF )
+            // InternalSolverLanguage.g:863:2: iv_ruleObject= ruleObject EOF
+            {
+             newCompositeNode(grammarAccess.getObjectRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleObject=ruleObject();
+            state._fsp--;
+             current =iv_ruleObject; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleObject"
+    // $ANTLR start "ruleObject"
+    // InternalSolverLanguage.g:869:1: ruleObject returns [EObject current=null] : (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject ) ;
+    public final EObject ruleObject() throws RecognitionException {
+        EObject current = null;
+        EObject this_NamedObject_0 = null;
+        EObject this_UnnamedObject_1 = null;
+        EObject this_DataObject_2 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:875:2: ( (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject ) )
+            // InternalSolverLanguage.g:876:2: (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject )
+            {
+            // InternalSolverLanguage.g:876:2: (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject )
+            int alt13=3;
+            switch ( input.LA(1) ) {
+            case 26:
+                {
+                alt13=1;
+                }
+                break;
+            case RULE_ID:
+                {
+                alt13=2;
+                }
+                break;
+            case RULE_INT:
+            case RULE_STRING:
+            case 11:
+            case 13:
+            case 14:
+                {
+                alt13=3;
+                }
+                break;
+            default:
+                NoViableAltException nvae =
+                    new NoViableAltException("", 13, 0, input);
+                throw nvae;
+            }
+            switch (alt13) {
+                case 1 :
+                    // InternalSolverLanguage.g:877:3: this_NamedObject_0= ruleNamedObject
+                    {
+                                        newCompositeNode(grammarAccess.getObjectAccess().getNamedObjectParserRuleCall_0());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_NamedObject_0=ruleNamedObject();
+                    state._fsp--;
+                                        current = this_NamedObject_0;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:886:3: this_UnnamedObject_1= ruleUnnamedObject
+                    {
+                                        newCompositeNode(grammarAccess.getObjectAccess().getUnnamedObjectParserRuleCall_1());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_UnnamedObject_1=ruleUnnamedObject();
+                    state._fsp--;
+                                        current = this_UnnamedObject_1;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 3 :
+                    // InternalSolverLanguage.g:895:3: this_DataObject_2= ruleDataObject
+                    {
+                                        newCompositeNode(grammarAccess.getObjectAccess().getDataObjectParserRuleCall_2());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_DataObject_2=ruleDataObject();
+                    state._fsp--;
+                                        current = this_DataObject_2;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleObject"
+    // $ANTLR start "entryRuleNamedObject"
+    // InternalSolverLanguage.g:907:1: entryRuleNamedObject returns [EObject current=null] : iv_ruleNamedObject= ruleNamedObject EOF ;
+    public final EObject entryRuleNamedObject() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleNamedObject = null;
+        try {
+            // InternalSolverLanguage.g:907:52: (iv_ruleNamedObject= ruleNamedObject EOF )
+            // InternalSolverLanguage.g:908:2: iv_ruleNamedObject= ruleNamedObject EOF
+            {
+             newCompositeNode(grammarAccess.getNamedObjectRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleNamedObject=ruleNamedObject();
+            state._fsp--;
+             current =iv_ruleNamedObject; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleNamedObject"
+    // $ANTLR start "ruleNamedObject"
+    // InternalSolverLanguage.g:914:1: ruleNamedObject returns [EObject current=null] : (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' ) ;
+    public final EObject ruleNamedObject() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_0=null;
+        Token lv_name_1_0=null;
+        Token otherlv_2=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:920:2: ( (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' ) )
+            // InternalSolverLanguage.g:921:2: (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' )
+            {
+            // InternalSolverLanguage.g:921:2: (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' )
+            // InternalSolverLanguage.g:922:3: otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\''
+            {
+            otherlv_0=(Token)match(input,26,FOLLOW_10); 
+                                newLeafNode(otherlv_0, grammarAccess.getNamedObjectAccess().getApostropheKeyword_0());
+                        
+            // InternalSolverLanguage.g:926:3: ( (lv_name_1_0= RULE_ID ) )
+            // InternalSolverLanguage.g:927:4: (lv_name_1_0= RULE_ID )
+            {
+            // InternalSolverLanguage.g:927:4: (lv_name_1_0= RULE_ID )
+            // InternalSolverLanguage.g:928:5: lv_name_1_0= RULE_ID
+            {
+            lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_11); 
+                                                newLeafNode(lv_name_1_0, grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0());
+                                        
+                                                if (current==null) {
+                                                        current = createModelElement(grammarAccess.getNamedObjectRule());
+                                                }
+                                                setWithLastConsumed(
+                                                        current,
+                                                        "name",
+                                                        lv_name_1_0,
+                                                        "org.eclipse.xtext.common.Terminals.ID");
+                                        
+            }
+            }
+            otherlv_2=(Token)match(input,26,FOLLOW_2); 
+                                newLeafNode(otherlv_2, grammarAccess.getNamedObjectAccess().getApostropheKeyword_2());
+                        
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleNamedObject"
+    // $ANTLR start "entryRuleUnnamedObject"
+    // InternalSolverLanguage.g:952:1: entryRuleUnnamedObject returns [EObject current=null] : iv_ruleUnnamedObject= ruleUnnamedObject EOF ;
+    public final EObject entryRuleUnnamedObject() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleUnnamedObject = null;
+        try {
+            // InternalSolverLanguage.g:952:54: (iv_ruleUnnamedObject= ruleUnnamedObject EOF )
+            // InternalSolverLanguage.g:953:2: iv_ruleUnnamedObject= ruleUnnamedObject EOF
+            {
+             newCompositeNode(grammarAccess.getUnnamedObjectRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleUnnamedObject=ruleUnnamedObject();
+            state._fsp--;
+             current =iv_ruleUnnamedObject; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleUnnamedObject"
+    // $ANTLR start "ruleUnnamedObject"
+    // InternalSolverLanguage.g:959:1: ruleUnnamedObject returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ;
+    public final EObject ruleUnnamedObject() throws RecognitionException {
+        EObject current = null;
+        Token lv_name_0_0=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:965:2: ( ( (lv_name_0_0= RULE_ID ) ) )
+            // InternalSolverLanguage.g:966:2: ( (lv_name_0_0= RULE_ID ) )
+            {
+            // InternalSolverLanguage.g:966:2: ( (lv_name_0_0= RULE_ID ) )
+            // InternalSolverLanguage.g:967:3: (lv_name_0_0= RULE_ID )
+            {
+            // InternalSolverLanguage.g:967:3: (lv_name_0_0= RULE_ID )
+            // InternalSolverLanguage.g:968:4: lv_name_0_0= RULE_ID
+            {
+            lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_2); 
+                                        newLeafNode(lv_name_0_0, grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0());
+                                
+                                        if (current==null) {
+                                                current = createModelElement(grammarAccess.getUnnamedObjectRule());
+                                        }
+                                        setWithLastConsumed(
+                                                current,
+                                                "name",
+                                                lv_name_0_0,
+                                                "org.eclipse.xtext.common.Terminals.ID");
+                                
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleUnnamedObject"
+    // $ANTLR start "entryRuleDataObject"
+    // InternalSolverLanguage.g:987:1: entryRuleDataObject returns [EObject current=null] : iv_ruleDataObject= ruleDataObject EOF ;
+    public final EObject entryRuleDataObject() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleDataObject = null;
+        try {
+            // InternalSolverLanguage.g:987:51: (iv_ruleDataObject= ruleDataObject EOF )
+            // InternalSolverLanguage.g:988:2: iv_ruleDataObject= ruleDataObject EOF
+            {
+             newCompositeNode(grammarAccess.getDataObjectRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleDataObject=ruleDataObject();
+            state._fsp--;
+             current =iv_ruleDataObject; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleDataObject"
+    // $ANTLR start "ruleDataObject"
+    // InternalSolverLanguage.g:994:1: ruleDataObject returns [EObject current=null] : (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject ) ;
+    public final EObject ruleDataObject() throws RecognitionException {
+        EObject current = null;
+        EObject this_BooleanObject_0 = null;
+        EObject this_IntObject_1 = null;
+        EObject this_RealObject_2 = null;
+        EObject this_StringObject_3 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:1000:2: ( (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject ) )
+            // InternalSolverLanguage.g:1001:2: (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject )
+            {
+            // InternalSolverLanguage.g:1001:2: (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject )
+            int alt14=4;
+            switch ( input.LA(1) ) {
+            case 13:
+            case 14:
+                {
+                alt14=1;
+                }
+                break;
+            case 11:
+                {
+                int LA14_2 = input.LA(2);
+                if ( (LA14_2==RULE_INT) ) {
+                    int LA14_3 = input.LA(3);
+                    if ( (LA14_3==12) ) {
+                        alt14=3;
+                    }
+                    else if ( (LA14_3==EOF||(LA14_3>=RULE_INT && LA14_3<=RULE_STRING)||LA14_3==11||(LA14_3>=13 && LA14_3<=14)||(LA14_3>=18 && LA14_3<=19)||LA14_3==26||LA14_3==30) ) {
+                        alt14=2;
+                    }
+                    else {
+                        NoViableAltException nvae =
+                            new NoViableAltException("", 14, 3, input);
+                        throw nvae;
+                    }
+                }
+                else {
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 14, 2, input);
+                    throw nvae;
+                }
+                }
+                break;
+            case RULE_INT:
+                {
+                int LA14_3 = input.LA(2);
+                if ( (LA14_3==12) ) {
+                    alt14=3;
+                }
+                else if ( (LA14_3==EOF||(LA14_3>=RULE_INT && LA14_3<=RULE_STRING)||LA14_3==11||(LA14_3>=13 && LA14_3<=14)||(LA14_3>=18 && LA14_3<=19)||LA14_3==26||LA14_3==30) ) {
+                    alt14=2;
+                }
+                else {
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 14, 3, input);
+                    throw nvae;
+                }
+                }
+                break;
+            case RULE_STRING:
+                {
+                alt14=4;
+                }
+                break;
+            default:
+                NoViableAltException nvae =
+                    new NoViableAltException("", 14, 0, input);
+                throw nvae;
+            }
+            switch (alt14) {
+                case 1 :
+                    // InternalSolverLanguage.g:1002:3: this_BooleanObject_0= ruleBooleanObject
+                    {
+                                        newCompositeNode(grammarAccess.getDataObjectAccess().getBooleanObjectParserRuleCall_0());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_BooleanObject_0=ruleBooleanObject();
+                    state._fsp--;
+                                        current = this_BooleanObject_0;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:1011:3: this_IntObject_1= ruleIntObject
+                    {
+                                        newCompositeNode(grammarAccess.getDataObjectAccess().getIntObjectParserRuleCall_1());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_IntObject_1=ruleIntObject();
+                    state._fsp--;
+                                        current = this_IntObject_1;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 3 :
+                    // InternalSolverLanguage.g:1020:3: this_RealObject_2= ruleRealObject
+                    {
+                                        newCompositeNode(grammarAccess.getDataObjectAccess().getRealObjectParserRuleCall_2());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_RealObject_2=ruleRealObject();
+                    state._fsp--;
+                                        current = this_RealObject_2;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 4 :
+                    // InternalSolverLanguage.g:1029:3: this_StringObject_3= ruleStringObject
+                    {
+                                        newCompositeNode(grammarAccess.getDataObjectAccess().getStringObjectParserRuleCall_3());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_StringObject_3=ruleStringObject();
+                    state._fsp--;
+                                        current = this_StringObject_3;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleDataObject"
+    // $ANTLR start "entryRuleBooleanObject"
+    // InternalSolverLanguage.g:1041:1: entryRuleBooleanObject returns [EObject current=null] : iv_ruleBooleanObject= ruleBooleanObject EOF ;
+    public final EObject entryRuleBooleanObject() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleBooleanObject = null;
+        try {
+            // InternalSolverLanguage.g:1041:54: (iv_ruleBooleanObject= ruleBooleanObject EOF )
+            // InternalSolverLanguage.g:1042:2: iv_ruleBooleanObject= ruleBooleanObject EOF
+            {
+             newCompositeNode(grammarAccess.getBooleanObjectRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleBooleanObject=ruleBooleanObject();
+            state._fsp--;
+             current =iv_ruleBooleanObject; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleBooleanObject"
+    // $ANTLR start "ruleBooleanObject"
+    // InternalSolverLanguage.g:1048:1: ruleBooleanObject returns [EObject current=null] : ( (lv_value_0_0= ruleBooleanValue ) ) ;
+    public final EObject ruleBooleanObject() throws RecognitionException {
+        EObject current = null;
+        EObject lv_value_0_0 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:1054:2: ( ( (lv_value_0_0= ruleBooleanValue ) ) )
+            // InternalSolverLanguage.g:1055:2: ( (lv_value_0_0= ruleBooleanValue ) )
+            {
+            // InternalSolverLanguage.g:1055:2: ( (lv_value_0_0= ruleBooleanValue ) )
+            // InternalSolverLanguage.g:1056:3: (lv_value_0_0= ruleBooleanValue )
+            {
+            // InternalSolverLanguage.g:1056:3: (lv_value_0_0= ruleBooleanValue )
+            // InternalSolverLanguage.g:1057:4: lv_value_0_0= ruleBooleanValue
+            {
+                                        newCompositeNode(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0());
+                                
+            pushFollow(FOLLOW_2);
+            lv_value_0_0=ruleBooleanValue();
+            state._fsp--;
+                                        if (current==null) {
+                                                current = createModelElementForParent(grammarAccess.getBooleanObjectRule());
+                                        }
+                                        set(
+                                                current,
+                                                "value",
+                                                lv_value_0_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.BooleanValue");
+                                        afterParserOrEnumRuleCall();
+                                
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleBooleanObject"
+    // $ANTLR start "entryRuleIntObject"
+    // InternalSolverLanguage.g:1077:1: entryRuleIntObject returns [EObject current=null] : iv_ruleIntObject= ruleIntObject EOF ;
+    public final EObject entryRuleIntObject() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleIntObject = null;
+        try {
+            // InternalSolverLanguage.g:1077:50: (iv_ruleIntObject= ruleIntObject EOF )
+            // InternalSolverLanguage.g:1078:2: iv_ruleIntObject= ruleIntObject EOF
+            {
+             newCompositeNode(grammarAccess.getIntObjectRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleIntObject=ruleIntObject();
+            state._fsp--;
+             current =iv_ruleIntObject; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleIntObject"
+    // $ANTLR start "ruleIntObject"
+    // InternalSolverLanguage.g:1084:1: ruleIntObject returns [EObject current=null] : ( (lv_value_0_0= ruleINTLiteral ) ) ;
+    public final EObject ruleIntObject() throws RecognitionException {
+        EObject current = null;
+        AntlrDatatypeRuleToken lv_value_0_0 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:1090:2: ( ( (lv_value_0_0= ruleINTLiteral ) ) )
+            // InternalSolverLanguage.g:1091:2: ( (lv_value_0_0= ruleINTLiteral ) )
+            {
+            // InternalSolverLanguage.g:1091:2: ( (lv_value_0_0= ruleINTLiteral ) )
+            // InternalSolverLanguage.g:1092:3: (lv_value_0_0= ruleINTLiteral )
+            {
+            // InternalSolverLanguage.g:1092:3: (lv_value_0_0= ruleINTLiteral )
+            // InternalSolverLanguage.g:1093:4: lv_value_0_0= ruleINTLiteral
+            {
+                                        newCompositeNode(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0());
+                                
+            pushFollow(FOLLOW_2);
+            lv_value_0_0=ruleINTLiteral();
+            state._fsp--;
+                                        if (current==null) {
+                                                current = createModelElementForParent(grammarAccess.getIntObjectRule());
+                                        }
+                                        set(
+                                                current,
+                                                "value",
+                                                lv_value_0_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.INTLiteral");
+                                        afterParserOrEnumRuleCall();
+                                
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleIntObject"
+    // $ANTLR start "entryRuleRealObject"
+    // InternalSolverLanguage.g:1113:1: entryRuleRealObject returns [EObject current=null] : iv_ruleRealObject= ruleRealObject EOF ;
+    public final EObject entryRuleRealObject() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleRealObject = null;
+        try {
+            // InternalSolverLanguage.g:1113:51: (iv_ruleRealObject= ruleRealObject EOF )
+            // InternalSolverLanguage.g:1114:2: iv_ruleRealObject= ruleRealObject EOF
+            {
+             newCompositeNode(grammarAccess.getRealObjectRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleRealObject=ruleRealObject();
+            state._fsp--;
+             current =iv_ruleRealObject; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleRealObject"
+    // $ANTLR start "ruleRealObject"
+    // InternalSolverLanguage.g:1120:1: ruleRealObject returns [EObject current=null] : ( (lv_value_0_0= ruleREALLiteral ) ) ;
+    public final EObject ruleRealObject() throws RecognitionException {
+        EObject current = null;
+        AntlrDatatypeRuleToken lv_value_0_0 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:1126:2: ( ( (lv_value_0_0= ruleREALLiteral ) ) )
+            // InternalSolverLanguage.g:1127:2: ( (lv_value_0_0= ruleREALLiteral ) )
+            {
+            // InternalSolverLanguage.g:1127:2: ( (lv_value_0_0= ruleREALLiteral ) )
+            // InternalSolverLanguage.g:1128:3: (lv_value_0_0= ruleREALLiteral )
+            {
+            // InternalSolverLanguage.g:1128:3: (lv_value_0_0= ruleREALLiteral )
+            // InternalSolverLanguage.g:1129:4: lv_value_0_0= ruleREALLiteral
+            {
+                                        newCompositeNode(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0());
+                                
+            pushFollow(FOLLOW_2);
+            lv_value_0_0=ruleREALLiteral();
+            state._fsp--;
+                                        if (current==null) {
+                                                current = createModelElementForParent(grammarAccess.getRealObjectRule());
+                                        }
+                                        set(
+                                                current,
+                                                "value",
+                                                lv_value_0_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.REALLiteral");
+                                        afterParserOrEnumRuleCall();
+                                
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleRealObject"
+    // $ANTLR start "entryRuleStringObject"
+    // InternalSolverLanguage.g:1149:1: entryRuleStringObject returns [EObject current=null] : iv_ruleStringObject= ruleStringObject EOF ;
+    public final EObject entryRuleStringObject() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleStringObject = null;
+        try {
+            // InternalSolverLanguage.g:1149:53: (iv_ruleStringObject= ruleStringObject EOF )
+            // InternalSolverLanguage.g:1150:2: iv_ruleStringObject= ruleStringObject EOF
+            {
+             newCompositeNode(grammarAccess.getStringObjectRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleStringObject=ruleStringObject();
+            state._fsp--;
+             current =iv_ruleStringObject; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleStringObject"
+    // $ANTLR start "ruleStringObject"
+    // InternalSolverLanguage.g:1156:1: ruleStringObject returns [EObject current=null] : ( (lv_value_0_0= RULE_STRING ) ) ;
+    public final EObject ruleStringObject() throws RecognitionException {
+        EObject current = null;
+        Token lv_value_0_0=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:1162:2: ( ( (lv_value_0_0= RULE_STRING ) ) )
+            // InternalSolverLanguage.g:1163:2: ( (lv_value_0_0= RULE_STRING ) )
+            {
+            // InternalSolverLanguage.g:1163:2: ( (lv_value_0_0= RULE_STRING ) )
+            // InternalSolverLanguage.g:1164:3: (lv_value_0_0= RULE_STRING )
+            {
+            // InternalSolverLanguage.g:1164:3: (lv_value_0_0= RULE_STRING )
+            // InternalSolverLanguage.g:1165:4: lv_value_0_0= RULE_STRING
+            {
+            lv_value_0_0=(Token)match(input,RULE_STRING,FOLLOW_2); 
+                                        newLeafNode(lv_value_0_0, grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0());
+                                
+                                        if (current==null) {
+                                                current = createModelElement(grammarAccess.getStringObjectRule());
+                                        }
+                                        setWithLastConsumed(
+                                                current,
+                                                "value",
+                                                lv_value_0_0,
+                                                "org.eclipse.viatra.solver.language.SolverLanguage.STRING");
+                                
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleStringObject"
+    // $ANTLR start "entryRulePredicate"
+    // InternalSolverLanguage.g:1184:1: entryRulePredicate returns [EObject current=null] : iv_rulePredicate= rulePredicate EOF ;
+    public final EObject entryRulePredicate() throws RecognitionException {
+        EObject current = null;
+        EObject iv_rulePredicate = null;
+        try {
+            // InternalSolverLanguage.g:1184:50: (iv_rulePredicate= rulePredicate EOF )
+            // InternalSolverLanguage.g:1185:2: iv_rulePredicate= rulePredicate EOF
+            {
+             newCompositeNode(grammarAccess.getPredicateRule()); 
+            pushFollow(FOLLOW_1);
+            iv_rulePredicate=rulePredicate();
+            state._fsp--;
+             current =iv_rulePredicate; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRulePredicate"
+    // $ANTLR start "rulePredicate"
+    // InternalSolverLanguage.g:1191:1: rulePredicate returns [EObject current=null] : (this_PredicateSymbol_0= rulePredicateSymbol | this_ErrorPredicate_1= ruleErrorPredicate ) ;
+    public final EObject rulePredicate() throws RecognitionException {
+        EObject current = null;
+        EObject this_PredicateSymbol_0 = null;
+        EObject this_ErrorPredicate_1 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:1197:2: ( (this_PredicateSymbol_0= rulePredicateSymbol | this_ErrorPredicate_1= ruleErrorPredicate ) )
+            // InternalSolverLanguage.g:1198:2: (this_PredicateSymbol_0= rulePredicateSymbol | this_ErrorPredicate_1= ruleErrorPredicate )
+            {
+            // InternalSolverLanguage.g:1198:2: (this_PredicateSymbol_0= rulePredicateSymbol | this_ErrorPredicate_1= ruleErrorPredicate )
+            int alt15=2;
+            int LA15_0 = input.LA(1);
+            if ( (LA15_0==27) ) {
+                alt15=1;
+            }
+            else if ( (LA15_0==16) ) {
+                alt15=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 15, 0, input);
+                throw nvae;
+            }
+            switch (alt15) {
+                case 1 :
+                    // InternalSolverLanguage.g:1199:3: this_PredicateSymbol_0= rulePredicateSymbol
+                    {
+                                        newCompositeNode(grammarAccess.getPredicateAccess().getPredicateSymbolParserRuleCall_0());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_PredicateSymbol_0=rulePredicateSymbol();
+                    state._fsp--;
+                                        current = this_PredicateSymbol_0;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:1208:3: this_ErrorPredicate_1= ruleErrorPredicate
+                    {
+                                        newCompositeNode(grammarAccess.getPredicateAccess().getErrorPredicateParserRuleCall_1());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_ErrorPredicate_1=ruleErrorPredicate();
+                    state._fsp--;
+                                        current = this_ErrorPredicate_1;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "rulePredicate"
+    // $ANTLR start "entryRulePredicateSymbol"
+    // InternalSolverLanguage.g:1220:1: entryRulePredicateSymbol returns [EObject current=null] : iv_rulePredicateSymbol= rulePredicateSymbol EOF ;
+    public final EObject entryRulePredicateSymbol() throws RecognitionException {
+        EObject current = null;
+        EObject iv_rulePredicateSymbol = null;
+        try {
+            // InternalSolverLanguage.g:1220:56: (iv_rulePredicateSymbol= rulePredicateSymbol EOF )
+            // InternalSolverLanguage.g:1221:2: iv_rulePredicateSymbol= rulePredicateSymbol EOF
+            {
+             newCompositeNode(grammarAccess.getPredicateSymbolRule()); 
+            pushFollow(FOLLOW_1);
+            iv_rulePredicateSymbol=rulePredicateSymbol();
+            state._fsp--;
+             current =iv_rulePredicateSymbol; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRulePredicateSymbol"
+    // $ANTLR start "rulePredicateSymbol"
+    // InternalSolverLanguage.g:1227:1: rulePredicateSymbol returns [EObject current=null] : (otherlv_0= 'predicate' ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= '(' ( (lv_parameters_3_0= ruleParameter ) )* otherlv_4= ')' otherlv_5= ':' (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) ) otherlv_10= '.' ) ;
+    public final EObject rulePredicateSymbol() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_0=null;
+        Token otherlv_2=null;
+        Token otherlv_4=null;
+        Token otherlv_5=null;
+        Token otherlv_6=null;
+        Token otherlv_8=null;
+        Token otherlv_10=null;
+        EObject lv_symbol_1_0 = null;
+        EObject lv_parameters_3_0 = null;
+        EObject lv_bodies_7_0 = null;
+        EObject lv_bodies_9_0 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:1233:2: ( (otherlv_0= 'predicate' ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= '(' ( (lv_parameters_3_0= ruleParameter ) )* otherlv_4= ')' otherlv_5= ':' (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) ) otherlv_10= '.' ) )
+            // InternalSolverLanguage.g:1234:2: (otherlv_0= 'predicate' ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= '(' ( (lv_parameters_3_0= ruleParameter ) )* otherlv_4= ')' otherlv_5= ':' (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) ) otherlv_10= '.' )
+            {
+            // InternalSolverLanguage.g:1234:2: (otherlv_0= 'predicate' ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= '(' ( (lv_parameters_3_0= ruleParameter ) )* otherlv_4= ')' otherlv_5= ':' (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) ) otherlv_10= '.' )
+            // InternalSolverLanguage.g:1235:3: otherlv_0= 'predicate' ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= '(' ( (lv_parameters_3_0= ruleParameter ) )* otherlv_4= ')' otherlv_5= ':' (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) ) otherlv_10= '.'
+            {
+            otherlv_0=(Token)match(input,27,FOLLOW_10); 
+                                newLeafNode(otherlv_0, grammarAccess.getPredicateSymbolAccess().getPredicateKeyword_0());
+                        
+            // InternalSolverLanguage.g:1239:3: ( (lv_symbol_1_0= ruleModelSymbol ) )
+            // InternalSolverLanguage.g:1240:4: (lv_symbol_1_0= ruleModelSymbol )
+            {
+            // InternalSolverLanguage.g:1240:4: (lv_symbol_1_0= ruleModelSymbol )
+            // InternalSolverLanguage.g:1241:5: lv_symbol_1_0= ruleModelSymbol
+            {
+                                                newCompositeNode(grammarAccess.getPredicateSymbolAccess().getSymbolModelSymbolParserRuleCall_1_0());
+                                        
+            pushFollow(FOLLOW_6);
+            lv_symbol_1_0=ruleModelSymbol();
+            state._fsp--;
+                                                if (current==null) {
+                                                        current = createModelElementForParent(grammarAccess.getPredicateSymbolRule());
+                                                }
+                                                set(
+                                                        current,
+                                                        "symbol",
+                                                        lv_symbol_1_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
+                                                afterParserOrEnumRuleCall();
+                                        
+            }
+            }
+            otherlv_2=(Token)match(input,17,FOLLOW_12); 
+                                newLeafNode(otherlv_2, grammarAccess.getPredicateSymbolAccess().getLeftParenthesisKeyword_2());
+                        
+            // InternalSolverLanguage.g:1262:3: ( (lv_parameters_3_0= ruleParameter ) )*
+            loop16:
+            do {
+                int alt16=2;
+                int LA16_0 = input.LA(1);
+                if ( (LA16_0==RULE_ID) ) {
+                    alt16=1;
+                }
+                switch (alt16) {
+                case 1 :
+                    // InternalSolverLanguage.g:1263:4: (lv_parameters_3_0= ruleParameter )
+                    {
+                    // InternalSolverLanguage.g:1263:4: (lv_parameters_3_0= ruleParameter )
+                    // InternalSolverLanguage.g:1264:5: lv_parameters_3_0= ruleParameter
+                    {
+                                                        newCompositeNode(grammarAccess.getPredicateSymbolAccess().getParametersParameterParserRuleCall_3_0());
+                                                
+                    pushFollow(FOLLOW_12);
+                    lv_parameters_3_0=ruleParameter();
+                    state._fsp--;
+                                                        if (current==null) {
+                                                                current = createModelElementForParent(grammarAccess.getPredicateSymbolRule());
+                                                        }
+                                                        add(
+                                                                current,
+                                                                "parameters",
+                                                                lv_parameters_3_0,
+                                                                "org.eclipse.viatra.solver.language.SolverLanguage.Parameter");
+                                                        afterParserOrEnumRuleCall();
+                                                
+                    }
+                    }
+                    break;
+                default :
+                    break loop16;
+                }
+            } while (true);
+            otherlv_4=(Token)match(input,18,FOLLOW_8); 
+                                newLeafNode(otherlv_4, grammarAccess.getPredicateSymbolAccess().getRightParenthesisKeyword_4());
+                        
+            otherlv_5=(Token)match(input,19,FOLLOW_13); 
+                                newLeafNode(otherlv_5, grammarAccess.getPredicateSymbolAccess().getColonKeyword_5());
+                        
+            // InternalSolverLanguage.g:1289:3: (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) )
+            int alt18=2;
+            int LA18_0 = input.LA(1);
+            if ( (LA18_0==14) ) {
+                alt18=1;
+            }
+            else if ( (LA18_0==EOF||LA18_0==RULE_ID||(LA18_0>=11 && LA18_0<=13)||(LA18_0>=28 && LA18_0<=29)) ) {
+                alt18=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 18, 0, input);
+                throw nvae;
+            }
+            switch (alt18) {
+                case 1 :
+                    // InternalSolverLanguage.g:1290:4: otherlv_6= 'false'
+                    {
+                    otherlv_6=(Token)match(input,14,FOLLOW_5); 
+                                                newLeafNode(otherlv_6, grammarAccess.getPredicateSymbolAccess().getFalseKeyword_6_0());
+                                        
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:1295:4: ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* )
+                    {
+                    // InternalSolverLanguage.g:1295:4: ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* )
+                    // InternalSolverLanguage.g:1296:5: ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )*
+                    {
+                    // InternalSolverLanguage.g:1296:5: ( (lv_bodies_7_0= rulePatternBody ) )
+                    // InternalSolverLanguage.g:1297:6: (lv_bodies_7_0= rulePatternBody )
+                    {
+                    // InternalSolverLanguage.g:1297:6: (lv_bodies_7_0= rulePatternBody )
+                    // InternalSolverLanguage.g:1298:7: lv_bodies_7_0= rulePatternBody
+                    {
+                                                                        newCompositeNode(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_0_0());
+                                                                
+                    pushFollow(FOLLOW_14);
+                    lv_bodies_7_0=rulePatternBody();
+                    state._fsp--;
+                                                                        if (current==null) {
+                                                                                current = createModelElementForParent(grammarAccess.getPredicateSymbolRule());
+                                                                        }
+                                                                        add(
+                                                                                current,
+                                                                                "bodies",
+                                                                                lv_bodies_7_0,
+                                                                                "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody");
+                                                                        afterParserOrEnumRuleCall();
+                                                                
+                    }
+                    }
+                    // InternalSolverLanguage.g:1315:5: (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )*
+                    loop17:
+                    do {
+                        int alt17=2;
+                        int LA17_0 = input.LA(1);
+                        if ( (LA17_0==28) ) {
+                            alt17=1;
+                        }
+                        switch (alt17) {
+                        case 1 :
+                            // InternalSolverLanguage.g:1316:6: otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) )
+                            {
+                            otherlv_8=(Token)match(input,28,FOLLOW_15); 
+                                                                        newLeafNode(otherlv_8, grammarAccess.getPredicateSymbolAccess().getVerticalLineKeyword_6_1_1_0());
+                                                                
+                            // InternalSolverLanguage.g:1320:6: ( (lv_bodies_9_0= rulePatternBody ) )
+                            // InternalSolverLanguage.g:1321:7: (lv_bodies_9_0= rulePatternBody )
+                            {
+                            // InternalSolverLanguage.g:1321:7: (lv_bodies_9_0= rulePatternBody )
+                            // InternalSolverLanguage.g:1322:8: lv_bodies_9_0= rulePatternBody
+                            {
+                                                                                        newCompositeNode(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_1_1_0());
+                                                                                
+                            pushFollow(FOLLOW_14);
+                            lv_bodies_9_0=rulePatternBody();
+                            state._fsp--;
+                                                                                        if (current==null) {
+                                                                                                current = createModelElementForParent(grammarAccess.getPredicateSymbolRule());
+                                                                                        }
+                                                                                        add(
+                                                                                                current,
+                                                                                                "bodies",
+                                                                                                lv_bodies_9_0,
+                                                                                                "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody");
+                                                                                        afterParserOrEnumRuleCall();
+                                                                                
+                            }
+                            }
+                            }
+                            break;
+                        default :
+                            break loop17;
+                        }
+                    } while (true);
+                    }
+                    }
+                    break;
+            }
+            otherlv_10=(Token)match(input,12,FOLLOW_2); 
+                                newLeafNode(otherlv_10, grammarAccess.getPredicateSymbolAccess().getFullStopKeyword_7());
+                        
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "rulePredicateSymbol"
+    // $ANTLR start "entryRuleErrorPredicate"
+    // InternalSolverLanguage.g:1350:1: entryRuleErrorPredicate returns [EObject current=null] : iv_ruleErrorPredicate= ruleErrorPredicate EOF ;
+    public final EObject entryRuleErrorPredicate() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleErrorPredicate = null;
+        try {
+            // InternalSolverLanguage.g:1350:55: (iv_ruleErrorPredicate= ruleErrorPredicate EOF )
+            // InternalSolverLanguage.g:1351:2: iv_ruleErrorPredicate= ruleErrorPredicate EOF
+            {
+             newCompositeNode(grammarAccess.getErrorPredicateRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleErrorPredicate=ruleErrorPredicate();
+            state._fsp--;
+             current =iv_ruleErrorPredicate; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleErrorPredicate"
+    // $ANTLR start "ruleErrorPredicate"
+    // InternalSolverLanguage.g:1357:1: ruleErrorPredicate returns [EObject current=null] : ( () otherlv_1= 'error' ( (lv_name_2_0= RULE_ID ) )? (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' ) otherlv_6= ':' (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) ) otherlv_11= '.' ) ;
+    public final EObject ruleErrorPredicate() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_1=null;
+        Token lv_name_2_0=null;
+        Token otherlv_3=null;
+        Token otherlv_5=null;
+        Token otherlv_6=null;
+        Token otherlv_7=null;
+        Token otherlv_9=null;
+        Token otherlv_11=null;
+        EObject lv_parameters_4_0 = null;
+        EObject lv_bodies_8_0 = null;
+        EObject lv_bodies_10_0 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:1363:2: ( ( () otherlv_1= 'error' ( (lv_name_2_0= RULE_ID ) )? (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' ) otherlv_6= ':' (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) ) otherlv_11= '.' ) )
+            // InternalSolverLanguage.g:1364:2: ( () otherlv_1= 'error' ( (lv_name_2_0= RULE_ID ) )? (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' ) otherlv_6= ':' (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) ) otherlv_11= '.' )
+            {
+            // InternalSolverLanguage.g:1364:2: ( () otherlv_1= 'error' ( (lv_name_2_0= RULE_ID ) )? (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' ) otherlv_6= ':' (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) ) otherlv_11= '.' )
+            // InternalSolverLanguage.g:1365:3: () otherlv_1= 'error' ( (lv_name_2_0= RULE_ID ) )? (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' ) otherlv_6= ':' (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) ) otherlv_11= '.'
+            {
+            // InternalSolverLanguage.g:1365:3: ()
+            // InternalSolverLanguage.g:1366:4: 
+            {
+                                        current = forceCreateModelElement(
+                                                grammarAccess.getErrorPredicateAccess().getErrorPredicateAction_0(),
+                                                current);
+                                
+            }
+            otherlv_1=(Token)match(input,16,FOLLOW_16); 
+                                newLeafNode(otherlv_1, grammarAccess.getErrorPredicateAccess().getErrorKeyword_1());
+                        
+            // InternalSolverLanguage.g:1376:3: ( (lv_name_2_0= RULE_ID ) )?
+            int alt19=2;
+            int LA19_0 = input.LA(1);
+            if ( (LA19_0==RULE_ID) ) {
+                alt19=1;
+            }
+            switch (alt19) {
+                case 1 :
+                    // InternalSolverLanguage.g:1377:4: (lv_name_2_0= RULE_ID )
+                    {
+                    // InternalSolverLanguage.g:1377:4: (lv_name_2_0= RULE_ID )
+                    // InternalSolverLanguage.g:1378:5: lv_name_2_0= RULE_ID
+                    {
+                    lv_name_2_0=(Token)match(input,RULE_ID,FOLLOW_6); 
+                                                        newLeafNode(lv_name_2_0, grammarAccess.getErrorPredicateAccess().getNameIDTerminalRuleCall_2_0());
+                                                
+                                                        if (current==null) {
+                                                                current = createModelElement(grammarAccess.getErrorPredicateRule());
+                                                        }
+                                                        setWithLastConsumed(
+                                                                current,
+                                                                "name",
+                                                                lv_name_2_0,
+                                                                "org.eclipse.xtext.common.Terminals.ID");
+                                                
+                    }
+                    }
+                    break;
+            }
+            // InternalSolverLanguage.g:1394:3: (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' )
+            // InternalSolverLanguage.g:1395:4: otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')'
+            {
+            otherlv_3=(Token)match(input,17,FOLLOW_12); 
+                                        newLeafNode(otherlv_3, grammarAccess.getErrorPredicateAccess().getLeftParenthesisKeyword_3_0());
+                                
+            // InternalSolverLanguage.g:1399:4: ( (lv_parameters_4_0= ruleParameter ) )*
+            loop20:
+            do {
+                int alt20=2;
+                int LA20_0 = input.LA(1);
+                if ( (LA20_0==RULE_ID) ) {
+                    alt20=1;
+                }
+                switch (alt20) {
+                case 1 :
+                    // InternalSolverLanguage.g:1400:5: (lv_parameters_4_0= ruleParameter )
+                    {
+                    // InternalSolverLanguage.g:1400:5: (lv_parameters_4_0= ruleParameter )
+                    // InternalSolverLanguage.g:1401:6: lv_parameters_4_0= ruleParameter
+                    {
+                                                                newCompositeNode(grammarAccess.getErrorPredicateAccess().getParametersParameterParserRuleCall_3_1_0());
+                                                        
+                    pushFollow(FOLLOW_12);
+                    lv_parameters_4_0=ruleParameter();
+                    state._fsp--;
+                                                                if (current==null) {
+                                                                        current = createModelElementForParent(grammarAccess.getErrorPredicateRule());
+                                                                }
+                                                                add(
+                                                                        current,
+                                                                        "parameters",
+                                                                        lv_parameters_4_0,
+                                                                        "org.eclipse.viatra.solver.language.SolverLanguage.Parameter");
+                                                                afterParserOrEnumRuleCall();
+                                                        
+                    }
+                    }
+                    break;
+                default :
+                    break loop20;
+                }
+            } while (true);
+            otherlv_5=(Token)match(input,18,FOLLOW_8); 
+                                        newLeafNode(otherlv_5, grammarAccess.getErrorPredicateAccess().getRightParenthesisKeyword_3_2());
+                                
+            }
+            otherlv_6=(Token)match(input,19,FOLLOW_13); 
+                                newLeafNode(otherlv_6, grammarAccess.getErrorPredicateAccess().getColonKeyword_4());
+                        
+            // InternalSolverLanguage.g:1427:3: (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) )
+            int alt22=2;
+            int LA22_0 = input.LA(1);
+            if ( (LA22_0==14) ) {
+                alt22=1;
+            }
+            else if ( (LA22_0==EOF||LA22_0==RULE_ID||(LA22_0>=11 && LA22_0<=13)||(LA22_0>=28 && LA22_0<=29)) ) {
+                alt22=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 22, 0, input);
+                throw nvae;
+            }
+            switch (alt22) {
+                case 1 :
+                    // InternalSolverLanguage.g:1428:4: otherlv_7= 'false'
+                    {
+                    otherlv_7=(Token)match(input,14,FOLLOW_5); 
+                                                newLeafNode(otherlv_7, grammarAccess.getErrorPredicateAccess().getFalseKeyword_5_0());
+                                        
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:1433:4: ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* )
+                    {
+                    // InternalSolverLanguage.g:1433:4: ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* )
+                    // InternalSolverLanguage.g:1434:5: ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )*
+                    {
+                    // InternalSolverLanguage.g:1434:5: ( (lv_bodies_8_0= rulePatternBody ) )
+                    // InternalSolverLanguage.g:1435:6: (lv_bodies_8_0= rulePatternBody )
+                    {
+                    // InternalSolverLanguage.g:1435:6: (lv_bodies_8_0= rulePatternBody )
+                    // InternalSolverLanguage.g:1436:7: lv_bodies_8_0= rulePatternBody
+                    {
+                                                                        newCompositeNode(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_0_0());
+                                                                
+                    pushFollow(FOLLOW_14);
+                    lv_bodies_8_0=rulePatternBody();
+                    state._fsp--;
+                                                                        if (current==null) {
+                                                                                current = createModelElementForParent(grammarAccess.getErrorPredicateRule());
+                                                                        }
+                                                                        add(
+                                                                                current,
+                                                                                "bodies",
+                                                                                lv_bodies_8_0,
+                                                                                "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody");
+                                                                        afterParserOrEnumRuleCall();
+                                                                
+                    }
+                    }
+                    // InternalSolverLanguage.g:1453:5: (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )*
+                    loop21:
+                    do {
+                        int alt21=2;
+                        int LA21_0 = input.LA(1);
+                        if ( (LA21_0==28) ) {
+                            alt21=1;
+                        }
+                        switch (alt21) {
+                        case 1 :
+                            // InternalSolverLanguage.g:1454:6: otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) )
+                            {
+                            otherlv_9=(Token)match(input,28,FOLLOW_15); 
+                                                                        newLeafNode(otherlv_9, grammarAccess.getErrorPredicateAccess().getVerticalLineKeyword_5_1_1_0());
+                                                                
+                            // InternalSolverLanguage.g:1458:6: ( (lv_bodies_10_0= rulePatternBody ) )
+                            // InternalSolverLanguage.g:1459:7: (lv_bodies_10_0= rulePatternBody )
+                            {
+                            // InternalSolverLanguage.g:1459:7: (lv_bodies_10_0= rulePatternBody )
+                            // InternalSolverLanguage.g:1460:8: lv_bodies_10_0= rulePatternBody
+                            {
+                                                                                        newCompositeNode(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_1_1_0());
+                                                                                
+                            pushFollow(FOLLOW_14);
+                            lv_bodies_10_0=rulePatternBody();
+                            state._fsp--;
+                                                                                        if (current==null) {
+                                                                                                current = createModelElementForParent(grammarAccess.getErrorPredicateRule());
+                                                                                        }
+                                                                                        add(
+                                                                                                current,
+                                                                                                "bodies",
+                                                                                                lv_bodies_10_0,
+                                                                                                "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody");
+                                                                                        afterParserOrEnumRuleCall();
+                                                                                
+                            }
+                            }
+                            }
+                            break;
+                        default :
+                            break loop21;
+                        }
+                    } while (true);
+                    }
+                    }
+                    break;
+            }
+            otherlv_11=(Token)match(input,12,FOLLOW_2); 
+                                newLeafNode(otherlv_11, grammarAccess.getErrorPredicateAccess().getFullStopKeyword_6());
+                        
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleErrorPredicate"
+    // $ANTLR start "entryRuleParameter"
+    // InternalSolverLanguage.g:1488:1: entryRuleParameter returns [EObject current=null] : iv_ruleParameter= ruleParameter EOF ;
+    public final EObject entryRuleParameter() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleParameter = null;
+        try {
+            // InternalSolverLanguage.g:1488:50: (iv_ruleParameter= ruleParameter EOF )
+            // InternalSolverLanguage.g:1489:2: iv_ruleParameter= ruleParameter EOF
+            {
+             newCompositeNode(grammarAccess.getParameterRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleParameter=ruleParameter();
+            state._fsp--;
+             current =iv_ruleParameter; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleParameter"
+    // $ANTLR start "ruleParameter"
+    // InternalSolverLanguage.g:1495:1: ruleParameter returns [EObject current=null] : ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? ) ;
+    public final EObject ruleParameter() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_1=null;
+        EObject lv_variable_0_0 = null;
+        EObject lv_type_2_0 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:1501:2: ( ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? ) )
+            // InternalSolverLanguage.g:1502:2: ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? )
+            {
+            // InternalSolverLanguage.g:1502:2: ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? )
+            // InternalSolverLanguage.g:1503:3: ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )?
+            {
+            // InternalSolverLanguage.g:1503:3: ( (lv_variable_0_0= ruleVariable ) )
+            // InternalSolverLanguage.g:1504:4: (lv_variable_0_0= ruleVariable )
+            {
+            // InternalSolverLanguage.g:1504:4: (lv_variable_0_0= ruleVariable )
+            // InternalSolverLanguage.g:1505:5: lv_variable_0_0= ruleVariable
+            {
+                                                newCompositeNode(grammarAccess.getParameterAccess().getVariableVariableParserRuleCall_0_0());
+                                        
+            pushFollow(FOLLOW_17);
+            lv_variable_0_0=ruleVariable();
+            state._fsp--;
+                                                if (current==null) {
+                                                        current = createModelElementForParent(grammarAccess.getParameterRule());
+                                                }
+                                                set(
+                                                        current,
+                                                        "variable",
+                                                        lv_variable_0_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.Variable");
+                                                afterParserOrEnumRuleCall();
+                                        
+            }
+            }
+            // InternalSolverLanguage.g:1522:3: (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )?
+            int alt23=2;
+            int LA23_0 = input.LA(1);
+            if ( (LA23_0==19) ) {
+                alt23=1;
+            }
+            switch (alt23) {
+                case 1 :
+                    // InternalSolverLanguage.g:1523:4: otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) )
+                    {
+                    otherlv_1=(Token)match(input,19,FOLLOW_18); 
+                                                newLeafNode(otherlv_1, grammarAccess.getParameterAccess().getColonKeyword_1_0());
+                                        
+                    // InternalSolverLanguage.g:1527:4: ( (lv_type_2_0= ruleSymbol ) )
+                    // InternalSolverLanguage.g:1528:5: (lv_type_2_0= ruleSymbol )
+                    {
+                    // InternalSolverLanguage.g:1528:5: (lv_type_2_0= ruleSymbol )
+                    // InternalSolverLanguage.g:1529:6: lv_type_2_0= ruleSymbol
+                    {
+                                                                newCompositeNode(grammarAccess.getParameterAccess().getTypeSymbolParserRuleCall_1_1_0());
+                                                        
+                    pushFollow(FOLLOW_2);
+                    lv_type_2_0=ruleSymbol();
+                    state._fsp--;
+                                                                if (current==null) {
+                                                                        current = createModelElementForParent(grammarAccess.getParameterRule());
+                                                                }
+                                                                set(
+                                                                        current,
+                                                                        "type",
+                                                                        lv_type_2_0,
+                                                                        "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
+                                                                afterParserOrEnumRuleCall();
+                                                        
+                    }
+                    }
+                    }
+                    break;
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleParameter"
+    // $ANTLR start "entryRulePatternBody"
+    // InternalSolverLanguage.g:1551:1: entryRulePatternBody returns [EObject current=null] : iv_rulePatternBody= rulePatternBody EOF ;
+    public final EObject entryRulePatternBody() throws RecognitionException {
+        EObject current = null;
+        EObject iv_rulePatternBody = null;
+        try {
+            // InternalSolverLanguage.g:1551:52: (iv_rulePatternBody= rulePatternBody EOF )
+            // InternalSolverLanguage.g:1552:2: iv_rulePatternBody= rulePatternBody EOF
+            {
+             newCompositeNode(grammarAccess.getPatternBodyRule()); 
+            pushFollow(FOLLOW_1);
+            iv_rulePatternBody=rulePatternBody();
+            state._fsp--;
+             current =iv_rulePatternBody; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRulePatternBody"
+    // $ANTLR start "rulePatternBody"
+    // InternalSolverLanguage.g:1558:1: rulePatternBody returns [EObject current=null] : ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) ) ;
+    public final EObject rulePatternBody() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_1=null;
+        EObject lv_constraints_2_0 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:1564:2: ( ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) ) )
+            // InternalSolverLanguage.g:1565:2: ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) )
+            {
+            // InternalSolverLanguage.g:1565:2: ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) )
+            // InternalSolverLanguage.g:1566:3: () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* )
+            {
+            // InternalSolverLanguage.g:1566:3: ()
+            // InternalSolverLanguage.g:1567:4: 
+            {
+                                        current = forceCreateModelElement(
+                                                grammarAccess.getPatternBodyAccess().getPatternBodyAction_0(),
+                                                current);
+                                
+            }
+            // InternalSolverLanguage.g:1573:3: (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* )
+            int alt25=2;
+            int LA25_0 = input.LA(1);
+            if ( (LA25_0==13) ) {
+                alt25=1;
+            }
+            else if ( (LA25_0==EOF||LA25_0==RULE_ID||(LA25_0>=11 && LA25_0<=12)||(LA25_0>=28 && LA25_0<=29)) ) {
+                alt25=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 25, 0, input);
+                throw nvae;
+            }
+            switch (alt25) {
+                case 1 :
+                    // InternalSolverLanguage.g:1574:4: otherlv_1= 'true'
+                    {
+                    otherlv_1=(Token)match(input,13,FOLLOW_2); 
+                                                newLeafNode(otherlv_1, grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0());
+                                        
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:1579:4: ( (lv_constraints_2_0= ruleConstraint ) )*
+                    {
+                    // InternalSolverLanguage.g:1579:4: ( (lv_constraints_2_0= ruleConstraint ) )*
+                    loop24:
+                    do {
+                        int alt24=2;
+                        int LA24_0 = input.LA(1);
+                        if ( (LA24_0==RULE_ID||LA24_0==11||LA24_0==29) ) {
+                            alt24=1;
+                        }
+                        switch (alt24) {
+                        case 1 :
+                            // InternalSolverLanguage.g:1580:5: (lv_constraints_2_0= ruleConstraint )
+                            {
+                            // InternalSolverLanguage.g:1580:5: (lv_constraints_2_0= ruleConstraint )
+                            // InternalSolverLanguage.g:1581:6: lv_constraints_2_0= ruleConstraint
+                            {
+                                                                        newCompositeNode(grammarAccess.getPatternBodyAccess().getConstraintsConstraintParserRuleCall_1_1_0());
+                                                                
+                            pushFollow(FOLLOW_19);
+                            lv_constraints_2_0=ruleConstraint();
+                            state._fsp--;
+                                                                        if (current==null) {
+                                                                                current = createModelElementForParent(grammarAccess.getPatternBodyRule());
+                                                                        }
+                                                                        add(
+                                                                                current,
+                                                                                "constraints",
+                                                                                lv_constraints_2_0,
+                                                                                "org.eclipse.viatra.solver.language.SolverLanguage.Constraint");
+                                                                        afterParserOrEnumRuleCall();
+                                                                
+                            }
+                            }
+                            break;
+                        default :
+                            break loop24;
+                        }
+                    } while (true);
+                    }
+                    break;
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "rulePatternBody"
+    // $ANTLR start "entryRulePolarity"
+    // InternalSolverLanguage.g:1603:1: entryRulePolarity returns [EObject current=null] : iv_rulePolarity= rulePolarity EOF ;
+    public final EObject entryRulePolarity() throws RecognitionException {
+        EObject current = null;
+        EObject iv_rulePolarity = null;
+        try {
+            // InternalSolverLanguage.g:1603:49: (iv_rulePolarity= rulePolarity EOF )
+            // InternalSolverLanguage.g:1604:2: iv_rulePolarity= rulePolarity EOF
+            {
+             newCompositeNode(grammarAccess.getPolarityRule()); 
+            pushFollow(FOLLOW_1);
+            iv_rulePolarity=rulePolarity();
+            state._fsp--;
+             current =iv_rulePolarity; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRulePolarity"
+    // $ANTLR start "rulePolarity"
+    // InternalSolverLanguage.g:1610:1: rulePolarity returns [EObject current=null] : ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) ) ;
+    public final EObject rulePolarity() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_1=null;
+        Token otherlv_3=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:1616:2: ( ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) ) )
+            // InternalSolverLanguage.g:1617:2: ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) )
+            {
+            // InternalSolverLanguage.g:1617:2: ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) )
+            int alt26=2;
+            int LA26_0 = input.LA(1);
+            if ( (LA26_0==29) ) {
+                alt26=1;
+            }
+            else if ( (LA26_0==11) ) {
+                alt26=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 26, 0, input);
+                throw nvae;
+            }
+            switch (alt26) {
+                case 1 :
+                    // InternalSolverLanguage.g:1618:3: ( () otherlv_1= '+' )
+                    {
+                    // InternalSolverLanguage.g:1618:3: ( () otherlv_1= '+' )
+                    // InternalSolverLanguage.g:1619:4: () otherlv_1= '+'
+                    {
+                    // InternalSolverLanguage.g:1619:4: ()
+                    // InternalSolverLanguage.g:1620:5: 
+                    {
+                                                        current = forceCreateModelElement(
+                                                                grammarAccess.getPolarityAccess().getPositiveAction_0_0(),
+                                                                current);
+                                                
+                    }
+                    otherlv_1=(Token)match(input,29,FOLLOW_2); 
+                                                newLeafNode(otherlv_1, grammarAccess.getPolarityAccess().getPlusSignKeyword_0_1());
+                                        
+                    }
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:1632:3: ( () otherlv_3= '-' )
+                    {
+                    // InternalSolverLanguage.g:1632:3: ( () otherlv_3= '-' )
+                    // InternalSolverLanguage.g:1633:4: () otherlv_3= '-'
+                    {
+                    // InternalSolverLanguage.g:1633:4: ()
+                    // InternalSolverLanguage.g:1634:5: 
+                    {
+                                                        current = forceCreateModelElement(
+                                                                grammarAccess.getPolarityAccess().getNegativeAction_1_0(),
+                                                                current);
+                                                
+                    }
+                    otherlv_3=(Token)match(input,11,FOLLOW_2); 
+                                                newLeafNode(otherlv_3, grammarAccess.getPolarityAccess().getHyphenMinusKeyword_1_1());
+                                        
+                    }
+                    }
+                    break;
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "rulePolarity"
+    // $ANTLR start "entryRuleConstraint"
+    // InternalSolverLanguage.g:1649:1: entryRuleConstraint returns [EObject current=null] : iv_ruleConstraint= ruleConstraint EOF ;
+    public final EObject entryRuleConstraint() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleConstraint = null;
+        try {
+            // InternalSolverLanguage.g:1649:51: (iv_ruleConstraint= ruleConstraint EOF )
+            // InternalSolverLanguage.g:1650:2: iv_ruleConstraint= ruleConstraint EOF
+            {
+             newCompositeNode(grammarAccess.getConstraintRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleConstraint=ruleConstraint();
+            state._fsp--;
+             current =iv_ruleConstraint; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleConstraint"
+    // $ANTLR start "ruleConstraint"
+    // InternalSolverLanguage.g:1656:1: ruleConstraint returns [EObject current=null] : ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) ) ) ;
+    public final EObject ruleConstraint() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_2=null;
+        Token otherlv_4=null;
+        Token otherlv_6=null;
+        Token otherlv_9=null;
+        EObject lv_polarity_0_0 = null;
+        EObject lv_symbol_1_0 = null;
+        EObject lv_params_3_0 = null;
+        EObject lv_closureType_5_0 = null;
+        EObject lv_params_7_0 = null;
+        EObject lv_params_8_0 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:1662:2: ( ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) ) ) )
+            // InternalSolverLanguage.g:1663:2: ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) ) )
+            {
+            // InternalSolverLanguage.g:1663:2: ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) ) )
+            // InternalSolverLanguage.g:1664:3: ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) )
+            {
+            // InternalSolverLanguage.g:1664:3: ( (lv_polarity_0_0= rulePolarity ) )?
+            int alt27=2;
+            int LA27_0 = input.LA(1);
+            if ( (LA27_0==11||LA27_0==29) ) {
+                alt27=1;
+            }
+            switch (alt27) {
+                case 1 :
+                    // InternalSolverLanguage.g:1665:4: (lv_polarity_0_0= rulePolarity )
+                    {
+                    // InternalSolverLanguage.g:1665:4: (lv_polarity_0_0= rulePolarity )
+                    // InternalSolverLanguage.g:1666:5: lv_polarity_0_0= rulePolarity
+                    {
+                                                        newCompositeNode(grammarAccess.getConstraintAccess().getPolarityPolarityParserRuleCall_0_0());
+                                                
+                    pushFollow(FOLLOW_10);
+                    lv_polarity_0_0=rulePolarity();
+                    state._fsp--;
+                                                        if (current==null) {
+                                                                current = createModelElementForParent(grammarAccess.getConstraintRule());
+                                                        }
+                                                        set(
+                                                                current,
+                                                                "polarity",
+                                                                lv_polarity_0_0,
+                                                                "org.eclipse.viatra.solver.language.SolverLanguage.Polarity");
+                                                        afterParserOrEnumRuleCall();
+                                                
+                    }
+                    }
+                    break;
+            }
+            // InternalSolverLanguage.g:1683:3: ( (lv_symbol_1_0= ruleModelSymbol ) )
+            // InternalSolverLanguage.g:1684:4: (lv_symbol_1_0= ruleModelSymbol )
+            {
+            // InternalSolverLanguage.g:1684:4: (lv_symbol_1_0= ruleModelSymbol )
+            // InternalSolverLanguage.g:1685:5: lv_symbol_1_0= ruleModelSymbol
+            {
+                                                newCompositeNode(grammarAccess.getConstraintAccess().getSymbolModelSymbolParserRuleCall_1_0());
+                                        
+            pushFollow(FOLLOW_20);
+            lv_symbol_1_0=ruleModelSymbol();
+            state._fsp--;
+                                                if (current==null) {
+                                                        current = createModelElementForParent(grammarAccess.getConstraintRule());
+                                                }
+                                                set(
+                                                        current,
+                                                        "symbol",
+                                                        lv_symbol_1_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
+                                                afterParserOrEnumRuleCall();
+                                        
+            }
+            }
+            // InternalSolverLanguage.g:1702:3: ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) )
+            int alt29=2;
+            int LA29_0 = input.LA(1);
+            if ( (LA29_0==17) ) {
+                alt29=1;
+            }
+            else if ( ((LA29_0>=29 && LA29_0<=30)) ) {
+                alt29=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 29, 0, input);
+                throw nvae;
+            }
+            switch (alt29) {
+                case 1 :
+                    // InternalSolverLanguage.g:1703:4: (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' )
+                    {
+                    // InternalSolverLanguage.g:1703:4: (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' )
+                    // InternalSolverLanguage.g:1704:5: otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')'
+                    {
+                    otherlv_2=(Token)match(input,17,FOLLOW_21); 
+                                                        newLeafNode(otherlv_2, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_0_0());
+                                                
+                    // InternalSolverLanguage.g:1708:5: ( (lv_params_3_0= ruleLiteral ) )*
+                    loop28:
+                    do {
+                        int alt28=2;
+                        int LA28_0 = input.LA(1);
+                        if ( ((LA28_0>=RULE_INT && LA28_0<=RULE_STRING)||LA28_0==11||(LA28_0>=13 && LA28_0<=14)) ) {
+                            alt28=1;
+                        }
+                        switch (alt28) {
+                        case 1 :
+                            // InternalSolverLanguage.g:1709:6: (lv_params_3_0= ruleLiteral )
+                            {
+                            // InternalSolverLanguage.g:1709:6: (lv_params_3_0= ruleLiteral )
+                            // InternalSolverLanguage.g:1710:7: lv_params_3_0= ruleLiteral
+                            {
+                                                                                newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_0_1_0());
+                                                                        
+                            pushFollow(FOLLOW_21);
+                            lv_params_3_0=ruleLiteral();
+                            state._fsp--;
+                                                                                if (current==null) {
+                                                                                        current = createModelElementForParent(grammarAccess.getConstraintRule());
+                                                                                }
+                                                                                add(
+                                                                                        current,
+                                                                                        "params",
+                                                                                        lv_params_3_0,
+                                                                                        "org.eclipse.viatra.solver.language.SolverLanguage.Literal");
+                                                                                afterParserOrEnumRuleCall();
+                                                                        
+                            }
+                            }
+                            break;
+                        default :
+                            break loop28;
+                        }
+                    } while (true);
+                    otherlv_4=(Token)match(input,18,FOLLOW_2); 
+                                                        newLeafNode(otherlv_4, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_0_2());
+                                                
+                    }
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:1733:4: ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' )
+                    {
+                    // InternalSolverLanguage.g:1733:4: ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' )
+                    // InternalSolverLanguage.g:1734:5: ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')'
+                    {
+                    // InternalSolverLanguage.g:1734:5: ( (lv_closureType_5_0= ruleClosureType ) )
+                    // InternalSolverLanguage.g:1735:6: (lv_closureType_5_0= ruleClosureType )
+                    {
+                    // InternalSolverLanguage.g:1735:6: (lv_closureType_5_0= ruleClosureType )
+                    // InternalSolverLanguage.g:1736:7: lv_closureType_5_0= ruleClosureType
+                    {
+                                                                        newCompositeNode(grammarAccess.getConstraintAccess().getClosureTypeClosureTypeParserRuleCall_2_1_0_0());
+                                                                
+                    pushFollow(FOLLOW_6);
+                    lv_closureType_5_0=ruleClosureType();
+                    state._fsp--;
+                                                                        if (current==null) {
+                                                                                current = createModelElementForParent(grammarAccess.getConstraintRule());
+                                                                        }
+                                                                        set(
+                                                                                current,
+                                                                                "closureType",
+                                                                                lv_closureType_5_0,
+                                                                                "org.eclipse.viatra.solver.language.SolverLanguage.ClosureType");
+                                                                        afterParserOrEnumRuleCall();
+                                                                
+                    }
+                    }
+                    otherlv_6=(Token)match(input,17,FOLLOW_22); 
+                                                        newLeafNode(otherlv_6, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_1_1());
+                                                
+                    // InternalSolverLanguage.g:1757:5: ( (lv_params_7_0= ruleLiteral ) )
+                    // InternalSolverLanguage.g:1758:6: (lv_params_7_0= ruleLiteral )
+                    {
+                    // InternalSolverLanguage.g:1758:6: (lv_params_7_0= ruleLiteral )
+                    // InternalSolverLanguage.g:1759:7: lv_params_7_0= ruleLiteral
+                    {
+                                                                        newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_2_0());
+                                                                
+                    pushFollow(FOLLOW_22);
+                    lv_params_7_0=ruleLiteral();
+                    state._fsp--;
+                                                                        if (current==null) {
+                                                                                current = createModelElementForParent(grammarAccess.getConstraintRule());
+                                                                        }
+                                                                        add(
+                                                                                current,
+                                                                                "params",
+                                                                                lv_params_7_0,
+                                                                                "org.eclipse.viatra.solver.language.SolverLanguage.Literal");
+                                                                        afterParserOrEnumRuleCall();
+                                                                
+                    }
+                    }
+                    // InternalSolverLanguage.g:1776:5: ( (lv_params_8_0= ruleLiteral ) )
+                    // InternalSolverLanguage.g:1777:6: (lv_params_8_0= ruleLiteral )
+                    {
+                    // InternalSolverLanguage.g:1777:6: (lv_params_8_0= ruleLiteral )
+                    // InternalSolverLanguage.g:1778:7: lv_params_8_0= ruleLiteral
+                    {
+                                                                        newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_3_0());
+                                                                
+                    pushFollow(FOLLOW_23);
+                    lv_params_8_0=ruleLiteral();
+                    state._fsp--;
+                                                                        if (current==null) {
+                                                                                current = createModelElementForParent(grammarAccess.getConstraintRule());
+                                                                        }
+                                                                        add(
+                                                                                current,
+                                                                                "params",
+                                                                                lv_params_8_0,
+                                                                                "org.eclipse.viatra.solver.language.SolverLanguage.Literal");
+                                                                        afterParserOrEnumRuleCall();
+                                                                
+                    }
+                    }
+                    otherlv_9=(Token)match(input,18,FOLLOW_2); 
+                                                        newLeafNode(otherlv_9, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_1_4());
+                                                
+                    }
+                    }
+                    break;
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleConstraint"
+    // $ANTLR start "entryRuleClosureType"
+    // InternalSolverLanguage.g:1805:1: entryRuleClosureType returns [EObject current=null] : iv_ruleClosureType= ruleClosureType EOF ;
+    public final EObject entryRuleClosureType() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleClosureType = null;
+        try {
+            // InternalSolverLanguage.g:1805:52: (iv_ruleClosureType= ruleClosureType EOF )
+            // InternalSolverLanguage.g:1806:2: iv_ruleClosureType= ruleClosureType EOF
+            {
+             newCompositeNode(grammarAccess.getClosureTypeRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleClosureType=ruleClosureType();
+            state._fsp--;
+             current =iv_ruleClosureType; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleClosureType"
+    // $ANTLR start "ruleClosureType"
+    // InternalSolverLanguage.g:1812:1: ruleClosureType returns [EObject current=null] : ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) ) ;
+    public final EObject ruleClosureType() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_1=null;
+        Token otherlv_3=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:1818:2: ( ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) ) )
+            // InternalSolverLanguage.g:1819:2: ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) )
+            {
+            // InternalSolverLanguage.g:1819:2: ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) )
+            int alt30=2;
+            int LA30_0 = input.LA(1);
+            if ( (LA30_0==30) ) {
+                alt30=1;
+            }
+            else if ( (LA30_0==29) ) {
+                alt30=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 30, 0, input);
+                throw nvae;
+            }
+            switch (alt30) {
+                case 1 :
+                    // InternalSolverLanguage.g:1820:3: ( () otherlv_1= '*' )
+                    {
+                    // InternalSolverLanguage.g:1820:3: ( () otherlv_1= '*' )
+                    // InternalSolverLanguage.g:1821:4: () otherlv_1= '*'
+                    {
+                    // InternalSolverLanguage.g:1821:4: ()
+                    // InternalSolverLanguage.g:1822:5: 
+                    {
+                                                        current = forceCreateModelElement(
+                                                                grammarAccess.getClosureTypeAccess().getReflexiveClosureAction_0_0(),
+                                                                current);
+                                                
+                    }
+                    otherlv_1=(Token)match(input,30,FOLLOW_2); 
+                                                newLeafNode(otherlv_1, grammarAccess.getClosureTypeAccess().getAsteriskKeyword_0_1());
+                                        
+                    }
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:1834:3: ( () otherlv_3= '+' )
+                    {
+                    // InternalSolverLanguage.g:1834:3: ( () otherlv_3= '+' )
+                    // InternalSolverLanguage.g:1835:4: () otherlv_3= '+'
+                    {
+                    // InternalSolverLanguage.g:1835:4: ()
+                    // InternalSolverLanguage.g:1836:5: 
+                    {
+                                                        current = forceCreateModelElement(
+                                                                grammarAccess.getClosureTypeAccess().getIrreflexiveClosureAction_1_0(),
+                                                                current);
+                                                
+                    }
+                    otherlv_3=(Token)match(input,29,FOLLOW_2); 
+                                                newLeafNode(otherlv_3, grammarAccess.getClosureTypeAccess().getPlusSignKeyword_1_1());
+                                        
+                    }
+                    }
+                    break;
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleClosureType"
+    // $ANTLR start "entryRuleLiteral"
+    // InternalSolverLanguage.g:1851:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ;
+    public final EObject entryRuleLiteral() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleLiteral = null;
+        try {
+            // InternalSolverLanguage.g:1851:48: (iv_ruleLiteral= ruleLiteral EOF )
+            // InternalSolverLanguage.g:1852:2: iv_ruleLiteral= ruleLiteral EOF
+            {
+             newCompositeNode(grammarAccess.getLiteralRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleLiteral=ruleLiteral();
+            state._fsp--;
+             current =iv_ruleLiteral; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleLiteral"
+    // $ANTLR start "ruleLiteral"
+    // InternalSolverLanguage.g:1858:1: ruleLiteral returns [EObject current=null] : (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject ) ;
+    public final EObject ruleLiteral() throws RecognitionException {
+        EObject current = null;
+        EObject this_Variable_0 = null;
+        EObject this_DataObject_1 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:1864:2: ( (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject ) )
+            // InternalSolverLanguage.g:1865:2: (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject )
+            {
+            // InternalSolverLanguage.g:1865:2: (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject )
+            int alt31=2;
+            int LA31_0 = input.LA(1);
+            if ( (LA31_0==RULE_ID) ) {
+                alt31=1;
+            }
+            else if ( (LA31_0==RULE_INT||LA31_0==RULE_STRING||LA31_0==11||(LA31_0>=13 && LA31_0<=14)) ) {
+                alt31=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 31, 0, input);
+                throw nvae;
+            }
+            switch (alt31) {
+                case 1 :
+                    // InternalSolverLanguage.g:1866:3: this_Variable_0= ruleVariable
+                    {
+                                        newCompositeNode(grammarAccess.getLiteralAccess().getVariableParserRuleCall_0());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_Variable_0=ruleVariable();
+                    state._fsp--;
+                                        current = this_Variable_0;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:1875:3: this_DataObject_1= ruleDataObject
+                    {
+                                        newCompositeNode(grammarAccess.getLiteralAccess().getDataObjectParserRuleCall_1());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_DataObject_1=ruleDataObject();
+                    state._fsp--;
+                                        current = this_DataObject_1;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleLiteral"
+    // $ANTLR start "entryRuleVariable"
+    // InternalSolverLanguage.g:1887:1: entryRuleVariable returns [EObject current=null] : iv_ruleVariable= ruleVariable EOF ;
+    public final EObject entryRuleVariable() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleVariable = null;
+        try {
+            // InternalSolverLanguage.g:1887:49: (iv_ruleVariable= ruleVariable EOF )
+            // InternalSolverLanguage.g:1888:2: iv_ruleVariable= ruleVariable EOF
+            {
+             newCompositeNode(grammarAccess.getVariableRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleVariable=ruleVariable();
+            state._fsp--;
+             current =iv_ruleVariable; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleVariable"
+    // $ANTLR start "ruleVariable"
+    // InternalSolverLanguage.g:1894:1: ruleVariable returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ;
+    public final EObject ruleVariable() throws RecognitionException {
+        EObject current = null;
+        Token lv_name_0_0=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:1900:2: ( ( (lv_name_0_0= RULE_ID ) ) )
+            // InternalSolverLanguage.g:1901:2: ( (lv_name_0_0= RULE_ID ) )
+            {
+            // InternalSolverLanguage.g:1901:2: ( (lv_name_0_0= RULE_ID ) )
+            // InternalSolverLanguage.g:1902:3: (lv_name_0_0= RULE_ID )
+            {
+            // InternalSolverLanguage.g:1902:3: (lv_name_0_0= RULE_ID )
+            // InternalSolverLanguage.g:1903:4: lv_name_0_0= RULE_ID
+            {
+            lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_2); 
+                                        newLeafNode(lv_name_0_0, grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0());
+                                
+                                        if (current==null) {
+                                                current = createModelElement(grammarAccess.getVariableRule());
+                                        }
+                                        setWithLastConsumed(
+                                                current,
+                                                "name",
+                                                lv_name_0_0,
+                                                "org.eclipse.xtext.common.Terminals.ID");
+                                
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleVariable"
+    // $ANTLR start "entryRuleAllInstances"
+    // InternalSolverLanguage.g:1922:1: entryRuleAllInstances returns [EObject current=null] : iv_ruleAllInstances= ruleAllInstances EOF ;
+    public final EObject entryRuleAllInstances() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleAllInstances = null;
+        try {
+            // InternalSolverLanguage.g:1922:53: (iv_ruleAllInstances= ruleAllInstances EOF )
+            // InternalSolverLanguage.g:1923:2: iv_ruleAllInstances= ruleAllInstances EOF
+            {
+             newCompositeNode(grammarAccess.getAllInstancesRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleAllInstances=ruleAllInstances();
+            state._fsp--;
+             current =iv_ruleAllInstances; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleAllInstances"
+    // $ANTLR start "ruleAllInstances"
+    // InternalSolverLanguage.g:1929:1: ruleAllInstances returns [EObject current=null] : (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) ) ;
+    public final EObject ruleAllInstances() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_0=null;
+        EObject lv_symbol_1_0 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:1935:2: ( (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) ) )
+            // InternalSolverLanguage.g:1936:2: (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) )
+            {
+            // InternalSolverLanguage.g:1936:2: (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) )
+            // InternalSolverLanguage.g:1937:3: otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) )
+            {
+            otherlv_0=(Token)match(input,19,FOLLOW_18); 
+                                newLeafNode(otherlv_0, grammarAccess.getAllInstancesAccess().getColonKeyword_0());
+                        
+            // InternalSolverLanguage.g:1941:3: ( (lv_symbol_1_0= ruleSymbol ) )
+            // InternalSolverLanguage.g:1942:4: (lv_symbol_1_0= ruleSymbol )
+            {
+            // InternalSolverLanguage.g:1942:4: (lv_symbol_1_0= ruleSymbol )
+            // InternalSolverLanguage.g:1943:5: lv_symbol_1_0= ruleSymbol
+            {
+                                                newCompositeNode(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0());
+                                        
+            pushFollow(FOLLOW_2);
+            lv_symbol_1_0=ruleSymbol();
+            state._fsp--;
+                                                if (current==null) {
+                                                        current = createModelElementForParent(grammarAccess.getAllInstancesRule());
+                                                }
+                                                set(
+                                                        current,
+                                                        "symbol",
+                                                        lv_symbol_1_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
+                                                afterParserOrEnumRuleCall();
+                                        
+            }
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleAllInstances"
+    // $ANTLR start "entryRuleAllObjects"
+    // InternalSolverLanguage.g:1964:1: entryRuleAllObjects returns [EObject current=null] : iv_ruleAllObjects= ruleAllObjects EOF ;
+    public final EObject entryRuleAllObjects() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleAllObjects = null;
+        try {
+            // InternalSolverLanguage.g:1964:51: (iv_ruleAllObjects= ruleAllObjects EOF )
+            // InternalSolverLanguage.g:1965:2: iv_ruleAllObjects= ruleAllObjects EOF
+            {
+             newCompositeNode(grammarAccess.getAllObjectsRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleAllObjects=ruleAllObjects();
+            state._fsp--;
+             current =iv_ruleAllObjects; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleAllObjects"
+    // $ANTLR start "ruleAllObjects"
+    // InternalSolverLanguage.g:1971:1: ruleAllObjects returns [EObject current=null] : ( () otherlv_1= '*' ) ;
+    public final EObject ruleAllObjects() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_1=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:1977:2: ( ( () otherlv_1= '*' ) )
+            // InternalSolverLanguage.g:1978:2: ( () otherlv_1= '*' )
+            {
+            // InternalSolverLanguage.g:1978:2: ( () otherlv_1= '*' )
+            // InternalSolverLanguage.g:1979:3: () otherlv_1= '*'
+            {
+            // InternalSolverLanguage.g:1979:3: ()
+            // InternalSolverLanguage.g:1980:4: 
+            {
+                                        current = forceCreateModelElement(
+                                                grammarAccess.getAllObjectsAccess().getAllObjectsAction_0(),
+                                                current);
+                                
+            }
+            otherlv_1=(Token)match(input,30,FOLLOW_2); 
+                                newLeafNode(otherlv_1, grammarAccess.getAllObjectsAccess().getAsteriskKeyword_1());
+                        
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleAllObjects"
+    // $ANTLR start "entryRuleDefaultInterpretation"
+    // InternalSolverLanguage.g:1994:1: entryRuleDefaultInterpretation returns [EObject current=null] : iv_ruleDefaultInterpretation= ruleDefaultInterpretation EOF ;
+    public final EObject entryRuleDefaultInterpretation() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleDefaultInterpretation = null;
+        try {
+            // InternalSolverLanguage.g:1994:62: (iv_ruleDefaultInterpretation= ruleDefaultInterpretation EOF )
+            // InternalSolverLanguage.g:1995:2: iv_ruleDefaultInterpretation= ruleDefaultInterpretation EOF
+            {
+             newCompositeNode(grammarAccess.getDefaultInterpretationRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleDefaultInterpretation=ruleDefaultInterpretation();
+            state._fsp--;
+             current =iv_ruleDefaultInterpretation; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleDefaultInterpretation"
+    // $ANTLR start "ruleDefaultInterpretation"
+    // InternalSolverLanguage.g:2001:1: ruleDefaultInterpretation returns [EObject current=null] : (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) ) ;
+    public final EObject ruleDefaultInterpretation() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_0=null;
+        EObject lv_interpretation_1_0 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:2007:2: ( (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) ) )
+            // InternalSolverLanguage.g:2008:2: (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) )
+            {
+            // InternalSolverLanguage.g:2008:2: (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) )
+            // InternalSolverLanguage.g:2009:3: otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) )
+            {
+            otherlv_0=(Token)match(input,31,FOLLOW_18); 
+                                newLeafNode(otherlv_0, grammarAccess.getDefaultInterpretationAccess().getDefaultKeyword_0());
+                        
+            // InternalSolverLanguage.g:2013:3: ( (lv_interpretation_1_0= ruleBasicInterpretation ) )
+            // InternalSolverLanguage.g:2014:4: (lv_interpretation_1_0= ruleBasicInterpretation )
+            {
+            // InternalSolverLanguage.g:2014:4: (lv_interpretation_1_0= ruleBasicInterpretation )
+            // InternalSolverLanguage.g:2015:5: lv_interpretation_1_0= ruleBasicInterpretation
+            {
+                                                newCompositeNode(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0());
+                                        
+            pushFollow(FOLLOW_2);
+            lv_interpretation_1_0=ruleBasicInterpretation();
+            state._fsp--;
+                                                if (current==null) {
+                                                        current = createModelElementForParent(grammarAccess.getDefaultInterpretationRule());
+                                                }
+                                                set(
+                                                        current,
+                                                        "interpretation",
+                                                        lv_interpretation_1_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.BasicInterpretation");
+                                                afterParserOrEnumRuleCall();
+                                        
+            }
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleDefaultInterpretation"
+    // $ANTLR start "entryRuleCDInterpretation"
+    // InternalSolverLanguage.g:2036:1: entryRuleCDInterpretation returns [EObject current=null] : iv_ruleCDInterpretation= ruleCDInterpretation EOF ;
+    public final EObject entryRuleCDInterpretation() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleCDInterpretation = null;
+        try {
+            // InternalSolverLanguage.g:2036:57: (iv_ruleCDInterpretation= ruleCDInterpretation EOF )
+            // InternalSolverLanguage.g:2037:2: iv_ruleCDInterpretation= ruleCDInterpretation EOF
+            {
+             newCompositeNode(grammarAccess.getCDInterpretationRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleCDInterpretation=ruleCDInterpretation();
+            state._fsp--;
+             current =iv_ruleCDInterpretation; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleCDInterpretation"
+    // $ANTLR start "ruleCDInterpretation"
+    // InternalSolverLanguage.g:2043:1: ruleCDInterpretation returns [EObject current=null] : (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation ) ;
+    public final EObject ruleCDInterpretation() throws RecognitionException {
+        EObject current = null;
+        EObject this_ClassInterpretation_0 = null;
+        EObject this_EnumInterpretation_1 = null;
+        EObject this_GlobalRelationInterpretation_2 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:2049:2: ( (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation ) )
+            // InternalSolverLanguage.g:2050:2: (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation )
+            {
+            // InternalSolverLanguage.g:2050:2: (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation )
+            int alt32=3;
+            switch ( input.LA(1) ) {
+            case 32:
+                {
+                alt32=1;
+                }
+                break;
+            case 37:
+                {
+                alt32=2;
+                }
+                break;
+            case 38:
+                {
+                alt32=3;
+                }
+                break;
+            default:
+                NoViableAltException nvae =
+                    new NoViableAltException("", 32, 0, input);
+                throw nvae;
+            }
+            switch (alt32) {
+                case 1 :
+                    // InternalSolverLanguage.g:2051:3: this_ClassInterpretation_0= ruleClassInterpretation
+                    {
+                                        newCompositeNode(grammarAccess.getCDInterpretationAccess().getClassInterpretationParserRuleCall_0());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_ClassInterpretation_0=ruleClassInterpretation();
+                    state._fsp--;
+                                        current = this_ClassInterpretation_0;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:2060:3: this_EnumInterpretation_1= ruleEnumInterpretation
+                    {
+                                        newCompositeNode(grammarAccess.getCDInterpretationAccess().getEnumInterpretationParserRuleCall_1());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_EnumInterpretation_1=ruleEnumInterpretation();
+                    state._fsp--;
+                                        current = this_EnumInterpretation_1;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+                case 3 :
+                    // InternalSolverLanguage.g:2069:3: this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation
+                    {
+                                        newCompositeNode(grammarAccess.getCDInterpretationAccess().getGlobalRelationInterpretationParserRuleCall_2());
+                                
+                    pushFollow(FOLLOW_2);
+                    this_GlobalRelationInterpretation_2=ruleGlobalRelationInterpretation();
+                    state._fsp--;
+                                        current = this_GlobalRelationInterpretation_2;
+                                        afterParserOrEnumRuleCall();
+                                
+                    }
+                    break;
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleCDInterpretation"
+    // $ANTLR start "entryRuleClassInterpretation"
+    // InternalSolverLanguage.g:2081:1: entryRuleClassInterpretation returns [EObject current=null] : iv_ruleClassInterpretation= ruleClassInterpretation EOF ;
+    public final EObject entryRuleClassInterpretation() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleClassInterpretation = null;
+        try {
+            // InternalSolverLanguage.g:2081:60: (iv_ruleClassInterpretation= ruleClassInterpretation EOF )
+            // InternalSolverLanguage.g:2082:2: iv_ruleClassInterpretation= ruleClassInterpretation EOF
+            {
+             newCompositeNode(grammarAccess.getClassInterpretationRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleClassInterpretation=ruleClassInterpretation();
+            state._fsp--;
+             current =iv_ruleClassInterpretation; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleClassInterpretation"
+    // $ANTLR start "ruleClassInterpretation"
+    // InternalSolverLanguage.g:2088:1: ruleClassInterpretation returns [EObject current=null] : ( ( (lv_abstract_0_0= 'abstract' ) ) otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' ) ;
+    public final EObject ruleClassInterpretation() throws RecognitionException {
+        EObject current = null;
+        Token lv_abstract_0_0=null;
+        Token otherlv_1=null;
+        Token otherlv_3=null;
+        Token otherlv_5=null;
+        Token otherlv_7=null;
+        EObject lv_symbol_2_0 = null;
+        EObject lv_supertypes_4_0 = null;
+        EObject lv_fielt_6_0 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:2094:2: ( ( ( (lv_abstract_0_0= 'abstract' ) ) otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' ) )
+            // InternalSolverLanguage.g:2095:2: ( ( (lv_abstract_0_0= 'abstract' ) ) otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' )
+            {
+            // InternalSolverLanguage.g:2095:2: ( ( (lv_abstract_0_0= 'abstract' ) ) otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' )
+            // InternalSolverLanguage.g:2096:3: ( (lv_abstract_0_0= 'abstract' ) ) otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}'
+            {
+            // InternalSolverLanguage.g:2096:3: ( (lv_abstract_0_0= 'abstract' ) )
+            // InternalSolverLanguage.g:2097:4: (lv_abstract_0_0= 'abstract' )
+            {
+            // InternalSolverLanguage.g:2097:4: (lv_abstract_0_0= 'abstract' )
+            // InternalSolverLanguage.g:2098:5: lv_abstract_0_0= 'abstract'
+            {
+            lv_abstract_0_0=(Token)match(input,32,FOLLOW_24); 
+                                                newLeafNode(lv_abstract_0_0, grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0());
+                                        
+                                                if (current==null) {
+                                                        current = createModelElement(grammarAccess.getClassInterpretationRule());
+                                                }
+                                                setWithLastConsumed(current, "abstract", true, "abstract");
+                                        
+            }
+            }
+            otherlv_1=(Token)match(input,33,FOLLOW_10); 
+                                newLeafNode(otherlv_1, grammarAccess.getClassInterpretationAccess().getClassKeyword_1());
+                        
+            // InternalSolverLanguage.g:2114:3: ( (lv_symbol_2_0= ruleModelSymbol ) )
+            // InternalSolverLanguage.g:2115:4: (lv_symbol_2_0= ruleModelSymbol )
+            {
+            // InternalSolverLanguage.g:2115:4: (lv_symbol_2_0= ruleModelSymbol )
+            // InternalSolverLanguage.g:2116:5: lv_symbol_2_0= ruleModelSymbol
+            {
+                                                newCompositeNode(grammarAccess.getClassInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0());
+                                        
+            pushFollow(FOLLOW_25);
+            lv_symbol_2_0=ruleModelSymbol();
+            state._fsp--;
+                                                if (current==null) {
+                                                        current = createModelElementForParent(grammarAccess.getClassInterpretationRule());
+                                                }
+                                                set(
+                                                        current,
+                                                        "symbol",
+                                                        lv_symbol_2_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
+                                                afterParserOrEnumRuleCall();
+                                        
+            }
+            }
+            // InternalSolverLanguage.g:2133:3: (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )?
+            int alt34=2;
+            int LA34_0 = input.LA(1);
+            if ( (LA34_0==34) ) {
+                alt34=1;
+            }
+            switch (alt34) {
+                case 1 :
+                    // InternalSolverLanguage.g:2134:4: otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+
+                    {
+                    otherlv_3=(Token)match(input,34,FOLLOW_10); 
+                                                newLeafNode(otherlv_3, grammarAccess.getClassInterpretationAccess().getExtendsKeyword_3_0());
+                                        
+                    // InternalSolverLanguage.g:2138:4: ( (lv_supertypes_4_0= ruleModelSymbol ) )+
+                    int cnt33=0;
+                    loop33:
+                    do {
+                        int alt33=2;
+                        int LA33_0 = input.LA(1);
+                        if ( (LA33_0==RULE_ID) ) {
+                            alt33=1;
+                        }
+                        switch (alt33) {
+                        case 1 :
+                            // InternalSolverLanguage.g:2139:5: (lv_supertypes_4_0= ruleModelSymbol )
+                            {
+                            // InternalSolverLanguage.g:2139:5: (lv_supertypes_4_0= ruleModelSymbol )
+                            // InternalSolverLanguage.g:2140:6: lv_supertypes_4_0= ruleModelSymbol
+                            {
+                                                                        newCompositeNode(grammarAccess.getClassInterpretationAccess().getSupertypesModelSymbolParserRuleCall_3_1_0());
+                                                                
+                            pushFollow(FOLLOW_26);
+                            lv_supertypes_4_0=ruleModelSymbol();
+                            state._fsp--;
+                                                                        if (current==null) {
+                                                                                current = createModelElementForParent(grammarAccess.getClassInterpretationRule());
+                                                                        }
+                                                                        add(
+                                                                                current,
+                                                                                "supertypes",
+                                                                                lv_supertypes_4_0,
+                                                                                "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
+                                                                        afterParserOrEnumRuleCall();
+                                                                
+                            }
+                            }
+                            break;
+                        default :
+                            if ( cnt33 >= 1 ) break loop33;
+                                EarlyExitException eee =
+                                    new EarlyExitException(33, input);
+                                throw eee;
+                        }
+                        cnt33++;
+                    } while (true);
+                    }
+                    break;
+            }
+            otherlv_5=(Token)match(input,35,FOLLOW_27); 
+                                newLeafNode(otherlv_5, grammarAccess.getClassInterpretationAccess().getLeftCurlyBracketKeyword_4());
+                        
+            // InternalSolverLanguage.g:2162:3: ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )*
+            loop35:
+            do {
+                int alt35=2;
+                int LA35_0 = input.LA(1);
+                if ( (LA35_0==38) ) {
+                    alt35=1;
+                }
+                switch (alt35) {
+                case 1 :
+                    // InternalSolverLanguage.g:2163:4: (lv_fielt_6_0= ruleFieldRelationInterpretation )
+                    {
+                    // InternalSolverLanguage.g:2163:4: (lv_fielt_6_0= ruleFieldRelationInterpretation )
+                    // InternalSolverLanguage.g:2164:5: lv_fielt_6_0= ruleFieldRelationInterpretation
+                    {
+                                                        newCompositeNode(grammarAccess.getClassInterpretationAccess().getFieltFieldRelationInterpretationParserRuleCall_5_0());
+                                                
+                    pushFollow(FOLLOW_27);
+                    lv_fielt_6_0=ruleFieldRelationInterpretation();
+                    state._fsp--;
+                                                        if (current==null) {
+                                                                current = createModelElementForParent(grammarAccess.getClassInterpretationRule());
+                                                        }
+                                                        add(
+                                                                current,
+                                                                "fielt",
+                                                                lv_fielt_6_0,
+                                                                "org.eclipse.viatra.solver.language.SolverLanguage.FieldRelationInterpretation");
+                                                        afterParserOrEnumRuleCall();
+                                                
+                    }
+                    }
+                    break;
+                default :
+                    break loop35;
+                }
+            } while (true);
+            otherlv_7=(Token)match(input,36,FOLLOW_2); 
+                                newLeafNode(otherlv_7, grammarAccess.getClassInterpretationAccess().getRightCurlyBracketKeyword_6());
+                        
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleClassInterpretation"
+    // $ANTLR start "entryRuleEnumInterpretation"
+    // InternalSolverLanguage.g:2189:1: entryRuleEnumInterpretation returns [EObject current=null] : iv_ruleEnumInterpretation= ruleEnumInterpretation EOF ;
+    public final EObject entryRuleEnumInterpretation() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleEnumInterpretation = null;
+        try {
+            // InternalSolverLanguage.g:2189:59: (iv_ruleEnumInterpretation= ruleEnumInterpretation EOF )
+            // InternalSolverLanguage.g:2190:2: iv_ruleEnumInterpretation= ruleEnumInterpretation EOF
+            {
+             newCompositeNode(grammarAccess.getEnumInterpretationRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleEnumInterpretation=ruleEnumInterpretation();
+            state._fsp--;
+             current =iv_ruleEnumInterpretation; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleEnumInterpretation"
+    // $ANTLR start "ruleEnumInterpretation"
+    // InternalSolverLanguage.g:2196:1: ruleEnumInterpretation returns [EObject current=null] : (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' ) ;
+    public final EObject ruleEnumInterpretation() throws RecognitionException {
+        EObject current = null;
+        Token otherlv_0=null;
+        Token otherlv_2=null;
+        Token otherlv_4=null;
+        EObject lv_Symbol_1_0 = null;
+        EObject lv_objects_3_0 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:2202:2: ( (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' ) )
+            // InternalSolverLanguage.g:2203:2: (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' )
+            {
+            // InternalSolverLanguage.g:2203:2: (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' )
+            // InternalSolverLanguage.g:2204:3: otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}'
+            {
+            otherlv_0=(Token)match(input,37,FOLLOW_10); 
+                                newLeafNode(otherlv_0, grammarAccess.getEnumInterpretationAccess().getEnumKeyword_0());
+                        
+            // InternalSolverLanguage.g:2208:3: ( (lv_Symbol_1_0= ruleModelSymbol ) )
+            // InternalSolverLanguage.g:2209:4: (lv_Symbol_1_0= ruleModelSymbol )
+            {
+            // InternalSolverLanguage.g:2209:4: (lv_Symbol_1_0= ruleModelSymbol )
+            // InternalSolverLanguage.g:2210:5: lv_Symbol_1_0= ruleModelSymbol
+            {
+                                                newCompositeNode(grammarAccess.getEnumInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0());
+                                        
+            pushFollow(FOLLOW_28);
+            lv_Symbol_1_0=ruleModelSymbol();
+            state._fsp--;
+                                                if (current==null) {
+                                                        current = createModelElementForParent(grammarAccess.getEnumInterpretationRule());
+                                                }
+                                                set(
+                                                        current,
+                                                        "Symbol",
+                                                        lv_Symbol_1_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
+                                                afterParserOrEnumRuleCall();
+                                        
+            }
+            }
+            otherlv_2=(Token)match(input,35,FOLLOW_11); 
+                                newLeafNode(otherlv_2, grammarAccess.getEnumInterpretationAccess().getLeftCurlyBracketKeyword_2());
+                        
+            // InternalSolverLanguage.g:2231:3: ( (lv_objects_3_0= ruleNamedObject ) )+
+            int cnt36=0;
+            loop36:
+            do {
+                int alt36=2;
+                int LA36_0 = input.LA(1);
+                if ( (LA36_0==26) ) {
+                    alt36=1;
+                }
+                switch (alt36) {
+                case 1 :
+                    // InternalSolverLanguage.g:2232:4: (lv_objects_3_0= ruleNamedObject )
+                    {
+                    // InternalSolverLanguage.g:2232:4: (lv_objects_3_0= ruleNamedObject )
+                    // InternalSolverLanguage.g:2233:5: lv_objects_3_0= ruleNamedObject
+                    {
+                                                        newCompositeNode(grammarAccess.getEnumInterpretationAccess().getObjectsNamedObjectParserRuleCall_3_0());
+                                                
+                    pushFollow(FOLLOW_29);
+                    lv_objects_3_0=ruleNamedObject();
+                    state._fsp--;
+                                                        if (current==null) {
+                                                                current = createModelElementForParent(grammarAccess.getEnumInterpretationRule());
+                                                        }
+                                                        add(
+                                                                current,
+                                                                "objects",
+                                                                lv_objects_3_0,
+                                                                "org.eclipse.viatra.solver.language.SolverLanguage.NamedObject");
+                                                        afterParserOrEnumRuleCall();
+                                                
+                    }
+                    }
+                    break;
+                default :
+                    if ( cnt36 >= 1 ) break loop36;
+                        EarlyExitException eee =
+                            new EarlyExitException(36, input);
+                        throw eee;
+                }
+                cnt36++;
+            } while (true);
+            otherlv_4=(Token)match(input,36,FOLLOW_2); 
+                                newLeafNode(otherlv_4, grammarAccess.getEnumInterpretationAccess().getRightCurlyBracketKeyword_4());
+                        
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleEnumInterpretation"
+    // $ANTLR start "entryRuleFieldRelationInterpretation"
+    // InternalSolverLanguage.g:2258:1: entryRuleFieldRelationInterpretation returns [EObject current=null] : iv_ruleFieldRelationInterpretation= ruleFieldRelationInterpretation EOF ;
+    public final EObject entryRuleFieldRelationInterpretation() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleFieldRelationInterpretation = null;
+        try {
+            // InternalSolverLanguage.g:2258:68: (iv_ruleFieldRelationInterpretation= ruleFieldRelationInterpretation EOF )
+            // InternalSolverLanguage.g:2259:2: iv_ruleFieldRelationInterpretation= ruleFieldRelationInterpretation EOF
+            {
+             newCompositeNode(grammarAccess.getFieldRelationInterpretationRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleFieldRelationInterpretation=ruleFieldRelationInterpretation();
+            state._fsp--;
+             current =iv_ruleFieldRelationInterpretation; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleFieldRelationInterpretation"
+    // $ANTLR start "ruleFieldRelationInterpretation"
+    // InternalSolverLanguage.g:2265:1: ruleFieldRelationInterpretation returns [EObject current=null] : ( ( (lv_containment_0_0= 'containment' ) ) ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) ) ;
+    public final EObject ruleFieldRelationInterpretation() throws RecognitionException {
+        EObject current = null;
+        Token lv_containment_0_0=null;
+        Token otherlv_2=null;
+        EObject lv_symbol_1_0 = null;
+        EObject lv_multiplicity_3_0 = null;
+        EObject lv_target_4_0 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:2271:2: ( ( ( (lv_containment_0_0= 'containment' ) ) ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) ) )
+            // InternalSolverLanguage.g:2272:2: ( ( (lv_containment_0_0= 'containment' ) ) ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) )
+            {
+            // InternalSolverLanguage.g:2272:2: ( ( (lv_containment_0_0= 'containment' ) ) ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) )
+            // InternalSolverLanguage.g:2273:3: ( (lv_containment_0_0= 'containment' ) ) ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) )
+            {
+            // InternalSolverLanguage.g:2273:3: ( (lv_containment_0_0= 'containment' ) )
+            // InternalSolverLanguage.g:2274:4: (lv_containment_0_0= 'containment' )
+            {
+            // InternalSolverLanguage.g:2274:4: (lv_containment_0_0= 'containment' )
+            // InternalSolverLanguage.g:2275:5: lv_containment_0_0= 'containment'
+            {
+            lv_containment_0_0=(Token)match(input,38,FOLLOW_10); 
+                                                newLeafNode(lv_containment_0_0, grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0());
+                                        
+                                                if (current==null) {
+                                                        current = createModelElement(grammarAccess.getFieldRelationInterpretationRule());
+                                                }
+                                                setWithLastConsumed(current, "containment", true, "containment");
+                                        
+            }
+            }
+            // InternalSolverLanguage.g:2287:3: ( (lv_symbol_1_0= ruleModelSymbol ) )
+            // InternalSolverLanguage.g:2288:4: (lv_symbol_1_0= ruleModelSymbol )
+            {
+            // InternalSolverLanguage.g:2288:4: (lv_symbol_1_0= ruleModelSymbol )
+            // InternalSolverLanguage.g:2289:5: lv_symbol_1_0= ruleModelSymbol
+            {
+                                                newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0());
+                                        
+            pushFollow(FOLLOW_8);
+            lv_symbol_1_0=ruleModelSymbol();
+            state._fsp--;
+                                                if (current==null) {
+                                                        current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule());
+                                                }
+                                                set(
+                                                        current,
+                                                        "symbol",
+                                                        lv_symbol_1_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
+                                                afterParserOrEnumRuleCall();
+                                        
+            }
+            }
+            otherlv_2=(Token)match(input,19,FOLLOW_30); 
+                                newLeafNode(otherlv_2, grammarAccess.getFieldRelationInterpretationAccess().getColonKeyword_2());
+                        
+            // InternalSolverLanguage.g:2310:3: ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )?
+            int alt37=2;
+            int LA37_0 = input.LA(1);
+            if ( (LA37_0==RULE_INT) ) {
+                alt37=1;
+            }
+            switch (alt37) {
+                case 1 :
+                    // InternalSolverLanguage.g:2311:4: (lv_multiplicity_3_0= ruleMultiplicityDefinition )
+                    {
+                    // InternalSolverLanguage.g:2311:4: (lv_multiplicity_3_0= ruleMultiplicityDefinition )
+                    // InternalSolverLanguage.g:2312:5: lv_multiplicity_3_0= ruleMultiplicityDefinition
+                    {
+                                                        newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityMultiplicityDefinitionParserRuleCall_3_0());
+                                                
+                    pushFollow(FOLLOW_18);
+                    lv_multiplicity_3_0=ruleMultiplicityDefinition();
+                    state._fsp--;
+                                                        if (current==null) {
+                                                                current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule());
+                                                        }
+                                                        set(
+                                                                current,
+                                                                "multiplicity",
+                                                                lv_multiplicity_3_0,
+                                                                "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition");
+                                                        afterParserOrEnumRuleCall();
+                                                
+                    }
+                    }
+                    break;
+            }
+            // InternalSolverLanguage.g:2329:3: ( (lv_target_4_0= ruleSymbol ) )
+            // InternalSolverLanguage.g:2330:4: (lv_target_4_0= ruleSymbol )
+            {
+            // InternalSolverLanguage.g:2330:4: (lv_target_4_0= ruleSymbol )
+            // InternalSolverLanguage.g:2331:5: lv_target_4_0= ruleSymbol
+            {
+                                                newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getTargetSymbolParserRuleCall_4_0());
+                                        
+            pushFollow(FOLLOW_2);
+            lv_target_4_0=ruleSymbol();
+            state._fsp--;
+                                                if (current==null) {
+                                                        current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule());
+                                                }
+                                                set(
+                                                        current,
+                                                        "target",
+                                                        lv_target_4_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
+                                                afterParserOrEnumRuleCall();
+                                        
+            }
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleFieldRelationInterpretation"
+    // $ANTLR start "entryRuleGlobalRelationInterpretation"
+    // InternalSolverLanguage.g:2352:1: entryRuleGlobalRelationInterpretation returns [EObject current=null] : iv_ruleGlobalRelationInterpretation= ruleGlobalRelationInterpretation EOF ;
+    public final EObject entryRuleGlobalRelationInterpretation() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleGlobalRelationInterpretation = null;
+        try {
+            // InternalSolverLanguage.g:2352:69: (iv_ruleGlobalRelationInterpretation= ruleGlobalRelationInterpretation EOF )
+            // InternalSolverLanguage.g:2353:2: iv_ruleGlobalRelationInterpretation= ruleGlobalRelationInterpretation EOF
+            {
+             newCompositeNode(grammarAccess.getGlobalRelationInterpretationRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleGlobalRelationInterpretation=ruleGlobalRelationInterpretation();
+            state._fsp--;
+             current =iv_ruleGlobalRelationInterpretation; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleGlobalRelationInterpretation"
+    // $ANTLR start "ruleGlobalRelationInterpretation"
+    // InternalSolverLanguage.g:2359:1: ruleGlobalRelationInterpretation returns [EObject current=null] : ( ( (lv_containment_0_0= 'containment' ) ) otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) ) ;
+    public final EObject ruleGlobalRelationInterpretation() throws RecognitionException {
+        EObject current = null;
+        Token lv_containment_0_0=null;
+        Token otherlv_1=null;
+        Token otherlv_3=null;
+        EObject lv_symbol_2_0 = null;
+        EObject lv_sourceMultiplicity_4_0 = null;
+        EObject lv_source_5_0 = null;
+        EObject lv_targetMultiplicity_6_0 = null;
+        EObject lv_target_7_0 = null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:2365:2: ( ( ( (lv_containment_0_0= 'containment' ) ) otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) ) )
+            // InternalSolverLanguage.g:2366:2: ( ( (lv_containment_0_0= 'containment' ) ) otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) )
+            {
+            // InternalSolverLanguage.g:2366:2: ( ( (lv_containment_0_0= 'containment' ) ) otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) )
+            // InternalSolverLanguage.g:2367:3: ( (lv_containment_0_0= 'containment' ) ) otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) )
+            {
+            // InternalSolverLanguage.g:2367:3: ( (lv_containment_0_0= 'containment' ) )
+            // InternalSolverLanguage.g:2368:4: (lv_containment_0_0= 'containment' )
+            {
+            // InternalSolverLanguage.g:2368:4: (lv_containment_0_0= 'containment' )
+            // InternalSolverLanguage.g:2369:5: lv_containment_0_0= 'containment'
+            {
+            lv_containment_0_0=(Token)match(input,38,FOLLOW_31); 
+                                                newLeafNode(lv_containment_0_0, grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0());
+                                        
+                                                if (current==null) {
+                                                        current = createModelElement(grammarAccess.getGlobalRelationInterpretationRule());
+                                                }
+                                                setWithLastConsumed(current, "containment", true, "containment");
+                                        
+            }
+            }
+            otherlv_1=(Token)match(input,39,FOLLOW_10); 
+                                newLeafNode(otherlv_1, grammarAccess.getGlobalRelationInterpretationAccess().getRelationKeyword_1());
+                        
+            // InternalSolverLanguage.g:2385:3: ( (lv_symbol_2_0= ruleModelSymbol ) )
+            // InternalSolverLanguage.g:2386:4: (lv_symbol_2_0= ruleModelSymbol )
+            {
+            // InternalSolverLanguage.g:2386:4: (lv_symbol_2_0= ruleModelSymbol )
+            // InternalSolverLanguage.g:2387:5: lv_symbol_2_0= ruleModelSymbol
+            {
+                                                newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0());
+                                        
+            pushFollow(FOLLOW_8);
+            lv_symbol_2_0=ruleModelSymbol();
+            state._fsp--;
+                                                if (current==null) {
+                                                        current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule());
+                                                }
+                                                set(
+                                                        current,
+                                                        "symbol",
+                                                        lv_symbol_2_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
+                                                afterParserOrEnumRuleCall();
+                                        
+            }
+            }
+            otherlv_3=(Token)match(input,19,FOLLOW_30); 
+                                newLeafNode(otherlv_3, grammarAccess.getGlobalRelationInterpretationAccess().getColonKeyword_3());
+                        
+            // InternalSolverLanguage.g:2408:3: ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )?
+            int alt38=2;
+            int LA38_0 = input.LA(1);
+            if ( (LA38_0==RULE_INT) ) {
+                alt38=1;
+            }
+            switch (alt38) {
+                case 1 :
+                    // InternalSolverLanguage.g:2409:4: (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition )
+                    {
+                    // InternalSolverLanguage.g:2409:4: (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition )
+                    // InternalSolverLanguage.g:2410:5: lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition
+                    {
+                                                        newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0());
+                                                
+                    pushFollow(FOLLOW_18);
+                    lv_sourceMultiplicity_4_0=ruleMultiplicityDefinition();
+                    state._fsp--;
+                                                        if (current==null) {
+                                                                current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule());
+                                                        }
+                                                        set(
+                                                                current,
+                                                                "sourceMultiplicity",
+                                                                lv_sourceMultiplicity_4_0,
+                                                                "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition");
+                                                        afterParserOrEnumRuleCall();
+                                                
+                    }
+                    }
+                    break;
+            }
+            // InternalSolverLanguage.g:2427:3: ( (lv_source_5_0= ruleSymbol ) )
+            // InternalSolverLanguage.g:2428:4: (lv_source_5_0= ruleSymbol )
+            {
+            // InternalSolverLanguage.g:2428:4: (lv_source_5_0= ruleSymbol )
+            // InternalSolverLanguage.g:2429:5: lv_source_5_0= ruleSymbol
+            {
+                                                newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceSymbolParserRuleCall_5_0());
+                                        
+            pushFollow(FOLLOW_30);
+            lv_source_5_0=ruleSymbol();
+            state._fsp--;
+                                                if (current==null) {
+                                                        current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule());
+                                                }
+                                                set(
+                                                        current,
+                                                        "source",
+                                                        lv_source_5_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
+                                                afterParserOrEnumRuleCall();
+                                        
+            }
+            }
+            // InternalSolverLanguage.g:2446:3: ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )?
+            int alt39=2;
+            int LA39_0 = input.LA(1);
+            if ( (LA39_0==RULE_INT) ) {
+                alt39=1;
+            }
+            switch (alt39) {
+                case 1 :
+                    // InternalSolverLanguage.g:2447:4: (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition )
+                    {
+                    // InternalSolverLanguage.g:2447:4: (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition )
+                    // InternalSolverLanguage.g:2448:5: lv_targetMultiplicity_6_0= ruleMultiplicityDefinition
+                    {
+                                                        newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0());
+                                                
+                    pushFollow(FOLLOW_18);
+                    lv_targetMultiplicity_6_0=ruleMultiplicityDefinition();
+                    state._fsp--;
+                                                        if (current==null) {
+                                                                current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule());
+                                                        }
+                                                        set(
+                                                                current,
+                                                                "targetMultiplicity",
+                                                                lv_targetMultiplicity_6_0,
+                                                                "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition");
+                                                        afterParserOrEnumRuleCall();
+                                                
+                    }
+                    }
+                    break;
+            }
+            // InternalSolverLanguage.g:2465:3: ( (lv_target_7_0= ruleSymbol ) )
+            // InternalSolverLanguage.g:2466:4: (lv_target_7_0= ruleSymbol )
+            {
+            // InternalSolverLanguage.g:2466:4: (lv_target_7_0= ruleSymbol )
+            // InternalSolverLanguage.g:2467:5: lv_target_7_0= ruleSymbol
+            {
+                                                newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetSymbolParserRuleCall_7_0());
+                                        
+            pushFollow(FOLLOW_2);
+            lv_target_7_0=ruleSymbol();
+            state._fsp--;
+                                                if (current==null) {
+                                                        current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule());
+                                                }
+                                                set(
+                                                        current,
+                                                        "target",
+                                                        lv_target_7_0,
+                                                        "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
+                                                afterParserOrEnumRuleCall();
+                                        
+            }
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleGlobalRelationInterpretation"
+    // $ANTLR start "entryRuleMultiplicityDefinition"
+    // InternalSolverLanguage.g:2488:1: entryRuleMultiplicityDefinition returns [EObject current=null] : iv_ruleMultiplicityDefinition= ruleMultiplicityDefinition EOF ;
+    public final EObject entryRuleMultiplicityDefinition() throws RecognitionException {
+        EObject current = null;
+        EObject iv_ruleMultiplicityDefinition = null;
+        try {
+            // InternalSolverLanguage.g:2488:63: (iv_ruleMultiplicityDefinition= ruleMultiplicityDefinition EOF )
+            // InternalSolverLanguage.g:2489:2: iv_ruleMultiplicityDefinition= ruleMultiplicityDefinition EOF
+            {
+             newCompositeNode(grammarAccess.getMultiplicityDefinitionRule()); 
+            pushFollow(FOLLOW_1);
+            iv_ruleMultiplicityDefinition=ruleMultiplicityDefinition();
+            state._fsp--;
+             current =iv_ruleMultiplicityDefinition; 
+            match(input,EOF,FOLLOW_2); 
+            }
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleMultiplicityDefinition"
+    // $ANTLR start "ruleMultiplicityDefinition"
+    // InternalSolverLanguage.g:2495:1: ruleMultiplicityDefinition returns [EObject current=null] : ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) ) ;
+    public final EObject ruleMultiplicityDefinition() throws RecognitionException {
+        EObject current = null;
+        Token lv_lower_0_0=null;
+        Token otherlv_1=null;
+        Token lv_upper_2_0=null;
+        Token lv_unlimitedUpper_3_0=null;
+                enterRule();
+        try {
+            // InternalSolverLanguage.g:2501:2: ( ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) ) )
+            // InternalSolverLanguage.g:2502:2: ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) )
+            {
+            // InternalSolverLanguage.g:2502:2: ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) )
+            // InternalSolverLanguage.g:2503:3: ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) )
+            {
+            // InternalSolverLanguage.g:2503:3: ( (lv_lower_0_0= RULE_INT ) )
+            // InternalSolverLanguage.g:2504:4: (lv_lower_0_0= RULE_INT )
+            {
+            // InternalSolverLanguage.g:2504:4: (lv_lower_0_0= RULE_INT )
+            // InternalSolverLanguage.g:2505:5: lv_lower_0_0= RULE_INT
+            {
+            lv_lower_0_0=(Token)match(input,RULE_INT,FOLLOW_32); 
+                                                newLeafNode(lv_lower_0_0, grammarAccess.getMultiplicityDefinitionAccess().getLowerINTTerminalRuleCall_0_0());
+                                        
+                                                if (current==null) {
+                                                        current = createModelElement(grammarAccess.getMultiplicityDefinitionRule());
+                                                }
+                                                setWithLastConsumed(
+                                                        current,
+                                                        "lower",
+                                                        lv_lower_0_0,
+                                                        "org.eclipse.xtext.common.Terminals.INT");
+                                        
+            }
+            }
+            otherlv_1=(Token)match(input,40,FOLLOW_33); 
+                                newLeafNode(otherlv_1, grammarAccess.getMultiplicityDefinitionAccess().getFullStopFullStopKeyword_1());
+                        
+            // InternalSolverLanguage.g:2525:3: ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) )
+            int alt40=2;
+            int LA40_0 = input.LA(1);
+            if ( (LA40_0==RULE_INT) ) {
+                alt40=1;
+            }
+            else if ( (LA40_0==30) ) {
+                alt40=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 40, 0, input);
+                throw nvae;
+            }
+            switch (alt40) {
+                case 1 :
+                    // InternalSolverLanguage.g:2526:4: ( (lv_upper_2_0= RULE_INT ) )
+                    {
+                    // InternalSolverLanguage.g:2526:4: ( (lv_upper_2_0= RULE_INT ) )
+                    // InternalSolverLanguage.g:2527:5: (lv_upper_2_0= RULE_INT )
+                    {
+                    // InternalSolverLanguage.g:2527:5: (lv_upper_2_0= RULE_INT )
+                    // InternalSolverLanguage.g:2528:6: lv_upper_2_0= RULE_INT
+                    {
+                    lv_upper_2_0=(Token)match(input,RULE_INT,FOLLOW_2); 
+                                                                newLeafNode(lv_upper_2_0, grammarAccess.getMultiplicityDefinitionAccess().getUpperINTTerminalRuleCall_2_0_0());
+                                                        
+                                                                if (current==null) {
+                                                                        current = createModelElement(grammarAccess.getMultiplicityDefinitionRule());
+                                                                }
+                                                                setWithLastConsumed(
+                                                                        current,
+                                                                        "upper",
+                                                                        lv_upper_2_0,
+                                                                        "org.eclipse.xtext.common.Terminals.INT");
+                                                        
+                    }
+                    }
+                    }
+                    break;
+                case 2 :
+                    // InternalSolverLanguage.g:2545:4: ( (lv_unlimitedUpper_3_0= '*' ) )
+                    {
+                    // InternalSolverLanguage.g:2545:4: ( (lv_unlimitedUpper_3_0= '*' ) )
+                    // InternalSolverLanguage.g:2546:5: (lv_unlimitedUpper_3_0= '*' )
+                    {
+                    // InternalSolverLanguage.g:2546:5: (lv_unlimitedUpper_3_0= '*' )
+                    // InternalSolverLanguage.g:2547:6: lv_unlimitedUpper_3_0= '*'
+                    {
+                    lv_unlimitedUpper_3_0=(Token)match(input,30,FOLLOW_2); 
+                                                                newLeafNode(lv_unlimitedUpper_3_0, grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0());
+                                                        
+                                                                if (current==null) {
+                                                                        current = createModelElement(grammarAccess.getMultiplicityDefinitionRule());
+                                                                }
+                                                                setWithLastConsumed(current, "unlimitedUpper", true, "*");
+                                                        
+                    }
+                    }
+                    }
+                    break;
+            }
+            }
+            }
+                leaveRule();
+        }
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleMultiplicityDefinition"
+    // Delegated rules
+ 
+    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[]{0x000000618BF10022L});
+    public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000010L});
+    public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000001000L});
+    public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000020000L});
+    public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x00000000440C6870L});
+    public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000080000L});
+    public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x000000000001E000L});
+    public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000000020L});
+    public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000004000000L});
+    public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000040020L});
+    public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000030007820L});
+    public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000010001000L});
+    public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000030003820L});
+    public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000020020L});
+    public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000080002L});
+    public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000003F00020L});
+    public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000020000822L});
+    public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000060020000L});
+    public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000004046870L});
+    public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000004006870L});
+    public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000040000L});
+    public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000200000000L});
+    public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000C00000000L});
+    public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000800000020L});
+    public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000005000000000L});
+    public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000800000000L});
+    public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000001004000000L});
+    public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000003F00030L});
+    public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000008000000000L});
+    public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000010000000000L});
+    public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000040000010L});
+}
+\ No newline at end of file
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/scoping/AbstractSolverLanguageScopeProvider.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/scoping/AbstractSolverLanguageScopeProvider.java
new file mode 100644
index 00000000..52cb01b5
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/scoping/AbstractSolverLanguageScopeProvider.java
@@ -0,0 +1,9 @@
+/*
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.scoping;
+import org.eclipse.xtext.scoping.impl.DelegatingScopeProvider;
+public abstract class AbstractSolverLanguageScopeProvider extends DelegatingScopeProvider {
+}
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java
new file mode 100644
index 00000000..80f9a02e
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java
@@ -0,0 +1,781 @@
+/*
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.serializer;
+import com.google.inject.Inject;
+import java.util.Set;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
+import org.eclipse.viatra.solver.language.solverLanguage.AllInstances;
+import org.eclipse.viatra.solver.language.solverLanguage.AllObjects;
+import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanObject;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue;
+import org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.Constraint;
+import org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate;
+import org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.False;
+import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.IntObject;
+import org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure;
+import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition;
+import org.eclipse.viatra.solver.language.solverLanguage.NamedObject;
+import org.eclipse.viatra.solver.language.solverLanguage.Negative;
+import org.eclipse.viatra.solver.language.solverLanguage.PatternBody;
+import org.eclipse.viatra.solver.language.solverLanguage.Positive;
+import org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.Problem;
+import org.eclipse.viatra.solver.language.solverLanguage.RealObject;
+import org.eclipse.viatra.solver.language.solverLanguage.RealSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.StringObject;
+import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.True;
+import org.eclipse.viatra.solver.language.solverLanguage.Unknown;
+import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject;
+import org.eclipse.viatra.solver.language.solverLanguage.Variable;
+import org.eclipse.xtext.Action;
+import org.eclipse.xtext.Parameter;
+import org.eclipse.xtext.ParserRule;
+import org.eclipse.xtext.serializer.ISerializationContext;
+import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
+import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
+import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;
+@SuppressWarnings("all")
+public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticSequencer {
+        @Inject
+        private SolverLanguageGrammarAccess grammarAccess;
+        
+        @Override
+        public void sequence(ISerializationContext context, EObject semanticObject) {
+                EPackage epackage = semanticObject.eClass().getEPackage();
+                ParserRule rule = context.getParserRule();
+                Action action = context.getAssignedAction();
+                Set<Parameter> parameters = context.getEnabledBooleanParameters();
+                if (epackage == SolverLanguagePackage.eINSTANCE)
+                        switch (semanticObject.eClass().getClassifierID()) {
+                        case SolverLanguagePackage.ALL_INSTANCES:
+                                sequence_AllInstances(context, (AllInstances) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.ALL_OBJECTS:
+                                sequence_AllObjects(context, (AllObjects) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.BASIC_INTERPRETATION:
+                                sequence_BasicInterpretation(context, (BasicInterpretation) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.BOOLEAN_FALSE:
+                                sequence_BooleanValue(context, (BooleanFalse) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.BOOLEAN_OBJECT:
+                                sequence_BooleanObject(context, (BooleanObject) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.BOOLEAN_SYMBOL:
+                                sequence_BooleanSymbol(context, (BooleanSymbol) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.BOOLEAN_TRUE:
+                                sequence_BooleanValue(context, (BooleanTrue) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.CLASS_INTERPRETATION:
+                                sequence_ClassInterpretation(context, (ClassInterpretation) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.CONSTRAINT:
+                                sequence_Constraint(context, (Constraint) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.DEFAULT_INTERPRETATION:
+                                sequence_DefaultInterpretation(context, (DefaultInterpretation) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.ENUM_INTERPRETATION:
+                                sequence_EnumInterpretation(context, (EnumInterpretation) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.EQUALS_SYMBOL:
+                                sequence_EqualsSymbol(context, (EqualsSymbol) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.ERROR:
+                                sequence_TruthValue(context, (org.eclipse.viatra.solver.language.solverLanguage.Error) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.ERROR_PREDICATE:
+                                sequence_ErrorPredicate(context, (ErrorPredicate) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.EXIST_SYMBOL:
+                                sequence_ExistSymbol(context, (ExistSymbol) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.FALSE:
+                                sequence_TruthValue(context, (False) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION:
+                                sequence_FieldRelationInterpretation(context, (FieldRelationInterpretation) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION:
+                                sequence_GlobalRelationInterpretation(context, (GlobalRelationInterpretation) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.INT_OBJECT:
+                                sequence_IntObject(context, (IntObject) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.INTEGER_SYMBOL:
+                                sequence_IntegerSymbol(context, (IntegerSymbol) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.IRREFLEXIVE_CLOSURE:
+                                sequence_ClosureType(context, (IrreflexiveClosure) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.MODEL_SYMBOL:
+                                sequence_ModelSymbol(context, (ModelSymbol) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.MULTIPLICITY_DEFINITION:
+                                sequence_MultiplicityDefinition(context, (MultiplicityDefinition) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.NAMED_OBJECT:
+                                sequence_NamedObject(context, (NamedObject) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.NEGATIVE:
+                                sequence_Polarity(context, (Negative) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.PARAMETER:
+                                sequence_Parameter(context, (org.eclipse.viatra.solver.language.solverLanguage.Parameter) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.PATTERN_BODY:
+                                sequence_PatternBody(context, (PatternBody) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.POSITIVE:
+                                sequence_Polarity(context, (Positive) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.PREDICATE_SYMBOL:
+                                sequence_PredicateSymbol(context, (PredicateSymbol) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.PROBLEM:
+                                sequence_Problem(context, (Problem) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.REAL_OBJECT:
+                                sequence_RealObject(context, (RealObject) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.REAL_SYMBOL:
+                                sequence_RealSymbol(context, (RealSymbol) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.REFLEXIVE_CLOSURE:
+                                sequence_ClosureType(context, (ReflexiveClosure) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.STRING_OBJECT:
+                                sequence_StringObject(context, (StringObject) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.STRING_SYMBOL:
+                                sequence_StringSymbol(context, (StringSymbol) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.TRUE:
+                                sequence_TruthValue(context, (True) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.UNKNOWN:
+                                sequence_TruthValue(context, (Unknown) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.UNNAMED_OBJECT:
+                                sequence_UnnamedObject(context, (UnnamedObject) semanticObject); 
+                                return; 
+                        case SolverLanguagePackage.VARIABLE:
+                                sequence_Variable(context, (Variable) semanticObject); 
+                                return; 
+                        }
+                if (errorAcceptor != null)
+                        errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
+        }
+        
+        /**
+         * Contexts:
+         *     ComplexObject returns AllInstances
+         *     AllInstances returns AllInstances
+         *
+         * Constraint:
+         *     symbol=Symbol
+         */
+        protected void sequence_AllInstances(ISerializationContext context, AllInstances semanticObject) {
+                if (errorAcceptor != null) {
+                        if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.ALL_INSTANCES__SYMBOL) == ValueTransient.YES)
+                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.ALL_INSTANCES__SYMBOL));
+                }
+                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
+                feeder.accept(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0(), semanticObject.getSymbol());
+                feeder.finish();
+        }
+        
+        
+        /**
+         * Contexts:
+         *     ComplexObject returns AllObjects
+         *     AllObjects returns AllObjects
+         *
+         * Constraint:
+         *     {AllObjects}
+         */
+        protected void sequence_AllObjects(ISerializationContext context, AllObjects semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Statement returns BasicInterpretation
+         *     Interpretation returns BasicInterpretation
+         *     BasicInterpretation returns BasicInterpretation
+         *
+         * Constraint:
+         *     (symbol=Symbol objects+=ComplexObject* value=TruthValue)
+         */
+        protected void sequence_BasicInterpretation(ISerializationContext context, BasicInterpretation semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     ComplexObject returns BooleanObject
+         *     Object returns BooleanObject
+         *     DataObject returns BooleanObject
+         *     BooleanObject returns BooleanObject
+         *     Literal returns BooleanObject
+         *
+         * Constraint:
+         *     value=BooleanValue
+         */
+        protected void sequence_BooleanObject(ISerializationContext context, BooleanObject semanticObject) {
+                if (errorAcceptor != null) {
+                        if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.BOOLEAN_OBJECT__VALUE) == ValueTransient.YES)
+                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.BOOLEAN_OBJECT__VALUE));
+                }
+                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
+                feeder.accept(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0(), semanticObject.getValue());
+                feeder.finish();
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Symbol returns BooleanSymbol
+         *     DataSymbol returns BooleanSymbol
+         *     BooleanSymbol returns BooleanSymbol
+         *
+         * Constraint:
+         *     {BooleanSymbol}
+         */
+        protected void sequence_BooleanSymbol(ISerializationContext context, BooleanSymbol semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     BooleanValue returns BooleanFalse
+         *
+         * Constraint:
+         *     {BooleanFalse}
+         */
+        protected void sequence_BooleanValue(ISerializationContext context, BooleanFalse semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     BooleanValue returns BooleanTrue
+         *
+         * Constraint:
+         *     {BooleanTrue}
+         */
+        protected void sequence_BooleanValue(ISerializationContext context, BooleanTrue semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Statement returns ClassInterpretation
+         *     Interpretation returns ClassInterpretation
+         *     CDInterpretation returns ClassInterpretation
+         *     ClassInterpretation returns ClassInterpretation
+         *
+         * Constraint:
+         *     (abstract?='abstract' symbol=ModelSymbol supertypes+=ModelSymbol* fielt+=FieldRelationInterpretation*)
+         */
+        protected void sequence_ClassInterpretation(ISerializationContext context, ClassInterpretation semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     ClosureType returns IrreflexiveClosure
+         *
+         * Constraint:
+         *     {IrreflexiveClosure}
+         */
+        protected void sequence_ClosureType(ISerializationContext context, IrreflexiveClosure semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     ClosureType returns ReflexiveClosure
+         *
+         * Constraint:
+         *     {ReflexiveClosure}
+         */
+        protected void sequence_ClosureType(ISerializationContext context, ReflexiveClosure semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Constraint returns Constraint
+         *
+         * Constraint:
+         *     (polarity=Polarity? symbol=ModelSymbol (params+=Literal+ | (closureType=ClosureType params+=Literal params+=Literal))?)
+         */
+        protected void sequence_Constraint(ISerializationContext context, Constraint semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Statement returns DefaultInterpretation
+         *     Interpretation returns DefaultInterpretation
+         *     DefaultInterpretation returns DefaultInterpretation
+         *
+         * Constraint:
+         *     interpretation=BasicInterpretation
+         */
+        protected void sequence_DefaultInterpretation(ISerializationContext context, DefaultInterpretation semanticObject) {
+                if (errorAcceptor != null) {
+                        if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.DEFAULT_INTERPRETATION__INTERPRETATION) == ValueTransient.YES)
+                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.DEFAULT_INTERPRETATION__INTERPRETATION));
+                }
+                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
+                feeder.accept(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0(), semanticObject.getInterpretation());
+                feeder.finish();
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Statement returns EnumInterpretation
+         *     Interpretation returns EnumInterpretation
+         *     CDInterpretation returns EnumInterpretation
+         *     EnumInterpretation returns EnumInterpretation
+         *
+         * Constraint:
+         *     (Symbol=ModelSymbol objects+=NamedObject+)
+         */
+        protected void sequence_EnumInterpretation(ISerializationContext context, EnumInterpretation semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Symbol returns EqualsSymbol
+         *     PartialitySymbol returns EqualsSymbol
+         *     EqualsSymbol returns EqualsSymbol
+         *
+         * Constraint:
+         *     {EqualsSymbol}
+         */
+        protected void sequence_EqualsSymbol(ISerializationContext context, EqualsSymbol semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Statement returns ErrorPredicate
+         *     Predicate returns ErrorPredicate
+         *     ErrorPredicate returns ErrorPredicate
+         *
+         * Constraint:
+         *     (name=ID? parameters+=Parameter* (bodies+=PatternBody bodies+=PatternBody*)?)
+         */
+        protected void sequence_ErrorPredicate(ISerializationContext context, ErrorPredicate semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Symbol returns ExistSymbol
+         *     PartialitySymbol returns ExistSymbol
+         *     ExistSymbol returns ExistSymbol
+         *
+         * Constraint:
+         *     {ExistSymbol}
+         */
+        protected void sequence_ExistSymbol(ISerializationContext context, ExistSymbol semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     FieldRelationInterpretation returns FieldRelationInterpretation
+         *
+         * Constraint:
+         *     (containment?='containment' symbol=ModelSymbol multiplicity=MultiplicityDefinition? target=Symbol)
+         */
+        protected void sequence_FieldRelationInterpretation(ISerializationContext context, FieldRelationInterpretation semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Statement returns GlobalRelationInterpretation
+         *     Interpretation returns GlobalRelationInterpretation
+         *     CDInterpretation returns GlobalRelationInterpretation
+         *     GlobalRelationInterpretation returns GlobalRelationInterpretation
+         *
+         * Constraint:
+         *     (
+         *         containment?='containment' 
+         *         symbol=ModelSymbol 
+         *         sourceMultiplicity=MultiplicityDefinition? 
+         *         source=Symbol 
+         *         targetMultiplicity=MultiplicityDefinition? 
+         *         target=Symbol
+         *     )
+         */
+        protected void sequence_GlobalRelationInterpretation(ISerializationContext context, GlobalRelationInterpretation semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     ComplexObject returns IntObject
+         *     Object returns IntObject
+         *     DataObject returns IntObject
+         *     IntObject returns IntObject
+         *     Literal returns IntObject
+         *
+         * Constraint:
+         *     value=INTLiteral
+         */
+        protected void sequence_IntObject(ISerializationContext context, IntObject semanticObject) {
+                if (errorAcceptor != null) {
+                        if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INT_OBJECT__VALUE) == ValueTransient.YES)
+                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INT_OBJECT__VALUE));
+                }
+                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
+                feeder.accept(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0(), semanticObject.getValue());
+                feeder.finish();
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Symbol returns IntegerSymbol
+         *     DataSymbol returns IntegerSymbol
+         *     IntegerSymbol returns IntegerSymbol
+         *
+         * Constraint:
+         *     {IntegerSymbol}
+         */
+        protected void sequence_IntegerSymbol(ISerializationContext context, IntegerSymbol semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Symbol returns ModelSymbol
+         *     ModelSymbol returns ModelSymbol
+         *
+         * Constraint:
+         *     name=ID
+         */
+        protected void sequence_ModelSymbol(ISerializationContext context, ModelSymbol semanticObject) {
+                if (errorAcceptor != null) {
+                        if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.MODEL_SYMBOL__NAME) == ValueTransient.YES)
+                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.MODEL_SYMBOL__NAME));
+                }
+                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
+                feeder.accept(grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
+                feeder.finish();
+        }
+        
+        
+        /**
+         * Contexts:
+         *     MultiplicityDefinition returns MultiplicityDefinition
+         *
+         * Constraint:
+         *     (lower=INT (upper=INT | unlimitedUpper?='*'))
+         */
+        protected void sequence_MultiplicityDefinition(ISerializationContext context, MultiplicityDefinition semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     ComplexObject returns NamedObject
+         *     Object returns NamedObject
+         *     NamedObject returns NamedObject
+         *
+         * Constraint:
+         *     name=ID
+         */
+        protected void sequence_NamedObject(ISerializationContext context, NamedObject semanticObject) {
+                if (errorAcceptor != null) {
+                        if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.NAMED_OBJECT__NAME) == ValueTransient.YES)
+                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.NAMED_OBJECT__NAME));
+                }
+                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
+                feeder.accept(grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
+                feeder.finish();
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Parameter returns Parameter
+         *
+         * Constraint:
+         *     (variable=Variable type=Symbol?)
+         */
+        protected void sequence_Parameter(ISerializationContext context, org.eclipse.viatra.solver.language.solverLanguage.Parameter semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     PatternBody returns PatternBody
+         *
+         * Constraint:
+         *     constraints+=Constraint*
+         */
+        protected void sequence_PatternBody(ISerializationContext context, PatternBody semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Polarity returns Negative
+         *
+         * Constraint:
+         *     {Negative}
+         */
+        protected void sequence_Polarity(ISerializationContext context, Negative semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Polarity returns Positive
+         *
+         * Constraint:
+         *     {Positive}
+         */
+        protected void sequence_Polarity(ISerializationContext context, Positive semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Statement returns PredicateSymbol
+         *     Predicate returns PredicateSymbol
+         *     PredicateSymbol returns PredicateSymbol
+         *
+         * Constraint:
+         *     (symbol=ModelSymbol parameters+=Parameter* (bodies+=PatternBody bodies+=PatternBody*)?)
+         */
+        protected void sequence_PredicateSymbol(ISerializationContext context, PredicateSymbol semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Problem returns Problem
+         *
+         * Constraint:
+         *     statements+=Statement+
+         */
+        protected void sequence_Problem(ISerializationContext context, Problem semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     ComplexObject returns RealObject
+         *     Object returns RealObject
+         *     DataObject returns RealObject
+         *     RealObject returns RealObject
+         *     Literal returns RealObject
+         *
+         * Constraint:
+         *     value=REALLiteral
+         */
+        protected void sequence_RealObject(ISerializationContext context, RealObject semanticObject) {
+                if (errorAcceptor != null) {
+                        if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.REAL_OBJECT__VALUE) == ValueTransient.YES)
+                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.REAL_OBJECT__VALUE));
+                }
+                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
+                feeder.accept(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0(), semanticObject.getValue());
+                feeder.finish();
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Symbol returns RealSymbol
+         *     DataSymbol returns RealSymbol
+         *     RealSymbol returns RealSymbol
+         *
+         * Constraint:
+         *     {RealSymbol}
+         */
+        protected void sequence_RealSymbol(ISerializationContext context, RealSymbol semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     ComplexObject returns StringObject
+         *     Object returns StringObject
+         *     DataObject returns StringObject
+         *     StringObject returns StringObject
+         *     Literal returns StringObject
+         *
+         * Constraint:
+         *     value=STRING
+         */
+        protected void sequence_StringObject(ISerializationContext context, StringObject semanticObject) {
+                if (errorAcceptor != null) {
+                        if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.STRING_OBJECT__VALUE) == ValueTransient.YES)
+                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.STRING_OBJECT__VALUE));
+                }
+                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
+                feeder.accept(grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0(), semanticObject.getValue());
+                feeder.finish();
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Symbol returns StringSymbol
+         *     DataSymbol returns StringSymbol
+         *     StringSymbol returns StringSymbol
+         *
+         * Constraint:
+         *     {StringSymbol}
+         */
+        protected void sequence_StringSymbol(ISerializationContext context, StringSymbol semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     TruthValue returns Error
+         *
+         * Constraint:
+         *     {Error}
+         */
+        protected void sequence_TruthValue(ISerializationContext context, org.eclipse.viatra.solver.language.solverLanguage.Error semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     TruthValue returns False
+         *
+         * Constraint:
+         *     {False}
+         */
+        protected void sequence_TruthValue(ISerializationContext context, False semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     TruthValue returns True
+         *
+         * Constraint:
+         *     {True}
+         */
+        protected void sequence_TruthValue(ISerializationContext context, True semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     TruthValue returns Unknown
+         *
+         * Constraint:
+         *     {Unknown}
+         */
+        protected void sequence_TruthValue(ISerializationContext context, Unknown semanticObject) {
+                genericSequencer.createSequence(context, semanticObject);
+        }
+        
+        
+        /**
+         * Contexts:
+         *     ComplexObject returns UnnamedObject
+         *     Object returns UnnamedObject
+         *     UnnamedObject returns UnnamedObject
+         *
+         * Constraint:
+         *     name=ID
+         */
+        protected void sequence_UnnamedObject(ISerializationContext context, UnnamedObject semanticObject) {
+                if (errorAcceptor != null) {
+                        if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_OBJECT__NAME) == ValueTransient.YES)
+                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_OBJECT__NAME));
+                }
+                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
+                feeder.accept(grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
+                feeder.finish();
+        }
+        
+        
+        /**
+         * Contexts:
+         *     Literal returns Variable
+         *     Variable returns Variable
+         *
+         * Constraint:
+         *     name=ID
+         */
+        protected void sequence_Variable(ISerializationContext context, Variable semanticObject) {
+                if (errorAcceptor != null) {
+                        if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.VARIABLE__NAME) == ValueTransient.YES)
+                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.VARIABLE__NAME));
+                }
+                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
+                feeder.accept(grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
+                feeder.finish();
+        }
+        
+        
+}
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java
new file mode 100644
index 00000000..5145bfac
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java
@@ -0,0 +1,60 @@
+/*
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.serializer;
+import com.google.inject.Inject;
+import java.util.List;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
+import org.eclipse.xtext.IGrammarAccess;
+import org.eclipse.xtext.RuleCall;
+import org.eclipse.xtext.nodemodel.INode;
+import org.eclipse.xtext.serializer.analysis.GrammarAlias.AbstractElementAlias;
+import org.eclipse.xtext.serializer.analysis.GrammarAlias.TokenAlias;
+import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynNavigable;
+import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynTransition;
+import org.eclipse.xtext.serializer.sequencer.AbstractSyntacticSequencer;
+@SuppressWarnings("all")
+public class SolverLanguageSyntacticSequencer extends AbstractSyntacticSequencer {
+        protected SolverLanguageGrammarAccess grammarAccess;
+        protected AbstractElementAlias match_PatternBody_TrueKeyword_1_0_q;
+        
+        @Inject
+        protected void init(IGrammarAccess access) {
+                grammarAccess = (SolverLanguageGrammarAccess) access;
+                match_PatternBody_TrueKeyword_1_0_q = new TokenAlias(false, true, grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0());
+        }
+        
+        @Override
+        protected String getUnassignedRuleCallToken(EObject semanticObject, RuleCall ruleCall, INode node) {
+                return "";
+        }
+        
+        
+        @Override
+        protected void emitUnassignedTokens(EObject semanticObject, ISynTransition transition, INode fromNode, INode toNode) {
+                if (transition.getAmbiguousSyntaxes().isEmpty()) return;
+                List<INode> transitionNodes = collectNodes(fromNode, toNode);
+                for (AbstractElementAlias syntax : transition.getAmbiguousSyntaxes()) {
+                        List<INode> syntaxNodes = getNodesFor(transitionNodes, syntax);
+                        if (match_PatternBody_TrueKeyword_1_0_q.equals(syntax))
+                                emit_PatternBody_TrueKeyword_1_0_q(semanticObject, getLastNavigableState(), syntaxNodes);
+                        else acceptNodes(getLastNavigableState(), syntaxNodes);
+                }
+        }
+        /**
+         * Ambiguous syntax:
+         *     'true'?
+         *
+         * This ambiguous syntax occurs at:
+         *     (rule start) (ambiguity) (rule start)
+         */
+        protected void emit_PatternBody_TrueKeyword_1_0_q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {
+                acceptNodes(transition, nodes);
+        }
+        
+}
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/services/SolverLanguageGrammarAccess.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/services/SolverLanguageGrammarAccess.java
new file mode 100644
index 00000000..fb5ea124
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/services/SolverLanguageGrammarAccess.java
@@ -0,0 +1,2124 @@
+/*
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.services;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.List;
+import org.eclipse.xtext.Action;
+import org.eclipse.xtext.Alternatives;
+import org.eclipse.xtext.Assignment;
+import org.eclipse.xtext.Grammar;
+import org.eclipse.xtext.GrammarUtil;
+import org.eclipse.xtext.Group;
+import org.eclipse.xtext.Keyword;
+import org.eclipse.xtext.ParserRule;
+import org.eclipse.xtext.RuleCall;
+import org.eclipse.xtext.TerminalRule;
+import org.eclipse.xtext.common.services.TerminalsGrammarAccess;
+import org.eclipse.xtext.service.AbstractElementFinder.AbstractGrammarElementFinder;
+import org.eclipse.xtext.service.GrammarProvider;
+@Singleton
+public class SolverLanguageGrammarAccess extends AbstractGrammarElementFinder {
+        
+        public class ProblemElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Problem");
+                private final Assignment cStatementsAssignment = (Assignment)rule.eContents().get(1);
+                private final RuleCall cStatementsStatementParserRuleCall_0 = (RuleCall)cStatementsAssignment.eContents().get(0);
+                
+                //Problem:
+                //      statements+=Statement*;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //statements+=Statement*
+                public Assignment getStatementsAssignment() { return cStatementsAssignment; }
+                
+                //Statement
+                public RuleCall getStatementsStatementParserRuleCall_0() { return cStatementsStatementParserRuleCall_0; }
+        }
+        public class StatementElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Statement");
+                private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+                private final RuleCall cInterpretationParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+                private final RuleCall cPredicateParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+                
+                //Statement:
+                //      Interpretation | Predicate;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //Interpretation | Predicate
+                public Alternatives getAlternatives() { return cAlternatives; }
+                
+                //Interpretation
+                public RuleCall getInterpretationParserRuleCall_0() { return cInterpretationParserRuleCall_0; }
+                
+                //Predicate
+                public RuleCall getPredicateParserRuleCall_1() { return cPredicateParserRuleCall_1; }
+        }
+        public class REALLiteralElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.REALLiteral");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Keyword cHyphenMinusKeyword_0 = (Keyword)cGroup.eContents().get(0);
+                private final RuleCall cINTTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+                private final Keyword cFullStopKeyword_2 = (Keyword)cGroup.eContents().get(2);
+                private final RuleCall cINTTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3);
+                
+                //REALLiteral ecore::EBigDecimal:
+                //      '-'? INT '.' INT;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //'-'? INT '.' INT
+                public Group getGroup() { return cGroup; }
+                
+                //'-'?
+                public Keyword getHyphenMinusKeyword_0() { return cHyphenMinusKeyword_0; }
+                
+                //INT
+                public RuleCall getINTTerminalRuleCall_1() { return cINTTerminalRuleCall_1; }
+                
+                //'.'
+                public Keyword getFullStopKeyword_2() { return cFullStopKeyword_2; }
+                
+                //INT
+                public RuleCall getINTTerminalRuleCall_3() { return cINTTerminalRuleCall_3; }
+        }
+        public class INTLiteralElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.INTLiteral");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Keyword cHyphenMinusKeyword_0 = (Keyword)cGroup.eContents().get(0);
+                private final RuleCall cINTTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+                
+                //INTLiteral ecore::EInt:
+                //      '-'? INT;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //'-'? INT
+                public Group getGroup() { return cGroup; }
+                
+                //'-'?
+                public Keyword getHyphenMinusKeyword_0() { return cHyphenMinusKeyword_0; }
+                
+                //INT
+                public RuleCall getINTTerminalRuleCall_1() { return cINTTerminalRuleCall_1; }
+        }
+        public class BooleanValueElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BooleanValue");
+                private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+                private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0);
+                private final Action cBooleanTrueAction_0_0 = (Action)cGroup_0.eContents().get(0);
+                private final Keyword cTrueKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1);
+                private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1);
+                private final Keyword cFalseKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0);
+                private final Action cBooleanFalseAction_1_1 = (Action)cGroup_1.eContents().get(1);
+                
+                //BooleanValue:
+                //      {BooleanTrue} 'true' | 'false' {BooleanFalse};
+                @Override public ParserRule getRule() { return rule; }
+                
+                //{BooleanTrue} 'true' | 'false' {BooleanFalse}
+                public Alternatives getAlternatives() { return cAlternatives; }
+                
+                //{BooleanTrue} 'true'
+                public Group getGroup_0() { return cGroup_0; }
+                
+                //{BooleanTrue}
+                public Action getBooleanTrueAction_0_0() { return cBooleanTrueAction_0_0; }
+                
+                //'true'
+                public Keyword getTrueKeyword_0_1() { return cTrueKeyword_0_1; }
+                
+                //'false' {BooleanFalse}
+                public Group getGroup_1() { return cGroup_1; }
+                
+                //'false'
+                public Keyword getFalseKeyword_1_0() { return cFalseKeyword_1_0; }
+                
+                //{BooleanFalse}
+                public Action getBooleanFalseAction_1_1() { return cBooleanFalseAction_1_1; }
+        }
+        public class TruthValueElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.TruthValue");
+                private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+                private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0);
+                private final Action cTrueAction_0_0 = (Action)cGroup_0.eContents().get(0);
+                private final Keyword cTrueKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1);
+                private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1);
+                private final Action cFalseAction_1_0 = (Action)cGroup_1.eContents().get(0);
+                private final Keyword cFalseKeyword_1_1 = (Keyword)cGroup_1.eContents().get(1);
+                private final Group cGroup_2 = (Group)cAlternatives.eContents().get(2);
+                private final Action cUnknownAction_2_0 = (Action)cGroup_2.eContents().get(0);
+                private final Keyword cUnknownKeyword_2_1 = (Keyword)cGroup_2.eContents().get(1);
+                private final Group cGroup_3 = (Group)cAlternatives.eContents().get(3);
+                private final Action cErrorAction_3_0 = (Action)cGroup_3.eContents().get(0);
+                private final Keyword cErrorKeyword_3_1 = (Keyword)cGroup_3.eContents().get(1);
+                
+                //TruthValue:
+                //      {True} 'true' | {False} 'false' | {Unknown} 'unknown' | {Error} 'error';
+                @Override public ParserRule getRule() { return rule; }
+                
+                //{True} 'true' | {False} 'false' | {Unknown} 'unknown' | {Error} 'error'
+                public Alternatives getAlternatives() { return cAlternatives; }
+                
+                //{True} 'true'
+                public Group getGroup_0() { return cGroup_0; }
+                
+                //{True}
+                public Action getTrueAction_0_0() { return cTrueAction_0_0; }
+                
+                //'true'
+                public Keyword getTrueKeyword_0_1() { return cTrueKeyword_0_1; }
+                
+                //{False} 'false'
+                public Group getGroup_1() { return cGroup_1; }
+                
+                //{False}
+                public Action getFalseAction_1_0() { return cFalseAction_1_0; }
+                
+                //'false'
+                public Keyword getFalseKeyword_1_1() { return cFalseKeyword_1_1; }
+                
+                //{Unknown} 'unknown'
+                public Group getGroup_2() { return cGroup_2; }
+                
+                //{Unknown}
+                public Action getUnknownAction_2_0() { return cUnknownAction_2_0; }
+                
+                //'unknown'
+                public Keyword getUnknownKeyword_2_1() { return cUnknownKeyword_2_1; }
+                
+                //{Error} 'error'
+                public Group getGroup_3() { return cGroup_3; }
+                
+                //{Error}
+                public Action getErrorAction_3_0() { return cErrorAction_3_0; }
+                
+                //'error'
+                public Keyword getErrorKeyword_3_1() { return cErrorKeyword_3_1; }
+        }
+        public class InterpretationElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Interpretation");
+                private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+                private final RuleCall cBasicInterpretationParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+                private final RuleCall cDefaultInterpretationParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+                private final RuleCall cCDInterpretationParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
+                
+                /////////////////////
+                //// Core grammar
+                // ///////////////////
+                //Interpretation:
+                //      BasicInterpretation | DefaultInterpretation | CDInterpretation;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //BasicInterpretation | DefaultInterpretation | CDInterpretation
+                public Alternatives getAlternatives() { return cAlternatives; }
+                
+                //BasicInterpretation
+                public RuleCall getBasicInterpretationParserRuleCall_0() { return cBasicInterpretationParserRuleCall_0; }
+                
+                //DefaultInterpretation
+                public RuleCall getDefaultInterpretationParserRuleCall_1() { return cDefaultInterpretationParserRuleCall_1; }
+                
+                //CDInterpretation
+                public RuleCall getCDInterpretationParserRuleCall_2() { return cCDInterpretationParserRuleCall_2; }
+        }
+        public class BasicInterpretationElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BasicInterpretation");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Assignment cSymbolAssignment_0 = (Assignment)cGroup.eContents().get(0);
+                private final RuleCall cSymbolSymbolParserRuleCall_0_0 = (RuleCall)cSymbolAssignment_0.eContents().get(0);
+                private final Keyword cLeftParenthesisKeyword_1 = (Keyword)cGroup.eContents().get(1);
+                private final Assignment cObjectsAssignment_2 = (Assignment)cGroup.eContents().get(2);
+                private final RuleCall cObjectsComplexObjectParserRuleCall_2_0 = (RuleCall)cObjectsAssignment_2.eContents().get(0);
+                private final Keyword cRightParenthesisKeyword_3 = (Keyword)cGroup.eContents().get(3);
+                private final Keyword cColonKeyword_4 = (Keyword)cGroup.eContents().get(4);
+                private final Assignment cValueAssignment_5 = (Assignment)cGroup.eContents().get(5);
+                private final RuleCall cValueTruthValueParserRuleCall_5_0 = (RuleCall)cValueAssignment_5.eContents().get(0);
+                
+                //BasicInterpretation:
+                //      symbol=Symbol '(' objects+=ComplexObject* ')' ':' value=TruthValue;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //symbol=Symbol '(' objects+=ComplexObject* ')' ':' value=TruthValue
+                public Group getGroup() { return cGroup; }
+                
+                //symbol=Symbol
+                public Assignment getSymbolAssignment_0() { return cSymbolAssignment_0; }
+                
+                //Symbol
+                public RuleCall getSymbolSymbolParserRuleCall_0_0() { return cSymbolSymbolParserRuleCall_0_0; }
+                
+                //'('
+                public Keyword getLeftParenthesisKeyword_1() { return cLeftParenthesisKeyword_1; }
+                
+                //objects+=ComplexObject*
+                public Assignment getObjectsAssignment_2() { return cObjectsAssignment_2; }
+                
+                //ComplexObject
+                public RuleCall getObjectsComplexObjectParserRuleCall_2_0() { return cObjectsComplexObjectParserRuleCall_2_0; }
+                
+                //')'
+                public Keyword getRightParenthesisKeyword_3() { return cRightParenthesisKeyword_3; }
+                
+                //':'
+                public Keyword getColonKeyword_4() { return cColonKeyword_4; }
+                
+                //value=TruthValue
+                public Assignment getValueAssignment_5() { return cValueAssignment_5; }
+                
+                //TruthValue
+                public RuleCall getValueTruthValueParserRuleCall_5_0() { return cValueTruthValueParserRuleCall_5_0; }
+        }
+        public class SymbolElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Symbol");
+                private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+                private final RuleCall cModelSymbolParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+                private final RuleCall cPartialitySymbolParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+                private final RuleCall cDataSymbolParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
+                
+                //Symbol:
+                //      ModelSymbol | PartialitySymbol | DataSymbol;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //ModelSymbol | PartialitySymbol | DataSymbol
+                public Alternatives getAlternatives() { return cAlternatives; }
+                
+                //ModelSymbol
+                public RuleCall getModelSymbolParserRuleCall_0() { return cModelSymbolParserRuleCall_0; }
+                
+                //PartialitySymbol
+                public RuleCall getPartialitySymbolParserRuleCall_1() { return cPartialitySymbolParserRuleCall_1; }
+                
+                //DataSymbol
+                public RuleCall getDataSymbolParserRuleCall_2() { return cDataSymbolParserRuleCall_2; }
+        }
+        public class ModelSymbolElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol");
+                private final Assignment cNameAssignment = (Assignment)rule.eContents().get(1);
+                private final RuleCall cNameIDTerminalRuleCall_0 = (RuleCall)cNameAssignment.eContents().get(0);
+                
+                //ModelSymbol:
+                //      name=ID;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //name=ID
+                public Assignment getNameAssignment() { return cNameAssignment; }
+                
+                //ID
+                public RuleCall getNameIDTerminalRuleCall_0() { return cNameIDTerminalRuleCall_0; }
+        }
+        public class PartialitySymbolElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.PartialitySymbol");
+                private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+                private final RuleCall cExistSymbolParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+                private final RuleCall cEqualsSymbolParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+                
+                //PartialitySymbol:
+                //      ExistSymbol | EqualsSymbol;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //ExistSymbol | EqualsSymbol
+                public Alternatives getAlternatives() { return cAlternatives; }
+                
+                //ExistSymbol
+                public RuleCall getExistSymbolParserRuleCall_0() { return cExistSymbolParserRuleCall_0; }
+                
+                //EqualsSymbol
+                public RuleCall getEqualsSymbolParserRuleCall_1() { return cEqualsSymbolParserRuleCall_1; }
+        }
+        public class ExistSymbolElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExistSymbol");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Keyword cExistsKeyword_0 = (Keyword)cGroup.eContents().get(0);
+                private final Action cExistSymbolAction_1 = (Action)cGroup.eContents().get(1);
+                
+                //ExistSymbol:
+                //      'exists' {ExistSymbol};
+                @Override public ParserRule getRule() { return rule; }
+                
+                //'exists' {ExistSymbol}
+                public Group getGroup() { return cGroup; }
+                
+                //'exists'
+                public Keyword getExistsKeyword_0() { return cExistsKeyword_0; }
+                
+                //{ExistSymbol}
+                public Action getExistSymbolAction_1() { return cExistSymbolAction_1; }
+        }
+        public class EqualsSymbolElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.EqualsSymbol");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Keyword cEqualsKeyword_0 = (Keyword)cGroup.eContents().get(0);
+                private final Action cEqualsSymbolAction_1 = (Action)cGroup.eContents().get(1);
+                
+                //EqualsSymbol:
+                //      'equals' {EqualsSymbol};
+                @Override public ParserRule getRule() { return rule; }
+                
+                //'equals' {EqualsSymbol}
+                public Group getGroup() { return cGroup; }
+                
+                //'equals'
+                public Keyword getEqualsKeyword_0() { return cEqualsKeyword_0; }
+                
+                //{EqualsSymbol}
+                public Action getEqualsSymbolAction_1() { return cEqualsSymbolAction_1; }
+        }
+        public class DataSymbolElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.DataSymbol");
+                private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+                private final RuleCall cBooleanSymbolParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+                private final RuleCall cIntegerSymbolParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+                private final RuleCall cRealSymbolParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
+                private final RuleCall cStringSymbolParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3);
+                
+                //DataSymbol:
+                //      BooleanSymbol | IntegerSymbol | RealSymbol | StringSymbol;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //BooleanSymbol | IntegerSymbol | RealSymbol | StringSymbol
+                public Alternatives getAlternatives() { return cAlternatives; }
+                
+                //BooleanSymbol
+                public RuleCall getBooleanSymbolParserRuleCall_0() { return cBooleanSymbolParserRuleCall_0; }
+                
+                //IntegerSymbol
+                public RuleCall getIntegerSymbolParserRuleCall_1() { return cIntegerSymbolParserRuleCall_1; }
+                
+                //RealSymbol
+                public RuleCall getRealSymbolParserRuleCall_2() { return cRealSymbolParserRuleCall_2; }
+                
+                //StringSymbol
+                public RuleCall getStringSymbolParserRuleCall_3() { return cStringSymbolParserRuleCall_3; }
+        }
+        public class BooleanSymbolElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BooleanSymbol");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Keyword cBoolKeyword_0 = (Keyword)cGroup.eContents().get(0);
+                private final Action cBooleanSymbolAction_1 = (Action)cGroup.eContents().get(1);
+                
+                //BooleanSymbol:
+                //      'bool' {BooleanSymbol};
+                @Override public ParserRule getRule() { return rule; }
+                
+                //'bool' {BooleanSymbol}
+                public Group getGroup() { return cGroup; }
+                
+                //'bool'
+                public Keyword getBoolKeyword_0() { return cBoolKeyword_0; }
+                
+                //{BooleanSymbol}
+                public Action getBooleanSymbolAction_1() { return cBooleanSymbolAction_1; }
+        }
+        public class IntegerSymbolElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.IntegerSymbol");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Keyword cIntKeyword_0 = (Keyword)cGroup.eContents().get(0);
+                private final Action cIntegerSymbolAction_1 = (Action)cGroup.eContents().get(1);
+                
+                //IntegerSymbol:
+                //      'int' {IntegerSymbol};
+                @Override public ParserRule getRule() { return rule; }
+                
+                //'int' {IntegerSymbol}
+                public Group getGroup() { return cGroup; }
+                
+                //'int'
+                public Keyword getIntKeyword_0() { return cIntKeyword_0; }
+                
+                //{IntegerSymbol}
+                public Action getIntegerSymbolAction_1() { return cIntegerSymbolAction_1; }
+        }
+        public class RealSymbolElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.RealSymbol");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Keyword cRealKeyword_0 = (Keyword)cGroup.eContents().get(0);
+                private final Action cRealSymbolAction_1 = (Action)cGroup.eContents().get(1);
+                
+                //RealSymbol:
+                //      'real' {RealSymbol};
+                @Override public ParserRule getRule() { return rule; }
+                
+                //'real' {RealSymbol}
+                public Group getGroup() { return cGroup; }
+                
+                //'real'
+                public Keyword getRealKeyword_0() { return cRealKeyword_0; }
+                
+                //{RealSymbol}
+                public Action getRealSymbolAction_1() { return cRealSymbolAction_1; }
+        }
+        public class StringSymbolElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.StringSymbol");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Keyword cStringKeyword_0 = (Keyword)cGroup.eContents().get(0);
+                private final Action cStringSymbolAction_1 = (Action)cGroup.eContents().get(1);
+                
+                //StringSymbol:
+                //      'string' {StringSymbol};
+                @Override public ParserRule getRule() { return rule; }
+                
+                //'string' {StringSymbol}
+                public Group getGroup() { return cGroup; }
+                
+                //'string'
+                public Keyword getStringKeyword_0() { return cStringKeyword_0; }
+                
+                //{StringSymbol}
+                public Action getStringSymbolAction_1() { return cStringSymbolAction_1; }
+        }
+        public class ComplexObjectElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ComplexObject");
+                private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+                private final RuleCall cObjectParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+                private final RuleCall cAllInstancesParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+                private final RuleCall cAllObjectsParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
+                
+                //ComplexObject:
+                //      Object | AllInstances | AllObjects;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //Object | AllInstances | AllObjects
+                public Alternatives getAlternatives() { return cAlternatives; }
+                
+                //Object
+                public RuleCall getObjectParserRuleCall_0() { return cObjectParserRuleCall_0; }
+                
+                //AllInstances
+                public RuleCall getAllInstancesParserRuleCall_1() { return cAllInstancesParserRuleCall_1; }
+                
+                //AllObjects
+                public RuleCall getAllObjectsParserRuleCall_2() { return cAllObjectsParserRuleCall_2; }
+        }
+        public class ObjectElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Object");
+                private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+                private final RuleCall cNamedObjectParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+                private final RuleCall cUnnamedObjectParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+                private final RuleCall cDataObjectParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
+                
+                //Object:
+                //      NamedObject | UnnamedObject | DataObject;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //NamedObject | UnnamedObject | DataObject
+                public Alternatives getAlternatives() { return cAlternatives; }
+                
+                //NamedObject
+                public RuleCall getNamedObjectParserRuleCall_0() { return cNamedObjectParserRuleCall_0; }
+                
+                //UnnamedObject
+                public RuleCall getUnnamedObjectParserRuleCall_1() { return cUnnamedObjectParserRuleCall_1; }
+                
+                //DataObject
+                public RuleCall getDataObjectParserRuleCall_2() { return cDataObjectParserRuleCall_2; }
+        }
+        public class NamedObjectElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.NamedObject");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Keyword cApostropheKeyword_0 = (Keyword)cGroup.eContents().get(0);
+                private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1);
+                private final RuleCall cNameIDTerminalRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0);
+                private final Keyword cApostropheKeyword_2 = (Keyword)cGroup.eContents().get(2);
+                
+                //NamedObject:
+                //      "'" name=ID "'";
+                @Override public ParserRule getRule() { return rule; }
+                
+                //"'" name=ID "'"
+                public Group getGroup() { return cGroup; }
+                
+                //"'"
+                public Keyword getApostropheKeyword_0() { return cApostropheKeyword_0; }
+                
+                //name=ID
+                public Assignment getNameAssignment_1() { return cNameAssignment_1; }
+                
+                //ID
+                public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; }
+                
+                //"'"
+                public Keyword getApostropheKeyword_2() { return cApostropheKeyword_2; }
+        }
+        public class UnnamedObjectElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.UnnamedObject");
+                private final Assignment cNameAssignment = (Assignment)rule.eContents().get(1);
+                private final RuleCall cNameIDTerminalRuleCall_0 = (RuleCall)cNameAssignment.eContents().get(0);
+                
+                //UnnamedObject:
+                //      name=ID;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //name=ID
+                public Assignment getNameAssignment() { return cNameAssignment; }
+                
+                //ID
+                public RuleCall getNameIDTerminalRuleCall_0() { return cNameIDTerminalRuleCall_0; }
+        }
+        public class DataObjectElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.DataObject");
+                private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+                private final RuleCall cBooleanObjectParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+                private final RuleCall cIntObjectParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+                private final RuleCall cRealObjectParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
+                private final RuleCall cStringObjectParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3);
+                
+                //DataObject:
+                //      BooleanObject | IntObject | RealObject | StringObject;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //BooleanObject | IntObject | RealObject | StringObject
+                public Alternatives getAlternatives() { return cAlternatives; }
+                
+                //BooleanObject
+                public RuleCall getBooleanObjectParserRuleCall_0() { return cBooleanObjectParserRuleCall_0; }
+                
+                //IntObject
+                public RuleCall getIntObjectParserRuleCall_1() { return cIntObjectParserRuleCall_1; }
+                
+                //RealObject
+                public RuleCall getRealObjectParserRuleCall_2() { return cRealObjectParserRuleCall_2; }
+                
+                //StringObject
+                public RuleCall getStringObjectParserRuleCall_3() { return cStringObjectParserRuleCall_3; }
+        }
+        public class BooleanObjectElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BooleanObject");
+                private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1);
+                private final RuleCall cValueBooleanValueParserRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0);
+                
+                //BooleanObject:
+                //      value=BooleanValue;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //value=BooleanValue
+                public Assignment getValueAssignment() { return cValueAssignment; }
+                
+                //BooleanValue
+                public RuleCall getValueBooleanValueParserRuleCall_0() { return cValueBooleanValueParserRuleCall_0; }
+        }
+        public class IntObjectElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.IntObject");
+                private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1);
+                private final RuleCall cValueINTLiteralParserRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0);
+                
+                //IntObject:
+                //      value=INTLiteral;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //value=INTLiteral
+                public Assignment getValueAssignment() { return cValueAssignment; }
+                
+                //INTLiteral
+                public RuleCall getValueINTLiteralParserRuleCall_0() { return cValueINTLiteralParserRuleCall_0; }
+        }
+        public class RealObjectElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.RealObject");
+                private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1);
+                private final RuleCall cValueREALLiteralParserRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0);
+                
+                //RealObject:
+                //      value=REALLiteral;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //value=REALLiteral
+                public Assignment getValueAssignment() { return cValueAssignment; }
+                
+                //REALLiteral
+                public RuleCall getValueREALLiteralParserRuleCall_0() { return cValueREALLiteralParserRuleCall_0; }
+        }
+        public class StringObjectElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.StringObject");
+                private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1);
+                private final RuleCall cValueSTRINGTerminalRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0);
+                
+                //StringObject:
+                //      value=STRING;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //value=STRING
+                public Assignment getValueAssignment() { return cValueAssignment; }
+                
+                //STRING
+                public RuleCall getValueSTRINGTerminalRuleCall_0() { return cValueSTRINGTerminalRuleCall_0; }
+        }
+        public class PredicateElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Predicate");
+                private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+                private final RuleCall cPredicateSymbolParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+                private final RuleCall cErrorPredicateParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+                
+                /////////////////////
+                //// Predicte grammar
+                /////////////////////
+                //Predicate:
+                //      PredicateSymbol | ErrorPredicate;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //PredicateSymbol | ErrorPredicate
+                public Alternatives getAlternatives() { return cAlternatives; }
+                
+                //PredicateSymbol
+                public RuleCall getPredicateSymbolParserRuleCall_0() { return cPredicateSymbolParserRuleCall_0; }
+                
+                //ErrorPredicate
+                public RuleCall getErrorPredicateParserRuleCall_1() { return cErrorPredicateParserRuleCall_1; }
+        }
+        public class PredicateSymbolElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.PredicateSymbol");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Keyword cPredicateKeyword_0 = (Keyword)cGroup.eContents().get(0);
+                private final Assignment cSymbolAssignment_1 = (Assignment)cGroup.eContents().get(1);
+                private final RuleCall cSymbolModelSymbolParserRuleCall_1_0 = (RuleCall)cSymbolAssignment_1.eContents().get(0);
+                private final Keyword cLeftParenthesisKeyword_2 = (Keyword)cGroup.eContents().get(2);
+                private final Assignment cParametersAssignment_3 = (Assignment)cGroup.eContents().get(3);
+                private final RuleCall cParametersParameterParserRuleCall_3_0 = (RuleCall)cParametersAssignment_3.eContents().get(0);
+                private final Keyword cRightParenthesisKeyword_4 = (Keyword)cGroup.eContents().get(4);
+                private final Keyword cColonKeyword_5 = (Keyword)cGroup.eContents().get(5);
+                private final Alternatives cAlternatives_6 = (Alternatives)cGroup.eContents().get(6);
+                private final Keyword cFalseKeyword_6_0 = (Keyword)cAlternatives_6.eContents().get(0);
+                private final Group cGroup_6_1 = (Group)cAlternatives_6.eContents().get(1);
+                private final Assignment cBodiesAssignment_6_1_0 = (Assignment)cGroup_6_1.eContents().get(0);
+                private final RuleCall cBodiesPatternBodyParserRuleCall_6_1_0_0 = (RuleCall)cBodiesAssignment_6_1_0.eContents().get(0);
+                private final Group cGroup_6_1_1 = (Group)cGroup_6_1.eContents().get(1);
+                private final Keyword cVerticalLineKeyword_6_1_1_0 = (Keyword)cGroup_6_1_1.eContents().get(0);
+                private final Assignment cBodiesAssignment_6_1_1_1 = (Assignment)cGroup_6_1_1.eContents().get(1);
+                private final RuleCall cBodiesPatternBodyParserRuleCall_6_1_1_1_0 = (RuleCall)cBodiesAssignment_6_1_1_1.eContents().get(0);
+                private final Keyword cFullStopKeyword_7 = (Keyword)cGroup.eContents().get(7);
+                
+                //PredicateSymbol:
+                //      'predicate' symbol=ModelSymbol '(' parameters+=Parameter* ')' ':' ('false' | bodies+=PatternBody ('|'
+                //      bodies+=PatternBody)*) '.';
+                @Override public ParserRule getRule() { return rule; }
+                
+                //'predicate' symbol=ModelSymbol '(' parameters+=Parameter* ')' ':' ('false' | bodies+=PatternBody ('|'
+                //bodies+=PatternBody)*) '.'
+                public Group getGroup() { return cGroup; }
+                
+                //'predicate'
+                public Keyword getPredicateKeyword_0() { return cPredicateKeyword_0; }
+                
+                //symbol=ModelSymbol
+                public Assignment getSymbolAssignment_1() { return cSymbolAssignment_1; }
+                
+                //ModelSymbol
+                public RuleCall getSymbolModelSymbolParserRuleCall_1_0() { return cSymbolModelSymbolParserRuleCall_1_0; }
+                
+                //'('
+                public Keyword getLeftParenthesisKeyword_2() { return cLeftParenthesisKeyword_2; }
+                
+                //parameters+=Parameter*
+                public Assignment getParametersAssignment_3() { return cParametersAssignment_3; }
+                
+                //Parameter
+                public RuleCall getParametersParameterParserRuleCall_3_0() { return cParametersParameterParserRuleCall_3_0; }
+                
+                //')'
+                public Keyword getRightParenthesisKeyword_4() { return cRightParenthesisKeyword_4; }
+                
+                //':'
+                public Keyword getColonKeyword_5() { return cColonKeyword_5; }
+                
+                //'false' | bodies+=PatternBody ('|' bodies+=PatternBody)*
+                public Alternatives getAlternatives_6() { return cAlternatives_6; }
+                
+                //'false'
+                public Keyword getFalseKeyword_6_0() { return cFalseKeyword_6_0; }
+                
+                //bodies+=PatternBody ('|' bodies+=PatternBody)*
+                public Group getGroup_6_1() { return cGroup_6_1; }
+                
+                //bodies+=PatternBody
+                public Assignment getBodiesAssignment_6_1_0() { return cBodiesAssignment_6_1_0; }
+                
+                //PatternBody
+                public RuleCall getBodiesPatternBodyParserRuleCall_6_1_0_0() { return cBodiesPatternBodyParserRuleCall_6_1_0_0; }
+                
+                //('|' bodies+=PatternBody)*
+                public Group getGroup_6_1_1() { return cGroup_6_1_1; }
+                
+                //'|'
+                public Keyword getVerticalLineKeyword_6_1_1_0() { return cVerticalLineKeyword_6_1_1_0; }
+                
+                //bodies+=PatternBody
+                public Assignment getBodiesAssignment_6_1_1_1() { return cBodiesAssignment_6_1_1_1; }
+                
+                //PatternBody
+                public RuleCall getBodiesPatternBodyParserRuleCall_6_1_1_1_0() { return cBodiesPatternBodyParserRuleCall_6_1_1_1_0; }
+                
+                //'.'
+                public Keyword getFullStopKeyword_7() { return cFullStopKeyword_7; }
+        }
+        public class ErrorPredicateElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ErrorPredicate");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Action cErrorPredicateAction_0 = (Action)cGroup.eContents().get(0);
+                private final Keyword cErrorKeyword_1 = (Keyword)cGroup.eContents().get(1);
+                private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2);
+                private final RuleCall cNameIDTerminalRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0);
+                private final Group cGroup_3 = (Group)cGroup.eContents().get(3);
+                private final Keyword cLeftParenthesisKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0);
+                private final Assignment cParametersAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1);
+                private final RuleCall cParametersParameterParserRuleCall_3_1_0 = (RuleCall)cParametersAssignment_3_1.eContents().get(0);
+                private final Keyword cRightParenthesisKeyword_3_2 = (Keyword)cGroup_3.eContents().get(2);
+                private final Keyword cColonKeyword_4 = (Keyword)cGroup.eContents().get(4);
+                private final Alternatives cAlternatives_5 = (Alternatives)cGroup.eContents().get(5);
+                private final Keyword cFalseKeyword_5_0 = (Keyword)cAlternatives_5.eContents().get(0);
+                private final Group cGroup_5_1 = (Group)cAlternatives_5.eContents().get(1);
+                private final Assignment cBodiesAssignment_5_1_0 = (Assignment)cGroup_5_1.eContents().get(0);
+                private final RuleCall cBodiesPatternBodyParserRuleCall_5_1_0_0 = (RuleCall)cBodiesAssignment_5_1_0.eContents().get(0);
+                private final Group cGroup_5_1_1 = (Group)cGroup_5_1.eContents().get(1);
+                private final Keyword cVerticalLineKeyword_5_1_1_0 = (Keyword)cGroup_5_1_1.eContents().get(0);
+                private final Assignment cBodiesAssignment_5_1_1_1 = (Assignment)cGroup_5_1_1.eContents().get(1);
+                private final RuleCall cBodiesPatternBodyParserRuleCall_5_1_1_1_0 = (RuleCall)cBodiesAssignment_5_1_1_1.eContents().get(0);
+                private final Keyword cFullStopKeyword_6 = (Keyword)cGroup.eContents().get(6);
+                
+                //ErrorPredicate:
+                //      {ErrorPredicate} 'error' name=ID? ('(' parameters+=Parameter* ')') ':' ('false' | bodies+=PatternBody ('|'
+                //      bodies+=PatternBody)*) '.';
+                @Override public ParserRule getRule() { return rule; }
+                
+                //{ErrorPredicate} 'error' name=ID? ('(' parameters+=Parameter* ')') ':' ('false' | bodies+=PatternBody ('|'
+                //bodies+=PatternBody)*) '.'
+                public Group getGroup() { return cGroup; }
+                
+                //{ErrorPredicate}
+                public Action getErrorPredicateAction_0() { return cErrorPredicateAction_0; }
+                
+                //'error'
+                public Keyword getErrorKeyword_1() { return cErrorKeyword_1; }
+                
+                //name=ID?
+                public Assignment getNameAssignment_2() { return cNameAssignment_2; }
+                
+                //ID
+                public RuleCall getNameIDTerminalRuleCall_2_0() { return cNameIDTerminalRuleCall_2_0; }
+                
+                //'(' parameters+=Parameter* ')'
+                public Group getGroup_3() { return cGroup_3; }
+                
+                //'('
+                public Keyword getLeftParenthesisKeyword_3_0() { return cLeftParenthesisKeyword_3_0; }
+                
+                //parameters+=Parameter*
+                public Assignment getParametersAssignment_3_1() { return cParametersAssignment_3_1; }
+                
+                //Parameter
+                public RuleCall getParametersParameterParserRuleCall_3_1_0() { return cParametersParameterParserRuleCall_3_1_0; }
+                
+                //')'
+                public Keyword getRightParenthesisKeyword_3_2() { return cRightParenthesisKeyword_3_2; }
+                
+                //':'
+                public Keyword getColonKeyword_4() { return cColonKeyword_4; }
+                
+                //'false' | bodies+=PatternBody ('|' bodies+=PatternBody)*
+                public Alternatives getAlternatives_5() { return cAlternatives_5; }
+                
+                //'false'
+                public Keyword getFalseKeyword_5_0() { return cFalseKeyword_5_0; }
+                
+                //bodies+=PatternBody ('|' bodies+=PatternBody)*
+                public Group getGroup_5_1() { return cGroup_5_1; }
+                
+                //bodies+=PatternBody
+                public Assignment getBodiesAssignment_5_1_0() { return cBodiesAssignment_5_1_0; }
+                
+                //PatternBody
+                public RuleCall getBodiesPatternBodyParserRuleCall_5_1_0_0() { return cBodiesPatternBodyParserRuleCall_5_1_0_0; }
+                
+                //('|' bodies+=PatternBody)*
+                public Group getGroup_5_1_1() { return cGroup_5_1_1; }
+                
+                //'|'
+                public Keyword getVerticalLineKeyword_5_1_1_0() { return cVerticalLineKeyword_5_1_1_0; }
+                
+                //bodies+=PatternBody
+                public Assignment getBodiesAssignment_5_1_1_1() { return cBodiesAssignment_5_1_1_1; }
+                
+                //PatternBody
+                public RuleCall getBodiesPatternBodyParserRuleCall_5_1_1_1_0() { return cBodiesPatternBodyParserRuleCall_5_1_1_1_0; }
+                
+                //'.'
+                public Keyword getFullStopKeyword_6() { return cFullStopKeyword_6; }
+        }
+        public class ParameterElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Parameter");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Assignment cVariableAssignment_0 = (Assignment)cGroup.eContents().get(0);
+                private final RuleCall cVariableVariableParserRuleCall_0_0 = (RuleCall)cVariableAssignment_0.eContents().get(0);
+                private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
+                private final Keyword cColonKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0);
+                private final Assignment cTypeAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+                private final RuleCall cTypeSymbolParserRuleCall_1_1_0 = (RuleCall)cTypeAssignment_1_1.eContents().get(0);
+                
+                //Parameter:
+                //      variable=Variable (':' type=Symbol)?;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //variable=Variable (':' type=Symbol)?
+                public Group getGroup() { return cGroup; }
+                
+                //variable=Variable
+                public Assignment getVariableAssignment_0() { return cVariableAssignment_0; }
+                
+                //Variable
+                public RuleCall getVariableVariableParserRuleCall_0_0() { return cVariableVariableParserRuleCall_0_0; }
+                
+                //(':' type=Symbol)?
+                public Group getGroup_1() { return cGroup_1; }
+                
+                //':'
+                public Keyword getColonKeyword_1_0() { return cColonKeyword_1_0; }
+                
+                //type=Symbol
+                public Assignment getTypeAssignment_1_1() { return cTypeAssignment_1_1; }
+                
+                //Symbol
+                public RuleCall getTypeSymbolParserRuleCall_1_1_0() { return cTypeSymbolParserRuleCall_1_1_0; }
+        }
+        public class PatternBodyElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Action cPatternBodyAction_0 = (Action)cGroup.eContents().get(0);
+                private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1);
+                private final Keyword cTrueKeyword_1_0 = (Keyword)cAlternatives_1.eContents().get(0);
+                private final Assignment cConstraintsAssignment_1_1 = (Assignment)cAlternatives_1.eContents().get(1);
+                private final RuleCall cConstraintsConstraintParserRuleCall_1_1_0 = (RuleCall)cConstraintsAssignment_1_1.eContents().get(0);
+                
+                //PatternBody:
+                //      {PatternBody} ('true' | constraints+=Constraint*);
+                @Override public ParserRule getRule() { return rule; }
+                
+                //{PatternBody} ('true' | constraints+=Constraint*)
+                public Group getGroup() { return cGroup; }
+                
+                //{PatternBody}
+                public Action getPatternBodyAction_0() { return cPatternBodyAction_0; }
+                
+                //'true' | constraints+=Constraint*
+                public Alternatives getAlternatives_1() { return cAlternatives_1; }
+                
+                //'true'
+                public Keyword getTrueKeyword_1_0() { return cTrueKeyword_1_0; }
+                
+                //constraints+=Constraint*
+                public Assignment getConstraintsAssignment_1_1() { return cConstraintsAssignment_1_1; }
+                
+                //Constraint
+                public RuleCall getConstraintsConstraintParserRuleCall_1_1_0() { return cConstraintsConstraintParserRuleCall_1_1_0; }
+        }
+        public class PolarityElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Polarity");
+                private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+                private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0);
+                private final Action cPositiveAction_0_0 = (Action)cGroup_0.eContents().get(0);
+                private final Keyword cPlusSignKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1);
+                private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1);
+                private final Action cNegativeAction_1_0 = (Action)cGroup_1.eContents().get(0);
+                private final Keyword cHyphenMinusKeyword_1_1 = (Keyword)cGroup_1.eContents().get(1);
+                
+                //Polarity:
+                //      {Positive} '+' | {Negative} '-';
+                @Override public ParserRule getRule() { return rule; }
+                
+                //{Positive} '+' | {Negative} '-'
+                public Alternatives getAlternatives() { return cAlternatives; }
+                
+                //{Positive} '+'
+                public Group getGroup_0() { return cGroup_0; }
+                
+                //{Positive}
+                public Action getPositiveAction_0_0() { return cPositiveAction_0_0; }
+                
+                //'+'
+                public Keyword getPlusSignKeyword_0_1() { return cPlusSignKeyword_0_1; }
+                
+                //{Negative} '-'
+                public Group getGroup_1() { return cGroup_1; }
+                
+                //{Negative}
+                public Action getNegativeAction_1_0() { return cNegativeAction_1_0; }
+                
+                //'-'
+                public Keyword getHyphenMinusKeyword_1_1() { return cHyphenMinusKeyword_1_1; }
+        }
+        public class ConstraintElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Constraint");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Assignment cPolarityAssignment_0 = (Assignment)cGroup.eContents().get(0);
+                private final RuleCall cPolarityPolarityParserRuleCall_0_0 = (RuleCall)cPolarityAssignment_0.eContents().get(0);
+                private final Assignment cSymbolAssignment_1 = (Assignment)cGroup.eContents().get(1);
+                private final RuleCall cSymbolModelSymbolParserRuleCall_1_0 = (RuleCall)cSymbolAssignment_1.eContents().get(0);
+                private final Alternatives cAlternatives_2 = (Alternatives)cGroup.eContents().get(2);
+                private final Group cGroup_2_0 = (Group)cAlternatives_2.eContents().get(0);
+                private final Keyword cLeftParenthesisKeyword_2_0_0 = (Keyword)cGroup_2_0.eContents().get(0);
+                private final Assignment cParamsAssignment_2_0_1 = (Assignment)cGroup_2_0.eContents().get(1);
+                private final RuleCall cParamsLiteralParserRuleCall_2_0_1_0 = (RuleCall)cParamsAssignment_2_0_1.eContents().get(0);
+                private final Keyword cRightParenthesisKeyword_2_0_2 = (Keyword)cGroup_2_0.eContents().get(2);
+                private final Group cGroup_2_1 = (Group)cAlternatives_2.eContents().get(1);
+                private final Assignment cClosureTypeAssignment_2_1_0 = (Assignment)cGroup_2_1.eContents().get(0);
+                private final RuleCall cClosureTypeClosureTypeParserRuleCall_2_1_0_0 = (RuleCall)cClosureTypeAssignment_2_1_0.eContents().get(0);
+                private final Keyword cLeftParenthesisKeyword_2_1_1 = (Keyword)cGroup_2_1.eContents().get(1);
+                private final Assignment cParamsAssignment_2_1_2 = (Assignment)cGroup_2_1.eContents().get(2);
+                private final RuleCall cParamsLiteralParserRuleCall_2_1_2_0 = (RuleCall)cParamsAssignment_2_1_2.eContents().get(0);
+                private final Assignment cParamsAssignment_2_1_3 = (Assignment)cGroup_2_1.eContents().get(3);
+                private final RuleCall cParamsLiteralParserRuleCall_2_1_3_0 = (RuleCall)cParamsAssignment_2_1_3.eContents().get(0);
+                private final Keyword cRightParenthesisKeyword_2_1_4 = (Keyword)cGroup_2_1.eContents().get(4);
+                
+                //Constraint:
+                //      polarity=Polarity? symbol=ModelSymbol ('(' params+=Literal* ')' | closureType=ClosureType '(' params+=Literal
+                //      params+=Literal ')');
+                @Override public ParserRule getRule() { return rule; }
+                
+                //polarity=Polarity? symbol=ModelSymbol ('(' params+=Literal* ')' | closureType=ClosureType '(' params+=Literal
+                //params+=Literal ')')
+                public Group getGroup() { return cGroup; }
+                
+                //polarity=Polarity?
+                public Assignment getPolarityAssignment_0() { return cPolarityAssignment_0; }
+                
+                //Polarity
+                public RuleCall getPolarityPolarityParserRuleCall_0_0() { return cPolarityPolarityParserRuleCall_0_0; }
+                
+                //symbol=ModelSymbol
+                public Assignment getSymbolAssignment_1() { return cSymbolAssignment_1; }
+                
+                //ModelSymbol
+                public RuleCall getSymbolModelSymbolParserRuleCall_1_0() { return cSymbolModelSymbolParserRuleCall_1_0; }
+                
+                //'(' params+=Literal* ')' | closureType=ClosureType '(' params+=Literal params+=Literal ')'
+                public Alternatives getAlternatives_2() { return cAlternatives_2; }
+                
+                //'(' params+=Literal* ')'
+                public Group getGroup_2_0() { return cGroup_2_0; }
+                
+                //'('
+                public Keyword getLeftParenthesisKeyword_2_0_0() { return cLeftParenthesisKeyword_2_0_0; }
+                
+                //params+=Literal*
+                public Assignment getParamsAssignment_2_0_1() { return cParamsAssignment_2_0_1; }
+                
+                //Literal
+                public RuleCall getParamsLiteralParserRuleCall_2_0_1_0() { return cParamsLiteralParserRuleCall_2_0_1_0; }
+                
+                //')'
+                public Keyword getRightParenthesisKeyword_2_0_2() { return cRightParenthesisKeyword_2_0_2; }
+                
+                //closureType=ClosureType '(' params+=Literal params+=Literal ')'
+                public Group getGroup_2_1() { return cGroup_2_1; }
+                
+                //closureType=ClosureType
+                public Assignment getClosureTypeAssignment_2_1_0() { return cClosureTypeAssignment_2_1_0; }
+                
+                //ClosureType
+                public RuleCall getClosureTypeClosureTypeParserRuleCall_2_1_0_0() { return cClosureTypeClosureTypeParserRuleCall_2_1_0_0; }
+                
+                //'('
+                public Keyword getLeftParenthesisKeyword_2_1_1() { return cLeftParenthesisKeyword_2_1_1; }
+                
+                //params+=Literal
+                public Assignment getParamsAssignment_2_1_2() { return cParamsAssignment_2_1_2; }
+                
+                //Literal
+                public RuleCall getParamsLiteralParserRuleCall_2_1_2_0() { return cParamsLiteralParserRuleCall_2_1_2_0; }
+                
+                //params+=Literal
+                public Assignment getParamsAssignment_2_1_3() { return cParamsAssignment_2_1_3; }
+                
+                //Literal
+                public RuleCall getParamsLiteralParserRuleCall_2_1_3_0() { return cParamsLiteralParserRuleCall_2_1_3_0; }
+                
+                //')'
+                public Keyword getRightParenthesisKeyword_2_1_4() { return cRightParenthesisKeyword_2_1_4; }
+        }
+        public class ClosureTypeElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ClosureType");
+                private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+                private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0);
+                private final Action cReflexiveClosureAction_0_0 = (Action)cGroup_0.eContents().get(0);
+                private final Keyword cAsteriskKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1);
+                private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1);
+                private final Action cIrreflexiveClosureAction_1_0 = (Action)cGroup_1.eContents().get(0);
+                private final Keyword cPlusSignKeyword_1_1 = (Keyword)cGroup_1.eContents().get(1);
+                
+                //ClosureType:
+                //      {ReflexiveClosure} '*' | {IrreflexiveClosure} '+';
+                @Override public ParserRule getRule() { return rule; }
+                
+                //{ReflexiveClosure} '*' | {IrreflexiveClosure} '+'
+                public Alternatives getAlternatives() { return cAlternatives; }
+                
+                //{ReflexiveClosure} '*'
+                public Group getGroup_0() { return cGroup_0; }
+                
+                //{ReflexiveClosure}
+                public Action getReflexiveClosureAction_0_0() { return cReflexiveClosureAction_0_0; }
+                
+                //'*'
+                public Keyword getAsteriskKeyword_0_1() { return cAsteriskKeyword_0_1; }
+                
+                //{IrreflexiveClosure} '+'
+                public Group getGroup_1() { return cGroup_1; }
+                
+                //{IrreflexiveClosure}
+                public Action getIrreflexiveClosureAction_1_0() { return cIrreflexiveClosureAction_1_0; }
+                
+                //'+'
+                public Keyword getPlusSignKeyword_1_1() { return cPlusSignKeyword_1_1; }
+        }
+        public class LiteralElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Literal");
+                private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+                private final RuleCall cVariableParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+                private final RuleCall cDataObjectParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+                
+                //Literal:
+                //      Variable | DataObject;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //Variable | DataObject
+                public Alternatives getAlternatives() { return cAlternatives; }
+                
+                //Variable
+                public RuleCall getVariableParserRuleCall_0() { return cVariableParserRuleCall_0; }
+                
+                //DataObject
+                public RuleCall getDataObjectParserRuleCall_1() { return cDataObjectParserRuleCall_1; }
+        }
+        public class VariableElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Variable");
+                private final Assignment cNameAssignment = (Assignment)rule.eContents().get(1);
+                private final RuleCall cNameIDTerminalRuleCall_0 = (RuleCall)cNameAssignment.eContents().get(0);
+                
+                //Variable:
+                //      name=ID;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //name=ID
+                public Assignment getNameAssignment() { return cNameAssignment; }
+                
+                //ID
+                public RuleCall getNameIDTerminalRuleCall_0() { return cNameIDTerminalRuleCall_0; }
+        }
+        public class AllInstancesElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.AllInstances");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Keyword cColonKeyword_0 = (Keyword)cGroup.eContents().get(0);
+                private final Assignment cSymbolAssignment_1 = (Assignment)cGroup.eContents().get(1);
+                private final RuleCall cSymbolSymbolParserRuleCall_1_0 = (RuleCall)cSymbolAssignment_1.eContents().get(0);
+                
+                /////////////////////
+                //// Complex Interpretation grammar
+                /////////////////////
+                //AllInstances:
+                //      ':' symbol=Symbol;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //':' symbol=Symbol
+                public Group getGroup() { return cGroup; }
+                
+                //':'
+                public Keyword getColonKeyword_0() { return cColonKeyword_0; }
+                
+                //symbol=Symbol
+                public Assignment getSymbolAssignment_1() { return cSymbolAssignment_1; }
+                
+                //Symbol
+                public RuleCall getSymbolSymbolParserRuleCall_1_0() { return cSymbolSymbolParserRuleCall_1_0; }
+        }
+        public class AllObjectsElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.AllObjects");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Action cAllObjectsAction_0 = (Action)cGroup.eContents().get(0);
+                private final Keyword cAsteriskKeyword_1 = (Keyword)cGroup.eContents().get(1);
+                
+                //AllObjects:
+                //      {AllObjects} '*';
+                @Override public ParserRule getRule() { return rule; }
+                
+                //{AllObjects} '*'
+                public Group getGroup() { return cGroup; }
+                
+                //{AllObjects}
+                public Action getAllObjectsAction_0() { return cAllObjectsAction_0; }
+                
+                //'*'
+                public Keyword getAsteriskKeyword_1() { return cAsteriskKeyword_1; }
+        }
+        public class DefaultInterpretationElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.DefaultInterpretation");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Keyword cDefaultKeyword_0 = (Keyword)cGroup.eContents().get(0);
+                private final Assignment cInterpretationAssignment_1 = (Assignment)cGroup.eContents().get(1);
+                private final RuleCall cInterpretationBasicInterpretationParserRuleCall_1_0 = (RuleCall)cInterpretationAssignment_1.eContents().get(0);
+                
+                /////////////////////
+                //// Defaul Interpretation grammar
+                /////////////////////
+                //DefaultInterpretation:
+                //      'default' interpretation=BasicInterpretation;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //'default' interpretation=BasicInterpretation
+                public Group getGroup() { return cGroup; }
+                
+                //'default'
+                public Keyword getDefaultKeyword_0() { return cDefaultKeyword_0; }
+                
+                //interpretation=BasicInterpretation
+                public Assignment getInterpretationAssignment_1() { return cInterpretationAssignment_1; }
+                
+                //BasicInterpretation
+                public RuleCall getInterpretationBasicInterpretationParserRuleCall_1_0() { return cInterpretationBasicInterpretationParserRuleCall_1_0; }
+        }
+        public class CDInterpretationElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.CDInterpretation");
+                private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+                private final RuleCall cClassInterpretationParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+                private final RuleCall cEnumInterpretationParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+                private final RuleCall cGlobalRelationInterpretationParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
+                
+                /////////////////////
+                //// Advanced Class-Diagram interpretations
+                /////////////////////
+                //CDInterpretation:
+                //      ClassInterpretation | EnumInterpretation | GlobalRelationInterpretation;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //ClassInterpretation | EnumInterpretation | GlobalRelationInterpretation
+                public Alternatives getAlternatives() { return cAlternatives; }
+                
+                //ClassInterpretation
+                public RuleCall getClassInterpretationParserRuleCall_0() { return cClassInterpretationParserRuleCall_0; }
+                
+                //EnumInterpretation
+                public RuleCall getEnumInterpretationParserRuleCall_1() { return cEnumInterpretationParserRuleCall_1; }
+                
+                //GlobalRelationInterpretation
+                public RuleCall getGlobalRelationInterpretationParserRuleCall_2() { return cGlobalRelationInterpretationParserRuleCall_2; }
+        }
+        public class ClassInterpretationElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ClassInterpretation");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Assignment cAbstractAssignment_0 = (Assignment)cGroup.eContents().get(0);
+                private final Keyword cAbstractAbstractKeyword_0_0 = (Keyword)cAbstractAssignment_0.eContents().get(0);
+                private final Keyword cClassKeyword_1 = (Keyword)cGroup.eContents().get(1);
+                private final Assignment cSymbolAssignment_2 = (Assignment)cGroup.eContents().get(2);
+                private final RuleCall cSymbolModelSymbolParserRuleCall_2_0 = (RuleCall)cSymbolAssignment_2.eContents().get(0);
+                private final Group cGroup_3 = (Group)cGroup.eContents().get(3);
+                private final Keyword cExtendsKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0);
+                private final Assignment cSupertypesAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1);
+                private final RuleCall cSupertypesModelSymbolParserRuleCall_3_1_0 = (RuleCall)cSupertypesAssignment_3_1.eContents().get(0);
+                private final Keyword cLeftCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4);
+                private final Assignment cFieltAssignment_5 = (Assignment)cGroup.eContents().get(5);
+                private final RuleCall cFieltFieldRelationInterpretationParserRuleCall_5_0 = (RuleCall)cFieltAssignment_5.eContents().get(0);
+                private final Keyword cRightCurlyBracketKeyword_6 = (Keyword)cGroup.eContents().get(6);
+                
+                //ClassInterpretation:
+                //      abstract?='abstract' 'class' symbol=ModelSymbol ('extends' supertypes+=ModelSymbol+)? '{'
+                //      fielt+=FieldRelationInterpretation*
+                //      '}';
+                @Override public ParserRule getRule() { return rule; }
+                
+                //abstract?='abstract' 'class' symbol=ModelSymbol ('extends' supertypes+=ModelSymbol+)? '{'
+                //fielt+=FieldRelationInterpretation* '}'
+                public Group getGroup() { return cGroup; }
+                
+                //abstract?='abstract'
+                public Assignment getAbstractAssignment_0() { return cAbstractAssignment_0; }
+                
+                //'abstract'
+                public Keyword getAbstractAbstractKeyword_0_0() { return cAbstractAbstractKeyword_0_0; }
+                
+                //'class'
+                public Keyword getClassKeyword_1() { return cClassKeyword_1; }
+                
+                //symbol=ModelSymbol
+                public Assignment getSymbolAssignment_2() { return cSymbolAssignment_2; }
+                
+                //ModelSymbol
+                public RuleCall getSymbolModelSymbolParserRuleCall_2_0() { return cSymbolModelSymbolParserRuleCall_2_0; }
+                
+                //('extends' supertypes+=ModelSymbol+)?
+                public Group getGroup_3() { return cGroup_3; }
+                
+                //'extends'
+                public Keyword getExtendsKeyword_3_0() { return cExtendsKeyword_3_0; }
+                
+                //supertypes+=ModelSymbol+
+                public Assignment getSupertypesAssignment_3_1() { return cSupertypesAssignment_3_1; }
+                
+                //ModelSymbol
+                public RuleCall getSupertypesModelSymbolParserRuleCall_3_1_0() { return cSupertypesModelSymbolParserRuleCall_3_1_0; }
+                
+                //'{'
+                public Keyword getLeftCurlyBracketKeyword_4() { return cLeftCurlyBracketKeyword_4; }
+                
+                //fielt+=FieldRelationInterpretation*
+                public Assignment getFieltAssignment_5() { return cFieltAssignment_5; }
+                
+                //FieldRelationInterpretation
+                public RuleCall getFieltFieldRelationInterpretationParserRuleCall_5_0() { return cFieltFieldRelationInterpretationParserRuleCall_5_0; }
+                
+                //'}'
+                public Keyword getRightCurlyBracketKeyword_6() { return cRightCurlyBracketKeyword_6; }
+        }
+        public class EnumInterpretationElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.EnumInterpretation");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Keyword cEnumKeyword_0 = (Keyword)cGroup.eContents().get(0);
+                private final Assignment cSymbolAssignment_1 = (Assignment)cGroup.eContents().get(1);
+                private final RuleCall cSymbolModelSymbolParserRuleCall_1_0 = (RuleCall)cSymbolAssignment_1.eContents().get(0);
+                private final Keyword cLeftCurlyBracketKeyword_2 = (Keyword)cGroup.eContents().get(2);
+                private final Assignment cObjectsAssignment_3 = (Assignment)cGroup.eContents().get(3);
+                private final RuleCall cObjectsNamedObjectParserRuleCall_3_0 = (RuleCall)cObjectsAssignment_3.eContents().get(0);
+                private final Keyword cRightCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4);
+                
+                //EnumInterpretation:
+                //      'enum' Symbol=ModelSymbol '{' objects+=NamedObject+ '}';
+                @Override public ParserRule getRule() { return rule; }
+                
+                //'enum' Symbol=ModelSymbol '{' objects+=NamedObject+ '}'
+                public Group getGroup() { return cGroup; }
+                
+                //'enum'
+                public Keyword getEnumKeyword_0() { return cEnumKeyword_0; }
+                
+                //Symbol=ModelSymbol
+                public Assignment getSymbolAssignment_1() { return cSymbolAssignment_1; }
+                
+                //ModelSymbol
+                public RuleCall getSymbolModelSymbolParserRuleCall_1_0() { return cSymbolModelSymbolParserRuleCall_1_0; }
+                
+                //'{'
+                public Keyword getLeftCurlyBracketKeyword_2() { return cLeftCurlyBracketKeyword_2; }
+                
+                //objects+=NamedObject+
+                public Assignment getObjectsAssignment_3() { return cObjectsAssignment_3; }
+                
+                //NamedObject
+                public RuleCall getObjectsNamedObjectParserRuleCall_3_0() { return cObjectsNamedObjectParserRuleCall_3_0; }
+                
+                //'}'
+                public Keyword getRightCurlyBracketKeyword_4() { return cRightCurlyBracketKeyword_4; }
+        }
+        public class FieldRelationInterpretationElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.FieldRelationInterpretation");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Assignment cContainmentAssignment_0 = (Assignment)cGroup.eContents().get(0);
+                private final Keyword cContainmentContainmentKeyword_0_0 = (Keyword)cContainmentAssignment_0.eContents().get(0);
+                private final Assignment cSymbolAssignment_1 = (Assignment)cGroup.eContents().get(1);
+                private final RuleCall cSymbolModelSymbolParserRuleCall_1_0 = (RuleCall)cSymbolAssignment_1.eContents().get(0);
+                private final Keyword cColonKeyword_2 = (Keyword)cGroup.eContents().get(2);
+                private final Assignment cMultiplicityAssignment_3 = (Assignment)cGroup.eContents().get(3);
+                private final RuleCall cMultiplicityMultiplicityDefinitionParserRuleCall_3_0 = (RuleCall)cMultiplicityAssignment_3.eContents().get(0);
+                private final Assignment cTargetAssignment_4 = (Assignment)cGroup.eContents().get(4);
+                private final RuleCall cTargetSymbolParserRuleCall_4_0 = (RuleCall)cTargetAssignment_4.eContents().get(0);
+                
+                //FieldRelationInterpretation:
+                //      containment?='containment' symbol=ModelSymbol ':' multiplicity=MultiplicityDefinition? target=Symbol;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //containment?='containment' symbol=ModelSymbol ':' multiplicity=MultiplicityDefinition? target=Symbol
+                public Group getGroup() { return cGroup; }
+                
+                //containment?='containment'
+                public Assignment getContainmentAssignment_0() { return cContainmentAssignment_0; }
+                
+                //'containment'
+                public Keyword getContainmentContainmentKeyword_0_0() { return cContainmentContainmentKeyword_0_0; }
+                
+                //symbol=ModelSymbol
+                public Assignment getSymbolAssignment_1() { return cSymbolAssignment_1; }
+                
+                //ModelSymbol
+                public RuleCall getSymbolModelSymbolParserRuleCall_1_0() { return cSymbolModelSymbolParserRuleCall_1_0; }
+                
+                //':'
+                public Keyword getColonKeyword_2() { return cColonKeyword_2; }
+                
+                //multiplicity=MultiplicityDefinition?
+                public Assignment getMultiplicityAssignment_3() { return cMultiplicityAssignment_3; }
+                
+                //MultiplicityDefinition
+                public RuleCall getMultiplicityMultiplicityDefinitionParserRuleCall_3_0() { return cMultiplicityMultiplicityDefinitionParserRuleCall_3_0; }
+                
+                //target=Symbol
+                public Assignment getTargetAssignment_4() { return cTargetAssignment_4; }
+                
+                //Symbol
+                public RuleCall getTargetSymbolParserRuleCall_4_0() { return cTargetSymbolParserRuleCall_4_0; }
+        }
+        public class GlobalRelationInterpretationElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.GlobalRelationInterpretation");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Assignment cContainmentAssignment_0 = (Assignment)cGroup.eContents().get(0);
+                private final Keyword cContainmentContainmentKeyword_0_0 = (Keyword)cContainmentAssignment_0.eContents().get(0);
+                private final Keyword cRelationKeyword_1 = (Keyword)cGroup.eContents().get(1);
+                private final Assignment cSymbolAssignment_2 = (Assignment)cGroup.eContents().get(2);
+                private final RuleCall cSymbolModelSymbolParserRuleCall_2_0 = (RuleCall)cSymbolAssignment_2.eContents().get(0);
+                private final Keyword cColonKeyword_3 = (Keyword)cGroup.eContents().get(3);
+                private final Assignment cSourceMultiplicityAssignment_4 = (Assignment)cGroup.eContents().get(4);
+                private final RuleCall cSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0 = (RuleCall)cSourceMultiplicityAssignment_4.eContents().get(0);
+                private final Assignment cSourceAssignment_5 = (Assignment)cGroup.eContents().get(5);
+                private final RuleCall cSourceSymbolParserRuleCall_5_0 = (RuleCall)cSourceAssignment_5.eContents().get(0);
+                private final Assignment cTargetMultiplicityAssignment_6 = (Assignment)cGroup.eContents().get(6);
+                private final RuleCall cTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0 = (RuleCall)cTargetMultiplicityAssignment_6.eContents().get(0);
+                private final Assignment cTargetAssignment_7 = (Assignment)cGroup.eContents().get(7);
+                private final RuleCall cTargetSymbolParserRuleCall_7_0 = (RuleCall)cTargetAssignment_7.eContents().get(0);
+                
+                //GlobalRelationInterpretation:
+                //      containment?='containment' 'relation' symbol=ModelSymbol ':' sourceMultiplicity=MultiplicityDefinition? source=Symbol
+                //      targetMultiplicity=MultiplicityDefinition? target=Symbol;
+                @Override public ParserRule getRule() { return rule; }
+                
+                //containment?='containment' 'relation' symbol=ModelSymbol ':' sourceMultiplicity=MultiplicityDefinition? source=Symbol
+                //targetMultiplicity=MultiplicityDefinition? target=Symbol
+                public Group getGroup() { return cGroup; }
+                
+                //containment?='containment'
+                public Assignment getContainmentAssignment_0() { return cContainmentAssignment_0; }
+                
+                //'containment'
+                public Keyword getContainmentContainmentKeyword_0_0() { return cContainmentContainmentKeyword_0_0; }
+                
+                //'relation'
+                public Keyword getRelationKeyword_1() { return cRelationKeyword_1; }
+                
+                //symbol=ModelSymbol
+                public Assignment getSymbolAssignment_2() { return cSymbolAssignment_2; }
+                
+                //ModelSymbol
+                public RuleCall getSymbolModelSymbolParserRuleCall_2_0() { return cSymbolModelSymbolParserRuleCall_2_0; }
+                
+                //':'
+                public Keyword getColonKeyword_3() { return cColonKeyword_3; }
+                
+                //sourceMultiplicity=MultiplicityDefinition?
+                public Assignment getSourceMultiplicityAssignment_4() { return cSourceMultiplicityAssignment_4; }
+                
+                //MultiplicityDefinition
+                public RuleCall getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0() { return cSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0; }
+                
+                //source=Symbol
+                public Assignment getSourceAssignment_5() { return cSourceAssignment_5; }
+                
+                //Symbol
+                public RuleCall getSourceSymbolParserRuleCall_5_0() { return cSourceSymbolParserRuleCall_5_0; }
+                
+                //targetMultiplicity=MultiplicityDefinition?
+                public Assignment getTargetMultiplicityAssignment_6() { return cTargetMultiplicityAssignment_6; }
+                
+                //MultiplicityDefinition
+                public RuleCall getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0() { return cTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0; }
+                
+                //target=Symbol
+                public Assignment getTargetAssignment_7() { return cTargetAssignment_7; }
+                
+                //Symbol
+                public RuleCall getTargetSymbolParserRuleCall_7_0() { return cTargetSymbolParserRuleCall_7_0; }
+        }
+        public class MultiplicityDefinitionElements extends AbstractParserRuleElementFinder {
+                private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition");
+                private final Group cGroup = (Group)rule.eContents().get(1);
+                private final Assignment cLowerAssignment_0 = (Assignment)cGroup.eContents().get(0);
+                private final RuleCall cLowerINTTerminalRuleCall_0_0 = (RuleCall)cLowerAssignment_0.eContents().get(0);
+                private final Keyword cFullStopFullStopKeyword_1 = (Keyword)cGroup.eContents().get(1);
+                private final Alternatives cAlternatives_2 = (Alternatives)cGroup.eContents().get(2);
+                private final Assignment cUpperAssignment_2_0 = (Assignment)cAlternatives_2.eContents().get(0);
+                private final RuleCall cUpperINTTerminalRuleCall_2_0_0 = (RuleCall)cUpperAssignment_2_0.eContents().get(0);
+                private final Assignment cUnlimitedUpperAssignment_2_1 = (Assignment)cAlternatives_2.eContents().get(1);
+                private final Keyword cUnlimitedUpperAsteriskKeyword_2_1_0 = (Keyword)cUnlimitedUpperAssignment_2_1.eContents().get(0);
+                
+                //MultiplicityDefinition:
+                //      lower=INT '..' (upper=INT | unlimitedUpper?='*');
+                @Override public ParserRule getRule() { return rule; }
+                
+                //lower=INT '..' (upper=INT | unlimitedUpper?='*')
+                public Group getGroup() { return cGroup; }
+                
+                //lower=INT
+                public Assignment getLowerAssignment_0() { return cLowerAssignment_0; }
+                
+                //INT
+                public RuleCall getLowerINTTerminalRuleCall_0_0() { return cLowerINTTerminalRuleCall_0_0; }
+                
+                //'..'
+                public Keyword getFullStopFullStopKeyword_1() { return cFullStopFullStopKeyword_1; }
+                
+                //upper=INT | unlimitedUpper?='*'
+                public Alternatives getAlternatives_2() { return cAlternatives_2; }
+                
+                //upper=INT
+                public Assignment getUpperAssignment_2_0() { return cUpperAssignment_2_0; }
+                
+                //INT
+                public RuleCall getUpperINTTerminalRuleCall_2_0_0() { return cUpperINTTerminalRuleCall_2_0_0; }
+                
+                //unlimitedUpper?='*'
+                public Assignment getUnlimitedUpperAssignment_2_1() { return cUnlimitedUpperAssignment_2_1; }
+                
+                //'*'
+                public Keyword getUnlimitedUpperAsteriskKeyword_2_1_0() { return cUnlimitedUpperAsteriskKeyword_2_1_0; }
+        }
+        
+        
+        private final ProblemElements pProblem;
+        private final StatementElements pStatement;
+        private final TerminalRule tSTRING;
+        private final REALLiteralElements pREALLiteral;
+        private final INTLiteralElements pINTLiteral;
+        private final BooleanValueElements pBooleanValue;
+        private final TruthValueElements pTruthValue;
+        private final InterpretationElements pInterpretation;
+        private final BasicInterpretationElements pBasicInterpretation;
+        private final SymbolElements pSymbol;
+        private final ModelSymbolElements pModelSymbol;
+        private final PartialitySymbolElements pPartialitySymbol;
+        private final ExistSymbolElements pExistSymbol;
+        private final EqualsSymbolElements pEqualsSymbol;
+        private final DataSymbolElements pDataSymbol;
+        private final BooleanSymbolElements pBooleanSymbol;
+        private final IntegerSymbolElements pIntegerSymbol;
+        private final RealSymbolElements pRealSymbol;
+        private final StringSymbolElements pStringSymbol;
+        private final ComplexObjectElements pComplexObject;
+        private final ObjectElements pObject;
+        private final NamedObjectElements pNamedObject;
+        private final UnnamedObjectElements pUnnamedObject;
+        private final DataObjectElements pDataObject;
+        private final BooleanObjectElements pBooleanObject;
+        private final IntObjectElements pIntObject;
+        private final RealObjectElements pRealObject;
+        private final StringObjectElements pStringObject;
+        private final PredicateElements pPredicate;
+        private final PredicateSymbolElements pPredicateSymbol;
+        private final ErrorPredicateElements pErrorPredicate;
+        private final ParameterElements pParameter;
+        private final PatternBodyElements pPatternBody;
+        private final PolarityElements pPolarity;
+        private final ConstraintElements pConstraint;
+        private final ClosureTypeElements pClosureType;
+        private final LiteralElements pLiteral;
+        private final VariableElements pVariable;
+        private final AllInstancesElements pAllInstances;
+        private final AllObjectsElements pAllObjects;
+        private final DefaultInterpretationElements pDefaultInterpretation;
+        private final CDInterpretationElements pCDInterpretation;
+        private final ClassInterpretationElements pClassInterpretation;
+        private final EnumInterpretationElements pEnumInterpretation;
+        private final FieldRelationInterpretationElements pFieldRelationInterpretation;
+        private final GlobalRelationInterpretationElements pGlobalRelationInterpretation;
+        private final MultiplicityDefinitionElements pMultiplicityDefinition;
+        
+        private final Grammar grammar;
+        
+        private final TerminalsGrammarAccess gaTerminals;
+        @Inject
+        public SolverLanguageGrammarAccess(GrammarProvider grammarProvider,
+                        TerminalsGrammarAccess gaTerminals) {
+                this.grammar = internalFindGrammar(grammarProvider);
+                this.gaTerminals = gaTerminals;
+                this.pProblem = new ProblemElements();
+                this.pStatement = new StatementElements();
+                this.tSTRING = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.STRING");
+                this.pREALLiteral = new REALLiteralElements();
+                this.pINTLiteral = new INTLiteralElements();
+                this.pBooleanValue = new BooleanValueElements();
+                this.pTruthValue = new TruthValueElements();
+                this.pInterpretation = new InterpretationElements();
+                this.pBasicInterpretation = new BasicInterpretationElements();
+                this.pSymbol = new SymbolElements();
+                this.pModelSymbol = new ModelSymbolElements();
+                this.pPartialitySymbol = new PartialitySymbolElements();
+                this.pExistSymbol = new ExistSymbolElements();
+                this.pEqualsSymbol = new EqualsSymbolElements();
+                this.pDataSymbol = new DataSymbolElements();
+                this.pBooleanSymbol = new BooleanSymbolElements();
+                this.pIntegerSymbol = new IntegerSymbolElements();
+                this.pRealSymbol = new RealSymbolElements();
+                this.pStringSymbol = new StringSymbolElements();
+                this.pComplexObject = new ComplexObjectElements();
+                this.pObject = new ObjectElements();
+                this.pNamedObject = new NamedObjectElements();
+                this.pUnnamedObject = new UnnamedObjectElements();
+                this.pDataObject = new DataObjectElements();
+                this.pBooleanObject = new BooleanObjectElements();
+                this.pIntObject = new IntObjectElements();
+                this.pRealObject = new RealObjectElements();
+                this.pStringObject = new StringObjectElements();
+                this.pPredicate = new PredicateElements();
+                this.pPredicateSymbol = new PredicateSymbolElements();
+                this.pErrorPredicate = new ErrorPredicateElements();
+                this.pParameter = new ParameterElements();
+                this.pPatternBody = new PatternBodyElements();
+                this.pPolarity = new PolarityElements();
+                this.pConstraint = new ConstraintElements();
+                this.pClosureType = new ClosureTypeElements();
+                this.pLiteral = new LiteralElements();
+                this.pVariable = new VariableElements();
+                this.pAllInstances = new AllInstancesElements();
+                this.pAllObjects = new AllObjectsElements();
+                this.pDefaultInterpretation = new DefaultInterpretationElements();
+                this.pCDInterpretation = new CDInterpretationElements();
+                this.pClassInterpretation = new ClassInterpretationElements();
+                this.pEnumInterpretation = new EnumInterpretationElements();
+                this.pFieldRelationInterpretation = new FieldRelationInterpretationElements();
+                this.pGlobalRelationInterpretation = new GlobalRelationInterpretationElements();
+                this.pMultiplicityDefinition = new MultiplicityDefinitionElements();
+        }
+        
+        protected Grammar internalFindGrammar(GrammarProvider grammarProvider) {
+                Grammar grammar = grammarProvider.getGrammar(this);
+                while (grammar != null) {
+                        if ("org.eclipse.viatra.solver.language.SolverLanguage".equals(grammar.getName())) {
+                                return grammar;
+                        }
+                        List<Grammar> grammars = grammar.getUsedGrammars();
+                        if (!grammars.isEmpty()) {
+                                grammar = grammars.iterator().next();
+                        } else {
+                                return null;
+                        }
+                }
+                return grammar;
+        }
+        
+        @Override
+        public Grammar getGrammar() {
+                return grammar;
+        }
+        
+        
+        public TerminalsGrammarAccess getTerminalsGrammarAccess() {
+                return gaTerminals;
+        }
+        
+        //Problem:
+        //      statements+=Statement*;
+        public ProblemElements getProblemAccess() {
+                return pProblem;
+        }
+        
+        public ParserRule getProblemRule() {
+                return getProblemAccess().getRule();
+        }
+        
+        //Statement:
+        //      Interpretation | Predicate;
+        public StatementElements getStatementAccess() {
+                return pStatement;
+        }
+        
+        public ParserRule getStatementRule() {
+                return getStatementAccess().getRule();
+        }
+        
+        //@Override
+        //terminal STRING:
+        //      '"' ('\\' . | !('\\' | '"'))* '"';
+        public TerminalRule getSTRINGRule() {
+                return tSTRING;
+        }
+        
+        //REALLiteral ecore::EBigDecimal:
+        //      '-'? INT '.' INT;
+        public REALLiteralElements getREALLiteralAccess() {
+                return pREALLiteral;
+        }
+        
+        public ParserRule getREALLiteralRule() {
+                return getREALLiteralAccess().getRule();
+        }
+        
+        //INTLiteral ecore::EInt:
+        //      '-'? INT;
+        public INTLiteralElements getINTLiteralAccess() {
+                return pINTLiteral;
+        }
+        
+        public ParserRule getINTLiteralRule() {
+                return getINTLiteralAccess().getRule();
+        }
+        
+        //BooleanValue:
+        //      {BooleanTrue} 'true' | 'false' {BooleanFalse};
+        public BooleanValueElements getBooleanValueAccess() {
+                return pBooleanValue;
+        }
+        
+        public ParserRule getBooleanValueRule() {
+                return getBooleanValueAccess().getRule();
+        }
+        
+        //TruthValue:
+        //      {True} 'true' | {False} 'false' | {Unknown} 'unknown' | {Error} 'error';
+        public TruthValueElements getTruthValueAccess() {
+                return pTruthValue;
+        }
+        
+        public ParserRule getTruthValueRule() {
+                return getTruthValueAccess().getRule();
+        }
+        
+        /////////////////////
+        //// Core grammar
+        // ///////////////////
+        //Interpretation:
+        //      BasicInterpretation | DefaultInterpretation | CDInterpretation;
+        public InterpretationElements getInterpretationAccess() {
+                return pInterpretation;
+        }
+        
+        public ParserRule getInterpretationRule() {
+                return getInterpretationAccess().getRule();
+        }
+        
+        //BasicInterpretation:
+        //      symbol=Symbol '(' objects+=ComplexObject* ')' ':' value=TruthValue;
+        public BasicInterpretationElements getBasicInterpretationAccess() {
+                return pBasicInterpretation;
+        }
+        
+        public ParserRule getBasicInterpretationRule() {
+                return getBasicInterpretationAccess().getRule();
+        }
+        
+        //Symbol:
+        //      ModelSymbol | PartialitySymbol | DataSymbol;
+        public SymbolElements getSymbolAccess() {
+                return pSymbol;
+        }
+        
+        public ParserRule getSymbolRule() {
+                return getSymbolAccess().getRule();
+        }
+        
+        //ModelSymbol:
+        //      name=ID;
+        public ModelSymbolElements getModelSymbolAccess() {
+                return pModelSymbol;
+        }
+        
+        public ParserRule getModelSymbolRule() {
+                return getModelSymbolAccess().getRule();
+        }
+        
+        //PartialitySymbol:
+        //      ExistSymbol | EqualsSymbol;
+        public PartialitySymbolElements getPartialitySymbolAccess() {
+                return pPartialitySymbol;
+        }
+        
+        public ParserRule getPartialitySymbolRule() {
+                return getPartialitySymbolAccess().getRule();
+        }
+        
+        //ExistSymbol:
+        //      'exists' {ExistSymbol};
+        public ExistSymbolElements getExistSymbolAccess() {
+                return pExistSymbol;
+        }
+        
+        public ParserRule getExistSymbolRule() {
+                return getExistSymbolAccess().getRule();
+        }
+        
+        //EqualsSymbol:
+        //      'equals' {EqualsSymbol};
+        public EqualsSymbolElements getEqualsSymbolAccess() {
+                return pEqualsSymbol;
+        }
+        
+        public ParserRule getEqualsSymbolRule() {
+                return getEqualsSymbolAccess().getRule();
+        }
+        
+        //DataSymbol:
+        //      BooleanSymbol | IntegerSymbol | RealSymbol | StringSymbol;
+        public DataSymbolElements getDataSymbolAccess() {
+                return pDataSymbol;
+        }
+        
+        public ParserRule getDataSymbolRule() {
+                return getDataSymbolAccess().getRule();
+        }
+        
+        //BooleanSymbol:
+        //      'bool' {BooleanSymbol};
+        public BooleanSymbolElements getBooleanSymbolAccess() {
+                return pBooleanSymbol;
+        }
+        
+        public ParserRule getBooleanSymbolRule() {
+                return getBooleanSymbolAccess().getRule();
+        }
+        
+        //IntegerSymbol:
+        //      'int' {IntegerSymbol};
+        public IntegerSymbolElements getIntegerSymbolAccess() {
+                return pIntegerSymbol;
+        }
+        
+        public ParserRule getIntegerSymbolRule() {
+                return getIntegerSymbolAccess().getRule();
+        }
+        
+        //RealSymbol:
+        //      'real' {RealSymbol};
+        public RealSymbolElements getRealSymbolAccess() {
+                return pRealSymbol;
+        }
+        
+        public ParserRule getRealSymbolRule() {
+                return getRealSymbolAccess().getRule();
+        }
+        
+        //StringSymbol:
+        //      'string' {StringSymbol};
+        public StringSymbolElements getStringSymbolAccess() {
+                return pStringSymbol;
+        }
+        
+        public ParserRule getStringSymbolRule() {
+                return getStringSymbolAccess().getRule();
+        }
+        
+        //ComplexObject:
+        //      Object | AllInstances | AllObjects;
+        public ComplexObjectElements getComplexObjectAccess() {
+                return pComplexObject;
+        }
+        
+        public ParserRule getComplexObjectRule() {
+                return getComplexObjectAccess().getRule();
+        }
+        
+        //Object:
+        //      NamedObject | UnnamedObject | DataObject;
+        public ObjectElements getObjectAccess() {
+                return pObject;
+        }
+        
+        public ParserRule getObjectRule() {
+                return getObjectAccess().getRule();
+        }
+        
+        //NamedObject:
+        //      "'" name=ID "'";
+        public NamedObjectElements getNamedObjectAccess() {
+                return pNamedObject;
+        }
+        
+        public ParserRule getNamedObjectRule() {
+                return getNamedObjectAccess().getRule();
+        }
+        
+        //UnnamedObject:
+        //      name=ID;
+        public UnnamedObjectElements getUnnamedObjectAccess() {
+                return pUnnamedObject;
+        }
+        
+        public ParserRule getUnnamedObjectRule() {
+                return getUnnamedObjectAccess().getRule();
+        }
+        
+        //DataObject:
+        //      BooleanObject | IntObject | RealObject | StringObject;
+        public DataObjectElements getDataObjectAccess() {
+                return pDataObject;
+        }
+        
+        public ParserRule getDataObjectRule() {
+                return getDataObjectAccess().getRule();
+        }
+        
+        //BooleanObject:
+        //      value=BooleanValue;
+        public BooleanObjectElements getBooleanObjectAccess() {
+                return pBooleanObject;
+        }
+        
+        public ParserRule getBooleanObjectRule() {
+                return getBooleanObjectAccess().getRule();
+        }
+        
+        //IntObject:
+        //      value=INTLiteral;
+        public IntObjectElements getIntObjectAccess() {
+                return pIntObject;
+        }
+        
+        public ParserRule getIntObjectRule() {
+                return getIntObjectAccess().getRule();
+        }
+        
+        //RealObject:
+        //      value=REALLiteral;
+        public RealObjectElements getRealObjectAccess() {
+                return pRealObject;
+        }
+        
+        public ParserRule getRealObjectRule() {
+                return getRealObjectAccess().getRule();
+        }
+        
+        //StringObject:
+        //      value=STRING;
+        public StringObjectElements getStringObjectAccess() {
+                return pStringObject;
+        }
+        
+        public ParserRule getStringObjectRule() {
+                return getStringObjectAccess().getRule();
+        }
+        
+        /////////////////////
+        //// Predicte grammar
+        /////////////////////
+        //Predicate:
+        //      PredicateSymbol | ErrorPredicate;
+        public PredicateElements getPredicateAccess() {
+                return pPredicate;
+        }
+        
+        public ParserRule getPredicateRule() {
+                return getPredicateAccess().getRule();
+        }
+        
+        //PredicateSymbol:
+        //      'predicate' symbol=ModelSymbol '(' parameters+=Parameter* ')' ':' ('false' | bodies+=PatternBody ('|'
+        //      bodies+=PatternBody)*) '.';
+        public PredicateSymbolElements getPredicateSymbolAccess() {
+                return pPredicateSymbol;
+        }
+        
+        public ParserRule getPredicateSymbolRule() {
+                return getPredicateSymbolAccess().getRule();
+        }
+        
+        //ErrorPredicate:
+        //      {ErrorPredicate} 'error' name=ID? ('(' parameters+=Parameter* ')') ':' ('false' | bodies+=PatternBody ('|'
+        //      bodies+=PatternBody)*) '.';
+        public ErrorPredicateElements getErrorPredicateAccess() {
+                return pErrorPredicate;
+        }
+        
+        public ParserRule getErrorPredicateRule() {
+                return getErrorPredicateAccess().getRule();
+        }
+        
+        //Parameter:
+        //      variable=Variable (':' type=Symbol)?;
+        public ParameterElements getParameterAccess() {
+                return pParameter;
+        }
+        
+        public ParserRule getParameterRule() {
+                return getParameterAccess().getRule();
+        }
+        
+        //PatternBody:
+        //      {PatternBody} ('true' | constraints+=Constraint*);
+        public PatternBodyElements getPatternBodyAccess() {
+                return pPatternBody;
+        }
+        
+        public ParserRule getPatternBodyRule() {
+                return getPatternBodyAccess().getRule();
+        }
+        
+        //Polarity:
+        //      {Positive} '+' | {Negative} '-';
+        public PolarityElements getPolarityAccess() {
+                return pPolarity;
+        }
+        
+        public ParserRule getPolarityRule() {
+                return getPolarityAccess().getRule();
+        }
+        
+        //Constraint:
+        //      polarity=Polarity? symbol=ModelSymbol ('(' params+=Literal* ')' | closureType=ClosureType '(' params+=Literal
+        //      params+=Literal ')');
+        public ConstraintElements getConstraintAccess() {
+                return pConstraint;
+        }
+        
+        public ParserRule getConstraintRule() {
+                return getConstraintAccess().getRule();
+        }
+        
+        //ClosureType:
+        //      {ReflexiveClosure} '*' | {IrreflexiveClosure} '+';
+        public ClosureTypeElements getClosureTypeAccess() {
+                return pClosureType;
+        }
+        
+        public ParserRule getClosureTypeRule() {
+                return getClosureTypeAccess().getRule();
+        }
+        
+        //Literal:
+        //      Variable | DataObject;
+        public LiteralElements getLiteralAccess() {
+                return pLiteral;
+        }
+        
+        public ParserRule getLiteralRule() {
+                return getLiteralAccess().getRule();
+        }
+        
+        //Variable:
+        //      name=ID;
+        public VariableElements getVariableAccess() {
+                return pVariable;
+        }
+        
+        public ParserRule getVariableRule() {
+                return getVariableAccess().getRule();
+        }
+        
+        /////////////////////
+        //// Complex Interpretation grammar
+        /////////////////////
+        //AllInstances:
+        //      ':' symbol=Symbol;
+        public AllInstancesElements getAllInstancesAccess() {
+                return pAllInstances;
+        }
+        
+        public ParserRule getAllInstancesRule() {
+                return getAllInstancesAccess().getRule();
+        }
+        
+        //AllObjects:
+        //      {AllObjects} '*';
+        public AllObjectsElements getAllObjectsAccess() {
+                return pAllObjects;
+        }
+        
+        public ParserRule getAllObjectsRule() {
+                return getAllObjectsAccess().getRule();
+        }
+        
+        /////////////////////
+        //// Defaul Interpretation grammar
+        /////////////////////
+        //DefaultInterpretation:
+        //      'default' interpretation=BasicInterpretation;
+        public DefaultInterpretationElements getDefaultInterpretationAccess() {
+                return pDefaultInterpretation;
+        }
+        
+        public ParserRule getDefaultInterpretationRule() {
+                return getDefaultInterpretationAccess().getRule();
+        }
+        
+        /////////////////////
+        //// Advanced Class-Diagram interpretations
+        /////////////////////
+        //CDInterpretation:
+        //      ClassInterpretation | EnumInterpretation | GlobalRelationInterpretation;
+        public CDInterpretationElements getCDInterpretationAccess() {
+                return pCDInterpretation;
+        }
+        
+        public ParserRule getCDInterpretationRule() {
+                return getCDInterpretationAccess().getRule();
+        }
+        
+        //ClassInterpretation:
+        //      abstract?='abstract' 'class' symbol=ModelSymbol ('extends' supertypes+=ModelSymbol+)? '{'
+        //      fielt+=FieldRelationInterpretation*
+        //      '}';
+        public ClassInterpretationElements getClassInterpretationAccess() {
+                return pClassInterpretation;
+        }
+        
+        public ParserRule getClassInterpretationRule() {
+                return getClassInterpretationAccess().getRule();
+        }
+        
+        //EnumInterpretation:
+        //      'enum' Symbol=ModelSymbol '{' objects+=NamedObject+ '}';
+        public EnumInterpretationElements getEnumInterpretationAccess() {
+                return pEnumInterpretation;
+        }
+        
+        public ParserRule getEnumInterpretationRule() {
+                return getEnumInterpretationAccess().getRule();
+        }
+        
+        //FieldRelationInterpretation:
+        //      containment?='containment' symbol=ModelSymbol ':' multiplicity=MultiplicityDefinition? target=Symbol;
+        public FieldRelationInterpretationElements getFieldRelationInterpretationAccess() {
+                return pFieldRelationInterpretation;
+        }
+        
+        public ParserRule getFieldRelationInterpretationRule() {
+                return getFieldRelationInterpretationAccess().getRule();
+        }
+        
+        //GlobalRelationInterpretation:
+        //      containment?='containment' 'relation' symbol=ModelSymbol ':' sourceMultiplicity=MultiplicityDefinition? source=Symbol
+        //      targetMultiplicity=MultiplicityDefinition? target=Symbol;
+        public GlobalRelationInterpretationElements getGlobalRelationInterpretationAccess() {
+                return pGlobalRelationInterpretation;
+        }
+        
+        public ParserRule getGlobalRelationInterpretationRule() {
+                return getGlobalRelationInterpretationAccess().getRule();
+        }
+        
+        //MultiplicityDefinition:
+        //      lower=INT '..' (upper=INT | unlimitedUpper?='*');
+        public MultiplicityDefinitionElements getMultiplicityDefinitionAccess() {
+                return pMultiplicityDefinition;
+        }
+        
+        public ParserRule getMultiplicityDefinitionRule() {
+                return getMultiplicityDefinitionAccess().getRule();
+        }
+        
+        //terminal ID:
+        //      '^'? ('a'..'z' | 'A'..'Z' | '_') ('a'..'z' | 'A'..'Z' | '_' | '0'..'9')*;
+        public TerminalRule getIDRule() {
+                return gaTerminals.getIDRule();
+        }
+        
+        //terminal INT returns ecore::EInt:
+        //      '0'..'9'+;
+        public TerminalRule getINTRule() {
+                return gaTerminals.getINTRule();
+        }
+        
+        //terminal ML_COMMENT:
+        //      '/*'->'*/';
+        public TerminalRule getML_COMMENTRule() {
+                return gaTerminals.getML_COMMENTRule();
+        }
+        
+        //terminal SL_COMMENT:
+        //      '//' !('\n' | '\r')* ('\r'? '\n')?;
+        public TerminalRule getSL_COMMENTRule() {
+                return gaTerminals.getSL_COMMENTRule();
+        }
+        
+        //terminal WS:
+        //      ' ' | '\t' | '\r' | '\n'+;
+        public TerminalRule getWSRule() {
+                return gaTerminals.getWSRule();
+        }
+        
+        //terminal ANY_OTHER:
+        //      .;
+        public TerminalRule getANY_OTHERRule() {
+                return gaTerminals.getANY_OTHERRule();
+        }
+}
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllInstances.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllInstances.java
new file mode 100644
index 00000000..17cb45fb
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllInstances.java
@@ -0,0 +1,47 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>All Instances</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.AllInstances#getSymbol <em>Symbol</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getAllInstances()
+ * @model
+ * @generated
+ */
+public interface AllInstances extends ComplexObject
+{
+  /**
+   * Returns the value of the '<em><b>Symbol</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Symbol</em>' containment reference.
+   * @see #setSymbol(Symbol)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getAllInstances_Symbol()
+   * @model containment="true"
+   * @generated
+   */
+  Symbol getSymbol();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.AllInstances#getSymbol <em>Symbol</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Symbol</em>' containment reference.
+   * @see #getSymbol()
+   * @generated
+   */
+  void setSymbol(Symbol value);
+} // AllInstances
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllObjects.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllObjects.java
new file mode 100644
index 00000000..fbb18046
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllObjects.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>All Objects</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getAllObjects()
+ * @model
+ * @generated
+ */
+public interface AllObjects extends ComplexObject
+{
+} // AllObjects
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BasicInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BasicInterpretation.java
new file mode 100644
index 00000000..b4226d4a
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BasicInterpretation.java
@@ -0,0 +1,84 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.common.util.EList;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Basic Interpretation</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getSymbol <em>Symbol</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getObjects <em>Objects</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBasicInterpretation()
+ * @model
+ * @generated
+ */
+public interface BasicInterpretation extends Interpretation
+{
+  /**
+   * Returns the value of the '<em><b>Symbol</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Symbol</em>' containment reference.
+   * @see #setSymbol(Symbol)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBasicInterpretation_Symbol()
+   * @model containment="true"
+   * @generated
+   */
+  Symbol getSymbol();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getSymbol <em>Symbol</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Symbol</em>' containment reference.
+   * @see #getSymbol()
+   * @generated
+   */
+  void setSymbol(Symbol value);
+  /**
+   * Returns the value of the '<em><b>Objects</b></em>' containment reference list.
+   * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.ComplexObject}.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Objects</em>' containment reference list.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBasicInterpretation_Objects()
+   * @model containment="true"
+   * @generated
+   */
+  EList<ComplexObject> getObjects();
+  /**
+   * Returns the value of the '<em><b>Value</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Value</em>' containment reference.
+   * @see #setValue(TruthValue)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBasicInterpretation_Value()
+   * @model containment="true"
+   * @generated
+   */
+  TruthValue getValue();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getValue <em>Value</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Value</em>' containment reference.
+   * @see #getValue()
+   * @generated
+   */
+  void setValue(TruthValue value);
+} // BasicInterpretation
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanFalse.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanFalse.java
new file mode 100644
index 00000000..678e8fee
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanFalse.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Boolean False</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanFalse()
+ * @model
+ * @generated
+ */
+public interface BooleanFalse extends BooleanValue
+{
+} // BooleanFalse
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanObject.java
new file mode 100644
index 00000000..c2c652ab
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanObject.java
@@ -0,0 +1,47 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Boolean Object</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanObject#getValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanObject()
+ * @model
+ * @generated
+ */
+public interface BooleanObject extends DataObject
+{
+  /**
+   * Returns the value of the '<em><b>Value</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Value</em>' containment reference.
+   * @see #setValue(BooleanValue)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanObject_Value()
+   * @model containment="true"
+   * @generated
+   */
+  BooleanValue getValue();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanObject#getValue <em>Value</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Value</em>' containment reference.
+   * @see #getValue()
+   * @generated
+   */
+  void setValue(BooleanValue value);
+} // BooleanObject
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanSymbol.java
new file mode 100644
index 00000000..4760c96c
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanSymbol.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Boolean Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanSymbol()
+ * @model
+ * @generated
+ */
+public interface BooleanSymbol extends DataSymbol
+{
+} // BooleanSymbol
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanTrue.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanTrue.java
new file mode 100644
index 00000000..7c72ec36
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanTrue.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Boolean True</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanTrue()
+ * @model
+ * @generated
+ */
+public interface BooleanTrue extends BooleanValue
+{
+} // BooleanTrue
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanValue.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanValue.java
new file mode 100644
index 00000000..8fe67a48
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanValue.java
@@ -0,0 +1,20 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.ecore.EObject;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Boolean Value</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanValue()
+ * @model
+ * @generated
+ */
+public interface BooleanValue extends EObject
+{
+} // BooleanValue
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/CDInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/CDInterpretation.java
new file mode 100644
index 00000000..9a69fc8a
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/CDInterpretation.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>CD Interpretation</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getCDInterpretation()
+ * @model
+ * @generated
+ */
+public interface CDInterpretation extends Interpretation
+{
+} // CDInterpretation
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClassInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClassInterpretation.java
new file mode 100644
index 00000000..777e0c50
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClassInterpretation.java
@@ -0,0 +1,97 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.common.util.EList;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Class Interpretation</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#isAbstract <em>Abstract</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSymbol <em>Symbol</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSupertypes <em>Supertypes</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getFielt <em>Fielt</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassInterpretation()
+ * @model
+ * @generated
+ */
+public interface ClassInterpretation extends CDInterpretation
+{
+  /**
+   * Returns the value of the '<em><b>Abstract</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Abstract</em>' attribute.
+   * @see #setAbstract(boolean)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassInterpretation_Abstract()
+   * @model
+   * @generated
+   */
+  boolean isAbstract();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#isAbstract <em>Abstract</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Abstract</em>' attribute.
+   * @see #isAbstract()
+   * @generated
+   */
+  void setAbstract(boolean value);
+  /**
+   * Returns the value of the '<em><b>Symbol</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Symbol</em>' containment reference.
+   * @see #setSymbol(ModelSymbol)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassInterpretation_Symbol()
+   * @model containment="true"
+   * @generated
+   */
+  ModelSymbol getSymbol();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSymbol <em>Symbol</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Symbol</em>' containment reference.
+   * @see #getSymbol()
+   * @generated
+   */
+  void setSymbol(ModelSymbol value);
+  /**
+   * Returns the value of the '<em><b>Supertypes</b></em>' containment reference list.
+   * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol}.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Supertypes</em>' containment reference list.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassInterpretation_Supertypes()
+   * @model containment="true"
+   * @generated
+   */
+  EList<ModelSymbol> getSupertypes();
+  /**
+   * Returns the value of the '<em><b>Fielt</b></em>' containment reference list.
+   * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation}.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Fielt</em>' containment reference list.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassInterpretation_Fielt()
+   * @model containment="true"
+   * @generated
+   */
+  EList<FieldRelationInterpretation> getFielt();
+} // ClassInterpretation
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClosureType.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClosureType.java
new file mode 100644
index 00000000..f9d8dc28
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClosureType.java
@@ -0,0 +1,20 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.ecore.EObject;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Closure Type</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClosureType()
+ * @model
+ * @generated
+ */
+public interface ClosureType extends EObject
+{
+} // ClosureType
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ComplexObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ComplexObject.java
new file mode 100644
index 00000000..e266f231
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ComplexObject.java
@@ -0,0 +1,20 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.ecore.EObject;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Complex Object</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getComplexObject()
+ * @model
+ * @generated
+ */
+public interface ComplexObject extends EObject
+{
+} // ComplexObject
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Constraint.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Constraint.java
new file mode 100644
index 00000000..9c957def
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Constraint.java
@@ -0,0 +1,109 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Constraint</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getPolarity <em>Polarity</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getSymbol <em>Symbol</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getParams <em>Params</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getClosureType <em>Closure Type</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getConstraint()
+ * @model
+ * @generated
+ */
+public interface Constraint extends EObject
+{
+  /**
+   * Returns the value of the '<em><b>Polarity</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Polarity</em>' containment reference.
+   * @see #setPolarity(Polarity)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getConstraint_Polarity()
+   * @model containment="true"
+   * @generated
+   */
+  Polarity getPolarity();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getPolarity <em>Polarity</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Polarity</em>' containment reference.
+   * @see #getPolarity()
+   * @generated
+   */
+  void setPolarity(Polarity value);
+  /**
+   * Returns the value of the '<em><b>Symbol</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Symbol</em>' containment reference.
+   * @see #setSymbol(ModelSymbol)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getConstraint_Symbol()
+   * @model containment="true"
+   * @generated
+   */
+  ModelSymbol getSymbol();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getSymbol <em>Symbol</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Symbol</em>' containment reference.
+   * @see #getSymbol()
+   * @generated
+   */
+  void setSymbol(ModelSymbol value);
+  /**
+   * Returns the value of the '<em><b>Params</b></em>' containment reference list.
+   * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.Literal}.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Params</em>' containment reference list.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getConstraint_Params()
+   * @model containment="true"
+   * @generated
+   */
+  EList<Literal> getParams();
+  /**
+   * Returns the value of the '<em><b>Closure Type</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Closure Type</em>' containment reference.
+   * @see #setClosureType(ClosureType)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getConstraint_ClosureType()
+   * @model containment="true"
+   * @generated
+   */
+  ClosureType getClosureType();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getClosureType <em>Closure Type</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Closure Type</em>' containment reference.
+   * @see #getClosureType()
+   * @generated
+   */
+  void setClosureType(ClosureType value);
+} // Constraint
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataObject.java
new file mode 100644
index 00000000..79a0af43
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataObject.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Data Object</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getDataObject()
+ * @model
+ * @generated
+ */
+public interface DataObject extends org.eclipse.viatra.solver.language.solverLanguage.Object, Literal
+{
+} // DataObject
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataSymbol.java
new file mode 100644
index 00000000..eae8175a
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataSymbol.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Data Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getDataSymbol()
+ * @model
+ * @generated
+ */
+public interface DataSymbol extends Symbol
+{
+} // DataSymbol
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DefaultInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DefaultInterpretation.java
new file mode 100644
index 00000000..2e9209f6
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DefaultInterpretation.java
@@ -0,0 +1,47 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Default Interpretation</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation#getInterpretation <em>Interpretation</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getDefaultInterpretation()
+ * @model
+ * @generated
+ */
+public interface DefaultInterpretation extends Interpretation
+{
+  /**
+   * Returns the value of the '<em><b>Interpretation</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Interpretation</em>' containment reference.
+   * @see #setInterpretation(BasicInterpretation)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getDefaultInterpretation_Interpretation()
+   * @model containment="true"
+   * @generated
+   */
+  BasicInterpretation getInterpretation();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation#getInterpretation <em>Interpretation</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Interpretation</em>' containment reference.
+   * @see #getInterpretation()
+   * @generated
+   */
+  void setInterpretation(BasicInterpretation value);
+} // DefaultInterpretation
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EnumInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EnumInterpretation.java
new file mode 100644
index 00000000..8d48c0df
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EnumInterpretation.java
@@ -0,0 +1,61 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.common.util.EList;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Enum Interpretation</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getSymbol <em>Symbol</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getObjects <em>Objects</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getEnumInterpretation()
+ * @model
+ * @generated
+ */
+public interface EnumInterpretation extends CDInterpretation
+{
+  /**
+   * Returns the value of the '<em><b>Symbol</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Symbol</em>' containment reference.
+   * @see #setSymbol(ModelSymbol)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getEnumInterpretation_Symbol()
+   * @model containment="true"
+   * @generated
+   */
+  ModelSymbol getSymbol();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getSymbol <em>Symbol</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Symbol</em>' containment reference.
+   * @see #getSymbol()
+   * @generated
+   */
+  void setSymbol(ModelSymbol value);
+  /**
+   * Returns the value of the '<em><b>Objects</b></em>' containment reference list.
+   * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject}.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Objects</em>' containment reference list.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getEnumInterpretation_Objects()
+   * @model containment="true"
+   * @generated
+   */
+  EList<NamedObject> getObjects();
+} // EnumInterpretation
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EqualsSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EqualsSymbol.java
new file mode 100644
index 00000000..1edb994f
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EqualsSymbol.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Equals Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getEqualsSymbol()
+ * @model
+ * @generated
+ */
+public interface EqualsSymbol extends PartialitySymbol
+{
+} // EqualsSymbol
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Error.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Error.java
new file mode 100644
index 00000000..bf99bc42
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Error.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Error</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getError()
+ * @model
+ * @generated
+ */
+public interface Error extends TruthValue
+{
+} // Error
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ErrorPredicate.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ErrorPredicate.java
new file mode 100644
index 00000000..c8e49d48
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ErrorPredicate.java
@@ -0,0 +1,47 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Error Predicate</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate#getName <em>Name</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getErrorPredicate()
+ * @model
+ * @generated
+ */
+public interface ErrorPredicate extends Predicate
+{
+  /**
+   * Returns the value of the '<em><b>Name</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Name</em>' attribute.
+   * @see #setName(String)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getErrorPredicate_Name()
+   * @model
+   * @generated
+   */
+  String getName();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate#getName <em>Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Name</em>' attribute.
+   * @see #getName()
+   * @generated
+   */
+  void setName(String value);
+} // ErrorPredicate
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExistSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExistSymbol.java
new file mode 100644
index 00000000..4dad3295
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExistSymbol.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Exist Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getExistSymbol()
+ * @model
+ * @generated
+ */
+public interface ExistSymbol extends PartialitySymbol
+{
+} // ExistSymbol
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/False.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/False.java
new file mode 100644
index 00000000..71947237
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/False.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>False</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFalse()
+ * @model
+ * @generated
+ */
+public interface False extends TruthValue
+{
+} // False
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/FieldRelationInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/FieldRelationInterpretation.java
new file mode 100644
index 00000000..eccf49e0
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/FieldRelationInterpretation.java
@@ -0,0 +1,117 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.ecore.EObject;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Field Relation Interpretation</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#isContainment <em>Containment</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getSymbol <em>Symbol</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getMultiplicity <em>Multiplicity</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getTarget <em>Target</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFieldRelationInterpretation()
+ * @model
+ * @generated
+ */
+public interface FieldRelationInterpretation extends EObject
+{
+  /**
+   * Returns the value of the '<em><b>Containment</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Containment</em>' attribute.
+   * @see #setContainment(boolean)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFieldRelationInterpretation_Containment()
+   * @model
+   * @generated
+   */
+  boolean isContainment();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#isContainment <em>Containment</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Containment</em>' attribute.
+   * @see #isContainment()
+   * @generated
+   */
+  void setContainment(boolean value);
+  /**
+   * Returns the value of the '<em><b>Symbol</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Symbol</em>' containment reference.
+   * @see #setSymbol(ModelSymbol)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFieldRelationInterpretation_Symbol()
+   * @model containment="true"
+   * @generated
+   */
+  ModelSymbol getSymbol();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getSymbol <em>Symbol</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Symbol</em>' containment reference.
+   * @see #getSymbol()
+   * @generated
+   */
+  void setSymbol(ModelSymbol value);
+  /**
+   * Returns the value of the '<em><b>Multiplicity</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Multiplicity</em>' containment reference.
+   * @see #setMultiplicity(MultiplicityDefinition)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFieldRelationInterpretation_Multiplicity()
+   * @model containment="true"
+   * @generated
+   */
+  MultiplicityDefinition getMultiplicity();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getMultiplicity <em>Multiplicity</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Multiplicity</em>' containment reference.
+   * @see #getMultiplicity()
+   * @generated
+   */
+  void setMultiplicity(MultiplicityDefinition value);
+  /**
+   * Returns the value of the '<em><b>Target</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Target</em>' containment reference.
+   * @see #setTarget(Symbol)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFieldRelationInterpretation_Target()
+   * @model containment="true"
+   * @generated
+   */
+  Symbol getTarget();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getTarget <em>Target</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Target</em>' containment reference.
+   * @see #getTarget()
+   * @generated
+   */
+  void setTarget(Symbol value);
+} // FieldRelationInterpretation
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/GlobalRelationInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/GlobalRelationInterpretation.java
new file mode 100644
index 00000000..59ab4278
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/GlobalRelationInterpretation.java
@@ -0,0 +1,162 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Global Relation Interpretation</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#isContainment <em>Containment</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSymbol <em>Symbol</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSourceMultiplicity <em>Source Multiplicity</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSource <em>Source</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTargetMultiplicity <em>Target Multiplicity</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTarget <em>Target</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation()
+ * @model
+ * @generated
+ */
+public interface GlobalRelationInterpretation extends CDInterpretation
+{
+  /**
+   * Returns the value of the '<em><b>Containment</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Containment</em>' attribute.
+   * @see #setContainment(boolean)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_Containment()
+   * @model
+   * @generated
+   */
+  boolean isContainment();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#isContainment <em>Containment</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Containment</em>' attribute.
+   * @see #isContainment()
+   * @generated
+   */
+  void setContainment(boolean value);
+  /**
+   * Returns the value of the '<em><b>Symbol</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Symbol</em>' containment reference.
+   * @see #setSymbol(ModelSymbol)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_Symbol()
+   * @model containment="true"
+   * @generated
+   */
+  ModelSymbol getSymbol();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSymbol <em>Symbol</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Symbol</em>' containment reference.
+   * @see #getSymbol()
+   * @generated
+   */
+  void setSymbol(ModelSymbol value);
+  /**
+   * Returns the value of the '<em><b>Source Multiplicity</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Source Multiplicity</em>' containment reference.
+   * @see #setSourceMultiplicity(MultiplicityDefinition)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_SourceMultiplicity()
+   * @model containment="true"
+   * @generated
+   */
+  MultiplicityDefinition getSourceMultiplicity();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSourceMultiplicity <em>Source Multiplicity</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Source Multiplicity</em>' containment reference.
+   * @see #getSourceMultiplicity()
+   * @generated
+   */
+  void setSourceMultiplicity(MultiplicityDefinition value);
+  /**
+   * Returns the value of the '<em><b>Source</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Source</em>' containment reference.
+   * @see #setSource(Symbol)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_Source()
+   * @model containment="true"
+   * @generated
+   */
+  Symbol getSource();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSource <em>Source</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Source</em>' containment reference.
+   * @see #getSource()
+   * @generated
+   */
+  void setSource(Symbol value);
+  /**
+   * Returns the value of the '<em><b>Target Multiplicity</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Target Multiplicity</em>' containment reference.
+   * @see #setTargetMultiplicity(MultiplicityDefinition)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_TargetMultiplicity()
+   * @model containment="true"
+   * @generated
+   */
+  MultiplicityDefinition getTargetMultiplicity();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTargetMultiplicity <em>Target Multiplicity</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Target Multiplicity</em>' containment reference.
+   * @see #getTargetMultiplicity()
+   * @generated
+   */
+  void setTargetMultiplicity(MultiplicityDefinition value);
+  /**
+   * Returns the value of the '<em><b>Target</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Target</em>' containment reference.
+   * @see #setTarget(Symbol)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_Target()
+   * @model containment="true"
+   * @generated
+   */
+  Symbol getTarget();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTarget <em>Target</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Target</em>' containment reference.
+   * @see #getTarget()
+   * @generated
+   */
+  void setTarget(Symbol value);
+} // GlobalRelationInterpretation
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntObject.java
new file mode 100644
index 00000000..1a42b0c3
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntObject.java
@@ -0,0 +1,47 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Int Object</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.IntObject#getValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getIntObject()
+ * @model
+ * @generated
+ */
+public interface IntObject extends DataObject
+{
+  /**
+   * Returns the value of the '<em><b>Value</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Value</em>' attribute.
+   * @see #setValue(int)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getIntObject_Value()
+   * @model
+   * @generated
+   */
+  int getValue();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.IntObject#getValue <em>Value</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Value</em>' attribute.
+   * @see #getValue()
+   * @generated
+   */
+  void setValue(int value);
+} // IntObject
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntegerSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntegerSymbol.java
new file mode 100644
index 00000000..d1472499
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntegerSymbol.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Integer Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getIntegerSymbol()
+ * @model
+ * @generated
+ */
+public interface IntegerSymbol extends DataSymbol
+{
+} // IntegerSymbol
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Interpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Interpretation.java
new file mode 100644
index 00000000..56541016
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Interpretation.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Interpretation</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getInterpretation()
+ * @model
+ * @generated
+ */
+public interface Interpretation extends Statement
+{
+} // Interpretation
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IrreflexiveClosure.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IrreflexiveClosure.java
new file mode 100644
index 00000000..eca04f1e
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IrreflexiveClosure.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Irreflexive Closure</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getIrreflexiveClosure()
+ * @model
+ * @generated
+ */
+public interface IrreflexiveClosure extends ClosureType
+{
+} // IrreflexiveClosure
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Literal.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Literal.java
new file mode 100644
index 00000000..259abe8c
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Literal.java
@@ -0,0 +1,20 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.ecore.EObject;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Literal</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getLiteral()
+ * @model
+ * @generated
+ */
+public interface Literal extends EObject
+{
+} // Literal
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ModelSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ModelSymbol.java
new file mode 100644
index 00000000..0d91b791
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ModelSymbol.java
@@ -0,0 +1,47 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Model Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol#getName <em>Name</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getModelSymbol()
+ * @model
+ * @generated
+ */
+public interface ModelSymbol extends Symbol
+{
+  /**
+   * Returns the value of the '<em><b>Name</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Name</em>' attribute.
+   * @see #setName(String)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getModelSymbol_Name()
+   * @model
+   * @generated
+   */
+  String getName();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol#getName <em>Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Name</em>' attribute.
+   * @see #getName()
+   * @generated
+   */
+  void setName(String value);
+} // ModelSymbol
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MultiplicityDefinition.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MultiplicityDefinition.java
new file mode 100644
index 00000000..9b4def59
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MultiplicityDefinition.java
@@ -0,0 +1,94 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.ecore.EObject;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Multiplicity Definition</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getLower <em>Lower</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getUpper <em>Upper</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#isUnlimitedUpper <em>Unlimited Upper</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMultiplicityDefinition()
+ * @model
+ * @generated
+ */
+public interface MultiplicityDefinition extends EObject
+{
+  /**
+   * Returns the value of the '<em><b>Lower</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Lower</em>' attribute.
+   * @see #setLower(int)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMultiplicityDefinition_Lower()
+   * @model
+   * @generated
+   */
+  int getLower();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getLower <em>Lower</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Lower</em>' attribute.
+   * @see #getLower()
+   * @generated
+   */
+  void setLower(int value);
+  /**
+   * Returns the value of the '<em><b>Upper</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Upper</em>' attribute.
+   * @see #setUpper(int)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMultiplicityDefinition_Upper()
+   * @model
+   * @generated
+   */
+  int getUpper();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getUpper <em>Upper</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Upper</em>' attribute.
+   * @see #getUpper()
+   * @generated
+   */
+  void setUpper(int value);
+  /**
+   * Returns the value of the '<em><b>Unlimited Upper</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Unlimited Upper</em>' attribute.
+   * @see #setUnlimitedUpper(boolean)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMultiplicityDefinition_UnlimitedUpper()
+   * @model
+   * @generated
+   */
+  boolean isUnlimitedUpper();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#isUnlimitedUpper <em>Unlimited Upper</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Unlimited Upper</em>' attribute.
+   * @see #isUnlimitedUpper()
+   * @generated
+   */
+  void setUnlimitedUpper(boolean value);
+} // MultiplicityDefinition
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/NamedObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/NamedObject.java
new file mode 100644
index 00000000..a6deaea8
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/NamedObject.java
@@ -0,0 +1,47 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Named Object</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject#getName <em>Name</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getNamedObject()
+ * @model
+ * @generated
+ */
+public interface NamedObject extends org.eclipse.viatra.solver.language.solverLanguage.Object
+{
+  /**
+   * Returns the value of the '<em><b>Name</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Name</em>' attribute.
+   * @see #setName(String)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getNamedObject_Name()
+   * @model
+   * @generated
+   */
+  String getName();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject#getName <em>Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Name</em>' attribute.
+   * @see #getName()
+   * @generated
+   */
+  void setName(String value);
+} // NamedObject
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Negative.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Negative.java
new file mode 100644
index 00000000..5d735fec
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Negative.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Negative</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getNegative()
+ * @model
+ * @generated
+ */
+public interface Negative extends Polarity
+{
+} // Negative
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Object.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Object.java
new file mode 100644
index 00000000..908ae5a6
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Object.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Object</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getObject()
+ * @model
+ * @generated
+ */
+public interface Object extends ComplexObject
+{
+} // Object
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Parameter.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Parameter.java
new file mode 100644
index 00000000..e4ef1c28
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Parameter.java
@@ -0,0 +1,71 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.ecore.EObject;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Parameter</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getVariable <em>Variable</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getType <em>Type</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getParameter()
+ * @model
+ * @generated
+ */
+public interface Parameter extends EObject
+{
+  /**
+   * Returns the value of the '<em><b>Variable</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Variable</em>' containment reference.
+   * @see #setVariable(Variable)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getParameter_Variable()
+   * @model containment="true"
+   * @generated
+   */
+  Variable getVariable();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getVariable <em>Variable</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Variable</em>' containment reference.
+   * @see #getVariable()
+   * @generated
+   */
+  void setVariable(Variable value);
+  /**
+   * Returns the value of the '<em><b>Type</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Type</em>' containment reference.
+   * @see #setType(Symbol)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getParameter_Type()
+   * @model containment="true"
+   * @generated
+   */
+  Symbol getType();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getType <em>Type</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Type</em>' containment reference.
+   * @see #getType()
+   * @generated
+   */
+  void setType(Symbol value);
+} // Parameter
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PartialitySymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PartialitySymbol.java
new file mode 100644
index 00000000..a4331248
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PartialitySymbol.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Partiality Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPartialitySymbol()
+ * @model
+ * @generated
+ */
+public interface PartialitySymbol extends Symbol
+{
+} // PartialitySymbol
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PatternBody.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PatternBody.java
new file mode 100644
index 00000000..62be12a1
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PatternBody.java
@@ -0,0 +1,40 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Pattern Body</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.PatternBody#getConstraints <em>Constraints</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPatternBody()
+ * @model
+ * @generated
+ */
+public interface PatternBody extends EObject
+{
+  /**
+   * Returns the value of the '<em><b>Constraints</b></em>' containment reference list.
+   * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.Constraint}.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Constraints</em>' containment reference list.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPatternBody_Constraints()
+   * @model containment="true"
+   * @generated
+   */
+  EList<Constraint> getConstraints();
+} // PatternBody
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Polarity.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Polarity.java
new file mode 100644
index 00000000..ba30c6ad
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Polarity.java
@@ -0,0 +1,20 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.ecore.EObject;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Polarity</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPolarity()
+ * @model
+ * @generated
+ */
+public interface Polarity extends EObject
+{
+} // Polarity
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Positive.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Positive.java
new file mode 100644
index 00000000..075a865f
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Positive.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Positive</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPositive()
+ * @model
+ * @generated
+ */
+public interface Positive extends Polarity
+{
+} // Positive
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Predicate.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Predicate.java
new file mode 100644
index 00000000..fc61ea86
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Predicate.java
@@ -0,0 +1,51 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.common.util.EList;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Predicate</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#getParameters <em>Parameters</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#getBodies <em>Bodies</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicate()
+ * @model
+ * @generated
+ */
+public interface Predicate extends Statement
+{
+  /**
+   * Returns the value of the '<em><b>Parameters</b></em>' containment reference list.
+   * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.Parameter}.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Parameters</em>' containment reference list.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicate_Parameters()
+   * @model containment="true"
+   * @generated
+   */
+  EList<Parameter> getParameters();
+  /**
+   * Returns the value of the '<em><b>Bodies</b></em>' containment reference list.
+   * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.PatternBody}.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Bodies</em>' containment reference list.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicate_Bodies()
+   * @model containment="true"
+   * @generated
+   */
+  EList<PatternBody> getBodies();
+} // Predicate
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PredicateSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PredicateSymbol.java
new file mode 100644
index 00000000..0f1d0c47
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PredicateSymbol.java
@@ -0,0 +1,47 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Predicate Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol#getSymbol <em>Symbol</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicateSymbol()
+ * @model
+ * @generated
+ */
+public interface PredicateSymbol extends Predicate
+{
+  /**
+   * Returns the value of the '<em><b>Symbol</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Symbol</em>' containment reference.
+   * @see #setSymbol(ModelSymbol)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicateSymbol_Symbol()
+   * @model containment="true"
+   * @generated
+   */
+  ModelSymbol getSymbol();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol#getSymbol <em>Symbol</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Symbol</em>' containment reference.
+   * @see #getSymbol()
+   * @generated
+   */
+  void setSymbol(ModelSymbol value);
+} // PredicateSymbol
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Problem.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Problem.java
new file mode 100644
index 00000000..91967617
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Problem.java
@@ -0,0 +1,40 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Problem</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Problem#getStatements <em>Statements</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getProblem()
+ * @model
+ * @generated
+ */
+public interface Problem extends EObject
+{
+  /**
+   * Returns the value of the '<em><b>Statements</b></em>' containment reference list.
+   * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.Statement}.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Statements</em>' containment reference list.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getProblem_Statements()
+   * @model containment="true"
+   * @generated
+   */
+  EList<Statement> getStatements();
+} // Problem
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealObject.java
new file mode 100644
index 00000000..12e8be3e
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealObject.java
@@ -0,0 +1,48 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import java.math.BigDecimal;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Real Object</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.RealObject#getValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getRealObject()
+ * @model
+ * @generated
+ */
+public interface RealObject extends DataObject
+{
+  /**
+   * Returns the value of the '<em><b>Value</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Value</em>' attribute.
+   * @see #setValue(BigDecimal)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getRealObject_Value()
+   * @model
+   * @generated
+   */
+  BigDecimal getValue();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.RealObject#getValue <em>Value</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Value</em>' attribute.
+   * @see #getValue()
+   * @generated
+   */
+  void setValue(BigDecimal value);
+} // RealObject
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealSymbol.java
new file mode 100644
index 00000000..06dd35fc
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealSymbol.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Real Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getRealSymbol()
+ * @model
+ * @generated
+ */
+public interface RealSymbol extends DataSymbol
+{
+} // RealSymbol
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ReflexiveClosure.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ReflexiveClosure.java
new file mode 100644
index 00000000..3eb30271
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ReflexiveClosure.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Reflexive Closure</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getReflexiveClosure()
+ * @model
+ * @generated
+ */
+public interface ReflexiveClosure extends ClosureType
+{
+} // ReflexiveClosure
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguageFactory.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguageFactory.java
new file mode 100644
index 00000000..ebe2abdb
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguageFactory.java
@@ -0,0 +1,521 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.ecore.EFactory;
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Factory</b> for the model.
+ * It provides a create method for each non-abstract class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage
+ * @generated
+ */
+public interface SolverLanguageFactory extends EFactory
+{
+  /**
+   * The singleton instance of the factory.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  SolverLanguageFactory eINSTANCE = org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguageFactoryImpl.init();
+  /**
+   * Returns a new object of class '<em>Problem</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Problem</em>'.
+   * @generated
+   */
+  Problem createProblem();
+  /**
+   * Returns a new object of class '<em>Statement</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Statement</em>'.
+   * @generated
+   */
+  Statement createStatement();
+  /**
+   * Returns a new object of class '<em>Boolean Value</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Boolean Value</em>'.
+   * @generated
+   */
+  BooleanValue createBooleanValue();
+  /**
+   * Returns a new object of class '<em>Truth Value</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Truth Value</em>'.
+   * @generated
+   */
+  TruthValue createTruthValue();
+  /**
+   * Returns a new object of class '<em>Interpretation</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Interpretation</em>'.
+   * @generated
+   */
+  Interpretation createInterpretation();
+  /**
+   * Returns a new object of class '<em>Basic Interpretation</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Basic Interpretation</em>'.
+   * @generated
+   */
+  BasicInterpretation createBasicInterpretation();
+  /**
+   * Returns a new object of class '<em>Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Symbol</em>'.
+   * @generated
+   */
+  Symbol createSymbol();
+  /**
+   * Returns a new object of class '<em>Model Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Model Symbol</em>'.
+   * @generated
+   */
+  ModelSymbol createModelSymbol();
+  /**
+   * Returns a new object of class '<em>Partiality Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Partiality Symbol</em>'.
+   * @generated
+   */
+  PartialitySymbol createPartialitySymbol();
+  /**
+   * Returns a new object of class '<em>Exist Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Exist Symbol</em>'.
+   * @generated
+   */
+  ExistSymbol createExistSymbol();
+  /**
+   * Returns a new object of class '<em>Equals Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Equals Symbol</em>'.
+   * @generated
+   */
+  EqualsSymbol createEqualsSymbol();
+  /**
+   * Returns a new object of class '<em>Data Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Data Symbol</em>'.
+   * @generated
+   */
+  DataSymbol createDataSymbol();
+  /**
+   * Returns a new object of class '<em>Boolean Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Boolean Symbol</em>'.
+   * @generated
+   */
+  BooleanSymbol createBooleanSymbol();
+  /**
+   * Returns a new object of class '<em>Integer Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Integer Symbol</em>'.
+   * @generated
+   */
+  IntegerSymbol createIntegerSymbol();
+  /**
+   * Returns a new object of class '<em>Real Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Real Symbol</em>'.
+   * @generated
+   */
+  RealSymbol createRealSymbol();
+  /**
+   * Returns a new object of class '<em>String Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>String Symbol</em>'.
+   * @generated
+   */
+  StringSymbol createStringSymbol();
+  /**
+   * Returns a new object of class '<em>Complex Object</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Complex Object</em>'.
+   * @generated
+   */
+  ComplexObject createComplexObject();
+  /**
+   * Returns a new object of class '<em>Object</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Object</em>'.
+   * @generated
+   */
+  Object createObject();
+  /**
+   * Returns a new object of class '<em>Named Object</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Named Object</em>'.
+   * @generated
+   */
+  NamedObject createNamedObject();
+  /**
+   * Returns a new object of class '<em>Unnamed Object</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Unnamed Object</em>'.
+   * @generated
+   */
+  UnnamedObject createUnnamedObject();
+  /**
+   * Returns a new object of class '<em>Data Object</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Data Object</em>'.
+   * @generated
+   */
+  DataObject createDataObject();
+  /**
+   * Returns a new object of class '<em>Boolean Object</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Boolean Object</em>'.
+   * @generated
+   */
+  BooleanObject createBooleanObject();
+  /**
+   * Returns a new object of class '<em>Int Object</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Int Object</em>'.
+   * @generated
+   */
+  IntObject createIntObject();
+  /**
+   * Returns a new object of class '<em>Real Object</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Real Object</em>'.
+   * @generated
+   */
+  RealObject createRealObject();
+  /**
+   * Returns a new object of class '<em>String Object</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>String Object</em>'.
+   * @generated
+   */
+  StringObject createStringObject();
+  /**
+   * Returns a new object of class '<em>Predicate</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Predicate</em>'.
+   * @generated
+   */
+  Predicate createPredicate();
+  /**
+   * Returns a new object of class '<em>Predicate Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Predicate Symbol</em>'.
+   * @generated
+   */
+  PredicateSymbol createPredicateSymbol();
+  /**
+   * Returns a new object of class '<em>Error Predicate</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Error Predicate</em>'.
+   * @generated
+   */
+  ErrorPredicate createErrorPredicate();
+  /**
+   * Returns a new object of class '<em>Parameter</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Parameter</em>'.
+   * @generated
+   */
+  Parameter createParameter();
+  /**
+   * Returns a new object of class '<em>Pattern Body</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Pattern Body</em>'.
+   * @generated
+   */
+  PatternBody createPatternBody();
+  /**
+   * Returns a new object of class '<em>Polarity</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Polarity</em>'.
+   * @generated
+   */
+  Polarity createPolarity();
+  /**
+   * Returns a new object of class '<em>Constraint</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Constraint</em>'.
+   * @generated
+   */
+  Constraint createConstraint();
+  /**
+   * Returns a new object of class '<em>Closure Type</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Closure Type</em>'.
+   * @generated
+   */
+  ClosureType createClosureType();
+  /**
+   * Returns a new object of class '<em>Literal</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Literal</em>'.
+   * @generated
+   */
+  Literal createLiteral();
+  /**
+   * Returns a new object of class '<em>Variable</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Variable</em>'.
+   * @generated
+   */
+  Variable createVariable();
+  /**
+   * Returns a new object of class '<em>All Instances</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>All Instances</em>'.
+   * @generated
+   */
+  AllInstances createAllInstances();
+  /**
+   * Returns a new object of class '<em>All Objects</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>All Objects</em>'.
+   * @generated
+   */
+  AllObjects createAllObjects();
+  /**
+   * Returns a new object of class '<em>Default Interpretation</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Default Interpretation</em>'.
+   * @generated
+   */
+  DefaultInterpretation createDefaultInterpretation();
+  /**
+   * Returns a new object of class '<em>CD Interpretation</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>CD Interpretation</em>'.
+   * @generated
+   */
+  CDInterpretation createCDInterpretation();
+  /**
+   * Returns a new object of class '<em>Class Interpretation</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Class Interpretation</em>'.
+   * @generated
+   */
+  ClassInterpretation createClassInterpretation();
+  /**
+   * Returns a new object of class '<em>Enum Interpretation</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Enum Interpretation</em>'.
+   * @generated
+   */
+  EnumInterpretation createEnumInterpretation();
+  /**
+   * Returns a new object of class '<em>Field Relation Interpretation</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Field Relation Interpretation</em>'.
+   * @generated
+   */
+  FieldRelationInterpretation createFieldRelationInterpretation();
+  /**
+   * Returns a new object of class '<em>Global Relation Interpretation</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Global Relation Interpretation</em>'.
+   * @generated
+   */
+  GlobalRelationInterpretation createGlobalRelationInterpretation();
+  /**
+   * Returns a new object of class '<em>Multiplicity Definition</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Multiplicity Definition</em>'.
+   * @generated
+   */
+  MultiplicityDefinition createMultiplicityDefinition();
+  /**
+   * Returns a new object of class '<em>Boolean True</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Boolean True</em>'.
+   * @generated
+   */
+  BooleanTrue createBooleanTrue();
+  /**
+   * Returns a new object of class '<em>Boolean False</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Boolean False</em>'.
+   * @generated
+   */
+  BooleanFalse createBooleanFalse();
+  /**
+   * Returns a new object of class '<em>True</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>True</em>'.
+   * @generated
+   */
+  True createTrue();
+  /**
+   * Returns a new object of class '<em>False</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>False</em>'.
+   * @generated
+   */
+  False createFalse();
+  /**
+   * Returns a new object of class '<em>Unknown</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Unknown</em>'.
+   * @generated
+   */
+  Unknown createUnknown();
+  /**
+   * Returns a new object of class '<em>Error</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Error</em>'.
+   * @generated
+   */
+  Error createError();
+  /**
+   * Returns a new object of class '<em>Positive</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Positive</em>'.
+   * @generated
+   */
+  Positive createPositive();
+  /**
+   * Returns a new object of class '<em>Negative</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Negative</em>'.
+   * @generated
+   */
+  Negative createNegative();
+  /**
+   * Returns a new object of class '<em>Reflexive Closure</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Reflexive Closure</em>'.
+   * @generated
+   */
+  ReflexiveClosure createReflexiveClosure();
+  /**
+   * Returns a new object of class '<em>Irreflexive Closure</em>'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return a new object of class '<em>Irreflexive Closure</em>'.
+   * @generated
+   */
+  IrreflexiveClosure createIrreflexiveClosure();
+  /**
+   * Returns the package supported by this factory.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the package supported by this factory.
+   * @generated
+   */
+  SolverLanguagePackage getSolverLanguagePackage();
+} //SolverLanguageFactory
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguagePackage.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguagePackage.java
new file mode 100644
index 00000000..3bd01417
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguagePackage.java
@@ -0,0 +1,3460 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Package</b> for the model.
+ * It contains accessors for the meta objects to represent
+ * <ul>
+ *   <li>each class,</li>
+ *   <li>each feature of each class,</li>
+ *   <li>each enum,</li>
+ *   <li>and each data type</li>
+ * </ul>
+ * <!-- end-user-doc -->
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguageFactory
+ * @model kind="package"
+ * @generated
+ */
+public interface SolverLanguagePackage extends EPackage
+{
+  /**
+   * The package name.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  String eNAME = "solverLanguage";
+  /**
+   * The package namespace URI.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  String eNS_URI = "http://www.eclipse.org/viatra/solver/language/SolverLanguage";
+  /**
+   * The package namespace name.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  String eNS_PREFIX = "solverLanguage";
+  /**
+   * The singleton instance of the package.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  SolverLanguagePackage eINSTANCE = org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl.init();
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ProblemImpl <em>Problem</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ProblemImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getProblem()
+   * @generated
+   */
+  int PROBLEM = 0;
+  /**
+   * The feature id for the '<em><b>Statements</b></em>' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int PROBLEM__STATEMENTS = 0;
+  /**
+   * The number of structural features of the '<em>Problem</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int PROBLEM_FEATURE_COUNT = 1;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StatementImpl <em>Statement</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StatementImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStatement()
+   * @generated
+   */
+  int STATEMENT = 1;
+  /**
+   * The number of structural features of the '<em>Statement</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int STATEMENT_FEATURE_COUNT = 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanValueImpl <em>Boolean Value</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanValueImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanValue()
+   * @generated
+   */
+  int BOOLEAN_VALUE = 2;
+  /**
+   * The number of structural features of the '<em>Boolean Value</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int BOOLEAN_VALUE_FEATURE_COUNT = 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TruthValueImpl <em>Truth Value</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.TruthValueImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getTruthValue()
+   * @generated
+   */
+  int TRUTH_VALUE = 3;
+  /**
+   * The number of structural features of the '<em>Truth Value</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int TRUTH_VALUE_FEATURE_COUNT = 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.InterpretationImpl <em>Interpretation</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.InterpretationImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getInterpretation()
+   * @generated
+   */
+  int INTERPRETATION = 4;
+  /**
+   * The number of structural features of the '<em>Interpretation</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int INTERPRETATION_FEATURE_COUNT = STATEMENT_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl <em>Basic Interpretation</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBasicInterpretation()
+   * @generated
+   */
+  int BASIC_INTERPRETATION = 5;
+  /**
+   * The feature id for the '<em><b>Symbol</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int BASIC_INTERPRETATION__SYMBOL = INTERPRETATION_FEATURE_COUNT + 0;
+  /**
+   * The feature id for the '<em><b>Objects</b></em>' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int BASIC_INTERPRETATION__OBJECTS = INTERPRETATION_FEATURE_COUNT + 1;
+  /**
+   * The feature id for the '<em><b>Value</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int BASIC_INTERPRETATION__VALUE = INTERPRETATION_FEATURE_COUNT + 2;
+  /**
+   * The number of structural features of the '<em>Basic Interpretation</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int BASIC_INTERPRETATION_FEATURE_COUNT = INTERPRETATION_FEATURE_COUNT + 3;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.SymbolImpl <em>Symbol</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SymbolImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getSymbol()
+   * @generated
+   */
+  int SYMBOL = 6;
+  /**
+   * The number of structural features of the '<em>Symbol</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int SYMBOL_FEATURE_COUNT = 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ModelSymbolImpl <em>Model Symbol</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ModelSymbolImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getModelSymbol()
+   * @generated
+   */
+  int MODEL_SYMBOL = 7;
+  /**
+   * The feature id for the '<em><b>Name</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int MODEL_SYMBOL__NAME = SYMBOL_FEATURE_COUNT + 0;
+  /**
+   * The number of structural features of the '<em>Model Symbol</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int MODEL_SYMBOL_FEATURE_COUNT = SYMBOL_FEATURE_COUNT + 1;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PartialitySymbolImpl <em>Partiality Symbol</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PartialitySymbolImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPartialitySymbol()
+   * @generated
+   */
+  int PARTIALITY_SYMBOL = 8;
+  /**
+   * The number of structural features of the '<em>Partiality Symbol</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int PARTIALITY_SYMBOL_FEATURE_COUNT = SYMBOL_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExistSymbolImpl <em>Exist Symbol</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExistSymbolImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExistSymbol()
+   * @generated
+   */
+  int EXIST_SYMBOL = 9;
+  /**
+   * The number of structural features of the '<em>Exist Symbol</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int EXIST_SYMBOL_FEATURE_COUNT = PARTIALITY_SYMBOL_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EqualsSymbolImpl <em>Equals Symbol</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.EqualsSymbolImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getEqualsSymbol()
+   * @generated
+   */
+  int EQUALS_SYMBOL = 10;
+  /**
+   * The number of structural features of the '<em>Equals Symbol</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int EQUALS_SYMBOL_FEATURE_COUNT = PARTIALITY_SYMBOL_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DataSymbolImpl <em>Data Symbol</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DataSymbolImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDataSymbol()
+   * @generated
+   */
+  int DATA_SYMBOL = 11;
+  /**
+   * The number of structural features of the '<em>Data Symbol</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int DATA_SYMBOL_FEATURE_COUNT = SYMBOL_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanSymbolImpl <em>Boolean Symbol</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanSymbolImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanSymbol()
+   * @generated
+   */
+  int BOOLEAN_SYMBOL = 12;
+  /**
+   * The number of structural features of the '<em>Boolean Symbol</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int BOOLEAN_SYMBOL_FEATURE_COUNT = DATA_SYMBOL_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntegerSymbolImpl <em>Integer Symbol</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IntegerSymbolImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIntegerSymbol()
+   * @generated
+   */
+  int INTEGER_SYMBOL = 13;
+  /**
+   * The number of structural features of the '<em>Integer Symbol</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int INTEGER_SYMBOL_FEATURE_COUNT = DATA_SYMBOL_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.RealSymbolImpl <em>Real Symbol</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.RealSymbolImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getRealSymbol()
+   * @generated
+   */
+  int REAL_SYMBOL = 14;
+  /**
+   * The number of structural features of the '<em>Real Symbol</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int REAL_SYMBOL_FEATURE_COUNT = DATA_SYMBOL_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringSymbolImpl <em>String Symbol</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StringSymbolImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStringSymbol()
+   * @generated
+   */
+  int STRING_SYMBOL = 15;
+  /**
+   * The number of structural features of the '<em>String Symbol</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int STRING_SYMBOL_FEATURE_COUNT = DATA_SYMBOL_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ComplexObjectImpl <em>Complex Object</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ComplexObjectImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getComplexObject()
+   * @generated
+   */
+  int COMPLEX_OBJECT = 16;
+  /**
+   * The number of structural features of the '<em>Complex Object</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int COMPLEX_OBJECT_FEATURE_COUNT = 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectImpl <em>Object</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getObject()
+   * @generated
+   */
+  int OBJECT = 17;
+  /**
+   * The number of structural features of the '<em>Object</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int OBJECT_FEATURE_COUNT = COMPLEX_OBJECT_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NamedObjectImpl <em>Named Object</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.NamedObjectImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getNamedObject()
+   * @generated
+   */
+  int NAMED_OBJECT = 18;
+  /**
+   * The feature id for the '<em><b>Name</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int NAMED_OBJECT__NAME = OBJECT_FEATURE_COUNT + 0;
+  /**
+   * The number of structural features of the '<em>Named Object</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int NAMED_OBJECT_FEATURE_COUNT = OBJECT_FEATURE_COUNT + 1;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedObjectImpl <em>Unnamed Object</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedObjectImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnnamedObject()
+   * @generated
+   */
+  int UNNAMED_OBJECT = 19;
+  /**
+   * The feature id for the '<em><b>Name</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int UNNAMED_OBJECT__NAME = OBJECT_FEATURE_COUNT + 0;
+  /**
+   * The number of structural features of the '<em>Unnamed Object</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int UNNAMED_OBJECT_FEATURE_COUNT = OBJECT_FEATURE_COUNT + 1;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DataObjectImpl <em>Data Object</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DataObjectImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDataObject()
+   * @generated
+   */
+  int DATA_OBJECT = 20;
+  /**
+   * The number of structural features of the '<em>Data Object</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int DATA_OBJECT_FEATURE_COUNT = OBJECT_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanObjectImpl <em>Boolean Object</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanObjectImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanObject()
+   * @generated
+   */
+  int BOOLEAN_OBJECT = 21;
+  /**
+   * The feature id for the '<em><b>Value</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int BOOLEAN_OBJECT__VALUE = DATA_OBJECT_FEATURE_COUNT + 0;
+  /**
+   * The number of structural features of the '<em>Boolean Object</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int BOOLEAN_OBJECT_FEATURE_COUNT = DATA_OBJECT_FEATURE_COUNT + 1;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntObjectImpl <em>Int Object</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IntObjectImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIntObject()
+   * @generated
+   */
+  int INT_OBJECT = 22;
+  /**
+   * The feature id for the '<em><b>Value</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int INT_OBJECT__VALUE = DATA_OBJECT_FEATURE_COUNT + 0;
+  /**
+   * The number of structural features of the '<em>Int Object</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int INT_OBJECT_FEATURE_COUNT = DATA_OBJECT_FEATURE_COUNT + 1;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.RealObjectImpl <em>Real Object</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.RealObjectImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getRealObject()
+   * @generated
+   */
+  int REAL_OBJECT = 23;
+  /**
+   * The feature id for the '<em><b>Value</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int REAL_OBJECT__VALUE = DATA_OBJECT_FEATURE_COUNT + 0;
+  /**
+   * The number of structural features of the '<em>Real Object</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int REAL_OBJECT_FEATURE_COUNT = DATA_OBJECT_FEATURE_COUNT + 1;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringObjectImpl <em>String Object</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StringObjectImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStringObject()
+   * @generated
+   */
+  int STRING_OBJECT = 24;
+  /**
+   * The feature id for the '<em><b>Value</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int STRING_OBJECT__VALUE = DATA_OBJECT_FEATURE_COUNT + 0;
+  /**
+   * The number of structural features of the '<em>String Object</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int STRING_OBJECT_FEATURE_COUNT = DATA_OBJECT_FEATURE_COUNT + 1;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl <em>Predicate</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPredicate()
+   * @generated
+   */
+  int PREDICATE = 25;
+  /**
+   * The feature id for the '<em><b>Parameters</b></em>' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int PREDICATE__PARAMETERS = STATEMENT_FEATURE_COUNT + 0;
+  /**
+   * The feature id for the '<em><b>Bodies</b></em>' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int PREDICATE__BODIES = STATEMENT_FEATURE_COUNT + 1;
+  /**
+   * The number of structural features of the '<em>Predicate</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int PREDICATE_FEATURE_COUNT = STATEMENT_FEATURE_COUNT + 2;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateSymbolImpl <em>Predicate Symbol</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateSymbolImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPredicateSymbol()
+   * @generated
+   */
+  int PREDICATE_SYMBOL = 26;
+  /**
+   * The feature id for the '<em><b>Parameters</b></em>' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int PREDICATE_SYMBOL__PARAMETERS = PREDICATE__PARAMETERS;
+  /**
+   * The feature id for the '<em><b>Bodies</b></em>' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int PREDICATE_SYMBOL__BODIES = PREDICATE__BODIES;
+  /**
+   * The feature id for the '<em><b>Symbol</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int PREDICATE_SYMBOL__SYMBOL = PREDICATE_FEATURE_COUNT + 0;
+  /**
+   * The number of structural features of the '<em>Predicate Symbol</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int PREDICATE_SYMBOL_FEATURE_COUNT = PREDICATE_FEATURE_COUNT + 1;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorPredicateImpl <em>Error Predicate</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorPredicateImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getErrorPredicate()
+   * @generated
+   */
+  int ERROR_PREDICATE = 27;
+  /**
+   * The feature id for the '<em><b>Parameters</b></em>' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int ERROR_PREDICATE__PARAMETERS = PREDICATE__PARAMETERS;
+  /**
+   * The feature id for the '<em><b>Bodies</b></em>' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int ERROR_PREDICATE__BODIES = PREDICATE__BODIES;
+  /**
+   * The feature id for the '<em><b>Name</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int ERROR_PREDICATE__NAME = PREDICATE_FEATURE_COUNT + 0;
+  /**
+   * The number of structural features of the '<em>Error Predicate</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int ERROR_PREDICATE_FEATURE_COUNT = PREDICATE_FEATURE_COUNT + 1;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl <em>Parameter</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getParameter()
+   * @generated
+   */
+  int PARAMETER = 28;
+  /**
+   * The feature id for the '<em><b>Variable</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int PARAMETER__VARIABLE = 0;
+  /**
+   * The feature id for the '<em><b>Type</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int PARAMETER__TYPE = 1;
+  /**
+   * The number of structural features of the '<em>Parameter</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int PARAMETER_FEATURE_COUNT = 2;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PatternBodyImpl <em>Pattern Body</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PatternBodyImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPatternBody()
+   * @generated
+   */
+  int PATTERN_BODY = 29;
+  /**
+   * The feature id for the '<em><b>Constraints</b></em>' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int PATTERN_BODY__CONSTRAINTS = 0;
+  /**
+   * The number of structural features of the '<em>Pattern Body</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int PATTERN_BODY_FEATURE_COUNT = 1;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PolarityImpl <em>Polarity</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PolarityImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPolarity()
+   * @generated
+   */
+  int POLARITY = 30;
+  /**
+   * The number of structural features of the '<em>Polarity</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int POLARITY_FEATURE_COUNT = 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl <em>Constraint</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getConstraint()
+   * @generated
+   */
+  int CONSTRAINT = 31;
+  /**
+   * The feature id for the '<em><b>Polarity</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int CONSTRAINT__POLARITY = 0;
+  /**
+   * The feature id for the '<em><b>Symbol</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int CONSTRAINT__SYMBOL = 1;
+  /**
+   * The feature id for the '<em><b>Params</b></em>' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int CONSTRAINT__PARAMS = 2;
+  /**
+   * The feature id for the '<em><b>Closure Type</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int CONSTRAINT__CLOSURE_TYPE = 3;
+  /**
+   * The number of structural features of the '<em>Constraint</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int CONSTRAINT_FEATURE_COUNT = 4;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClosureTypeImpl <em>Closure Type</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ClosureTypeImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getClosureType()
+   * @generated
+   */
+  int CLOSURE_TYPE = 32;
+  /**
+   * The number of structural features of the '<em>Closure Type</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int CLOSURE_TYPE_FEATURE_COUNT = 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.LiteralImpl <em>Literal</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.LiteralImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getLiteral()
+   * @generated
+   */
+  int LITERAL = 33;
+  /**
+   * The number of structural features of the '<em>Literal</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int LITERAL_FEATURE_COUNT = 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.VariableImpl <em>Variable</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.VariableImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getVariable()
+   * @generated
+   */
+  int VARIABLE = 34;
+  /**
+   * The feature id for the '<em><b>Name</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int VARIABLE__NAME = LITERAL_FEATURE_COUNT + 0;
+  /**
+   * The number of structural features of the '<em>Variable</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int VARIABLE_FEATURE_COUNT = LITERAL_FEATURE_COUNT + 1;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AllInstancesImpl <em>All Instances</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.AllInstancesImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAllInstances()
+   * @generated
+   */
+  int ALL_INSTANCES = 35;
+  /**
+   * The feature id for the '<em><b>Symbol</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int ALL_INSTANCES__SYMBOL = COMPLEX_OBJECT_FEATURE_COUNT + 0;
+  /**
+   * The number of structural features of the '<em>All Instances</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int ALL_INSTANCES_FEATURE_COUNT = COMPLEX_OBJECT_FEATURE_COUNT + 1;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AllObjectsImpl <em>All Objects</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.AllObjectsImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAllObjects()
+   * @generated
+   */
+  int ALL_OBJECTS = 36;
+  /**
+   * The number of structural features of the '<em>All Objects</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int ALL_OBJECTS_FEATURE_COUNT = COMPLEX_OBJECT_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultInterpretationImpl <em>Default Interpretation</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultInterpretationImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDefaultInterpretation()
+   * @generated
+   */
+  int DEFAULT_INTERPRETATION = 37;
+  /**
+   * The feature id for the '<em><b>Interpretation</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int DEFAULT_INTERPRETATION__INTERPRETATION = INTERPRETATION_FEATURE_COUNT + 0;
+  /**
+   * The number of structural features of the '<em>Default Interpretation</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int DEFAULT_INTERPRETATION_FEATURE_COUNT = INTERPRETATION_FEATURE_COUNT + 1;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CDInterpretationImpl <em>CD Interpretation</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.CDInterpretationImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getCDInterpretation()
+   * @generated
+   */
+  int CD_INTERPRETATION = 38;
+  /**
+   * The number of structural features of the '<em>CD Interpretation</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int CD_INTERPRETATION_FEATURE_COUNT = INTERPRETATION_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl <em>Class Interpretation</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getClassInterpretation()
+   * @generated
+   */
+  int CLASS_INTERPRETATION = 39;
+  /**
+   * The feature id for the '<em><b>Abstract</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int CLASS_INTERPRETATION__ABSTRACT = CD_INTERPRETATION_FEATURE_COUNT + 0;
+  /**
+   * The feature id for the '<em><b>Symbol</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int CLASS_INTERPRETATION__SYMBOL = CD_INTERPRETATION_FEATURE_COUNT + 1;
+  /**
+   * The feature id for the '<em><b>Supertypes</b></em>' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int CLASS_INTERPRETATION__SUPERTYPES = CD_INTERPRETATION_FEATURE_COUNT + 2;
+  /**
+   * The feature id for the '<em><b>Fielt</b></em>' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int CLASS_INTERPRETATION__FIELT = CD_INTERPRETATION_FEATURE_COUNT + 3;
+  /**
+   * The number of structural features of the '<em>Class Interpretation</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int CLASS_INTERPRETATION_FEATURE_COUNT = CD_INTERPRETATION_FEATURE_COUNT + 4;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl <em>Enum Interpretation</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getEnumInterpretation()
+   * @generated
+   */
+  int ENUM_INTERPRETATION = 40;
+  /**
+   * The feature id for the '<em><b>Symbol</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int ENUM_INTERPRETATION__SYMBOL = CD_INTERPRETATION_FEATURE_COUNT + 0;
+  /**
+   * The feature id for the '<em><b>Objects</b></em>' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int ENUM_INTERPRETATION__OBJECTS = CD_INTERPRETATION_FEATURE_COUNT + 1;
+  /**
+   * The number of structural features of the '<em>Enum Interpretation</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int ENUM_INTERPRETATION_FEATURE_COUNT = CD_INTERPRETATION_FEATURE_COUNT + 2;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl <em>Field Relation Interpretation</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getFieldRelationInterpretation()
+   * @generated
+   */
+  int FIELD_RELATION_INTERPRETATION = 41;
+  /**
+   * The feature id for the '<em><b>Containment</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int FIELD_RELATION_INTERPRETATION__CONTAINMENT = 0;
+  /**
+   * The feature id for the '<em><b>Symbol</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int FIELD_RELATION_INTERPRETATION__SYMBOL = 1;
+  /**
+   * The feature id for the '<em><b>Multiplicity</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int FIELD_RELATION_INTERPRETATION__MULTIPLICITY = 2;
+  /**
+   * The feature id for the '<em><b>Target</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int FIELD_RELATION_INTERPRETATION__TARGET = 3;
+  /**
+   * The number of structural features of the '<em>Field Relation Interpretation</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int FIELD_RELATION_INTERPRETATION_FEATURE_COUNT = 4;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl <em>Global Relation Interpretation</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getGlobalRelationInterpretation()
+   * @generated
+   */
+  int GLOBAL_RELATION_INTERPRETATION = 42;
+  /**
+   * The feature id for the '<em><b>Containment</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GLOBAL_RELATION_INTERPRETATION__CONTAINMENT = CD_INTERPRETATION_FEATURE_COUNT + 0;
+  /**
+   * The feature id for the '<em><b>Symbol</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GLOBAL_RELATION_INTERPRETATION__SYMBOL = CD_INTERPRETATION_FEATURE_COUNT + 1;
+  /**
+   * The feature id for the '<em><b>Source Multiplicity</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY = CD_INTERPRETATION_FEATURE_COUNT + 2;
+  /**
+   * The feature id for the '<em><b>Source</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GLOBAL_RELATION_INTERPRETATION__SOURCE = CD_INTERPRETATION_FEATURE_COUNT + 3;
+  /**
+   * The feature id for the '<em><b>Target Multiplicity</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY = CD_INTERPRETATION_FEATURE_COUNT + 4;
+  /**
+   * The feature id for the '<em><b>Target</b></em>' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GLOBAL_RELATION_INTERPRETATION__TARGET = CD_INTERPRETATION_FEATURE_COUNT + 5;
+  /**
+   * The number of structural features of the '<em>Global Relation Interpretation</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int GLOBAL_RELATION_INTERPRETATION_FEATURE_COUNT = CD_INTERPRETATION_FEATURE_COUNT + 6;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl <em>Multiplicity Definition</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getMultiplicityDefinition()
+   * @generated
+   */
+  int MULTIPLICITY_DEFINITION = 43;
+  /**
+   * The feature id for the '<em><b>Lower</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int MULTIPLICITY_DEFINITION__LOWER = 0;
+  /**
+   * The feature id for the '<em><b>Upper</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int MULTIPLICITY_DEFINITION__UPPER = 1;
+  /**
+   * The feature id for the '<em><b>Unlimited Upper</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int MULTIPLICITY_DEFINITION__UNLIMITED_UPPER = 2;
+  /**
+   * The number of structural features of the '<em>Multiplicity Definition</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int MULTIPLICITY_DEFINITION_FEATURE_COUNT = 3;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanTrueImpl <em>Boolean True</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanTrueImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanTrue()
+   * @generated
+   */
+  int BOOLEAN_TRUE = 44;
+  /**
+   * The number of structural features of the '<em>Boolean True</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int BOOLEAN_TRUE_FEATURE_COUNT = BOOLEAN_VALUE_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanFalseImpl <em>Boolean False</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanFalseImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanFalse()
+   * @generated
+   */
+  int BOOLEAN_FALSE = 45;
+  /**
+   * The number of structural features of the '<em>Boolean False</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int BOOLEAN_FALSE_FEATURE_COUNT = BOOLEAN_VALUE_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TrueImpl <em>True</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.TrueImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getTrue()
+   * @generated
+   */
+  int TRUE = 46;
+  /**
+   * The number of structural features of the '<em>True</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int TRUE_FEATURE_COUNT = TRUTH_VALUE_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FalseImpl <em>False</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.FalseImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getFalse()
+   * @generated
+   */
+  int FALSE = 47;
+  /**
+   * The number of structural features of the '<em>False</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int FALSE_FEATURE_COUNT = TRUTH_VALUE_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnknownImpl <em>Unknown</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.UnknownImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnknown()
+   * @generated
+   */
+  int UNKNOWN = 48;
+  /**
+   * The number of structural features of the '<em>Unknown</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int UNKNOWN_FEATURE_COUNT = TRUTH_VALUE_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorImpl <em>Error</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getError()
+   * @generated
+   */
+  int ERROR = 49;
+  /**
+   * The number of structural features of the '<em>Error</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int ERROR_FEATURE_COUNT = TRUTH_VALUE_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PositiveImpl <em>Positive</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PositiveImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPositive()
+   * @generated
+   */
+  int POSITIVE = 50;
+  /**
+   * The number of structural features of the '<em>Positive</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int POSITIVE_FEATURE_COUNT = POLARITY_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NegativeImpl <em>Negative</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.NegativeImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getNegative()
+   * @generated
+   */
+  int NEGATIVE = 51;
+  /**
+   * The number of structural features of the '<em>Negative</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int NEGATIVE_FEATURE_COUNT = POLARITY_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ReflexiveClosureImpl <em>Reflexive Closure</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ReflexiveClosureImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getReflexiveClosure()
+   * @generated
+   */
+  int REFLEXIVE_CLOSURE = 52;
+  /**
+   * The number of structural features of the '<em>Reflexive Closure</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int REFLEXIVE_CLOSURE_FEATURE_COUNT = CLOSURE_TYPE_FEATURE_COUNT + 0;
+  /**
+   * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IrreflexiveClosureImpl <em>Irreflexive Closure</em>}' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IrreflexiveClosureImpl
+   * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIrreflexiveClosure()
+   * @generated
+   */
+  int IRREFLEXIVE_CLOSURE = 53;
+  /**
+   * The number of structural features of the '<em>Irreflexive Closure</em>' class.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   * @ordered
+   */
+  int IRREFLEXIVE_CLOSURE_FEATURE_COUNT = CLOSURE_TYPE_FEATURE_COUNT + 0;
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Problem <em>Problem</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Problem</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Problem
+   * @generated
+   */
+  EClass getProblem();
+  /**
+   * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.Problem#getStatements <em>Statements</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference list '<em>Statements</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Problem#getStatements()
+   * @see #getProblem()
+   * @generated
+   */
+  EReference getProblem_Statements();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Statement <em>Statement</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Statement</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Statement
+   * @generated
+   */
+  EClass getStatement();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanValue <em>Boolean Value</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Boolean Value</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanValue
+   * @generated
+   */
+  EClass getBooleanValue();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.TruthValue <em>Truth Value</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Truth Value</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.TruthValue
+   * @generated
+   */
+  EClass getTruthValue();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Interpretation <em>Interpretation</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Interpretation</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Interpretation
+   * @generated
+   */
+  EClass getInterpretation();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation <em>Basic Interpretation</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Basic Interpretation</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation
+   * @generated
+   */
+  EClass getBasicInterpretation();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getSymbol <em>Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getSymbol()
+   * @see #getBasicInterpretation()
+   * @generated
+   */
+  EReference getBasicInterpretation_Symbol();
+  /**
+   * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getObjects <em>Objects</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference list '<em>Objects</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getObjects()
+   * @see #getBasicInterpretation()
+   * @generated
+   */
+  EReference getBasicInterpretation_Objects();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getValue <em>Value</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Value</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getValue()
+   * @see #getBasicInterpretation()
+   * @generated
+   */
+  EReference getBasicInterpretation_Value();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Symbol <em>Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Symbol
+   * @generated
+   */
+  EClass getSymbol();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol <em>Model Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Model Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol
+   * @generated
+   */
+  EClass getModelSymbol();
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol#getName <em>Name</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Name</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol#getName()
+   * @see #getModelSymbol()
+   * @generated
+   */
+  EAttribute getModelSymbol_Name();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol <em>Partiality Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Partiality Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol
+   * @generated
+   */
+  EClass getPartialitySymbol();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol <em>Exist Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Exist Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol
+   * @generated
+   */
+  EClass getExistSymbol();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol <em>Equals Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Equals Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol
+   * @generated
+   */
+  EClass getEqualsSymbol();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.DataSymbol <em>Data Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Data Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.DataSymbol
+   * @generated
+   */
+  EClass getDataSymbol();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol <em>Boolean Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Boolean Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol
+   * @generated
+   */
+  EClass getBooleanSymbol();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol <em>Integer Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Integer Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol
+   * @generated
+   */
+  EClass getIntegerSymbol();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.RealSymbol <em>Real Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Real Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.RealSymbol
+   * @generated
+   */
+  EClass getRealSymbol();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.StringSymbol <em>String Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>String Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.StringSymbol
+   * @generated
+   */
+  EClass getStringSymbol();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ComplexObject <em>Complex Object</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Complex Object</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ComplexObject
+   * @generated
+   */
+  EClass getComplexObject();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Object <em>Object</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Object</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Object
+   * @generated
+   */
+  EClass getObject();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject <em>Named Object</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Named Object</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.NamedObject
+   * @generated
+   */
+  EClass getNamedObject();
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject#getName <em>Name</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Name</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.NamedObject#getName()
+   * @see #getNamedObject()
+   * @generated
+   */
+  EAttribute getNamedObject_Name();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject <em>Unnamed Object</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Unnamed Object</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject
+   * @generated
+   */
+  EClass getUnnamedObject();
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject#getName <em>Name</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Name</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject#getName()
+   * @see #getUnnamedObject()
+   * @generated
+   */
+  EAttribute getUnnamedObject_Name();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.DataObject <em>Data Object</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Data Object</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.DataObject
+   * @generated
+   */
+  EClass getDataObject();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanObject <em>Boolean Object</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Boolean Object</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanObject
+   * @generated
+   */
+  EClass getBooleanObject();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanObject#getValue <em>Value</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Value</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanObject#getValue()
+   * @see #getBooleanObject()
+   * @generated
+   */
+  EReference getBooleanObject_Value();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.IntObject <em>Int Object</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Int Object</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.IntObject
+   * @generated
+   */
+  EClass getIntObject();
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.IntObject#getValue <em>Value</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Value</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.IntObject#getValue()
+   * @see #getIntObject()
+   * @generated
+   */
+  EAttribute getIntObject_Value();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.RealObject <em>Real Object</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Real Object</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.RealObject
+   * @generated
+   */
+  EClass getRealObject();
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.RealObject#getValue <em>Value</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Value</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.RealObject#getValue()
+   * @see #getRealObject()
+   * @generated
+   */
+  EAttribute getRealObject_Value();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.StringObject <em>String Object</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>String Object</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.StringObject
+   * @generated
+   */
+  EClass getStringObject();
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.StringObject#getValue <em>Value</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Value</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.StringObject#getValue()
+   * @see #getStringObject()
+   * @generated
+   */
+  EAttribute getStringObject_Value();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate <em>Predicate</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Predicate</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Predicate
+   * @generated
+   */
+  EClass getPredicate();
+  /**
+   * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#getParameters <em>Parameters</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference list '<em>Parameters</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Predicate#getParameters()
+   * @see #getPredicate()
+   * @generated
+   */
+  EReference getPredicate_Parameters();
+  /**
+   * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#getBodies <em>Bodies</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference list '<em>Bodies</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Predicate#getBodies()
+   * @see #getPredicate()
+   * @generated
+   */
+  EReference getPredicate_Bodies();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol <em>Predicate Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Predicate Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol
+   * @generated
+   */
+  EClass getPredicateSymbol();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol#getSymbol <em>Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol#getSymbol()
+   * @see #getPredicateSymbol()
+   * @generated
+   */
+  EReference getPredicateSymbol_Symbol();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate <em>Error Predicate</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Error Predicate</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate
+   * @generated
+   */
+  EClass getErrorPredicate();
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate#getName <em>Name</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Name</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate#getName()
+   * @see #getErrorPredicate()
+   * @generated
+   */
+  EAttribute getErrorPredicate_Name();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter <em>Parameter</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Parameter</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Parameter
+   * @generated
+   */
+  EClass getParameter();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getVariable <em>Variable</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Variable</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Parameter#getVariable()
+   * @see #getParameter()
+   * @generated
+   */
+  EReference getParameter_Variable();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getType <em>Type</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Type</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Parameter#getType()
+   * @see #getParameter()
+   * @generated
+   */
+  EReference getParameter_Type();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.PatternBody <em>Pattern Body</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Pattern Body</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.PatternBody
+   * @generated
+   */
+  EClass getPatternBody();
+  /**
+   * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.PatternBody#getConstraints <em>Constraints</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference list '<em>Constraints</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.PatternBody#getConstraints()
+   * @see #getPatternBody()
+   * @generated
+   */
+  EReference getPatternBody_Constraints();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Polarity <em>Polarity</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Polarity</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Polarity
+   * @generated
+   */
+  EClass getPolarity();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint <em>Constraint</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Constraint</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint
+   * @generated
+   */
+  EClass getConstraint();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getPolarity <em>Polarity</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Polarity</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint#getPolarity()
+   * @see #getConstraint()
+   * @generated
+   */
+  EReference getConstraint_Polarity();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getSymbol <em>Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint#getSymbol()
+   * @see #getConstraint()
+   * @generated
+   */
+  EReference getConstraint_Symbol();
+  /**
+   * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getParams <em>Params</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference list '<em>Params</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint#getParams()
+   * @see #getConstraint()
+   * @generated
+   */
+  EReference getConstraint_Params();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getClosureType <em>Closure Type</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Closure Type</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint#getClosureType()
+   * @see #getConstraint()
+   * @generated
+   */
+  EReference getConstraint_ClosureType();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ClosureType <em>Closure Type</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Closure Type</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ClosureType
+   * @generated
+   */
+  EClass getClosureType();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Literal <em>Literal</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Literal</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Literal
+   * @generated
+   */
+  EClass getLiteral();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Variable <em>Variable</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Variable</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Variable
+   * @generated
+   */
+  EClass getVariable();
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.Variable#getName <em>Name</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Name</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Variable#getName()
+   * @see #getVariable()
+   * @generated
+   */
+  EAttribute getVariable_Name();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.AllInstances <em>All Instances</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>All Instances</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.AllInstances
+   * @generated
+   */
+  EClass getAllInstances();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.AllInstances#getSymbol <em>Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.AllInstances#getSymbol()
+   * @see #getAllInstances()
+   * @generated
+   */
+  EReference getAllInstances_Symbol();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.AllObjects <em>All Objects</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>All Objects</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.AllObjects
+   * @generated
+   */
+  EClass getAllObjects();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation <em>Default Interpretation</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Default Interpretation</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation
+   * @generated
+   */
+  EClass getDefaultInterpretation();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation#getInterpretation <em>Interpretation</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Interpretation</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation#getInterpretation()
+   * @see #getDefaultInterpretation()
+   * @generated
+   */
+  EReference getDefaultInterpretation_Interpretation();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation <em>CD Interpretation</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>CD Interpretation</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation
+   * @generated
+   */
+  EClass getCDInterpretation();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation <em>Class Interpretation</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Class Interpretation</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation
+   * @generated
+   */
+  EClass getClassInterpretation();
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#isAbstract <em>Abstract</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Abstract</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#isAbstract()
+   * @see #getClassInterpretation()
+   * @generated
+   */
+  EAttribute getClassInterpretation_Abstract();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSymbol <em>Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSymbol()
+   * @see #getClassInterpretation()
+   * @generated
+   */
+  EReference getClassInterpretation_Symbol();
+  /**
+   * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSupertypes <em>Supertypes</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference list '<em>Supertypes</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSupertypes()
+   * @see #getClassInterpretation()
+   * @generated
+   */
+  EReference getClassInterpretation_Supertypes();
+  /**
+   * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getFielt <em>Fielt</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference list '<em>Fielt</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getFielt()
+   * @see #getClassInterpretation()
+   * @generated
+   */
+  EReference getClassInterpretation_Fielt();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation <em>Enum Interpretation</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Enum Interpretation</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation
+   * @generated
+   */
+  EClass getEnumInterpretation();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getSymbol <em>Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getSymbol()
+   * @see #getEnumInterpretation()
+   * @generated
+   */
+  EReference getEnumInterpretation_Symbol();
+  /**
+   * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getObjects <em>Objects</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference list '<em>Objects</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getObjects()
+   * @see #getEnumInterpretation()
+   * @generated
+   */
+  EReference getEnumInterpretation_Objects();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation <em>Field Relation Interpretation</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Field Relation Interpretation</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation
+   * @generated
+   */
+  EClass getFieldRelationInterpretation();
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#isContainment <em>Containment</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Containment</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#isContainment()
+   * @see #getFieldRelationInterpretation()
+   * @generated
+   */
+  EAttribute getFieldRelationInterpretation_Containment();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getSymbol <em>Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getSymbol()
+   * @see #getFieldRelationInterpretation()
+   * @generated
+   */
+  EReference getFieldRelationInterpretation_Symbol();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getMultiplicity <em>Multiplicity</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Multiplicity</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getMultiplicity()
+   * @see #getFieldRelationInterpretation()
+   * @generated
+   */
+  EReference getFieldRelationInterpretation_Multiplicity();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getTarget <em>Target</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Target</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getTarget()
+   * @see #getFieldRelationInterpretation()
+   * @generated
+   */
+  EReference getFieldRelationInterpretation_Target();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation <em>Global Relation Interpretation</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Global Relation Interpretation</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation
+   * @generated
+   */
+  EClass getGlobalRelationInterpretation();
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#isContainment <em>Containment</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Containment</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#isContainment()
+   * @see #getGlobalRelationInterpretation()
+   * @generated
+   */
+  EAttribute getGlobalRelationInterpretation_Containment();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSymbol <em>Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Symbol</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSymbol()
+   * @see #getGlobalRelationInterpretation()
+   * @generated
+   */
+  EReference getGlobalRelationInterpretation_Symbol();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSourceMultiplicity <em>Source Multiplicity</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Source Multiplicity</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSourceMultiplicity()
+   * @see #getGlobalRelationInterpretation()
+   * @generated
+   */
+  EReference getGlobalRelationInterpretation_SourceMultiplicity();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSource <em>Source</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Source</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSource()
+   * @see #getGlobalRelationInterpretation()
+   * @generated
+   */
+  EReference getGlobalRelationInterpretation_Source();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTargetMultiplicity <em>Target Multiplicity</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Target Multiplicity</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTargetMultiplicity()
+   * @see #getGlobalRelationInterpretation()
+   * @generated
+   */
+  EReference getGlobalRelationInterpretation_TargetMultiplicity();
+  /**
+   * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTarget <em>Target</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the containment reference '<em>Target</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTarget()
+   * @see #getGlobalRelationInterpretation()
+   * @generated
+   */
+  EReference getGlobalRelationInterpretation_Target();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition <em>Multiplicity Definition</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Multiplicity Definition</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition
+   * @generated
+   */
+  EClass getMultiplicityDefinition();
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getLower <em>Lower</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Lower</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getLower()
+   * @see #getMultiplicityDefinition()
+   * @generated
+   */
+  EAttribute getMultiplicityDefinition_Lower();
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getUpper <em>Upper</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Upper</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getUpper()
+   * @see #getMultiplicityDefinition()
+   * @generated
+   */
+  EAttribute getMultiplicityDefinition_Upper();
+  /**
+   * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#isUnlimitedUpper <em>Unlimited Upper</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for the attribute '<em>Unlimited Upper</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#isUnlimitedUpper()
+   * @see #getMultiplicityDefinition()
+   * @generated
+   */
+  EAttribute getMultiplicityDefinition_UnlimitedUpper();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue <em>Boolean True</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Boolean True</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue
+   * @generated
+   */
+  EClass getBooleanTrue();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse <em>Boolean False</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Boolean False</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse
+   * @generated
+   */
+  EClass getBooleanFalse();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.True <em>True</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>True</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.True
+   * @generated
+   */
+  EClass getTrue();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.False <em>False</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>False</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.False
+   * @generated
+   */
+  EClass getFalse();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Unknown <em>Unknown</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Unknown</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Unknown
+   * @generated
+   */
+  EClass getUnknown();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Error <em>Error</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Error</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Error
+   * @generated
+   */
+  EClass getError();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Positive <em>Positive</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Positive</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Positive
+   * @generated
+   */
+  EClass getPositive();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Negative <em>Negative</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Negative</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Negative
+   * @generated
+   */
+  EClass getNegative();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure <em>Reflexive Closure</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Reflexive Closure</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure
+   * @generated
+   */
+  EClass getReflexiveClosure();
+  /**
+   * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure <em>Irreflexive Closure</em>}'.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the meta object for class '<em>Irreflexive Closure</em>'.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure
+   * @generated
+   */
+  EClass getIrreflexiveClosure();
+  /**
+   * Returns the factory that creates the instances of the model.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the factory that creates the instances of the model.
+   * @generated
+   */
+  SolverLanguageFactory getSolverLanguageFactory();
+  /**
+   * <!-- begin-user-doc -->
+   * Defines literals for the meta objects that represent
+   * <ul>
+   *   <li>each class,</li>
+   *   <li>each feature of each class,</li>
+   *   <li>each enum,</li>
+   *   <li>and each data type</li>
+   * </ul>
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  interface Literals
+  {
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ProblemImpl <em>Problem</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ProblemImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getProblem()
+     * @generated
+     */
+    EClass PROBLEM = eINSTANCE.getProblem();
+    /**
+     * The meta object literal for the '<em><b>Statements</b></em>' containment reference list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference PROBLEM__STATEMENTS = eINSTANCE.getProblem_Statements();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StatementImpl <em>Statement</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StatementImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStatement()
+     * @generated
+     */
+    EClass STATEMENT = eINSTANCE.getStatement();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanValueImpl <em>Boolean Value</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanValueImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanValue()
+     * @generated
+     */
+    EClass BOOLEAN_VALUE = eINSTANCE.getBooleanValue();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TruthValueImpl <em>Truth Value</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.TruthValueImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getTruthValue()
+     * @generated
+     */
+    EClass TRUTH_VALUE = eINSTANCE.getTruthValue();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.InterpretationImpl <em>Interpretation</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.InterpretationImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getInterpretation()
+     * @generated
+     */
+    EClass INTERPRETATION = eINSTANCE.getInterpretation();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl <em>Basic Interpretation</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBasicInterpretation()
+     * @generated
+     */
+    EClass BASIC_INTERPRETATION = eINSTANCE.getBasicInterpretation();
+    /**
+     * The meta object literal for the '<em><b>Symbol</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference BASIC_INTERPRETATION__SYMBOL = eINSTANCE.getBasicInterpretation_Symbol();
+    /**
+     * The meta object literal for the '<em><b>Objects</b></em>' containment reference list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference BASIC_INTERPRETATION__OBJECTS = eINSTANCE.getBasicInterpretation_Objects();
+    /**
+     * The meta object literal for the '<em><b>Value</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference BASIC_INTERPRETATION__VALUE = eINSTANCE.getBasicInterpretation_Value();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.SymbolImpl <em>Symbol</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SymbolImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getSymbol()
+     * @generated
+     */
+    EClass SYMBOL = eINSTANCE.getSymbol();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ModelSymbolImpl <em>Model Symbol</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ModelSymbolImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getModelSymbol()
+     * @generated
+     */
+    EClass MODEL_SYMBOL = eINSTANCE.getModelSymbol();
+    /**
+     * The meta object literal for the '<em><b>Name</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute MODEL_SYMBOL__NAME = eINSTANCE.getModelSymbol_Name();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PartialitySymbolImpl <em>Partiality Symbol</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PartialitySymbolImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPartialitySymbol()
+     * @generated
+     */
+    EClass PARTIALITY_SYMBOL = eINSTANCE.getPartialitySymbol();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExistSymbolImpl <em>Exist Symbol</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExistSymbolImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExistSymbol()
+     * @generated
+     */
+    EClass EXIST_SYMBOL = eINSTANCE.getExistSymbol();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EqualsSymbolImpl <em>Equals Symbol</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.EqualsSymbolImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getEqualsSymbol()
+     * @generated
+     */
+    EClass EQUALS_SYMBOL = eINSTANCE.getEqualsSymbol();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DataSymbolImpl <em>Data Symbol</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DataSymbolImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDataSymbol()
+     * @generated
+     */
+    EClass DATA_SYMBOL = eINSTANCE.getDataSymbol();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanSymbolImpl <em>Boolean Symbol</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanSymbolImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanSymbol()
+     * @generated
+     */
+    EClass BOOLEAN_SYMBOL = eINSTANCE.getBooleanSymbol();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntegerSymbolImpl <em>Integer Symbol</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IntegerSymbolImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIntegerSymbol()
+     * @generated
+     */
+    EClass INTEGER_SYMBOL = eINSTANCE.getIntegerSymbol();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.RealSymbolImpl <em>Real Symbol</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.RealSymbolImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getRealSymbol()
+     * @generated
+     */
+    EClass REAL_SYMBOL = eINSTANCE.getRealSymbol();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringSymbolImpl <em>String Symbol</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StringSymbolImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStringSymbol()
+     * @generated
+     */
+    EClass STRING_SYMBOL = eINSTANCE.getStringSymbol();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ComplexObjectImpl <em>Complex Object</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ComplexObjectImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getComplexObject()
+     * @generated
+     */
+    EClass COMPLEX_OBJECT = eINSTANCE.getComplexObject();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectImpl <em>Object</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getObject()
+     * @generated
+     */
+    EClass OBJECT = eINSTANCE.getObject();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NamedObjectImpl <em>Named Object</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.NamedObjectImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getNamedObject()
+     * @generated
+     */
+    EClass NAMED_OBJECT = eINSTANCE.getNamedObject();
+    /**
+     * The meta object literal for the '<em><b>Name</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute NAMED_OBJECT__NAME = eINSTANCE.getNamedObject_Name();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedObjectImpl <em>Unnamed Object</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedObjectImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnnamedObject()
+     * @generated
+     */
+    EClass UNNAMED_OBJECT = eINSTANCE.getUnnamedObject();
+    /**
+     * The meta object literal for the '<em><b>Name</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute UNNAMED_OBJECT__NAME = eINSTANCE.getUnnamedObject_Name();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DataObjectImpl <em>Data Object</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DataObjectImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDataObject()
+     * @generated
+     */
+    EClass DATA_OBJECT = eINSTANCE.getDataObject();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanObjectImpl <em>Boolean Object</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanObjectImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanObject()
+     * @generated
+     */
+    EClass BOOLEAN_OBJECT = eINSTANCE.getBooleanObject();
+    /**
+     * The meta object literal for the '<em><b>Value</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference BOOLEAN_OBJECT__VALUE = eINSTANCE.getBooleanObject_Value();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntObjectImpl <em>Int Object</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IntObjectImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIntObject()
+     * @generated
+     */
+    EClass INT_OBJECT = eINSTANCE.getIntObject();
+    /**
+     * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute INT_OBJECT__VALUE = eINSTANCE.getIntObject_Value();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.RealObjectImpl <em>Real Object</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.RealObjectImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getRealObject()
+     * @generated
+     */
+    EClass REAL_OBJECT = eINSTANCE.getRealObject();
+    /**
+     * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute REAL_OBJECT__VALUE = eINSTANCE.getRealObject_Value();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringObjectImpl <em>String Object</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StringObjectImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStringObject()
+     * @generated
+     */
+    EClass STRING_OBJECT = eINSTANCE.getStringObject();
+    /**
+     * The meta object literal for the '<em><b>Value</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute STRING_OBJECT__VALUE = eINSTANCE.getStringObject_Value();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl <em>Predicate</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPredicate()
+     * @generated
+     */
+    EClass PREDICATE = eINSTANCE.getPredicate();
+    /**
+     * The meta object literal for the '<em><b>Parameters</b></em>' containment reference list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference PREDICATE__PARAMETERS = eINSTANCE.getPredicate_Parameters();
+    /**
+     * The meta object literal for the '<em><b>Bodies</b></em>' containment reference list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference PREDICATE__BODIES = eINSTANCE.getPredicate_Bodies();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateSymbolImpl <em>Predicate Symbol</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateSymbolImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPredicateSymbol()
+     * @generated
+     */
+    EClass PREDICATE_SYMBOL = eINSTANCE.getPredicateSymbol();
+    /**
+     * The meta object literal for the '<em><b>Symbol</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference PREDICATE_SYMBOL__SYMBOL = eINSTANCE.getPredicateSymbol_Symbol();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorPredicateImpl <em>Error Predicate</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorPredicateImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getErrorPredicate()
+     * @generated
+     */
+    EClass ERROR_PREDICATE = eINSTANCE.getErrorPredicate();
+    /**
+     * The meta object literal for the '<em><b>Name</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute ERROR_PREDICATE__NAME = eINSTANCE.getErrorPredicate_Name();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl <em>Parameter</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getParameter()
+     * @generated
+     */
+    EClass PARAMETER = eINSTANCE.getParameter();
+    /**
+     * The meta object literal for the '<em><b>Variable</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference PARAMETER__VARIABLE = eINSTANCE.getParameter_Variable();
+    /**
+     * The meta object literal for the '<em><b>Type</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference PARAMETER__TYPE = eINSTANCE.getParameter_Type();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PatternBodyImpl <em>Pattern Body</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PatternBodyImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPatternBody()
+     * @generated
+     */
+    EClass PATTERN_BODY = eINSTANCE.getPatternBody();
+    /**
+     * The meta object literal for the '<em><b>Constraints</b></em>' containment reference list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference PATTERN_BODY__CONSTRAINTS = eINSTANCE.getPatternBody_Constraints();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PolarityImpl <em>Polarity</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PolarityImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPolarity()
+     * @generated
+     */
+    EClass POLARITY = eINSTANCE.getPolarity();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl <em>Constraint</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getConstraint()
+     * @generated
+     */
+    EClass CONSTRAINT = eINSTANCE.getConstraint();
+    /**
+     * The meta object literal for the '<em><b>Polarity</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference CONSTRAINT__POLARITY = eINSTANCE.getConstraint_Polarity();
+    /**
+     * The meta object literal for the '<em><b>Symbol</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference CONSTRAINT__SYMBOL = eINSTANCE.getConstraint_Symbol();
+    /**
+     * The meta object literal for the '<em><b>Params</b></em>' containment reference list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference CONSTRAINT__PARAMS = eINSTANCE.getConstraint_Params();
+    /**
+     * The meta object literal for the '<em><b>Closure Type</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference CONSTRAINT__CLOSURE_TYPE = eINSTANCE.getConstraint_ClosureType();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClosureTypeImpl <em>Closure Type</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ClosureTypeImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getClosureType()
+     * @generated
+     */
+    EClass CLOSURE_TYPE = eINSTANCE.getClosureType();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.LiteralImpl <em>Literal</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.LiteralImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getLiteral()
+     * @generated
+     */
+    EClass LITERAL = eINSTANCE.getLiteral();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.VariableImpl <em>Variable</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.VariableImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getVariable()
+     * @generated
+     */
+    EClass VARIABLE = eINSTANCE.getVariable();
+    /**
+     * The meta object literal for the '<em><b>Name</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute VARIABLE__NAME = eINSTANCE.getVariable_Name();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AllInstancesImpl <em>All Instances</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.AllInstancesImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAllInstances()
+     * @generated
+     */
+    EClass ALL_INSTANCES = eINSTANCE.getAllInstances();
+    /**
+     * The meta object literal for the '<em><b>Symbol</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference ALL_INSTANCES__SYMBOL = eINSTANCE.getAllInstances_Symbol();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AllObjectsImpl <em>All Objects</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.AllObjectsImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAllObjects()
+     * @generated
+     */
+    EClass ALL_OBJECTS = eINSTANCE.getAllObjects();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultInterpretationImpl <em>Default Interpretation</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultInterpretationImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDefaultInterpretation()
+     * @generated
+     */
+    EClass DEFAULT_INTERPRETATION = eINSTANCE.getDefaultInterpretation();
+    /**
+     * The meta object literal for the '<em><b>Interpretation</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference DEFAULT_INTERPRETATION__INTERPRETATION = eINSTANCE.getDefaultInterpretation_Interpretation();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CDInterpretationImpl <em>CD Interpretation</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.CDInterpretationImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getCDInterpretation()
+     * @generated
+     */
+    EClass CD_INTERPRETATION = eINSTANCE.getCDInterpretation();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl <em>Class Interpretation</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getClassInterpretation()
+     * @generated
+     */
+    EClass CLASS_INTERPRETATION = eINSTANCE.getClassInterpretation();
+    /**
+     * The meta object literal for the '<em><b>Abstract</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute CLASS_INTERPRETATION__ABSTRACT = eINSTANCE.getClassInterpretation_Abstract();
+    /**
+     * The meta object literal for the '<em><b>Symbol</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference CLASS_INTERPRETATION__SYMBOL = eINSTANCE.getClassInterpretation_Symbol();
+    /**
+     * The meta object literal for the '<em><b>Supertypes</b></em>' containment reference list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference CLASS_INTERPRETATION__SUPERTYPES = eINSTANCE.getClassInterpretation_Supertypes();
+    /**
+     * The meta object literal for the '<em><b>Fielt</b></em>' containment reference list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference CLASS_INTERPRETATION__FIELT = eINSTANCE.getClassInterpretation_Fielt();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl <em>Enum Interpretation</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getEnumInterpretation()
+     * @generated
+     */
+    EClass ENUM_INTERPRETATION = eINSTANCE.getEnumInterpretation();
+    /**
+     * The meta object literal for the '<em><b>Symbol</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference ENUM_INTERPRETATION__SYMBOL = eINSTANCE.getEnumInterpretation_Symbol();
+    /**
+     * The meta object literal for the '<em><b>Objects</b></em>' containment reference list feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference ENUM_INTERPRETATION__OBJECTS = eINSTANCE.getEnumInterpretation_Objects();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl <em>Field Relation Interpretation</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getFieldRelationInterpretation()
+     * @generated
+     */
+    EClass FIELD_RELATION_INTERPRETATION = eINSTANCE.getFieldRelationInterpretation();
+    /**
+     * The meta object literal for the '<em><b>Containment</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute FIELD_RELATION_INTERPRETATION__CONTAINMENT = eINSTANCE.getFieldRelationInterpretation_Containment();
+    /**
+     * The meta object literal for the '<em><b>Symbol</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference FIELD_RELATION_INTERPRETATION__SYMBOL = eINSTANCE.getFieldRelationInterpretation_Symbol();
+    /**
+     * The meta object literal for the '<em><b>Multiplicity</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference FIELD_RELATION_INTERPRETATION__MULTIPLICITY = eINSTANCE.getFieldRelationInterpretation_Multiplicity();
+    /**
+     * The meta object literal for the '<em><b>Target</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference FIELD_RELATION_INTERPRETATION__TARGET = eINSTANCE.getFieldRelationInterpretation_Target();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl <em>Global Relation Interpretation</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getGlobalRelationInterpretation()
+     * @generated
+     */
+    EClass GLOBAL_RELATION_INTERPRETATION = eINSTANCE.getGlobalRelationInterpretation();
+    /**
+     * The meta object literal for the '<em><b>Containment</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute GLOBAL_RELATION_INTERPRETATION__CONTAINMENT = eINSTANCE.getGlobalRelationInterpretation_Containment();
+    /**
+     * The meta object literal for the '<em><b>Symbol</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GLOBAL_RELATION_INTERPRETATION__SYMBOL = eINSTANCE.getGlobalRelationInterpretation_Symbol();
+    /**
+     * The meta object literal for the '<em><b>Source Multiplicity</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY = eINSTANCE.getGlobalRelationInterpretation_SourceMultiplicity();
+    /**
+     * The meta object literal for the '<em><b>Source</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GLOBAL_RELATION_INTERPRETATION__SOURCE = eINSTANCE.getGlobalRelationInterpretation_Source();
+    /**
+     * The meta object literal for the '<em><b>Target Multiplicity</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY = eINSTANCE.getGlobalRelationInterpretation_TargetMultiplicity();
+    /**
+     * The meta object literal for the '<em><b>Target</b></em>' containment reference feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EReference GLOBAL_RELATION_INTERPRETATION__TARGET = eINSTANCE.getGlobalRelationInterpretation_Target();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl <em>Multiplicity Definition</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getMultiplicityDefinition()
+     * @generated
+     */
+    EClass MULTIPLICITY_DEFINITION = eINSTANCE.getMultiplicityDefinition();
+    /**
+     * The meta object literal for the '<em><b>Lower</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute MULTIPLICITY_DEFINITION__LOWER = eINSTANCE.getMultiplicityDefinition_Lower();
+    /**
+     * The meta object literal for the '<em><b>Upper</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute MULTIPLICITY_DEFINITION__UPPER = eINSTANCE.getMultiplicityDefinition_Upper();
+    /**
+     * The meta object literal for the '<em><b>Unlimited Upper</b></em>' attribute feature.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @generated
+     */
+    EAttribute MULTIPLICITY_DEFINITION__UNLIMITED_UPPER = eINSTANCE.getMultiplicityDefinition_UnlimitedUpper();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanTrueImpl <em>Boolean True</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanTrueImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanTrue()
+     * @generated
+     */
+    EClass BOOLEAN_TRUE = eINSTANCE.getBooleanTrue();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanFalseImpl <em>Boolean False</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanFalseImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanFalse()
+     * @generated
+     */
+    EClass BOOLEAN_FALSE = eINSTANCE.getBooleanFalse();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TrueImpl <em>True</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.TrueImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getTrue()
+     * @generated
+     */
+    EClass TRUE = eINSTANCE.getTrue();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FalseImpl <em>False</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.FalseImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getFalse()
+     * @generated
+     */
+    EClass FALSE = eINSTANCE.getFalse();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnknownImpl <em>Unknown</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.UnknownImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnknown()
+     * @generated
+     */
+    EClass UNKNOWN = eINSTANCE.getUnknown();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorImpl <em>Error</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getError()
+     * @generated
+     */
+    EClass ERROR = eINSTANCE.getError();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PositiveImpl <em>Positive</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PositiveImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPositive()
+     * @generated
+     */
+    EClass POSITIVE = eINSTANCE.getPositive();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NegativeImpl <em>Negative</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.NegativeImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getNegative()
+     * @generated
+     */
+    EClass NEGATIVE = eINSTANCE.getNegative();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ReflexiveClosureImpl <em>Reflexive Closure</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ReflexiveClosureImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getReflexiveClosure()
+     * @generated
+     */
+    EClass REFLEXIVE_CLOSURE = eINSTANCE.getReflexiveClosure();
+    /**
+     * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IrreflexiveClosureImpl <em>Irreflexive Closure</em>}' class.
+     * <!-- begin-user-doc -->
+     * <!-- end-user-doc -->
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IrreflexiveClosureImpl
+     * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIrreflexiveClosure()
+     * @generated
+     */
+    EClass IRREFLEXIVE_CLOSURE = eINSTANCE.getIrreflexiveClosure();
+  }
+} //SolverLanguagePackage
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Statement.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Statement.java
new file mode 100644
index 00000000..f3da8f9c
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Statement.java
@@ -0,0 +1,20 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.ecore.EObject;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Statement</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getStatement()
+ * @model
+ * @generated
+ */
+public interface Statement extends EObject
+{
+} // Statement
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringObject.java
new file mode 100644
index 00000000..d1d3ee6d
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringObject.java
@@ -0,0 +1,47 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>String Object</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.StringObject#getValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getStringObject()
+ * @model
+ * @generated
+ */
+public interface StringObject extends DataObject
+{
+  /**
+   * Returns the value of the '<em><b>Value</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Value</em>' attribute.
+   * @see #setValue(String)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getStringObject_Value()
+   * @model
+   * @generated
+   */
+  String getValue();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.StringObject#getValue <em>Value</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Value</em>' attribute.
+   * @see #getValue()
+   * @generated
+   */
+  void setValue(String value);
+} // StringObject
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringSymbol.java
new file mode 100644
index 00000000..f3d6d8ee
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringSymbol.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>String Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getStringSymbol()
+ * @model
+ * @generated
+ */
+public interface StringSymbol extends DataSymbol
+{
+} // StringSymbol
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Symbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Symbol.java
new file mode 100644
index 00000000..dcf2a01a
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Symbol.java
@@ -0,0 +1,20 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.ecore.EObject;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getSymbol()
+ * @model
+ * @generated
+ */
+public interface Symbol extends EObject
+{
+} // Symbol
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/True.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/True.java
new file mode 100644
index 00000000..d125d86a
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/True.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>True</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getTrue()
+ * @model
+ * @generated
+ */
+public interface True extends TruthValue
+{
+} // True
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/TruthValue.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/TruthValue.java
new file mode 100644
index 00000000..48e2b8e8
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/TruthValue.java
@@ -0,0 +1,20 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+import org.eclipse.emf.ecore.EObject;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Truth Value</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getTruthValue()
+ * @model
+ * @generated
+ */
+public interface TruthValue extends EObject
+{
+} // TruthValue
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Unknown.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Unknown.java
new file mode 100644
index 00000000..496f433a
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Unknown.java
@@ -0,0 +1,19 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Unknown</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getUnknown()
+ * @model
+ * @generated
+ */
+public interface Unknown extends TruthValue
+{
+} // Unknown
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnnamedObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnnamedObject.java
new file mode 100644
index 00000000..152ee782
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnnamedObject.java
@@ -0,0 +1,47 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Unnamed Object</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject#getName <em>Name</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getUnnamedObject()
+ * @model
+ * @generated
+ */
+public interface UnnamedObject extends org.eclipse.viatra.solver.language.solverLanguage.Object
+{
+  /**
+   * Returns the value of the '<em><b>Name</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Name</em>' attribute.
+   * @see #setName(String)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getUnnamedObject_Name()
+   * @model
+   * @generated
+   */
+  String getName();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject#getName <em>Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Name</em>' attribute.
+   * @see #getName()
+   * @generated
+   */
+  void setName(String value);
+} // UnnamedObject
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Variable.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Variable.java
new file mode 100644
index 00000000..2f915fa7
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Variable.java
@@ -0,0 +1,47 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage;
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>Variable</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.Variable#getName <em>Name</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getVariable()
+ * @model
+ * @generated
+ */
+public interface Variable extends Literal
+{
+  /**
+   * Returns the value of the '<em><b>Name</b></em>' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the value of the '<em>Name</em>' attribute.
+   * @see #setName(String)
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getVariable_Name()
+   * @model
+   * @generated
+   */
+  String getName();
+  /**
+   * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Variable#getName <em>Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param value the new value of the '<em>Name</em>' attribute.
+   * @see #getName()
+   * @generated
+   */
+  void setName(String value);
+} // Variable
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllInstancesImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllInstancesImpl.java
new file mode 100644
index 00000000..5da3bf30
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllInstancesImpl.java
@@ -0,0 +1,196 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.AllInstances;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.Symbol;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>All Instances</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AllInstancesImpl#getSymbol <em>Symbol</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class AllInstancesImpl extends ComplexObjectImpl implements AllInstances
+{
+  /**
+   * The cached value of the '{@link #getSymbol() <em>Symbol</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getSymbol()
+   * @generated
+   * @ordered
+   */
+  protected Symbol symbol;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected AllInstancesImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.ALL_INSTANCES;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Symbol getSymbol()
+  {
+    return symbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetSymbol(Symbol newSymbol, NotificationChain msgs)
+  {
+    Symbol oldSymbol = symbol;
+    symbol = newSymbol;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ALL_INSTANCES__SYMBOL, oldSymbol, newSymbol);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setSymbol(Symbol newSymbol)
+  {
+    if (newSymbol != symbol)
+    {
+      NotificationChain msgs = null;
+      if (symbol != null)
+        msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.ALL_INSTANCES__SYMBOL, null, msgs);
+      if (newSymbol != null)
+        msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.ALL_INSTANCES__SYMBOL, null, msgs);
+      msgs = basicSetSymbol(newSymbol, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ALL_INSTANCES__SYMBOL, newSymbol, newSymbol));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.ALL_INSTANCES__SYMBOL:
+        return basicSetSymbol(null, msgs);
+    }
+    return super.eInverseRemove(otherEnd, featureID, msgs);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.ALL_INSTANCES__SYMBOL:
+        return getSymbol();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.ALL_INSTANCES__SYMBOL:
+        setSymbol((Symbol)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.ALL_INSTANCES__SYMBOL:
+        setSymbol((Symbol)null);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.ALL_INSTANCES__SYMBOL:
+        return symbol != null;
+    }
+    return super.eIsSet(featureID);
+  }
+} //AllInstancesImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllObjectsImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllObjectsImpl.java
new file mode 100644
index 00000000..b1e9c3d0
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllObjectsImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.AllObjects;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>All Objects</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class AllObjectsImpl extends ComplexObjectImpl implements AllObjects
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected AllObjectsImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.ALL_OBJECTS;
+  }
+} //AllObjectsImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BasicInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BasicInterpretationImpl.java
new file mode 100644
index 00000000..aef515f6
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BasicInterpretationImpl.java
@@ -0,0 +1,318 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import java.util.Collection;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.ComplexObject;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.Symbol;
+import org.eclipse.viatra.solver.language.solverLanguage.TruthValue;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Basic Interpretation</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl#getSymbol <em>Symbol</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl#getObjects <em>Objects</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl#getValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class BasicInterpretationImpl extends InterpretationImpl implements BasicInterpretation
+{
+  /**
+   * The cached value of the '{@link #getSymbol() <em>Symbol</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getSymbol()
+   * @generated
+   * @ordered
+   */
+  protected Symbol symbol;
+  /**
+   * The cached value of the '{@link #getObjects() <em>Objects</em>}' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getObjects()
+   * @generated
+   * @ordered
+   */
+  protected EList<ComplexObject> objects;
+  /**
+   * The cached value of the '{@link #getValue() <em>Value</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getValue()
+   * @generated
+   * @ordered
+   */
+  protected TruthValue value;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected BasicInterpretationImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.BASIC_INTERPRETATION;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Symbol getSymbol()
+  {
+    return symbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetSymbol(Symbol newSymbol, NotificationChain msgs)
+  {
+    Symbol oldSymbol = symbol;
+    symbol = newSymbol;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL, oldSymbol, newSymbol);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setSymbol(Symbol newSymbol)
+  {
+    if (newSymbol != symbol)
+    {
+      NotificationChain msgs = null;
+      if (symbol != null)
+        msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL, null, msgs);
+      if (newSymbol != null)
+        msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL, null, msgs);
+      msgs = basicSetSymbol(newSymbol, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL, newSymbol, newSymbol));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EList<ComplexObject> getObjects()
+  {
+    if (objects == null)
+    {
+      objects = new EObjectContainmentEList<ComplexObject>(ComplexObject.class, this, SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS);
+    }
+    return objects;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public TruthValue getValue()
+  {
+    return value;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetValue(TruthValue newValue, NotificationChain msgs)
+  {
+    TruthValue oldValue = value;
+    value = newValue;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BASIC_INTERPRETATION__VALUE, oldValue, newValue);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setValue(TruthValue newValue)
+  {
+    if (newValue != value)
+    {
+      NotificationChain msgs = null;
+      if (value != null)
+        msgs = ((InternalEObject)value).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BASIC_INTERPRETATION__VALUE, null, msgs);
+      if (newValue != null)
+        msgs = ((InternalEObject)newValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BASIC_INTERPRETATION__VALUE, null, msgs);
+      msgs = basicSetValue(newValue, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BASIC_INTERPRETATION__VALUE, newValue, newValue));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL:
+        return basicSetSymbol(null, msgs);
+      case SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS:
+        return ((InternalEList<?>)getObjects()).basicRemove(otherEnd, msgs);
+      case SolverLanguagePackage.BASIC_INTERPRETATION__VALUE:
+        return basicSetValue(null, msgs);
+    }
+    return super.eInverseRemove(otherEnd, featureID, msgs);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL:
+        return getSymbol();
+      case SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS:
+        return getObjects();
+      case SolverLanguagePackage.BASIC_INTERPRETATION__VALUE:
+        return getValue();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @SuppressWarnings("unchecked")
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL:
+        setSymbol((Symbol)newValue);
+        return;
+      case SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS:
+        getObjects().clear();
+        getObjects().addAll((Collection<? extends ComplexObject>)newValue);
+        return;
+      case SolverLanguagePackage.BASIC_INTERPRETATION__VALUE:
+        setValue((TruthValue)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL:
+        setSymbol((Symbol)null);
+        return;
+      case SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS:
+        getObjects().clear();
+        return;
+      case SolverLanguagePackage.BASIC_INTERPRETATION__VALUE:
+        setValue((TruthValue)null);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL:
+        return symbol != null;
+      case SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS:
+        return objects != null && !objects.isEmpty();
+      case SolverLanguagePackage.BASIC_INTERPRETATION__VALUE:
+        return value != null;
+    }
+    return super.eIsSet(featureID);
+  }
+} //BasicInterpretationImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanFalseImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanFalseImpl.java
new file mode 100644
index 00000000..ae78f540
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanFalseImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Boolean False</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class BooleanFalseImpl extends BooleanValueImpl implements BooleanFalse
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected BooleanFalseImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.BOOLEAN_FALSE;
+  }
+} //BooleanFalseImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanObjectImpl.java
new file mode 100644
index 00000000..cb1a3ff4
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanObjectImpl.java
@@ -0,0 +1,196 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanObject;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanValue;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Boolean Object</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanObjectImpl#getValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class BooleanObjectImpl extends DataObjectImpl implements BooleanObject
+{
+  /**
+   * The cached value of the '{@link #getValue() <em>Value</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getValue()
+   * @generated
+   * @ordered
+   */
+  protected BooleanValue value;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected BooleanObjectImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.BOOLEAN_OBJECT;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public BooleanValue getValue()
+  {
+    return value;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetValue(BooleanValue newValue, NotificationChain msgs)
+  {
+    BooleanValue oldValue = value;
+    value = newValue;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BOOLEAN_OBJECT__VALUE, oldValue, newValue);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setValue(BooleanValue newValue)
+  {
+    if (newValue != value)
+    {
+      NotificationChain msgs = null;
+      if (value != null)
+        msgs = ((InternalEObject)value).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BOOLEAN_OBJECT__VALUE, null, msgs);
+      if (newValue != null)
+        msgs = ((InternalEObject)newValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BOOLEAN_OBJECT__VALUE, null, msgs);
+      msgs = basicSetValue(newValue, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BOOLEAN_OBJECT__VALUE, newValue, newValue));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.BOOLEAN_OBJECT__VALUE:
+        return basicSetValue(null, msgs);
+    }
+    return super.eInverseRemove(otherEnd, featureID, msgs);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.BOOLEAN_OBJECT__VALUE:
+        return getValue();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.BOOLEAN_OBJECT__VALUE:
+        setValue((BooleanValue)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.BOOLEAN_OBJECT__VALUE:
+        setValue((BooleanValue)null);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.BOOLEAN_OBJECT__VALUE:
+        return value != null;
+    }
+    return super.eIsSet(featureID);
+  }
+} //BooleanObjectImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanSymbolImpl.java
new file mode 100644
index 00000000..49258091
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanSymbolImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Boolean Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class BooleanSymbolImpl extends DataSymbolImpl implements BooleanSymbol
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected BooleanSymbolImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.BOOLEAN_SYMBOL;
+  }
+} //BooleanSymbolImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanTrueImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanTrueImpl.java
new file mode 100644
index 00000000..4d110ee9
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanTrueImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Boolean True</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class BooleanTrueImpl extends BooleanValueImpl implements BooleanTrue
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected BooleanTrueImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.BOOLEAN_TRUE;
+  }
+} //BooleanTrueImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanValueImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanValueImpl.java
new file mode 100644
index 00000000..b27ab959
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanValueImpl.java
@@ -0,0 +1,43 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanValue;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Boolean Value</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class BooleanValueImpl extends MinimalEObjectImpl.Container implements BooleanValue
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected BooleanValueImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.BOOLEAN_VALUE;
+  }
+} //BooleanValueImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CDInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CDInterpretationImpl.java
new file mode 100644
index 00000000..b23bbba5
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CDInterpretationImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>CD Interpretation</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class CDInterpretationImpl extends InterpretationImpl implements CDInterpretation
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected CDInterpretationImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.CD_INTERPRETATION;
+  }
+} //CDInterpretationImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClassInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClassInterpretationImpl.java
new file mode 100644
index 00000000..effc5970
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClassInterpretationImpl.java
@@ -0,0 +1,356 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import java.util.Collection;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Class Interpretation</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl#isAbstract <em>Abstract</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl#getSymbol <em>Symbol</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl#getSupertypes <em>Supertypes</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl#getFielt <em>Fielt</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class ClassInterpretationImpl extends CDInterpretationImpl implements ClassInterpretation
+{
+  /**
+   * The default value of the '{@link #isAbstract() <em>Abstract</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #isAbstract()
+   * @generated
+   * @ordered
+   */
+  protected static final boolean ABSTRACT_EDEFAULT = false;
+  /**
+   * The cached value of the '{@link #isAbstract() <em>Abstract</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #isAbstract()
+   * @generated
+   * @ordered
+   */
+  protected boolean abstract_ = ABSTRACT_EDEFAULT;
+  /**
+   * The cached value of the '{@link #getSymbol() <em>Symbol</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getSymbol()
+   * @generated
+   * @ordered
+   */
+  protected ModelSymbol symbol;
+  /**
+   * The cached value of the '{@link #getSupertypes() <em>Supertypes</em>}' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getSupertypes()
+   * @generated
+   * @ordered
+   */
+  protected EList<ModelSymbol> supertypes;
+  /**
+   * The cached value of the '{@link #getFielt() <em>Fielt</em>}' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getFielt()
+   * @generated
+   * @ordered
+   */
+  protected EList<FieldRelationInterpretation> fielt;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected ClassInterpretationImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.CLASS_INTERPRETATION;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean isAbstract()
+  {
+    return abstract_;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setAbstract(boolean newAbstract)
+  {
+    boolean oldAbstract = abstract_;
+    abstract_ = newAbstract;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CLASS_INTERPRETATION__ABSTRACT, oldAbstract, abstract_));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public ModelSymbol getSymbol()
+  {
+    return symbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs)
+  {
+    ModelSymbol oldSymbol = symbol;
+    symbol = newSymbol;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL, oldSymbol, newSymbol);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setSymbol(ModelSymbol newSymbol)
+  {
+    if (newSymbol != symbol)
+    {
+      NotificationChain msgs = null;
+      if (symbol != null)
+        msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL, null, msgs);
+      if (newSymbol != null)
+        msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL, null, msgs);
+      msgs = basicSetSymbol(newSymbol, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL, newSymbol, newSymbol));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EList<ModelSymbol> getSupertypes()
+  {
+    if (supertypes == null)
+    {
+      supertypes = new EObjectContainmentEList<ModelSymbol>(ModelSymbol.class, this, SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES);
+    }
+    return supertypes;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EList<FieldRelationInterpretation> getFielt()
+  {
+    if (fielt == null)
+    {
+      fielt = new EObjectContainmentEList<FieldRelationInterpretation>(FieldRelationInterpretation.class, this, SolverLanguagePackage.CLASS_INTERPRETATION__FIELT);
+    }
+    return fielt;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL:
+        return basicSetSymbol(null, msgs);
+      case SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES:
+        return ((InternalEList<?>)getSupertypes()).basicRemove(otherEnd, msgs);
+      case SolverLanguagePackage.CLASS_INTERPRETATION__FIELT:
+        return ((InternalEList<?>)getFielt()).basicRemove(otherEnd, msgs);
+    }
+    return super.eInverseRemove(otherEnd, featureID, msgs);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.CLASS_INTERPRETATION__ABSTRACT:
+        return isAbstract();
+      case SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL:
+        return getSymbol();
+      case SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES:
+        return getSupertypes();
+      case SolverLanguagePackage.CLASS_INTERPRETATION__FIELT:
+        return getFielt();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @SuppressWarnings("unchecked")
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.CLASS_INTERPRETATION__ABSTRACT:
+        setAbstract((Boolean)newValue);
+        return;
+      case SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL:
+        setSymbol((ModelSymbol)newValue);
+        return;
+      case SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES:
+        getSupertypes().clear();
+        getSupertypes().addAll((Collection<? extends ModelSymbol>)newValue);
+        return;
+      case SolverLanguagePackage.CLASS_INTERPRETATION__FIELT:
+        getFielt().clear();
+        getFielt().addAll((Collection<? extends FieldRelationInterpretation>)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.CLASS_INTERPRETATION__ABSTRACT:
+        setAbstract(ABSTRACT_EDEFAULT);
+        return;
+      case SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL:
+        setSymbol((ModelSymbol)null);
+        return;
+      case SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES:
+        getSupertypes().clear();
+        return;
+      case SolverLanguagePackage.CLASS_INTERPRETATION__FIELT:
+        getFielt().clear();
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.CLASS_INTERPRETATION__ABSTRACT:
+        return abstract_ != ABSTRACT_EDEFAULT;
+      case SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL:
+        return symbol != null;
+      case SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES:
+        return supertypes != null && !supertypes.isEmpty();
+      case SolverLanguagePackage.CLASS_INTERPRETATION__FIELT:
+        return fielt != null && !fielt.isEmpty();
+    }
+    return super.eIsSet(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String toString()
+  {
+    if (eIsProxy()) return super.toString();
+    StringBuilder result = new StringBuilder(super.toString());
+    result.append(" (abstract: ");
+    result.append(abstract_);
+    result.append(')');
+    return result.toString();
+  }
+} //ClassInterpretationImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClosureTypeImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClosureTypeImpl.java
new file mode 100644
index 00000000..98136f79
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClosureTypeImpl.java
@@ -0,0 +1,43 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.ClosureType;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Closure Type</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class ClosureTypeImpl extends MinimalEObjectImpl.Container implements ClosureType
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected ClosureTypeImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.CLOSURE_TYPE;
+  }
+} //ClosureTypeImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ComplexObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ComplexObjectImpl.java
new file mode 100644
index 00000000..09ad8a6d
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ComplexObjectImpl.java
@@ -0,0 +1,43 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.ComplexObject;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Complex Object</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class ComplexObjectImpl extends MinimalEObjectImpl.Container implements ComplexObject
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected ComplexObjectImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.COMPLEX_OBJECT;
+  }
+} //ComplexObjectImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ConstraintImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ConstraintImpl.java
new file mode 100644
index 00000000..2f990fee
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ConstraintImpl.java
@@ -0,0 +1,393 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import java.util.Collection;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.viatra.solver.language.solverLanguage.ClosureType;
+import org.eclipse.viatra.solver.language.solverLanguage.Constraint;
+import org.eclipse.viatra.solver.language.solverLanguage.Literal;
+import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.Polarity;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Constraint</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl#getPolarity <em>Polarity</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl#getSymbol <em>Symbol</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl#getParams <em>Params</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl#getClosureType <em>Closure Type</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class ConstraintImpl extends MinimalEObjectImpl.Container implements Constraint
+{
+  /**
+   * The cached value of the '{@link #getPolarity() <em>Polarity</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getPolarity()
+   * @generated
+   * @ordered
+   */
+  protected Polarity polarity;
+  /**
+   * The cached value of the '{@link #getSymbol() <em>Symbol</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getSymbol()
+   * @generated
+   * @ordered
+   */
+  protected ModelSymbol symbol;
+  /**
+   * The cached value of the '{@link #getParams() <em>Params</em>}' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getParams()
+   * @generated
+   * @ordered
+   */
+  protected EList<Literal> params;
+  /**
+   * The cached value of the '{@link #getClosureType() <em>Closure Type</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getClosureType()
+   * @generated
+   * @ordered
+   */
+  protected ClosureType closureType;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected ConstraintImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.CONSTRAINT;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Polarity getPolarity()
+  {
+    return polarity;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetPolarity(Polarity newPolarity, NotificationChain msgs)
+  {
+    Polarity oldPolarity = polarity;
+    polarity = newPolarity;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__POLARITY, oldPolarity, newPolarity);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setPolarity(Polarity newPolarity)
+  {
+    if (newPolarity != polarity)
+    {
+      NotificationChain msgs = null;
+      if (polarity != null)
+        msgs = ((InternalEObject)polarity).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__POLARITY, null, msgs);
+      if (newPolarity != null)
+        msgs = ((InternalEObject)newPolarity).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__POLARITY, null, msgs);
+      msgs = basicSetPolarity(newPolarity, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__POLARITY, newPolarity, newPolarity));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public ModelSymbol getSymbol()
+  {
+    return symbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs)
+  {
+    ModelSymbol oldSymbol = symbol;
+    symbol = newSymbol;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__SYMBOL, oldSymbol, newSymbol);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setSymbol(ModelSymbol newSymbol)
+  {
+    if (newSymbol != symbol)
+    {
+      NotificationChain msgs = null;
+      if (symbol != null)
+        msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__SYMBOL, null, msgs);
+      if (newSymbol != null)
+        msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__SYMBOL, null, msgs);
+      msgs = basicSetSymbol(newSymbol, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__SYMBOL, newSymbol, newSymbol));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EList<Literal> getParams()
+  {
+    if (params == null)
+    {
+      params = new EObjectContainmentEList<Literal>(Literal.class, this, SolverLanguagePackage.CONSTRAINT__PARAMS);
+    }
+    return params;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public ClosureType getClosureType()
+  {
+    return closureType;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetClosureType(ClosureType newClosureType, NotificationChain msgs)
+  {
+    ClosureType oldClosureType = closureType;
+    closureType = newClosureType;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE, oldClosureType, newClosureType);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setClosureType(ClosureType newClosureType)
+  {
+    if (newClosureType != closureType)
+    {
+      NotificationChain msgs = null;
+      if (closureType != null)
+        msgs = ((InternalEObject)closureType).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE, null, msgs);
+      if (newClosureType != null)
+        msgs = ((InternalEObject)newClosureType).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE, null, msgs);
+      msgs = basicSetClosureType(newClosureType, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE, newClosureType, newClosureType));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.CONSTRAINT__POLARITY:
+        return basicSetPolarity(null, msgs);
+      case SolverLanguagePackage.CONSTRAINT__SYMBOL:
+        return basicSetSymbol(null, msgs);
+      case SolverLanguagePackage.CONSTRAINT__PARAMS:
+        return ((InternalEList<?>)getParams()).basicRemove(otherEnd, msgs);
+      case SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE:
+        return basicSetClosureType(null, msgs);
+    }
+    return super.eInverseRemove(otherEnd, featureID, msgs);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.CONSTRAINT__POLARITY:
+        return getPolarity();
+      case SolverLanguagePackage.CONSTRAINT__SYMBOL:
+        return getSymbol();
+      case SolverLanguagePackage.CONSTRAINT__PARAMS:
+        return getParams();
+      case SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE:
+        return getClosureType();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @SuppressWarnings("unchecked")
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.CONSTRAINT__POLARITY:
+        setPolarity((Polarity)newValue);
+        return;
+      case SolverLanguagePackage.CONSTRAINT__SYMBOL:
+        setSymbol((ModelSymbol)newValue);
+        return;
+      case SolverLanguagePackage.CONSTRAINT__PARAMS:
+        getParams().clear();
+        getParams().addAll((Collection<? extends Literal>)newValue);
+        return;
+      case SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE:
+        setClosureType((ClosureType)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.CONSTRAINT__POLARITY:
+        setPolarity((Polarity)null);
+        return;
+      case SolverLanguagePackage.CONSTRAINT__SYMBOL:
+        setSymbol((ModelSymbol)null);
+        return;
+      case SolverLanguagePackage.CONSTRAINT__PARAMS:
+        getParams().clear();
+        return;
+      case SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE:
+        setClosureType((ClosureType)null);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.CONSTRAINT__POLARITY:
+        return polarity != null;
+      case SolverLanguagePackage.CONSTRAINT__SYMBOL:
+        return symbol != null;
+      case SolverLanguagePackage.CONSTRAINT__PARAMS:
+        return params != null && !params.isEmpty();
+      case SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE:
+        return closureType != null;
+    }
+    return super.eIsSet(featureID);
+  }
+} //ConstraintImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataObjectImpl.java
new file mode 100644
index 00000000..33bee29f
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataObjectImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.DataObject;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Data Object</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class DataObjectImpl extends ObjectImpl implements DataObject
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected DataObjectImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.DATA_OBJECT;
+  }
+} //DataObjectImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataSymbolImpl.java
new file mode 100644
index 00000000..221b4783
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataSymbolImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.DataSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Data Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class DataSymbolImpl extends SymbolImpl implements DataSymbol
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected DataSymbolImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.DATA_SYMBOL;
+  }
+} //DataSymbolImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DefaultInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DefaultInterpretationImpl.java
new file mode 100644
index 00000000..eb2835a0
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DefaultInterpretationImpl.java
@@ -0,0 +1,196 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Default Interpretation</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultInterpretationImpl#getInterpretation <em>Interpretation</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class DefaultInterpretationImpl extends InterpretationImpl implements DefaultInterpretation
+{
+  /**
+   * The cached value of the '{@link #getInterpretation() <em>Interpretation</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getInterpretation()
+   * @generated
+   * @ordered
+   */
+  protected BasicInterpretation interpretation;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected DefaultInterpretationImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.DEFAULT_INTERPRETATION;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public BasicInterpretation getInterpretation()
+  {
+    return interpretation;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetInterpretation(BasicInterpretation newInterpretation, NotificationChain msgs)
+  {
+    BasicInterpretation oldInterpretation = interpretation;
+    interpretation = newInterpretation;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION, oldInterpretation, newInterpretation);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setInterpretation(BasicInterpretation newInterpretation)
+  {
+    if (newInterpretation != interpretation)
+    {
+      NotificationChain msgs = null;
+      if (interpretation != null)
+        msgs = ((InternalEObject)interpretation).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION, null, msgs);
+      if (newInterpretation != null)
+        msgs = ((InternalEObject)newInterpretation).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION, null, msgs);
+      msgs = basicSetInterpretation(newInterpretation, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION, newInterpretation, newInterpretation));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION:
+        return basicSetInterpretation(null, msgs);
+    }
+    return super.eInverseRemove(otherEnd, featureID, msgs);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION:
+        return getInterpretation();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION:
+        setInterpretation((BasicInterpretation)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION:
+        setInterpretation((BasicInterpretation)null);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION:
+        return interpretation != null;
+    }
+    return super.eIsSet(featureID);
+  }
+} //DefaultInterpretationImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EnumInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EnumInterpretationImpl.java
new file mode 100644
index 00000000..efa12ea6
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EnumInterpretationImpl.java
@@ -0,0 +1,244 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import java.util.Collection;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.NamedObject;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Enum Interpretation</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl#getSymbol <em>Symbol</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl#getObjects <em>Objects</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class EnumInterpretationImpl extends CDInterpretationImpl implements EnumInterpretation
+{
+  /**
+   * The cached value of the '{@link #getSymbol() <em>Symbol</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getSymbol()
+   * @generated
+   * @ordered
+   */
+  protected ModelSymbol symbol;
+  /**
+   * The cached value of the '{@link #getObjects() <em>Objects</em>}' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getObjects()
+   * @generated
+   * @ordered
+   */
+  protected EList<NamedObject> objects;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected EnumInterpretationImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.ENUM_INTERPRETATION;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public ModelSymbol getSymbol()
+  {
+    return symbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs)
+  {
+    ModelSymbol oldSymbol = symbol;
+    symbol = newSymbol;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL, oldSymbol, newSymbol);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setSymbol(ModelSymbol newSymbol)
+  {
+    if (newSymbol != symbol)
+    {
+      NotificationChain msgs = null;
+      if (symbol != null)
+        msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL, null, msgs);
+      if (newSymbol != null)
+        msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL, null, msgs);
+      msgs = basicSetSymbol(newSymbol, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL, newSymbol, newSymbol));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EList<NamedObject> getObjects()
+  {
+    if (objects == null)
+    {
+      objects = new EObjectContainmentEList<NamedObject>(NamedObject.class, this, SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS);
+    }
+    return objects;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL:
+        return basicSetSymbol(null, msgs);
+      case SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS:
+        return ((InternalEList<?>)getObjects()).basicRemove(otherEnd, msgs);
+    }
+    return super.eInverseRemove(otherEnd, featureID, msgs);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL:
+        return getSymbol();
+      case SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS:
+        return getObjects();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @SuppressWarnings("unchecked")
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL:
+        setSymbol((ModelSymbol)newValue);
+        return;
+      case SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS:
+        getObjects().clear();
+        getObjects().addAll((Collection<? extends NamedObject>)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL:
+        setSymbol((ModelSymbol)null);
+        return;
+      case SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS:
+        getObjects().clear();
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL:
+        return symbol != null;
+      case SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS:
+        return objects != null && !objects.isEmpty();
+    }
+    return super.eIsSet(featureID);
+  }
+} //EnumInterpretationImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EqualsSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EqualsSymbolImpl.java
new file mode 100644
index 00000000..33929f42
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EqualsSymbolImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Equals Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class EqualsSymbolImpl extends PartialitySymbolImpl implements EqualsSymbol
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected EqualsSymbolImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.EQUALS_SYMBOL;
+  }
+} //EqualsSymbolImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ErrorImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ErrorImpl.java
new file mode 100644
index 00000000..e58094a7
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ErrorImpl.java
@@ -0,0 +1,40 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Error</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class ErrorImpl extends TruthValueImpl implements org.eclipse.viatra.solver.language.solverLanguage.Error
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected ErrorImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.ERROR;
+  }
+} //ErrorImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ErrorPredicateImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ErrorPredicateImpl.java
new file mode 100644
index 00000000..f9b0e8c8
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ErrorPredicateImpl.java
@@ -0,0 +1,179 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Error Predicate</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorPredicateImpl#getName <em>Name</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class ErrorPredicateImpl extends PredicateImpl implements ErrorPredicate
+{
+  /**
+   * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getName()
+   * @generated
+   * @ordered
+   */
+  protected static final String NAME_EDEFAULT = null;
+  /**
+   * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getName()
+   * @generated
+   * @ordered
+   */
+  protected String name = NAME_EDEFAULT;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected ErrorPredicateImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.ERROR_PREDICATE;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String getName()
+  {
+    return name;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setName(String newName)
+  {
+    String oldName = name;
+    name = newName;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ERROR_PREDICATE__NAME, oldName, name));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.ERROR_PREDICATE__NAME:
+        return getName();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.ERROR_PREDICATE__NAME:
+        setName((String)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.ERROR_PREDICATE__NAME:
+        setName(NAME_EDEFAULT);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.ERROR_PREDICATE__NAME:
+        return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+    }
+    return super.eIsSet(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String toString()
+  {
+    if (eIsProxy()) return super.toString();
+    StringBuilder result = new StringBuilder(super.toString());
+    result.append(" (name: ");
+    result.append(name);
+    result.append(')');
+    return result.toString();
+  }
+} //ErrorPredicateImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExistSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExistSymbolImpl.java
new file mode 100644
index 00000000..2fd59e41
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExistSymbolImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Exist Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class ExistSymbolImpl extends PartialitySymbolImpl implements ExistSymbol
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected ExistSymbolImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.EXIST_SYMBOL;
+  }
+} //ExistSymbolImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FalseImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FalseImpl.java
new file mode 100644
index 00000000..332f9af3
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FalseImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.False;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>False</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class FalseImpl extends TruthValueImpl implements False
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected FalseImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.FALSE;
+  }
+} //FalseImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FieldRelationInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FieldRelationInterpretationImpl.java
new file mode 100644
index 00000000..ea9b80b2
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FieldRelationInterpretationImpl.java
@@ -0,0 +1,418 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.Symbol;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Field Relation Interpretation</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl#isContainment <em>Containment</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl#getSymbol <em>Symbol</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl#getMultiplicity <em>Multiplicity</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl#getTarget <em>Target</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class FieldRelationInterpretationImpl extends MinimalEObjectImpl.Container implements FieldRelationInterpretation
+{
+  /**
+   * The default value of the '{@link #isContainment() <em>Containment</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #isContainment()
+   * @generated
+   * @ordered
+   */
+  protected static final boolean CONTAINMENT_EDEFAULT = false;
+  /**
+   * The cached value of the '{@link #isContainment() <em>Containment</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #isContainment()
+   * @generated
+   * @ordered
+   */
+  protected boolean containment = CONTAINMENT_EDEFAULT;
+  /**
+   * The cached value of the '{@link #getSymbol() <em>Symbol</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getSymbol()
+   * @generated
+   * @ordered
+   */
+  protected ModelSymbol symbol;
+  /**
+   * The cached value of the '{@link #getMultiplicity() <em>Multiplicity</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getMultiplicity()
+   * @generated
+   * @ordered
+   */
+  protected MultiplicityDefinition multiplicity;
+  /**
+   * The cached value of the '{@link #getTarget() <em>Target</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getTarget()
+   * @generated
+   * @ordered
+   */
+  protected Symbol target;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected FieldRelationInterpretationImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.FIELD_RELATION_INTERPRETATION;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean isContainment()
+  {
+    return containment;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setContainment(boolean newContainment)
+  {
+    boolean oldContainment = containment;
+    containment = newContainment;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__CONTAINMENT, oldContainment, containment));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public ModelSymbol getSymbol()
+  {
+    return symbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs)
+  {
+    ModelSymbol oldSymbol = symbol;
+    symbol = newSymbol;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL, oldSymbol, newSymbol);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setSymbol(ModelSymbol newSymbol)
+  {
+    if (newSymbol != symbol)
+    {
+      NotificationChain msgs = null;
+      if (symbol != null)
+        msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL, null, msgs);
+      if (newSymbol != null)
+        msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL, null, msgs);
+      msgs = basicSetSymbol(newSymbol, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL, newSymbol, newSymbol));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public MultiplicityDefinition getMultiplicity()
+  {
+    return multiplicity;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetMultiplicity(MultiplicityDefinition newMultiplicity, NotificationChain msgs)
+  {
+    MultiplicityDefinition oldMultiplicity = multiplicity;
+    multiplicity = newMultiplicity;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY, oldMultiplicity, newMultiplicity);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setMultiplicity(MultiplicityDefinition newMultiplicity)
+  {
+    if (newMultiplicity != multiplicity)
+    {
+      NotificationChain msgs = null;
+      if (multiplicity != null)
+        msgs = ((InternalEObject)multiplicity).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY, null, msgs);
+      if (newMultiplicity != null)
+        msgs = ((InternalEObject)newMultiplicity).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY, null, msgs);
+      msgs = basicSetMultiplicity(newMultiplicity, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY, newMultiplicity, newMultiplicity));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Symbol getTarget()
+  {
+    return target;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetTarget(Symbol newTarget, NotificationChain msgs)
+  {
+    Symbol oldTarget = target;
+    target = newTarget;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET, oldTarget, newTarget);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setTarget(Symbol newTarget)
+  {
+    if (newTarget != target)
+    {
+      NotificationChain msgs = null;
+      if (target != null)
+        msgs = ((InternalEObject)target).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET, null, msgs);
+      if (newTarget != null)
+        msgs = ((InternalEObject)newTarget).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET, null, msgs);
+      msgs = basicSetTarget(newTarget, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET, newTarget, newTarget));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL:
+        return basicSetSymbol(null, msgs);
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY:
+        return basicSetMultiplicity(null, msgs);
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET:
+        return basicSetTarget(null, msgs);
+    }
+    return super.eInverseRemove(otherEnd, featureID, msgs);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__CONTAINMENT:
+        return isContainment();
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL:
+        return getSymbol();
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY:
+        return getMultiplicity();
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET:
+        return getTarget();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__CONTAINMENT:
+        setContainment((Boolean)newValue);
+        return;
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL:
+        setSymbol((ModelSymbol)newValue);
+        return;
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY:
+        setMultiplicity((MultiplicityDefinition)newValue);
+        return;
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET:
+        setTarget((Symbol)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__CONTAINMENT:
+        setContainment(CONTAINMENT_EDEFAULT);
+        return;
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL:
+        setSymbol((ModelSymbol)null);
+        return;
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY:
+        setMultiplicity((MultiplicityDefinition)null);
+        return;
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET:
+        setTarget((Symbol)null);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__CONTAINMENT:
+        return containment != CONTAINMENT_EDEFAULT;
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL:
+        return symbol != null;
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY:
+        return multiplicity != null;
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET:
+        return target != null;
+    }
+    return super.eIsSet(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String toString()
+  {
+    if (eIsProxy()) return super.toString();
+    StringBuilder result = new StringBuilder(super.toString());
+    result.append(" (containment: ");
+    result.append(containment);
+    result.append(')');
+    return result.toString();
+  }
+} //FieldRelationInterpretationImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/GlobalRelationInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/GlobalRelationInterpretationImpl.java
new file mode 100644
index 00000000..52f7a67d
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/GlobalRelationInterpretationImpl.java
@@ -0,0 +1,563 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.Symbol;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Global Relation Interpretation</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#isContainment <em>Containment</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#getSymbol <em>Symbol</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#getSourceMultiplicity <em>Source Multiplicity</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#getSource <em>Source</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#getTargetMultiplicity <em>Target Multiplicity</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#getTarget <em>Target</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class GlobalRelationInterpretationImpl extends CDInterpretationImpl implements GlobalRelationInterpretation
+{
+  /**
+   * The default value of the '{@link #isContainment() <em>Containment</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #isContainment()
+   * @generated
+   * @ordered
+   */
+  protected static final boolean CONTAINMENT_EDEFAULT = false;
+  /**
+   * The cached value of the '{@link #isContainment() <em>Containment</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #isContainment()
+   * @generated
+   * @ordered
+   */
+  protected boolean containment = CONTAINMENT_EDEFAULT;
+  /**
+   * The cached value of the '{@link #getSymbol() <em>Symbol</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getSymbol()
+   * @generated
+   * @ordered
+   */
+  protected ModelSymbol symbol;
+  /**
+   * The cached value of the '{@link #getSourceMultiplicity() <em>Source Multiplicity</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getSourceMultiplicity()
+   * @generated
+   * @ordered
+   */
+  protected MultiplicityDefinition sourceMultiplicity;
+  /**
+   * The cached value of the '{@link #getSource() <em>Source</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getSource()
+   * @generated
+   * @ordered
+   */
+  protected Symbol source;
+  /**
+   * The cached value of the '{@link #getTargetMultiplicity() <em>Target Multiplicity</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getTargetMultiplicity()
+   * @generated
+   * @ordered
+   */
+  protected MultiplicityDefinition targetMultiplicity;
+  /**
+   * The cached value of the '{@link #getTarget() <em>Target</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getTarget()
+   * @generated
+   * @ordered
+   */
+  protected Symbol target;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected GlobalRelationInterpretationImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.GLOBAL_RELATION_INTERPRETATION;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean isContainment()
+  {
+    return containment;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setContainment(boolean newContainment)
+  {
+    boolean oldContainment = containment;
+    containment = newContainment;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__CONTAINMENT, oldContainment, containment));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public ModelSymbol getSymbol()
+  {
+    return symbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs)
+  {
+    ModelSymbol oldSymbol = symbol;
+    symbol = newSymbol;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL, oldSymbol, newSymbol);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setSymbol(ModelSymbol newSymbol)
+  {
+    if (newSymbol != symbol)
+    {
+      NotificationChain msgs = null;
+      if (symbol != null)
+        msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL, null, msgs);
+      if (newSymbol != null)
+        msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL, null, msgs);
+      msgs = basicSetSymbol(newSymbol, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL, newSymbol, newSymbol));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public MultiplicityDefinition getSourceMultiplicity()
+  {
+    return sourceMultiplicity;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetSourceMultiplicity(MultiplicityDefinition newSourceMultiplicity, NotificationChain msgs)
+  {
+    MultiplicityDefinition oldSourceMultiplicity = sourceMultiplicity;
+    sourceMultiplicity = newSourceMultiplicity;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY, oldSourceMultiplicity, newSourceMultiplicity);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setSourceMultiplicity(MultiplicityDefinition newSourceMultiplicity)
+  {
+    if (newSourceMultiplicity != sourceMultiplicity)
+    {
+      NotificationChain msgs = null;
+      if (sourceMultiplicity != null)
+        msgs = ((InternalEObject)sourceMultiplicity).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY, null, msgs);
+      if (newSourceMultiplicity != null)
+        msgs = ((InternalEObject)newSourceMultiplicity).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY, null, msgs);
+      msgs = basicSetSourceMultiplicity(newSourceMultiplicity, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY, newSourceMultiplicity, newSourceMultiplicity));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Symbol getSource()
+  {
+    return source;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetSource(Symbol newSource, NotificationChain msgs)
+  {
+    Symbol oldSource = source;
+    source = newSource;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE, oldSource, newSource);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setSource(Symbol newSource)
+  {
+    if (newSource != source)
+    {
+      NotificationChain msgs = null;
+      if (source != null)
+        msgs = ((InternalEObject)source).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE, null, msgs);
+      if (newSource != null)
+        msgs = ((InternalEObject)newSource).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE, null, msgs);
+      msgs = basicSetSource(newSource, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE, newSource, newSource));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public MultiplicityDefinition getTargetMultiplicity()
+  {
+    return targetMultiplicity;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetTargetMultiplicity(MultiplicityDefinition newTargetMultiplicity, NotificationChain msgs)
+  {
+    MultiplicityDefinition oldTargetMultiplicity = targetMultiplicity;
+    targetMultiplicity = newTargetMultiplicity;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY, oldTargetMultiplicity, newTargetMultiplicity);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setTargetMultiplicity(MultiplicityDefinition newTargetMultiplicity)
+  {
+    if (newTargetMultiplicity != targetMultiplicity)
+    {
+      NotificationChain msgs = null;
+      if (targetMultiplicity != null)
+        msgs = ((InternalEObject)targetMultiplicity).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY, null, msgs);
+      if (newTargetMultiplicity != null)
+        msgs = ((InternalEObject)newTargetMultiplicity).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY, null, msgs);
+      msgs = basicSetTargetMultiplicity(newTargetMultiplicity, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY, newTargetMultiplicity, newTargetMultiplicity));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Symbol getTarget()
+  {
+    return target;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetTarget(Symbol newTarget, NotificationChain msgs)
+  {
+    Symbol oldTarget = target;
+    target = newTarget;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET, oldTarget, newTarget);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setTarget(Symbol newTarget)
+  {
+    if (newTarget != target)
+    {
+      NotificationChain msgs = null;
+      if (target != null)
+        msgs = ((InternalEObject)target).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET, null, msgs);
+      if (newTarget != null)
+        msgs = ((InternalEObject)newTarget).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET, null, msgs);
+      msgs = basicSetTarget(newTarget, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET, newTarget, newTarget));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL:
+        return basicSetSymbol(null, msgs);
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY:
+        return basicSetSourceMultiplicity(null, msgs);
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE:
+        return basicSetSource(null, msgs);
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY:
+        return basicSetTargetMultiplicity(null, msgs);
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET:
+        return basicSetTarget(null, msgs);
+    }
+    return super.eInverseRemove(otherEnd, featureID, msgs);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__CONTAINMENT:
+        return isContainment();
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL:
+        return getSymbol();
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY:
+        return getSourceMultiplicity();
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE:
+        return getSource();
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY:
+        return getTargetMultiplicity();
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET:
+        return getTarget();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__CONTAINMENT:
+        setContainment((Boolean)newValue);
+        return;
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL:
+        setSymbol((ModelSymbol)newValue);
+        return;
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY:
+        setSourceMultiplicity((MultiplicityDefinition)newValue);
+        return;
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE:
+        setSource((Symbol)newValue);
+        return;
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY:
+        setTargetMultiplicity((MultiplicityDefinition)newValue);
+        return;
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET:
+        setTarget((Symbol)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__CONTAINMENT:
+        setContainment(CONTAINMENT_EDEFAULT);
+        return;
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL:
+        setSymbol((ModelSymbol)null);
+        return;
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY:
+        setSourceMultiplicity((MultiplicityDefinition)null);
+        return;
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE:
+        setSource((Symbol)null);
+        return;
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY:
+        setTargetMultiplicity((MultiplicityDefinition)null);
+        return;
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET:
+        setTarget((Symbol)null);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__CONTAINMENT:
+        return containment != CONTAINMENT_EDEFAULT;
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL:
+        return symbol != null;
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY:
+        return sourceMultiplicity != null;
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE:
+        return source != null;
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY:
+        return targetMultiplicity != null;
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET:
+        return target != null;
+    }
+    return super.eIsSet(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String toString()
+  {
+    if (eIsProxy()) return super.toString();
+    StringBuilder result = new StringBuilder(super.toString());
+    result.append(" (containment: ");
+    result.append(containment);
+    result.append(')');
+    return result.toString();
+  }
+} //GlobalRelationInterpretationImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntObjectImpl.java
new file mode 100644
index 00000000..fa844b68
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntObjectImpl.java
@@ -0,0 +1,179 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.IntObject;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Int Object</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntObjectImpl#getValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class IntObjectImpl extends DataObjectImpl implements IntObject
+{
+  /**
+   * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getValue()
+   * @generated
+   * @ordered
+   */
+  protected static final int VALUE_EDEFAULT = 0;
+  /**
+   * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getValue()
+   * @generated
+   * @ordered
+   */
+  protected int value = VALUE_EDEFAULT;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected IntObjectImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.INT_OBJECT;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public int getValue()
+  {
+    return value;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setValue(int newValue)
+  {
+    int oldValue = value;
+    value = newValue;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.INT_OBJECT__VALUE, oldValue, value));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.INT_OBJECT__VALUE:
+        return getValue();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.INT_OBJECT__VALUE:
+        setValue((Integer)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.INT_OBJECT__VALUE:
+        setValue(VALUE_EDEFAULT);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.INT_OBJECT__VALUE:
+        return value != VALUE_EDEFAULT;
+    }
+    return super.eIsSet(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String toString()
+  {
+    if (eIsProxy()) return super.toString();
+    StringBuilder result = new StringBuilder(super.toString());
+    result.append(" (value: ");
+    result.append(value);
+    result.append(')');
+    return result.toString();
+  }
+} //IntObjectImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntegerSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntegerSymbolImpl.java
new file mode 100644
index 00000000..bcd978fa
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntegerSymbolImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Integer Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class IntegerSymbolImpl extends DataSymbolImpl implements IntegerSymbol
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected IntegerSymbolImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.INTEGER_SYMBOL;
+  }
+} //IntegerSymbolImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/InterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/InterpretationImpl.java
new file mode 100644
index 00000000..fb41d77d
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/InterpretationImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.Interpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Interpretation</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class InterpretationImpl extends StatementImpl implements Interpretation
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected InterpretationImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.INTERPRETATION;
+  }
+} //InterpretationImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IrreflexiveClosureImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IrreflexiveClosureImpl.java
new file mode 100644
index 00000000..07ad66f9
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IrreflexiveClosureImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Irreflexive Closure</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class IrreflexiveClosureImpl extends ClosureTypeImpl implements IrreflexiveClosure
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected IrreflexiveClosureImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.IRREFLEXIVE_CLOSURE;
+  }
+} //IrreflexiveClosureImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/LiteralImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/LiteralImpl.java
new file mode 100644
index 00000000..518aa2b7
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/LiteralImpl.java
@@ -0,0 +1,43 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.Literal;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Literal</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class LiteralImpl extends MinimalEObjectImpl.Container implements Literal
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected LiteralImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.LITERAL;
+  }
+} //LiteralImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ModelSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ModelSymbolImpl.java
new file mode 100644
index 00000000..bd195572
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ModelSymbolImpl.java
@@ -0,0 +1,179 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Model Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ModelSymbolImpl#getName <em>Name</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class ModelSymbolImpl extends SymbolImpl implements ModelSymbol
+{
+  /**
+   * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getName()
+   * @generated
+   * @ordered
+   */
+  protected static final String NAME_EDEFAULT = null;
+  /**
+   * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getName()
+   * @generated
+   * @ordered
+   */
+  protected String name = NAME_EDEFAULT;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected ModelSymbolImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.MODEL_SYMBOL;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String getName()
+  {
+    return name;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setName(String newName)
+  {
+    String oldName = name;
+    name = newName;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MODEL_SYMBOL__NAME, oldName, name));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.MODEL_SYMBOL__NAME:
+        return getName();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.MODEL_SYMBOL__NAME:
+        setName((String)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.MODEL_SYMBOL__NAME:
+        setName(NAME_EDEFAULT);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.MODEL_SYMBOL__NAME:
+        return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+    }
+    return super.eIsSet(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String toString()
+  {
+    if (eIsProxy()) return super.toString();
+    StringBuilder result = new StringBuilder(super.toString());
+    result.append(" (name: ");
+    result.append(name);
+    result.append(')');
+    return result.toString();
+  }
+} //ModelSymbolImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MultiplicityDefinitionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MultiplicityDefinitionImpl.java
new file mode 100644
index 00000000..a346568c
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MultiplicityDefinitionImpl.java
@@ -0,0 +1,296 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Multiplicity Definition</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl#getLower <em>Lower</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl#getUpper <em>Upper</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl#isUnlimitedUpper <em>Unlimited Upper</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class MultiplicityDefinitionImpl extends MinimalEObjectImpl.Container implements MultiplicityDefinition
+{
+  /**
+   * The default value of the '{@link #getLower() <em>Lower</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getLower()
+   * @generated
+   * @ordered
+   */
+  protected static final int LOWER_EDEFAULT = 0;
+  /**
+   * The cached value of the '{@link #getLower() <em>Lower</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getLower()
+   * @generated
+   * @ordered
+   */
+  protected int lower = LOWER_EDEFAULT;
+  /**
+   * The default value of the '{@link #getUpper() <em>Upper</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getUpper()
+   * @generated
+   * @ordered
+   */
+  protected static final int UPPER_EDEFAULT = 0;
+  /**
+   * The cached value of the '{@link #getUpper() <em>Upper</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getUpper()
+   * @generated
+   * @ordered
+   */
+  protected int upper = UPPER_EDEFAULT;
+  /**
+   * The default value of the '{@link #isUnlimitedUpper() <em>Unlimited Upper</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #isUnlimitedUpper()
+   * @generated
+   * @ordered
+   */
+  protected static final boolean UNLIMITED_UPPER_EDEFAULT = false;
+  /**
+   * The cached value of the '{@link #isUnlimitedUpper() <em>Unlimited Upper</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #isUnlimitedUpper()
+   * @generated
+   * @ordered
+   */
+  protected boolean unlimitedUpper = UNLIMITED_UPPER_EDEFAULT;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected MultiplicityDefinitionImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.MULTIPLICITY_DEFINITION;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public int getLower()
+  {
+    return lower;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setLower(int newLower)
+  {
+    int oldLower = lower;
+    lower = newLower;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MULTIPLICITY_DEFINITION__LOWER, oldLower, lower));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public int getUpper()
+  {
+    return upper;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setUpper(int newUpper)
+  {
+    int oldUpper = upper;
+    upper = newUpper;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MULTIPLICITY_DEFINITION__UPPER, oldUpper, upper));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean isUnlimitedUpper()
+  {
+    return unlimitedUpper;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setUnlimitedUpper(boolean newUnlimitedUpper)
+  {
+    boolean oldUnlimitedUpper = unlimitedUpper;
+    unlimitedUpper = newUnlimitedUpper;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MULTIPLICITY_DEFINITION__UNLIMITED_UPPER, oldUnlimitedUpper, unlimitedUpper));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.MULTIPLICITY_DEFINITION__LOWER:
+        return getLower();
+      case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UPPER:
+        return getUpper();
+      case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UNLIMITED_UPPER:
+        return isUnlimitedUpper();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.MULTIPLICITY_DEFINITION__LOWER:
+        setLower((Integer)newValue);
+        return;
+      case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UPPER:
+        setUpper((Integer)newValue);
+        return;
+      case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UNLIMITED_UPPER:
+        setUnlimitedUpper((Boolean)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.MULTIPLICITY_DEFINITION__LOWER:
+        setLower(LOWER_EDEFAULT);
+        return;
+      case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UPPER:
+        setUpper(UPPER_EDEFAULT);
+        return;
+      case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UNLIMITED_UPPER:
+        setUnlimitedUpper(UNLIMITED_UPPER_EDEFAULT);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.MULTIPLICITY_DEFINITION__LOWER:
+        return lower != LOWER_EDEFAULT;
+      case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UPPER:
+        return upper != UPPER_EDEFAULT;
+      case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UNLIMITED_UPPER:
+        return unlimitedUpper != UNLIMITED_UPPER_EDEFAULT;
+    }
+    return super.eIsSet(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String toString()
+  {
+    if (eIsProxy()) return super.toString();
+    StringBuilder result = new StringBuilder(super.toString());
+    result.append(" (lower: ");
+    result.append(lower);
+    result.append(", upper: ");
+    result.append(upper);
+    result.append(", unlimitedUpper: ");
+    result.append(unlimitedUpper);
+    result.append(')');
+    return result.toString();
+  }
+} //MultiplicityDefinitionImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NamedObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NamedObjectImpl.java
new file mode 100644
index 00000000..9d907661
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NamedObjectImpl.java
@@ -0,0 +1,179 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.NamedObject;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Named Object</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NamedObjectImpl#getName <em>Name</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class NamedObjectImpl extends ObjectImpl implements NamedObject
+{
+  /**
+   * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getName()
+   * @generated
+   * @ordered
+   */
+  protected static final String NAME_EDEFAULT = null;
+  /**
+   * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getName()
+   * @generated
+   * @ordered
+   */
+  protected String name = NAME_EDEFAULT;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected NamedObjectImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.NAMED_OBJECT;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String getName()
+  {
+    return name;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setName(String newName)
+  {
+    String oldName = name;
+    name = newName;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.NAMED_OBJECT__NAME, oldName, name));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.NAMED_OBJECT__NAME:
+        return getName();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.NAMED_OBJECT__NAME:
+        setName((String)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.NAMED_OBJECT__NAME:
+        setName(NAME_EDEFAULT);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.NAMED_OBJECT__NAME:
+        return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+    }
+    return super.eIsSet(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String toString()
+  {
+    if (eIsProxy()) return super.toString();
+    StringBuilder result = new StringBuilder(super.toString());
+    result.append(" (name: ");
+    result.append(name);
+    result.append(')');
+    return result.toString();
+  }
+} //NamedObjectImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NegativeImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NegativeImpl.java
new file mode 100644
index 00000000..a30b228f
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NegativeImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.Negative;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Negative</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class NegativeImpl extends PolarityImpl implements Negative
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected NegativeImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.NEGATIVE;
+  }
+} //NegativeImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ObjectImpl.java
new file mode 100644
index 00000000..d2f9b8d9
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ObjectImpl.java
@@ -0,0 +1,40 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Object</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class ObjectImpl extends ComplexObjectImpl implements org.eclipse.viatra.solver.language.solverLanguage.Object
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected ObjectImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.OBJECT;
+  }
+} //ObjectImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ParameterImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ParameterImpl.java
new file mode 100644
index 00000000..6281c4bc
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ParameterImpl.java
@@ -0,0 +1,271 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.Parameter;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.Symbol;
+import org.eclipse.viatra.solver.language.solverLanguage.Variable;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Parameter</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl#getVariable <em>Variable</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl#getType <em>Type</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class ParameterImpl extends MinimalEObjectImpl.Container implements Parameter
+{
+  /**
+   * The cached value of the '{@link #getVariable() <em>Variable</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getVariable()
+   * @generated
+   * @ordered
+   */
+  protected Variable variable;
+  /**
+   * The cached value of the '{@link #getType() <em>Type</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getType()
+   * @generated
+   * @ordered
+   */
+  protected Symbol type;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected ParameterImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.PARAMETER;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Variable getVariable()
+  {
+    return variable;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetVariable(Variable newVariable, NotificationChain msgs)
+  {
+    Variable oldVariable = variable;
+    variable = newVariable;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PARAMETER__VARIABLE, oldVariable, newVariable);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setVariable(Variable newVariable)
+  {
+    if (newVariable != variable)
+    {
+      NotificationChain msgs = null;
+      if (variable != null)
+        msgs = ((InternalEObject)variable).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PARAMETER__VARIABLE, null, msgs);
+      if (newVariable != null)
+        msgs = ((InternalEObject)newVariable).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PARAMETER__VARIABLE, null, msgs);
+      msgs = basicSetVariable(newVariable, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PARAMETER__VARIABLE, newVariable, newVariable));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Symbol getType()
+  {
+    return type;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetType(Symbol newType, NotificationChain msgs)
+  {
+    Symbol oldType = type;
+    type = newType;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PARAMETER__TYPE, oldType, newType);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setType(Symbol newType)
+  {
+    if (newType != type)
+    {
+      NotificationChain msgs = null;
+      if (type != null)
+        msgs = ((InternalEObject)type).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PARAMETER__TYPE, null, msgs);
+      if (newType != null)
+        msgs = ((InternalEObject)newType).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PARAMETER__TYPE, null, msgs);
+      msgs = basicSetType(newType, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PARAMETER__TYPE, newType, newType));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PARAMETER__VARIABLE:
+        return basicSetVariable(null, msgs);
+      case SolverLanguagePackage.PARAMETER__TYPE:
+        return basicSetType(null, msgs);
+    }
+    return super.eInverseRemove(otherEnd, featureID, msgs);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PARAMETER__VARIABLE:
+        return getVariable();
+      case SolverLanguagePackage.PARAMETER__TYPE:
+        return getType();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PARAMETER__VARIABLE:
+        setVariable((Variable)newValue);
+        return;
+      case SolverLanguagePackage.PARAMETER__TYPE:
+        setType((Symbol)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PARAMETER__VARIABLE:
+        setVariable((Variable)null);
+        return;
+      case SolverLanguagePackage.PARAMETER__TYPE:
+        setType((Symbol)null);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PARAMETER__VARIABLE:
+        return variable != null;
+      case SolverLanguagePackage.PARAMETER__TYPE:
+        return type != null;
+    }
+    return super.eIsSet(featureID);
+  }
+} //ParameterImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PartialitySymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PartialitySymbolImpl.java
new file mode 100644
index 00000000..efc2c5f5
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PartialitySymbolImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Partiality Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class PartialitySymbolImpl extends SymbolImpl implements PartialitySymbol
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected PartialitySymbolImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.PARTIALITY_SYMBOL;
+  }
+} //PartialitySymbolImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PatternBodyImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PatternBodyImpl.java
new file mode 100644
index 00000000..5cd03fbf
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PatternBodyImpl.java
@@ -0,0 +1,169 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import java.util.Collection;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.viatra.solver.language.solverLanguage.Constraint;
+import org.eclipse.viatra.solver.language.solverLanguage.PatternBody;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Pattern Body</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PatternBodyImpl#getConstraints <em>Constraints</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class PatternBodyImpl extends MinimalEObjectImpl.Container implements PatternBody
+{
+  /**
+   * The cached value of the '{@link #getConstraints() <em>Constraints</em>}' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getConstraints()
+   * @generated
+   * @ordered
+   */
+  protected EList<Constraint> constraints;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected PatternBodyImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.PATTERN_BODY;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EList<Constraint> getConstraints()
+  {
+    if (constraints == null)
+    {
+      constraints = new EObjectContainmentEList<Constraint>(Constraint.class, this, SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS);
+    }
+    return constraints;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS:
+        return ((InternalEList<?>)getConstraints()).basicRemove(otherEnd, msgs);
+    }
+    return super.eInverseRemove(otherEnd, featureID, msgs);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS:
+        return getConstraints();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @SuppressWarnings("unchecked")
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS:
+        getConstraints().clear();
+        getConstraints().addAll((Collection<? extends Constraint>)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS:
+        getConstraints().clear();
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS:
+        return constraints != null && !constraints.isEmpty();
+    }
+    return super.eIsSet(featureID);
+  }
+} //PatternBodyImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PolarityImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PolarityImpl.java
new file mode 100644
index 00000000..7c2ae07d
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PolarityImpl.java
@@ -0,0 +1,43 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.Polarity;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Polarity</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class PolarityImpl extends MinimalEObjectImpl.Container implements Polarity
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected PolarityImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.POLARITY;
+  }
+} //PolarityImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PositiveImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PositiveImpl.java
new file mode 100644
index 00000000..130cfe7a
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PositiveImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.Positive;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Positive</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class PositiveImpl extends PolarityImpl implements Positive
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected PositiveImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.POSITIVE;
+  }
+} //PositiveImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateImpl.java
new file mode 100644
index 00000000..947d74bb
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateImpl.java
@@ -0,0 +1,207 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import java.util.Collection;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.viatra.solver.language.solverLanguage.Parameter;
+import org.eclipse.viatra.solver.language.solverLanguage.PatternBody;
+import org.eclipse.viatra.solver.language.solverLanguage.Predicate;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Predicate</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl#getParameters <em>Parameters</em>}</li>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl#getBodies <em>Bodies</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class PredicateImpl extends StatementImpl implements Predicate
+{
+  /**
+   * The cached value of the '{@link #getParameters() <em>Parameters</em>}' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getParameters()
+   * @generated
+   * @ordered
+   */
+  protected EList<Parameter> parameters;
+  /**
+   * The cached value of the '{@link #getBodies() <em>Bodies</em>}' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getBodies()
+   * @generated
+   * @ordered
+   */
+  protected EList<PatternBody> bodies;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected PredicateImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.PREDICATE;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EList<Parameter> getParameters()
+  {
+    if (parameters == null)
+    {
+      parameters = new EObjectContainmentEList<Parameter>(Parameter.class, this, SolverLanguagePackage.PREDICATE__PARAMETERS);
+    }
+    return parameters;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EList<PatternBody> getBodies()
+  {
+    if (bodies == null)
+    {
+      bodies = new EObjectContainmentEList<PatternBody>(PatternBody.class, this, SolverLanguagePackage.PREDICATE__BODIES);
+    }
+    return bodies;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PREDICATE__PARAMETERS:
+        return ((InternalEList<?>)getParameters()).basicRemove(otherEnd, msgs);
+      case SolverLanguagePackage.PREDICATE__BODIES:
+        return ((InternalEList<?>)getBodies()).basicRemove(otherEnd, msgs);
+    }
+    return super.eInverseRemove(otherEnd, featureID, msgs);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PREDICATE__PARAMETERS:
+        return getParameters();
+      case SolverLanguagePackage.PREDICATE__BODIES:
+        return getBodies();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @SuppressWarnings("unchecked")
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PREDICATE__PARAMETERS:
+        getParameters().clear();
+        getParameters().addAll((Collection<? extends Parameter>)newValue);
+        return;
+      case SolverLanguagePackage.PREDICATE__BODIES:
+        getBodies().clear();
+        getBodies().addAll((Collection<? extends PatternBody>)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PREDICATE__PARAMETERS:
+        getParameters().clear();
+        return;
+      case SolverLanguagePackage.PREDICATE__BODIES:
+        getBodies().clear();
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PREDICATE__PARAMETERS:
+        return parameters != null && !parameters.isEmpty();
+      case SolverLanguagePackage.PREDICATE__BODIES:
+        return bodies != null && !bodies.isEmpty();
+    }
+    return super.eIsSet(featureID);
+  }
+} //PredicateImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateSymbolImpl.java
new file mode 100644
index 00000000..f49c6701
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateSymbolImpl.java
@@ -0,0 +1,196 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Predicate Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateSymbolImpl#getSymbol <em>Symbol</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class PredicateSymbolImpl extends PredicateImpl implements PredicateSymbol
+{
+  /**
+   * The cached value of the '{@link #getSymbol() <em>Symbol</em>}' containment reference.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getSymbol()
+   * @generated
+   * @ordered
+   */
+  protected ModelSymbol symbol;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected PredicateSymbolImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.PREDICATE_SYMBOL;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public ModelSymbol getSymbol()
+  {
+    return symbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs)
+  {
+    ModelSymbol oldSymbol = symbol;
+    symbol = newSymbol;
+    if (eNotificationRequired())
+    {
+      ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL, oldSymbol, newSymbol);
+      if (msgs == null) msgs = notification; else msgs.add(notification);
+    }
+    return msgs;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setSymbol(ModelSymbol newSymbol)
+  {
+    if (newSymbol != symbol)
+    {
+      NotificationChain msgs = null;
+      if (symbol != null)
+        msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL, null, msgs);
+      if (newSymbol != null)
+        msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL, null, msgs);
+      msgs = basicSetSymbol(newSymbol, msgs);
+      if (msgs != null) msgs.dispatch();
+    }
+    else if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL, newSymbol, newSymbol));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL:
+        return basicSetSymbol(null, msgs);
+    }
+    return super.eInverseRemove(otherEnd, featureID, msgs);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL:
+        return getSymbol();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL:
+        setSymbol((ModelSymbol)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL:
+        setSymbol((ModelSymbol)null);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL:
+        return symbol != null;
+    }
+    return super.eIsSet(featureID);
+  }
+} //PredicateSymbolImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ProblemImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ProblemImpl.java
new file mode 100644
index 00000000..e5cc3585
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ProblemImpl.java
@@ -0,0 +1,169 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import java.util.Collection;
+import org.eclipse.emf.common.notify.NotificationChain;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.viatra.solver.language.solverLanguage.Problem;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.Statement;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Problem</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ProblemImpl#getStatements <em>Statements</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class ProblemImpl extends MinimalEObjectImpl.Container implements Problem
+{
+  /**
+   * The cached value of the '{@link #getStatements() <em>Statements</em>}' containment reference list.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getStatements()
+   * @generated
+   * @ordered
+   */
+  protected EList<Statement> statements;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected ProblemImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.PROBLEM;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EList<Statement> getStatements()
+  {
+    if (statements == null)
+    {
+      statements = new EObjectContainmentEList<Statement>(Statement.class, this, SolverLanguagePackage.PROBLEM__STATEMENTS);
+    }
+    return statements;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PROBLEM__STATEMENTS:
+        return ((InternalEList<?>)getStatements()).basicRemove(otherEnd, msgs);
+    }
+    return super.eInverseRemove(otherEnd, featureID, msgs);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PROBLEM__STATEMENTS:
+        return getStatements();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @SuppressWarnings("unchecked")
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PROBLEM__STATEMENTS:
+        getStatements().clear();
+        getStatements().addAll((Collection<? extends Statement>)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PROBLEM__STATEMENTS:
+        getStatements().clear();
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.PROBLEM__STATEMENTS:
+        return statements != null && !statements.isEmpty();
+    }
+    return super.eIsSet(featureID);
+  }
+} //ProblemImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealObjectImpl.java
new file mode 100644
index 00000000..bc32a9a6
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealObjectImpl.java
@@ -0,0 +1,181 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import java.math.BigDecimal;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.RealObject;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Real Object</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.RealObjectImpl#getValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class RealObjectImpl extends DataObjectImpl implements RealObject
+{
+  /**
+   * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getValue()
+   * @generated
+   * @ordered
+   */
+  protected static final BigDecimal VALUE_EDEFAULT = null;
+  /**
+   * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getValue()
+   * @generated
+   * @ordered
+   */
+  protected BigDecimal value = VALUE_EDEFAULT;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected RealObjectImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.REAL_OBJECT;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public BigDecimal getValue()
+  {
+    return value;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setValue(BigDecimal newValue)
+  {
+    BigDecimal oldValue = value;
+    value = newValue;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.REAL_OBJECT__VALUE, oldValue, value));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.REAL_OBJECT__VALUE:
+        return getValue();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.REAL_OBJECT__VALUE:
+        setValue((BigDecimal)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.REAL_OBJECT__VALUE:
+        setValue(VALUE_EDEFAULT);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.REAL_OBJECT__VALUE:
+        return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value);
+    }
+    return super.eIsSet(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String toString()
+  {
+    if (eIsProxy()) return super.toString();
+    StringBuilder result = new StringBuilder(super.toString());
+    result.append(" (value: ");
+    result.append(value);
+    result.append(')');
+    return result.toString();
+  }
+} //RealObjectImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealSymbolImpl.java
new file mode 100644
index 00000000..8cfd0980
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealSymbolImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.RealSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Real Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class RealSymbolImpl extends DataSymbolImpl implements RealSymbol
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected RealSymbolImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.REAL_SYMBOL;
+  }
+} //RealSymbolImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ReflexiveClosureImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ReflexiveClosureImpl.java
new file mode 100644
index 00000000..111b48cb
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ReflexiveClosureImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Reflexive Closure</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class ReflexiveClosureImpl extends ClosureTypeImpl implements ReflexiveClosure
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected ReflexiveClosureImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.REFLEXIVE_CLOSURE;
+  }
+} //ReflexiveClosureImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java
new file mode 100644
index 00000000..12ffc551
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java
@@ -0,0 +1,851 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.impl.EFactoryImpl;
+import org.eclipse.emf.ecore.plugin.EcorePlugin;
+import org.eclipse.viatra.solver.language.solverLanguage.AllInstances;
+import org.eclipse.viatra.solver.language.solverLanguage.AllObjects;
+import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanObject;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanValue;
+import org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.ClosureType;
+import org.eclipse.viatra.solver.language.solverLanguage.ComplexObject;
+import org.eclipse.viatra.solver.language.solverLanguage.Constraint;
+import org.eclipse.viatra.solver.language.solverLanguage.DataObject;
+import org.eclipse.viatra.solver.language.solverLanguage.DataSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate;
+import org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.False;
+import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.IntObject;
+import org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.Interpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure;
+import org.eclipse.viatra.solver.language.solverLanguage.Literal;
+import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition;
+import org.eclipse.viatra.solver.language.solverLanguage.NamedObject;
+import org.eclipse.viatra.solver.language.solverLanguage.Negative;
+import org.eclipse.viatra.solver.language.solverLanguage.Parameter;
+import org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.PatternBody;
+import org.eclipse.viatra.solver.language.solverLanguage.Polarity;
+import org.eclipse.viatra.solver.language.solverLanguage.Positive;
+import org.eclipse.viatra.solver.language.solverLanguage.Predicate;
+import org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.Problem;
+import org.eclipse.viatra.solver.language.solverLanguage.RealObject;
+import org.eclipse.viatra.solver.language.solverLanguage.RealSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguageFactory;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.Statement;
+import org.eclipse.viatra.solver.language.solverLanguage.StringObject;
+import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.Symbol;
+import org.eclipse.viatra.solver.language.solverLanguage.True;
+import org.eclipse.viatra.solver.language.solverLanguage.TruthValue;
+import org.eclipse.viatra.solver.language.solverLanguage.Unknown;
+import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject;
+import org.eclipse.viatra.solver.language.solverLanguage.Variable;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Factory</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLanguageFactory
+{
+  /**
+   * Creates the default factory implementation.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public static SolverLanguageFactory init()
+  {
+    try
+    {
+      SolverLanguageFactory theSolverLanguageFactory = (SolverLanguageFactory)EPackage.Registry.INSTANCE.getEFactory(SolverLanguagePackage.eNS_URI);
+      if (theSolverLanguageFactory != null)
+      {
+        return theSolverLanguageFactory;
+      }
+    }
+    catch (Exception exception)
+    {
+      EcorePlugin.INSTANCE.log(exception);
+    }
+    return new SolverLanguageFactoryImpl();
+  }
+  /**
+   * Creates an instance of the factory.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public SolverLanguageFactoryImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EObject create(EClass eClass)
+  {
+    switch (eClass.getClassifierID())
+    {
+      case SolverLanguagePackage.PROBLEM: return createProblem();
+      case SolverLanguagePackage.STATEMENT: return createStatement();
+      case SolverLanguagePackage.BOOLEAN_VALUE: return createBooleanValue();
+      case SolverLanguagePackage.TRUTH_VALUE: return createTruthValue();
+      case SolverLanguagePackage.INTERPRETATION: return createInterpretation();
+      case SolverLanguagePackage.BASIC_INTERPRETATION: return createBasicInterpretation();
+      case SolverLanguagePackage.SYMBOL: return createSymbol();
+      case SolverLanguagePackage.MODEL_SYMBOL: return createModelSymbol();
+      case SolverLanguagePackage.PARTIALITY_SYMBOL: return createPartialitySymbol();
+      case SolverLanguagePackage.EXIST_SYMBOL: return createExistSymbol();
+      case SolverLanguagePackage.EQUALS_SYMBOL: return createEqualsSymbol();
+      case SolverLanguagePackage.DATA_SYMBOL: return createDataSymbol();
+      case SolverLanguagePackage.BOOLEAN_SYMBOL: return createBooleanSymbol();
+      case SolverLanguagePackage.INTEGER_SYMBOL: return createIntegerSymbol();
+      case SolverLanguagePackage.REAL_SYMBOL: return createRealSymbol();
+      case SolverLanguagePackage.STRING_SYMBOL: return createStringSymbol();
+      case SolverLanguagePackage.COMPLEX_OBJECT: return createComplexObject();
+      case SolverLanguagePackage.OBJECT: return createObject();
+      case SolverLanguagePackage.NAMED_OBJECT: return createNamedObject();
+      case SolverLanguagePackage.UNNAMED_OBJECT: return createUnnamedObject();
+      case SolverLanguagePackage.DATA_OBJECT: return createDataObject();
+      case SolverLanguagePackage.BOOLEAN_OBJECT: return createBooleanObject();
+      case SolverLanguagePackage.INT_OBJECT: return createIntObject();
+      case SolverLanguagePackage.REAL_OBJECT: return createRealObject();
+      case SolverLanguagePackage.STRING_OBJECT: return createStringObject();
+      case SolverLanguagePackage.PREDICATE: return createPredicate();
+      case SolverLanguagePackage.PREDICATE_SYMBOL: return createPredicateSymbol();
+      case SolverLanguagePackage.ERROR_PREDICATE: return createErrorPredicate();
+      case SolverLanguagePackage.PARAMETER: return createParameter();
+      case SolverLanguagePackage.PATTERN_BODY: return createPatternBody();
+      case SolverLanguagePackage.POLARITY: return createPolarity();
+      case SolverLanguagePackage.CONSTRAINT: return createConstraint();
+      case SolverLanguagePackage.CLOSURE_TYPE: return createClosureType();
+      case SolverLanguagePackage.LITERAL: return createLiteral();
+      case SolverLanguagePackage.VARIABLE: return createVariable();
+      case SolverLanguagePackage.ALL_INSTANCES: return createAllInstances();
+      case SolverLanguagePackage.ALL_OBJECTS: return createAllObjects();
+      case SolverLanguagePackage.DEFAULT_INTERPRETATION: return createDefaultInterpretation();
+      case SolverLanguagePackage.CD_INTERPRETATION: return createCDInterpretation();
+      case SolverLanguagePackage.CLASS_INTERPRETATION: return createClassInterpretation();
+      case SolverLanguagePackage.ENUM_INTERPRETATION: return createEnumInterpretation();
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION: return createFieldRelationInterpretation();
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION: return createGlobalRelationInterpretation();
+      case SolverLanguagePackage.MULTIPLICITY_DEFINITION: return createMultiplicityDefinition();
+      case SolverLanguagePackage.BOOLEAN_TRUE: return createBooleanTrue();
+      case SolverLanguagePackage.BOOLEAN_FALSE: return createBooleanFalse();
+      case SolverLanguagePackage.TRUE: return createTrue();
+      case SolverLanguagePackage.FALSE: return createFalse();
+      case SolverLanguagePackage.UNKNOWN: return createUnknown();
+      case SolverLanguagePackage.ERROR: return createError();
+      case SolverLanguagePackage.POSITIVE: return createPositive();
+      case SolverLanguagePackage.NEGATIVE: return createNegative();
+      case SolverLanguagePackage.REFLEXIVE_CLOSURE: return createReflexiveClosure();
+      case SolverLanguagePackage.IRREFLEXIVE_CLOSURE: return createIrreflexiveClosure();
+      default:
+        throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
+    }
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Problem createProblem()
+  {
+    ProblemImpl problem = new ProblemImpl();
+    return problem;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Statement createStatement()
+  {
+    StatementImpl statement = new StatementImpl();
+    return statement;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public BooleanValue createBooleanValue()
+  {
+    BooleanValueImpl booleanValue = new BooleanValueImpl();
+    return booleanValue;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public TruthValue createTruthValue()
+  {
+    TruthValueImpl truthValue = new TruthValueImpl();
+    return truthValue;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Interpretation createInterpretation()
+  {
+    InterpretationImpl interpretation = new InterpretationImpl();
+    return interpretation;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public BasicInterpretation createBasicInterpretation()
+  {
+    BasicInterpretationImpl basicInterpretation = new BasicInterpretationImpl();
+    return basicInterpretation;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Symbol createSymbol()
+  {
+    SymbolImpl symbol = new SymbolImpl();
+    return symbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public ModelSymbol createModelSymbol()
+  {
+    ModelSymbolImpl modelSymbol = new ModelSymbolImpl();
+    return modelSymbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public PartialitySymbol createPartialitySymbol()
+  {
+    PartialitySymbolImpl partialitySymbol = new PartialitySymbolImpl();
+    return partialitySymbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public ExistSymbol createExistSymbol()
+  {
+    ExistSymbolImpl existSymbol = new ExistSymbolImpl();
+    return existSymbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EqualsSymbol createEqualsSymbol()
+  {
+    EqualsSymbolImpl equalsSymbol = new EqualsSymbolImpl();
+    return equalsSymbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public DataSymbol createDataSymbol()
+  {
+    DataSymbolImpl dataSymbol = new DataSymbolImpl();
+    return dataSymbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public BooleanSymbol createBooleanSymbol()
+  {
+    BooleanSymbolImpl booleanSymbol = new BooleanSymbolImpl();
+    return booleanSymbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public IntegerSymbol createIntegerSymbol()
+  {
+    IntegerSymbolImpl integerSymbol = new IntegerSymbolImpl();
+    return integerSymbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public RealSymbol createRealSymbol()
+  {
+    RealSymbolImpl realSymbol = new RealSymbolImpl();
+    return realSymbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public StringSymbol createStringSymbol()
+  {
+    StringSymbolImpl stringSymbol = new StringSymbolImpl();
+    return stringSymbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public ComplexObject createComplexObject()
+  {
+    ComplexObjectImpl complexObject = new ComplexObjectImpl();
+    return complexObject;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public org.eclipse.viatra.solver.language.solverLanguage.Object createObject()
+  {
+    ObjectImpl object = new ObjectImpl();
+    return object;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public NamedObject createNamedObject()
+  {
+    NamedObjectImpl namedObject = new NamedObjectImpl();
+    return namedObject;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public UnnamedObject createUnnamedObject()
+  {
+    UnnamedObjectImpl unnamedObject = new UnnamedObjectImpl();
+    return unnamedObject;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public DataObject createDataObject()
+  {
+    DataObjectImpl dataObject = new DataObjectImpl();
+    return dataObject;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public BooleanObject createBooleanObject()
+  {
+    BooleanObjectImpl booleanObject = new BooleanObjectImpl();
+    return booleanObject;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public IntObject createIntObject()
+  {
+    IntObjectImpl intObject = new IntObjectImpl();
+    return intObject;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public RealObject createRealObject()
+  {
+    RealObjectImpl realObject = new RealObjectImpl();
+    return realObject;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public StringObject createStringObject()
+  {
+    StringObjectImpl stringObject = new StringObjectImpl();
+    return stringObject;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Predicate createPredicate()
+  {
+    PredicateImpl predicate = new PredicateImpl();
+    return predicate;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public PredicateSymbol createPredicateSymbol()
+  {
+    PredicateSymbolImpl predicateSymbol = new PredicateSymbolImpl();
+    return predicateSymbol;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public ErrorPredicate createErrorPredicate()
+  {
+    ErrorPredicateImpl errorPredicate = new ErrorPredicateImpl();
+    return errorPredicate;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Parameter createParameter()
+  {
+    ParameterImpl parameter = new ParameterImpl();
+    return parameter;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public PatternBody createPatternBody()
+  {
+    PatternBodyImpl patternBody = new PatternBodyImpl();
+    return patternBody;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Polarity createPolarity()
+  {
+    PolarityImpl polarity = new PolarityImpl();
+    return polarity;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Constraint createConstraint()
+  {
+    ConstraintImpl constraint = new ConstraintImpl();
+    return constraint;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public ClosureType createClosureType()
+  {
+    ClosureTypeImpl closureType = new ClosureTypeImpl();
+    return closureType;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Literal createLiteral()
+  {
+    LiteralImpl literal = new LiteralImpl();
+    return literal;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Variable createVariable()
+  {
+    VariableImpl variable = new VariableImpl();
+    return variable;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public AllInstances createAllInstances()
+  {
+    AllInstancesImpl allInstances = new AllInstancesImpl();
+    return allInstances;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public AllObjects createAllObjects()
+  {
+    AllObjectsImpl allObjects = new AllObjectsImpl();
+    return allObjects;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public DefaultInterpretation createDefaultInterpretation()
+  {
+    DefaultInterpretationImpl defaultInterpretation = new DefaultInterpretationImpl();
+    return defaultInterpretation;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public CDInterpretation createCDInterpretation()
+  {
+    CDInterpretationImpl cdInterpretation = new CDInterpretationImpl();
+    return cdInterpretation;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public ClassInterpretation createClassInterpretation()
+  {
+    ClassInterpretationImpl classInterpretation = new ClassInterpretationImpl();
+    return classInterpretation;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EnumInterpretation createEnumInterpretation()
+  {
+    EnumInterpretationImpl enumInterpretation = new EnumInterpretationImpl();
+    return enumInterpretation;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public FieldRelationInterpretation createFieldRelationInterpretation()
+  {
+    FieldRelationInterpretationImpl fieldRelationInterpretation = new FieldRelationInterpretationImpl();
+    return fieldRelationInterpretation;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public GlobalRelationInterpretation createGlobalRelationInterpretation()
+  {
+    GlobalRelationInterpretationImpl globalRelationInterpretation = new GlobalRelationInterpretationImpl();
+    return globalRelationInterpretation;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public MultiplicityDefinition createMultiplicityDefinition()
+  {
+    MultiplicityDefinitionImpl multiplicityDefinition = new MultiplicityDefinitionImpl();
+    return multiplicityDefinition;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public BooleanTrue createBooleanTrue()
+  {
+    BooleanTrueImpl booleanTrue = new BooleanTrueImpl();
+    return booleanTrue;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public BooleanFalse createBooleanFalse()
+  {
+    BooleanFalseImpl booleanFalse = new BooleanFalseImpl();
+    return booleanFalse;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public True createTrue()
+  {
+    TrueImpl true_ = new TrueImpl();
+    return true_;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public False createFalse()
+  {
+    FalseImpl false_ = new FalseImpl();
+    return false_;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Unknown createUnknown()
+  {
+    UnknownImpl unknown = new UnknownImpl();
+    return unknown;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public org.eclipse.viatra.solver.language.solverLanguage.Error createError()
+  {
+    ErrorImpl error = new ErrorImpl();
+    return error;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Positive createPositive()
+  {
+    PositiveImpl positive = new PositiveImpl();
+    return positive;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Negative createNegative()
+  {
+    NegativeImpl negative = new NegativeImpl();
+    return negative;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public ReflexiveClosure createReflexiveClosure()
+  {
+    ReflexiveClosureImpl reflexiveClosure = new ReflexiveClosureImpl();
+    return reflexiveClosure;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public IrreflexiveClosure createIrreflexiveClosure()
+  {
+    IrreflexiveClosureImpl irreflexiveClosure = new IrreflexiveClosureImpl();
+    return irreflexiveClosure;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public SolverLanguagePackage getSolverLanguagePackage()
+  {
+    return (SolverLanguagePackage)getEPackage();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @deprecated
+   * @generated
+   */
+  @Deprecated
+  public static SolverLanguagePackage getPackage()
+  {
+    return SolverLanguagePackage.eINSTANCE;
+  }
+} //SolverLanguageFactoryImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguagePackageImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguagePackageImpl.java
new file mode 100644
index 00000000..9e5d391b
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguagePackageImpl.java
@@ -0,0 +1,2007 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.AllInstances;
+import org.eclipse.viatra.solver.language.solverLanguage.AllObjects;
+import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanObject;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanValue;
+import org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.ClosureType;
+import org.eclipse.viatra.solver.language.solverLanguage.ComplexObject;
+import org.eclipse.viatra.solver.language.solverLanguage.Constraint;
+import org.eclipse.viatra.solver.language.solverLanguage.DataObject;
+import org.eclipse.viatra.solver.language.solverLanguage.DataSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate;
+import org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.False;
+import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.IntObject;
+import org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.Interpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure;
+import org.eclipse.viatra.solver.language.solverLanguage.Literal;
+import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition;
+import org.eclipse.viatra.solver.language.solverLanguage.NamedObject;
+import org.eclipse.viatra.solver.language.solverLanguage.Negative;
+import org.eclipse.viatra.solver.language.solverLanguage.Parameter;
+import org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.PatternBody;
+import org.eclipse.viatra.solver.language.solverLanguage.Polarity;
+import org.eclipse.viatra.solver.language.solverLanguage.Positive;
+import org.eclipse.viatra.solver.language.solverLanguage.Predicate;
+import org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.Problem;
+import org.eclipse.viatra.solver.language.solverLanguage.RealObject;
+import org.eclipse.viatra.solver.language.solverLanguage.RealSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguageFactory;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.Statement;
+import org.eclipse.viatra.solver.language.solverLanguage.StringObject;
+import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.Symbol;
+import org.eclipse.viatra.solver.language.solverLanguage.True;
+import org.eclipse.viatra.solver.language.solverLanguage.TruthValue;
+import org.eclipse.viatra.solver.language.solverLanguage.Unknown;
+import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject;
+import org.eclipse.viatra.solver.language.solverLanguage.Variable;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Package</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLanguagePackage
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass problemEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass statementEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass booleanValueEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass truthValueEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass interpretationEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass basicInterpretationEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass symbolEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass modelSymbolEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass partialitySymbolEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass existSymbolEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass equalsSymbolEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass dataSymbolEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass booleanSymbolEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass integerSymbolEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass realSymbolEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass stringSymbolEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass complexObjectEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass objectEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass namedObjectEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass unnamedObjectEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass dataObjectEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass booleanObjectEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass intObjectEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass realObjectEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass stringObjectEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass predicateEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass predicateSymbolEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass errorPredicateEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass parameterEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass patternBodyEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass polarityEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass constraintEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass closureTypeEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass literalEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass variableEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass allInstancesEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass allObjectsEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass defaultInterpretationEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass cdInterpretationEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass classInterpretationEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass enumInterpretationEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass fieldRelationInterpretationEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass globalRelationInterpretationEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass multiplicityDefinitionEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass booleanTrueEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass booleanFalseEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass trueEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass falseEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass unknownEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass errorEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass positiveEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass negativeEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass reflexiveClosureEClass = null;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private EClass irreflexiveClosureEClass = null;
+  /**
+   * Creates an instance of the model <b>Package</b>, registered with
+   * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
+   * package URI value.
+   * <p>Note: the correct way to create the package is via the static
+   * factory method {@link #init init()}, which also performs
+   * initialization of the package, or returns the registered package,
+   * if one already exists.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see org.eclipse.emf.ecore.EPackage.Registry
+   * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#eNS_URI
+   * @see #init()
+   * @generated
+   */
+  private SolverLanguagePackageImpl()
+  {
+    super(eNS_URI, SolverLanguageFactory.eINSTANCE);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private static boolean isInited = false;
+  /**
+   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon which it depends.
+   *
+   * <p>This method is used to initialize {@link SolverLanguagePackage#eINSTANCE} when that field is accessed.
+   * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #eNS_URI
+   * @see #createPackageContents()
+   * @see #initializePackageContents()
+   * @generated
+   */
+  public static SolverLanguagePackage init()
+  {
+    if (isInited) return (SolverLanguagePackage)EPackage.Registry.INSTANCE.getEPackage(SolverLanguagePackage.eNS_URI);
+    // Obtain or create and register package
+    Object registeredSolverLanguagePackage = EPackage.Registry.INSTANCE.get(eNS_URI);
+    SolverLanguagePackageImpl theSolverLanguagePackage = registeredSolverLanguagePackage instanceof SolverLanguagePackageImpl ? (SolverLanguagePackageImpl)registeredSolverLanguagePackage : new SolverLanguagePackageImpl();
+    isInited = true;
+    // Create package meta-data objects
+    theSolverLanguagePackage.createPackageContents();
+    // Initialize created meta-data
+    theSolverLanguagePackage.initializePackageContents();
+    // Mark meta-data to indicate it can't be changed
+    theSolverLanguagePackage.freeze();
+    // Update the registry and return the package
+    EPackage.Registry.INSTANCE.put(SolverLanguagePackage.eNS_URI, theSolverLanguagePackage);
+    return theSolverLanguagePackage;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getProblem()
+  {
+    return problemEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getProblem_Statements()
+  {
+    return (EReference)problemEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getStatement()
+  {
+    return statementEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getBooleanValue()
+  {
+    return booleanValueEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getTruthValue()
+  {
+    return truthValueEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getInterpretation()
+  {
+    return interpretationEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getBasicInterpretation()
+  {
+    return basicInterpretationEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getBasicInterpretation_Symbol()
+  {
+    return (EReference)basicInterpretationEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getBasicInterpretation_Objects()
+  {
+    return (EReference)basicInterpretationEClass.getEStructuralFeatures().get(1);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getBasicInterpretation_Value()
+  {
+    return (EReference)basicInterpretationEClass.getEStructuralFeatures().get(2);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getSymbol()
+  {
+    return symbolEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getModelSymbol()
+  {
+    return modelSymbolEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EAttribute getModelSymbol_Name()
+  {
+    return (EAttribute)modelSymbolEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getPartialitySymbol()
+  {
+    return partialitySymbolEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getExistSymbol()
+  {
+    return existSymbolEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getEqualsSymbol()
+  {
+    return equalsSymbolEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getDataSymbol()
+  {
+    return dataSymbolEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getBooleanSymbol()
+  {
+    return booleanSymbolEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getIntegerSymbol()
+  {
+    return integerSymbolEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getRealSymbol()
+  {
+    return realSymbolEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getStringSymbol()
+  {
+    return stringSymbolEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getComplexObject()
+  {
+    return complexObjectEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getObject()
+  {
+    return objectEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getNamedObject()
+  {
+    return namedObjectEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EAttribute getNamedObject_Name()
+  {
+    return (EAttribute)namedObjectEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getUnnamedObject()
+  {
+    return unnamedObjectEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EAttribute getUnnamedObject_Name()
+  {
+    return (EAttribute)unnamedObjectEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getDataObject()
+  {
+    return dataObjectEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getBooleanObject()
+  {
+    return booleanObjectEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getBooleanObject_Value()
+  {
+    return (EReference)booleanObjectEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getIntObject()
+  {
+    return intObjectEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EAttribute getIntObject_Value()
+  {
+    return (EAttribute)intObjectEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getRealObject()
+  {
+    return realObjectEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EAttribute getRealObject_Value()
+  {
+    return (EAttribute)realObjectEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getStringObject()
+  {
+    return stringObjectEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EAttribute getStringObject_Value()
+  {
+    return (EAttribute)stringObjectEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getPredicate()
+  {
+    return predicateEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getPredicate_Parameters()
+  {
+    return (EReference)predicateEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getPredicate_Bodies()
+  {
+    return (EReference)predicateEClass.getEStructuralFeatures().get(1);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getPredicateSymbol()
+  {
+    return predicateSymbolEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getPredicateSymbol_Symbol()
+  {
+    return (EReference)predicateSymbolEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getErrorPredicate()
+  {
+    return errorPredicateEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EAttribute getErrorPredicate_Name()
+  {
+    return (EAttribute)errorPredicateEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getParameter()
+  {
+    return parameterEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getParameter_Variable()
+  {
+    return (EReference)parameterEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getParameter_Type()
+  {
+    return (EReference)parameterEClass.getEStructuralFeatures().get(1);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getPatternBody()
+  {
+    return patternBodyEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getPatternBody_Constraints()
+  {
+    return (EReference)patternBodyEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getPolarity()
+  {
+    return polarityEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getConstraint()
+  {
+    return constraintEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getConstraint_Polarity()
+  {
+    return (EReference)constraintEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getConstraint_Symbol()
+  {
+    return (EReference)constraintEClass.getEStructuralFeatures().get(1);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getConstraint_Params()
+  {
+    return (EReference)constraintEClass.getEStructuralFeatures().get(2);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getConstraint_ClosureType()
+  {
+    return (EReference)constraintEClass.getEStructuralFeatures().get(3);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getClosureType()
+  {
+    return closureTypeEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getLiteral()
+  {
+    return literalEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getVariable()
+  {
+    return variableEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EAttribute getVariable_Name()
+  {
+    return (EAttribute)variableEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getAllInstances()
+  {
+    return allInstancesEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getAllInstances_Symbol()
+  {
+    return (EReference)allInstancesEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getAllObjects()
+  {
+    return allObjectsEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getDefaultInterpretation()
+  {
+    return defaultInterpretationEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getDefaultInterpretation_Interpretation()
+  {
+    return (EReference)defaultInterpretationEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getCDInterpretation()
+  {
+    return cdInterpretationEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getClassInterpretation()
+  {
+    return classInterpretationEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EAttribute getClassInterpretation_Abstract()
+  {
+    return (EAttribute)classInterpretationEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getClassInterpretation_Symbol()
+  {
+    return (EReference)classInterpretationEClass.getEStructuralFeatures().get(1);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getClassInterpretation_Supertypes()
+  {
+    return (EReference)classInterpretationEClass.getEStructuralFeatures().get(2);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getClassInterpretation_Fielt()
+  {
+    return (EReference)classInterpretationEClass.getEStructuralFeatures().get(3);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getEnumInterpretation()
+  {
+    return enumInterpretationEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getEnumInterpretation_Symbol()
+  {
+    return (EReference)enumInterpretationEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getEnumInterpretation_Objects()
+  {
+    return (EReference)enumInterpretationEClass.getEStructuralFeatures().get(1);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getFieldRelationInterpretation()
+  {
+    return fieldRelationInterpretationEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EAttribute getFieldRelationInterpretation_Containment()
+  {
+    return (EAttribute)fieldRelationInterpretationEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getFieldRelationInterpretation_Symbol()
+  {
+    return (EReference)fieldRelationInterpretationEClass.getEStructuralFeatures().get(1);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getFieldRelationInterpretation_Multiplicity()
+  {
+    return (EReference)fieldRelationInterpretationEClass.getEStructuralFeatures().get(2);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getFieldRelationInterpretation_Target()
+  {
+    return (EReference)fieldRelationInterpretationEClass.getEStructuralFeatures().get(3);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getGlobalRelationInterpretation()
+  {
+    return globalRelationInterpretationEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EAttribute getGlobalRelationInterpretation_Containment()
+  {
+    return (EAttribute)globalRelationInterpretationEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getGlobalRelationInterpretation_Symbol()
+  {
+    return (EReference)globalRelationInterpretationEClass.getEStructuralFeatures().get(1);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getGlobalRelationInterpretation_SourceMultiplicity()
+  {
+    return (EReference)globalRelationInterpretationEClass.getEStructuralFeatures().get(2);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getGlobalRelationInterpretation_Source()
+  {
+    return (EReference)globalRelationInterpretationEClass.getEStructuralFeatures().get(3);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getGlobalRelationInterpretation_TargetMultiplicity()
+  {
+    return (EReference)globalRelationInterpretationEClass.getEStructuralFeatures().get(4);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EReference getGlobalRelationInterpretation_Target()
+  {
+    return (EReference)globalRelationInterpretationEClass.getEStructuralFeatures().get(5);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getMultiplicityDefinition()
+  {
+    return multiplicityDefinitionEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EAttribute getMultiplicityDefinition_Lower()
+  {
+    return (EAttribute)multiplicityDefinitionEClass.getEStructuralFeatures().get(0);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EAttribute getMultiplicityDefinition_Upper()
+  {
+    return (EAttribute)multiplicityDefinitionEClass.getEStructuralFeatures().get(1);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EAttribute getMultiplicityDefinition_UnlimitedUpper()
+  {
+    return (EAttribute)multiplicityDefinitionEClass.getEStructuralFeatures().get(2);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getBooleanTrue()
+  {
+    return booleanTrueEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getBooleanFalse()
+  {
+    return booleanFalseEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getTrue()
+  {
+    return trueEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getFalse()
+  {
+    return falseEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getUnknown()
+  {
+    return unknownEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getError()
+  {
+    return errorEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getPositive()
+  {
+    return positiveEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getNegative()
+  {
+    return negativeEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getReflexiveClosure()
+  {
+    return reflexiveClosureEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public EClass getIrreflexiveClosure()
+  {
+    return irreflexiveClosureEClass;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public SolverLanguageFactory getSolverLanguageFactory()
+  {
+    return (SolverLanguageFactory)getEFactoryInstance();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private boolean isCreated = false;
+  /**
+   * Creates the meta-model objects for the package.  This method is
+   * guarded to have no affect on any invocation but its first.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public void createPackageContents()
+  {
+    if (isCreated) return;
+    isCreated = true;
+    // Create classes and their features
+    problemEClass = createEClass(PROBLEM);
+    createEReference(problemEClass, PROBLEM__STATEMENTS);
+    statementEClass = createEClass(STATEMENT);
+    booleanValueEClass = createEClass(BOOLEAN_VALUE);
+    truthValueEClass = createEClass(TRUTH_VALUE);
+    interpretationEClass = createEClass(INTERPRETATION);
+    basicInterpretationEClass = createEClass(BASIC_INTERPRETATION);
+    createEReference(basicInterpretationEClass, BASIC_INTERPRETATION__SYMBOL);
+    createEReference(basicInterpretationEClass, BASIC_INTERPRETATION__OBJECTS);
+    createEReference(basicInterpretationEClass, BASIC_INTERPRETATION__VALUE);
+    symbolEClass = createEClass(SYMBOL);
+    modelSymbolEClass = createEClass(MODEL_SYMBOL);
+    createEAttribute(modelSymbolEClass, MODEL_SYMBOL__NAME);
+    partialitySymbolEClass = createEClass(PARTIALITY_SYMBOL);
+    existSymbolEClass = createEClass(EXIST_SYMBOL);
+    equalsSymbolEClass = createEClass(EQUALS_SYMBOL);
+    dataSymbolEClass = createEClass(DATA_SYMBOL);
+    booleanSymbolEClass = createEClass(BOOLEAN_SYMBOL);
+    integerSymbolEClass = createEClass(INTEGER_SYMBOL);
+    realSymbolEClass = createEClass(REAL_SYMBOL);
+    stringSymbolEClass = createEClass(STRING_SYMBOL);
+    complexObjectEClass = createEClass(COMPLEX_OBJECT);
+    objectEClass = createEClass(OBJECT);
+    namedObjectEClass = createEClass(NAMED_OBJECT);
+    createEAttribute(namedObjectEClass, NAMED_OBJECT__NAME);
+    unnamedObjectEClass = createEClass(UNNAMED_OBJECT);
+    createEAttribute(unnamedObjectEClass, UNNAMED_OBJECT__NAME);
+    dataObjectEClass = createEClass(DATA_OBJECT);
+    booleanObjectEClass = createEClass(BOOLEAN_OBJECT);
+    createEReference(booleanObjectEClass, BOOLEAN_OBJECT__VALUE);
+    intObjectEClass = createEClass(INT_OBJECT);
+    createEAttribute(intObjectEClass, INT_OBJECT__VALUE);
+    realObjectEClass = createEClass(REAL_OBJECT);
+    createEAttribute(realObjectEClass, REAL_OBJECT__VALUE);
+    stringObjectEClass = createEClass(STRING_OBJECT);
+    createEAttribute(stringObjectEClass, STRING_OBJECT__VALUE);
+    predicateEClass = createEClass(PREDICATE);
+    createEReference(predicateEClass, PREDICATE__PARAMETERS);
+    createEReference(predicateEClass, PREDICATE__BODIES);
+    predicateSymbolEClass = createEClass(PREDICATE_SYMBOL);
+    createEReference(predicateSymbolEClass, PREDICATE_SYMBOL__SYMBOL);
+    errorPredicateEClass = createEClass(ERROR_PREDICATE);
+    createEAttribute(errorPredicateEClass, ERROR_PREDICATE__NAME);
+    parameterEClass = createEClass(PARAMETER);
+    createEReference(parameterEClass, PARAMETER__VARIABLE);
+    createEReference(parameterEClass, PARAMETER__TYPE);
+    patternBodyEClass = createEClass(PATTERN_BODY);
+    createEReference(patternBodyEClass, PATTERN_BODY__CONSTRAINTS);
+    polarityEClass = createEClass(POLARITY);
+    constraintEClass = createEClass(CONSTRAINT);
+    createEReference(constraintEClass, CONSTRAINT__POLARITY);
+    createEReference(constraintEClass, CONSTRAINT__SYMBOL);
+    createEReference(constraintEClass, CONSTRAINT__PARAMS);
+    createEReference(constraintEClass, CONSTRAINT__CLOSURE_TYPE);
+    closureTypeEClass = createEClass(CLOSURE_TYPE);
+    literalEClass = createEClass(LITERAL);
+    variableEClass = createEClass(VARIABLE);
+    createEAttribute(variableEClass, VARIABLE__NAME);
+    allInstancesEClass = createEClass(ALL_INSTANCES);
+    createEReference(allInstancesEClass, ALL_INSTANCES__SYMBOL);
+    allObjectsEClass = createEClass(ALL_OBJECTS);
+    defaultInterpretationEClass = createEClass(DEFAULT_INTERPRETATION);
+    createEReference(defaultInterpretationEClass, DEFAULT_INTERPRETATION__INTERPRETATION);
+    cdInterpretationEClass = createEClass(CD_INTERPRETATION);
+    classInterpretationEClass = createEClass(CLASS_INTERPRETATION);
+    createEAttribute(classInterpretationEClass, CLASS_INTERPRETATION__ABSTRACT);
+    createEReference(classInterpretationEClass, CLASS_INTERPRETATION__SYMBOL);
+    createEReference(classInterpretationEClass, CLASS_INTERPRETATION__SUPERTYPES);
+    createEReference(classInterpretationEClass, CLASS_INTERPRETATION__FIELT);
+    enumInterpretationEClass = createEClass(ENUM_INTERPRETATION);
+    createEReference(enumInterpretationEClass, ENUM_INTERPRETATION__SYMBOL);
+    createEReference(enumInterpretationEClass, ENUM_INTERPRETATION__OBJECTS);
+    fieldRelationInterpretationEClass = createEClass(FIELD_RELATION_INTERPRETATION);
+    createEAttribute(fieldRelationInterpretationEClass, FIELD_RELATION_INTERPRETATION__CONTAINMENT);
+    createEReference(fieldRelationInterpretationEClass, FIELD_RELATION_INTERPRETATION__SYMBOL);
+    createEReference(fieldRelationInterpretationEClass, FIELD_RELATION_INTERPRETATION__MULTIPLICITY);
+    createEReference(fieldRelationInterpretationEClass, FIELD_RELATION_INTERPRETATION__TARGET);
+    globalRelationInterpretationEClass = createEClass(GLOBAL_RELATION_INTERPRETATION);
+    createEAttribute(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__CONTAINMENT);
+    createEReference(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__SYMBOL);
+    createEReference(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY);
+    createEReference(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__SOURCE);
+    createEReference(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY);
+    createEReference(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__TARGET);
+    multiplicityDefinitionEClass = createEClass(MULTIPLICITY_DEFINITION);
+    createEAttribute(multiplicityDefinitionEClass, MULTIPLICITY_DEFINITION__LOWER);
+    createEAttribute(multiplicityDefinitionEClass, MULTIPLICITY_DEFINITION__UPPER);
+    createEAttribute(multiplicityDefinitionEClass, MULTIPLICITY_DEFINITION__UNLIMITED_UPPER);
+    booleanTrueEClass = createEClass(BOOLEAN_TRUE);
+    booleanFalseEClass = createEClass(BOOLEAN_FALSE);
+    trueEClass = createEClass(TRUE);
+    falseEClass = createEClass(FALSE);
+    unknownEClass = createEClass(UNKNOWN);
+    errorEClass = createEClass(ERROR);
+    positiveEClass = createEClass(POSITIVE);
+    negativeEClass = createEClass(NEGATIVE);
+    reflexiveClosureEClass = createEClass(REFLEXIVE_CLOSURE);
+    irreflexiveClosureEClass = createEClass(IRREFLEXIVE_CLOSURE);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  private boolean isInitialized = false;
+  /**
+   * Complete the initialization of the package and its meta-model.  This
+   * method is guarded to have no affect on any invocation but its first.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public void initializePackageContents()
+  {
+    if (isInitialized) return;
+    isInitialized = true;
+    // Initialize package
+    setName(eNAME);
+    setNsPrefix(eNS_PREFIX);
+    setNsURI(eNS_URI);
+    // Create type parameters
+    // Set bounds for type parameters
+    // Add supertypes to classes
+    interpretationEClass.getESuperTypes().add(this.getStatement());
+    basicInterpretationEClass.getESuperTypes().add(this.getInterpretation());
+    modelSymbolEClass.getESuperTypes().add(this.getSymbol());
+    partialitySymbolEClass.getESuperTypes().add(this.getSymbol());
+    existSymbolEClass.getESuperTypes().add(this.getPartialitySymbol());
+    equalsSymbolEClass.getESuperTypes().add(this.getPartialitySymbol());
+    dataSymbolEClass.getESuperTypes().add(this.getSymbol());
+    booleanSymbolEClass.getESuperTypes().add(this.getDataSymbol());
+    integerSymbolEClass.getESuperTypes().add(this.getDataSymbol());
+    realSymbolEClass.getESuperTypes().add(this.getDataSymbol());
+    stringSymbolEClass.getESuperTypes().add(this.getDataSymbol());
+    objectEClass.getESuperTypes().add(this.getComplexObject());
+    namedObjectEClass.getESuperTypes().add(this.getObject());
+    unnamedObjectEClass.getESuperTypes().add(this.getObject());
+    dataObjectEClass.getESuperTypes().add(this.getObject());
+    dataObjectEClass.getESuperTypes().add(this.getLiteral());
+    booleanObjectEClass.getESuperTypes().add(this.getDataObject());
+    intObjectEClass.getESuperTypes().add(this.getDataObject());
+    realObjectEClass.getESuperTypes().add(this.getDataObject());
+    stringObjectEClass.getESuperTypes().add(this.getDataObject());
+    predicateEClass.getESuperTypes().add(this.getStatement());
+    predicateSymbolEClass.getESuperTypes().add(this.getPredicate());
+    errorPredicateEClass.getESuperTypes().add(this.getPredicate());
+    variableEClass.getESuperTypes().add(this.getLiteral());
+    allInstancesEClass.getESuperTypes().add(this.getComplexObject());
+    allObjectsEClass.getESuperTypes().add(this.getComplexObject());
+    defaultInterpretationEClass.getESuperTypes().add(this.getInterpretation());
+    cdInterpretationEClass.getESuperTypes().add(this.getInterpretation());
+    classInterpretationEClass.getESuperTypes().add(this.getCDInterpretation());
+    enumInterpretationEClass.getESuperTypes().add(this.getCDInterpretation());
+    globalRelationInterpretationEClass.getESuperTypes().add(this.getCDInterpretation());
+    booleanTrueEClass.getESuperTypes().add(this.getBooleanValue());
+    booleanFalseEClass.getESuperTypes().add(this.getBooleanValue());
+    trueEClass.getESuperTypes().add(this.getTruthValue());
+    falseEClass.getESuperTypes().add(this.getTruthValue());
+    unknownEClass.getESuperTypes().add(this.getTruthValue());
+    errorEClass.getESuperTypes().add(this.getTruthValue());
+    positiveEClass.getESuperTypes().add(this.getPolarity());
+    negativeEClass.getESuperTypes().add(this.getPolarity());
+    reflexiveClosureEClass.getESuperTypes().add(this.getClosureType());
+    irreflexiveClosureEClass.getESuperTypes().add(this.getClosureType());
+    // Initialize classes and features; add operations and parameters
+    initEClass(problemEClass, Problem.class, "Problem", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEReference(getProblem_Statements(), this.getStatement(), null, "statements", null, 0, -1, Problem.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(statementEClass, Statement.class, "Statement", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(booleanValueEClass, BooleanValue.class, "BooleanValue", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(truthValueEClass, TruthValue.class, "TruthValue", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(interpretationEClass, Interpretation.class, "Interpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(basicInterpretationEClass, BasicInterpretation.class, "BasicInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEReference(getBasicInterpretation_Symbol(), this.getSymbol(), null, "symbol", null, 0, 1, BasicInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getBasicInterpretation_Objects(), this.getComplexObject(), null, "objects", null, 0, -1, BasicInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getBasicInterpretation_Value(), this.getTruthValue(), null, "value", null, 0, 1, BasicInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(symbolEClass, Symbol.class, "Symbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(modelSymbolEClass, ModelSymbol.class, "ModelSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEAttribute(getModelSymbol_Name(), ecorePackage.getEString(), "name", null, 0, 1, ModelSymbol.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(partialitySymbolEClass, PartialitySymbol.class, "PartialitySymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(existSymbolEClass, ExistSymbol.class, "ExistSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(equalsSymbolEClass, EqualsSymbol.class, "EqualsSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(dataSymbolEClass, DataSymbol.class, "DataSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(booleanSymbolEClass, BooleanSymbol.class, "BooleanSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(integerSymbolEClass, IntegerSymbol.class, "IntegerSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(realSymbolEClass, RealSymbol.class, "RealSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(stringSymbolEClass, StringSymbol.class, "StringSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(complexObjectEClass, ComplexObject.class, "ComplexObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(objectEClass, org.eclipse.viatra.solver.language.solverLanguage.Object.class, "Object", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(namedObjectEClass, NamedObject.class, "NamedObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEAttribute(getNamedObject_Name(), ecorePackage.getEString(), "name", null, 0, 1, NamedObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(unnamedObjectEClass, UnnamedObject.class, "UnnamedObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEAttribute(getUnnamedObject_Name(), ecorePackage.getEString(), "name", null, 0, 1, UnnamedObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(dataObjectEClass, DataObject.class, "DataObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(booleanObjectEClass, BooleanObject.class, "BooleanObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEReference(getBooleanObject_Value(), this.getBooleanValue(), null, "value", null, 0, 1, BooleanObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(intObjectEClass, IntObject.class, "IntObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEAttribute(getIntObject_Value(), ecorePackage.getEInt(), "value", null, 0, 1, IntObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(realObjectEClass, RealObject.class, "RealObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEAttribute(getRealObject_Value(), ecorePackage.getEBigDecimal(), "value", null, 0, 1, RealObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(stringObjectEClass, StringObject.class, "StringObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEAttribute(getStringObject_Value(), ecorePackage.getEString(), "value", null, 0, 1, StringObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(predicateEClass, Predicate.class, "Predicate", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEReference(getPredicate_Parameters(), this.getParameter(), null, "parameters", null, 0, -1, Predicate.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getPredicate_Bodies(), this.getPatternBody(), null, "bodies", null, 0, -1, Predicate.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(predicateSymbolEClass, PredicateSymbol.class, "PredicateSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEReference(getPredicateSymbol_Symbol(), this.getModelSymbol(), null, "symbol", null, 0, 1, PredicateSymbol.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(errorPredicateEClass, ErrorPredicate.class, "ErrorPredicate", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEAttribute(getErrorPredicate_Name(), ecorePackage.getEString(), "name", null, 0, 1, ErrorPredicate.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(parameterEClass, Parameter.class, "Parameter", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEReference(getParameter_Variable(), this.getVariable(), null, "variable", null, 0, 1, Parameter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getParameter_Type(), this.getSymbol(), null, "type", null, 0, 1, Parameter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(patternBodyEClass, PatternBody.class, "PatternBody", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEReference(getPatternBody_Constraints(), this.getConstraint(), null, "constraints", null, 0, -1, PatternBody.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(polarityEClass, Polarity.class, "Polarity", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(constraintEClass, Constraint.class, "Constraint", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEReference(getConstraint_Polarity(), this.getPolarity(), null, "polarity", null, 0, 1, Constraint.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getConstraint_Symbol(), this.getModelSymbol(), null, "symbol", null, 0, 1, Constraint.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getConstraint_Params(), this.getLiteral(), null, "params", null, 0, -1, Constraint.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getConstraint_ClosureType(), this.getClosureType(), null, "closureType", null, 0, 1, Constraint.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(closureTypeEClass, ClosureType.class, "ClosureType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(literalEClass, Literal.class, "Literal", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(variableEClass, Variable.class, "Variable", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEAttribute(getVariable_Name(), ecorePackage.getEString(), "name", null, 0, 1, Variable.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(allInstancesEClass, AllInstances.class, "AllInstances", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEReference(getAllInstances_Symbol(), this.getSymbol(), null, "symbol", null, 0, 1, AllInstances.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(allObjectsEClass, AllObjects.class, "AllObjects", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(defaultInterpretationEClass, DefaultInterpretation.class, "DefaultInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEReference(getDefaultInterpretation_Interpretation(), this.getBasicInterpretation(), null, "interpretation", null, 0, 1, DefaultInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(cdInterpretationEClass, CDInterpretation.class, "CDInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(classInterpretationEClass, ClassInterpretation.class, "ClassInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEAttribute(getClassInterpretation_Abstract(), ecorePackage.getEBoolean(), "abstract", null, 0, 1, ClassInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getClassInterpretation_Symbol(), this.getModelSymbol(), null, "symbol", null, 0, 1, ClassInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getClassInterpretation_Supertypes(), this.getModelSymbol(), null, "supertypes", null, 0, -1, ClassInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getClassInterpretation_Fielt(), this.getFieldRelationInterpretation(), null, "fielt", null, 0, -1, ClassInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(enumInterpretationEClass, EnumInterpretation.class, "EnumInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEReference(getEnumInterpretation_Symbol(), this.getModelSymbol(), null, "Symbol", null, 0, 1, EnumInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getEnumInterpretation_Objects(), this.getNamedObject(), null, "objects", null, 0, -1, EnumInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(fieldRelationInterpretationEClass, FieldRelationInterpretation.class, "FieldRelationInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEAttribute(getFieldRelationInterpretation_Containment(), ecorePackage.getEBoolean(), "containment", null, 0, 1, FieldRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getFieldRelationInterpretation_Symbol(), this.getModelSymbol(), null, "symbol", null, 0, 1, FieldRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getFieldRelationInterpretation_Multiplicity(), this.getMultiplicityDefinition(), null, "multiplicity", null, 0, 1, FieldRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getFieldRelationInterpretation_Target(), this.getSymbol(), null, "target", null, 0, 1, FieldRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(globalRelationInterpretationEClass, GlobalRelationInterpretation.class, "GlobalRelationInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEAttribute(getGlobalRelationInterpretation_Containment(), ecorePackage.getEBoolean(), "containment", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getGlobalRelationInterpretation_Symbol(), this.getModelSymbol(), null, "symbol", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getGlobalRelationInterpretation_SourceMultiplicity(), this.getMultiplicityDefinition(), null, "sourceMultiplicity", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getGlobalRelationInterpretation_Source(), this.getSymbol(), null, "source", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getGlobalRelationInterpretation_TargetMultiplicity(), this.getMultiplicityDefinition(), null, "targetMultiplicity", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEReference(getGlobalRelationInterpretation_Target(), this.getSymbol(), null, "target", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(multiplicityDefinitionEClass, MultiplicityDefinition.class, "MultiplicityDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEAttribute(getMultiplicityDefinition_Lower(), ecorePackage.getEInt(), "lower", null, 0, 1, MultiplicityDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEAttribute(getMultiplicityDefinition_Upper(), ecorePackage.getEInt(), "upper", null, 0, 1, MultiplicityDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEAttribute(getMultiplicityDefinition_UnlimitedUpper(), ecorePackage.getEBoolean(), "unlimitedUpper", null, 0, 1, MultiplicityDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+    initEClass(booleanTrueEClass, BooleanTrue.class, "BooleanTrue", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(booleanFalseEClass, BooleanFalse.class, "BooleanFalse", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(trueEClass, True.class, "True", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(falseEClass, False.class, "False", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(unknownEClass, Unknown.class, "Unknown", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(errorEClass, org.eclipse.viatra.solver.language.solverLanguage.Error.class, "Error", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(positiveEClass, Positive.class, "Positive", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(negativeEClass, Negative.class, "Negative", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(reflexiveClosureEClass, ReflexiveClosure.class, "ReflexiveClosure", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    initEClass(irreflexiveClosureEClass, IrreflexiveClosure.class, "IrreflexiveClosure", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+    // Create resource
+    createResource(eNS_URI);
+  }
+} //SolverLanguagePackageImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StatementImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StatementImpl.java
new file mode 100644
index 00000000..6e660396
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StatementImpl.java
@@ -0,0 +1,43 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.Statement;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Statement</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class StatementImpl extends MinimalEObjectImpl.Container implements Statement
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected StatementImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.STATEMENT;
+  }
+} //StatementImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringObjectImpl.java
new file mode 100644
index 00000000..7a7866a7
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringObjectImpl.java
@@ -0,0 +1,179 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.StringObject;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>String Object</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringObjectImpl#getValue <em>Value</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class StringObjectImpl extends DataObjectImpl implements StringObject
+{
+  /**
+   * The default value of the '{@link #getValue() <em>Value</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getValue()
+   * @generated
+   * @ordered
+   */
+  protected static final String VALUE_EDEFAULT = null;
+  /**
+   * The cached value of the '{@link #getValue() <em>Value</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getValue()
+   * @generated
+   * @ordered
+   */
+  protected String value = VALUE_EDEFAULT;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected StringObjectImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.STRING_OBJECT;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String getValue()
+  {
+    return value;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setValue(String newValue)
+  {
+    String oldValue = value;
+    value = newValue;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.STRING_OBJECT__VALUE, oldValue, value));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.STRING_OBJECT__VALUE:
+        return getValue();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.STRING_OBJECT__VALUE:
+        setValue((String)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.STRING_OBJECT__VALUE:
+        setValue(VALUE_EDEFAULT);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.STRING_OBJECT__VALUE:
+        return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value);
+    }
+    return super.eIsSet(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String toString()
+  {
+    if (eIsProxy()) return super.toString();
+    StringBuilder result = new StringBuilder(super.toString());
+    result.append(" (value: ");
+    result.append(value);
+    result.append(')');
+    return result.toString();
+  }
+} //StringObjectImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringSymbolImpl.java
new file mode 100644
index 00000000..faf3f06a
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringSymbolImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>String Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class StringSymbolImpl extends DataSymbolImpl implements StringSymbol
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected StringSymbolImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.STRING_SYMBOL;
+  }
+} //StringSymbolImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SymbolImpl.java
new file mode 100644
index 00000000..15d1294e
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SymbolImpl.java
@@ -0,0 +1,43 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.Symbol;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Symbol</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class SymbolImpl extends MinimalEObjectImpl.Container implements Symbol
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected SymbolImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.SYMBOL;
+  }
+} //SymbolImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TrueImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TrueImpl.java
new file mode 100644
index 00000000..c0e04a9a
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TrueImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.True;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>True</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class TrueImpl extends TruthValueImpl implements True
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected TrueImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.TRUE;
+  }
+} //TrueImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TruthValueImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TruthValueImpl.java
new file mode 100644
index 00000000..f5b0fba6
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TruthValueImpl.java
@@ -0,0 +1,43 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.TruthValue;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Truth Value</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class TruthValueImpl extends MinimalEObjectImpl.Container implements TruthValue
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected TruthValueImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.TRUTH_VALUE;
+  }
+} //TruthValueImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnknownImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnknownImpl.java
new file mode 100644
index 00000000..44195feb
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnknownImpl.java
@@ -0,0 +1,41 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.Unknown;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Unknown</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * @generated
+ */
+public class UnknownImpl extends TruthValueImpl implements Unknown
+{
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected UnknownImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.UNKNOWN;
+  }
+} //UnknownImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnnamedObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnnamedObjectImpl.java
new file mode 100644
index 00000000..39bec164
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnnamedObjectImpl.java
@@ -0,0 +1,179 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Unnamed Object</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedObjectImpl#getName <em>Name</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class UnnamedObjectImpl extends ObjectImpl implements UnnamedObject
+{
+  /**
+   * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getName()
+   * @generated
+   * @ordered
+   */
+  protected static final String NAME_EDEFAULT = null;
+  /**
+   * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getName()
+   * @generated
+   * @ordered
+   */
+  protected String name = NAME_EDEFAULT;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected UnnamedObjectImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.UNNAMED_OBJECT;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String getName()
+  {
+    return name;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setName(String newName)
+  {
+    String oldName = name;
+    name = newName;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.UNNAMED_OBJECT__NAME, oldName, name));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.UNNAMED_OBJECT__NAME:
+        return getName();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.UNNAMED_OBJECT__NAME:
+        setName((String)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.UNNAMED_OBJECT__NAME:
+        setName(NAME_EDEFAULT);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.UNNAMED_OBJECT__NAME:
+        return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+    }
+    return super.eIsSet(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String toString()
+  {
+    if (eIsProxy()) return super.toString();
+    StringBuilder result = new StringBuilder(super.toString());
+    result.append(" (name: ");
+    result.append(name);
+    result.append(')');
+    return result.toString();
+  }
+} //UnnamedObjectImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/VariableImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/VariableImpl.java
new file mode 100644
index 00000000..9a254023
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/VariableImpl.java
@@ -0,0 +1,179 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.impl;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.Variable;
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>Variable</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.viatra.solver.language.solverLanguage.impl.VariableImpl#getName <em>Name</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class VariableImpl extends LiteralImpl implements Variable
+{
+  /**
+   * The default value of the '{@link #getName() <em>Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getName()
+   * @generated
+   * @ordered
+   */
+  protected static final String NAME_EDEFAULT = null;
+  /**
+   * The cached value of the '{@link #getName() <em>Name</em>}' attribute.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @see #getName()
+   * @generated
+   * @ordered
+   */
+  protected String name = NAME_EDEFAULT;
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected VariableImpl()
+  {
+    super();
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  protected EClass eStaticClass()
+  {
+    return SolverLanguagePackage.Literals.VARIABLE;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String getName()
+  {
+    return name;
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void setName(String newName)
+  {
+    String oldName = name;
+    name = newName;
+    if (eNotificationRequired())
+      eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.VARIABLE__NAME, oldName, name));
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public Object eGet(int featureID, boolean resolve, boolean coreType)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.VARIABLE__NAME:
+        return getName();
+    }
+    return super.eGet(featureID, resolve, coreType);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eSet(int featureID, Object newValue)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.VARIABLE__NAME:
+        setName((String)newValue);
+        return;
+    }
+    super.eSet(featureID, newValue);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public void eUnset(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.VARIABLE__NAME:
+        setName(NAME_EDEFAULT);
+        return;
+    }
+    super.eUnset(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public boolean eIsSet(int featureID)
+  {
+    switch (featureID)
+    {
+      case SolverLanguagePackage.VARIABLE__NAME:
+        return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+    }
+    return super.eIsSet(featureID);
+  }
+  /**
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  @Override
+  public String toString()
+  {
+    if (eIsProxy()) return super.toString();
+    StringBuilder result = new StringBuilder(super.toString());
+    result.append(" (name: ");
+    result.append(name);
+    result.append(')');
+    return result.toString();
+  }
+} //VariableImpl
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageAdapterFactory.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageAdapterFactory.java
new file mode 100644
index 00000000..e76e359a
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageAdapterFactory.java
@@ -0,0 +1,1245 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.util;
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.viatra.solver.language.solverLanguage.AllInstances;
+import org.eclipse.viatra.solver.language.solverLanguage.AllObjects;
+import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanObject;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanValue;
+import org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.ClosureType;
+import org.eclipse.viatra.solver.language.solverLanguage.ComplexObject;
+import org.eclipse.viatra.solver.language.solverLanguage.Constraint;
+import org.eclipse.viatra.solver.language.solverLanguage.DataObject;
+import org.eclipse.viatra.solver.language.solverLanguage.DataSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate;
+import org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.False;
+import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.IntObject;
+import org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.Interpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure;
+import org.eclipse.viatra.solver.language.solverLanguage.Literal;
+import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition;
+import org.eclipse.viatra.solver.language.solverLanguage.NamedObject;
+import org.eclipse.viatra.solver.language.solverLanguage.Negative;
+import org.eclipse.viatra.solver.language.solverLanguage.Parameter;
+import org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.PatternBody;
+import org.eclipse.viatra.solver.language.solverLanguage.Polarity;
+import org.eclipse.viatra.solver.language.solverLanguage.Positive;
+import org.eclipse.viatra.solver.language.solverLanguage.Predicate;
+import org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.Problem;
+import org.eclipse.viatra.solver.language.solverLanguage.RealObject;
+import org.eclipse.viatra.solver.language.solverLanguage.RealSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.Statement;
+import org.eclipse.viatra.solver.language.solverLanguage.StringObject;
+import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.Symbol;
+import org.eclipse.viatra.solver.language.solverLanguage.True;
+import org.eclipse.viatra.solver.language.solverLanguage.TruthValue;
+import org.eclipse.viatra.solver.language.solverLanguage.Unknown;
+import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject;
+import org.eclipse.viatra.solver.language.solverLanguage.Variable;
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Adapter Factory</b> for the model.
+ * It provides an adapter <code>createXXX</code> method for each class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage
+ * @generated
+ */
+public class SolverLanguageAdapterFactory extends AdapterFactoryImpl
+{
+  /**
+   * The cached model package.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected static SolverLanguagePackage modelPackage;
+  /**
+   * Creates an instance of the adapter factory.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public SolverLanguageAdapterFactory()
+  {
+    if (modelPackage == null)
+    {
+      modelPackage = SolverLanguagePackage.eINSTANCE;
+    }
+  }
+  /**
+   * Returns whether this factory is applicable for the type of the object.
+   * <!-- begin-user-doc -->
+   * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
+   * <!-- end-user-doc -->
+   * @return whether this factory is applicable for the type of the object.
+   * @generated
+   */
+  @Override
+  public boolean isFactoryForType(Object object)
+  {
+    if (object == modelPackage)
+    {
+      return true;
+    }
+    if (object instanceof EObject)
+    {
+      return ((EObject)object).eClass().getEPackage() == modelPackage;
+    }
+    return false;
+  }
+  /**
+   * The switch that delegates to the <code>createXXX</code> methods.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected SolverLanguageSwitch<Adapter> modelSwitch =
+    new SolverLanguageSwitch<Adapter>()
+    {
+      @Override
+      public Adapter caseProblem(Problem object)
+      {
+        return createProblemAdapter();
+      }
+      @Override
+      public Adapter caseStatement(Statement object)
+      {
+        return createStatementAdapter();
+      }
+      @Override
+      public Adapter caseBooleanValue(BooleanValue object)
+      {
+        return createBooleanValueAdapter();
+      }
+      @Override
+      public Adapter caseTruthValue(TruthValue object)
+      {
+        return createTruthValueAdapter();
+      }
+      @Override
+      public Adapter caseInterpretation(Interpretation object)
+      {
+        return createInterpretationAdapter();
+      }
+      @Override
+      public Adapter caseBasicInterpretation(BasicInterpretation object)
+      {
+        return createBasicInterpretationAdapter();
+      }
+      @Override
+      public Adapter caseSymbol(Symbol object)
+      {
+        return createSymbolAdapter();
+      }
+      @Override
+      public Adapter caseModelSymbol(ModelSymbol object)
+      {
+        return createModelSymbolAdapter();
+      }
+      @Override
+      public Adapter casePartialitySymbol(PartialitySymbol object)
+      {
+        return createPartialitySymbolAdapter();
+      }
+      @Override
+      public Adapter caseExistSymbol(ExistSymbol object)
+      {
+        return createExistSymbolAdapter();
+      }
+      @Override
+      public Adapter caseEqualsSymbol(EqualsSymbol object)
+      {
+        return createEqualsSymbolAdapter();
+      }
+      @Override
+      public Adapter caseDataSymbol(DataSymbol object)
+      {
+        return createDataSymbolAdapter();
+      }
+      @Override
+      public Adapter caseBooleanSymbol(BooleanSymbol object)
+      {
+        return createBooleanSymbolAdapter();
+      }
+      @Override
+      public Adapter caseIntegerSymbol(IntegerSymbol object)
+      {
+        return createIntegerSymbolAdapter();
+      }
+      @Override
+      public Adapter caseRealSymbol(RealSymbol object)
+      {
+        return createRealSymbolAdapter();
+      }
+      @Override
+      public Adapter caseStringSymbol(StringSymbol object)
+      {
+        return createStringSymbolAdapter();
+      }
+      @Override
+      public Adapter caseComplexObject(ComplexObject object)
+      {
+        return createComplexObjectAdapter();
+      }
+      @Override
+      public Adapter caseObject(org.eclipse.viatra.solver.language.solverLanguage.Object object)
+      {
+        return createObjectAdapter();
+      }
+      @Override
+      public Adapter caseNamedObject(NamedObject object)
+      {
+        return createNamedObjectAdapter();
+      }
+      @Override
+      public Adapter caseUnnamedObject(UnnamedObject object)
+      {
+        return createUnnamedObjectAdapter();
+      }
+      @Override
+      public Adapter caseDataObject(DataObject object)
+      {
+        return createDataObjectAdapter();
+      }
+      @Override
+      public Adapter caseBooleanObject(BooleanObject object)
+      {
+        return createBooleanObjectAdapter();
+      }
+      @Override
+      public Adapter caseIntObject(IntObject object)
+      {
+        return createIntObjectAdapter();
+      }
+      @Override
+      public Adapter caseRealObject(RealObject object)
+      {
+        return createRealObjectAdapter();
+      }
+      @Override
+      public Adapter caseStringObject(StringObject object)
+      {
+        return createStringObjectAdapter();
+      }
+      @Override
+      public Adapter casePredicate(Predicate object)
+      {
+        return createPredicateAdapter();
+      }
+      @Override
+      public Adapter casePredicateSymbol(PredicateSymbol object)
+      {
+        return createPredicateSymbolAdapter();
+      }
+      @Override
+      public Adapter caseErrorPredicate(ErrorPredicate object)
+      {
+        return createErrorPredicateAdapter();
+      }
+      @Override
+      public Adapter caseParameter(Parameter object)
+      {
+        return createParameterAdapter();
+      }
+      @Override
+      public Adapter casePatternBody(PatternBody object)
+      {
+        return createPatternBodyAdapter();
+      }
+      @Override
+      public Adapter casePolarity(Polarity object)
+      {
+        return createPolarityAdapter();
+      }
+      @Override
+      public Adapter caseConstraint(Constraint object)
+      {
+        return createConstraintAdapter();
+      }
+      @Override
+      public Adapter caseClosureType(ClosureType object)
+      {
+        return createClosureTypeAdapter();
+      }
+      @Override
+      public Adapter caseLiteral(Literal object)
+      {
+        return createLiteralAdapter();
+      }
+      @Override
+      public Adapter caseVariable(Variable object)
+      {
+        return createVariableAdapter();
+      }
+      @Override
+      public Adapter caseAllInstances(AllInstances object)
+      {
+        return createAllInstancesAdapter();
+      }
+      @Override
+      public Adapter caseAllObjects(AllObjects object)
+      {
+        return createAllObjectsAdapter();
+      }
+      @Override
+      public Adapter caseDefaultInterpretation(DefaultInterpretation object)
+      {
+        return createDefaultInterpretationAdapter();
+      }
+      @Override
+      public Adapter caseCDInterpretation(CDInterpretation object)
+      {
+        return createCDInterpretationAdapter();
+      }
+      @Override
+      public Adapter caseClassInterpretation(ClassInterpretation object)
+      {
+        return createClassInterpretationAdapter();
+      }
+      @Override
+      public Adapter caseEnumInterpretation(EnumInterpretation object)
+      {
+        return createEnumInterpretationAdapter();
+      }
+      @Override
+      public Adapter caseFieldRelationInterpretation(FieldRelationInterpretation object)
+      {
+        return createFieldRelationInterpretationAdapter();
+      }
+      @Override
+      public Adapter caseGlobalRelationInterpretation(GlobalRelationInterpretation object)
+      {
+        return createGlobalRelationInterpretationAdapter();
+      }
+      @Override
+      public Adapter caseMultiplicityDefinition(MultiplicityDefinition object)
+      {
+        return createMultiplicityDefinitionAdapter();
+      }
+      @Override
+      public Adapter caseBooleanTrue(BooleanTrue object)
+      {
+        return createBooleanTrueAdapter();
+      }
+      @Override
+      public Adapter caseBooleanFalse(BooleanFalse object)
+      {
+        return createBooleanFalseAdapter();
+      }
+      @Override
+      public Adapter caseTrue(True object)
+      {
+        return createTrueAdapter();
+      }
+      @Override
+      public Adapter caseFalse(False object)
+      {
+        return createFalseAdapter();
+      }
+      @Override
+      public Adapter caseUnknown(Unknown object)
+      {
+        return createUnknownAdapter();
+      }
+      @Override
+      public Adapter caseError(org.eclipse.viatra.solver.language.solverLanguage.Error object)
+      {
+        return createErrorAdapter();
+      }
+      @Override
+      public Adapter casePositive(Positive object)
+      {
+        return createPositiveAdapter();
+      }
+      @Override
+      public Adapter caseNegative(Negative object)
+      {
+        return createNegativeAdapter();
+      }
+      @Override
+      public Adapter caseReflexiveClosure(ReflexiveClosure object)
+      {
+        return createReflexiveClosureAdapter();
+      }
+      @Override
+      public Adapter caseIrreflexiveClosure(IrreflexiveClosure object)
+      {
+        return createIrreflexiveClosureAdapter();
+      }
+      @Override
+      public Adapter defaultCase(EObject object)
+      {
+        return createEObjectAdapter();
+      }
+    };
+  /**
+   * Creates an adapter for the <code>target</code>.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param target the object to adapt.
+   * @return the adapter for the <code>target</code>.
+   * @generated
+   */
+  @Override
+  public Adapter createAdapter(Notifier target)
+  {
+    return modelSwitch.doSwitch((EObject)target);
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Problem <em>Problem</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Problem
+   * @generated
+   */
+  public Adapter createProblemAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Statement <em>Statement</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Statement
+   * @generated
+   */
+  public Adapter createStatementAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanValue <em>Boolean Value</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanValue
+   * @generated
+   */
+  public Adapter createBooleanValueAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.TruthValue <em>Truth Value</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.TruthValue
+   * @generated
+   */
+  public Adapter createTruthValueAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Interpretation <em>Interpretation</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Interpretation
+   * @generated
+   */
+  public Adapter createInterpretationAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation <em>Basic Interpretation</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation
+   * @generated
+   */
+  public Adapter createBasicInterpretationAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Symbol <em>Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Symbol
+   * @generated
+   */
+  public Adapter createSymbolAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol <em>Model Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol
+   * @generated
+   */
+  public Adapter createModelSymbolAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol <em>Partiality Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol
+   * @generated
+   */
+  public Adapter createPartialitySymbolAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol <em>Exist Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol
+   * @generated
+   */
+  public Adapter createExistSymbolAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol <em>Equals Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol
+   * @generated
+   */
+  public Adapter createEqualsSymbolAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.DataSymbol <em>Data Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.DataSymbol
+   * @generated
+   */
+  public Adapter createDataSymbolAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol <em>Boolean Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol
+   * @generated
+   */
+  public Adapter createBooleanSymbolAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol <em>Integer Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol
+   * @generated
+   */
+  public Adapter createIntegerSymbolAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.RealSymbol <em>Real Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.RealSymbol
+   * @generated
+   */
+  public Adapter createRealSymbolAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.StringSymbol <em>String Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.StringSymbol
+   * @generated
+   */
+  public Adapter createStringSymbolAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ComplexObject <em>Complex Object</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ComplexObject
+   * @generated
+   */
+  public Adapter createComplexObjectAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Object <em>Object</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Object
+   * @generated
+   */
+  public Adapter createObjectAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject <em>Named Object</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.NamedObject
+   * @generated
+   */
+  public Adapter createNamedObjectAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject <em>Unnamed Object</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject
+   * @generated
+   */
+  public Adapter createUnnamedObjectAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.DataObject <em>Data Object</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.DataObject
+   * @generated
+   */
+  public Adapter createDataObjectAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanObject <em>Boolean Object</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanObject
+   * @generated
+   */
+  public Adapter createBooleanObjectAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.IntObject <em>Int Object</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.IntObject
+   * @generated
+   */
+  public Adapter createIntObjectAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.RealObject <em>Real Object</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.RealObject
+   * @generated
+   */
+  public Adapter createRealObjectAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.StringObject <em>String Object</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.StringObject
+   * @generated
+   */
+  public Adapter createStringObjectAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate <em>Predicate</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Predicate
+   * @generated
+   */
+  public Adapter createPredicateAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol <em>Predicate Symbol</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol
+   * @generated
+   */
+  public Adapter createPredicateSymbolAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate <em>Error Predicate</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate
+   * @generated
+   */
+  public Adapter createErrorPredicateAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter <em>Parameter</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Parameter
+   * @generated
+   */
+  public Adapter createParameterAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.PatternBody <em>Pattern Body</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.PatternBody
+   * @generated
+   */
+  public Adapter createPatternBodyAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Polarity <em>Polarity</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Polarity
+   * @generated
+   */
+  public Adapter createPolarityAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint <em>Constraint</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint
+   * @generated
+   */
+  public Adapter createConstraintAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ClosureType <em>Closure Type</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ClosureType
+   * @generated
+   */
+  public Adapter createClosureTypeAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Literal <em>Literal</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Literal
+   * @generated
+   */
+  public Adapter createLiteralAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Variable <em>Variable</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Variable
+   * @generated
+   */
+  public Adapter createVariableAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.AllInstances <em>All Instances</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.AllInstances
+   * @generated
+   */
+  public Adapter createAllInstancesAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.AllObjects <em>All Objects</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.AllObjects
+   * @generated
+   */
+  public Adapter createAllObjectsAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation <em>Default Interpretation</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation
+   * @generated
+   */
+  public Adapter createDefaultInterpretationAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation <em>CD Interpretation</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation
+   * @generated
+   */
+  public Adapter createCDInterpretationAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation <em>Class Interpretation</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation
+   * @generated
+   */
+  public Adapter createClassInterpretationAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation <em>Enum Interpretation</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation
+   * @generated
+   */
+  public Adapter createEnumInterpretationAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation <em>Field Relation Interpretation</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation
+   * @generated
+   */
+  public Adapter createFieldRelationInterpretationAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation <em>Global Relation Interpretation</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation
+   * @generated
+   */
+  public Adapter createGlobalRelationInterpretationAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition <em>Multiplicity Definition</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition
+   * @generated
+   */
+  public Adapter createMultiplicityDefinitionAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue <em>Boolean True</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue
+   * @generated
+   */
+  public Adapter createBooleanTrueAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse <em>Boolean False</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse
+   * @generated
+   */
+  public Adapter createBooleanFalseAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.True <em>True</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.True
+   * @generated
+   */
+  public Adapter createTrueAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.False <em>False</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.False
+   * @generated
+   */
+  public Adapter createFalseAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Unknown <em>Unknown</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Unknown
+   * @generated
+   */
+  public Adapter createUnknownAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Error <em>Error</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Error
+   * @generated
+   */
+  public Adapter createErrorAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Positive <em>Positive</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Positive
+   * @generated
+   */
+  public Adapter createPositiveAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Negative <em>Negative</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.Negative
+   * @generated
+   */
+  public Adapter createNegativeAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure <em>Reflexive Closure</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure
+   * @generated
+   */
+  public Adapter createReflexiveClosureAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure <em>Irreflexive Closure</em>}'.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null so that we can easily ignore cases;
+   * it's useful to ignore a case when inheritance will catch all the cases anyway.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @see org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure
+   * @generated
+   */
+  public Adapter createIrreflexiveClosureAdapter()
+  {
+    return null;
+  }
+  /**
+   * Creates a new adapter for the default case.
+   * <!-- begin-user-doc -->
+   * This default implementation returns null.
+   * <!-- end-user-doc -->
+   * @return the new adapter.
+   * @generated
+   */
+  public Adapter createEObjectAdapter()
+  {
+    return null;
+  }
+} //SolverLanguageAdapterFactory
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageSwitch.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageSwitch.java
new file mode 100644
index 00000000..9bc874e3
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageSwitch.java
@@ -0,0 +1,1464 @@
+/**
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.solverLanguage.util;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.util.Switch;
+import org.eclipse.viatra.solver.language.solverLanguage.AllInstances;
+import org.eclipse.viatra.solver.language.solverLanguage.AllObjects;
+import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanObject;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue;
+import org.eclipse.viatra.solver.language.solverLanguage.BooleanValue;
+import org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.ClosureType;
+import org.eclipse.viatra.solver.language.solverLanguage.ComplexObject;
+import org.eclipse.viatra.solver.language.solverLanguage.Constraint;
+import org.eclipse.viatra.solver.language.solverLanguage.DataObject;
+import org.eclipse.viatra.solver.language.solverLanguage.DataSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate;
+import org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.False;
+import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.IntObject;
+import org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.Interpretation;
+import org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure;
+import org.eclipse.viatra.solver.language.solverLanguage.Literal;
+import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition;
+import org.eclipse.viatra.solver.language.solverLanguage.NamedObject;
+import org.eclipse.viatra.solver.language.solverLanguage.Negative;
+import org.eclipse.viatra.solver.language.solverLanguage.Parameter;
+import org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.PatternBody;
+import org.eclipse.viatra.solver.language.solverLanguage.Polarity;
+import org.eclipse.viatra.solver.language.solverLanguage.Positive;
+import org.eclipse.viatra.solver.language.solverLanguage.Predicate;
+import org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.Problem;
+import org.eclipse.viatra.solver.language.solverLanguage.RealObject;
+import org.eclipse.viatra.solver.language.solverLanguage.RealSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure;
+import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
+import org.eclipse.viatra.solver.language.solverLanguage.Statement;
+import org.eclipse.viatra.solver.language.solverLanguage.StringObject;
+import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol;
+import org.eclipse.viatra.solver.language.solverLanguage.Symbol;
+import org.eclipse.viatra.solver.language.solverLanguage.True;
+import org.eclipse.viatra.solver.language.solverLanguage.TruthValue;
+import org.eclipse.viatra.solver.language.solverLanguage.Unknown;
+import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject;
+import org.eclipse.viatra.solver.language.solverLanguage.Variable;
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Switch</b> for the model's inheritance hierarchy.
+ * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the <code>caseXXX</code> method for each class of the model,
+ * starting with the actual class of the object
+ * and proceeding up the inheritance hierarchy
+ * until a non-null result is returned,
+ * which is the result of the switch.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage
+ * @generated
+ */
+public class SolverLanguageSwitch<T> extends Switch<T>
+{
+  /**
+   * The cached model package
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  protected static SolverLanguagePackage modelPackage;
+  /**
+   * Creates an instance of the switch.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @generated
+   */
+  public SolverLanguageSwitch()
+  {
+    if (modelPackage == null)
+    {
+      modelPackage = SolverLanguagePackage.eINSTANCE;
+    }
+  }
+  /**
+   * Checks whether this is a switch for the given package.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @param ePackage the package in question.
+   * @return whether this is a switch for the given package.
+   * @generated
+   */
+  @Override
+  protected boolean isSwitchFor(EPackage ePackage)
+  {
+    return ePackage == modelPackage;
+  }
+  /**
+   * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+   * <!-- begin-user-doc -->
+   * <!-- end-user-doc -->
+   * @return the first non-null result returned by a <code>caseXXX</code> call.
+   * @generated
+   */
+  @Override
+  protected T doSwitch(int classifierID, EObject theEObject)
+  {
+    switch (classifierID)
+    {
+      case SolverLanguagePackage.PROBLEM:
+      {
+        Problem problem = (Problem)theEObject;
+        T result = caseProblem(problem);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.STATEMENT:
+      {
+        Statement statement = (Statement)theEObject;
+        T result = caseStatement(statement);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.BOOLEAN_VALUE:
+      {
+        BooleanValue booleanValue = (BooleanValue)theEObject;
+        T result = caseBooleanValue(booleanValue);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.TRUTH_VALUE:
+      {
+        TruthValue truthValue = (TruthValue)theEObject;
+        T result = caseTruthValue(truthValue);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.INTERPRETATION:
+      {
+        Interpretation interpretation = (Interpretation)theEObject;
+        T result = caseInterpretation(interpretation);
+        if (result == null) result = caseStatement(interpretation);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.BASIC_INTERPRETATION:
+      {
+        BasicInterpretation basicInterpretation = (BasicInterpretation)theEObject;
+        T result = caseBasicInterpretation(basicInterpretation);
+        if (result == null) result = caseInterpretation(basicInterpretation);
+        if (result == null) result = caseStatement(basicInterpretation);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.SYMBOL:
+      {
+        Symbol symbol = (Symbol)theEObject;
+        T result = caseSymbol(symbol);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.MODEL_SYMBOL:
+      {
+        ModelSymbol modelSymbol = (ModelSymbol)theEObject;
+        T result = caseModelSymbol(modelSymbol);
+        if (result == null) result = caseSymbol(modelSymbol);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.PARTIALITY_SYMBOL:
+      {
+        PartialitySymbol partialitySymbol = (PartialitySymbol)theEObject;
+        T result = casePartialitySymbol(partialitySymbol);
+        if (result == null) result = caseSymbol(partialitySymbol);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.EXIST_SYMBOL:
+      {
+        ExistSymbol existSymbol = (ExistSymbol)theEObject;
+        T result = caseExistSymbol(existSymbol);
+        if (result == null) result = casePartialitySymbol(existSymbol);
+        if (result == null) result = caseSymbol(existSymbol);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.EQUALS_SYMBOL:
+      {
+        EqualsSymbol equalsSymbol = (EqualsSymbol)theEObject;
+        T result = caseEqualsSymbol(equalsSymbol);
+        if (result == null) result = casePartialitySymbol(equalsSymbol);
+        if (result == null) result = caseSymbol(equalsSymbol);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.DATA_SYMBOL:
+      {
+        DataSymbol dataSymbol = (DataSymbol)theEObject;
+        T result = caseDataSymbol(dataSymbol);
+        if (result == null) result = caseSymbol(dataSymbol);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.BOOLEAN_SYMBOL:
+      {
+        BooleanSymbol booleanSymbol = (BooleanSymbol)theEObject;
+        T result = caseBooleanSymbol(booleanSymbol);
+        if (result == null) result = caseDataSymbol(booleanSymbol);
+        if (result == null) result = caseSymbol(booleanSymbol);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.INTEGER_SYMBOL:
+      {
+        IntegerSymbol integerSymbol = (IntegerSymbol)theEObject;
+        T result = caseIntegerSymbol(integerSymbol);
+        if (result == null) result = caseDataSymbol(integerSymbol);
+        if (result == null) result = caseSymbol(integerSymbol);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.REAL_SYMBOL:
+      {
+        RealSymbol realSymbol = (RealSymbol)theEObject;
+        T result = caseRealSymbol(realSymbol);
+        if (result == null) result = caseDataSymbol(realSymbol);
+        if (result == null) result = caseSymbol(realSymbol);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.STRING_SYMBOL:
+      {
+        StringSymbol stringSymbol = (StringSymbol)theEObject;
+        T result = caseStringSymbol(stringSymbol);
+        if (result == null) result = caseDataSymbol(stringSymbol);
+        if (result == null) result = caseSymbol(stringSymbol);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.COMPLEX_OBJECT:
+      {
+        ComplexObject complexObject = (ComplexObject)theEObject;
+        T result = caseComplexObject(complexObject);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.OBJECT:
+      {
+        org.eclipse.viatra.solver.language.solverLanguage.Object object = (org.eclipse.viatra.solver.language.solverLanguage.Object)theEObject;
+        T result = caseObject(object);
+        if (result == null) result = caseComplexObject(object);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.NAMED_OBJECT:
+      {
+        NamedObject namedObject = (NamedObject)theEObject;
+        T result = caseNamedObject(namedObject);
+        if (result == null) result = caseObject(namedObject);
+        if (result == null) result = caseComplexObject(namedObject);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.UNNAMED_OBJECT:
+      {
+        UnnamedObject unnamedObject = (UnnamedObject)theEObject;
+        T result = caseUnnamedObject(unnamedObject);
+        if (result == null) result = caseObject(unnamedObject);
+        if (result == null) result = caseComplexObject(unnamedObject);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.DATA_OBJECT:
+      {
+        DataObject dataObject = (DataObject)theEObject;
+        T result = caseDataObject(dataObject);
+        if (result == null) result = caseObject(dataObject);
+        if (result == null) result = caseLiteral(dataObject);
+        if (result == null) result = caseComplexObject(dataObject);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.BOOLEAN_OBJECT:
+      {
+        BooleanObject booleanObject = (BooleanObject)theEObject;
+        T result = caseBooleanObject(booleanObject);
+        if (result == null) result = caseDataObject(booleanObject);
+        if (result == null) result = caseObject(booleanObject);
+        if (result == null) result = caseLiteral(booleanObject);
+        if (result == null) result = caseComplexObject(booleanObject);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.INT_OBJECT:
+      {
+        IntObject intObject = (IntObject)theEObject;
+        T result = caseIntObject(intObject);
+        if (result == null) result = caseDataObject(intObject);
+        if (result == null) result = caseObject(intObject);
+        if (result == null) result = caseLiteral(intObject);
+        if (result == null) result = caseComplexObject(intObject);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.REAL_OBJECT:
+      {
+        RealObject realObject = (RealObject)theEObject;
+        T result = caseRealObject(realObject);
+        if (result == null) result = caseDataObject(realObject);
+        if (result == null) result = caseObject(realObject);
+        if (result == null) result = caseLiteral(realObject);
+        if (result == null) result = caseComplexObject(realObject);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.STRING_OBJECT:
+      {
+        StringObject stringObject = (StringObject)theEObject;
+        T result = caseStringObject(stringObject);
+        if (result == null) result = caseDataObject(stringObject);
+        if (result == null) result = caseObject(stringObject);
+        if (result == null) result = caseLiteral(stringObject);
+        if (result == null) result = caseComplexObject(stringObject);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.PREDICATE:
+      {
+        Predicate predicate = (Predicate)theEObject;
+        T result = casePredicate(predicate);
+        if (result == null) result = caseStatement(predicate);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.PREDICATE_SYMBOL:
+      {
+        PredicateSymbol predicateSymbol = (PredicateSymbol)theEObject;
+        T result = casePredicateSymbol(predicateSymbol);
+        if (result == null) result = casePredicate(predicateSymbol);
+        if (result == null) result = caseStatement(predicateSymbol);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.ERROR_PREDICATE:
+      {
+        ErrorPredicate errorPredicate = (ErrorPredicate)theEObject;
+        T result = caseErrorPredicate(errorPredicate);
+        if (result == null) result = casePredicate(errorPredicate);
+        if (result == null) result = caseStatement(errorPredicate);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.PARAMETER:
+      {
+        Parameter parameter = (Parameter)theEObject;
+        T result = caseParameter(parameter);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.PATTERN_BODY:
+      {
+        PatternBody patternBody = (PatternBody)theEObject;
+        T result = casePatternBody(patternBody);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.POLARITY:
+      {
+        Polarity polarity = (Polarity)theEObject;
+        T result = casePolarity(polarity);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.CONSTRAINT:
+      {
+        Constraint constraint = (Constraint)theEObject;
+        T result = caseConstraint(constraint);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.CLOSURE_TYPE:
+      {
+        ClosureType closureType = (ClosureType)theEObject;
+        T result = caseClosureType(closureType);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.LITERAL:
+      {
+        Literal literal = (Literal)theEObject;
+        T result = caseLiteral(literal);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.VARIABLE:
+      {
+        Variable variable = (Variable)theEObject;
+        T result = caseVariable(variable);
+        if (result == null) result = caseLiteral(variable);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.ALL_INSTANCES:
+      {
+        AllInstances allInstances = (AllInstances)theEObject;
+        T result = caseAllInstances(allInstances);
+        if (result == null) result = caseComplexObject(allInstances);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.ALL_OBJECTS:
+      {
+        AllObjects allObjects = (AllObjects)theEObject;
+        T result = caseAllObjects(allObjects);
+        if (result == null) result = caseComplexObject(allObjects);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.DEFAULT_INTERPRETATION:
+      {
+        DefaultInterpretation defaultInterpretation = (DefaultInterpretation)theEObject;
+        T result = caseDefaultInterpretation(defaultInterpretation);
+        if (result == null) result = caseInterpretation(defaultInterpretation);
+        if (result == null) result = caseStatement(defaultInterpretation);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.CD_INTERPRETATION:
+      {
+        CDInterpretation cdInterpretation = (CDInterpretation)theEObject;
+        T result = caseCDInterpretation(cdInterpretation);
+        if (result == null) result = caseInterpretation(cdInterpretation);
+        if (result == null) result = caseStatement(cdInterpretation);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.CLASS_INTERPRETATION:
+      {
+        ClassInterpretation classInterpretation = (ClassInterpretation)theEObject;
+        T result = caseClassInterpretation(classInterpretation);
+        if (result == null) result = caseCDInterpretation(classInterpretation);
+        if (result == null) result = caseInterpretation(classInterpretation);
+        if (result == null) result = caseStatement(classInterpretation);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.ENUM_INTERPRETATION:
+      {
+        EnumInterpretation enumInterpretation = (EnumInterpretation)theEObject;
+        T result = caseEnumInterpretation(enumInterpretation);
+        if (result == null) result = caseCDInterpretation(enumInterpretation);
+        if (result == null) result = caseInterpretation(enumInterpretation);
+        if (result == null) result = caseStatement(enumInterpretation);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION:
+      {
+        FieldRelationInterpretation fieldRelationInterpretation = (FieldRelationInterpretation)theEObject;
+        T result = caseFieldRelationInterpretation(fieldRelationInterpretation);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION:
+      {
+        GlobalRelationInterpretation globalRelationInterpretation = (GlobalRelationInterpretation)theEObject;
+        T result = caseGlobalRelationInterpretation(globalRelationInterpretation);
+        if (result == null) result = caseCDInterpretation(globalRelationInterpretation);
+        if (result == null) result = caseInterpretation(globalRelationInterpretation);
+        if (result == null) result = caseStatement(globalRelationInterpretation);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.MULTIPLICITY_DEFINITION:
+      {
+        MultiplicityDefinition multiplicityDefinition = (MultiplicityDefinition)theEObject;
+        T result = caseMultiplicityDefinition(multiplicityDefinition);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.BOOLEAN_TRUE:
+      {
+        BooleanTrue booleanTrue = (BooleanTrue)theEObject;
+        T result = caseBooleanTrue(booleanTrue);
+        if (result == null) result = caseBooleanValue(booleanTrue);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.BOOLEAN_FALSE:
+      {
+        BooleanFalse booleanFalse = (BooleanFalse)theEObject;
+        T result = caseBooleanFalse(booleanFalse);
+        if (result == null) result = caseBooleanValue(booleanFalse);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.TRUE:
+      {
+        True true_ = (True)theEObject;
+        T result = caseTrue(true_);
+        if (result == null) result = caseTruthValue(true_);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.FALSE:
+      {
+        False false_ = (False)theEObject;
+        T result = caseFalse(false_);
+        if (result == null) result = caseTruthValue(false_);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.UNKNOWN:
+      {
+        Unknown unknown = (Unknown)theEObject;
+        T result = caseUnknown(unknown);
+        if (result == null) result = caseTruthValue(unknown);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.ERROR:
+      {
+        org.eclipse.viatra.solver.language.solverLanguage.Error error = (org.eclipse.viatra.solver.language.solverLanguage.Error)theEObject;
+        T result = caseError(error);
+        if (result == null) result = caseTruthValue(error);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.POSITIVE:
+      {
+        Positive positive = (Positive)theEObject;
+        T result = casePositive(positive);
+        if (result == null) result = casePolarity(positive);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.NEGATIVE:
+      {
+        Negative negative = (Negative)theEObject;
+        T result = caseNegative(negative);
+        if (result == null) result = casePolarity(negative);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.REFLEXIVE_CLOSURE:
+      {
+        ReflexiveClosure reflexiveClosure = (ReflexiveClosure)theEObject;
+        T result = caseReflexiveClosure(reflexiveClosure);
+        if (result == null) result = caseClosureType(reflexiveClosure);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      case SolverLanguagePackage.IRREFLEXIVE_CLOSURE:
+      {
+        IrreflexiveClosure irreflexiveClosure = (IrreflexiveClosure)theEObject;
+        T result = caseIrreflexiveClosure(irreflexiveClosure);
+        if (result == null) result = caseClosureType(irreflexiveClosure);
+        if (result == null) result = defaultCase(theEObject);
+        return result;
+      }
+      default: return defaultCase(theEObject);
+    }
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Problem</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Problem</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseProblem(Problem object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Statement</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Statement</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseStatement(Statement object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Boolean Value</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Boolean Value</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseBooleanValue(BooleanValue object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Truth Value</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Truth Value</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseTruthValue(TruthValue object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Interpretation</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Interpretation</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseInterpretation(Interpretation object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Basic Interpretation</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Basic Interpretation</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseBasicInterpretation(BasicInterpretation object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Symbol</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseSymbol(Symbol object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Model Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Model Symbol</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseModelSymbol(ModelSymbol object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Partiality Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Partiality Symbol</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T casePartialitySymbol(PartialitySymbol object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Exist Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Exist Symbol</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseExistSymbol(ExistSymbol object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Equals Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Equals Symbol</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseEqualsSymbol(EqualsSymbol object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Data Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Data Symbol</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseDataSymbol(DataSymbol object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Boolean Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Boolean Symbol</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseBooleanSymbol(BooleanSymbol object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Integer Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Integer Symbol</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseIntegerSymbol(IntegerSymbol object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Real Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Real Symbol</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseRealSymbol(RealSymbol object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>String Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>String Symbol</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseStringSymbol(StringSymbol object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Complex Object</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Complex Object</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseComplexObject(ComplexObject object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Object</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Object</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseObject(org.eclipse.viatra.solver.language.solverLanguage.Object object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Named Object</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Named Object</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseNamedObject(NamedObject object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Unnamed Object</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Unnamed Object</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseUnnamedObject(UnnamedObject object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Data Object</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Data Object</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseDataObject(DataObject object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Boolean Object</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Boolean Object</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseBooleanObject(BooleanObject object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Int Object</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Int Object</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseIntObject(IntObject object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Real Object</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Real Object</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseRealObject(RealObject object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>String Object</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>String Object</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseStringObject(StringObject object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Predicate</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Predicate</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T casePredicate(Predicate object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Predicate Symbol</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Predicate Symbol</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T casePredicateSymbol(PredicateSymbol object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Error Predicate</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Error Predicate</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseErrorPredicate(ErrorPredicate object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Parameter</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Parameter</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseParameter(Parameter object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Pattern Body</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Pattern Body</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T casePatternBody(PatternBody object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Polarity</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Polarity</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T casePolarity(Polarity object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Constraint</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Constraint</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseConstraint(Constraint object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Closure Type</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Closure Type</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseClosureType(ClosureType object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Literal</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Literal</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseLiteral(Literal object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Variable</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Variable</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseVariable(Variable object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>All Instances</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>All Instances</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseAllInstances(AllInstances object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>All Objects</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>All Objects</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseAllObjects(AllObjects object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Default Interpretation</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Default Interpretation</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseDefaultInterpretation(DefaultInterpretation object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>CD Interpretation</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>CD Interpretation</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseCDInterpretation(CDInterpretation object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Class Interpretation</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Class Interpretation</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseClassInterpretation(ClassInterpretation object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Enum Interpretation</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Enum Interpretation</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseEnumInterpretation(EnumInterpretation object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Field Relation Interpretation</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Field Relation Interpretation</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseFieldRelationInterpretation(FieldRelationInterpretation object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Global Relation Interpretation</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Global Relation Interpretation</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseGlobalRelationInterpretation(GlobalRelationInterpretation object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Multiplicity Definition</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Multiplicity Definition</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseMultiplicityDefinition(MultiplicityDefinition object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Boolean True</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Boolean True</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseBooleanTrue(BooleanTrue object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Boolean False</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Boolean False</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseBooleanFalse(BooleanFalse object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>True</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>True</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseTrue(True object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>False</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>False</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseFalse(False object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Unknown</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Unknown</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseUnknown(Unknown object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Error</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Error</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseError(org.eclipse.viatra.solver.language.solverLanguage.Error object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Positive</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Positive</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T casePositive(Positive object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Negative</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Negative</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseNegative(Negative object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Reflexive Closure</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Reflexive Closure</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseReflexiveClosure(ReflexiveClosure object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>Irreflexive Closure</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>Irreflexive Closure</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+   * @generated
+   */
+  public T caseIrreflexiveClosure(IrreflexiveClosure object)
+  {
+    return null;
+  }
+  /**
+   * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
+   * <!-- begin-user-doc -->
+   * This implementation returns null;
+   * returning a non-null result will terminate the switch, but this is the last case anyway.
+   * <!-- end-user-doc -->
+   * @param object the target of the switch.
+   * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
+   * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+   * @generated
+   */
+  @Override
+  public T defaultCase(EObject object)
+  {
+    return null;
+  }
+} //SolverLanguageSwitch
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/AbstractSolverLanguageValidator.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/AbstractSolverLanguageValidator.java
new file mode 100644
index 00000000..e4313a24
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/AbstractSolverLanguageValidator.java
@@ -0,0 +1,19 @@
+/*
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.validation;
+import java.util.ArrayList;
+import java.util.List;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.xtext.validation.AbstractDeclarativeValidator;
+public abstract class AbstractSolverLanguageValidator extends AbstractDeclarativeValidator {
+        
+        @Override
+        protected List<EPackage> getEPackages() {
+                List<EPackage> result = new ArrayList<EPackage>();
+                result.add(org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage.eINSTANCE);
+                return result;
+        }
+}
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/SolverLanguageConfigurableIssueCodesProvider.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/SolverLanguageConfigurableIssueCodesProvider.java
new file mode 100644
index 00000000..4247dc60
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/SolverLanguageConfigurableIssueCodesProvider.java
@@ -0,0 +1,22 @@
+/*
+ * generated by Xtext 2.18.0.M3
+ */
+package org.eclipse.viatra.solver.language.validation;
+import org.eclipse.xtext.preferences.PreferenceKey;
+import org.eclipse.xtext.util.IAcceptor;
+import org.eclipse.xtext.validation.ConfigurableIssueCodesProvider;
+import org.eclipse.xtext.validation.SeverityConverter;
+@SuppressWarnings("restriction")
+public class SolverLanguageConfigurableIssueCodesProvider extends ConfigurableIssueCodesProvider {
+        protected static final String ISSUE_CODE_PREFIX = "org.eclipse.viatra.solver.language.";
+        public static final String DEPRECATED_MODEL_PART = ISSUE_CODE_PREFIX + "deprecatedModelPart";
+        @Override
+        protected void initialize(IAcceptor<PreferenceKey> acceptor) {
+                super.initialize(acceptor);
+                acceptor.accept(create(DEPRECATED_MODEL_PART, SeverityConverter.SEVERITY_WARNING));
+        }
+}
author	Oszkar Semerath <semerath@mit.bme.hu>	2020-04-28 20:43:04 +0200
committer	Oszkar Semerath <semerath@mit.bme.hu>	2020-04-28 20:43:04 +0200
commit	8a7b9b436b31e6d2f5a0521a077c960ebdeb4cbe (patch)
tree	d525bef75519f364d637e0779f8e63d4199dee31 /Application/org.eclipse.viatra.solver.language/src-gen
parent	check expressions are mapped to WF constraints (diff)
download	VIATRA-Generator-8a7b9b436b31e6d2f5a0521a077c960ebdeb4cbe.tar.gz VIATRA-Generator-8a7b9b436b31e6d2f5a0521a077c960ebdeb4cbe.tar.zst VIATRA-Generator-8a7b9b436b31e6d2f5a0521a077c960ebdeb4cbe.zip