Add gitignore, commit everything

104 files changed, 5275 insertions, 6779 deletions

diff --git a/Application/hu.bme.mit.inf.dslreasoner.application.ide/.gitignore b/Application/hu.bme.mit.inf.dslreasoner.application.ide/.gitignore
index ae3c1726..d95727ab 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application.ide/.gitignore
+++ b/Application/hu.bme.mit.inf.dslreasoner.application.ide/.gitignore
@@ -1 +1,3 @@
 /bin/
+/xtend-gen/
+/src-gen/
\ No newline at end of file
diff --git a/Application/hu.bme.mit.inf.dslreasoner.application.ide/xtend-gen/hu/bme/mit/inf/dslreasoner/application/ide/.ApplicationConfigurationIdeModule.xtendbin b/Application/hu.bme.mit.inf.dslreasoner.application.ide/xtend-gen/hu/bme/mit/inf/dslreasoner/application/ide/.ApplicationConfigurationIdeModule.xtendbin
index ca156c38..eca39970 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application.ide/xtend-gen/hu/bme/mit/inf/dslreasoner/application/ide/.ApplicationConfigurationIdeModule.xtendbin
+++ b/Application/hu.bme.mit.inf.dslreasoner.application.ide/xtend-gen/hu/bme/mit/inf/dslreasoner/application/ide/.ApplicationConfigurationIdeModule.xtendbin
diff --git a/Application/hu.bme.mit.inf.dslreasoner.application.ide/xtend-gen/hu/bme/mit/inf/dslreasoner/application/ide/.ApplicationConfigurationIdeSetup.xtendbin b/Application/hu.bme.mit.inf.dslreasoner.application.ide/xtend-gen/hu/bme/mit/inf/dslreasoner/application/ide/.ApplicationConfigurationIdeSetup.xtendbin
index 51888916..6d4d9077 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application.ide/xtend-gen/hu/bme/mit/inf/dslreasoner/application/ide/.ApplicationConfigurationIdeSetup.xtendbin
+++ b/Application/hu.bme.mit.inf.dslreasoner.application.ide/xtend-gen/hu/bme/mit/inf/dslreasoner/application/ide/.ApplicationConfigurationIdeSetup.xtendbin
diff --git a/Domains/Examples/ModelGenExampleFAM_standalone/inputs/FamPatterns.vql b/Domains/Examples/ModelGenExampleFAM_standalone/inputs/FamPatterns.vql
index 34394ef6..3966d0af 100644
--- a/Domains/Examples/ModelGenExampleFAM_standalone/inputs/FamPatterns.vql
+++ b/Domains/Examples/ModelGenExampleFAM_standalone/inputs/FamPatterns.vql
@@ -1,7 +1,7 @@
 package hu.bme.mit.inf.dslreasoner.domains.fam

 

-import epackage "http://www.inf.mit.bme.hu/viatrasolver/example/fam"

-//import epackage "platform:/resource/ModelGenExampleFAM/inputs/FamMetamodel.ecore";

+//import epackage "http://www.inf.mit.bme.hu/viatrasolver/example/fam"

+import epackage "platform:/resource/ModelGenExampleFAM/inputs/FamMetamodel.ecore";

 

 @Constraint(message="terminatorAndInformation", severity="error", key={T})

 pattern terminatorAndInformation(T : FAMTerminator, I : InformationLink) = {

diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/META-INF/MANIFEST.MF b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/META-INF/MANIFEST.MF
index 41726ae6..85d7e580 100644
--- a/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/META-INF/MANIFEST.MF
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/META-INF/MANIFEST.MF
@@ -6,20 +6,20 @@ Bundle-Version: 1.0.0.qualifier
 Bundle-ClassPath: .
 Bundle-Vendor: %providerName
 Bundle-Localization: plugin
-Export-Package: hu.bme.mit.inf.dslreasoner.domains.alloyexamples,

- hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem,

- hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.impl,

- hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.util,

- hu.bme.mit.inf.dslreasoner.domains.alloyexamples.util
-Require-Bundle: org.eclipse.viatra.addon.querybasedfeatures.runtime,

- org.eclipse.viatra.query.runtime,

- org.eclipse.core.runtime,

- org.eclipse.emf.ecore;visibility:=reexport,

- org.eclipse.emf.emfstore.common,

- com.google.guava,

- org.eclipse.xtext.xbase.lib,

- org.eclipse.xtend.lib,

- org.eclipse.xtend.lib.macro
+Export-Package: hu.bme.mit.inf.dslreasoner.domains.alloyexamples,
+  hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem,
+  hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.impl,
+  hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.util,
+  hu.bme.mit.inf.dslreasoner.domains.alloyexamples.util
+Require-Bundle: org.eclipse.viatra.addon.querybasedfeatures.runtime,
+  org.eclipse.viatra.query.runtime,
+  org.eclipse.core.runtime,
+  org.eclipse.emf.ecore;visibility:=reexport,
+  org.eclipse.emf.emfstore.common,
+  com.google.guava,
+  org.eclipse.xtext.xbase.lib,
+  org.eclipse.xtend.lib,
+  org.eclipse.xtend.lib.macro
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Bundle-ActivationPolicy: lazy
 Import-Package: org.apache.log4j
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/.gitignore b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/.gitignore
index 9d608403..52338993 100644
--- a/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/.gitignore
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/.gitignore
@@ -34,3 +34,11 @@
 /OppositeMatcher.java
 /PatternContentMatch.java
 /PatternContentMatcher.java
+/.ContentInNotLive.java._trace
+/.DirectSupertype.java._trace
+/.Live.java._trace
+/.LoopInInheritence.java._trace
+/.NonSymmetricOpposite.java._trace
+/.Opposite.java._trace
+/.OppositeDifferentClass.java._trace
+/.PatternContent.java._trace
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/ContentInNotLive.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/ContentInNotLive.java
new file mode 100644
index 00000000..38d48ddb
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/ContentInNotLive.java
@@ -0,0 +1,741 @@
+/**

+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/patterns/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/FileSystem.vql

+ */

+package hu.bme.mit.inf.dslreasoner.domains.alloyexamples;

+

+import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.Dir;

+import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject;

+import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Live;

+import java.util.Arrays;

+import java.util.Collection;

+import java.util.LinkedHashSet;

+import java.util.List;

+import java.util.Objects;

+import java.util.Optional;

+import java.util.Set;

+import java.util.function.Consumer;

+import java.util.stream.Collectors;

+import java.util.stream.Stream;

+import org.apache.log4j.Logger;

+import org.eclipse.emf.ecore.EClass;

+import org.eclipse.viatra.query.runtime.api.IPatternMatch;

+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;

+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;

+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;

+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;

+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;

+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;

+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;

+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;

+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;

+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;

+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;

+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;

+

+/**

+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.

+ * 

+ * <p>Original source:

+ *         <code><pre>

+ *         {@literal @}Constraint(key={child}, severity="error", message="error")

+ *         pattern contentInNotLive(parent : Dir, child: FSObject) {

+ *              Dir.contents(parent,child);

+ *              neg find live(_,parent);

+ *         } or {

+ *              Dir.contents(parent,child);

+ *              neg find live(_,child);

+ *         }

+ * </pre></code>

+ * 

+ * @see Matcher

+ * @see Match

+ * 

+ */

+@SuppressWarnings("all")

+public final class ContentInNotLive extends BaseGeneratedEMFQuerySpecification<ContentInNotLive.Matcher> {

+  /**

+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.contentInNotLive pattern,

+   * to be used in conjunction with {@link Matcher}.

+   * 

+   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

+   * Each instance is a (possibly partial) substitution of pattern parameters,

+   * usable to represent a match of the pattern in the result of a query,

+   * or to specify the bound (fixed) input parameters when issuing a query.

+   * 

+   * @see Matcher

+   * 

+   */

+  public static abstract class Match extends BasePatternMatch {

+    private Dir fParent;

+    

+    private FSObject fChild;

+    

+    private static List<String> parameterNames = makeImmutableList("parent", "child");

+    

+    private Match(final Dir pParent, final FSObject pChild) {

+      this.fParent = pParent;

+      this.fChild = pChild;

+    }

+    

+    @Override

+    public Object get(final String parameterName) {

+      if ("parent".equals(parameterName)) return this.fParent;

+      if ("child".equals(parameterName)) return this.fChild;

+      return null;

+    }

+    

+    public Dir getParent() {

+      return this.fParent;

+    }

+    

+    public FSObject getChild() {

+      return this.fChild;

+    }

+    

+    @Override

+    public boolean set(final String parameterName, final Object newValue) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      if ("parent".equals(parameterName) ) {

+          this.fParent = (Dir) newValue;

+          return true;

+      }

+      if ("child".equals(parameterName) ) {

+          this.fChild = (FSObject) newValue;

+          return true;

+      }

+      return false;

+    }

+    

+    public void setParent(final Dir pParent) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      this.fParent = pParent;

+    }

+    

+    public void setChild(final FSObject pChild) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      this.fChild = pChild;

+    }

+    

+    @Override

+    public String patternName() {

+      return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.contentInNotLive";

+    }

+    

+    @Override

+    public List<String> parameterNames() {

+      return ContentInNotLive.Match.parameterNames;

+    }

+    

+    @Override

+    public Object[] toArray() {

+      return new Object[]{fParent, fChild};

+    }

+    

+    @Override

+    public ContentInNotLive.Match toImmutable() {

+      return isMutable() ? newMatch(fParent, fChild) : this;

+    }

+    

+    @Override

+    public String prettyPrint() {

+      StringBuilder result = new StringBuilder();

+      result.append("\"parent\"=" + prettyPrintValue(fParent) + ", ");

+      result.append("\"child\"=" + prettyPrintValue(fChild));

+      return result.toString();

+    }

+    

+    @Override

+    public int hashCode() {

+      return Objects.hash(fParent, fChild);

+    }

+    

+    @Override

+    public boolean equals(final Object obj) {

+      if (this == obj)

+          return true;

+      if (obj == null) {

+          return false;

+      }

+      if ((obj instanceof ContentInNotLive.Match)) {

+          ContentInNotLive.Match other = (ContentInNotLive.Match) obj;

+          return Objects.equals(fParent, other.fParent) && Objects.equals(fChild, other.fChild);

+      } else {

+          // this should be infrequent

+          if (!(obj instanceof IPatternMatch)) {

+              return false;

+          }

+          IPatternMatch otherSig  = (IPatternMatch) obj;

+          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());

+      }

+    }

+    

+    @Override

+    public ContentInNotLive specification() {

+      return ContentInNotLive.instance();

+    }

+    

+    /**

+     * Returns an empty, mutable match.

+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

+     * 

+     * @return the empty match.

+     * 

+     */

+    public static ContentInNotLive.Match newEmptyMatch() {

+      return new Mutable(null, null);

+    }

+    

+    /**

+     * Returns a mutable (partial) match.

+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

+     * 

+     * @param pParent the fixed value of pattern parameter parent, or null if not bound.

+     * @param pChild the fixed value of pattern parameter child, or null if not bound.

+     * @return the new, mutable (partial) match object.

+     * 

+     */

+    public static ContentInNotLive.Match newMutableMatch(final Dir pParent, final FSObject pChild) {

+      return new Mutable(pParent, pChild);

+    }

+    

+    /**

+     * Returns a new (partial) match.

+     * This can be used e.g. to call the matcher with a partial match.

+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

+     * @param pParent the fixed value of pattern parameter parent, or null if not bound.

+     * @param pChild the fixed value of pattern parameter child, or null if not bound.

+     * @return the (partial) match object.

+     * 

+     */

+    public static ContentInNotLive.Match newMatch(final Dir pParent, final FSObject pChild) {

+      return new Immutable(pParent, pChild);

+    }

+    

+    private static final class Mutable extends ContentInNotLive.Match {

+      Mutable(final Dir pParent, final FSObject pChild) {

+        super(pParent, pChild);

+      }

+      

+      @Override

+      public boolean isMutable() {

+        return true;

+      }

+    }

+    

+    private static final class Immutable extends ContentInNotLive.Match {

+      Immutable(final Dir pParent, final FSObject pChild) {

+        super(pParent, pChild);

+      }

+      

+      @Override

+      public boolean isMutable() {

+        return false;

+      }

+    }

+  }

+  

+  /**

+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.contentInNotLive pattern,

+   * providing pattern-specific query methods.

+   * 

+   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

+   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.

+   * 

+   * <p>Matches of the pattern will be represented as {@link Match}.

+   * 

+   * <p>Original source:

+   * <code><pre>

+   * {@literal @}Constraint(key={child}, severity="error", message="error")

+   * pattern contentInNotLive(parent : Dir, child: FSObject) {

+   *    Dir.contents(parent,child);

+   *    neg find live(_,parent);

+   * } or {

+   *    Dir.contents(parent,child);

+   *    neg find live(_,child);

+   * }

+   * </pre></code>

+   * 

+   * @see Match

+   * @see ContentInNotLive

+   * 

+   */

+  public static class Matcher extends BaseMatcher<ContentInNotLive.Match> {

+    /**

+     * Initializes the pattern matcher within an existing VIATRA Query engine.

+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

+     * 

+     * @param engine the existing VIATRA Query engine in which this matcher will be created.

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * 

+     */

+    public static ContentInNotLive.Matcher on(final ViatraQueryEngine engine) {

+      // check if matcher already exists

+      Matcher matcher = engine.getExistingMatcher(querySpecification());

+      if (matcher == null) {

+          matcher = (Matcher)engine.getMatcher(querySpecification());

+      }

+      return matcher;

+    }

+    

+    /**

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * @return an initialized matcher

+     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

+     * 

+     */

+    public static ContentInNotLive.Matcher create() {

+      return new Matcher();

+    }

+    

+    private final static int POSITION_PARENT = 0;

+    

+    private final static int POSITION_CHILD = 1;

+    

+    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(ContentInNotLive.Matcher.class);

+    

+    /**

+     * Initializes the pattern matcher within an existing VIATRA Query engine.

+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

+     * 

+     * @param engine the existing VIATRA Query engine in which this matcher will be created.

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * 

+     */

+    private Matcher() {

+      super(querySpecification());

+    }

+    

+    /**

+     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

+     * @param pParent the fixed value of pattern parameter parent, or null if not bound.

+     * @param pChild the fixed value of pattern parameter child, or null if not bound.

+     * @return matches represented as a Match object.

+     * 

+     */

+    public Collection<ContentInNotLive.Match> getAllMatches(final Dir pParent, final FSObject pChild) {

+      return rawStreamAllMatches(new Object[]{pParent, pChild}).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     * @param pParent the fixed value of pattern parameter parent, or null if not bound.

+     * @param pChild the fixed value of pattern parameter child, or null if not bound.

+     * @return a stream of matches represented as a Match object.

+     * 

+     */

+    public Stream<ContentInNotLive.Match> streamAllMatches(final Dir pParent, final FSObject pChild) {

+      return rawStreamAllMatches(new Object[]{pParent, pChild});

+    }

+    

+    /**

+     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

+     * Neither determinism nor randomness of selection is guaranteed.

+     * @param pParent the fixed value of pattern parameter parent, or null if not bound.

+     * @param pChild the fixed value of pattern parameter child, or null if not bound.

+     * @return a match represented as a Match object, or null if no match is found.

+     * 

+     */

+    public Optional<ContentInNotLive.Match> getOneArbitraryMatch(final Dir pParent, final FSObject pChild) {

+      return rawGetOneArbitraryMatch(new Object[]{pParent, pChild});

+    }

+    

+    /**

+     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

+     * under any possible substitution of the unspecified parameters (if any).

+     * @param pParent the fixed value of pattern parameter parent, or null if not bound.

+     * @param pChild the fixed value of pattern parameter child, or null if not bound.

+     * @return true if the input is a valid (partial) match of the pattern.

+     * 

+     */

+    public boolean hasMatch(final Dir pParent, final FSObject pChild) {

+      return rawHasMatch(new Object[]{pParent, pChild});

+    }

+    

+    /**

+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

+     * @param pParent the fixed value of pattern parameter parent, or null if not bound.

+     * @param pChild the fixed value of pattern parameter child, or null if not bound.

+     * @return the number of pattern matches found.

+     * 

+     */

+    public int countMatches(final Dir pParent, final FSObject pChild) {

+      return rawCountMatches(new Object[]{pParent, pChild});

+    }

+    

+    /**

+     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

+     * Neither determinism nor randomness of selection is guaranteed.

+     * @param pParent the fixed value of pattern parameter parent, or null if not bound.

+     * @param pChild the fixed value of pattern parameter child, or null if not bound.

+     * @param processor the action that will process the selected match.

+     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

+     * 

+     */

+    public boolean forOneArbitraryMatch(final Dir pParent, final FSObject pChild, final Consumer<? super ContentInNotLive.Match> processor) {

+      return rawForOneArbitraryMatch(new Object[]{pParent, pChild}, processor);

+    }

+    

+    /**

+     * Returns a new (partial) match.

+     * This can be used e.g. to call the matcher with a partial match.

+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

+     * @param pParent the fixed value of pattern parameter parent, or null if not bound.

+     * @param pChild the fixed value of pattern parameter child, or null if not bound.

+     * @return the (partial) match object.

+     * 

+     */

+    public ContentInNotLive.Match newMatch(final Dir pParent, final FSObject pChild) {

+      return ContentInNotLive.Match.newMatch(pParent, pChild);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for parent.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    protected Stream<Dir> rawStreamAllValuesOfparent(final Object[] parameters) {

+      return rawStreamAllValues(POSITION_PARENT, parameters).map(Dir.class::cast);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for parent.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<Dir> getAllValuesOfparent() {

+      return rawStreamAllValuesOfparent(emptyArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for parent.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<Dir> streamAllValuesOfparent() {

+      return rawStreamAllValuesOfparent(emptyArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for parent.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<Dir> streamAllValuesOfparent(final ContentInNotLive.Match partialMatch) {

+      return rawStreamAllValuesOfparent(partialMatch.toArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for parent.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<Dir> streamAllValuesOfparent(final FSObject pChild) {

+      return rawStreamAllValuesOfparent(new Object[]{null, pChild});

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for parent.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<Dir> getAllValuesOfparent(final ContentInNotLive.Match partialMatch) {

+      return rawStreamAllValuesOfparent(partialMatch.toArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for parent.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<Dir> getAllValuesOfparent(final FSObject pChild) {

+      return rawStreamAllValuesOfparent(new Object[]{null, pChild}).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for child.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    protected Stream<FSObject> rawStreamAllValuesOfchild(final Object[] parameters) {

+      return rawStreamAllValues(POSITION_CHILD, parameters).map(FSObject.class::cast);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for child.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<FSObject> getAllValuesOfchild() {

+      return rawStreamAllValuesOfchild(emptyArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for child.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<FSObject> streamAllValuesOfchild() {

+      return rawStreamAllValuesOfchild(emptyArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for child.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<FSObject> streamAllValuesOfchild(final ContentInNotLive.Match partialMatch) {

+      return rawStreamAllValuesOfchild(partialMatch.toArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for child.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<FSObject> streamAllValuesOfchild(final Dir pParent) {

+      return rawStreamAllValuesOfchild(new Object[]{pParent, null});

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for child.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<FSObject> getAllValuesOfchild(final ContentInNotLive.Match partialMatch) {

+      return rawStreamAllValuesOfchild(partialMatch.toArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for child.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<FSObject> getAllValuesOfchild(final Dir pParent) {

+      return rawStreamAllValuesOfchild(new Object[]{pParent, null}).collect(Collectors.toSet());

+    }

+    

+    @Override

+    protected ContentInNotLive.Match tupleToMatch(final Tuple t) {

+      try {

+          return ContentInNotLive.Match.newMatch((Dir) t.get(POSITION_PARENT), (FSObject) t.get(POSITION_CHILD));

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in tuple not properly typed!",e);

+          return null;

+      }

+    }

+    

+    @Override

+    protected ContentInNotLive.Match arrayToMatch(final Object[] match) {

+      try {

+          return ContentInNotLive.Match.newMatch((Dir) match[POSITION_PARENT], (FSObject) match[POSITION_CHILD]);

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in array not properly typed!",e);

+          return null;

+      }

+    }

+    

+    @Override

+    protected ContentInNotLive.Match arrayToMatchMutable(final Object[] match) {

+      try {

+          return ContentInNotLive.Match.newMutableMatch((Dir) match[POSITION_PARENT], (FSObject) match[POSITION_CHILD]);

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in array not properly typed!",e);

+          return null;

+      }

+    }

+    

+    /**

+     * @return the singleton instance of the query specification of this pattern

+     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

+     * 

+     */

+    public static IQuerySpecification<ContentInNotLive.Matcher> querySpecification() {

+      return ContentInNotLive.instance();

+    }

+  }

+  

+  private ContentInNotLive() {

+    super(GeneratedPQuery.INSTANCE);

+  }

+  

+  /**

+   * @return the singleton instance of the query specification

+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

+   * 

+   */

+  public static ContentInNotLive instance() {

+    try{

+        return LazyHolder.INSTANCE;

+    } catch (ExceptionInInitializerError err) {

+        throw processInitializerError(err);

+    }

+  }

+  

+  @Override

+  protected ContentInNotLive.Matcher instantiate(final ViatraQueryEngine engine) {

+    return ContentInNotLive.Matcher.on(engine);

+  }

+  

+  @Override

+  public ContentInNotLive.Matcher instantiate() {

+    return ContentInNotLive.Matcher.create();

+  }

+  

+  @Override

+  public ContentInNotLive.Match newEmptyMatch() {

+    return ContentInNotLive.Match.newEmptyMatch();

+  }

+  

+  @Override

+  public ContentInNotLive.Match newMatch(final Object... parameters) {

+    return ContentInNotLive.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.Dir) parameters[0], (hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject) parameters[1]);

+  }

+  

+  /**

+   * Inner class allowing the singleton instance of {@link JvmGenericType: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.ContentInNotLive (visibility: PUBLIC, simpleName: ContentInNotLive, identifier: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.ContentInNotLive, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: hu.bme.mit.inf.dslreasoner.domains.alloyexamples) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

+   *     <b>not</b> at the class load time of the outer class, 

+   *     but rather at the first call to {@link JvmGenericType: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.ContentInNotLive (visibility: PUBLIC, simpleName: ContentInNotLive, identifier: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.ContentInNotLive, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: hu.bme.mit.inf.dslreasoner.domains.alloyexamples) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

+   * 

+   * <p> This workaround is required e.g. to support recursion.

+   * 

+   */

+  private static class LazyHolder {

+    private final static ContentInNotLive INSTANCE = new ContentInNotLive();

+    

+    /**

+     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

+     * This initialization order is required to support indirect recursion.

+     * 

+     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.

+     * 

+     */

+    private final static Object STATIC_INITIALIZER = ensureInitialized();

+    

+    public static Object ensureInitialized() {

+      INSTANCE.ensureInitializedInternal();

+      return null;

+    }

+  }

+  

+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

+    private final static ContentInNotLive.GeneratedPQuery INSTANCE = new GeneratedPQuery();

+    

+    private final PParameter parameter_parent = new PParameter("parent", "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.Dir", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("FS", "Dir")), PParameterDirection.INOUT);

+    

+    private final PParameter parameter_child = new PParameter("child", "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("FS", "FSObject")), PParameterDirection.INOUT);

+    

+    private final List<PParameter> parameters = Arrays.asList(parameter_parent, parameter_child);

+    

+    private GeneratedPQuery() {

+      super(PVisibility.PUBLIC);

+    }

+    

+    @Override

+    public String getFullyQualifiedName() {

+      return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.contentInNotLive";

+    }

+    

+    @Override

+    public List<String> getParameterNames() {

+      return Arrays.asList("parent","child");

+    }

+    

+    @Override

+    public List<PParameter> getParameters() {

+      return parameters;

+    }

+    

+    @Override

+    public Set<PBody> doGetContainedBodies() {

+      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));

+      Set<PBody> bodies = new LinkedHashSet<>();

+      {

+          PBody body = new PBody(this);

+          PVariable var_parent = body.getOrCreateVariableByName("parent");

+          PVariable var_child = body.getOrCreateVariableByName("child");

+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_parent), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "Dir")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var_child), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FSObject")));

+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

+             new ExportedParameter(body, var_parent, parameter_parent),

+             new ExportedParameter(body, var_child, parameter_child)

+          ));

+          //    Dir.contents(parent,child)

+          new TypeConstraint(body, Tuples.flatTupleOf(var_parent), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "Dir")));

+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_parent, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("FS", "Dir", "contents")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FSObject")));

+          new Equality(body, var__virtual_0_, var_child);

+          //    neg find live(_,parent)

+          new NegativePatternCall(body, Tuples.flatTupleOf(var___0_, var_parent), Live.instance().getInternalQueryRepresentation());

+          bodies.add(body);

+      }

+      {

+          PBody body = new PBody(this);

+          PVariable var_parent = body.getOrCreateVariableByName("parent");

+          PVariable var_child = body.getOrCreateVariableByName("child");

+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_parent), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "Dir")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var_child), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FSObject")));

+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

+             new ExportedParameter(body, var_parent, parameter_parent),

+             new ExportedParameter(body, var_child, parameter_child)

+          ));

+          //    Dir.contents(parent,child)

+          new TypeConstraint(body, Tuples.flatTupleOf(var_parent), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "Dir")));

+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_parent, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("FS", "Dir", "contents")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FSObject")));

+          new Equality(body, var__virtual_0_, var_child);

+          //    neg find live(_,child)

+          new NegativePatternCall(body, Tuples.flatTupleOf(var___0_, var_child), Live.instance().getInternalQueryRepresentation());

+          bodies.add(body);

+      }

+      {

+          PAnnotation annotation = new PAnnotation("Constraint");

+          annotation.addAttribute("key", Arrays.asList(new Object[] {

+                              new ParameterReference("child")

+                              }));

+          annotation.addAttribute("severity", "error");

+          annotation.addAttribute("message", "error");

+          addAnnotation(annotation);

+      }

+      return bodies;

+    }

+  }

+}

diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/DirectSupertype.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/DirectSupertype.java
new file mode 100644
index 00000000..ffa846a0
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/DirectSupertype.java
@@ -0,0 +1,692 @@
+/**

+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/patterns/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Ecore.vql

+ */

+package hu.bme.mit.inf.dslreasoner.domains.alloyexamples;

+

+import java.util.Arrays;

+import java.util.Collection;

+import java.util.LinkedHashSet;

+import java.util.List;

+import java.util.Objects;

+import java.util.Optional;

+import java.util.Set;

+import java.util.function.Consumer;

+import java.util.stream.Collectors;

+import java.util.stream.Stream;

+import org.apache.log4j.Logger;

+import org.eclipse.emf.ecore.EClass;

+import org.eclipse.viatra.query.runtime.api.IPatternMatch;

+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;

+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;

+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;

+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;

+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;

+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;

+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;

+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;

+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;

+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;

+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;

+

+/**

+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.

+ * 

+ * <p>Original source:

+ *         <code><pre>

+ *         pattern directSupertype(a: EClass, b:EClass) {

+ *              EClass.eSuperTypes(a,b);

+ *         }

+ * </pre></code>

+ * 

+ * @see Matcher

+ * @see Match

+ * 

+ */

+@SuppressWarnings("all")

+public final class DirectSupertype extends BaseGeneratedEMFQuerySpecification<DirectSupertype.Matcher> {

+  /**

+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.directSupertype pattern,

+   * to be used in conjunction with {@link Matcher}.

+   * 

+   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

+   * Each instance is a (possibly partial) substitution of pattern parameters,

+   * usable to represent a match of the pattern in the result of a query,

+   * or to specify the bound (fixed) input parameters when issuing a query.

+   * 

+   * @see Matcher

+   * 

+   */

+  public static abstract class Match extends BasePatternMatch {

+    private EClass fA;

+    

+    private EClass fB;

+    

+    private static List<String> parameterNames = makeImmutableList("a", "b");

+    

+    private Match(final EClass pA, final EClass pB) {

+      this.fA = pA;

+      this.fB = pB;

+    }

+    

+    @Override

+    public Object get(final String parameterName) {

+      if ("a".equals(parameterName)) return this.fA;

+      if ("b".equals(parameterName)) return this.fB;

+      return null;

+    }

+    

+    public EClass getA() {

+      return this.fA;

+    }

+    

+    public EClass getB() {

+      return this.fB;

+    }

+    

+    @Override

+    public boolean set(final String parameterName, final Object newValue) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      if ("a".equals(parameterName) ) {

+          this.fA = (EClass) newValue;

+          return true;

+      }

+      if ("b".equals(parameterName) ) {

+          this.fB = (EClass) newValue;

+          return true;

+      }

+      return false;

+    }

+    

+    public void setA(final EClass pA) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      this.fA = pA;

+    }

+    

+    public void setB(final EClass pB) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      this.fB = pB;

+    }

+    

+    @Override

+    public String patternName() {

+      return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.directSupertype";

+    }

+    

+    @Override

+    public List<String> parameterNames() {

+      return DirectSupertype.Match.parameterNames;

+    }

+    

+    @Override

+    public Object[] toArray() {

+      return new Object[]{fA, fB};

+    }

+    

+    @Override

+    public DirectSupertype.Match toImmutable() {

+      return isMutable() ? newMatch(fA, fB) : this;

+    }

+    

+    @Override

+    public String prettyPrint() {

+      StringBuilder result = new StringBuilder();

+      result.append("\"a\"=" + prettyPrintValue(fA) + ", ");

+      result.append("\"b\"=" + prettyPrintValue(fB));

+      return result.toString();

+    }

+    

+    @Override

+    public int hashCode() {

+      return Objects.hash(fA, fB);

+    }

+    

+    @Override

+    public boolean equals(final Object obj) {

+      if (this == obj)

+          return true;

+      if (obj == null) {

+          return false;

+      }

+      if ((obj instanceof DirectSupertype.Match)) {

+          DirectSupertype.Match other = (DirectSupertype.Match) obj;

+          return Objects.equals(fA, other.fA) && Objects.equals(fB, other.fB);

+      } else {

+          // this should be infrequent

+          if (!(obj instanceof IPatternMatch)) {

+              return false;

+          }

+          IPatternMatch otherSig  = (IPatternMatch) obj;

+          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());

+      }

+    }

+    

+    @Override

+    public DirectSupertype specification() {

+      return DirectSupertype.instance();

+    }

+    

+    /**

+     * Returns an empty, mutable match.

+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

+     * 

+     * @return the empty match.

+     * 

+     */

+    public static DirectSupertype.Match newEmptyMatch() {

+      return new Mutable(null, null);

+    }

+    

+    /**

+     * Returns a mutable (partial) match.

+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

+     * 

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return the new, mutable (partial) match object.

+     * 

+     */

+    public static DirectSupertype.Match newMutableMatch(final EClass pA, final EClass pB) {

+      return new Mutable(pA, pB);

+    }

+    

+    /**

+     * Returns a new (partial) match.

+     * This can be used e.g. to call the matcher with a partial match.

+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return the (partial) match object.

+     * 

+     */

+    public static DirectSupertype.Match newMatch(final EClass pA, final EClass pB) {

+      return new Immutable(pA, pB);

+    }

+    

+    private static final class Mutable extends DirectSupertype.Match {

+      Mutable(final EClass pA, final EClass pB) {

+        super(pA, pB);

+      }

+      

+      @Override

+      public boolean isMutable() {

+        return true;

+      }

+    }

+    

+    private static final class Immutable extends DirectSupertype.Match {

+      Immutable(final EClass pA, final EClass pB) {

+        super(pA, pB);

+      }

+      

+      @Override

+      public boolean isMutable() {

+        return false;

+      }

+    }

+  }

+  

+  /**

+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.directSupertype pattern,

+   * providing pattern-specific query methods.

+   * 

+   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

+   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.

+   * 

+   * <p>Matches of the pattern will be represented as {@link Match}.

+   * 

+   * <p>Original source:

+   * <code><pre>

+   * pattern directSupertype(a: EClass, b:EClass) {

+   *    EClass.eSuperTypes(a,b);

+   * }

+   * </pre></code>

+   * 

+   * @see Match

+   * @see DirectSupertype

+   * 

+   */

+  public static class Matcher extends BaseMatcher<DirectSupertype.Match> {

+    /**

+     * Initializes the pattern matcher within an existing VIATRA Query engine.

+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

+     * 

+     * @param engine the existing VIATRA Query engine in which this matcher will be created.

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * 

+     */

+    public static DirectSupertype.Matcher on(final ViatraQueryEngine engine) {

+      // check if matcher already exists

+      Matcher matcher = engine.getExistingMatcher(querySpecification());

+      if (matcher == null) {

+          matcher = (Matcher)engine.getMatcher(querySpecification());

+      }

+      return matcher;

+    }

+    

+    /**

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * @return an initialized matcher

+     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

+     * 

+     */

+    public static DirectSupertype.Matcher create() {

+      return new Matcher();

+    }

+    

+    private final static int POSITION_A = 0;

+    

+    private final static int POSITION_B = 1;

+    

+    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(DirectSupertype.Matcher.class);

+    

+    /**

+     * Initializes the pattern matcher within an existing VIATRA Query engine.

+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

+     * 

+     * @param engine the existing VIATRA Query engine in which this matcher will be created.

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * 

+     */

+    private Matcher() {

+      super(querySpecification());

+    }

+    

+    /**

+     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return matches represented as a Match object.

+     * 

+     */

+    public Collection<DirectSupertype.Match> getAllMatches(final EClass pA, final EClass pB) {

+      return rawStreamAllMatches(new Object[]{pA, pB}).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return a stream of matches represented as a Match object.

+     * 

+     */

+    public Stream<DirectSupertype.Match> streamAllMatches(final EClass pA, final EClass pB) {

+      return rawStreamAllMatches(new Object[]{pA, pB});

+    }

+    

+    /**

+     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

+     * Neither determinism nor randomness of selection is guaranteed.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return a match represented as a Match object, or null if no match is found.

+     * 

+     */

+    public Optional<DirectSupertype.Match> getOneArbitraryMatch(final EClass pA, final EClass pB) {

+      return rawGetOneArbitraryMatch(new Object[]{pA, pB});

+    }

+    

+    /**

+     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

+     * under any possible substitution of the unspecified parameters (if any).

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return true if the input is a valid (partial) match of the pattern.

+     * 

+     */

+    public boolean hasMatch(final EClass pA, final EClass pB) {

+      return rawHasMatch(new Object[]{pA, pB});

+    }

+    

+    /**

+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return the number of pattern matches found.

+     * 

+     */

+    public int countMatches(final EClass pA, final EClass pB) {

+      return rawCountMatches(new Object[]{pA, pB});

+    }

+    

+    /**

+     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

+     * Neither determinism nor randomness of selection is guaranteed.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @param processor the action that will process the selected match.

+     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

+     * 

+     */

+    public boolean forOneArbitraryMatch(final EClass pA, final EClass pB, final Consumer<? super DirectSupertype.Match> processor) {

+      return rawForOneArbitraryMatch(new Object[]{pA, pB}, processor);

+    }

+    

+    /**

+     * Returns a new (partial) match.

+     * This can be used e.g. to call the matcher with a partial match.

+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return the (partial) match object.

+     * 

+     */

+    public DirectSupertype.Match newMatch(final EClass pA, final EClass pB) {

+      return DirectSupertype.Match.newMatch(pA, pB);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    protected Stream<EClass> rawStreamAllValuesOfa(final Object[] parameters) {

+      return rawStreamAllValues(POSITION_A, parameters).map(EClass.class::cast);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EClass> getAllValuesOfa() {

+      return rawStreamAllValuesOfa(emptyArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EClass> streamAllValuesOfa() {

+      return rawStreamAllValuesOfa(emptyArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EClass> streamAllValuesOfa(final DirectSupertype.Match partialMatch) {

+      return rawStreamAllValuesOfa(partialMatch.toArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EClass> streamAllValuesOfa(final EClass pB) {

+      return rawStreamAllValuesOfa(new Object[]{null, pB});

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EClass> getAllValuesOfa(final DirectSupertype.Match partialMatch) {

+      return rawStreamAllValuesOfa(partialMatch.toArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EClass> getAllValuesOfa(final EClass pB) {

+      return rawStreamAllValuesOfa(new Object[]{null, pB}).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    protected Stream<EClass> rawStreamAllValuesOfb(final Object[] parameters) {

+      return rawStreamAllValues(POSITION_B, parameters).map(EClass.class::cast);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EClass> getAllValuesOfb() {

+      return rawStreamAllValuesOfb(emptyArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EClass> streamAllValuesOfb() {

+      return rawStreamAllValuesOfb(emptyArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EClass> streamAllValuesOfb(final DirectSupertype.Match partialMatch) {

+      return rawStreamAllValuesOfb(partialMatch.toArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EClass> streamAllValuesOfb(final EClass pA) {

+      return rawStreamAllValuesOfb(new Object[]{pA, null});

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EClass> getAllValuesOfb(final DirectSupertype.Match partialMatch) {

+      return rawStreamAllValuesOfb(partialMatch.toArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EClass> getAllValuesOfb(final EClass pA) {

+      return rawStreamAllValuesOfb(new Object[]{pA, null}).collect(Collectors.toSet());

+    }

+    

+    @Override

+    protected DirectSupertype.Match tupleToMatch(final Tuple t) {

+      try {

+          return DirectSupertype.Match.newMatch((EClass) t.get(POSITION_A), (EClass) t.get(POSITION_B));

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in tuple not properly typed!",e);

+          return null;

+      }

+    }

+    

+    @Override

+    protected DirectSupertype.Match arrayToMatch(final Object[] match) {

+      try {

+          return DirectSupertype.Match.newMatch((EClass) match[POSITION_A], (EClass) match[POSITION_B]);

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in array not properly typed!",e);

+          return null;

+      }

+    }

+    

+    @Override

+    protected DirectSupertype.Match arrayToMatchMutable(final Object[] match) {

+      try {

+          return DirectSupertype.Match.newMutableMatch((EClass) match[POSITION_A], (EClass) match[POSITION_B]);

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in array not properly typed!",e);

+          return null;

+      }

+    }

+    

+    /**

+     * @return the singleton instance of the query specification of this pattern

+     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

+     * 

+     */

+    public static IQuerySpecification<DirectSupertype.Matcher> querySpecification() {

+      return DirectSupertype.instance();

+    }

+  }

+  

+  private DirectSupertype() {

+    super(GeneratedPQuery.INSTANCE);

+  }

+  

+  /**

+   * @return the singleton instance of the query specification

+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

+   * 

+   */

+  public static DirectSupertype instance() {

+    try{

+        return LazyHolder.INSTANCE;

+    } catch (ExceptionInInitializerError err) {

+        throw processInitializerError(err);

+    }

+  }

+  

+  @Override

+  protected DirectSupertype.Matcher instantiate(final ViatraQueryEngine engine) {

+    return DirectSupertype.Matcher.on(engine);

+  }

+  

+  @Override

+  public DirectSupertype.Matcher instantiate() {

+    return DirectSupertype.Matcher.create();

+  }

+  

+  @Override

+  public DirectSupertype.Match newEmptyMatch() {

+    return DirectSupertype.Match.newEmptyMatch();

+  }

+  

+  @Override

+  public DirectSupertype.Match newMatch(final Object... parameters) {

+    return DirectSupertype.Match.newMatch((org.eclipse.emf.ecore.EClass) parameters[0], (org.eclipse.emf.ecore.EClass) parameters[1]);

+  }

+  

+  /**

+   * Inner class allowing the singleton instance of {@link JvmGenericType: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.DirectSupertype (visibility: PUBLIC, simpleName: DirectSupertype, identifier: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.DirectSupertype, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: hu.bme.mit.inf.dslreasoner.domains.alloyexamples) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

+   *     <b>not</b> at the class load time of the outer class, 

+   *     but rather at the first call to {@link JvmGenericType: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.DirectSupertype (visibility: PUBLIC, simpleName: DirectSupertype, identifier: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.DirectSupertype, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: hu.bme.mit.inf.dslreasoner.domains.alloyexamples) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

+   * 

+   * <p> This workaround is required e.g. to support recursion.

+   * 

+   */

+  private static class LazyHolder {

+    private final static DirectSupertype INSTANCE = new DirectSupertype();

+    

+    /**

+     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

+     * This initialization order is required to support indirect recursion.

+     * 

+     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.

+     * 

+     */

+    private final static Object STATIC_INITIALIZER = ensureInitialized();

+    

+    public static Object ensureInitialized() {

+      INSTANCE.ensureInitializedInternal();

+      return null;

+    }

+  }

+  

+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

+    private final static DirectSupertype.GeneratedPQuery INSTANCE = new GeneratedPQuery();

+    

+    private final PParameter parameter_a = new PParameter("a", "org.eclipse.emf.ecore.EClass", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EClass")), PParameterDirection.INOUT);

+    

+    private final PParameter parameter_b = new PParameter("b", "org.eclipse.emf.ecore.EClass", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EClass")), PParameterDirection.INOUT);

+    

+    private final List<PParameter> parameters = Arrays.asList(parameter_a, parameter_b);

+    

+    private GeneratedPQuery() {

+      super(PVisibility.PUBLIC);

+    }

+    

+    @Override

+    public String getFullyQualifiedName() {

+      return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.directSupertype";

+    }

+    

+    @Override

+    public List<String> getParameterNames() {

+      return Arrays.asList("a","b");

+    }

+    

+    @Override

+    public List<PParameter> getParameters() {

+      return parameters;

+    }

+    

+    @Override

+    public Set<PBody> doGetContainedBodies() {

+      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));

+      Set<PBody> bodies = new LinkedHashSet<>();

+      {

+          PBody body = new PBody(this);

+          PVariable var_a = body.getOrCreateVariableByName("a");

+          PVariable var_b = body.getOrCreateVariableByName("b");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var_b), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));

+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

+             new ExportedParameter(body, var_a, parameter_a),

+             new ExportedParameter(body, var_b, parameter_b)

+          ));

+          //    EClass.eSuperTypes(a,b)

+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));

+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_a, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass", "eSuperTypes")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));

+          new Equality(body, var__virtual_0_, var_b);

+          bodies.add(body);

+      }

+      return bodies;

+    }

+  }

+}

diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Live.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Live.java
new file mode 100644
index 00000000..7bc2f458
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Live.java
@@ -0,0 +1,730 @@
+/**

+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/patterns/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/FileSystem.vql

+ */

+package hu.bme.mit.inf.dslreasoner.domains.alloyexamples;

+

+import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject;

+import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FileSystem;

+import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.PatternContent;

+import java.util.Arrays;

+import java.util.Collection;

+import java.util.LinkedHashSet;

+import java.util.List;

+import java.util.Objects;

+import java.util.Optional;

+import java.util.Set;

+import java.util.function.Consumer;

+import java.util.stream.Collectors;

+import java.util.stream.Stream;

+import org.apache.log4j.Logger;

+import org.eclipse.emf.ecore.EClass;

+import org.eclipse.viatra.query.runtime.api.IPatternMatch;

+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;

+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;

+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;

+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;

+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;

+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;

+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;

+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;

+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;

+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;

+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;

+

+/**

+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.

+ * 

+ * <p>Original source:

+ *         <code><pre>

+ *         {@literal @}QueryBasedFeature

+ *         pattern live(this: FileSystem, l: FSObject) {

+ *              FileSystem.root(this,l);

+ *         } or {

+ *              FileSystem.root(this,root);

+ *              find patternContent+(root,l);

+ *         }

+ * </pre></code>

+ * 

+ * @see Matcher

+ * @see Match

+ * 

+ */

+@SuppressWarnings("all")

+public final class Live extends BaseGeneratedEMFQuerySpecification<Live.Matcher> {

+  /**

+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.live pattern,

+   * to be used in conjunction with {@link Matcher}.

+   * 

+   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

+   * Each instance is a (possibly partial) substitution of pattern parameters,

+   * usable to represent a match of the pattern in the result of a query,

+   * or to specify the bound (fixed) input parameters when issuing a query.

+   * 

+   * @see Matcher

+   * 

+   */

+  public static abstract class Match extends BasePatternMatch {

+    private FileSystem fThis;

+    

+    private FSObject fL;

+    

+    private static List<String> parameterNames = makeImmutableList("this", "l");

+    

+    private Match(final FileSystem pThis, final FSObject pL) {

+      this.fThis = pThis;

+      this.fL = pL;

+    }

+    

+    @Override

+    public Object get(final String parameterName) {

+      if ("this".equals(parameterName)) return this.fThis;

+      if ("l".equals(parameterName)) return this.fL;

+      return null;

+    }

+    

+    public FileSystem getThis() {

+      return this.fThis;

+    }

+    

+    public FSObject getL() {

+      return this.fL;

+    }

+    

+    @Override

+    public boolean set(final String parameterName, final Object newValue) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      if ("this".equals(parameterName) ) {

+          this.fThis = (FileSystem) newValue;

+          return true;

+      }

+      if ("l".equals(parameterName) ) {

+          this.fL = (FSObject) newValue;

+          return true;

+      }

+      return false;

+    }

+    

+    public void setThis(final FileSystem pThis) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      this.fThis = pThis;

+    }

+    

+    public void setL(final FSObject pL) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      this.fL = pL;

+    }

+    

+    @Override

+    public String patternName() {

+      return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.live";

+    }

+    

+    @Override

+    public List<String> parameterNames() {

+      return Live.Match.parameterNames;

+    }

+    

+    @Override

+    public Object[] toArray() {

+      return new Object[]{fThis, fL};

+    }

+    

+    @Override

+    public Live.Match toImmutable() {

+      return isMutable() ? newMatch(fThis, fL) : this;

+    }

+    

+    @Override

+    public String prettyPrint() {

+      StringBuilder result = new StringBuilder();

+      result.append("\"this\"=" + prettyPrintValue(fThis) + ", ");

+      result.append("\"l\"=" + prettyPrintValue(fL));

+      return result.toString();

+    }

+    

+    @Override

+    public int hashCode() {

+      return Objects.hash(fThis, fL);

+    }

+    

+    @Override

+    public boolean equals(final Object obj) {

+      if (this == obj)

+          return true;

+      if (obj == null) {

+          return false;

+      }

+      if ((obj instanceof Live.Match)) {

+          Live.Match other = (Live.Match) obj;

+          return Objects.equals(fThis, other.fThis) && Objects.equals(fL, other.fL);

+      } else {

+          // this should be infrequent

+          if (!(obj instanceof IPatternMatch)) {

+              return false;

+          }

+          IPatternMatch otherSig  = (IPatternMatch) obj;

+          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());

+      }

+    }

+    

+    @Override

+    public Live specification() {

+      return Live.instance();

+    }

+    

+    /**

+     * Returns an empty, mutable match.

+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

+     * 

+     * @return the empty match.

+     * 

+     */

+    public static Live.Match newEmptyMatch() {

+      return new Mutable(null, null);

+    }

+    

+    /**

+     * Returns a mutable (partial) match.

+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

+     * 

+     * @param pThis the fixed value of pattern parameter this, or null if not bound.

+     * @param pL the fixed value of pattern parameter l, or null if not bound.

+     * @return the new, mutable (partial) match object.

+     * 

+     */

+    public static Live.Match newMutableMatch(final FileSystem pThis, final FSObject pL) {

+      return new Mutable(pThis, pL);

+    }

+    

+    /**

+     * Returns a new (partial) match.

+     * This can be used e.g. to call the matcher with a partial match.

+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

+     * @param pThis the fixed value of pattern parameter this, or null if not bound.

+     * @param pL the fixed value of pattern parameter l, or null if not bound.

+     * @return the (partial) match object.

+     * 

+     */

+    public static Live.Match newMatch(final FileSystem pThis, final FSObject pL) {

+      return new Immutable(pThis, pL);

+    }

+    

+    private static final class Mutable extends Live.Match {

+      Mutable(final FileSystem pThis, final FSObject pL) {

+        super(pThis, pL);

+      }

+      

+      @Override

+      public boolean isMutable() {

+        return true;

+      }

+    }

+    

+    private static final class Immutable extends Live.Match {

+      Immutable(final FileSystem pThis, final FSObject pL) {

+        super(pThis, pL);

+      }

+      

+      @Override

+      public boolean isMutable() {

+        return false;

+      }

+    }

+  }

+  

+  /**

+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.live pattern,

+   * providing pattern-specific query methods.

+   * 

+   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

+   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.

+   * 

+   * <p>Matches of the pattern will be represented as {@link Match}.

+   * 

+   * <p>Original source:

+   * <code><pre>

+   * {@literal @}QueryBasedFeature

+   * pattern live(this: FileSystem, l: FSObject) {

+   *    FileSystem.root(this,l);

+   * } or {

+   *    FileSystem.root(this,root);

+   *    find patternContent+(root,l);

+   * }

+   * </pre></code>

+   * 

+   * @see Match

+   * @see Live

+   * 

+   */

+  public static class Matcher extends BaseMatcher<Live.Match> {

+    /**

+     * Initializes the pattern matcher within an existing VIATRA Query engine.

+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

+     * 

+     * @param engine the existing VIATRA Query engine in which this matcher will be created.

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * 

+     */

+    public static Live.Matcher on(final ViatraQueryEngine engine) {

+      // check if matcher already exists

+      Matcher matcher = engine.getExistingMatcher(querySpecification());

+      if (matcher == null) {

+          matcher = (Matcher)engine.getMatcher(querySpecification());

+      }

+      return matcher;

+    }

+    

+    /**

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * @return an initialized matcher

+     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

+     * 

+     */

+    public static Live.Matcher create() {

+      return new Matcher();

+    }

+    

+    private final static int POSITION_THIS = 0;

+    

+    private final static int POSITION_L = 1;

+    

+    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(Live.Matcher.class);

+    

+    /**

+     * Initializes the pattern matcher within an existing VIATRA Query engine.

+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

+     * 

+     * @param engine the existing VIATRA Query engine in which this matcher will be created.

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * 

+     */

+    private Matcher() {

+      super(querySpecification());

+    }

+    

+    /**

+     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

+     * @param pThis the fixed value of pattern parameter this, or null if not bound.

+     * @param pL the fixed value of pattern parameter l, or null if not bound.

+     * @return matches represented as a Match object.

+     * 

+     */

+    public Collection<Live.Match> getAllMatches(final FileSystem pThis, final FSObject pL) {

+      return rawStreamAllMatches(new Object[]{pThis, pL}).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     * @param pThis the fixed value of pattern parameter this, or null if not bound.

+     * @param pL the fixed value of pattern parameter l, or null if not bound.

+     * @return a stream of matches represented as a Match object.

+     * 

+     */

+    public Stream<Live.Match> streamAllMatches(final FileSystem pThis, final FSObject pL) {

+      return rawStreamAllMatches(new Object[]{pThis, pL});

+    }

+    

+    /**

+     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

+     * Neither determinism nor randomness of selection is guaranteed.

+     * @param pThis the fixed value of pattern parameter this, or null if not bound.

+     * @param pL the fixed value of pattern parameter l, or null if not bound.

+     * @return a match represented as a Match object, or null if no match is found.

+     * 

+     */

+    public Optional<Live.Match> getOneArbitraryMatch(final FileSystem pThis, final FSObject pL) {

+      return rawGetOneArbitraryMatch(new Object[]{pThis, pL});

+    }

+    

+    /**

+     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

+     * under any possible substitution of the unspecified parameters (if any).

+     * @param pThis the fixed value of pattern parameter this, or null if not bound.

+     * @param pL the fixed value of pattern parameter l, or null if not bound.

+     * @return true if the input is a valid (partial) match of the pattern.

+     * 

+     */

+    public boolean hasMatch(final FileSystem pThis, final FSObject pL) {

+      return rawHasMatch(new Object[]{pThis, pL});

+    }

+    

+    /**

+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

+     * @param pThis the fixed value of pattern parameter this, or null if not bound.

+     * @param pL the fixed value of pattern parameter l, or null if not bound.

+     * @return the number of pattern matches found.

+     * 

+     */

+    public int countMatches(final FileSystem pThis, final FSObject pL) {

+      return rawCountMatches(new Object[]{pThis, pL});

+    }

+    

+    /**

+     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

+     * Neither determinism nor randomness of selection is guaranteed.

+     * @param pThis the fixed value of pattern parameter this, or null if not bound.

+     * @param pL the fixed value of pattern parameter l, or null if not bound.

+     * @param processor the action that will process the selected match.

+     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

+     * 

+     */

+    public boolean forOneArbitraryMatch(final FileSystem pThis, final FSObject pL, final Consumer<? super Live.Match> processor) {

+      return rawForOneArbitraryMatch(new Object[]{pThis, pL}, processor);

+    }

+    

+    /**

+     * Returns a new (partial) match.

+     * This can be used e.g. to call the matcher with a partial match.

+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

+     * @param pThis the fixed value of pattern parameter this, or null if not bound.

+     * @param pL the fixed value of pattern parameter l, or null if not bound.

+     * @return the (partial) match object.

+     * 

+     */

+    public Live.Match newMatch(final FileSystem pThis, final FSObject pL) {

+      return Live.Match.newMatch(pThis, pL);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for this.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    protected Stream<FileSystem> rawStreamAllValuesOfthis(final Object[] parameters) {

+      return rawStreamAllValues(POSITION_THIS, parameters).map(FileSystem.class::cast);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for this.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<FileSystem> getAllValuesOfthis() {

+      return rawStreamAllValuesOfthis(emptyArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for this.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<FileSystem> streamAllValuesOfthis() {

+      return rawStreamAllValuesOfthis(emptyArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for this.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<FileSystem> streamAllValuesOfthis(final Live.Match partialMatch) {

+      return rawStreamAllValuesOfthis(partialMatch.toArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for this.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<FileSystem> streamAllValuesOfthis(final FSObject pL) {

+      return rawStreamAllValuesOfthis(new Object[]{null, pL});

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for this.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<FileSystem> getAllValuesOfthis(final Live.Match partialMatch) {

+      return rawStreamAllValuesOfthis(partialMatch.toArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for this.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<FileSystem> getAllValuesOfthis(final FSObject pL) {

+      return rawStreamAllValuesOfthis(new Object[]{null, pL}).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for l.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    protected Stream<FSObject> rawStreamAllValuesOfl(final Object[] parameters) {

+      return rawStreamAllValues(POSITION_L, parameters).map(FSObject.class::cast);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for l.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<FSObject> getAllValuesOfl() {

+      return rawStreamAllValuesOfl(emptyArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for l.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<FSObject> streamAllValuesOfl() {

+      return rawStreamAllValuesOfl(emptyArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for l.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<FSObject> streamAllValuesOfl(final Live.Match partialMatch) {

+      return rawStreamAllValuesOfl(partialMatch.toArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for l.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<FSObject> streamAllValuesOfl(final FileSystem pThis) {

+      return rawStreamAllValuesOfl(new Object[]{pThis, null});

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for l.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<FSObject> getAllValuesOfl(final Live.Match partialMatch) {

+      return rawStreamAllValuesOfl(partialMatch.toArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for l.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<FSObject> getAllValuesOfl(final FileSystem pThis) {

+      return rawStreamAllValuesOfl(new Object[]{pThis, null}).collect(Collectors.toSet());

+    }

+    

+    @Override

+    protected Live.Match tupleToMatch(final Tuple t) {

+      try {

+          return Live.Match.newMatch((FileSystem) t.get(POSITION_THIS), (FSObject) t.get(POSITION_L));

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in tuple not properly typed!",e);

+          return null;

+      }

+    }

+    

+    @Override

+    protected Live.Match arrayToMatch(final Object[] match) {

+      try {

+          return Live.Match.newMatch((FileSystem) match[POSITION_THIS], (FSObject) match[POSITION_L]);

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in array not properly typed!",e);

+          return null;

+      }

+    }

+    

+    @Override

+    protected Live.Match arrayToMatchMutable(final Object[] match) {

+      try {

+          return Live.Match.newMutableMatch((FileSystem) match[POSITION_THIS], (FSObject) match[POSITION_L]);

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in array not properly typed!",e);

+          return null;

+      }

+    }

+    

+    /**

+     * @return the singleton instance of the query specification of this pattern

+     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

+     * 

+     */

+    public static IQuerySpecification<Live.Matcher> querySpecification() {

+      return Live.instance();

+    }

+  }

+  

+  private Live() {

+    super(GeneratedPQuery.INSTANCE);

+  }

+  

+  /**

+   * @return the singleton instance of the query specification

+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

+   * 

+   */

+  public static Live instance() {

+    try{

+        return LazyHolder.INSTANCE;

+    } catch (ExceptionInInitializerError err) {

+        throw processInitializerError(err);

+    }

+  }

+  

+  @Override

+  protected Live.Matcher instantiate(final ViatraQueryEngine engine) {

+    return Live.Matcher.on(engine);

+  }

+  

+  @Override

+  public Live.Matcher instantiate() {

+    return Live.Matcher.create();

+  }

+  

+  @Override

+  public Live.Match newEmptyMatch() {

+    return Live.Match.newEmptyMatch();

+  }

+  

+  @Override

+  public Live.Match newMatch(final Object... parameters) {

+    return Live.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FileSystem) parameters[0], (hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject) parameters[1]);

+  }

+  

+  /**

+   * Inner class allowing the singleton instance of {@link JvmGenericType: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Live (visibility: PUBLIC, simpleName: Live, identifier: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Live, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: hu.bme.mit.inf.dslreasoner.domains.alloyexamples) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

+   *     <b>not</b> at the class load time of the outer class, 

+   *     but rather at the first call to {@link JvmGenericType: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Live (visibility: PUBLIC, simpleName: Live, identifier: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Live, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: hu.bme.mit.inf.dslreasoner.domains.alloyexamples) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

+   * 

+   * <p> This workaround is required e.g. to support recursion.

+   * 

+   */

+  private static class LazyHolder {

+    private final static Live INSTANCE = new Live();

+    

+    /**

+     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

+     * This initialization order is required to support indirect recursion.

+     * 

+     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.

+     * 

+     */

+    private final static Object STATIC_INITIALIZER = ensureInitialized();

+    

+    public static Object ensureInitialized() {

+      INSTANCE.ensureInitializedInternal();

+      return null;

+    }

+  }

+  

+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

+    private final static Live.GeneratedPQuery INSTANCE = new GeneratedPQuery();

+    

+    private final PParameter parameter_this = new PParameter("this", "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FileSystem", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("FS", "FileSystem")), PParameterDirection.INOUT);

+    

+    private final PParameter parameter_l = new PParameter("l", "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("FS", "FSObject")), PParameterDirection.INOUT);

+    

+    private final List<PParameter> parameters = Arrays.asList(parameter_this, parameter_l);

+    

+    private GeneratedPQuery() {

+      super(PVisibility.PUBLIC);

+    }

+    

+    @Override

+    public String getFullyQualifiedName() {

+      return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.live";

+    }

+    

+    @Override

+    public List<String> getParameterNames() {

+      return Arrays.asList("this","l");

+    }

+    

+    @Override

+    public List<PParameter> getParameters() {

+      return parameters;

+    }

+    

+    @Override

+    public Set<PBody> doGetContainedBodies() {

+      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));

+      Set<PBody> bodies = new LinkedHashSet<>();

+      {

+          PBody body = new PBody(this);

+          PVariable var_this = body.getOrCreateVariableByName("this");

+          PVariable var_l = body.getOrCreateVariableByName("l");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_this), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FileSystem")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var_l), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FSObject")));

+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

+             new ExportedParameter(body, var_this, parameter_this),

+             new ExportedParameter(body, var_l, parameter_l)

+          ));

+          //    FileSystem.root(this,l)

+          new TypeConstraint(body, Tuples.flatTupleOf(var_this), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FileSystem")));

+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_this, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("FS", "FileSystem", "root")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "Dir")));

+          new Equality(body, var__virtual_0_, var_l);

+          bodies.add(body);

+      }

+      {

+          PBody body = new PBody(this);

+          PVariable var_this = body.getOrCreateVariableByName("this");

+          PVariable var_l = body.getOrCreateVariableByName("l");

+          PVariable var_root = body.getOrCreateVariableByName("root");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_this), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FileSystem")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var_l), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FSObject")));

+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

+             new ExportedParameter(body, var_this, parameter_this),

+             new ExportedParameter(body, var_l, parameter_l)

+          ));

+          //    FileSystem.root(this,root)

+          new TypeConstraint(body, Tuples.flatTupleOf(var_this), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FileSystem")));

+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_this, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("FS", "FileSystem", "root")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "Dir")));

+          new Equality(body, var__virtual_0_, var_root);

+          //    find patternContent+(root,l)

+          new BinaryTransitiveClosure(body, Tuples.flatTupleOf(var_root, var_l), PatternContent.instance().getInternalQueryRepresentation());

+          bodies.add(body);

+      }

+      {

+          PAnnotation annotation = new PAnnotation("QueryBasedFeature");

+          addAnnotation(annotation);

+      }

+      return bodies;

+    }

+  }

+}

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSOr.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/LoopInInheritence.java
index 0d8e0648..55afe7d0 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSOr.java
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/LoopInInheritence.java
@@ -1,8 +1,9 @@
 /**

- * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.queries/src/ca/mcgill/ecse/dslreasoner/vampire/queries/vampireQueries.vql

+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/patterns/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Ecore.vql

  */

-package ca.mcgill.ecse.dslreasoner.vampire.queries;

+package hu.bme.mit.inf.dslreasoner.domains.alloyexamples;

 

+import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.DirectSupertype;

 import java.util.Arrays;

 import java.util.Collection;

 import java.util.LinkedHashSet;

@@ -26,7 +27,10 @@ import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
 import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

 import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

 import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;

+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;

 import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure;

 import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

@@ -40,9 +44,9 @@ import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
  * 

  * <p>Original source:

  *         <code><pre>

- *         //VLSFormula

- *         pattern VLSOr(term: VLSOr){

- *              VLSOr(term);

+ *         {@literal @}Constraint(key={a}, severity="error", message="error")

+ *         pattern loopInInheritence(a: EClass) {

+ *              find directSupertype+(a,a);

  *         }

  * </pre></code>

  * 

@@ -51,9 +55,9 @@ import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
  * 

  */

 @SuppressWarnings("all")

-public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matcher> {

+public final class LoopInInheritence extends BaseGeneratedEMFQuerySpecification<LoopInInheritence.Matcher> {

   /**

-   * Pattern-specific match representation of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSOr pattern,

+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.loopInInheritence pattern,

    * to be used in conjunction with {@link Matcher}.

    * 

    * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

@@ -65,69 +69,69 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
    * 

    */

   public static abstract class Match extends BasePatternMatch {

-    private ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr fTerm;

+    private EClass fA;

     

-    private static List<String> parameterNames = makeImmutableList("term");

+    private static List<String> parameterNames = makeImmutableList("a");

     

-    private Match(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm) {

-      this.fTerm = pTerm;

+    private Match(final EClass pA) {

+      this.fA = pA;

     }

     

     @Override

     public Object get(final String parameterName) {

-      if ("term".equals(parameterName)) return this.fTerm;

+      if ("a".equals(parameterName)) return this.fA;

       return null;

     }

     

-    public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr getTerm() {

-      return this.fTerm;

+    public EClass getA() {

+      return this.fA;

     }

     

     @Override

     public boolean set(final String parameterName, final Object newValue) {

       if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      if ("term".equals(parameterName) ) {

-          this.fTerm = (ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr) newValue;

+      if ("a".equals(parameterName) ) {

+          this.fA = (EClass) newValue;

           return true;

       }

       return false;

     }

     

-    public void setTerm(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm) {

+    public void setA(final EClass pA) {

       if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      this.fTerm = pTerm;

+      this.fA = pA;

     }

     

     @Override

     public String patternName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSOr";

+      return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.loopInInheritence";

     }

     

     @Override

     public List<String> parameterNames() {

-      return VLSOr.Match.parameterNames;

+      return LoopInInheritence.Match.parameterNames;

     }

     

     @Override

     public Object[] toArray() {

-      return new Object[]{fTerm};

+      return new Object[]{fA};

     }

     

     @Override

-    public VLSOr.Match toImmutable() {

-      return isMutable() ? newMatch(fTerm) : this;

+    public LoopInInheritence.Match toImmutable() {

+      return isMutable() ? newMatch(fA) : this;

     }

     

     @Override

     public String prettyPrint() {

       StringBuilder result = new StringBuilder();

-      result.append("\"term\"=" + prettyPrintValue(fTerm));

+      result.append("\"a\"=" + prettyPrintValue(fA));

       return result.toString();

     }

     

     @Override

     public int hashCode() {

-      return Objects.hash(fTerm);

+      return Objects.hash(fA);

     }

     

     @Override

@@ -137,9 +141,9 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
       if (obj == null) {

           return false;

       }

-      if ((obj instanceof VLSOr.Match)) {

-          VLSOr.Match other = (VLSOr.Match) obj;

-          return Objects.equals(fTerm, other.fTerm);

+      if ((obj instanceof LoopInInheritence.Match)) {

+          LoopInInheritence.Match other = (LoopInInheritence.Match) obj;

+          return Objects.equals(fA, other.fA);

       } else {

           // this should be infrequent

           if (!(obj instanceof IPatternMatch)) {

@@ -151,8 +155,8 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
     }

     

     @Override

-    public VLSOr specification() {

-      return VLSOr.instance();

+    public LoopInInheritence specification() {

+      return LoopInInheritence.instance();

     }

     

     /**

@@ -162,7 +166,7 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
      * @return the empty match.

      * 

      */

-    public static VLSOr.Match newEmptyMatch() {

+    public static LoopInInheritence.Match newEmptyMatch() {

       return new Mutable(null);

     }

     

@@ -170,29 +174,29 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
      * Returns a mutable (partial) match.

      * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

      * 

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @return the new, mutable (partial) match object.

      * 

      */

-    public static VLSOr.Match newMutableMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm) {

-      return new Mutable(pTerm);

+    public static LoopInInheritence.Match newMutableMatch(final EClass pA) {

+      return new Mutable(pA);

     }

     

     /**

      * Returns a new (partial) match.

      * This can be used e.g. to call the matcher with a partial match.

      * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @return the (partial) match object.

      * 

      */

-    public static VLSOr.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm) {

-      return new Immutable(pTerm);

+    public static LoopInInheritence.Match newMatch(final EClass pA) {

+      return new Immutable(pA);

     }

     

-    private static final class Mutable extends VLSOr.Match {

-      Mutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm) {

-        super(pTerm);

+    private static final class Mutable extends LoopInInheritence.Match {

+      Mutable(final EClass pA) {

+        super(pA);

       }

       

       @Override

@@ -201,9 +205,9 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
       }

     }

     

-    private static final class Immutable extends VLSOr.Match {

-      Immutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm) {

-        super(pTerm);

+    private static final class Immutable extends LoopInInheritence.Match {

+      Immutable(final EClass pA) {

+        super(pA);

       }

       

       @Override

@@ -214,7 +218,7 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
   }

   

   /**

-   * Generated pattern matcher API of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSOr pattern,

+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.loopInInheritence pattern,

    * providing pattern-specific query methods.

    * 

    * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

@@ -224,17 +228,17 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
    * 

    * <p>Original source:

    * <code><pre>

-   * //VLSFormula

-   * pattern VLSOr(term: VLSOr){

-   *    VLSOr(term);

+   * {@literal @}Constraint(key={a}, severity="error", message="error")

+   * pattern loopInInheritence(a: EClass) {

+   *    find directSupertype+(a,a);

    * }

    * </pre></code>

    * 

    * @see Match

-   * @see VLSOr

+   * @see LoopInInheritence

    * 

    */

-  public static class Matcher extends BaseMatcher<VLSOr.Match> {

+  public static class Matcher extends BaseMatcher<LoopInInheritence.Match> {

     /**

      * Initializes the pattern matcher within an existing VIATRA Query engine.

      * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

@@ -243,7 +247,7 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
      * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

      * 

      */

-    public static VLSOr.Matcher on(final ViatraQueryEngine engine) {

+    public static LoopInInheritence.Matcher on(final ViatraQueryEngine engine) {

       // check if matcher already exists

       Matcher matcher = engine.getExistingMatcher(querySpecification());

       if (matcher == null) {

@@ -258,13 +262,13 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
      * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

      * 

      */

-    public static VLSOr.Matcher create() {

+    public static LoopInInheritence.Matcher create() {

       return new Matcher();

     }

     

-    private final static int POSITION_TERM = 0;

+    private final static int POSITION_A = 0;

     

-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSOr.Matcher.class);

+    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(LoopInInheritence.Matcher.class);

     

     /**

      * Initializes the pattern matcher within an existing VIATRA Query engine.

@@ -280,12 +284,12 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
     

     /**

      * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @return matches represented as a Match object.

      * 

      */

-    public Collection<VLSOr.Match> getAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm}).collect(Collectors.toSet());

+    public Collection<LoopInInheritence.Match> getAllMatches(final EClass pA) {

+      return rawStreamAllMatches(new Object[]{pA}).collect(Collectors.toSet());

     }

     

     /**

@@ -294,101 +298,101 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
      * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

      * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

      * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @return a stream of matches represented as a Match object.

      * 

      */

-    public Stream<VLSOr.Match> streamAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm});

+    public Stream<LoopInInheritence.Match> streamAllMatches(final EClass pA) {

+      return rawStreamAllMatches(new Object[]{pA});

     }

     

     /**

      * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

      * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @return a match represented as a Match object, or null if no match is found.

      * 

      */

-    public Optional<VLSOr.Match> getOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm) {

-      return rawGetOneArbitraryMatch(new Object[]{pTerm});

+    public Optional<LoopInInheritence.Match> getOneArbitraryMatch(final EClass pA) {

+      return rawGetOneArbitraryMatch(new Object[]{pA});

     }

     

     /**

      * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

      * under any possible substitution of the unspecified parameters (if any).

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @return true if the input is a valid (partial) match of the pattern.

      * 

      */

-    public boolean hasMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm) {

-      return rawHasMatch(new Object[]{pTerm});

+    public boolean hasMatch(final EClass pA) {

+      return rawHasMatch(new Object[]{pA});

     }

     

     /**

      * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @return the number of pattern matches found.

      * 

      */

-    public int countMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm) {

-      return rawCountMatches(new Object[]{pTerm});

+    public int countMatches(final EClass pA) {

+      return rawCountMatches(new Object[]{pA});

     }

     

     /**

      * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

      * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @param processor the action that will process the selected match.

      * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

      * 

      */

-    public boolean forOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm, final Consumer<? super VLSOr.Match> processor) {

-      return rawForOneArbitraryMatch(new Object[]{pTerm}, processor);

+    public boolean forOneArbitraryMatch(final EClass pA, final Consumer<? super LoopInInheritence.Match> processor) {

+      return rawForOneArbitraryMatch(new Object[]{pA}, processor);

     }

     

     /**

      * Returns a new (partial) match.

      * This can be used e.g. to call the matcher with a partial match.

      * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @return the (partial) match object.

      * 

      */

-    public VLSOr.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm) {

-      return VLSOr.Match.newMatch(pTerm);

+    public LoopInInheritence.Match newMatch(final EClass pA) {

+      return LoopInInheritence.Match.newMatch(pA);

     }

     

     /**

-     * Retrieve the set of values that occur in matches for term.

+     * Retrieve the set of values that occur in matches for a.

      * @return the Set of all values or empty set if there are no matches

      * 

      */

-    protected Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr> rawStreamAllValuesOfterm(final Object[] parameters) {

-      return rawStreamAllValues(POSITION_TERM, parameters).map(ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr.class::cast);

+    protected Stream<EClass> rawStreamAllValuesOfa(final Object[] parameters) {

+      return rawStreamAllValues(POSITION_A, parameters).map(EClass.class::cast);

     }

     

     /**

-     * Retrieve the set of values that occur in matches for term.

+     * Retrieve the set of values that occur in matches for a.

      * @return the Set of all values or empty set if there are no matches

      * 

      */

-    public Set<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr> getAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray()).collect(Collectors.toSet());

+    public Set<EClass> getAllValuesOfa() {

+      return rawStreamAllValuesOfa(emptyArray()).collect(Collectors.toSet());

     }

     

     /**

-     * Retrieve the set of values that occur in matches for term.

+     * Retrieve the set of values that occur in matches for a.

      * @return the Set of all values or empty set if there are no matches

      * 

      */

-    public Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr> streamAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray());

+    public Stream<EClass> streamAllValuesOfa() {

+      return rawStreamAllValuesOfa(emptyArray());

     }

     

     @Override

-    protected VLSOr.Match tupleToMatch(final Tuple t) {

+    protected LoopInInheritence.Match tupleToMatch(final Tuple t) {

       try {

-          return VLSOr.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr) t.get(POSITION_TERM));

+          return LoopInInheritence.Match.newMatch((EClass) t.get(POSITION_A));

       } catch(ClassCastException e) {

           LOGGER.error("Element(s) in tuple not properly typed!",e);

           return null;

@@ -396,9 +400,9 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
     }

     

     @Override

-    protected VLSOr.Match arrayToMatch(final Object[] match) {

+    protected LoopInInheritence.Match arrayToMatch(final Object[] match) {

       try {

-          return VLSOr.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr) match[POSITION_TERM]);

+          return LoopInInheritence.Match.newMatch((EClass) match[POSITION_A]);

       } catch(ClassCastException e) {

           LOGGER.error("Element(s) in array not properly typed!",e);

           return null;

@@ -406,9 +410,9 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
     }

     

     @Override

-    protected VLSOr.Match arrayToMatchMutable(final Object[] match) {

+    protected LoopInInheritence.Match arrayToMatchMutable(final Object[] match) {

       try {

-          return VLSOr.Match.newMutableMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr) match[POSITION_TERM]);

+          return LoopInInheritence.Match.newMutableMatch((EClass) match[POSITION_A]);

       } catch(ClassCastException e) {

           LOGGER.error("Element(s) in array not properly typed!",e);

           return null;

@@ -420,12 +424,12 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
      * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

      * 

      */

-    public static IQuerySpecification<VLSOr.Matcher> querySpecification() {

-      return VLSOr.instance();

+    public static IQuerySpecification<LoopInInheritence.Matcher> querySpecification() {

+      return LoopInInheritence.instance();

     }

   }

   

-  private VLSOr() {

+  private LoopInInheritence() {

     super(GeneratedPQuery.INSTANCE);

   }

   

@@ -434,7 +438,7 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
    * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

    * 

    */

-  public static VLSOr instance() {

+  public static LoopInInheritence instance() {

     try{

         return LazyHolder.INSTANCE;

     } catch (ExceptionInInitializerError err) {

@@ -443,35 +447,35 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
   }

   

   @Override

-  protected VLSOr.Matcher instantiate(final ViatraQueryEngine engine) {

-    return VLSOr.Matcher.on(engine);

+  protected LoopInInheritence.Matcher instantiate(final ViatraQueryEngine engine) {

+    return LoopInInheritence.Matcher.on(engine);

   }

   

   @Override

-  public VLSOr.Matcher instantiate() {

-    return VLSOr.Matcher.create();

+  public LoopInInheritence.Matcher instantiate() {

+    return LoopInInheritence.Matcher.create();

   }

   

   @Override

-  public VLSOr.Match newEmptyMatch() {

-    return VLSOr.Match.newEmptyMatch();

+  public LoopInInheritence.Match newEmptyMatch() {

+    return LoopInInheritence.Match.newEmptyMatch();

   }

   

   @Override

-  public VLSOr.Match newMatch(final Object... parameters) {

-    return VLSOr.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr) parameters[0]);

+  public LoopInInheritence.Match newMatch(final Object... parameters) {

+    return LoopInInheritence.Match.newMatch((org.eclipse.emf.ecore.EClass) parameters[0]);

   }

   

   /**

-   * Inner class allowing the singleton instance of {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSOr (visibility: PUBLIC, simpleName: VLSOr, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSOr, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

+   * Inner class allowing the singleton instance of {@link JvmGenericType: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.LoopInInheritence (visibility: PUBLIC, simpleName: LoopInInheritence, identifier: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.LoopInInheritence, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: hu.bme.mit.inf.dslreasoner.domains.alloyexamples) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

    *     <b>not</b> at the class load time of the outer class, 

-   *     but rather at the first call to {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSOr (visibility: PUBLIC, simpleName: VLSOr, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSOr, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

+   *     but rather at the first call to {@link JvmGenericType: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.LoopInInheritence (visibility: PUBLIC, simpleName: LoopInInheritence, identifier: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.LoopInInheritence, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: hu.bme.mit.inf.dslreasoner.domains.alloyexamples) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

    * 

    * <p> This workaround is required e.g. to support recursion.

    * 

    */

   private static class LazyHolder {

-    private final static VLSOr INSTANCE = new VLSOr();

+    private final static LoopInInheritence INSTANCE = new LoopInInheritence();

     

     /**

      * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

@@ -489,11 +493,11 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
   }

   

   private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

-    private final static VLSOr.GeneratedPQuery INSTANCE = new GeneratedPQuery();

+    private final static LoopInInheritence.GeneratedPQuery INSTANCE = new GeneratedPQuery();

     

-    private final PParameter parameter_term = new PParameter("term", "ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSOr")), PParameterDirection.INOUT);

+    private final PParameter parameter_a = new PParameter("a", "org.eclipse.emf.ecore.EClass", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EClass")), PParameterDirection.INOUT);

     

-    private final List<PParameter> parameters = Arrays.asList(parameter_term);

+    private final List<PParameter> parameters = Arrays.asList(parameter_a);

     

     private GeneratedPQuery() {

       super(PVisibility.PUBLIC);

@@ -501,12 +505,12 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
     

     @Override

     public String getFullyQualifiedName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSOr";

+      return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.loopInInheritence";

     }

     

     @Override

     public List<String> getParameterNames() {

-      return Arrays.asList("term");

+      return Arrays.asList("a");

     }

     

     @Override

@@ -520,15 +524,24 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
       Set<PBody> bodies = new LinkedHashSet<>();

       {

           PBody body = new PBody(this);

-          PVariable var_term = body.getOrCreateVariableByName("term");

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSOr")));

+          PVariable var_a = body.getOrCreateVariableByName("a");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));

           body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

-             new ExportedParameter(body, var_term, parameter_term)

+             new ExportedParameter(body, var_a, parameter_a)

           ));

-          //    VLSOr(term)

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSOr")));

+          //    find directSupertype+(a,a)

+          new BinaryTransitiveClosure(body, Tuples.flatTupleOf(var_a, var_a), DirectSupertype.instance().getInternalQueryRepresentation());

           bodies.add(body);

       }

+      {

+          PAnnotation annotation = new PAnnotation("Constraint");

+          annotation.addAttribute("key", Arrays.asList(new Object[] {

+                              new ParameterReference("a")

+                              }));

+          annotation.addAttribute("severity", "error");

+          annotation.addAttribute("message", "error");

+          addAnnotation(annotation);

+      }

       return bodies;

     }

   }

diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/NonSymmetricOpposite.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/NonSymmetricOpposite.java
new file mode 100644
index 00000000..5b24ef84
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/NonSymmetricOpposite.java
@@ -0,0 +1,707 @@
+/**

+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/patterns/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Ecore.vql

+ */

+package hu.bme.mit.inf.dslreasoner.domains.alloyexamples;

+

+import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Opposite;

+import java.util.Arrays;

+import java.util.Collection;

+import java.util.LinkedHashSet;

+import java.util.List;

+import java.util.Objects;

+import java.util.Optional;

+import java.util.Set;

+import java.util.function.Consumer;

+import java.util.stream.Collectors;

+import java.util.stream.Stream;

+import org.apache.log4j.Logger;

+import org.eclipse.emf.ecore.EClass;

+import org.eclipse.emf.ecore.EReference;

+import org.eclipse.viatra.query.runtime.api.IPatternMatch;

+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;

+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;

+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;

+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;

+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;

+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;

+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;

+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;

+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;

+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;

+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;

+

+/**

+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.

+ * 

+ * <p>Original source:

+ *         <code><pre>

+ *         {@literal @}Constraint(key={a}, severity="error", message="error")

+ *         pattern nonSymmetricOpposite(a:EReference, b:EReference) {

+ *              find opposite(a,b);

+ *              neg find opposite(b,a);

+ *         }

+ * </pre></code>

+ * 

+ * @see Matcher

+ * @see Match

+ * 

+ */

+@SuppressWarnings("all")

+public final class NonSymmetricOpposite extends BaseGeneratedEMFQuerySpecification<NonSymmetricOpposite.Matcher> {

+  /**

+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.nonSymmetricOpposite pattern,

+   * to be used in conjunction with {@link Matcher}.

+   * 

+   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

+   * Each instance is a (possibly partial) substitution of pattern parameters,

+   * usable to represent a match of the pattern in the result of a query,

+   * or to specify the bound (fixed) input parameters when issuing a query.

+   * 

+   * @see Matcher

+   * 

+   */

+  public static abstract class Match extends BasePatternMatch {

+    private EReference fA;

+    

+    private EReference fB;

+    

+    private static List<String> parameterNames = makeImmutableList("a", "b");

+    

+    private Match(final EReference pA, final EReference pB) {

+      this.fA = pA;

+      this.fB = pB;

+    }

+    

+    @Override

+    public Object get(final String parameterName) {

+      if ("a".equals(parameterName)) return this.fA;

+      if ("b".equals(parameterName)) return this.fB;

+      return null;

+    }

+    

+    public EReference getA() {

+      return this.fA;

+    }

+    

+    public EReference getB() {

+      return this.fB;

+    }

+    

+    @Override

+    public boolean set(final String parameterName, final Object newValue) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      if ("a".equals(parameterName) ) {

+          this.fA = (EReference) newValue;

+          return true;

+      }

+      if ("b".equals(parameterName) ) {

+          this.fB = (EReference) newValue;

+          return true;

+      }

+      return false;

+    }

+    

+    public void setA(final EReference pA) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      this.fA = pA;

+    }

+    

+    public void setB(final EReference pB) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      this.fB = pB;

+    }

+    

+    @Override

+    public String patternName() {

+      return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.nonSymmetricOpposite";

+    }

+    

+    @Override

+    public List<String> parameterNames() {

+      return NonSymmetricOpposite.Match.parameterNames;

+    }

+    

+    @Override

+    public Object[] toArray() {

+      return new Object[]{fA, fB};

+    }

+    

+    @Override

+    public NonSymmetricOpposite.Match toImmutable() {

+      return isMutable() ? newMatch(fA, fB) : this;

+    }

+    

+    @Override

+    public String prettyPrint() {

+      StringBuilder result = new StringBuilder();

+      result.append("\"a\"=" + prettyPrintValue(fA) + ", ");

+      result.append("\"b\"=" + prettyPrintValue(fB));

+      return result.toString();

+    }

+    

+    @Override

+    public int hashCode() {

+      return Objects.hash(fA, fB);

+    }

+    

+    @Override

+    public boolean equals(final Object obj) {

+      if (this == obj)

+          return true;

+      if (obj == null) {

+          return false;

+      }

+      if ((obj instanceof NonSymmetricOpposite.Match)) {

+          NonSymmetricOpposite.Match other = (NonSymmetricOpposite.Match) obj;

+          return Objects.equals(fA, other.fA) && Objects.equals(fB, other.fB);

+      } else {

+          // this should be infrequent

+          if (!(obj instanceof IPatternMatch)) {

+              return false;

+          }

+          IPatternMatch otherSig  = (IPatternMatch) obj;

+          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());

+      }

+    }

+    

+    @Override

+    public NonSymmetricOpposite specification() {

+      return NonSymmetricOpposite.instance();

+    }

+    

+    /**

+     * Returns an empty, mutable match.

+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

+     * 

+     * @return the empty match.

+     * 

+     */

+    public static NonSymmetricOpposite.Match newEmptyMatch() {

+      return new Mutable(null, null);

+    }

+    

+    /**

+     * Returns a mutable (partial) match.

+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

+     * 

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return the new, mutable (partial) match object.

+     * 

+     */

+    public static NonSymmetricOpposite.Match newMutableMatch(final EReference pA, final EReference pB) {

+      return new Mutable(pA, pB);

+    }

+    

+    /**

+     * Returns a new (partial) match.

+     * This can be used e.g. to call the matcher with a partial match.

+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return the (partial) match object.

+     * 

+     */

+    public static NonSymmetricOpposite.Match newMatch(final EReference pA, final EReference pB) {

+      return new Immutable(pA, pB);

+    }

+    

+    private static final class Mutable extends NonSymmetricOpposite.Match {

+      Mutable(final EReference pA, final EReference pB) {

+        super(pA, pB);

+      }

+      

+      @Override

+      public boolean isMutable() {

+        return true;

+      }

+    }

+    

+    private static final class Immutable extends NonSymmetricOpposite.Match {

+      Immutable(final EReference pA, final EReference pB) {

+        super(pA, pB);

+      }

+      

+      @Override

+      public boolean isMutable() {

+        return false;

+      }

+    }

+  }

+  

+  /**

+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.nonSymmetricOpposite pattern,

+   * providing pattern-specific query methods.

+   * 

+   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

+   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.

+   * 

+   * <p>Matches of the pattern will be represented as {@link Match}.

+   * 

+   * <p>Original source:

+   * <code><pre>

+   * {@literal @}Constraint(key={a}, severity="error", message="error")

+   * pattern nonSymmetricOpposite(a:EReference, b:EReference) {

+   *    find opposite(a,b);

+   *    neg find opposite(b,a);

+   * }

+   * </pre></code>

+   * 

+   * @see Match

+   * @see NonSymmetricOpposite

+   * 

+   */

+  public static class Matcher extends BaseMatcher<NonSymmetricOpposite.Match> {

+    /**

+     * Initializes the pattern matcher within an existing VIATRA Query engine.

+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

+     * 

+     * @param engine the existing VIATRA Query engine in which this matcher will be created.

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * 

+     */

+    public static NonSymmetricOpposite.Matcher on(final ViatraQueryEngine engine) {

+      // check if matcher already exists

+      Matcher matcher = engine.getExistingMatcher(querySpecification());

+      if (matcher == null) {

+          matcher = (Matcher)engine.getMatcher(querySpecification());

+      }

+      return matcher;

+    }

+    

+    /**

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * @return an initialized matcher

+     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

+     * 

+     */

+    public static NonSymmetricOpposite.Matcher create() {

+      return new Matcher();

+    }

+    

+    private final static int POSITION_A = 0;

+    

+    private final static int POSITION_B = 1;

+    

+    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(NonSymmetricOpposite.Matcher.class);

+    

+    /**

+     * Initializes the pattern matcher within an existing VIATRA Query engine.

+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

+     * 

+     * @param engine the existing VIATRA Query engine in which this matcher will be created.

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * 

+     */

+    private Matcher() {

+      super(querySpecification());

+    }

+    

+    /**

+     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return matches represented as a Match object.

+     * 

+     */

+    public Collection<NonSymmetricOpposite.Match> getAllMatches(final EReference pA, final EReference pB) {

+      return rawStreamAllMatches(new Object[]{pA, pB}).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return a stream of matches represented as a Match object.

+     * 

+     */

+    public Stream<NonSymmetricOpposite.Match> streamAllMatches(final EReference pA, final EReference pB) {

+      return rawStreamAllMatches(new Object[]{pA, pB});

+    }

+    

+    /**

+     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

+     * Neither determinism nor randomness of selection is guaranteed.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return a match represented as a Match object, or null if no match is found.

+     * 

+     */

+    public Optional<NonSymmetricOpposite.Match> getOneArbitraryMatch(final EReference pA, final EReference pB) {

+      return rawGetOneArbitraryMatch(new Object[]{pA, pB});

+    }

+    

+    /**

+     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

+     * under any possible substitution of the unspecified parameters (if any).

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return true if the input is a valid (partial) match of the pattern.

+     * 

+     */

+    public boolean hasMatch(final EReference pA, final EReference pB) {

+      return rawHasMatch(new Object[]{pA, pB});

+    }

+    

+    /**

+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return the number of pattern matches found.

+     * 

+     */

+    public int countMatches(final EReference pA, final EReference pB) {

+      return rawCountMatches(new Object[]{pA, pB});

+    }

+    

+    /**

+     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

+     * Neither determinism nor randomness of selection is guaranteed.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @param processor the action that will process the selected match.

+     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

+     * 

+     */

+    public boolean forOneArbitraryMatch(final EReference pA, final EReference pB, final Consumer<? super NonSymmetricOpposite.Match> processor) {

+      return rawForOneArbitraryMatch(new Object[]{pA, pB}, processor);

+    }

+    

+    /**

+     * Returns a new (partial) match.

+     * This can be used e.g. to call the matcher with a partial match.

+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return the (partial) match object.

+     * 

+     */

+    public NonSymmetricOpposite.Match newMatch(final EReference pA, final EReference pB) {

+      return NonSymmetricOpposite.Match.newMatch(pA, pB);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    protected Stream<EReference> rawStreamAllValuesOfa(final Object[] parameters) {

+      return rawStreamAllValues(POSITION_A, parameters).map(EReference.class::cast);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EReference> getAllValuesOfa() {

+      return rawStreamAllValuesOfa(emptyArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EReference> streamAllValuesOfa() {

+      return rawStreamAllValuesOfa(emptyArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EReference> streamAllValuesOfa(final NonSymmetricOpposite.Match partialMatch) {

+      return rawStreamAllValuesOfa(partialMatch.toArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EReference> streamAllValuesOfa(final EReference pB) {

+      return rawStreamAllValuesOfa(new Object[]{null, pB});

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EReference> getAllValuesOfa(final NonSymmetricOpposite.Match partialMatch) {

+      return rawStreamAllValuesOfa(partialMatch.toArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EReference> getAllValuesOfa(final EReference pB) {

+      return rawStreamAllValuesOfa(new Object[]{null, pB}).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    protected Stream<EReference> rawStreamAllValuesOfb(final Object[] parameters) {

+      return rawStreamAllValues(POSITION_B, parameters).map(EReference.class::cast);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EReference> getAllValuesOfb() {

+      return rawStreamAllValuesOfb(emptyArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EReference> streamAllValuesOfb() {

+      return rawStreamAllValuesOfb(emptyArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EReference> streamAllValuesOfb(final NonSymmetricOpposite.Match partialMatch) {

+      return rawStreamAllValuesOfb(partialMatch.toArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EReference> streamAllValuesOfb(final EReference pA) {

+      return rawStreamAllValuesOfb(new Object[]{pA, null});

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EReference> getAllValuesOfb(final NonSymmetricOpposite.Match partialMatch) {

+      return rawStreamAllValuesOfb(partialMatch.toArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EReference> getAllValuesOfb(final EReference pA) {

+      return rawStreamAllValuesOfb(new Object[]{pA, null}).collect(Collectors.toSet());

+    }

+    

+    @Override

+    protected NonSymmetricOpposite.Match tupleToMatch(final Tuple t) {

+      try {

+          return NonSymmetricOpposite.Match.newMatch((EReference) t.get(POSITION_A), (EReference) t.get(POSITION_B));

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in tuple not properly typed!",e);

+          return null;

+      }

+    }

+    

+    @Override

+    protected NonSymmetricOpposite.Match arrayToMatch(final Object[] match) {

+      try {

+          return NonSymmetricOpposite.Match.newMatch((EReference) match[POSITION_A], (EReference) match[POSITION_B]);

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in array not properly typed!",e);

+          return null;

+      }

+    }

+    

+    @Override

+    protected NonSymmetricOpposite.Match arrayToMatchMutable(final Object[] match) {

+      try {

+          return NonSymmetricOpposite.Match.newMutableMatch((EReference) match[POSITION_A], (EReference) match[POSITION_B]);

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in array not properly typed!",e);

+          return null;

+      }

+    }

+    

+    /**

+     * @return the singleton instance of the query specification of this pattern

+     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

+     * 

+     */

+    public static IQuerySpecification<NonSymmetricOpposite.Matcher> querySpecification() {

+      return NonSymmetricOpposite.instance();

+    }

+  }

+  

+  private NonSymmetricOpposite() {

+    super(GeneratedPQuery.INSTANCE);

+  }

+  

+  /**

+   * @return the singleton instance of the query specification

+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

+   * 

+   */

+  public static NonSymmetricOpposite instance() {

+    try{

+        return LazyHolder.INSTANCE;

+    } catch (ExceptionInInitializerError err) {

+        throw processInitializerError(err);

+    }

+  }

+  

+  @Override

+  protected NonSymmetricOpposite.Matcher instantiate(final ViatraQueryEngine engine) {

+    return NonSymmetricOpposite.Matcher.on(engine);

+  }

+  

+  @Override

+  public NonSymmetricOpposite.Matcher instantiate() {

+    return NonSymmetricOpposite.Matcher.create();

+  }

+  

+  @Override

+  public NonSymmetricOpposite.Match newEmptyMatch() {

+    return NonSymmetricOpposite.Match.newEmptyMatch();

+  }

+  

+  @Override

+  public NonSymmetricOpposite.Match newMatch(final Object... parameters) {

+    return NonSymmetricOpposite.Match.newMatch((org.eclipse.emf.ecore.EReference) parameters[0], (org.eclipse.emf.ecore.EReference) parameters[1]);

+  }

+  

+  /**

+   * Inner class allowing the singleton instance of {@link JvmGenericType: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.NonSymmetricOpposite (visibility: PUBLIC, simpleName: NonSymmetricOpposite, identifier: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.NonSymmetricOpposite, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: hu.bme.mit.inf.dslreasoner.domains.alloyexamples) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

+   *     <b>not</b> at the class load time of the outer class, 

+   *     but rather at the first call to {@link JvmGenericType: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.NonSymmetricOpposite (visibility: PUBLIC, simpleName: NonSymmetricOpposite, identifier: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.NonSymmetricOpposite, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: hu.bme.mit.inf.dslreasoner.domains.alloyexamples) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

+   * 

+   * <p> This workaround is required e.g. to support recursion.

+   * 

+   */

+  private static class LazyHolder {

+    private final static NonSymmetricOpposite INSTANCE = new NonSymmetricOpposite();

+    

+    /**

+     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

+     * This initialization order is required to support indirect recursion.

+     * 

+     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.

+     * 

+     */

+    private final static Object STATIC_INITIALIZER = ensureInitialized();

+    

+    public static Object ensureInitialized() {

+      INSTANCE.ensureInitializedInternal();

+      return null;

+    }

+  }

+  

+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

+    private final static NonSymmetricOpposite.GeneratedPQuery INSTANCE = new GeneratedPQuery();

+    

+    private final PParameter parameter_a = new PParameter("a", "org.eclipse.emf.ecore.EReference", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EReference")), PParameterDirection.INOUT);

+    

+    private final PParameter parameter_b = new PParameter("b", "org.eclipse.emf.ecore.EReference", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EReference")), PParameterDirection.INOUT);

+    

+    private final List<PParameter> parameters = Arrays.asList(parameter_a, parameter_b);

+    

+    private GeneratedPQuery() {

+      super(PVisibility.PUBLIC);

+    }

+    

+    @Override

+    public String getFullyQualifiedName() {

+      return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.nonSymmetricOpposite";

+    }

+    

+    @Override

+    public List<String> getParameterNames() {

+      return Arrays.asList("a","b");

+    }

+    

+    @Override

+    public List<PParameter> getParameters() {

+      return parameters;

+    }

+    

+    @Override

+    public Set<PBody> doGetContainedBodies() {

+      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));

+      Set<PBody> bodies = new LinkedHashSet<>();

+      {

+          PBody body = new PBody(this);

+          PVariable var_a = body.getOrCreateVariableByName("a");

+          PVariable var_b = body.getOrCreateVariableByName("b");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var_b), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));

+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

+             new ExportedParameter(body, var_a, parameter_a),

+             new ExportedParameter(body, var_b, parameter_b)

+          ));

+          //    find opposite(a,b)

+          new PositivePatternCall(body, Tuples.flatTupleOf(var_a, var_b), Opposite.instance().getInternalQueryRepresentation());

+          //    neg find opposite(b,a)

+          new NegativePatternCall(body, Tuples.flatTupleOf(var_b, var_a), Opposite.instance().getInternalQueryRepresentation());

+          bodies.add(body);

+      }

+      {

+          PAnnotation annotation = new PAnnotation("Constraint");

+          annotation.addAttribute("key", Arrays.asList(new Object[] {

+                              new ParameterReference("a")

+                              }));

+          annotation.addAttribute("severity", "error");

+          annotation.addAttribute("message", "error");

+          addAnnotation(annotation);

+      }

+      return bodies;

+    }

+  }

+}

diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Opposite.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Opposite.java
new file mode 100644
index 00000000..a8c3507d
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Opposite.java
@@ -0,0 +1,693 @@
+/**

+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/patterns/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Ecore.vql

+ */

+package hu.bme.mit.inf.dslreasoner.domains.alloyexamples;

+

+import java.util.Arrays;

+import java.util.Collection;

+import java.util.LinkedHashSet;

+import java.util.List;

+import java.util.Objects;

+import java.util.Optional;

+import java.util.Set;

+import java.util.function.Consumer;

+import java.util.stream.Collectors;

+import java.util.stream.Stream;

+import org.apache.log4j.Logger;

+import org.eclipse.emf.ecore.EClass;

+import org.eclipse.emf.ecore.EReference;

+import org.eclipse.viatra.query.runtime.api.IPatternMatch;

+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;

+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;

+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;

+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;

+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;

+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;

+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;

+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;

+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;

+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;

+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;

+

+/**

+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.

+ * 

+ * <p>Original source:

+ *         <code><pre>

+ *         pattern opposite(a:EReference, b: EReference) {

+ *              EReference.eOpposite(a,b);

+ *         }

+ * </pre></code>

+ * 

+ * @see Matcher

+ * @see Match

+ * 

+ */

+@SuppressWarnings("all")

+public final class Opposite extends BaseGeneratedEMFQuerySpecification<Opposite.Matcher> {

+  /**

+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.opposite pattern,

+   * to be used in conjunction with {@link Matcher}.

+   * 

+   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

+   * Each instance is a (possibly partial) substitution of pattern parameters,

+   * usable to represent a match of the pattern in the result of a query,

+   * or to specify the bound (fixed) input parameters when issuing a query.

+   * 

+   * @see Matcher

+   * 

+   */

+  public static abstract class Match extends BasePatternMatch {

+    private EReference fA;

+    

+    private EReference fB;

+    

+    private static List<String> parameterNames = makeImmutableList("a", "b");

+    

+    private Match(final EReference pA, final EReference pB) {

+      this.fA = pA;

+      this.fB = pB;

+    }

+    

+    @Override

+    public Object get(final String parameterName) {

+      if ("a".equals(parameterName)) return this.fA;

+      if ("b".equals(parameterName)) return this.fB;

+      return null;

+    }

+    

+    public EReference getA() {

+      return this.fA;

+    }

+    

+    public EReference getB() {

+      return this.fB;

+    }

+    

+    @Override

+    public boolean set(final String parameterName, final Object newValue) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      if ("a".equals(parameterName) ) {

+          this.fA = (EReference) newValue;

+          return true;

+      }

+      if ("b".equals(parameterName) ) {

+          this.fB = (EReference) newValue;

+          return true;

+      }

+      return false;

+    }

+    

+    public void setA(final EReference pA) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      this.fA = pA;

+    }

+    

+    public void setB(final EReference pB) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      this.fB = pB;

+    }

+    

+    @Override

+    public String patternName() {

+      return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.opposite";

+    }

+    

+    @Override

+    public List<String> parameterNames() {

+      return Opposite.Match.parameterNames;

+    }

+    

+    @Override

+    public Object[] toArray() {

+      return new Object[]{fA, fB};

+    }

+    

+    @Override

+    public Opposite.Match toImmutable() {

+      return isMutable() ? newMatch(fA, fB) : this;

+    }

+    

+    @Override

+    public String prettyPrint() {

+      StringBuilder result = new StringBuilder();

+      result.append("\"a\"=" + prettyPrintValue(fA) + ", ");

+      result.append("\"b\"=" + prettyPrintValue(fB));

+      return result.toString();

+    }

+    

+    @Override

+    public int hashCode() {

+      return Objects.hash(fA, fB);

+    }

+    

+    @Override

+    public boolean equals(final Object obj) {

+      if (this == obj)

+          return true;

+      if (obj == null) {

+          return false;

+      }

+      if ((obj instanceof Opposite.Match)) {

+          Opposite.Match other = (Opposite.Match) obj;

+          return Objects.equals(fA, other.fA) && Objects.equals(fB, other.fB);

+      } else {

+          // this should be infrequent

+          if (!(obj instanceof IPatternMatch)) {

+              return false;

+          }

+          IPatternMatch otherSig  = (IPatternMatch) obj;

+          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());

+      }

+    }

+    

+    @Override

+    public Opposite specification() {

+      return Opposite.instance();

+    }

+    

+    /**

+     * Returns an empty, mutable match.

+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

+     * 

+     * @return the empty match.

+     * 

+     */

+    public static Opposite.Match newEmptyMatch() {

+      return new Mutable(null, null);

+    }

+    

+    /**

+     * Returns a mutable (partial) match.

+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

+     * 

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return the new, mutable (partial) match object.

+     * 

+     */

+    public static Opposite.Match newMutableMatch(final EReference pA, final EReference pB) {

+      return new Mutable(pA, pB);

+    }

+    

+    /**

+     * Returns a new (partial) match.

+     * This can be used e.g. to call the matcher with a partial match.

+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return the (partial) match object.

+     * 

+     */

+    public static Opposite.Match newMatch(final EReference pA, final EReference pB) {

+      return new Immutable(pA, pB);

+    }

+    

+    private static final class Mutable extends Opposite.Match {

+      Mutable(final EReference pA, final EReference pB) {

+        super(pA, pB);

+      }

+      

+      @Override

+      public boolean isMutable() {

+        return true;

+      }

+    }

+    

+    private static final class Immutable extends Opposite.Match {

+      Immutable(final EReference pA, final EReference pB) {

+        super(pA, pB);

+      }

+      

+      @Override

+      public boolean isMutable() {

+        return false;

+      }

+    }

+  }

+  

+  /**

+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.opposite pattern,

+   * providing pattern-specific query methods.

+   * 

+   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

+   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.

+   * 

+   * <p>Matches of the pattern will be represented as {@link Match}.

+   * 

+   * <p>Original source:

+   * <code><pre>

+   * pattern opposite(a:EReference, b: EReference) {

+   *    EReference.eOpposite(a,b);

+   * }

+   * </pre></code>

+   * 

+   * @see Match

+   * @see Opposite

+   * 

+   */

+  public static class Matcher extends BaseMatcher<Opposite.Match> {

+    /**

+     * Initializes the pattern matcher within an existing VIATRA Query engine.

+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

+     * 

+     * @param engine the existing VIATRA Query engine in which this matcher will be created.

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * 

+     */

+    public static Opposite.Matcher on(final ViatraQueryEngine engine) {

+      // check if matcher already exists

+      Matcher matcher = engine.getExistingMatcher(querySpecification());

+      if (matcher == null) {

+          matcher = (Matcher)engine.getMatcher(querySpecification());

+      }

+      return matcher;

+    }

+    

+    /**

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * @return an initialized matcher

+     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

+     * 

+     */

+    public static Opposite.Matcher create() {

+      return new Matcher();

+    }

+    

+    private final static int POSITION_A = 0;

+    

+    private final static int POSITION_B = 1;

+    

+    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(Opposite.Matcher.class);

+    

+    /**

+     * Initializes the pattern matcher within an existing VIATRA Query engine.

+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

+     * 

+     * @param engine the existing VIATRA Query engine in which this matcher will be created.

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * 

+     */

+    private Matcher() {

+      super(querySpecification());

+    }

+    

+    /**

+     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return matches represented as a Match object.

+     * 

+     */

+    public Collection<Opposite.Match> getAllMatches(final EReference pA, final EReference pB) {

+      return rawStreamAllMatches(new Object[]{pA, pB}).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return a stream of matches represented as a Match object.

+     * 

+     */

+    public Stream<Opposite.Match> streamAllMatches(final EReference pA, final EReference pB) {

+      return rawStreamAllMatches(new Object[]{pA, pB});

+    }

+    

+    /**

+     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

+     * Neither determinism nor randomness of selection is guaranteed.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return a match represented as a Match object, or null if no match is found.

+     * 

+     */

+    public Optional<Opposite.Match> getOneArbitraryMatch(final EReference pA, final EReference pB) {

+      return rawGetOneArbitraryMatch(new Object[]{pA, pB});

+    }

+    

+    /**

+     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

+     * under any possible substitution of the unspecified parameters (if any).

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return true if the input is a valid (partial) match of the pattern.

+     * 

+     */

+    public boolean hasMatch(final EReference pA, final EReference pB) {

+      return rawHasMatch(new Object[]{pA, pB});

+    }

+    

+    /**

+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return the number of pattern matches found.

+     * 

+     */

+    public int countMatches(final EReference pA, final EReference pB) {

+      return rawCountMatches(new Object[]{pA, pB});

+    }

+    

+    /**

+     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

+     * Neither determinism nor randomness of selection is guaranteed.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @param processor the action that will process the selected match.

+     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

+     * 

+     */

+    public boolean forOneArbitraryMatch(final EReference pA, final EReference pB, final Consumer<? super Opposite.Match> processor) {

+      return rawForOneArbitraryMatch(new Object[]{pA, pB}, processor);

+    }

+    

+    /**

+     * Returns a new (partial) match.

+     * This can be used e.g. to call the matcher with a partial match.

+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

+     * @param pB the fixed value of pattern parameter b, or null if not bound.

+     * @return the (partial) match object.

+     * 

+     */

+    public Opposite.Match newMatch(final EReference pA, final EReference pB) {

+      return Opposite.Match.newMatch(pA, pB);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    protected Stream<EReference> rawStreamAllValuesOfa(final Object[] parameters) {

+      return rawStreamAllValues(POSITION_A, parameters).map(EReference.class::cast);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EReference> getAllValuesOfa() {

+      return rawStreamAllValuesOfa(emptyArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EReference> streamAllValuesOfa() {

+      return rawStreamAllValuesOfa(emptyArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EReference> streamAllValuesOfa(final Opposite.Match partialMatch) {

+      return rawStreamAllValuesOfa(partialMatch.toArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EReference> streamAllValuesOfa(final EReference pB) {

+      return rawStreamAllValuesOfa(new Object[]{null, pB});

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EReference> getAllValuesOfa(final Opposite.Match partialMatch) {

+      return rawStreamAllValuesOfa(partialMatch.toArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for a.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EReference> getAllValuesOfa(final EReference pB) {

+      return rawStreamAllValuesOfa(new Object[]{null, pB}).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    protected Stream<EReference> rawStreamAllValuesOfb(final Object[] parameters) {

+      return rawStreamAllValues(POSITION_B, parameters).map(EReference.class::cast);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EReference> getAllValuesOfb() {

+      return rawStreamAllValuesOfb(emptyArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EReference> streamAllValuesOfb() {

+      return rawStreamAllValuesOfb(emptyArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EReference> streamAllValuesOfb(final Opposite.Match partialMatch) {

+      return rawStreamAllValuesOfb(partialMatch.toArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<EReference> streamAllValuesOfb(final EReference pA) {

+      return rawStreamAllValuesOfb(new Object[]{pA, null});

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EReference> getAllValuesOfb(final Opposite.Match partialMatch) {

+      return rawStreamAllValuesOfb(partialMatch.toArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for b.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<EReference> getAllValuesOfb(final EReference pA) {

+      return rawStreamAllValuesOfb(new Object[]{pA, null}).collect(Collectors.toSet());

+    }

+    

+    @Override

+    protected Opposite.Match tupleToMatch(final Tuple t) {

+      try {

+          return Opposite.Match.newMatch((EReference) t.get(POSITION_A), (EReference) t.get(POSITION_B));

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in tuple not properly typed!",e);

+          return null;

+      }

+    }

+    

+    @Override

+    protected Opposite.Match arrayToMatch(final Object[] match) {

+      try {

+          return Opposite.Match.newMatch((EReference) match[POSITION_A], (EReference) match[POSITION_B]);

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in array not properly typed!",e);

+          return null;

+      }

+    }

+    

+    @Override

+    protected Opposite.Match arrayToMatchMutable(final Object[] match) {

+      try {

+          return Opposite.Match.newMutableMatch((EReference) match[POSITION_A], (EReference) match[POSITION_B]);

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in array not properly typed!",e);

+          return null;

+      }

+    }

+    

+    /**

+     * @return the singleton instance of the query specification of this pattern

+     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

+     * 

+     */

+    public static IQuerySpecification<Opposite.Matcher> querySpecification() {

+      return Opposite.instance();

+    }

+  }

+  

+  private Opposite() {

+    super(GeneratedPQuery.INSTANCE);

+  }

+  

+  /**

+   * @return the singleton instance of the query specification

+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

+   * 

+   */

+  public static Opposite instance() {

+    try{

+        return LazyHolder.INSTANCE;

+    } catch (ExceptionInInitializerError err) {

+        throw processInitializerError(err);

+    }

+  }

+  

+  @Override

+  protected Opposite.Matcher instantiate(final ViatraQueryEngine engine) {

+    return Opposite.Matcher.on(engine);

+  }

+  

+  @Override

+  public Opposite.Matcher instantiate() {

+    return Opposite.Matcher.create();

+  }

+  

+  @Override

+  public Opposite.Match newEmptyMatch() {

+    return Opposite.Match.newEmptyMatch();

+  }

+  

+  @Override

+  public Opposite.Match newMatch(final Object... parameters) {

+    return Opposite.Match.newMatch((org.eclipse.emf.ecore.EReference) parameters[0], (org.eclipse.emf.ecore.EReference) parameters[1]);

+  }

+  

+  /**

+   * Inner class allowing the singleton instance of {@link JvmGenericType: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Opposite (visibility: PUBLIC, simpleName: Opposite, identifier: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Opposite, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: hu.bme.mit.inf.dslreasoner.domains.alloyexamples) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

+   *     <b>not</b> at the class load time of the outer class, 

+   *     but rather at the first call to {@link JvmGenericType: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Opposite (visibility: PUBLIC, simpleName: Opposite, identifier: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Opposite, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: hu.bme.mit.inf.dslreasoner.domains.alloyexamples) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

+   * 

+   * <p> This workaround is required e.g. to support recursion.

+   * 

+   */

+  private static class LazyHolder {

+    private final static Opposite INSTANCE = new Opposite();

+    

+    /**

+     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

+     * This initialization order is required to support indirect recursion.

+     * 

+     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.

+     * 

+     */

+    private final static Object STATIC_INITIALIZER = ensureInitialized();

+    

+    public static Object ensureInitialized() {

+      INSTANCE.ensureInitializedInternal();

+      return null;

+    }

+  }

+  

+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

+    private final static Opposite.GeneratedPQuery INSTANCE = new GeneratedPQuery();

+    

+    private final PParameter parameter_a = new PParameter("a", "org.eclipse.emf.ecore.EReference", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EReference")), PParameterDirection.INOUT);

+    

+    private final PParameter parameter_b = new PParameter("b", "org.eclipse.emf.ecore.EReference", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EReference")), PParameterDirection.INOUT);

+    

+    private final List<PParameter> parameters = Arrays.asList(parameter_a, parameter_b);

+    

+    private GeneratedPQuery() {

+      super(PVisibility.PUBLIC);

+    }

+    

+    @Override

+    public String getFullyQualifiedName() {

+      return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.opposite";

+    }

+    

+    @Override

+    public List<String> getParameterNames() {

+      return Arrays.asList("a","b");

+    }

+    

+    @Override

+    public List<PParameter> getParameters() {

+      return parameters;

+    }

+    

+    @Override

+    public Set<PBody> doGetContainedBodies() {

+      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));

+      Set<PBody> bodies = new LinkedHashSet<>();

+      {

+          PBody body = new PBody(this);

+          PVariable var_a = body.getOrCreateVariableByName("a");

+          PVariable var_b = body.getOrCreateVariableByName("b");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var_b), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));

+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

+             new ExportedParameter(body, var_a, parameter_a),

+             new ExportedParameter(body, var_b, parameter_b)

+          ));

+          //    EReference.eOpposite(a,b)

+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));

+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_a, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference", "eOpposite")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));

+          new Equality(body, var__virtual_0_, var_b);

+          bodies.add(body);

+      }

+      return bodies;

+    }

+  }

+}

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSUniversalQuantifier.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/OppositeDifferentClass.java
index 0dab9771..0f8b6357 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSUniversalQuantifier.java
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/OppositeDifferentClass.java
@@ -1,7 +1,7 @@
 /**

- * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.queries/src/ca/mcgill/ecse/dslreasoner/vampire/queries/vampireQueries.vql

+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/patterns/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Ecore.vql

  */

-package ca.mcgill.ecse.dslreasoner.vampire.queries;

+package hu.bme.mit.inf.dslreasoner.domains.alloyexamples;

 

 import java.util.Arrays;

 import java.util.Collection;

@@ -15,6 +15,7 @@ import java.util.stream.Collectors;
 import java.util.stream.Stream;

 import org.apache.log4j.Logger;

 import org.eclipse.emf.ecore.EClass;

+import org.eclipse.emf.ecore.EReference;

 import org.eclipse.viatra.query.runtime.api.IPatternMatch;

 import org.eclipse.viatra.query.runtime.api.IQuerySpecification;

 import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

@@ -23,10 +24,15 @@ import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecificat
 import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;

 import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;

 import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;

+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;

 import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

 import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

 import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;

+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;

 import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality;

 import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

@@ -40,8 +46,12 @@ import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
  * 

  * <p>Original source:

  *         <code><pre>

- *         pattern VLSUniversalQuantifier(term: VLSUniversalQuantifier){

- *              VLSUniversalQuantifier(term);

+ *         {@literal @}Constraint(key={a}, severity="error", message="error")

+ *         pattern oppositeDifferentClass(a:EReference) {

+ *              EReference.eOpposite(a,b);

+ *              EReference.eContainingClass(a,aContaining);

+ *              EReference.eType(b,bTarget);

+ *              aContaining != bTarget;

  *         }

  * </pre></code>

  * 

@@ -50,9 +60,9 @@ import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
  * 

  */

 @SuppressWarnings("all")

-public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecification<VLSUniversalQuantifier.Matcher> {

+public final class OppositeDifferentClass extends BaseGeneratedEMFQuerySpecification<OppositeDifferentClass.Matcher> {

   /**

-   * Pattern-specific match representation of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUniversalQuantifier pattern,

+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.oppositeDifferentClass pattern,

    * to be used in conjunction with {@link Matcher}.

    * 

    * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

@@ -64,69 +74,69 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
    * 

    */

   public static abstract class Match extends BasePatternMatch {

-    private ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier fTerm;

+    private EReference fA;

     

-    private static List<String> parameterNames = makeImmutableList("term");

+    private static List<String> parameterNames = makeImmutableList("a");

     

-    private Match(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm) {

-      this.fTerm = pTerm;

+    private Match(final EReference pA) {

+      this.fA = pA;

     }

     

     @Override

     public Object get(final String parameterName) {

-      if ("term".equals(parameterName)) return this.fTerm;

+      if ("a".equals(parameterName)) return this.fA;

       return null;

     }

     

-    public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier getTerm() {

-      return this.fTerm;

+    public EReference getA() {

+      return this.fA;

     }

     

     @Override

     public boolean set(final String parameterName, final Object newValue) {

       if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      if ("term".equals(parameterName) ) {

-          this.fTerm = (ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier) newValue;

+      if ("a".equals(parameterName) ) {

+          this.fA = (EReference) newValue;

           return true;

       }

       return false;

     }

     

-    public void setTerm(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm) {

+    public void setA(final EReference pA) {

       if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      this.fTerm = pTerm;

+      this.fA = pA;

     }

     

     @Override

     public String patternName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUniversalQuantifier";

+      return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.oppositeDifferentClass";

     }

     

     @Override

     public List<String> parameterNames() {

-      return VLSUniversalQuantifier.Match.parameterNames;

+      return OppositeDifferentClass.Match.parameterNames;

     }

     

     @Override

     public Object[] toArray() {

-      return new Object[]{fTerm};

+      return new Object[]{fA};

     }

     

     @Override

-    public VLSUniversalQuantifier.Match toImmutable() {

-      return isMutable() ? newMatch(fTerm) : this;

+    public OppositeDifferentClass.Match toImmutable() {

+      return isMutable() ? newMatch(fA) : this;

     }

     

     @Override

     public String prettyPrint() {

       StringBuilder result = new StringBuilder();

-      result.append("\"term\"=" + prettyPrintValue(fTerm));

+      result.append("\"a\"=" + prettyPrintValue(fA));

       return result.toString();

     }

     

     @Override

     public int hashCode() {

-      return Objects.hash(fTerm);

+      return Objects.hash(fA);

     }

     

     @Override

@@ -136,9 +146,9 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
       if (obj == null) {

           return false;

       }

-      if ((obj instanceof VLSUniversalQuantifier.Match)) {

-          VLSUniversalQuantifier.Match other = (VLSUniversalQuantifier.Match) obj;

-          return Objects.equals(fTerm, other.fTerm);

+      if ((obj instanceof OppositeDifferentClass.Match)) {

+          OppositeDifferentClass.Match other = (OppositeDifferentClass.Match) obj;

+          return Objects.equals(fA, other.fA);

       } else {

           // this should be infrequent

           if (!(obj instanceof IPatternMatch)) {

@@ -150,8 +160,8 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
     }

     

     @Override

-    public VLSUniversalQuantifier specification() {

-      return VLSUniversalQuantifier.instance();

+    public OppositeDifferentClass specification() {

+      return OppositeDifferentClass.instance();

     }

     

     /**

@@ -161,7 +171,7 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
      * @return the empty match.

      * 

      */

-    public static VLSUniversalQuantifier.Match newEmptyMatch() {

+    public static OppositeDifferentClass.Match newEmptyMatch() {

       return new Mutable(null);

     }

     

@@ -169,29 +179,29 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
      * Returns a mutable (partial) match.

      * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

      * 

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @return the new, mutable (partial) match object.

      * 

      */

-    public static VLSUniversalQuantifier.Match newMutableMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm) {

-      return new Mutable(pTerm);

+    public static OppositeDifferentClass.Match newMutableMatch(final EReference pA) {

+      return new Mutable(pA);

     }

     

     /**

      * Returns a new (partial) match.

      * This can be used e.g. to call the matcher with a partial match.

      * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @return the (partial) match object.

      * 

      */

-    public static VLSUniversalQuantifier.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm) {

-      return new Immutable(pTerm);

+    public static OppositeDifferentClass.Match newMatch(final EReference pA) {

+      return new Immutable(pA);

     }

     

-    private static final class Mutable extends VLSUniversalQuantifier.Match {

-      Mutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm) {

-        super(pTerm);

+    private static final class Mutable extends OppositeDifferentClass.Match {

+      Mutable(final EReference pA) {

+        super(pA);

       }

       

       @Override

@@ -200,9 +210,9 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
       }

     }

     

-    private static final class Immutable extends VLSUniversalQuantifier.Match {

-      Immutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm) {

-        super(pTerm);

+    private static final class Immutable extends OppositeDifferentClass.Match {

+      Immutable(final EReference pA) {

+        super(pA);

       }

       

       @Override

@@ -213,7 +223,7 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
   }

   

   /**

-   * Generated pattern matcher API of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUniversalQuantifier pattern,

+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.oppositeDifferentClass pattern,

    * providing pattern-specific query methods.

    * 

    * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

@@ -223,16 +233,20 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
    * 

    * <p>Original source:

    * <code><pre>

-   * pattern VLSUniversalQuantifier(term: VLSUniversalQuantifier){

-   *    VLSUniversalQuantifier(term);

+   * {@literal @}Constraint(key={a}, severity="error", message="error")

+   * pattern oppositeDifferentClass(a:EReference) {

+   *    EReference.eOpposite(a,b);

+   *    EReference.eContainingClass(a,aContaining);

+   *    EReference.eType(b,bTarget);

+   *    aContaining != bTarget;

    * }

    * </pre></code>

    * 

    * @see Match

-   * @see VLSUniversalQuantifier

+   * @see OppositeDifferentClass

    * 

    */

-  public static class Matcher extends BaseMatcher<VLSUniversalQuantifier.Match> {

+  public static class Matcher extends BaseMatcher<OppositeDifferentClass.Match> {

     /**

      * Initializes the pattern matcher within an existing VIATRA Query engine.

      * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

@@ -241,7 +255,7 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
      * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

      * 

      */

-    public static VLSUniversalQuantifier.Matcher on(final ViatraQueryEngine engine) {

+    public static OppositeDifferentClass.Matcher on(final ViatraQueryEngine engine) {

       // check if matcher already exists

       Matcher matcher = engine.getExistingMatcher(querySpecification());

       if (matcher == null) {

@@ -256,13 +270,13 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
      * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

      * 

      */

-    public static VLSUniversalQuantifier.Matcher create() {

+    public static OppositeDifferentClass.Matcher create() {

       return new Matcher();

     }

     

-    private final static int POSITION_TERM = 0;

+    private final static int POSITION_A = 0;

     

-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSUniversalQuantifier.Matcher.class);

+    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(OppositeDifferentClass.Matcher.class);

     

     /**

      * Initializes the pattern matcher within an existing VIATRA Query engine.

@@ -278,12 +292,12 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
     

     /**

      * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @return matches represented as a Match object.

      * 

      */

-    public Collection<VLSUniversalQuantifier.Match> getAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm}).collect(Collectors.toSet());

+    public Collection<OppositeDifferentClass.Match> getAllMatches(final EReference pA) {

+      return rawStreamAllMatches(new Object[]{pA}).collect(Collectors.toSet());

     }

     

     /**

@@ -292,101 +306,101 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
      * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

      * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

      * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @return a stream of matches represented as a Match object.

      * 

      */

-    public Stream<VLSUniversalQuantifier.Match> streamAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm});

+    public Stream<OppositeDifferentClass.Match> streamAllMatches(final EReference pA) {

+      return rawStreamAllMatches(new Object[]{pA});

     }

     

     /**

      * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

      * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @return a match represented as a Match object, or null if no match is found.

      * 

      */

-    public Optional<VLSUniversalQuantifier.Match> getOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm) {

-      return rawGetOneArbitraryMatch(new Object[]{pTerm});

+    public Optional<OppositeDifferentClass.Match> getOneArbitraryMatch(final EReference pA) {

+      return rawGetOneArbitraryMatch(new Object[]{pA});

     }

     

     /**

      * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

      * under any possible substitution of the unspecified parameters (if any).

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @return true if the input is a valid (partial) match of the pattern.

      * 

      */

-    public boolean hasMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm) {

-      return rawHasMatch(new Object[]{pTerm});

+    public boolean hasMatch(final EReference pA) {

+      return rawHasMatch(new Object[]{pA});

     }

     

     /**

      * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @return the number of pattern matches found.

      * 

      */

-    public int countMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm) {

-      return rawCountMatches(new Object[]{pTerm});

+    public int countMatches(final EReference pA) {

+      return rawCountMatches(new Object[]{pA});

     }

     

     /**

      * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

      * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @param processor the action that will process the selected match.

      * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

      * 

      */

-    public boolean forOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm, final Consumer<? super VLSUniversalQuantifier.Match> processor) {

-      return rawForOneArbitraryMatch(new Object[]{pTerm}, processor);

+    public boolean forOneArbitraryMatch(final EReference pA, final Consumer<? super OppositeDifferentClass.Match> processor) {

+      return rawForOneArbitraryMatch(new Object[]{pA}, processor);

     }

     

     /**

      * Returns a new (partial) match.

      * This can be used e.g. to call the matcher with a partial match.

      * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

+     * @param pA the fixed value of pattern parameter a, or null if not bound.

      * @return the (partial) match object.

      * 

      */

-    public VLSUniversalQuantifier.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm) {

-      return VLSUniversalQuantifier.Match.newMatch(pTerm);

+    public OppositeDifferentClass.Match newMatch(final EReference pA) {

+      return OppositeDifferentClass.Match.newMatch(pA);

     }

     

     /**

-     * Retrieve the set of values that occur in matches for term.

+     * Retrieve the set of values that occur in matches for a.

      * @return the Set of all values or empty set if there are no matches

      * 

      */

-    protected Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier> rawStreamAllValuesOfterm(final Object[] parameters) {

-      return rawStreamAllValues(POSITION_TERM, parameters).map(ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier.class::cast);

+    protected Stream<EReference> rawStreamAllValuesOfa(final Object[] parameters) {

+      return rawStreamAllValues(POSITION_A, parameters).map(EReference.class::cast);

     }

     

     /**

-     * Retrieve the set of values that occur in matches for term.

+     * Retrieve the set of values that occur in matches for a.

      * @return the Set of all values or empty set if there are no matches

      * 

      */

-    public Set<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier> getAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray()).collect(Collectors.toSet());

+    public Set<EReference> getAllValuesOfa() {

+      return rawStreamAllValuesOfa(emptyArray()).collect(Collectors.toSet());

     }

     

     /**

-     * Retrieve the set of values that occur in matches for term.

+     * Retrieve the set of values that occur in matches for a.

      * @return the Set of all values or empty set if there are no matches

      * 

      */

-    public Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier> streamAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray());

+    public Stream<EReference> streamAllValuesOfa() {

+      return rawStreamAllValuesOfa(emptyArray());

     }

     

     @Override

-    protected VLSUniversalQuantifier.Match tupleToMatch(final Tuple t) {

+    protected OppositeDifferentClass.Match tupleToMatch(final Tuple t) {

       try {

-          return VLSUniversalQuantifier.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier) t.get(POSITION_TERM));

+          return OppositeDifferentClass.Match.newMatch((EReference) t.get(POSITION_A));

       } catch(ClassCastException e) {

           LOGGER.error("Element(s) in tuple not properly typed!",e);

           return null;

@@ -394,9 +408,9 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
     }

     

     @Override

-    protected VLSUniversalQuantifier.Match arrayToMatch(final Object[] match) {

+    protected OppositeDifferentClass.Match arrayToMatch(final Object[] match) {

       try {

-          return VLSUniversalQuantifier.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier) match[POSITION_TERM]);

+          return OppositeDifferentClass.Match.newMatch((EReference) match[POSITION_A]);

       } catch(ClassCastException e) {

           LOGGER.error("Element(s) in array not properly typed!",e);

           return null;

@@ -404,9 +418,9 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
     }

     

     @Override

-    protected VLSUniversalQuantifier.Match arrayToMatchMutable(final Object[] match) {

+    protected OppositeDifferentClass.Match arrayToMatchMutable(final Object[] match) {

       try {

-          return VLSUniversalQuantifier.Match.newMutableMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier) match[POSITION_TERM]);

+          return OppositeDifferentClass.Match.newMutableMatch((EReference) match[POSITION_A]);

       } catch(ClassCastException e) {

           LOGGER.error("Element(s) in array not properly typed!",e);

           return null;

@@ -418,12 +432,12 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
      * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

      * 

      */

-    public static IQuerySpecification<VLSUniversalQuantifier.Matcher> querySpecification() {

-      return VLSUniversalQuantifier.instance();

+    public static IQuerySpecification<OppositeDifferentClass.Matcher> querySpecification() {

+      return OppositeDifferentClass.instance();

     }

   }

   

-  private VLSUniversalQuantifier() {

+  private OppositeDifferentClass() {

     super(GeneratedPQuery.INSTANCE);

   }

   

@@ -432,7 +446,7 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
    * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

    * 

    */

-  public static VLSUniversalQuantifier instance() {

+  public static OppositeDifferentClass instance() {

     try{

         return LazyHolder.INSTANCE;

     } catch (ExceptionInInitializerError err) {

@@ -441,35 +455,35 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
   }

   

   @Override

-  protected VLSUniversalQuantifier.Matcher instantiate(final ViatraQueryEngine engine) {

-    return VLSUniversalQuantifier.Matcher.on(engine);

+  protected OppositeDifferentClass.Matcher instantiate(final ViatraQueryEngine engine) {

+    return OppositeDifferentClass.Matcher.on(engine);

   }

   

   @Override

-  public VLSUniversalQuantifier.Matcher instantiate() {

-    return VLSUniversalQuantifier.Matcher.create();

+  public OppositeDifferentClass.Matcher instantiate() {

+    return OppositeDifferentClass.Matcher.create();

   }

   

   @Override

-  public VLSUniversalQuantifier.Match newEmptyMatch() {

-    return VLSUniversalQuantifier.Match.newEmptyMatch();

+  public OppositeDifferentClass.Match newEmptyMatch() {

+    return OppositeDifferentClass.Match.newEmptyMatch();

   }

   

   @Override

-  public VLSUniversalQuantifier.Match newMatch(final Object... parameters) {

-    return VLSUniversalQuantifier.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier) parameters[0]);

+  public OppositeDifferentClass.Match newMatch(final Object... parameters) {

+    return OppositeDifferentClass.Match.newMatch((org.eclipse.emf.ecore.EReference) parameters[0]);

   }

   

   /**

-   * Inner class allowing the singleton instance of {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUniversalQuantifier (visibility: PUBLIC, simpleName: VLSUniversalQuantifier, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUniversalQuantifier, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

+   * Inner class allowing the singleton instance of {@link JvmGenericType: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.OppositeDifferentClass (visibility: PUBLIC, simpleName: OppositeDifferentClass, identifier: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.OppositeDifferentClass, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: hu.bme.mit.inf.dslreasoner.domains.alloyexamples) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

    *     <b>not</b> at the class load time of the outer class, 

-   *     but rather at the first call to {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUniversalQuantifier (visibility: PUBLIC, simpleName: VLSUniversalQuantifier, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUniversalQuantifier, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

+   *     but rather at the first call to {@link JvmGenericType: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.OppositeDifferentClass (visibility: PUBLIC, simpleName: OppositeDifferentClass, identifier: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.OppositeDifferentClass, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: hu.bme.mit.inf.dslreasoner.domains.alloyexamples) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

    * 

    * <p> This workaround is required e.g. to support recursion.

    * 

    */

   private static class LazyHolder {

-    private final static VLSUniversalQuantifier INSTANCE = new VLSUniversalQuantifier();

+    private final static OppositeDifferentClass INSTANCE = new OppositeDifferentClass();

     

     /**

      * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

@@ -487,11 +501,11 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
   }

   

   private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

-    private final static VLSUniversalQuantifier.GeneratedPQuery INSTANCE = new GeneratedPQuery();

+    private final static OppositeDifferentClass.GeneratedPQuery INSTANCE = new GeneratedPQuery();

     

-    private final PParameter parameter_term = new PParameter("term", "ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSUniversalQuantifier")), PParameterDirection.INOUT);

+    private final PParameter parameter_a = new PParameter("a", "org.eclipse.emf.ecore.EReference", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EReference")), PParameterDirection.INOUT);

     

-    private final List<PParameter> parameters = Arrays.asList(parameter_term);

+    private final List<PParameter> parameters = Arrays.asList(parameter_a);

     

     private GeneratedPQuery() {

       super(PVisibility.PUBLIC);

@@ -499,12 +513,12 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
     

     @Override

     public String getFullyQualifiedName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUniversalQuantifier";

+      return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.oppositeDifferentClass";

     }

     

     @Override

     public List<String> getParameterNames() {

-      return Arrays.asList("term");

+      return Arrays.asList("a");

     }

     

     @Override

@@ -518,15 +532,45 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
       Set<PBody> bodies = new LinkedHashSet<>();

       {

           PBody body = new PBody(this);

-          PVariable var_term = body.getOrCreateVariableByName("term");

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSUniversalQuantifier")));

+          PVariable var_a = body.getOrCreateVariableByName("a");

+          PVariable var_b = body.getOrCreateVariableByName("b");

+          PVariable var_aContaining = body.getOrCreateVariableByName("aContaining");

+          PVariable var_bTarget = body.getOrCreateVariableByName("bTarget");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));

           body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

-             new ExportedParameter(body, var_term, parameter_term)

+             new ExportedParameter(body, var_a, parameter_a)

           ));

-          //    VLSUniversalQuantifier(term)

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSUniversalQuantifier")));

+          //    EReference.eOpposite(a,b)

+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));

+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_a, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference", "eOpposite")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));

+          new Equality(body, var__virtual_0_, var_b);

+          //    EReference.eContainingClass(a,aContaining)

+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));

+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_a, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.eclipse.org/emf/2002/Ecore", "EStructuralFeature", "eContainingClass")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));

+          new Equality(body, var__virtual_1_, var_aContaining);

+          //    EReference.eType(b,bTarget)

+          new TypeConstraint(body, Tuples.flatTupleOf(var_b), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));

+          PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_b, var__virtual_2_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.eclipse.org/emf/2002/Ecore", "ETypedElement", "eType")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_2_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClassifier")));

+          new Equality(body, var__virtual_2_, var_bTarget);

+          //    aContaining != bTarget

+          new Inequality(body, var_aContaining, var_bTarget);

           bodies.add(body);

       }

+      {

+          PAnnotation annotation = new PAnnotation("Constraint");

+          annotation.addAttribute("key", Arrays.asList(new Object[] {

+                              new ParameterReference("a")

+                              }));

+          annotation.addAttribute("severity", "error");

+          annotation.addAttribute("message", "error");

+          addAnnotation(annotation);

+      }

       return bodies;

     }

   }

diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/PatternContent.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/PatternContent.java
new file mode 100644
index 00000000..f9bab96e
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/PatternContent.java
@@ -0,0 +1,693 @@
+/**

+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/patterns/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/FileSystem.vql

+ */

+package hu.bme.mit.inf.dslreasoner.domains.alloyexamples;

+

+import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject;

+import java.util.Arrays;

+import java.util.Collection;

+import java.util.LinkedHashSet;

+import java.util.List;

+import java.util.Objects;

+import java.util.Optional;

+import java.util.Set;

+import java.util.function.Consumer;

+import java.util.stream.Collectors;

+import java.util.stream.Stream;

+import org.apache.log4j.Logger;

+import org.eclipse.emf.ecore.EClass;

+import org.eclipse.viatra.query.runtime.api.IPatternMatch;

+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;

+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;

+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;

+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;

+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;

+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;

+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;

+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;

+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;

+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;

+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;

+

+/**

+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.

+ * 

+ * <p>Original source:

+ *         <code><pre>

+ *         pattern patternContent(o1: FSObject, o2: FSObject) {

+ *              Dir.contents(o1,o2);

+ *         }

+ * </pre></code>

+ * 

+ * @see Matcher

+ * @see Match

+ * 

+ */

+@SuppressWarnings("all")

+public final class PatternContent extends BaseGeneratedEMFQuerySpecification<PatternContent.Matcher> {

+  /**

+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.patternContent pattern,

+   * to be used in conjunction with {@link Matcher}.

+   * 

+   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

+   * Each instance is a (possibly partial) substitution of pattern parameters,

+   * usable to represent a match of the pattern in the result of a query,

+   * or to specify the bound (fixed) input parameters when issuing a query.

+   * 

+   * @see Matcher

+   * 

+   */

+  public static abstract class Match extends BasePatternMatch {

+    private FSObject fO1;

+    

+    private FSObject fO2;

+    

+    private static List<String> parameterNames = makeImmutableList("o1", "o2");

+    

+    private Match(final FSObject pO1, final FSObject pO2) {

+      this.fO1 = pO1;

+      this.fO2 = pO2;

+    }

+    

+    @Override

+    public Object get(final String parameterName) {

+      if ("o1".equals(parameterName)) return this.fO1;

+      if ("o2".equals(parameterName)) return this.fO2;

+      return null;

+    }

+    

+    public FSObject getO1() {

+      return this.fO1;

+    }

+    

+    public FSObject getO2() {

+      return this.fO2;

+    }

+    

+    @Override

+    public boolean set(final String parameterName, final Object newValue) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      if ("o1".equals(parameterName) ) {

+          this.fO1 = (FSObject) newValue;

+          return true;

+      }

+      if ("o2".equals(parameterName) ) {

+          this.fO2 = (FSObject) newValue;

+          return true;

+      }

+      return false;

+    }

+    

+    public void setO1(final FSObject pO1) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      this.fO1 = pO1;

+    }

+    

+    public void setO2(final FSObject pO2) {

+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

+      this.fO2 = pO2;

+    }

+    

+    @Override

+    public String patternName() {

+      return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.patternContent";

+    }

+    

+    @Override

+    public List<String> parameterNames() {

+      return PatternContent.Match.parameterNames;

+    }

+    

+    @Override

+    public Object[] toArray() {

+      return new Object[]{fO1, fO2};

+    }

+    

+    @Override

+    public PatternContent.Match toImmutable() {

+      return isMutable() ? newMatch(fO1, fO2) : this;

+    }

+    

+    @Override

+    public String prettyPrint() {

+      StringBuilder result = new StringBuilder();

+      result.append("\"o1\"=" + prettyPrintValue(fO1) + ", ");

+      result.append("\"o2\"=" + prettyPrintValue(fO2));

+      return result.toString();

+    }

+    

+    @Override

+    public int hashCode() {

+      return Objects.hash(fO1, fO2);

+    }

+    

+    @Override

+    public boolean equals(final Object obj) {

+      if (this == obj)

+          return true;

+      if (obj == null) {

+          return false;

+      }

+      if ((obj instanceof PatternContent.Match)) {

+          PatternContent.Match other = (PatternContent.Match) obj;

+          return Objects.equals(fO1, other.fO1) && Objects.equals(fO2, other.fO2);

+      } else {

+          // this should be infrequent

+          if (!(obj instanceof IPatternMatch)) {

+              return false;

+          }

+          IPatternMatch otherSig  = (IPatternMatch) obj;

+          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());

+      }

+    }

+    

+    @Override

+    public PatternContent specification() {

+      return PatternContent.instance();

+    }

+    

+    /**

+     * Returns an empty, mutable match.

+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

+     * 

+     * @return the empty match.

+     * 

+     */

+    public static PatternContent.Match newEmptyMatch() {

+      return new Mutable(null, null);

+    }

+    

+    /**

+     * Returns a mutable (partial) match.

+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

+     * 

+     * @param pO1 the fixed value of pattern parameter o1, or null if not bound.

+     * @param pO2 the fixed value of pattern parameter o2, or null if not bound.

+     * @return the new, mutable (partial) match object.

+     * 

+     */

+    public static PatternContent.Match newMutableMatch(final FSObject pO1, final FSObject pO2) {

+      return new Mutable(pO1, pO2);

+    }

+    

+    /**

+     * Returns a new (partial) match.

+     * This can be used e.g. to call the matcher with a partial match.

+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

+     * @param pO1 the fixed value of pattern parameter o1, or null if not bound.

+     * @param pO2 the fixed value of pattern parameter o2, or null if not bound.

+     * @return the (partial) match object.

+     * 

+     */

+    public static PatternContent.Match newMatch(final FSObject pO1, final FSObject pO2) {

+      return new Immutable(pO1, pO2);

+    }

+    

+    private static final class Mutable extends PatternContent.Match {

+      Mutable(final FSObject pO1, final FSObject pO2) {

+        super(pO1, pO2);

+      }

+      

+      @Override

+      public boolean isMutable() {

+        return true;

+      }

+    }

+    

+    private static final class Immutable extends PatternContent.Match {

+      Immutable(final FSObject pO1, final FSObject pO2) {

+        super(pO1, pO2);

+      }

+      

+      @Override

+      public boolean isMutable() {

+        return false;

+      }

+    }

+  }

+  

+  /**

+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.patternContent pattern,

+   * providing pattern-specific query methods.

+   * 

+   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

+   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.

+   * 

+   * <p>Matches of the pattern will be represented as {@link Match}.

+   * 

+   * <p>Original source:

+   * <code><pre>

+   * pattern patternContent(o1: FSObject, o2: FSObject) {

+   *    Dir.contents(o1,o2);

+   * }

+   * </pre></code>

+   * 

+   * @see Match

+   * @see PatternContent

+   * 

+   */

+  public static class Matcher extends BaseMatcher<PatternContent.Match> {

+    /**

+     * Initializes the pattern matcher within an existing VIATRA Query engine.

+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

+     * 

+     * @param engine the existing VIATRA Query engine in which this matcher will be created.

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * 

+     */

+    public static PatternContent.Matcher on(final ViatraQueryEngine engine) {

+      // check if matcher already exists

+      Matcher matcher = engine.getExistingMatcher(querySpecification());

+      if (matcher == null) {

+          matcher = (Matcher)engine.getMatcher(querySpecification());

+      }

+      return matcher;

+    }

+    

+    /**

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * @return an initialized matcher

+     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

+     * 

+     */

+    public static PatternContent.Matcher create() {

+      return new Matcher();

+    }

+    

+    private final static int POSITION_O1 = 0;

+    

+    private final static int POSITION_O2 = 1;

+    

+    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(PatternContent.Matcher.class);

+    

+    /**

+     * Initializes the pattern matcher within an existing VIATRA Query engine.

+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

+     * 

+     * @param engine the existing VIATRA Query engine in which this matcher will be created.

+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

+     * 

+     */

+    private Matcher() {

+      super(querySpecification());

+    }

+    

+    /**

+     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

+     * @param pO1 the fixed value of pattern parameter o1, or null if not bound.

+     * @param pO2 the fixed value of pattern parameter o2, or null if not bound.

+     * @return matches represented as a Match object.

+     * 

+     */

+    public Collection<PatternContent.Match> getAllMatches(final FSObject pO1, final FSObject pO2) {

+      return rawStreamAllMatches(new Object[]{pO1, pO2}).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     * @param pO1 the fixed value of pattern parameter o1, or null if not bound.

+     * @param pO2 the fixed value of pattern parameter o2, or null if not bound.

+     * @return a stream of matches represented as a Match object.

+     * 

+     */

+    public Stream<PatternContent.Match> streamAllMatches(final FSObject pO1, final FSObject pO2) {

+      return rawStreamAllMatches(new Object[]{pO1, pO2});

+    }

+    

+    /**

+     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

+     * Neither determinism nor randomness of selection is guaranteed.

+     * @param pO1 the fixed value of pattern parameter o1, or null if not bound.

+     * @param pO2 the fixed value of pattern parameter o2, or null if not bound.

+     * @return a match represented as a Match object, or null if no match is found.

+     * 

+     */

+    public Optional<PatternContent.Match> getOneArbitraryMatch(final FSObject pO1, final FSObject pO2) {

+      return rawGetOneArbitraryMatch(new Object[]{pO1, pO2});

+    }

+    

+    /**

+     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

+     * under any possible substitution of the unspecified parameters (if any).

+     * @param pO1 the fixed value of pattern parameter o1, or null if not bound.

+     * @param pO2 the fixed value of pattern parameter o2, or null if not bound.

+     * @return true if the input is a valid (partial) match of the pattern.

+     * 

+     */

+    public boolean hasMatch(final FSObject pO1, final FSObject pO2) {

+      return rawHasMatch(new Object[]{pO1, pO2});

+    }

+    

+    /**

+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

+     * @param pO1 the fixed value of pattern parameter o1, or null if not bound.

+     * @param pO2 the fixed value of pattern parameter o2, or null if not bound.

+     * @return the number of pattern matches found.

+     * 

+     */

+    public int countMatches(final FSObject pO1, final FSObject pO2) {

+      return rawCountMatches(new Object[]{pO1, pO2});

+    }

+    

+    /**

+     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

+     * Neither determinism nor randomness of selection is guaranteed.

+     * @param pO1 the fixed value of pattern parameter o1, or null if not bound.

+     * @param pO2 the fixed value of pattern parameter o2, or null if not bound.

+     * @param processor the action that will process the selected match.

+     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

+     * 

+     */

+    public boolean forOneArbitraryMatch(final FSObject pO1, final FSObject pO2, final Consumer<? super PatternContent.Match> processor) {

+      return rawForOneArbitraryMatch(new Object[]{pO1, pO2}, processor);

+    }

+    

+    /**

+     * Returns a new (partial) match.

+     * This can be used e.g. to call the matcher with a partial match.

+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

+     * @param pO1 the fixed value of pattern parameter o1, or null if not bound.

+     * @param pO2 the fixed value of pattern parameter o2, or null if not bound.

+     * @return the (partial) match object.

+     * 

+     */

+    public PatternContent.Match newMatch(final FSObject pO1, final FSObject pO2) {

+      return PatternContent.Match.newMatch(pO1, pO2);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for o1.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    protected Stream<FSObject> rawStreamAllValuesOfo1(final Object[] parameters) {

+      return rawStreamAllValues(POSITION_O1, parameters).map(FSObject.class::cast);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for o1.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<FSObject> getAllValuesOfo1() {

+      return rawStreamAllValuesOfo1(emptyArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for o1.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<FSObject> streamAllValuesOfo1() {

+      return rawStreamAllValuesOfo1(emptyArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for o1.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<FSObject> streamAllValuesOfo1(final PatternContent.Match partialMatch) {

+      return rawStreamAllValuesOfo1(partialMatch.toArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for o1.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<FSObject> streamAllValuesOfo1(final FSObject pO2) {

+      return rawStreamAllValuesOfo1(new Object[]{null, pO2});

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for o1.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<FSObject> getAllValuesOfo1(final PatternContent.Match partialMatch) {

+      return rawStreamAllValuesOfo1(partialMatch.toArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for o1.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<FSObject> getAllValuesOfo1(final FSObject pO2) {

+      return rawStreamAllValuesOfo1(new Object[]{null, pO2}).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for o2.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    protected Stream<FSObject> rawStreamAllValuesOfo2(final Object[] parameters) {

+      return rawStreamAllValues(POSITION_O2, parameters).map(FSObject.class::cast);

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for o2.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<FSObject> getAllValuesOfo2() {

+      return rawStreamAllValuesOfo2(emptyArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for o2.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<FSObject> streamAllValuesOfo2() {

+      return rawStreamAllValuesOfo2(emptyArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for o2.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<FSObject> streamAllValuesOfo2(final PatternContent.Match partialMatch) {

+      return rawStreamAllValuesOfo2(partialMatch.toArray());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for o2.

+     * </p>

+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

+     *      

+     * @return the Stream of all values or empty set if there are no matches

+     * 

+     */

+    public Stream<FSObject> streamAllValuesOfo2(final FSObject pO1) {

+      return rawStreamAllValuesOfo2(new Object[]{pO1, null});

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for o2.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<FSObject> getAllValuesOfo2(final PatternContent.Match partialMatch) {

+      return rawStreamAllValuesOfo2(partialMatch.toArray()).collect(Collectors.toSet());

+    }

+    

+    /**

+     * Retrieve the set of values that occur in matches for o2.

+     * @return the Set of all values or empty set if there are no matches

+     * 

+     */

+    public Set<FSObject> getAllValuesOfo2(final FSObject pO1) {

+      return rawStreamAllValuesOfo2(new Object[]{pO1, null}).collect(Collectors.toSet());

+    }

+    

+    @Override

+    protected PatternContent.Match tupleToMatch(final Tuple t) {

+      try {

+          return PatternContent.Match.newMatch((FSObject) t.get(POSITION_O1), (FSObject) t.get(POSITION_O2));

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in tuple not properly typed!",e);

+          return null;

+      }

+    }

+    

+    @Override

+    protected PatternContent.Match arrayToMatch(final Object[] match) {

+      try {

+          return PatternContent.Match.newMatch((FSObject) match[POSITION_O1], (FSObject) match[POSITION_O2]);

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in array not properly typed!",e);

+          return null;

+      }

+    }

+    

+    @Override

+    protected PatternContent.Match arrayToMatchMutable(final Object[] match) {

+      try {

+          return PatternContent.Match.newMutableMatch((FSObject) match[POSITION_O1], (FSObject) match[POSITION_O2]);

+      } catch(ClassCastException e) {

+          LOGGER.error("Element(s) in array not properly typed!",e);

+          return null;

+      }

+    }

+    

+    /**

+     * @return the singleton instance of the query specification of this pattern

+     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

+     * 

+     */

+    public static IQuerySpecification<PatternContent.Matcher> querySpecification() {

+      return PatternContent.instance();

+    }

+  }

+  

+  private PatternContent() {

+    super(GeneratedPQuery.INSTANCE);

+  }

+  

+  /**

+   * @return the singleton instance of the query specification

+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

+   * 

+   */

+  public static PatternContent instance() {

+    try{

+        return LazyHolder.INSTANCE;

+    } catch (ExceptionInInitializerError err) {

+        throw processInitializerError(err);

+    }

+  }

+  

+  @Override

+  protected PatternContent.Matcher instantiate(final ViatraQueryEngine engine) {

+    return PatternContent.Matcher.on(engine);

+  }

+  

+  @Override

+  public PatternContent.Matcher instantiate() {

+    return PatternContent.Matcher.create();

+  }

+  

+  @Override

+  public PatternContent.Match newEmptyMatch() {

+    return PatternContent.Match.newEmptyMatch();

+  }

+  

+  @Override

+  public PatternContent.Match newMatch(final Object... parameters) {

+    return PatternContent.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject) parameters[0], (hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject) parameters[1]);

+  }

+  

+  /**

+   * Inner class allowing the singleton instance of {@link JvmGenericType: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.PatternContent (visibility: PUBLIC, simpleName: PatternContent, identifier: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.PatternContent, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: hu.bme.mit.inf.dslreasoner.domains.alloyexamples) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

+   *     <b>not</b> at the class load time of the outer class, 

+   *     but rather at the first call to {@link JvmGenericType: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.PatternContent (visibility: PUBLIC, simpleName: PatternContent, identifier: hu.bme.mit.inf.dslreasoner.domains.alloyexamples.PatternContent, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: hu.bme.mit.inf.dslreasoner.domains.alloyexamples) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

+   * 

+   * <p> This workaround is required e.g. to support recursion.

+   * 

+   */

+  private static class LazyHolder {

+    private final static PatternContent INSTANCE = new PatternContent();

+    

+    /**

+     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

+     * This initialization order is required to support indirect recursion.

+     * 

+     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.

+     * 

+     */

+    private final static Object STATIC_INITIALIZER = ensureInitialized();

+    

+    public static Object ensureInitialized() {

+      INSTANCE.ensureInitializedInternal();

+      return null;

+    }

+  }

+  

+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

+    private final static PatternContent.GeneratedPQuery INSTANCE = new GeneratedPQuery();

+    

+    private final PParameter parameter_o1 = new PParameter("o1", "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("FS", "FSObject")), PParameterDirection.INOUT);

+    

+    private final PParameter parameter_o2 = new PParameter("o2", "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("FS", "FSObject")), PParameterDirection.INOUT);

+    

+    private final List<PParameter> parameters = Arrays.asList(parameter_o1, parameter_o2);

+    

+    private GeneratedPQuery() {

+      super(PVisibility.PUBLIC);

+    }

+    

+    @Override

+    public String getFullyQualifiedName() {

+      return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.patternContent";

+    }

+    

+    @Override

+    public List<String> getParameterNames() {

+      return Arrays.asList("o1","o2");

+    }

+    

+    @Override

+    public List<PParameter> getParameters() {

+      return parameters;

+    }

+    

+    @Override

+    public Set<PBody> doGetContainedBodies() {

+      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));

+      Set<PBody> bodies = new LinkedHashSet<>();

+      {

+          PBody body = new PBody(this);

+          PVariable var_o1 = body.getOrCreateVariableByName("o1");

+          PVariable var_o2 = body.getOrCreateVariableByName("o2");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_o1), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FSObject")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var_o2), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FSObject")));

+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

+             new ExportedParameter(body, var_o1, parameter_o1),

+             new ExportedParameter(body, var_o2, parameter_o2)

+          ));

+          //    Dir.contents(o1,o2)

+          new TypeConstraint(body, Tuples.flatTupleOf(var_o1), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "Dir")));

+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");

+          new TypeConstraint(body, Tuples.flatTupleOf(var_o1, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("FS", "Dir", "contents")));

+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FSObject")));

+          new Equality(body, var__virtual_0_, var_o2);

+          bodies.add(body);

+      }

+      return bodies;

+    }

+  }

+}

diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph/META-INF/MANIFEST.MF b/Domains/hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph/META-INF/MANIFEST.MF
index f15381b2..f2fd2ff3 100644
--- a/Domains/hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph/META-INF/MANIFEST.MF
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph/META-INF/MANIFEST.MF
@@ -6,17 +6,15 @@ Bundle-Version: 1.0.0.qualifier
 Bundle-ClassPath: .
 Bundle-Vendor: %providerName
 Bundle-Localization: plugin
-Export-Package: hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm,

- hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm.impl,

- hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm.util,

- hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu,

- hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.mutated,

- hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.mutated.util,

- hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.util
-Require-Bundle: org.eclipse.viatra.query.runtime,

- org.eclipse.core.runtime,

- org.eclipse.emf.ecore;visibility:=reexport,

- com.google.guava;bundle-version="15.0.0"
+Export-Package: hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm,
+  hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm.impl,
+  hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm.util,
+  hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu,
+  hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.mutated
+Require-Bundle: org.eclipse.viatra.query.runtime,
+  org.eclipse.core.runtime,
+  org.eclipse.emf.ecore;visibility:=reexport,
+  com.google.guava;bundle-version="15.0.0"
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Bundle-ActivationPolicy: lazy
 Import-Package: org.apache.log4j
diff --git a/Framework/hu.bme.mit.inf.dslreasoner.logic.model/.classpath b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/.classpath
index e84a3295..a9e661c7 100644
--- a/Framework/hu.bme.mit.inf.dslreasoner.logic.model/.classpath
+++ b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/.classpath
@@ -7,5 +7,6 @@
         <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>

         <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>

         <classpathentry kind="src" path="src"/>

+        <classpathentry kind="src" path="src-gen/"/>

         <classpathentry kind="output" path="bin"/>

 </classpath>

diff --git a/Framework/hu.bme.mit.inf.dslreasoner.logic.model/META-INF/MANIFEST.MF b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/META-INF/MANIFEST.MF
index 8e1bba03..27b81f93 100644
--- a/Framework/hu.bme.mit.inf.dslreasoner.logic.model/META-INF/MANIFEST.MF
+++ b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/META-INF/MANIFEST.MF
@@ -3,7 +3,6 @@ Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
 Bundle-SymbolicName: hu.bme.mit.inf.dslreasoner.logic.model;singleton:=true
 Bundle-Version: 1.0.0.qualifier
-Bundle-ClassPath: .
 Bundle-Vendor: %providerName
 Bundle-Localization: plugin
 Export-Package: hu.bme.mit.inf.dslreasoner.logic.model.builder,
@@ -30,7 +29,7 @@ Require-Bundle: org.eclipse.core.runtime,
   org.eclipse.viatra.query.runtime;bundle-version="1.3.0",
   org.apache.commons.lang;bundle-version="2.6.0",
   org.eclipse.emf.ecore.xmi;bundle-version="2.13.0"
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Bundle-ActivationPolicy: lazy
 Import-Package: org.apache.log4j
 Automatic-Module-Name: hu.bme.mit.inf.dslreasoner.logic.model
-Bundle-ActivationPolicy: lazy
-Bundle-RequiredExecutionEnvironment: JavaSE-1.8
diff --git a/Framework/hu.bme.mit.inf.dslreasoner.logic.model/build.properties b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/build.properties
index 9403fc5f..c18a0403 100644
--- a/Framework/hu.bme.mit.inf.dslreasoner.logic.model/build.properties
+++ b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/build.properties
@@ -8,5 +8,6 @@ source.. = ecore-gen/,\
            src/,\

            xtend-gen/,\

            patterns/,\

-           vql-gen/

+           vql-gen/,\

+           src-gen/

 output.. = bin/

diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/.classpath b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/.classpath
index de68b5f7..a29b9deb 100644
--- a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/.classpath
+++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/.classpath
@@ -7,5 +7,6 @@
         <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>

         <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>

         <classpathentry kind="src" path="src"/>

+        <classpathentry kind="src" path="src-gen/"/>

         <classpathentry kind="output" path="bin"/>

 </classpath>

diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/build.properties b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/build.properties
index 685c072b..1eb934ae 100644
--- a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/build.properties
+++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/build.properties
@@ -6,5 +6,6 @@ jars.compile.order = .
 source.. = src/,\

            queries/,\

            xtend-gen/,\

-           vql-gen/

+           vql-gen/,\

+           src-gen/

 output.. = bin/

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/.classpath b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/.classpath
deleted file mode 100644
index a0c6dd9c..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/.classpath
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>

-<classpath>

-        <classpathentry kind="src" path="src"/>

-        <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>

-        <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>

-        <classpathentry kind="output" path="bin"/>

-</classpath>

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/.project b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/.project
deleted file mode 100644
index 85d1308e..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/.project
+++ /dev/null
@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>

-<projectDescription>

-        <name>ca.mcgill.ecse.dslreasoner.trace.logic2vampire</name>

-        <comment></comment>

-        <projects>

-        </projects>

-        <buildSpec>

-                <buildCommand>

-                        <name>org.eclipse.jdt.core.javabuilder</name>

-                        <arguments>

-                        </arguments>

-                </buildCommand>

-                <buildCommand>

-                        <name>org.eclipse.pde.ManifestBuilder</name>

-                        <arguments>

-                        </arguments>

-                </buildCommand>

-                <buildCommand>

-                        <name>org.eclipse.pde.SchemaBuilder</name>

-                        <arguments>

-                        </arguments>

-                </buildCommand>

-        </buildSpec>

-        <natures>

-                <nature>org.eclipse.sirius.nature.modelingproject</nature>

-                <nature>org.eclipse.jdt.core.javanature</nature>

-                <nature>org.eclipse.pde.PluginNature</nature>

-        </natures>

-</projectDescription>

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/META-INF/MANIFEST.MF b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/META-INF/MANIFEST.MF
deleted file mode 100644
index f4f91de8..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/META-INF/MANIFEST.MF
+++ /dev/null
@@ -1,7 +0,0 @@
-Manifest-Version: 1.0

-Bundle-ManifestVersion: 2

-Bundle-Name: ca.mcgill.ecse.dslreasoner.trace.logic2vampire

-Bundle-SymbolicName: ca.mcgill.ecse.dslreasoner.trace.logic2vampire; singleton:=true

-Bundle-Version: 0.1.0.qualifier

-Require-Bundle: org.eclipse.emf.ecore;visibility:=reexport,

- org.eclipse.core.runtime

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/model/logic2vampire.aird b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/model/logic2vampire.aird
deleted file mode 100644
index 4fda4ff6..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/model/logic2vampire.aird
+++ /dev/null
@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>

-<xmi:XMI xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:description="http://www.eclipse.org/sirius/description/1.1.0" xmlns:description_1="http://www.eclipse.org/sirius/diagram/description/1.1.0" xmlns:diagram="http://www.eclipse.org/sirius/diagram/1.1.0" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" xmlns:notation="http://www.eclipse.org/gmf/runtime/1.0.2/notation" xmlns:viewpoint="http://www.eclipse.org/sirius/1.1.0" xsi:schemaLocation="http://www.eclipse.org/sirius/description/1.1.0 http://www.eclipse.org/sirius/1.1.0#//description http://www.eclipse.org/sirius/diagram/description/1.1.0 http://www.eclipse.org/sirius/diagram/1.1.0#//description">

-  <viewpoint:DAnalysis xmi:id="_c5vPUBjhEemoVuGVD8l-rg" selectedViews="_c-elYBjhEemoVuGVD8l-rg" version="12.0.0.201704271200">

-    <semanticResources>logic2vampire.ecore</semanticResources>

-    <semanticResources>logic2vampire.genmodel</semanticResources>

-    <ownedViews xmi:type="viewpoint:DView" xmi:id="_c-elYBjhEemoVuGVD8l-rg">

-      <viewpoint xmi:type="description:Viewpoint" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']"/>

-      <ownedRepresentationDescriptors xmi:type="viewpoint:DRepresentationDescriptor" xmi:id="_dEOBABjhEemoVuGVD8l-rg" name="logic2vampire" repPath="#_dEIhcBjhEemoVuGVD8l-rg">

-        <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>

-        <target xmi:type="ecore:EPackage" href="logic2vampire.ecore#/"/>

-      </ownedRepresentationDescriptors>

-    </ownedViews>

-  </viewpoint:DAnalysis>

-  <diagram:DSemanticDiagram xmi:id="_dEIhcBjhEemoVuGVD8l-rg" name="logic2vampire">

-    <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_dEIhcRjhEemoVuGVD8l-rg" source="DANNOTATION_CUSTOMIZATION_KEY">

-      <data xmi:type="diagram:ComputedStyleDescriptionRegistry" xmi:id="_dEIhchjhEemoVuGVD8l-rg"/>

-    </ownedAnnotationEntries>

-    <ownedAnnotationEntries xmi:type="description:AnnotationEntry" xmi:id="_dFEVkBjhEemoVuGVD8l-rg" source="GMF_DIAGRAMS">

-      <data xmi:type="notation:Diagram" xmi:id="_dFEVkRjhEemoVuGVD8l-rg" type="Sirius" element="_dEIhcBjhEemoVuGVD8l-rg" measurementUnit="Pixel">

-        <styles xmi:type="notation:DiagramStyle" xmi:id="_dFEVkhjhEemoVuGVD8l-rg"/>

-      </data>

-    </ownedAnnotationEntries>

-    <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>

-    <filterVariableHistory xmi:type="diagram:FilterVariableHistory" xmi:id="_dEIhdBjhEemoVuGVD8l-rg"/>

-    <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>

-    <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>

-    <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>

-    <target xmi:type="ecore:EPackage" href="logic2vampire.ecore#/"/>

-  </diagram:DSemanticDiagram>

-</xmi:XMI>

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/model/logic2vampire.ecore b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/model/logic2vampire.ecore
deleted file mode 100644
index 0cdf6d7f..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/model/logic2vampire.ecore
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>

-<ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"

-    name="logic2vampire" nsURI="http://www.example.org/logic2vampire"

-    nsPrefix="logic2vampire"/>

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/model/logic2vampire.genmodel b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/model/logic2vampire.genmodel
deleted file mode 100644
index 32de743d..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/model/logic2vampire.genmodel
+++ /dev/null
@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>

-<genmodel:GenModel xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

-    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" modelDirectory="/ca.mcgill.ecse.dslreasoner.trace.logic2vampire/src-gen"

-    creationIcons="false" editDirectory="/ca.mcgill.ecse.dslreasoner.trace.logic2vampire.edit/src-gen"

-    editorDirectory="/ca.mcgill.ecse.dslreasoner.trace.logic2vampire.editor/src-gen"

-    modelPluginID="ca.mcgill.ecse.dslreasoner.trace.logic2vampire" modelName="Logic2vampire"

-    rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container" codeFormatting="true"

-    importerID="org.eclipse.emf.importer.ecore" complianceLevel="8.0" copyrightFields="false"

-    operationReflection="true" importOrganizing="true">

-  <foreignModel>logic2vampire.ecore</foreignModel>

-  <testsDirectory xsi:nil="true"/>

-  <genPackages prefix="Logic2vampire" basePackage="ca.mcgill.ecse.dslreasoner.trace"

-      disposableProviderFactory="true" ecorePackage="logic2vampire.ecore#/"/>

-</genmodel:GenModel>

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ide/xtend-gen/ca/mcgill/ecse/dslreasoner/ide/.VampireLanguageIdeModule.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ide/xtend-gen/ca/mcgill/ecse/dslreasoner/ide/.VampireLanguageIdeModule.xtendbin
index 035b992e..416a4ced 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ide/xtend-gen/ca/mcgill/ecse/dslreasoner/ide/.VampireLanguageIdeModule.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ide/xtend-gen/ca/mcgill/ecse/dslreasoner/ide/.VampireLanguageIdeModule.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ide/xtend-gen/ca/mcgill/ecse/dslreasoner/ide/.VampireLanguageIdeSetup.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ide/xtend-gen/ca/mcgill/ecse/dslreasoner/ide/.VampireLanguageIdeSetup.xtendbin
index 3a2b0f09..4c3a5366 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ide/xtend-gen/ca/mcgill/ecse/dslreasoner/ide/.VampireLanguageIdeSetup.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ide/xtend-gen/ca/mcgill/ecse/dslreasoner/ide/.VampireLanguageIdeSetup.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/.VampireLanguageUiModule.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/.VampireLanguageUiModule.xtendbin
index b8a39035..b9e07a68 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/.VampireLanguageUiModule.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/.VampireLanguageUiModule.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/contentassist/.VampireLanguageProposalProvider.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/contentassist/.VampireLanguageProposalProvider.xtendbin
index c462e145..f51dce03 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/contentassist/.VampireLanguageProposalProvider.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/contentassist/.VampireLanguageProposalProvider.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/labeling/.VampireLanguageDescriptionLabelProvider.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/labeling/.VampireLanguageDescriptionLabelProvider.xtendbin
index 2d3b2709..23bdd607 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/labeling/.VampireLanguageDescriptionLabelProvider.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/labeling/.VampireLanguageDescriptionLabelProvider.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/labeling/.VampireLanguageLabelProvider.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/labeling/.VampireLanguageLabelProvider.xtendbin
index 8640966e..438765b1 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/labeling/.VampireLanguageLabelProvider.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/labeling/.VampireLanguageLabelProvider.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/outline/.VampireLanguageOutlineTreeProvider.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/outline/.VampireLanguageOutlineTreeProvider.xtendbin
index 183e5e40..fb05770c 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/outline/.VampireLanguageOutlineTreeProvider.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/outline/.VampireLanguageOutlineTreeProvider.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/quickfix/.VampireLanguageQuickfixProvider.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/quickfix/.VampireLanguageQuickfixProvider.xtendbin
index 7c2fb4bf..1626ed6c 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/quickfix/.VampireLanguageQuickfixProvider.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language.ui/xtend-gen/ca/mcgill/ecse/dslreasoner/ui/quickfix/.VampireLanguageQuickfixProvider.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/VLSFiniteModel.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/VLSFiniteModel.java
deleted file mode 100644
index bfd23d8d..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/VLSFiniteModel.java
+++ /dev/null
@@ -1,20 +0,0 @@
-/**

- * generated by Xtext 2.12.0

- */

-package ca.mcgill.ecse.dslreasoner.vampireLanguage;

-

-import org.eclipse.emf.ecore.EObject;

-

-/**

- * <!-- begin-user-doc -->

- * A representation of the model object '<em><b>VLS Finite Model</b></em>'.

- * <!-- end-user-doc -->

- *

- *

- * @see ca.mcgill.ecse.dslreasoner.vampireLanguage.VampireLanguagePackage#getVLSFiniteModel()

- * @model

- * @generated

- */

-public interface VLSFiniteModel extends EObject

-{

-} // VLSFiniteModel

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/VLSFunctionFof.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/VLSFunctionFof.java
deleted file mode 100644
index d151685f..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/VLSFunctionFof.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/**

- * generated by Xtext 2.12.0

- */

-package ca.mcgill.ecse.dslreasoner.vampireLanguage;

-

-import org.eclipse.emf.common.util.EList;

-

-/**

- * <!-- begin-user-doc -->

- * A representation of the model object '<em><b>VLS Function Fof</b></em>'.

- * <!-- end-user-doc -->

- *

- * <p>

- * The following features are supported:

- * </p>

- * <ul>

- *   <li>{@link ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof#getFunctor <em>Functor</em>}</li>

- *   <li>{@link ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof#getTerms <em>Terms</em>}</li>

- * </ul>

- *

- * @see ca.mcgill.ecse.dslreasoner.vampireLanguage.VampireLanguagePackage#getVLSFunctionFof()

- * @model

- * @generated

- */

-public interface VLSFunctionFof extends VLSTerm

-{

-  /**

-   * Returns the value of the '<em><b>Functor</b></em>' attribute.

-   * <!-- begin-user-doc -->

-   * <p>

-   * If the meaning of the '<em>Functor</em>' attribute isn't clear,

-   * there really should be more of a description here...

-   * </p>

-   * <!-- end-user-doc -->

-   * @return the value of the '<em>Functor</em>' attribute.

-   * @see #setFunctor(String)

-   * @see ca.mcgill.ecse.dslreasoner.vampireLanguage.VampireLanguagePackage#getVLSFunctionFof_Functor()

-   * @model

-   * @generated

-   */

-  String getFunctor();

-

-  /**

-   * Sets the value of the '{@link ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof#getFunctor <em>Functor</em>}' attribute.

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @param value the new value of the '<em>Functor</em>' attribute.

-   * @see #getFunctor()

-   * @generated

-   */

-  void setFunctor(String value);

-

-  /**

-   * Returns the value of the '<em><b>Terms</b></em>' containment reference list.

-   * The list contents are of type {@link ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSTerm}.

-   * <!-- begin-user-doc -->

-   * <p>

-   * If the meaning of the '<em>Terms</em>' containment reference list isn't clear,

-   * there really should be more of a description here...

-   * </p>

-   * <!-- end-user-doc -->

-   * @return the value of the '<em>Terms</em>' containment reference list.

-   * @see ca.mcgill.ecse.dslreasoner.vampireLanguage.VampireLanguagePackage#getVLSFunctionFof_Terms()

-   * @model containment="true"

-   * @generated

-   */

-  EList<VLSTerm> getTerms();

-

-} // VLSFunctionFof

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/VLSTrying.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/VLSTrying.java
deleted file mode 100644
index c2080a9c..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/VLSTrying.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/**

- * generated by Xtext 2.12.0

- */

-package ca.mcgill.ecse.dslreasoner.vampireLanguage;

-

-import org.eclipse.emf.ecore.EObject;

-

-/**

- * <!-- begin-user-doc -->

- * A representation of the model object '<em><b>VLS Trying</b></em>'.

- * <!-- end-user-doc -->

- *

- * <p>

- * The following features are supported:

- * </p>

- * <ul>

- *   <li>{@link ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSTrying#getName <em>Name</em>}</li>

- * </ul>

- *

- * @see ca.mcgill.ecse.dslreasoner.vampireLanguage.VampireLanguagePackage#getVLSTrying()

- * @model

- * @generated

- */

-public interface VLSTrying extends EObject

-{

-  /**

-   * Returns the value of the '<em><b>Name</b></em>' attribute.

-   * <!-- begin-user-doc -->

-   * <p>

-   * If the meaning of the '<em>Name</em>' attribute isn't clear,

-   * there really should be more of a description here...

-   * </p>

-   * <!-- end-user-doc -->

-   * @return the value of the '<em>Name</em>' attribute.

-   * @see #setName(String)

-   * @see ca.mcgill.ecse.dslreasoner.vampireLanguage.VampireLanguagePackage#getVLSTrying_Name()

-   * @model

-   * @generated

-   */

-  String getName();

-

-  /**

-   * Sets the value of the '{@link ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSTrying#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);

-

-} // VLSTrying

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/impl/VLSFiniteModelImpl.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/impl/VLSFiniteModelImpl.java
deleted file mode 100644
index dfbbf6ed..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/impl/VLSFiniteModelImpl.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/**

- * generated by Xtext 2.12.0

- */

-package ca.mcgill.ecse.dslreasoner.vampireLanguage.impl;

-

-import ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFiniteModel;

-import ca.mcgill.ecse.dslreasoner.vampireLanguage.VampireLanguagePackage;

-

-import org.eclipse.emf.ecore.EClass;

-

-import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;

-

-/**

- * <!-- begin-user-doc -->

- * An implementation of the model object '<em><b>VLS Finite Model</b></em>'.

- * <!-- end-user-doc -->

- *

- * @generated

- */

-public class VLSFiniteModelImpl extends MinimalEObjectImpl.Container implements VLSFiniteModel

-{

-  /**

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @generated

-   */

-  protected VLSFiniteModelImpl()

-  {

-    super();

-  }

-

-  /**

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @generated

-   */

-  @Override

-  protected EClass eStaticClass()

-  {

-    return VampireLanguagePackage.Literals.VLS_FINITE_MODEL;

-  }

-

-} //VLSFiniteModelImpl

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/impl/VLSFunctionFofImpl.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/impl/VLSFunctionFofImpl.java
deleted file mode 100644
index 6d1c538b..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/impl/VLSFunctionFofImpl.java
+++ /dev/null
@@ -1,240 +0,0 @@
-/**

- * generated by Xtext 2.12.0

- */

-package ca.mcgill.ecse.dslreasoner.vampireLanguage.impl;

-

-import ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof;

-import ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSTerm;

-import ca.mcgill.ecse.dslreasoner.vampireLanguage.VampireLanguagePackage;

-

-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;

-

-/**

- * <!-- begin-user-doc -->

- * An implementation of the model object '<em><b>VLS Function Fof</b></em>'.

- * <!-- end-user-doc -->

- * <p>

- * The following features are implemented:

- * </p>

- * <ul>

- *   <li>{@link ca.mcgill.ecse.dslreasoner.vampireLanguage.impl.VLSFunctionFofImpl#getFunctor <em>Functor</em>}</li>

- *   <li>{@link ca.mcgill.ecse.dslreasoner.vampireLanguage.impl.VLSFunctionFofImpl#getTerms <em>Terms</em>}</li>

- * </ul>

- *

- * @generated

- */

-public class VLSFunctionFofImpl extends VLSTermImpl implements VLSFunctionFof

-{

-  /**

-   * The default value of the '{@link #getFunctor() <em>Functor</em>}' attribute.

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @see #getFunctor()

-   * @generated

-   * @ordered

-   */

-  protected static final String FUNCTOR_EDEFAULT = null;

-

-  /**

-   * The cached value of the '{@link #getFunctor() <em>Functor</em>}' attribute.

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @see #getFunctor()

-   * @generated

-   * @ordered

-   */

-  protected String functor = FUNCTOR_EDEFAULT;

-

-  /**

-   * The cached value of the '{@link #getTerms() <em>Terms</em>}' containment reference list.

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @see #getTerms()

-   * @generated

-   * @ordered

-   */

-  protected EList<VLSTerm> terms;

-

-  /**

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @generated

-   */

-  protected VLSFunctionFofImpl()

-  {

-    super();

-  }

-

-  /**

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @generated

-   */

-  @Override

-  protected EClass eStaticClass()

-  {

-    return VampireLanguagePackage.Literals.VLS_FUNCTION_FOF;

-  }

-

-  /**

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @generated

-   */

-  public String getFunctor()

-  {

-    return functor;

-  }

-

-  /**

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @generated

-   */

-  public void setFunctor(String newFunctor)

-  {

-    String oldFunctor = functor;

-    functor = newFunctor;

-    if (eNotificationRequired())

-      eNotify(new ENotificationImpl(this, Notification.SET, VampireLanguagePackage.VLS_FUNCTION_FOF__FUNCTOR, oldFunctor, functor));

-  }

-

-  /**

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @generated

-   */

-  public EList<VLSTerm> getTerms()

-  {

-    if (terms == null)

-    {

-      terms = new EObjectContainmentEList<VLSTerm>(VLSTerm.class, this, VampireLanguagePackage.VLS_FUNCTION_FOF__TERMS);

-    }

-    return terms;

-  }

-

-  /**

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @generated

-   */

-  @Override

-  public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)

-  {

-    switch (featureID)

-    {

-      case VampireLanguagePackage.VLS_FUNCTION_FOF__TERMS:

-        return ((InternalEList<?>)getTerms()).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 VampireLanguagePackage.VLS_FUNCTION_FOF__FUNCTOR:

-        return getFunctor();

-      case VampireLanguagePackage.VLS_FUNCTION_FOF__TERMS:

-        return getTerms();

-    }

-    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 VampireLanguagePackage.VLS_FUNCTION_FOF__FUNCTOR:

-        setFunctor((String)newValue);

-        return;

-      case VampireLanguagePackage.VLS_FUNCTION_FOF__TERMS:

-        getTerms().clear();

-        getTerms().addAll((Collection<? extends VLSTerm>)newValue);

-        return;

-    }

-    super.eSet(featureID, newValue);

-  }

-

-  /**

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @generated

-   */

-  @Override

-  public void eUnset(int featureID)

-  {

-    switch (featureID)

-    {

-      case VampireLanguagePackage.VLS_FUNCTION_FOF__FUNCTOR:

-        setFunctor(FUNCTOR_EDEFAULT);

-        return;

-      case VampireLanguagePackage.VLS_FUNCTION_FOF__TERMS:

-        getTerms().clear();

-        return;

-    }

-    super.eUnset(featureID);

-  }

-

-  /**

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @generated

-   */

-  @Override

-  public boolean eIsSet(int featureID)

-  {

-    switch (featureID)

-    {

-      case VampireLanguagePackage.VLS_FUNCTION_FOF__FUNCTOR:

-        return FUNCTOR_EDEFAULT == null ? functor != null : !FUNCTOR_EDEFAULT.equals(functor);

-      case VampireLanguagePackage.VLS_FUNCTION_FOF__TERMS:

-        return terms != null && !terms.isEmpty();

-    }

-    return super.eIsSet(featureID);

-  }

-

-  /**

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @generated

-   */

-  @Override

-  public String toString()

-  {

-    if (eIsProxy()) return super.toString();

-

-    StringBuffer result = new StringBuffer(super.toString());

-    result.append(" (functor: ");

-    result.append(functor);

-    result.append(')');

-    return result.toString();

-  }

-

-} //VLSFunctionFofImpl

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/impl/VLSTryingImpl.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/impl/VLSTryingImpl.java
deleted file mode 100644
index 40e62d9e..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/src-gen/ca/mcgill/ecse/dslreasoner/vampireLanguage/impl/VLSTryingImpl.java
+++ /dev/null
@@ -1,178 +0,0 @@
-/**

- * generated by Xtext 2.12.0

- */

-package ca.mcgill.ecse.dslreasoner.vampireLanguage.impl;

-

-import ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSTrying;

-import ca.mcgill.ecse.dslreasoner.vampireLanguage.VampireLanguagePackage;

-

-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;

-

-/**

- * <!-- begin-user-doc -->

- * An implementation of the model object '<em><b>VLS Trying</b></em>'.

- * <!-- end-user-doc -->

- * <p>

- * The following features are implemented:

- * </p>

- * <ul>

- *   <li>{@link ca.mcgill.ecse.dslreasoner.vampireLanguage.impl.VLSTryingImpl#getName <em>Name</em>}</li>

- * </ul>

- *

- * @generated

- */

-public class VLSTryingImpl extends MinimalEObjectImpl.Container implements VLSTrying

-{

-  /**

-   * 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 VLSTryingImpl()

-  {

-    super();

-  }

-

-  /**

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @generated

-   */

-  @Override

-  protected EClass eStaticClass()

-  {

-    return VampireLanguagePackage.Literals.VLS_TRYING;

-  }

-

-  /**

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @generated

-   */

-  public String getName()

-  {

-    return name;

-  }

-

-  /**

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @generated

-   */

-  public void setName(String newName)

-  {

-    String oldName = name;

-    name = newName;

-    if (eNotificationRequired())

-      eNotify(new ENotificationImpl(this, Notification.SET, VampireLanguagePackage.VLS_TRYING__NAME, oldName, name));

-  }

-

-  /**

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @generated

-   */

-  @Override

-  public Object eGet(int featureID, boolean resolve, boolean coreType)

-  {

-    switch (featureID)

-    {

-      case VampireLanguagePackage.VLS_TRYING__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 VampireLanguagePackage.VLS_TRYING__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 VampireLanguagePackage.VLS_TRYING__NAME:

-        setName(NAME_EDEFAULT);

-        return;

-    }

-    super.eUnset(featureID);

-  }

-

-  /**

-   * <!-- begin-user-doc -->

-   * <!-- end-user-doc -->

-   * @generated

-   */

-  @Override

-  public boolean eIsSet(int featureID)

-  {

-    switch (featureID)

-    {

-      case VampireLanguagePackage.VLS_TRYING__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();

-

-    StringBuffer result = new StringBuffer(super.toString());

-    result.append(" (name: ");

-    result.append(name);

-    result.append(')');

-    return result.toString();

-  }

-

-} //VLSTryingImpl

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/.VampireLanguageRuntimeModule.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/.VampireLanguageRuntimeModule.xtendbin
index 415d0cc9..c38505ea 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/.VampireLanguageRuntimeModule.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/.VampireLanguageRuntimeModule.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/.VampireLanguageStandaloneSetup.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/.VampireLanguageStandaloneSetup.xtendbin
index 9d43d4a1..3ab52ff6 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/.VampireLanguageStandaloneSetup.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/.VampireLanguageStandaloneSetup.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/formatting2/.VampireLanguageFormatter.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/formatting2/.VampireLanguageFormatter.xtendbin
index d3a5a764..e845ff1e 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/formatting2/.VampireLanguageFormatter.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/formatting2/.VampireLanguageFormatter.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/generator/.VampireLanguageGenerator.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/generator/.VampireLanguageGenerator.xtendbin
index dd4b1eaa..d45af918 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/generator/.VampireLanguageGenerator.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/generator/.VampireLanguageGenerator.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/scoping/.VampireLanguageScopeProvider.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/scoping/.VampireLanguageScopeProvider.xtendbin
index a3a95c68..cc9d50ce 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/scoping/.VampireLanguageScopeProvider.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/scoping/.VampireLanguageScopeProvider.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/validation/.VampireLanguageValidator.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/validation/.VampireLanguageValidator.xtendbin
index 88c7412c..0418e131 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/validation/.VampireLanguageValidator.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.language/xtend-gen/ca/mcgill/ecse/dslreasoner/validation/.VampireLanguageValidator.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/.gitignore b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/.gitignore
index ae3c1726..39fc9cc5 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/.gitignore
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/.gitignore
@@ -1 +1,2 @@
 /bin/
+/src-gen/
\ No newline at end of file
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSAnd.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSAnd.java
deleted file mode 100644
index 23d9293f..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSAnd.java
+++ /dev/null
@@ -1,533 +0,0 @@
-/**

- * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.queries/src/ca/mcgill/ecse/dslreasoner/vampire/queries/vampireQueries.vql

- */

-package ca.mcgill.ecse.dslreasoner.vampire.queries;

-

-import java.util.Arrays;

-import java.util.Collection;

-import java.util.LinkedHashSet;

-import java.util.List;

-import java.util.Objects;

-import java.util.Optional;

-import java.util.Set;

-import java.util.function.Consumer;

-import java.util.stream.Collectors;

-import java.util.stream.Stream;

-import org.apache.log4j.Logger;

-import org.eclipse.emf.ecore.EClass;

-import org.eclipse.viatra.query.runtime.api.IPatternMatch;

-import org.eclipse.viatra.query.runtime.api.IQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;

-import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;

-import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;

-import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;

-import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;

-

-/**

- * A pattern-specific query specification that can instantiate Matcher in a type-safe way.

- * 

- * <p>Original source:

- *         <code><pre>

- *         pattern VLSAnd(term: VLSAnd){

- *              VLSAnd(term);

- *         }

- * </pre></code>

- * 

- * @see Matcher

- * @see Match

- * 

- */

-@SuppressWarnings("all")

-public final class VLSAnd extends BaseGeneratedEMFQuerySpecification<VLSAnd.Matcher> {

-  /**

-   * Pattern-specific match representation of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnd pattern,

-   * to be used in conjunction with {@link Matcher}.

-   * 

-   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

-   * Each instance is a (possibly partial) substitution of pattern parameters,

-   * usable to represent a match of the pattern in the result of a query,

-   * or to specify the bound (fixed) input parameters when issuing a query.

-   * 

-   * @see Matcher

-   * 

-   */

-  public static abstract class Match extends BasePatternMatch {

-    private ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd fTerm;

-    

-    private static List<String> parameterNames = makeImmutableList("term");

-    

-    private Match(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd pTerm) {

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public Object get(final String parameterName) {

-      if ("term".equals(parameterName)) return this.fTerm;

-      return null;

-    }

-    

-    public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd getTerm() {

-      return this.fTerm;

-    }

-    

-    @Override

-    public boolean set(final String parameterName, final Object newValue) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      if ("term".equals(parameterName) ) {

-          this.fTerm = (ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd) newValue;

-          return true;

-      }

-      return false;

-    }

-    

-    public void setTerm(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd pTerm) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public String patternName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnd";

-    }

-    

-    @Override

-    public List<String> parameterNames() {

-      return VLSAnd.Match.parameterNames;

-    }

-    

-    @Override

-    public Object[] toArray() {

-      return new Object[]{fTerm};

-    }

-    

-    @Override

-    public VLSAnd.Match toImmutable() {

-      return isMutable() ? newMatch(fTerm) : this;

-    }

-    

-    @Override

-    public String prettyPrint() {

-      StringBuilder result = new StringBuilder();

-      result.append("\"term\"=" + prettyPrintValue(fTerm));

-      return result.toString();

-    }

-    

-    @Override

-    public int hashCode() {

-      return Objects.hash(fTerm);

-    }

-    

-    @Override

-    public boolean equals(final Object obj) {

-      if (this == obj)

-          return true;

-      if (obj == null) {

-          return false;

-      }

-      if ((obj instanceof VLSAnd.Match)) {

-          VLSAnd.Match other = (VLSAnd.Match) obj;

-          return Objects.equals(fTerm, other.fTerm);

-      } else {

-          // this should be infrequent

-          if (!(obj instanceof IPatternMatch)) {

-              return false;

-          }

-          IPatternMatch otherSig  = (IPatternMatch) obj;

-          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());

-      }

-    }

-    

-    @Override

-    public VLSAnd specification() {

-      return VLSAnd.instance();

-    }

-    

-    /**

-     * Returns an empty, mutable match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @return the empty match.

-     * 

-     */

-    public static VLSAnd.Match newEmptyMatch() {

-      return new Mutable(null);

-    }

-    

-    /**

-     * Returns a mutable (partial) match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the new, mutable (partial) match object.

-     * 

-     */

-    public static VLSAnd.Match newMutableMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd pTerm) {

-      return new Mutable(pTerm);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public static VLSAnd.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd pTerm) {

-      return new Immutable(pTerm);

-    }

-    

-    private static final class Mutable extends VLSAnd.Match {

-      Mutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return true;

-      }

-    }

-    

-    private static final class Immutable extends VLSAnd.Match {

-      Immutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return false;

-      }

-    }

-  }

-  

-  /**

-   * Generated pattern matcher API of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnd pattern,

-   * providing pattern-specific query methods.

-   * 

-   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

-   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.

-   * 

-   * <p>Matches of the pattern will be represented as {@link Match}.

-   * 

-   * <p>Original source:

-   * <code><pre>

-   * pattern VLSAnd(term: VLSAnd){

-   *    VLSAnd(term);

-   * }

-   * </pre></code>

-   * 

-   * @see Match

-   * @see VLSAnd

-   * 

-   */

-  public static class Matcher extends BaseMatcher<VLSAnd.Match> {

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    public static VLSAnd.Matcher on(final ViatraQueryEngine engine) {

-      // check if matcher already exists

-      Matcher matcher = engine.getExistingMatcher(querySpecification());

-      if (matcher == null) {

-          matcher = (Matcher)engine.getMatcher(querySpecification());

-      }

-      return matcher;

-    }

-    

-    /**

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * @return an initialized matcher

-     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

-     * 

-     */

-    public static VLSAnd.Matcher create() {

-      return new Matcher();

-    }

-    

-    private final static int POSITION_TERM = 0;

-    

-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSAnd.Matcher.class);

-    

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    private Matcher() {

-      super(querySpecification());

-    }

-    

-    /**

-     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return matches represented as a Match object.

-     * 

-     */

-    public Collection<VLSAnd.Match> getAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm}).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.

-     * </p>

-     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

-     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

-     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a stream of matches represented as a Match object.

-     * 

-     */

-    public Stream<VLSAnd.Match> streamAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a match represented as a Match object, or null if no match is found.

-     * 

-     */

-    public Optional<VLSAnd.Match> getOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd pTerm) {

-      return rawGetOneArbitraryMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

-     * under any possible substitution of the unspecified parameters (if any).

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return true if the input is a valid (partial) match of the pattern.

-     * 

-     */

-    public boolean hasMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd pTerm) {

-      return rawHasMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the number of pattern matches found.

-     * 

-     */

-    public int countMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd pTerm) {

-      return rawCountMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @param processor the action that will process the selected match.

-     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

-     * 

-     */

-    public boolean forOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd pTerm, final Consumer<? super VLSAnd.Match> processor) {

-      return rawForOneArbitraryMatch(new Object[]{pTerm}, processor);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public VLSAnd.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd pTerm) {

-      return VLSAnd.Match.newMatch(pTerm);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    protected Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd> rawStreamAllValuesOfterm(final Object[] parameters) {

-      return rawStreamAllValues(POSITION_TERM, parameters).map(ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd.class::cast);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Set<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd> getAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray()).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd> streamAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray());

-    }

-    

-    @Override

-    protected VLSAnd.Match tupleToMatch(final Tuple t) {

-      try {

-          return VLSAnd.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd) t.get(POSITION_TERM));

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in tuple not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSAnd.Match arrayToMatch(final Object[] match) {

-      try {

-          return VLSAnd.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSAnd.Match arrayToMatchMutable(final Object[] match) {

-      try {

-          return VLSAnd.Match.newMutableMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    /**

-     * @return the singleton instance of the query specification of this pattern

-     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-     * 

-     */

-    public static IQuerySpecification<VLSAnd.Matcher> querySpecification() {

-      return VLSAnd.instance();

-    }

-  }

-  

-  private VLSAnd() {

-    super(GeneratedPQuery.INSTANCE);

-  }

-  

-  /**

-   * @return the singleton instance of the query specification

-   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-   * 

-   */

-  public static VLSAnd instance() {

-    try{

-        return LazyHolder.INSTANCE;

-    } catch (ExceptionInInitializerError err) {

-        throw processInitializerError(err);

-    }

-  }

-  

-  @Override

-  protected VLSAnd.Matcher instantiate(final ViatraQueryEngine engine) {

-    return VLSAnd.Matcher.on(engine);

-  }

-  

-  @Override

-  public VLSAnd.Matcher instantiate() {

-    return VLSAnd.Matcher.create();

-  }

-  

-  @Override

-  public VLSAnd.Match newEmptyMatch() {

-    return VLSAnd.Match.newEmptyMatch();

-  }

-  

-  @Override

-  public VLSAnd.Match newMatch(final Object... parameters) {

-    return VLSAnd.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd) parameters[0]);

-  }

-  

-  /**

-   * Inner class allowing the singleton instance of {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnd (visibility: PUBLIC, simpleName: VLSAnd, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnd, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

-   *     <b>not</b> at the class load time of the outer class, 

-   *     but rather at the first call to {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnd (visibility: PUBLIC, simpleName: VLSAnd, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnd, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

-   * 

-   * <p> This workaround is required e.g. to support recursion.

-   * 

-   */

-  private static class LazyHolder {

-    private final static VLSAnd INSTANCE = new VLSAnd();

-    

-    /**

-     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

-     * This initialization order is required to support indirect recursion.

-     * 

-     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.

-     * 

-     */

-    private final static Object STATIC_INITIALIZER = ensureInitialized();

-    

-    public static Object ensureInitialized() {

-      INSTANCE.ensureInitializedInternal();

-      return null;

-    }

-  }

-  

-  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

-    private final static VLSAnd.GeneratedPQuery INSTANCE = new GeneratedPQuery();

-    

-    private final PParameter parameter_term = new PParameter("term", "ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSAnd")), PParameterDirection.INOUT);

-    

-    private final List<PParameter> parameters = Arrays.asList(parameter_term);

-    

-    private GeneratedPQuery() {

-      super(PVisibility.PUBLIC);

-    }

-    

-    @Override

-    public String getFullyQualifiedName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnd";

-    }

-    

-    @Override

-    public List<String> getParameterNames() {

-      return Arrays.asList("term");

-    }

-    

-    @Override

-    public List<PParameter> getParameters() {

-      return parameters;

-    }

-    

-    @Override

-    public Set<PBody> doGetContainedBodies() {

-      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));

-      Set<PBody> bodies = new LinkedHashSet<>();

-      {

-          PBody body = new PBody(this);

-          PVariable var_term = body.getOrCreateVariableByName("term");

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSAnd")));

-          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

-             new ExportedParameter(body, var_term, parameter_term)

-          ));

-          //    VLSAnd(term)

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSAnd")));

-          bodies.add(body);

-      }

-      return bodies;

-    }

-  }

-}

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSAnnotation.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSAnnotation.java
deleted file mode 100644
index 282d813f..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSAnnotation.java
+++ /dev/null
@@ -1,533 +0,0 @@
-/**

- * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.queries/src/ca/mcgill/ecse/dslreasoner/vampire/queries/vampireQueries.vql

- */

-package ca.mcgill.ecse.dslreasoner.vampire.queries;

-

-import java.util.Arrays;

-import java.util.Collection;

-import java.util.LinkedHashSet;

-import java.util.List;

-import java.util.Objects;

-import java.util.Optional;

-import java.util.Set;

-import java.util.function.Consumer;

-import java.util.stream.Collectors;

-import java.util.stream.Stream;

-import org.apache.log4j.Logger;

-import org.eclipse.emf.ecore.EClass;

-import org.eclipse.viatra.query.runtime.api.IPatternMatch;

-import org.eclipse.viatra.query.runtime.api.IQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;

-import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;

-import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;

-import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;

-import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;

-

-/**

- * A pattern-specific query specification that can instantiate Matcher in a type-safe way.

- * 

- * <p>Original source:

- *         <code><pre>

- *         pattern VLSAnnotation(term: VLSAnnotation){

- *              VLSAnnotation(term);

- *         }

- * </pre></code>

- * 

- * @see Matcher

- * @see Match

- * 

- */

-@SuppressWarnings("all")

-public final class VLSAnnotation extends BaseGeneratedEMFQuerySpecification<VLSAnnotation.Matcher> {

-  /**

-   * Pattern-specific match representation of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnnotation pattern,

-   * to be used in conjunction with {@link Matcher}.

-   * 

-   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

-   * Each instance is a (possibly partial) substitution of pattern parameters,

-   * usable to represent a match of the pattern in the result of a query,

-   * or to specify the bound (fixed) input parameters when issuing a query.

-   * 

-   * @see Matcher

-   * 

-   */

-  public static abstract class Match extends BasePatternMatch {

-    private ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation fTerm;

-    

-    private static List<String> parameterNames = makeImmutableList("term");

-    

-    private Match(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation pTerm) {

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public Object get(final String parameterName) {

-      if ("term".equals(parameterName)) return this.fTerm;

-      return null;

-    }

-    

-    public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation getTerm() {

-      return this.fTerm;

-    }

-    

-    @Override

-    public boolean set(final String parameterName, final Object newValue) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      if ("term".equals(parameterName) ) {

-          this.fTerm = (ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation) newValue;

-          return true;

-      }

-      return false;

-    }

-    

-    public void setTerm(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation pTerm) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public String patternName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnnotation";

-    }

-    

-    @Override

-    public List<String> parameterNames() {

-      return VLSAnnotation.Match.parameterNames;

-    }

-    

-    @Override

-    public Object[] toArray() {

-      return new Object[]{fTerm};

-    }

-    

-    @Override

-    public VLSAnnotation.Match toImmutable() {

-      return isMutable() ? newMatch(fTerm) : this;

-    }

-    

-    @Override

-    public String prettyPrint() {

-      StringBuilder result = new StringBuilder();

-      result.append("\"term\"=" + prettyPrintValue(fTerm));

-      return result.toString();

-    }

-    

-    @Override

-    public int hashCode() {

-      return Objects.hash(fTerm);

-    }

-    

-    @Override

-    public boolean equals(final Object obj) {

-      if (this == obj)

-          return true;

-      if (obj == null) {

-          return false;

-      }

-      if ((obj instanceof VLSAnnotation.Match)) {

-          VLSAnnotation.Match other = (VLSAnnotation.Match) obj;

-          return Objects.equals(fTerm, other.fTerm);

-      } else {

-          // this should be infrequent

-          if (!(obj instanceof IPatternMatch)) {

-              return false;

-          }

-          IPatternMatch otherSig  = (IPatternMatch) obj;

-          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());

-      }

-    }

-    

-    @Override

-    public VLSAnnotation specification() {

-      return VLSAnnotation.instance();

-    }

-    

-    /**

-     * Returns an empty, mutable match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @return the empty match.

-     * 

-     */

-    public static VLSAnnotation.Match newEmptyMatch() {

-      return new Mutable(null);

-    }

-    

-    /**

-     * Returns a mutable (partial) match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the new, mutable (partial) match object.

-     * 

-     */

-    public static VLSAnnotation.Match newMutableMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation pTerm) {

-      return new Mutable(pTerm);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public static VLSAnnotation.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation pTerm) {

-      return new Immutable(pTerm);

-    }

-    

-    private static final class Mutable extends VLSAnnotation.Match {

-      Mutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return true;

-      }

-    }

-    

-    private static final class Immutable extends VLSAnnotation.Match {

-      Immutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return false;

-      }

-    }

-  }

-  

-  /**

-   * Generated pattern matcher API of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnnotation pattern,

-   * providing pattern-specific query methods.

-   * 

-   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

-   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.

-   * 

-   * <p>Matches of the pattern will be represented as {@link Match}.

-   * 

-   * <p>Original source:

-   * <code><pre>

-   * pattern VLSAnnotation(term: VLSAnnotation){

-   *    VLSAnnotation(term);

-   * }

-   * </pre></code>

-   * 

-   * @see Match

-   * @see VLSAnnotation

-   * 

-   */

-  public static class Matcher extends BaseMatcher<VLSAnnotation.Match> {

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    public static VLSAnnotation.Matcher on(final ViatraQueryEngine engine) {

-      // check if matcher already exists

-      Matcher matcher = engine.getExistingMatcher(querySpecification());

-      if (matcher == null) {

-          matcher = (Matcher)engine.getMatcher(querySpecification());

-      }

-      return matcher;

-    }

-    

-    /**

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * @return an initialized matcher

-     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

-     * 

-     */

-    public static VLSAnnotation.Matcher create() {

-      return new Matcher();

-    }

-    

-    private final static int POSITION_TERM = 0;

-    

-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSAnnotation.Matcher.class);

-    

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    private Matcher() {

-      super(querySpecification());

-    }

-    

-    /**

-     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return matches represented as a Match object.

-     * 

-     */

-    public Collection<VLSAnnotation.Match> getAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm}).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.

-     * </p>

-     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

-     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

-     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a stream of matches represented as a Match object.

-     * 

-     */

-    public Stream<VLSAnnotation.Match> streamAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a match represented as a Match object, or null if no match is found.

-     * 

-     */

-    public Optional<VLSAnnotation.Match> getOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation pTerm) {

-      return rawGetOneArbitraryMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

-     * under any possible substitution of the unspecified parameters (if any).

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return true if the input is a valid (partial) match of the pattern.

-     * 

-     */

-    public boolean hasMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation pTerm) {

-      return rawHasMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the number of pattern matches found.

-     * 

-     */

-    public int countMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation pTerm) {

-      return rawCountMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @param processor the action that will process the selected match.

-     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

-     * 

-     */

-    public boolean forOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation pTerm, final Consumer<? super VLSAnnotation.Match> processor) {

-      return rawForOneArbitraryMatch(new Object[]{pTerm}, processor);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public VLSAnnotation.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation pTerm) {

-      return VLSAnnotation.Match.newMatch(pTerm);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    protected Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation> rawStreamAllValuesOfterm(final Object[] parameters) {

-      return rawStreamAllValues(POSITION_TERM, parameters).map(ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation.class::cast);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Set<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation> getAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray()).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation> streamAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray());

-    }

-    

-    @Override

-    protected VLSAnnotation.Match tupleToMatch(final Tuple t) {

-      try {

-          return VLSAnnotation.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation) t.get(POSITION_TERM));

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in tuple not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSAnnotation.Match arrayToMatch(final Object[] match) {

-      try {

-          return VLSAnnotation.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSAnnotation.Match arrayToMatchMutable(final Object[] match) {

-      try {

-          return VLSAnnotation.Match.newMutableMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    /**

-     * @return the singleton instance of the query specification of this pattern

-     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-     * 

-     */

-    public static IQuerySpecification<VLSAnnotation.Matcher> querySpecification() {

-      return VLSAnnotation.instance();

-    }

-  }

-  

-  private VLSAnnotation() {

-    super(GeneratedPQuery.INSTANCE);

-  }

-  

-  /**

-   * @return the singleton instance of the query specification

-   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-   * 

-   */

-  public static VLSAnnotation instance() {

-    try{

-        return LazyHolder.INSTANCE;

-    } catch (ExceptionInInitializerError err) {

-        throw processInitializerError(err);

-    }

-  }

-  

-  @Override

-  protected VLSAnnotation.Matcher instantiate(final ViatraQueryEngine engine) {

-    return VLSAnnotation.Matcher.on(engine);

-  }

-  

-  @Override

-  public VLSAnnotation.Matcher instantiate() {

-    return VLSAnnotation.Matcher.create();

-  }

-  

-  @Override

-  public VLSAnnotation.Match newEmptyMatch() {

-    return VLSAnnotation.Match.newEmptyMatch();

-  }

-  

-  @Override

-  public VLSAnnotation.Match newMatch(final Object... parameters) {

-    return VLSAnnotation.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation) parameters[0]);

-  }

-  

-  /**

-   * Inner class allowing the singleton instance of {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnnotation (visibility: PUBLIC, simpleName: VLSAnnotation, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnnotation, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

-   *     <b>not</b> at the class load time of the outer class, 

-   *     but rather at the first call to {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnnotation (visibility: PUBLIC, simpleName: VLSAnnotation, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnnotation, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

-   * 

-   * <p> This workaround is required e.g. to support recursion.

-   * 

-   */

-  private static class LazyHolder {

-    private final static VLSAnnotation INSTANCE = new VLSAnnotation();

-    

-    /**

-     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

-     * This initialization order is required to support indirect recursion.

-     * 

-     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.

-     * 

-     */

-    private final static Object STATIC_INITIALIZER = ensureInitialized();

-    

-    public static Object ensureInitialized() {

-      INSTANCE.ensureInitializedInternal();

-      return null;

-    }

-  }

-  

-  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

-    private final static VLSAnnotation.GeneratedPQuery INSTANCE = new GeneratedPQuery();

-    

-    private final PParameter parameter_term = new PParameter("term", "ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSAnnotation")), PParameterDirection.INOUT);

-    

-    private final List<PParameter> parameters = Arrays.asList(parameter_term);

-    

-    private GeneratedPQuery() {

-      super(PVisibility.PUBLIC);

-    }

-    

-    @Override

-    public String getFullyQualifiedName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnnotation";

-    }

-    

-    @Override

-    public List<String> getParameterNames() {

-      return Arrays.asList("term");

-    }

-    

-    @Override

-    public List<PParameter> getParameters() {

-      return parameters;

-    }

-    

-    @Override

-    public Set<PBody> doGetContainedBodies() {

-      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));

-      Set<PBody> bodies = new LinkedHashSet<>();

-      {

-          PBody body = new PBody(this);

-          PVariable var_term = body.getOrCreateVariableByName("term");

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSAnnotation")));

-          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

-             new ExportedParameter(body, var_term, parameter_term)

-          ));

-          //    VLSAnnotation(term)

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSAnnotation")));

-          bodies.add(body);

-      }

-      return bodies;

-    }

-  }

-}

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSComment.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSComment.java
deleted file mode 100644
index ec2bfef3..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSComment.java
+++ /dev/null
@@ -1,533 +0,0 @@
-/**

- * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.queries/src/ca/mcgill/ecse/dslreasoner/vampire/queries/vampireQueries.vql

- */

-package ca.mcgill.ecse.dslreasoner.vampire.queries;

-

-import java.util.Arrays;

-import java.util.Collection;

-import java.util.LinkedHashSet;

-import java.util.List;

-import java.util.Objects;

-import java.util.Optional;

-import java.util.Set;

-import java.util.function.Consumer;

-import java.util.stream.Collectors;

-import java.util.stream.Stream;

-import org.apache.log4j.Logger;

-import org.eclipse.emf.ecore.EClass;

-import org.eclipse.viatra.query.runtime.api.IPatternMatch;

-import org.eclipse.viatra.query.runtime.api.IQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;

-import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;

-import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;

-import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;

-import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;

-

-/**

- * A pattern-specific query specification that can instantiate Matcher in a type-safe way.

- * 

- * <p>Original source:

- *         <code><pre>

- *         pattern VLSComment(term: VLSComment){

- *              VLSComment(term);

- *         }

- * </pre></code>

- * 

- * @see Matcher

- * @see Match

- * 

- */

-@SuppressWarnings("all")

-public final class VLSComment extends BaseGeneratedEMFQuerySpecification<VLSComment.Matcher> {

-  /**

-   * Pattern-specific match representation of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSComment pattern,

-   * to be used in conjunction with {@link Matcher}.

-   * 

-   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

-   * Each instance is a (possibly partial) substitution of pattern parameters,

-   * usable to represent a match of the pattern in the result of a query,

-   * or to specify the bound (fixed) input parameters when issuing a query.

-   * 

-   * @see Matcher

-   * 

-   */

-  public static abstract class Match extends BasePatternMatch {

-    private ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment fTerm;

-    

-    private static List<String> parameterNames = makeImmutableList("term");

-    

-    private Match(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment pTerm) {

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public Object get(final String parameterName) {

-      if ("term".equals(parameterName)) return this.fTerm;

-      return null;

-    }

-    

-    public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment getTerm() {

-      return this.fTerm;

-    }

-    

-    @Override

-    public boolean set(final String parameterName, final Object newValue) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      if ("term".equals(parameterName) ) {

-          this.fTerm = (ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment) newValue;

-          return true;

-      }

-      return false;

-    }

-    

-    public void setTerm(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment pTerm) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public String patternName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSComment";

-    }

-    

-    @Override

-    public List<String> parameterNames() {

-      return VLSComment.Match.parameterNames;

-    }

-    

-    @Override

-    public Object[] toArray() {

-      return new Object[]{fTerm};

-    }

-    

-    @Override

-    public VLSComment.Match toImmutable() {

-      return isMutable() ? newMatch(fTerm) : this;

-    }

-    

-    @Override

-    public String prettyPrint() {

-      StringBuilder result = new StringBuilder();

-      result.append("\"term\"=" + prettyPrintValue(fTerm));

-      return result.toString();

-    }

-    

-    @Override

-    public int hashCode() {

-      return Objects.hash(fTerm);

-    }

-    

-    @Override

-    public boolean equals(final Object obj) {

-      if (this == obj)

-          return true;

-      if (obj == null) {

-          return false;

-      }

-      if ((obj instanceof VLSComment.Match)) {

-          VLSComment.Match other = (VLSComment.Match) obj;

-          return Objects.equals(fTerm, other.fTerm);

-      } else {

-          // this should be infrequent

-          if (!(obj instanceof IPatternMatch)) {

-              return false;

-          }

-          IPatternMatch otherSig  = (IPatternMatch) obj;

-          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());

-      }

-    }

-    

-    @Override

-    public VLSComment specification() {

-      return VLSComment.instance();

-    }

-    

-    /**

-     * Returns an empty, mutable match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @return the empty match.

-     * 

-     */

-    public static VLSComment.Match newEmptyMatch() {

-      return new Mutable(null);

-    }

-    

-    /**

-     * Returns a mutable (partial) match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the new, mutable (partial) match object.

-     * 

-     */

-    public static VLSComment.Match newMutableMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment pTerm) {

-      return new Mutable(pTerm);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public static VLSComment.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment pTerm) {

-      return new Immutable(pTerm);

-    }

-    

-    private static final class Mutable extends VLSComment.Match {

-      Mutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return true;

-      }

-    }

-    

-    private static final class Immutable extends VLSComment.Match {

-      Immutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return false;

-      }

-    }

-  }

-  

-  /**

-   * Generated pattern matcher API of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSComment pattern,

-   * providing pattern-specific query methods.

-   * 

-   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

-   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.

-   * 

-   * <p>Matches of the pattern will be represented as {@link Match}.

-   * 

-   * <p>Original source:

-   * <code><pre>

-   * pattern VLSComment(term: VLSComment){

-   *    VLSComment(term);

-   * }

-   * </pre></code>

-   * 

-   * @see Match

-   * @see VLSComment

-   * 

-   */

-  public static class Matcher extends BaseMatcher<VLSComment.Match> {

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    public static VLSComment.Matcher on(final ViatraQueryEngine engine) {

-      // check if matcher already exists

-      Matcher matcher = engine.getExistingMatcher(querySpecification());

-      if (matcher == null) {

-          matcher = (Matcher)engine.getMatcher(querySpecification());

-      }

-      return matcher;

-    }

-    

-    /**

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * @return an initialized matcher

-     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

-     * 

-     */

-    public static VLSComment.Matcher create() {

-      return new Matcher();

-    }

-    

-    private final static int POSITION_TERM = 0;

-    

-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSComment.Matcher.class);

-    

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    private Matcher() {

-      super(querySpecification());

-    }

-    

-    /**

-     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return matches represented as a Match object.

-     * 

-     */

-    public Collection<VLSComment.Match> getAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm}).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.

-     * </p>

-     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

-     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

-     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a stream of matches represented as a Match object.

-     * 

-     */

-    public Stream<VLSComment.Match> streamAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a match represented as a Match object, or null if no match is found.

-     * 

-     */

-    public Optional<VLSComment.Match> getOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment pTerm) {

-      return rawGetOneArbitraryMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

-     * under any possible substitution of the unspecified parameters (if any).

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return true if the input is a valid (partial) match of the pattern.

-     * 

-     */

-    public boolean hasMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment pTerm) {

-      return rawHasMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the number of pattern matches found.

-     * 

-     */

-    public int countMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment pTerm) {

-      return rawCountMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @param processor the action that will process the selected match.

-     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

-     * 

-     */

-    public boolean forOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment pTerm, final Consumer<? super VLSComment.Match> processor) {

-      return rawForOneArbitraryMatch(new Object[]{pTerm}, processor);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public VLSComment.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment pTerm) {

-      return VLSComment.Match.newMatch(pTerm);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    protected Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment> rawStreamAllValuesOfterm(final Object[] parameters) {

-      return rawStreamAllValues(POSITION_TERM, parameters).map(ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment.class::cast);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Set<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment> getAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray()).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment> streamAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray());

-    }

-    

-    @Override

-    protected VLSComment.Match tupleToMatch(final Tuple t) {

-      try {

-          return VLSComment.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment) t.get(POSITION_TERM));

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in tuple not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSComment.Match arrayToMatch(final Object[] match) {

-      try {

-          return VLSComment.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSComment.Match arrayToMatchMutable(final Object[] match) {

-      try {

-          return VLSComment.Match.newMutableMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    /**

-     * @return the singleton instance of the query specification of this pattern

-     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-     * 

-     */

-    public static IQuerySpecification<VLSComment.Matcher> querySpecification() {

-      return VLSComment.instance();

-    }

-  }

-  

-  private VLSComment() {

-    super(GeneratedPQuery.INSTANCE);

-  }

-  

-  /**

-   * @return the singleton instance of the query specification

-   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-   * 

-   */

-  public static VLSComment instance() {

-    try{

-        return LazyHolder.INSTANCE;

-    } catch (ExceptionInInitializerError err) {

-        throw processInitializerError(err);

-    }

-  }

-  

-  @Override

-  protected VLSComment.Matcher instantiate(final ViatraQueryEngine engine) {

-    return VLSComment.Matcher.on(engine);

-  }

-  

-  @Override

-  public VLSComment.Matcher instantiate() {

-    return VLSComment.Matcher.create();

-  }

-  

-  @Override

-  public VLSComment.Match newEmptyMatch() {

-    return VLSComment.Match.newEmptyMatch();

-  }

-  

-  @Override

-  public VLSComment.Match newMatch(final Object... parameters) {

-    return VLSComment.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment) parameters[0]);

-  }

-  

-  /**

-   * Inner class allowing the singleton instance of {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSComment (visibility: PUBLIC, simpleName: VLSComment, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSComment, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

-   *     <b>not</b> at the class load time of the outer class, 

-   *     but rather at the first call to {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSComment (visibility: PUBLIC, simpleName: VLSComment, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSComment, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

-   * 

-   * <p> This workaround is required e.g. to support recursion.

-   * 

-   */

-  private static class LazyHolder {

-    private final static VLSComment INSTANCE = new VLSComment();

-    

-    /**

-     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

-     * This initialization order is required to support indirect recursion.

-     * 

-     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.

-     * 

-     */

-    private final static Object STATIC_INITIALIZER = ensureInitialized();

-    

-    public static Object ensureInitialized() {

-      INSTANCE.ensureInitializedInternal();

-      return null;

-    }

-  }

-  

-  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

-    private final static VLSComment.GeneratedPQuery INSTANCE = new GeneratedPQuery();

-    

-    private final PParameter parameter_term = new PParameter("term", "ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSComment")), PParameterDirection.INOUT);

-    

-    private final List<PParameter> parameters = Arrays.asList(parameter_term);

-    

-    private GeneratedPQuery() {

-      super(PVisibility.PUBLIC);

-    }

-    

-    @Override

-    public String getFullyQualifiedName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSComment";

-    }

-    

-    @Override

-    public List<String> getParameterNames() {

-      return Arrays.asList("term");

-    }

-    

-    @Override

-    public List<PParameter> getParameters() {

-      return parameters;

-    }

-    

-    @Override

-    public Set<PBody> doGetContainedBodies() {

-      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));

-      Set<PBody> bodies = new LinkedHashSet<>();

-      {

-          PBody body = new PBody(this);

-          PVariable var_term = body.getOrCreateVariableByName("term");

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSComment")));

-          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

-             new ExportedParameter(body, var_term, parameter_term)

-          ));

-          //    VLSComment(term)

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSComment")));

-          bodies.add(body);

-      }

-      return bodies;

-    }

-  }

-}

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSEquivalent.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSEquivalent.java
deleted file mode 100644
index 5a174fed..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSEquivalent.java
+++ /dev/null
@@ -1,533 +0,0 @@
-/**

- * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.queries/src/ca/mcgill/ecse/dslreasoner/vampire/queries/vampireQueries.vql

- */

-package ca.mcgill.ecse.dslreasoner.vampire.queries;

-

-import java.util.Arrays;

-import java.util.Collection;

-import java.util.LinkedHashSet;

-import java.util.List;

-import java.util.Objects;

-import java.util.Optional;

-import java.util.Set;

-import java.util.function.Consumer;

-import java.util.stream.Collectors;

-import java.util.stream.Stream;

-import org.apache.log4j.Logger;

-import org.eclipse.emf.ecore.EClass;

-import org.eclipse.viatra.query.runtime.api.IPatternMatch;

-import org.eclipse.viatra.query.runtime.api.IQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;

-import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;

-import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;

-import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;

-import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;

-

-/**

- * A pattern-specific query specification that can instantiate Matcher in a type-safe way.

- * 

- * <p>Original source:

- *         <code><pre>

- *         pattern VLSEquivalent(term: VLSEquivalent){

- *              VLSEquivalent(term);

- *         }

- * </pre></code>

- * 

- * @see Matcher

- * @see Match

- * 

- */

-@SuppressWarnings("all")

-public final class VLSEquivalent extends BaseGeneratedEMFQuerySpecification<VLSEquivalent.Matcher> {

-  /**

-   * Pattern-specific match representation of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSEquivalent pattern,

-   * to be used in conjunction with {@link Matcher}.

-   * 

-   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

-   * Each instance is a (possibly partial) substitution of pattern parameters,

-   * usable to represent a match of the pattern in the result of a query,

-   * or to specify the bound (fixed) input parameters when issuing a query.

-   * 

-   * @see Matcher

-   * 

-   */

-  public static abstract class Match extends BasePatternMatch {

-    private ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent fTerm;

-    

-    private static List<String> parameterNames = makeImmutableList("term");

-    

-    private Match(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent pTerm) {

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public Object get(final String parameterName) {

-      if ("term".equals(parameterName)) return this.fTerm;

-      return null;

-    }

-    

-    public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent getTerm() {

-      return this.fTerm;

-    }

-    

-    @Override

-    public boolean set(final String parameterName, final Object newValue) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      if ("term".equals(parameterName) ) {

-          this.fTerm = (ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent) newValue;

-          return true;

-      }

-      return false;

-    }

-    

-    public void setTerm(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent pTerm) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public String patternName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSEquivalent";

-    }

-    

-    @Override

-    public List<String> parameterNames() {

-      return VLSEquivalent.Match.parameterNames;

-    }

-    

-    @Override

-    public Object[] toArray() {

-      return new Object[]{fTerm};

-    }

-    

-    @Override

-    public VLSEquivalent.Match toImmutable() {

-      return isMutable() ? newMatch(fTerm) : this;

-    }

-    

-    @Override

-    public String prettyPrint() {

-      StringBuilder result = new StringBuilder();

-      result.append("\"term\"=" + prettyPrintValue(fTerm));

-      return result.toString();

-    }

-    

-    @Override

-    public int hashCode() {

-      return Objects.hash(fTerm);

-    }

-    

-    @Override

-    public boolean equals(final Object obj) {

-      if (this == obj)

-          return true;

-      if (obj == null) {

-          return false;

-      }

-      if ((obj instanceof VLSEquivalent.Match)) {

-          VLSEquivalent.Match other = (VLSEquivalent.Match) obj;

-          return Objects.equals(fTerm, other.fTerm);

-      } else {

-          // this should be infrequent

-          if (!(obj instanceof IPatternMatch)) {

-              return false;

-          }

-          IPatternMatch otherSig  = (IPatternMatch) obj;

-          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());

-      }

-    }

-    

-    @Override

-    public VLSEquivalent specification() {

-      return VLSEquivalent.instance();

-    }

-    

-    /**

-     * Returns an empty, mutable match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @return the empty match.

-     * 

-     */

-    public static VLSEquivalent.Match newEmptyMatch() {

-      return new Mutable(null);

-    }

-    

-    /**

-     * Returns a mutable (partial) match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the new, mutable (partial) match object.

-     * 

-     */

-    public static VLSEquivalent.Match newMutableMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent pTerm) {

-      return new Mutable(pTerm);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public static VLSEquivalent.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent pTerm) {

-      return new Immutable(pTerm);

-    }

-    

-    private static final class Mutable extends VLSEquivalent.Match {

-      Mutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return true;

-      }

-    }

-    

-    private static final class Immutable extends VLSEquivalent.Match {

-      Immutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return false;

-      }

-    }

-  }

-  

-  /**

-   * Generated pattern matcher API of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSEquivalent pattern,

-   * providing pattern-specific query methods.

-   * 

-   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

-   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.

-   * 

-   * <p>Matches of the pattern will be represented as {@link Match}.

-   * 

-   * <p>Original source:

-   * <code><pre>

-   * pattern VLSEquivalent(term: VLSEquivalent){

-   *    VLSEquivalent(term);

-   * }

-   * </pre></code>

-   * 

-   * @see Match

-   * @see VLSEquivalent

-   * 

-   */

-  public static class Matcher extends BaseMatcher<VLSEquivalent.Match> {

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    public static VLSEquivalent.Matcher on(final ViatraQueryEngine engine) {

-      // check if matcher already exists

-      Matcher matcher = engine.getExistingMatcher(querySpecification());

-      if (matcher == null) {

-          matcher = (Matcher)engine.getMatcher(querySpecification());

-      }

-      return matcher;

-    }

-    

-    /**

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * @return an initialized matcher

-     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

-     * 

-     */

-    public static VLSEquivalent.Matcher create() {

-      return new Matcher();

-    }

-    

-    private final static int POSITION_TERM = 0;

-    

-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSEquivalent.Matcher.class);

-    

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    private Matcher() {

-      super(querySpecification());

-    }

-    

-    /**

-     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return matches represented as a Match object.

-     * 

-     */

-    public Collection<VLSEquivalent.Match> getAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm}).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.

-     * </p>

-     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

-     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

-     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a stream of matches represented as a Match object.

-     * 

-     */

-    public Stream<VLSEquivalent.Match> streamAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a match represented as a Match object, or null if no match is found.

-     * 

-     */

-    public Optional<VLSEquivalent.Match> getOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent pTerm) {

-      return rawGetOneArbitraryMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

-     * under any possible substitution of the unspecified parameters (if any).

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return true if the input is a valid (partial) match of the pattern.

-     * 

-     */

-    public boolean hasMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent pTerm) {

-      return rawHasMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the number of pattern matches found.

-     * 

-     */

-    public int countMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent pTerm) {

-      return rawCountMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @param processor the action that will process the selected match.

-     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

-     * 

-     */

-    public boolean forOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent pTerm, final Consumer<? super VLSEquivalent.Match> processor) {

-      return rawForOneArbitraryMatch(new Object[]{pTerm}, processor);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public VLSEquivalent.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent pTerm) {

-      return VLSEquivalent.Match.newMatch(pTerm);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    protected Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent> rawStreamAllValuesOfterm(final Object[] parameters) {

-      return rawStreamAllValues(POSITION_TERM, parameters).map(ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent.class::cast);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Set<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent> getAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray()).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent> streamAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray());

-    }

-    

-    @Override

-    protected VLSEquivalent.Match tupleToMatch(final Tuple t) {

-      try {

-          return VLSEquivalent.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent) t.get(POSITION_TERM));

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in tuple not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSEquivalent.Match arrayToMatch(final Object[] match) {

-      try {

-          return VLSEquivalent.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSEquivalent.Match arrayToMatchMutable(final Object[] match) {

-      try {

-          return VLSEquivalent.Match.newMutableMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    /**

-     * @return the singleton instance of the query specification of this pattern

-     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-     * 

-     */

-    public static IQuerySpecification<VLSEquivalent.Matcher> querySpecification() {

-      return VLSEquivalent.instance();

-    }

-  }

-  

-  private VLSEquivalent() {

-    super(GeneratedPQuery.INSTANCE);

-  }

-  

-  /**

-   * @return the singleton instance of the query specification

-   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-   * 

-   */

-  public static VLSEquivalent instance() {

-    try{

-        return LazyHolder.INSTANCE;

-    } catch (ExceptionInInitializerError err) {

-        throw processInitializerError(err);

-    }

-  }

-  

-  @Override

-  protected VLSEquivalent.Matcher instantiate(final ViatraQueryEngine engine) {

-    return VLSEquivalent.Matcher.on(engine);

-  }

-  

-  @Override

-  public VLSEquivalent.Matcher instantiate() {

-    return VLSEquivalent.Matcher.create();

-  }

-  

-  @Override

-  public VLSEquivalent.Match newEmptyMatch() {

-    return VLSEquivalent.Match.newEmptyMatch();

-  }

-  

-  @Override

-  public VLSEquivalent.Match newMatch(final Object... parameters) {

-    return VLSEquivalent.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent) parameters[0]);

-  }

-  

-  /**

-   * Inner class allowing the singleton instance of {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSEquivalent (visibility: PUBLIC, simpleName: VLSEquivalent, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSEquivalent, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

-   *     <b>not</b> at the class load time of the outer class, 

-   *     but rather at the first call to {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSEquivalent (visibility: PUBLIC, simpleName: VLSEquivalent, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSEquivalent, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

-   * 

-   * <p> This workaround is required e.g. to support recursion.

-   * 

-   */

-  private static class LazyHolder {

-    private final static VLSEquivalent INSTANCE = new VLSEquivalent();

-    

-    /**

-     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

-     * This initialization order is required to support indirect recursion.

-     * 

-     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.

-     * 

-     */

-    private final static Object STATIC_INITIALIZER = ensureInitialized();

-    

-    public static Object ensureInitialized() {

-      INSTANCE.ensureInitializedInternal();

-      return null;

-    }

-  }

-  

-  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

-    private final static VLSEquivalent.GeneratedPQuery INSTANCE = new GeneratedPQuery();

-    

-    private final PParameter parameter_term = new PParameter("term", "ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSEquivalent")), PParameterDirection.INOUT);

-    

-    private final List<PParameter> parameters = Arrays.asList(parameter_term);

-    

-    private GeneratedPQuery() {

-      super(PVisibility.PUBLIC);

-    }

-    

-    @Override

-    public String getFullyQualifiedName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSEquivalent";

-    }

-    

-    @Override

-    public List<String> getParameterNames() {

-      return Arrays.asList("term");

-    }

-    

-    @Override

-    public List<PParameter> getParameters() {

-      return parameters;

-    }

-    

-    @Override

-    public Set<PBody> doGetContainedBodies() {

-      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));

-      Set<PBody> bodies = new LinkedHashSet<>();

-      {

-          PBody body = new PBody(this);

-          PVariable var_term = body.getOrCreateVariableByName("term");

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSEquivalent")));

-          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

-             new ExportedParameter(body, var_term, parameter_term)

-          ));

-          //    VLSEquivalent(term)

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSEquivalent")));

-          bodies.add(body);

-      }

-      return bodies;

-    }

-  }

-}

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSExistentialQuantifier.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSExistentialQuantifier.java
deleted file mode 100644
index 137e4ca0..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSExistentialQuantifier.java
+++ /dev/null
@@ -1,533 +0,0 @@
-/**

- * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.queries/src/ca/mcgill/ecse/dslreasoner/vampire/queries/vampireQueries.vql

- */

-package ca.mcgill.ecse.dslreasoner.vampire.queries;

-

-import java.util.Arrays;

-import java.util.Collection;

-import java.util.LinkedHashSet;

-import java.util.List;

-import java.util.Objects;

-import java.util.Optional;

-import java.util.Set;

-import java.util.function.Consumer;

-import java.util.stream.Collectors;

-import java.util.stream.Stream;

-import org.apache.log4j.Logger;

-import org.eclipse.emf.ecore.EClass;

-import org.eclipse.viatra.query.runtime.api.IPatternMatch;

-import org.eclipse.viatra.query.runtime.api.IQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;

-import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;

-import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;

-import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;

-import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;

-

-/**

- * A pattern-specific query specification that can instantiate Matcher in a type-safe way.

- * 

- * <p>Original source:

- *         <code><pre>

- *         pattern VLSExistentialQuantifier(term: VLSExistentialQuantifier){

- *              VLSExistentialQuantifier(term);

- *         }

- * </pre></code>

- * 

- * @see Matcher

- * @see Match

- * 

- */

-@SuppressWarnings("all")

-public final class VLSExistentialQuantifier extends BaseGeneratedEMFQuerySpecification<VLSExistentialQuantifier.Matcher> {

-  /**

-   * Pattern-specific match representation of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSExistentialQuantifier pattern,

-   * to be used in conjunction with {@link Matcher}.

-   * 

-   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

-   * Each instance is a (possibly partial) substitution of pattern parameters,

-   * usable to represent a match of the pattern in the result of a query,

-   * or to specify the bound (fixed) input parameters when issuing a query.

-   * 

-   * @see Matcher

-   * 

-   */

-  public static abstract class Match extends BasePatternMatch {

-    private ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier fTerm;

-    

-    private static List<String> parameterNames = makeImmutableList("term");

-    

-    private Match(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier pTerm) {

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public Object get(final String parameterName) {

-      if ("term".equals(parameterName)) return this.fTerm;

-      return null;

-    }

-    

-    public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier getTerm() {

-      return this.fTerm;

-    }

-    

-    @Override

-    public boolean set(final String parameterName, final Object newValue) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      if ("term".equals(parameterName) ) {

-          this.fTerm = (ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier) newValue;

-          return true;

-      }

-      return false;

-    }

-    

-    public void setTerm(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier pTerm) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public String patternName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSExistentialQuantifier";

-    }

-    

-    @Override

-    public List<String> parameterNames() {

-      return VLSExistentialQuantifier.Match.parameterNames;

-    }

-    

-    @Override

-    public Object[] toArray() {

-      return new Object[]{fTerm};

-    }

-    

-    @Override

-    public VLSExistentialQuantifier.Match toImmutable() {

-      return isMutable() ? newMatch(fTerm) : this;

-    }

-    

-    @Override

-    public String prettyPrint() {

-      StringBuilder result = new StringBuilder();

-      result.append("\"term\"=" + prettyPrintValue(fTerm));

-      return result.toString();

-    }

-    

-    @Override

-    public int hashCode() {

-      return Objects.hash(fTerm);

-    }

-    

-    @Override

-    public boolean equals(final Object obj) {

-      if (this == obj)

-          return true;

-      if (obj == null) {

-          return false;

-      }

-      if ((obj instanceof VLSExistentialQuantifier.Match)) {

-          VLSExistentialQuantifier.Match other = (VLSExistentialQuantifier.Match) obj;

-          return Objects.equals(fTerm, other.fTerm);

-      } else {

-          // this should be infrequent

-          if (!(obj instanceof IPatternMatch)) {

-              return false;

-          }

-          IPatternMatch otherSig  = (IPatternMatch) obj;

-          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());

-      }

-    }

-    

-    @Override

-    public VLSExistentialQuantifier specification() {

-      return VLSExistentialQuantifier.instance();

-    }

-    

-    /**

-     * Returns an empty, mutable match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @return the empty match.

-     * 

-     */

-    public static VLSExistentialQuantifier.Match newEmptyMatch() {

-      return new Mutable(null);

-    }

-    

-    /**

-     * Returns a mutable (partial) match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the new, mutable (partial) match object.

-     * 

-     */

-    public static VLSExistentialQuantifier.Match newMutableMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier pTerm) {

-      return new Mutable(pTerm);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public static VLSExistentialQuantifier.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier pTerm) {

-      return new Immutable(pTerm);

-    }

-    

-    private static final class Mutable extends VLSExistentialQuantifier.Match {

-      Mutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return true;

-      }

-    }

-    

-    private static final class Immutable extends VLSExistentialQuantifier.Match {

-      Immutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return false;

-      }

-    }

-  }

-  

-  /**

-   * Generated pattern matcher API of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSExistentialQuantifier pattern,

-   * providing pattern-specific query methods.

-   * 

-   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

-   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.

-   * 

-   * <p>Matches of the pattern will be represented as {@link Match}.

-   * 

-   * <p>Original source:

-   * <code><pre>

-   * pattern VLSExistentialQuantifier(term: VLSExistentialQuantifier){

-   *    VLSExistentialQuantifier(term);

-   * }

-   * </pre></code>

-   * 

-   * @see Match

-   * @see VLSExistentialQuantifier

-   * 

-   */

-  public static class Matcher extends BaseMatcher<VLSExistentialQuantifier.Match> {

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    public static VLSExistentialQuantifier.Matcher on(final ViatraQueryEngine engine) {

-      // check if matcher already exists

-      Matcher matcher = engine.getExistingMatcher(querySpecification());

-      if (matcher == null) {

-          matcher = (Matcher)engine.getMatcher(querySpecification());

-      }

-      return matcher;

-    }

-    

-    /**

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * @return an initialized matcher

-     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

-     * 

-     */

-    public static VLSExistentialQuantifier.Matcher create() {

-      return new Matcher();

-    }

-    

-    private final static int POSITION_TERM = 0;

-    

-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSExistentialQuantifier.Matcher.class);

-    

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    private Matcher() {

-      super(querySpecification());

-    }

-    

-    /**

-     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return matches represented as a Match object.

-     * 

-     */

-    public Collection<VLSExistentialQuantifier.Match> getAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm}).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.

-     * </p>

-     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

-     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

-     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a stream of matches represented as a Match object.

-     * 

-     */

-    public Stream<VLSExistentialQuantifier.Match> streamAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a match represented as a Match object, or null if no match is found.

-     * 

-     */

-    public Optional<VLSExistentialQuantifier.Match> getOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier pTerm) {

-      return rawGetOneArbitraryMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

-     * under any possible substitution of the unspecified parameters (if any).

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return true if the input is a valid (partial) match of the pattern.

-     * 

-     */

-    public boolean hasMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier pTerm) {

-      return rawHasMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the number of pattern matches found.

-     * 

-     */

-    public int countMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier pTerm) {

-      return rawCountMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @param processor the action that will process the selected match.

-     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

-     * 

-     */

-    public boolean forOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier pTerm, final Consumer<? super VLSExistentialQuantifier.Match> processor) {

-      return rawForOneArbitraryMatch(new Object[]{pTerm}, processor);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public VLSExistentialQuantifier.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier pTerm) {

-      return VLSExistentialQuantifier.Match.newMatch(pTerm);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    protected Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier> rawStreamAllValuesOfterm(final Object[] parameters) {

-      return rawStreamAllValues(POSITION_TERM, parameters).map(ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier.class::cast);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Set<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier> getAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray()).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier> streamAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray());

-    }

-    

-    @Override

-    protected VLSExistentialQuantifier.Match tupleToMatch(final Tuple t) {

-      try {

-          return VLSExistentialQuantifier.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier) t.get(POSITION_TERM));

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in tuple not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSExistentialQuantifier.Match arrayToMatch(final Object[] match) {

-      try {

-          return VLSExistentialQuantifier.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSExistentialQuantifier.Match arrayToMatchMutable(final Object[] match) {

-      try {

-          return VLSExistentialQuantifier.Match.newMutableMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    /**

-     * @return the singleton instance of the query specification of this pattern

-     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-     * 

-     */

-    public static IQuerySpecification<VLSExistentialQuantifier.Matcher> querySpecification() {

-      return VLSExistentialQuantifier.instance();

-    }

-  }

-  

-  private VLSExistentialQuantifier() {

-    super(GeneratedPQuery.INSTANCE);

-  }

-  

-  /**

-   * @return the singleton instance of the query specification

-   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-   * 

-   */

-  public static VLSExistentialQuantifier instance() {

-    try{

-        return LazyHolder.INSTANCE;

-    } catch (ExceptionInInitializerError err) {

-        throw processInitializerError(err);

-    }

-  }

-  

-  @Override

-  protected VLSExistentialQuantifier.Matcher instantiate(final ViatraQueryEngine engine) {

-    return VLSExistentialQuantifier.Matcher.on(engine);

-  }

-  

-  @Override

-  public VLSExistentialQuantifier.Matcher instantiate() {

-    return VLSExistentialQuantifier.Matcher.create();

-  }

-  

-  @Override

-  public VLSExistentialQuantifier.Match newEmptyMatch() {

-    return VLSExistentialQuantifier.Match.newEmptyMatch();

-  }

-  

-  @Override

-  public VLSExistentialQuantifier.Match newMatch(final Object... parameters) {

-    return VLSExistentialQuantifier.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier) parameters[0]);

-  }

-  

-  /**

-   * Inner class allowing the singleton instance of {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSExistentialQuantifier (visibility: PUBLIC, simpleName: VLSExistentialQuantifier, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSExistentialQuantifier, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

-   *     <b>not</b> at the class load time of the outer class, 

-   *     but rather at the first call to {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSExistentialQuantifier (visibility: PUBLIC, simpleName: VLSExistentialQuantifier, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSExistentialQuantifier, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

-   * 

-   * <p> This workaround is required e.g. to support recursion.

-   * 

-   */

-  private static class LazyHolder {

-    private final static VLSExistentialQuantifier INSTANCE = new VLSExistentialQuantifier();

-    

-    /**

-     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

-     * This initialization order is required to support indirect recursion.

-     * 

-     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.

-     * 

-     */

-    private final static Object STATIC_INITIALIZER = ensureInitialized();

-    

-    public static Object ensureInitialized() {

-      INSTANCE.ensureInitializedInternal();

-      return null;

-    }

-  }

-  

-  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

-    private final static VLSExistentialQuantifier.GeneratedPQuery INSTANCE = new GeneratedPQuery();

-    

-    private final PParameter parameter_term = new PParameter("term", "ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSExistentialQuantifier")), PParameterDirection.INOUT);

-    

-    private final List<PParameter> parameters = Arrays.asList(parameter_term);

-    

-    private GeneratedPQuery() {

-      super(PVisibility.PUBLIC);

-    }

-    

-    @Override

-    public String getFullyQualifiedName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSExistentialQuantifier";

-    }

-    

-    @Override

-    public List<String> getParameterNames() {

-      return Arrays.asList("term");

-    }

-    

-    @Override

-    public List<PParameter> getParameters() {

-      return parameters;

-    }

-    

-    @Override

-    public Set<PBody> doGetContainedBodies() {

-      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));

-      Set<PBody> bodies = new LinkedHashSet<>();

-      {

-          PBody body = new PBody(this);

-          PVariable var_term = body.getOrCreateVariableByName("term");

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSExistentialQuantifier")));

-          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

-             new ExportedParameter(body, var_term, parameter_term)

-          ));

-          //    VLSExistentialQuantifier(term)

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSExistentialQuantifier")));

-          bodies.add(body);

-      }

-      return bodies;

-    }

-  }

-}

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSFofFormula.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSFofFormula.java
deleted file mode 100644
index f55f408a..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSFofFormula.java
+++ /dev/null
@@ -1,533 +0,0 @@
-/**

- * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.queries/src/ca/mcgill/ecse/dslreasoner/vampire/queries/vampireQueries.vql

- */

-package ca.mcgill.ecse.dslreasoner.vampire.queries;

-

-import java.util.Arrays;

-import java.util.Collection;

-import java.util.LinkedHashSet;

-import java.util.List;

-import java.util.Objects;

-import java.util.Optional;

-import java.util.Set;

-import java.util.function.Consumer;

-import java.util.stream.Collectors;

-import java.util.stream.Stream;

-import org.apache.log4j.Logger;

-import org.eclipse.emf.ecore.EClass;

-import org.eclipse.viatra.query.runtime.api.IPatternMatch;

-import org.eclipse.viatra.query.runtime.api.IQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;

-import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;

-import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;

-import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;

-import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;

-

-/**

- * A pattern-specific query specification that can instantiate Matcher in a type-safe way.

- * 

- * <p>Original source:

- *         <code><pre>

- *         pattern VLSFofFormula(term: VLSFofFormula){

- *              VLSFofFormula(term);

- *         }

- * </pre></code>

- * 

- * @see Matcher

- * @see Match

- * 

- */

-@SuppressWarnings("all")

-public final class VLSFofFormula extends BaseGeneratedEMFQuerySpecification<VLSFofFormula.Matcher> {

-  /**

-   * Pattern-specific match representation of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFofFormula pattern,

-   * to be used in conjunction with {@link Matcher}.

-   * 

-   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

-   * Each instance is a (possibly partial) substitution of pattern parameters,

-   * usable to represent a match of the pattern in the result of a query,

-   * or to specify the bound (fixed) input parameters when issuing a query.

-   * 

-   * @see Matcher

-   * 

-   */

-  public static abstract class Match extends BasePatternMatch {

-    private ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula fTerm;

-    

-    private static List<String> parameterNames = makeImmutableList("term");

-    

-    private Match(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula pTerm) {

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public Object get(final String parameterName) {

-      if ("term".equals(parameterName)) return this.fTerm;

-      return null;

-    }

-    

-    public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula getTerm() {

-      return this.fTerm;

-    }

-    

-    @Override

-    public boolean set(final String parameterName, final Object newValue) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      if ("term".equals(parameterName) ) {

-          this.fTerm = (ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula) newValue;

-          return true;

-      }

-      return false;

-    }

-    

-    public void setTerm(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula pTerm) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public String patternName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFofFormula";

-    }

-    

-    @Override

-    public List<String> parameterNames() {

-      return VLSFofFormula.Match.parameterNames;

-    }

-    

-    @Override

-    public Object[] toArray() {

-      return new Object[]{fTerm};

-    }

-    

-    @Override

-    public VLSFofFormula.Match toImmutable() {

-      return isMutable() ? newMatch(fTerm) : this;

-    }

-    

-    @Override

-    public String prettyPrint() {

-      StringBuilder result = new StringBuilder();

-      result.append("\"term\"=" + prettyPrintValue(fTerm));

-      return result.toString();

-    }

-    

-    @Override

-    public int hashCode() {

-      return Objects.hash(fTerm);

-    }

-    

-    @Override

-    public boolean equals(final Object obj) {

-      if (this == obj)

-          return true;

-      if (obj == null) {

-          return false;

-      }

-      if ((obj instanceof VLSFofFormula.Match)) {

-          VLSFofFormula.Match other = (VLSFofFormula.Match) obj;

-          return Objects.equals(fTerm, other.fTerm);

-      } else {

-          // this should be infrequent

-          if (!(obj instanceof IPatternMatch)) {

-              return false;

-          }

-          IPatternMatch otherSig  = (IPatternMatch) obj;

-          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());

-      }

-    }

-    

-    @Override

-    public VLSFofFormula specification() {

-      return VLSFofFormula.instance();

-    }

-    

-    /**

-     * Returns an empty, mutable match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @return the empty match.

-     * 

-     */

-    public static VLSFofFormula.Match newEmptyMatch() {

-      return new Mutable(null);

-    }

-    

-    /**

-     * Returns a mutable (partial) match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the new, mutable (partial) match object.

-     * 

-     */

-    public static VLSFofFormula.Match newMutableMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula pTerm) {

-      return new Mutable(pTerm);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public static VLSFofFormula.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula pTerm) {

-      return new Immutable(pTerm);

-    }

-    

-    private static final class Mutable extends VLSFofFormula.Match {

-      Mutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return true;

-      }

-    }

-    

-    private static final class Immutable extends VLSFofFormula.Match {

-      Immutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return false;

-      }

-    }

-  }

-  

-  /**

-   * Generated pattern matcher API of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFofFormula pattern,

-   * providing pattern-specific query methods.

-   * 

-   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

-   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.

-   * 

-   * <p>Matches of the pattern will be represented as {@link Match}.

-   * 

-   * <p>Original source:

-   * <code><pre>

-   * pattern VLSFofFormula(term: VLSFofFormula){

-   *    VLSFofFormula(term);

-   * }

-   * </pre></code>

-   * 

-   * @see Match

-   * @see VLSFofFormula

-   * 

-   */

-  public static class Matcher extends BaseMatcher<VLSFofFormula.Match> {

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    public static VLSFofFormula.Matcher on(final ViatraQueryEngine engine) {

-      // check if matcher already exists

-      Matcher matcher = engine.getExistingMatcher(querySpecification());

-      if (matcher == null) {

-          matcher = (Matcher)engine.getMatcher(querySpecification());

-      }

-      return matcher;

-    }

-    

-    /**

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * @return an initialized matcher

-     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

-     * 

-     */

-    public static VLSFofFormula.Matcher create() {

-      return new Matcher();

-    }

-    

-    private final static int POSITION_TERM = 0;

-    

-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSFofFormula.Matcher.class);

-    

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    private Matcher() {

-      super(querySpecification());

-    }

-    

-    /**

-     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return matches represented as a Match object.

-     * 

-     */

-    public Collection<VLSFofFormula.Match> getAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm}).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.

-     * </p>

-     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

-     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

-     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a stream of matches represented as a Match object.

-     * 

-     */

-    public Stream<VLSFofFormula.Match> streamAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a match represented as a Match object, or null if no match is found.

-     * 

-     */

-    public Optional<VLSFofFormula.Match> getOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula pTerm) {

-      return rawGetOneArbitraryMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

-     * under any possible substitution of the unspecified parameters (if any).

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return true if the input is a valid (partial) match of the pattern.

-     * 

-     */

-    public boolean hasMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula pTerm) {

-      return rawHasMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the number of pattern matches found.

-     * 

-     */

-    public int countMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula pTerm) {

-      return rawCountMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @param processor the action that will process the selected match.

-     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

-     * 

-     */

-    public boolean forOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula pTerm, final Consumer<? super VLSFofFormula.Match> processor) {

-      return rawForOneArbitraryMatch(new Object[]{pTerm}, processor);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public VLSFofFormula.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula pTerm) {

-      return VLSFofFormula.Match.newMatch(pTerm);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    protected Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula> rawStreamAllValuesOfterm(final Object[] parameters) {

-      return rawStreamAllValues(POSITION_TERM, parameters).map(ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula.class::cast);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Set<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula> getAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray()).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula> streamAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray());

-    }

-    

-    @Override

-    protected VLSFofFormula.Match tupleToMatch(final Tuple t) {

-      try {

-          return VLSFofFormula.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula) t.get(POSITION_TERM));

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in tuple not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSFofFormula.Match arrayToMatch(final Object[] match) {

-      try {

-          return VLSFofFormula.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSFofFormula.Match arrayToMatchMutable(final Object[] match) {

-      try {

-          return VLSFofFormula.Match.newMutableMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    /**

-     * @return the singleton instance of the query specification of this pattern

-     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-     * 

-     */

-    public static IQuerySpecification<VLSFofFormula.Matcher> querySpecification() {

-      return VLSFofFormula.instance();

-    }

-  }

-  

-  private VLSFofFormula() {

-    super(GeneratedPQuery.INSTANCE);

-  }

-  

-  /**

-   * @return the singleton instance of the query specification

-   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-   * 

-   */

-  public static VLSFofFormula instance() {

-    try{

-        return LazyHolder.INSTANCE;

-    } catch (ExceptionInInitializerError err) {

-        throw processInitializerError(err);

-    }

-  }

-  

-  @Override

-  protected VLSFofFormula.Matcher instantiate(final ViatraQueryEngine engine) {

-    return VLSFofFormula.Matcher.on(engine);

-  }

-  

-  @Override

-  public VLSFofFormula.Matcher instantiate() {

-    return VLSFofFormula.Matcher.create();

-  }

-  

-  @Override

-  public VLSFofFormula.Match newEmptyMatch() {

-    return VLSFofFormula.Match.newEmptyMatch();

-  }

-  

-  @Override

-  public VLSFofFormula.Match newMatch(final Object... parameters) {

-    return VLSFofFormula.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula) parameters[0]);

-  }

-  

-  /**

-   * Inner class allowing the singleton instance of {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFofFormula (visibility: PUBLIC, simpleName: VLSFofFormula, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFofFormula, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

-   *     <b>not</b> at the class load time of the outer class, 

-   *     but rather at the first call to {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFofFormula (visibility: PUBLIC, simpleName: VLSFofFormula, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFofFormula, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

-   * 

-   * <p> This workaround is required e.g. to support recursion.

-   * 

-   */

-  private static class LazyHolder {

-    private final static VLSFofFormula INSTANCE = new VLSFofFormula();

-    

-    /**

-     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

-     * This initialization order is required to support indirect recursion.

-     * 

-     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.

-     * 

-     */

-    private final static Object STATIC_INITIALIZER = ensureInitialized();

-    

-    public static Object ensureInitialized() {

-      INSTANCE.ensureInitializedInternal();

-      return null;

-    }

-  }

-  

-  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

-    private final static VLSFofFormula.GeneratedPQuery INSTANCE = new GeneratedPQuery();

-    

-    private final PParameter parameter_term = new PParameter("term", "ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSFofFormula")), PParameterDirection.INOUT);

-    

-    private final List<PParameter> parameters = Arrays.asList(parameter_term);

-    

-    private GeneratedPQuery() {

-      super(PVisibility.PUBLIC);

-    }

-    

-    @Override

-    public String getFullyQualifiedName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFofFormula";

-    }

-    

-    @Override

-    public List<String> getParameterNames() {

-      return Arrays.asList("term");

-    }

-    

-    @Override

-    public List<PParameter> getParameters() {

-      return parameters;

-    }

-    

-    @Override

-    public Set<PBody> doGetContainedBodies() {

-      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));

-      Set<PBody> bodies = new LinkedHashSet<>();

-      {

-          PBody body = new PBody(this);

-          PVariable var_term = body.getOrCreateVariableByName("term");

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSFofFormula")));

-          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

-             new ExportedParameter(body, var_term, parameter_term)

-          ));

-          //    VLSFofFormula(term)

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSFofFormula")));

-          bodies.add(body);

-      }

-      return bodies;

-    }

-  }

-}

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSFunction.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSFunction.java
deleted file mode 100644
index f81a6e1a..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSFunction.java
+++ /dev/null
@@ -1,533 +0,0 @@
-/**

- * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.queries/src/ca/mcgill/ecse/dslreasoner/vampire/queries/vampireQueries.vql

- */

-package ca.mcgill.ecse.dslreasoner.vampire.queries;

-

-import java.util.Arrays;

-import java.util.Collection;

-import java.util.LinkedHashSet;

-import java.util.List;

-import java.util.Objects;

-import java.util.Optional;

-import java.util.Set;

-import java.util.function.Consumer;

-import java.util.stream.Collectors;

-import java.util.stream.Stream;

-import org.apache.log4j.Logger;

-import org.eclipse.emf.ecore.EClass;

-import org.eclipse.viatra.query.runtime.api.IPatternMatch;

-import org.eclipse.viatra.query.runtime.api.IQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;

-import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;

-import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;

-import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;

-import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;

-

-/**

- * A pattern-specific query specification that can instantiate Matcher in a type-safe way.

- * 

- * <p>Original source:

- *         <code><pre>

- *         pattern VLSFunction(term: VLSFunction){

- *              VLSFunction(term);

- *         }

- * </pre></code>

- * 

- * @see Matcher

- * @see Match

- * 

- */

-@SuppressWarnings("all")

-public final class VLSFunction extends BaseGeneratedEMFQuerySpecification<VLSFunction.Matcher> {

-  /**

-   * Pattern-specific match representation of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunction pattern,

-   * to be used in conjunction with {@link Matcher}.

-   * 

-   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

-   * Each instance is a (possibly partial) substitution of pattern parameters,

-   * usable to represent a match of the pattern in the result of a query,

-   * or to specify the bound (fixed) input parameters when issuing a query.

-   * 

-   * @see Matcher

-   * 

-   */

-  public static abstract class Match extends BasePatternMatch {

-    private ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction fTerm;

-    

-    private static List<String> parameterNames = makeImmutableList("term");

-    

-    private Match(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction pTerm) {

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public Object get(final String parameterName) {

-      if ("term".equals(parameterName)) return this.fTerm;

-      return null;

-    }

-    

-    public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction getTerm() {

-      return this.fTerm;

-    }

-    

-    @Override

-    public boolean set(final String parameterName, final Object newValue) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      if ("term".equals(parameterName) ) {

-          this.fTerm = (ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction) newValue;

-          return true;

-      }

-      return false;

-    }

-    

-    public void setTerm(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction pTerm) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public String patternName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunction";

-    }

-    

-    @Override

-    public List<String> parameterNames() {

-      return VLSFunction.Match.parameterNames;

-    }

-    

-    @Override

-    public Object[] toArray() {

-      return new Object[]{fTerm};

-    }

-    

-    @Override

-    public VLSFunction.Match toImmutable() {

-      return isMutable() ? newMatch(fTerm) : this;

-    }

-    

-    @Override

-    public String prettyPrint() {

-      StringBuilder result = new StringBuilder();

-      result.append("\"term\"=" + prettyPrintValue(fTerm));

-      return result.toString();

-    }

-    

-    @Override

-    public int hashCode() {

-      return Objects.hash(fTerm);

-    }

-    

-    @Override

-    public boolean equals(final Object obj) {

-      if (this == obj)

-          return true;

-      if (obj == null) {

-          return false;

-      }

-      if ((obj instanceof VLSFunction.Match)) {

-          VLSFunction.Match other = (VLSFunction.Match) obj;

-          return Objects.equals(fTerm, other.fTerm);

-      } else {

-          // this should be infrequent

-          if (!(obj instanceof IPatternMatch)) {

-              return false;

-          }

-          IPatternMatch otherSig  = (IPatternMatch) obj;

-          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());

-      }

-    }

-    

-    @Override

-    public VLSFunction specification() {

-      return VLSFunction.instance();

-    }

-    

-    /**

-     * Returns an empty, mutable match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @return the empty match.

-     * 

-     */

-    public static VLSFunction.Match newEmptyMatch() {

-      return new Mutable(null);

-    }

-    

-    /**

-     * Returns a mutable (partial) match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the new, mutable (partial) match object.

-     * 

-     */

-    public static VLSFunction.Match newMutableMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction pTerm) {

-      return new Mutable(pTerm);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public static VLSFunction.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction pTerm) {

-      return new Immutable(pTerm);

-    }

-    

-    private static final class Mutable extends VLSFunction.Match {

-      Mutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return true;

-      }

-    }

-    

-    private static final class Immutable extends VLSFunction.Match {

-      Immutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return false;

-      }

-    }

-  }

-  

-  /**

-   * Generated pattern matcher API of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunction pattern,

-   * providing pattern-specific query methods.

-   * 

-   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

-   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.

-   * 

-   * <p>Matches of the pattern will be represented as {@link Match}.

-   * 

-   * <p>Original source:

-   * <code><pre>

-   * pattern VLSFunction(term: VLSFunction){

-   *    VLSFunction(term);

-   * }

-   * </pre></code>

-   * 

-   * @see Match

-   * @see VLSFunction

-   * 

-   */

-  public static class Matcher extends BaseMatcher<VLSFunction.Match> {

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    public static VLSFunction.Matcher on(final ViatraQueryEngine engine) {

-      // check if matcher already exists

-      Matcher matcher = engine.getExistingMatcher(querySpecification());

-      if (matcher == null) {

-          matcher = (Matcher)engine.getMatcher(querySpecification());

-      }

-      return matcher;

-    }

-    

-    /**

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * @return an initialized matcher

-     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

-     * 

-     */

-    public static VLSFunction.Matcher create() {

-      return new Matcher();

-    }

-    

-    private final static int POSITION_TERM = 0;

-    

-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSFunction.Matcher.class);

-    

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    private Matcher() {

-      super(querySpecification());

-    }

-    

-    /**

-     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return matches represented as a Match object.

-     * 

-     */

-    public Collection<VLSFunction.Match> getAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm}).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.

-     * </p>

-     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

-     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

-     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a stream of matches represented as a Match object.

-     * 

-     */

-    public Stream<VLSFunction.Match> streamAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a match represented as a Match object, or null if no match is found.

-     * 

-     */

-    public Optional<VLSFunction.Match> getOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction pTerm) {

-      return rawGetOneArbitraryMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

-     * under any possible substitution of the unspecified parameters (if any).

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return true if the input is a valid (partial) match of the pattern.

-     * 

-     */

-    public boolean hasMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction pTerm) {

-      return rawHasMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the number of pattern matches found.

-     * 

-     */

-    public int countMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction pTerm) {

-      return rawCountMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @param processor the action that will process the selected match.

-     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

-     * 

-     */

-    public boolean forOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction pTerm, final Consumer<? super VLSFunction.Match> processor) {

-      return rawForOneArbitraryMatch(new Object[]{pTerm}, processor);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public VLSFunction.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction pTerm) {

-      return VLSFunction.Match.newMatch(pTerm);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    protected Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction> rawStreamAllValuesOfterm(final Object[] parameters) {

-      return rawStreamAllValues(POSITION_TERM, parameters).map(ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction.class::cast);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Set<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction> getAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray()).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction> streamAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray());

-    }

-    

-    @Override

-    protected VLSFunction.Match tupleToMatch(final Tuple t) {

-      try {

-          return VLSFunction.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction) t.get(POSITION_TERM));

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in tuple not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSFunction.Match arrayToMatch(final Object[] match) {

-      try {

-          return VLSFunction.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSFunction.Match arrayToMatchMutable(final Object[] match) {

-      try {

-          return VLSFunction.Match.newMutableMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    /**

-     * @return the singleton instance of the query specification of this pattern

-     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-     * 

-     */

-    public static IQuerySpecification<VLSFunction.Matcher> querySpecification() {

-      return VLSFunction.instance();

-    }

-  }

-  

-  private VLSFunction() {

-    super(GeneratedPQuery.INSTANCE);

-  }

-  

-  /**

-   * @return the singleton instance of the query specification

-   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-   * 

-   */

-  public static VLSFunction instance() {

-    try{

-        return LazyHolder.INSTANCE;

-    } catch (ExceptionInInitializerError err) {

-        throw processInitializerError(err);

-    }

-  }

-  

-  @Override

-  protected VLSFunction.Matcher instantiate(final ViatraQueryEngine engine) {

-    return VLSFunction.Matcher.on(engine);

-  }

-  

-  @Override

-  public VLSFunction.Matcher instantiate() {

-    return VLSFunction.Matcher.create();

-  }

-  

-  @Override

-  public VLSFunction.Match newEmptyMatch() {

-    return VLSFunction.Match.newEmptyMatch();

-  }

-  

-  @Override

-  public VLSFunction.Match newMatch(final Object... parameters) {

-    return VLSFunction.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction) parameters[0]);

-  }

-  

-  /**

-   * Inner class allowing the singleton instance of {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunction (visibility: PUBLIC, simpleName: VLSFunction, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunction, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

-   *     <b>not</b> at the class load time of the outer class, 

-   *     but rather at the first call to {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunction (visibility: PUBLIC, simpleName: VLSFunction, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunction, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

-   * 

-   * <p> This workaround is required e.g. to support recursion.

-   * 

-   */

-  private static class LazyHolder {

-    private final static VLSFunction INSTANCE = new VLSFunction();

-    

-    /**

-     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

-     * This initialization order is required to support indirect recursion.

-     * 

-     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.

-     * 

-     */

-    private final static Object STATIC_INITIALIZER = ensureInitialized();

-    

-    public static Object ensureInitialized() {

-      INSTANCE.ensureInitializedInternal();

-      return null;

-    }

-  }

-  

-  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

-    private final static VLSFunction.GeneratedPQuery INSTANCE = new GeneratedPQuery();

-    

-    private final PParameter parameter_term = new PParameter("term", "ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSFunction")), PParameterDirection.INOUT);

-    

-    private final List<PParameter> parameters = Arrays.asList(parameter_term);

-    

-    private GeneratedPQuery() {

-      super(PVisibility.PUBLIC);

-    }

-    

-    @Override

-    public String getFullyQualifiedName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunction";

-    }

-    

-    @Override

-    public List<String> getParameterNames() {

-      return Arrays.asList("term");

-    }

-    

-    @Override

-    public List<PParameter> getParameters() {

-      return parameters;

-    }

-    

-    @Override

-    public Set<PBody> doGetContainedBodies() {

-      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));

-      Set<PBody> bodies = new LinkedHashSet<>();

-      {

-          PBody body = new PBody(this);

-          PVariable var_term = body.getOrCreateVariableByName("term");

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSFunction")));

-          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

-             new ExportedParameter(body, var_term, parameter_term)

-          ));

-          //    VLSFunction(term)

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSFunction")));

-          bodies.add(body);

-      }

-      return bodies;

-    }

-  }

-}

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSFunctionFof.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSFunctionFof.java
deleted file mode 100644
index 86a3b95c..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSFunctionFof.java
+++ /dev/null
@@ -1,533 +0,0 @@
-/**

- * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.queries/src/ca/mcgill/ecse/dslreasoner/vampire/queries/vampireQueries.vql

- */

-package ca.mcgill.ecse.dslreasoner.vampire.queries;

-

-import java.util.Arrays;

-import java.util.Collection;

-import java.util.LinkedHashSet;

-import java.util.List;

-import java.util.Objects;

-import java.util.Optional;

-import java.util.Set;

-import java.util.function.Consumer;

-import java.util.stream.Collectors;

-import java.util.stream.Stream;

-import org.apache.log4j.Logger;

-import org.eclipse.emf.ecore.EClass;

-import org.eclipse.viatra.query.runtime.api.IPatternMatch;

-import org.eclipse.viatra.query.runtime.api.IQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;

-import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;

-import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;

-import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;

-import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;

-

-/**

- * A pattern-specific query specification that can instantiate Matcher in a type-safe way.

- * 

- * <p>Original source:

- *         <code><pre>

- *         pattern VLSFunctionFof(term: VLSFunctionFof){

- *              VLSFunctionFof(term);

- *         }

- * </pre></code>

- * 

- * @see Matcher

- * @see Match

- * 

- */

-@SuppressWarnings("all")

-public final class VLSFunctionFof extends BaseGeneratedEMFQuerySpecification<VLSFunctionFof.Matcher> {

-  /**

-   * Pattern-specific match representation of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunctionFof pattern,

-   * to be used in conjunction with {@link Matcher}.

-   * 

-   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

-   * Each instance is a (possibly partial) substitution of pattern parameters,

-   * usable to represent a match of the pattern in the result of a query,

-   * or to specify the bound (fixed) input parameters when issuing a query.

-   * 

-   * @see Matcher

-   * 

-   */

-  public static abstract class Match extends BasePatternMatch {

-    private ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof fTerm;

-    

-    private static List<String> parameterNames = makeImmutableList("term");

-    

-    private Match(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof pTerm) {

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public Object get(final String parameterName) {

-      if ("term".equals(parameterName)) return this.fTerm;

-      return null;

-    }

-    

-    public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof getTerm() {

-      return this.fTerm;

-    }

-    

-    @Override

-    public boolean set(final String parameterName, final Object newValue) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      if ("term".equals(parameterName) ) {

-          this.fTerm = (ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof) newValue;

-          return true;

-      }

-      return false;

-    }

-    

-    public void setTerm(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof pTerm) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public String patternName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunctionFof";

-    }

-    

-    @Override

-    public List<String> parameterNames() {

-      return VLSFunctionFof.Match.parameterNames;

-    }

-    

-    @Override

-    public Object[] toArray() {

-      return new Object[]{fTerm};

-    }

-    

-    @Override

-    public VLSFunctionFof.Match toImmutable() {

-      return isMutable() ? newMatch(fTerm) : this;

-    }

-    

-    @Override

-    public String prettyPrint() {

-      StringBuilder result = new StringBuilder();

-      result.append("\"term\"=" + prettyPrintValue(fTerm));

-      return result.toString();

-    }

-    

-    @Override

-    public int hashCode() {

-      return Objects.hash(fTerm);

-    }

-    

-    @Override

-    public boolean equals(final Object obj) {

-      if (this == obj)

-          return true;

-      if (obj == null) {

-          return false;

-      }

-      if ((obj instanceof VLSFunctionFof.Match)) {

-          VLSFunctionFof.Match other = (VLSFunctionFof.Match) obj;

-          return Objects.equals(fTerm, other.fTerm);

-      } else {

-          // this should be infrequent

-          if (!(obj instanceof IPatternMatch)) {

-              return false;

-          }

-          IPatternMatch otherSig  = (IPatternMatch) obj;

-          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());

-      }

-    }

-    

-    @Override

-    public VLSFunctionFof specification() {

-      return VLSFunctionFof.instance();

-    }

-    

-    /**

-     * Returns an empty, mutable match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @return the empty match.

-     * 

-     */

-    public static VLSFunctionFof.Match newEmptyMatch() {

-      return new Mutable(null);

-    }

-    

-    /**

-     * Returns a mutable (partial) match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the new, mutable (partial) match object.

-     * 

-     */

-    public static VLSFunctionFof.Match newMutableMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof pTerm) {

-      return new Mutable(pTerm);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public static VLSFunctionFof.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof pTerm) {

-      return new Immutable(pTerm);

-    }

-    

-    private static final class Mutable extends VLSFunctionFof.Match {

-      Mutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return true;

-      }

-    }

-    

-    private static final class Immutable extends VLSFunctionFof.Match {

-      Immutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return false;

-      }

-    }

-  }

-  

-  /**

-   * Generated pattern matcher API of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunctionFof pattern,

-   * providing pattern-specific query methods.

-   * 

-   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

-   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.

-   * 

-   * <p>Matches of the pattern will be represented as {@link Match}.

-   * 

-   * <p>Original source:

-   * <code><pre>

-   * pattern VLSFunctionFof(term: VLSFunctionFof){

-   *    VLSFunctionFof(term);

-   * }

-   * </pre></code>

-   * 

-   * @see Match

-   * @see VLSFunctionFof

-   * 

-   */

-  public static class Matcher extends BaseMatcher<VLSFunctionFof.Match> {

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    public static VLSFunctionFof.Matcher on(final ViatraQueryEngine engine) {

-      // check if matcher already exists

-      Matcher matcher = engine.getExistingMatcher(querySpecification());

-      if (matcher == null) {

-          matcher = (Matcher)engine.getMatcher(querySpecification());

-      }

-      return matcher;

-    }

-    

-    /**

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * @return an initialized matcher

-     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

-     * 

-     */

-    public static VLSFunctionFof.Matcher create() {

-      return new Matcher();

-    }

-    

-    private final static int POSITION_TERM = 0;

-    

-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSFunctionFof.Matcher.class);

-    

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    private Matcher() {

-      super(querySpecification());

-    }

-    

-    /**

-     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return matches represented as a Match object.

-     * 

-     */

-    public Collection<VLSFunctionFof.Match> getAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm}).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.

-     * </p>

-     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

-     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

-     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a stream of matches represented as a Match object.

-     * 

-     */

-    public Stream<VLSFunctionFof.Match> streamAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a match represented as a Match object, or null if no match is found.

-     * 

-     */

-    public Optional<VLSFunctionFof.Match> getOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof pTerm) {

-      return rawGetOneArbitraryMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

-     * under any possible substitution of the unspecified parameters (if any).

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return true if the input is a valid (partial) match of the pattern.

-     * 

-     */

-    public boolean hasMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof pTerm) {

-      return rawHasMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the number of pattern matches found.

-     * 

-     */

-    public int countMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof pTerm) {

-      return rawCountMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @param processor the action that will process the selected match.

-     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

-     * 

-     */

-    public boolean forOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof pTerm, final Consumer<? super VLSFunctionFof.Match> processor) {

-      return rawForOneArbitraryMatch(new Object[]{pTerm}, processor);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public VLSFunctionFof.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof pTerm) {

-      return VLSFunctionFof.Match.newMatch(pTerm);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    protected Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof> rawStreamAllValuesOfterm(final Object[] parameters) {

-      return rawStreamAllValues(POSITION_TERM, parameters).map(ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof.class::cast);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Set<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof> getAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray()).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof> streamAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray());

-    }

-    

-    @Override

-    protected VLSFunctionFof.Match tupleToMatch(final Tuple t) {

-      try {

-          return VLSFunctionFof.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof) t.get(POSITION_TERM));

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in tuple not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSFunctionFof.Match arrayToMatch(final Object[] match) {

-      try {

-          return VLSFunctionFof.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSFunctionFof.Match arrayToMatchMutable(final Object[] match) {

-      try {

-          return VLSFunctionFof.Match.newMutableMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    /**

-     * @return the singleton instance of the query specification of this pattern

-     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-     * 

-     */

-    public static IQuerySpecification<VLSFunctionFof.Matcher> querySpecification() {

-      return VLSFunctionFof.instance();

-    }

-  }

-  

-  private VLSFunctionFof() {

-    super(GeneratedPQuery.INSTANCE);

-  }

-  

-  /**

-   * @return the singleton instance of the query specification

-   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-   * 

-   */

-  public static VLSFunctionFof instance() {

-    try{

-        return LazyHolder.INSTANCE;

-    } catch (ExceptionInInitializerError err) {

-        throw processInitializerError(err);

-    }

-  }

-  

-  @Override

-  protected VLSFunctionFof.Matcher instantiate(final ViatraQueryEngine engine) {

-    return VLSFunctionFof.Matcher.on(engine);

-  }

-  

-  @Override

-  public VLSFunctionFof.Matcher instantiate() {

-    return VLSFunctionFof.Matcher.create();

-  }

-  

-  @Override

-  public VLSFunctionFof.Match newEmptyMatch() {

-    return VLSFunctionFof.Match.newEmptyMatch();

-  }

-  

-  @Override

-  public VLSFunctionFof.Match newMatch(final Object... parameters) {

-    return VLSFunctionFof.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof) parameters[0]);

-  }

-  

-  /**

-   * Inner class allowing the singleton instance of {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunctionFof (visibility: PUBLIC, simpleName: VLSFunctionFof, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunctionFof, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

-   *     <b>not</b> at the class load time of the outer class, 

-   *     but rather at the first call to {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunctionFof (visibility: PUBLIC, simpleName: VLSFunctionFof, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunctionFof, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

-   * 

-   * <p> This workaround is required e.g. to support recursion.

-   * 

-   */

-  private static class LazyHolder {

-    private final static VLSFunctionFof INSTANCE = new VLSFunctionFof();

-    

-    /**

-     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

-     * This initialization order is required to support indirect recursion.

-     * 

-     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.

-     * 

-     */

-    private final static Object STATIC_INITIALIZER = ensureInitialized();

-    

-    public static Object ensureInitialized() {

-      INSTANCE.ensureInitializedInternal();

-      return null;

-    }

-  }

-  

-  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

-    private final static VLSFunctionFof.GeneratedPQuery INSTANCE = new GeneratedPQuery();

-    

-    private final PParameter parameter_term = new PParameter("term", "ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionFof", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSFunctionFof")), PParameterDirection.INOUT);

-    

-    private final List<PParameter> parameters = Arrays.asList(parameter_term);

-    

-    private GeneratedPQuery() {

-      super(PVisibility.PUBLIC);

-    }

-    

-    @Override

-    public String getFullyQualifiedName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunctionFof";

-    }

-    

-    @Override

-    public List<String> getParameterNames() {

-      return Arrays.asList("term");

-    }

-    

-    @Override

-    public List<PParameter> getParameters() {

-      return parameters;

-    }

-    

-    @Override

-    public Set<PBody> doGetContainedBodies() {

-      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));

-      Set<PBody> bodies = new LinkedHashSet<>();

-      {

-          PBody body = new PBody(this);

-          PVariable var_term = body.getOrCreateVariableByName("term");

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSFunctionFof")));

-          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

-             new ExportedParameter(body, var_term, parameter_term)

-          ));

-          //    VLSFunctionFof(term)

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSFunctionFof")));

-          bodies.add(body);

-      }

-      return bodies;

-    }

-  }

-}

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSInequality.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSInequality.java
deleted file mode 100644
index 0dd35ed9..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSInequality.java
+++ /dev/null
@@ -1,533 +0,0 @@
-/**

- * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.queries/src/ca/mcgill/ecse/dslreasoner/vampire/queries/vampireQueries.vql

- */

-package ca.mcgill.ecse.dslreasoner.vampire.queries;

-

-import java.util.Arrays;

-import java.util.Collection;

-import java.util.LinkedHashSet;

-import java.util.List;

-import java.util.Objects;

-import java.util.Optional;

-import java.util.Set;

-import java.util.function.Consumer;

-import java.util.stream.Collectors;

-import java.util.stream.Stream;

-import org.apache.log4j.Logger;

-import org.eclipse.emf.ecore.EClass;

-import org.eclipse.viatra.query.runtime.api.IPatternMatch;

-import org.eclipse.viatra.query.runtime.api.IQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;

-import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;

-import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;

-import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;

-import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;

-

-/**

- * A pattern-specific query specification that can instantiate Matcher in a type-safe way.

- * 

- * <p>Original source:

- *         <code><pre>

- *         pattern VLSInequality(term: VLSInequality){

- *              VLSInequality(term);

- *         }

- * </pre></code>

- * 

- * @see Matcher

- * @see Match

- * 

- */

-@SuppressWarnings("all")

-public final class VLSInequality extends BaseGeneratedEMFQuerySpecification<VLSInequality.Matcher> {

-  /**

-   * Pattern-specific match representation of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSInequality pattern,

-   * to be used in conjunction with {@link Matcher}.

-   * 

-   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

-   * Each instance is a (possibly partial) substitution of pattern parameters,

-   * usable to represent a match of the pattern in the result of a query,

-   * or to specify the bound (fixed) input parameters when issuing a query.

-   * 

-   * @see Matcher

-   * 

-   */

-  public static abstract class Match extends BasePatternMatch {

-    private ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality fTerm;

-    

-    private static List<String> parameterNames = makeImmutableList("term");

-    

-    private Match(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality pTerm) {

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public Object get(final String parameterName) {

-      if ("term".equals(parameterName)) return this.fTerm;

-      return null;

-    }

-    

-    public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality getTerm() {

-      return this.fTerm;

-    }

-    

-    @Override

-    public boolean set(final String parameterName, final Object newValue) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      if ("term".equals(parameterName) ) {

-          this.fTerm = (ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality) newValue;

-          return true;

-      }

-      return false;

-    }

-    

-    public void setTerm(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality pTerm) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public String patternName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSInequality";

-    }

-    

-    @Override

-    public List<String> parameterNames() {

-      return VLSInequality.Match.parameterNames;

-    }

-    

-    @Override

-    public Object[] toArray() {

-      return new Object[]{fTerm};

-    }

-    

-    @Override

-    public VLSInequality.Match toImmutable() {

-      return isMutable() ? newMatch(fTerm) : this;

-    }

-    

-    @Override

-    public String prettyPrint() {

-      StringBuilder result = new StringBuilder();

-      result.append("\"term\"=" + prettyPrintValue(fTerm));

-      return result.toString();

-    }

-    

-    @Override

-    public int hashCode() {

-      return Objects.hash(fTerm);

-    }

-    

-    @Override

-    public boolean equals(final Object obj) {

-      if (this == obj)

-          return true;

-      if (obj == null) {

-          return false;

-      }

-      if ((obj instanceof VLSInequality.Match)) {

-          VLSInequality.Match other = (VLSInequality.Match) obj;

-          return Objects.equals(fTerm, other.fTerm);

-      } else {

-          // this should be infrequent

-          if (!(obj instanceof IPatternMatch)) {

-              return false;

-          }

-          IPatternMatch otherSig  = (IPatternMatch) obj;

-          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());

-      }

-    }

-    

-    @Override

-    public VLSInequality specification() {

-      return VLSInequality.instance();

-    }

-    

-    /**

-     * Returns an empty, mutable match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @return the empty match.

-     * 

-     */

-    public static VLSInequality.Match newEmptyMatch() {

-      return new Mutable(null);

-    }

-    

-    /**

-     * Returns a mutable (partial) match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the new, mutable (partial) match object.

-     * 

-     */

-    public static VLSInequality.Match newMutableMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality pTerm) {

-      return new Mutable(pTerm);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public static VLSInequality.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality pTerm) {

-      return new Immutable(pTerm);

-    }

-    

-    private static final class Mutable extends VLSInequality.Match {

-      Mutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return true;

-      }

-    }

-    

-    private static final class Immutable extends VLSInequality.Match {

-      Immutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return false;

-      }

-    }

-  }

-  

-  /**

-   * Generated pattern matcher API of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSInequality pattern,

-   * providing pattern-specific query methods.

-   * 

-   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

-   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.

-   * 

-   * <p>Matches of the pattern will be represented as {@link Match}.

-   * 

-   * <p>Original source:

-   * <code><pre>

-   * pattern VLSInequality(term: VLSInequality){

-   *    VLSInequality(term);

-   * }

-   * </pre></code>

-   * 

-   * @see Match

-   * @see VLSInequality

-   * 

-   */

-  public static class Matcher extends BaseMatcher<VLSInequality.Match> {

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    public static VLSInequality.Matcher on(final ViatraQueryEngine engine) {

-      // check if matcher already exists

-      Matcher matcher = engine.getExistingMatcher(querySpecification());

-      if (matcher == null) {

-          matcher = (Matcher)engine.getMatcher(querySpecification());

-      }

-      return matcher;

-    }

-    

-    /**

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * @return an initialized matcher

-     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

-     * 

-     */

-    public static VLSInequality.Matcher create() {

-      return new Matcher();

-    }

-    

-    private final static int POSITION_TERM = 0;

-    

-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSInequality.Matcher.class);

-    

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    private Matcher() {

-      super(querySpecification());

-    }

-    

-    /**

-     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return matches represented as a Match object.

-     * 

-     */

-    public Collection<VLSInequality.Match> getAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm}).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.

-     * </p>

-     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

-     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

-     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a stream of matches represented as a Match object.

-     * 

-     */

-    public Stream<VLSInequality.Match> streamAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a match represented as a Match object, or null if no match is found.

-     * 

-     */

-    public Optional<VLSInequality.Match> getOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality pTerm) {

-      return rawGetOneArbitraryMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

-     * under any possible substitution of the unspecified parameters (if any).

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return true if the input is a valid (partial) match of the pattern.

-     * 

-     */

-    public boolean hasMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality pTerm) {

-      return rawHasMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the number of pattern matches found.

-     * 

-     */

-    public int countMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality pTerm) {

-      return rawCountMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @param processor the action that will process the selected match.

-     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

-     * 

-     */

-    public boolean forOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality pTerm, final Consumer<? super VLSInequality.Match> processor) {

-      return rawForOneArbitraryMatch(new Object[]{pTerm}, processor);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public VLSInequality.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality pTerm) {

-      return VLSInequality.Match.newMatch(pTerm);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    protected Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality> rawStreamAllValuesOfterm(final Object[] parameters) {

-      return rawStreamAllValues(POSITION_TERM, parameters).map(ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality.class::cast);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Set<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality> getAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray()).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality> streamAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray());

-    }

-    

-    @Override

-    protected VLSInequality.Match tupleToMatch(final Tuple t) {

-      try {

-          return VLSInequality.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality) t.get(POSITION_TERM));

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in tuple not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSInequality.Match arrayToMatch(final Object[] match) {

-      try {

-          return VLSInequality.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSInequality.Match arrayToMatchMutable(final Object[] match) {

-      try {

-          return VLSInequality.Match.newMutableMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    /**

-     * @return the singleton instance of the query specification of this pattern

-     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-     * 

-     */

-    public static IQuerySpecification<VLSInequality.Matcher> querySpecification() {

-      return VLSInequality.instance();

-    }

-  }

-  

-  private VLSInequality() {

-    super(GeneratedPQuery.INSTANCE);

-  }

-  

-  /**

-   * @return the singleton instance of the query specification

-   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-   * 

-   */

-  public static VLSInequality instance() {

-    try{

-        return LazyHolder.INSTANCE;

-    } catch (ExceptionInInitializerError err) {

-        throw processInitializerError(err);

-    }

-  }

-  

-  @Override

-  protected VLSInequality.Matcher instantiate(final ViatraQueryEngine engine) {

-    return VLSInequality.Matcher.on(engine);

-  }

-  

-  @Override

-  public VLSInequality.Matcher instantiate() {

-    return VLSInequality.Matcher.create();

-  }

-  

-  @Override

-  public VLSInequality.Match newEmptyMatch() {

-    return VLSInequality.Match.newEmptyMatch();

-  }

-  

-  @Override

-  public VLSInequality.Match newMatch(final Object... parameters) {

-    return VLSInequality.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality) parameters[0]);

-  }

-  

-  /**

-   * Inner class allowing the singleton instance of {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSInequality (visibility: PUBLIC, simpleName: VLSInequality, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSInequality, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

-   *     <b>not</b> at the class load time of the outer class, 

-   *     but rather at the first call to {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSInequality (visibility: PUBLIC, simpleName: VLSInequality, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSInequality, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

-   * 

-   * <p> This workaround is required e.g. to support recursion.

-   * 

-   */

-  private static class LazyHolder {

-    private final static VLSInequality INSTANCE = new VLSInequality();

-    

-    /**

-     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

-     * This initialization order is required to support indirect recursion.

-     * 

-     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.

-     * 

-     */

-    private final static Object STATIC_INITIALIZER = ensureInitialized();

-    

-    public static Object ensureInitialized() {

-      INSTANCE.ensureInitializedInternal();

-      return null;

-    }

-  }

-  

-  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

-    private final static VLSInequality.GeneratedPQuery INSTANCE = new GeneratedPQuery();

-    

-    private final PParameter parameter_term = new PParameter("term", "ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSInequality")), PParameterDirection.INOUT);

-    

-    private final List<PParameter> parameters = Arrays.asList(parameter_term);

-    

-    private GeneratedPQuery() {

-      super(PVisibility.PUBLIC);

-    }

-    

-    @Override

-    public String getFullyQualifiedName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSInequality";

-    }

-    

-    @Override

-    public List<String> getParameterNames() {

-      return Arrays.asList("term");

-    }

-    

-    @Override

-    public List<PParameter> getParameters() {

-      return parameters;

-    }

-    

-    @Override

-    public Set<PBody> doGetContainedBodies() {

-      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));

-      Set<PBody> bodies = new LinkedHashSet<>();

-      {

-          PBody body = new PBody(this);

-          PVariable var_term = body.getOrCreateVariableByName("term");

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSInequality")));

-          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

-             new ExportedParameter(body, var_term, parameter_term)

-          ));

-          //    VLSInequality(term)

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSInequality")));

-          bodies.add(body);

-      }

-      return bodies;

-    }

-  }

-}

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSUnaryNegation.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSUnaryNegation.java
deleted file mode 100644
index b6290aab..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VLSUnaryNegation.java
+++ /dev/null
@@ -1,533 +0,0 @@
-/**

- * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.queries/src/ca/mcgill/ecse/dslreasoner/vampire/queries/vampireQueries.vql

- */

-package ca.mcgill.ecse.dslreasoner.vampire.queries;

-

-import java.util.Arrays;

-import java.util.Collection;

-import java.util.LinkedHashSet;

-import java.util.List;

-import java.util.Objects;

-import java.util.Optional;

-import java.util.Set;

-import java.util.function.Consumer;

-import java.util.stream.Collectors;

-import java.util.stream.Stream;

-import org.apache.log4j.Logger;

-import org.eclipse.emf.ecore.EClass;

-import org.eclipse.viatra.query.runtime.api.IPatternMatch;

-import org.eclipse.viatra.query.runtime.api.IQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;

-import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;

-import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;

-import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;

-import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;

-import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;

-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;

-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;

-import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;

-

-/**

- * A pattern-specific query specification that can instantiate Matcher in a type-safe way.

- * 

- * <p>Original source:

- *         <code><pre>

- *         pattern VLSUnaryNegation(term: VLSUnaryNegation){

- *              VLSUnaryNegation(term);

- *         }

- * </pre></code>

- * 

- * @see Matcher

- * @see Match

- * 

- */

-@SuppressWarnings("all")

-public final class VLSUnaryNegation extends BaseGeneratedEMFQuerySpecification<VLSUnaryNegation.Matcher> {

-  /**

-   * Pattern-specific match representation of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUnaryNegation pattern,

-   * to be used in conjunction with {@link Matcher}.

-   * 

-   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.

-   * Each instance is a (possibly partial) substitution of pattern parameters,

-   * usable to represent a match of the pattern in the result of a query,

-   * or to specify the bound (fixed) input parameters when issuing a query.

-   * 

-   * @see Matcher

-   * 

-   */

-  public static abstract class Match extends BasePatternMatch {

-    private ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation fTerm;

-    

-    private static List<String> parameterNames = makeImmutableList("term");

-    

-    private Match(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation pTerm) {

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public Object get(final String parameterName) {

-      if ("term".equals(parameterName)) return this.fTerm;

-      return null;

-    }

-    

-    public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation getTerm() {

-      return this.fTerm;

-    }

-    

-    @Override

-    public boolean set(final String parameterName, final Object newValue) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      if ("term".equals(parameterName) ) {

-          this.fTerm = (ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation) newValue;

-          return true;

-      }

-      return false;

-    }

-    

-    public void setTerm(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation pTerm) {

-      if (!isMutable()) throw new java.lang.UnsupportedOperationException();

-      this.fTerm = pTerm;

-    }

-    

-    @Override

-    public String patternName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUnaryNegation";

-    }

-    

-    @Override

-    public List<String> parameterNames() {

-      return VLSUnaryNegation.Match.parameterNames;

-    }

-    

-    @Override

-    public Object[] toArray() {

-      return new Object[]{fTerm};

-    }

-    

-    @Override

-    public VLSUnaryNegation.Match toImmutable() {

-      return isMutable() ? newMatch(fTerm) : this;

-    }

-    

-    @Override

-    public String prettyPrint() {

-      StringBuilder result = new StringBuilder();

-      result.append("\"term\"=" + prettyPrintValue(fTerm));

-      return result.toString();

-    }

-    

-    @Override

-    public int hashCode() {

-      return Objects.hash(fTerm);

-    }

-    

-    @Override

-    public boolean equals(final Object obj) {

-      if (this == obj)

-          return true;

-      if (obj == null) {

-          return false;

-      }

-      if ((obj instanceof VLSUnaryNegation.Match)) {

-          VLSUnaryNegation.Match other = (VLSUnaryNegation.Match) obj;

-          return Objects.equals(fTerm, other.fTerm);

-      } else {

-          // this should be infrequent

-          if (!(obj instanceof IPatternMatch)) {

-              return false;

-          }

-          IPatternMatch otherSig  = (IPatternMatch) obj;

-          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());

-      }

-    }

-    

-    @Override

-    public VLSUnaryNegation specification() {

-      return VLSUnaryNegation.instance();

-    }

-    

-    /**

-     * Returns an empty, mutable match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @return the empty match.

-     * 

-     */

-    public static VLSUnaryNegation.Match newEmptyMatch() {

-      return new Mutable(null);

-    }

-    

-    /**

-     * Returns a mutable (partial) match.

-     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.

-     * 

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the new, mutable (partial) match object.

-     * 

-     */

-    public static VLSUnaryNegation.Match newMutableMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation pTerm) {

-      return new Mutable(pTerm);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public static VLSUnaryNegation.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation pTerm) {

-      return new Immutable(pTerm);

-    }

-    

-    private static final class Mutable extends VLSUnaryNegation.Match {

-      Mutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return true;

-      }

-    }

-    

-    private static final class Immutable extends VLSUnaryNegation.Match {

-      Immutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation pTerm) {

-        super(pTerm);

-      }

-      

-      @Override

-      public boolean isMutable() {

-        return false;

-      }

-    }

-  }

-  

-  /**

-   * Generated pattern matcher API of the ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUnaryNegation pattern,

-   * providing pattern-specific query methods.

-   * 

-   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},

-   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.

-   * 

-   * <p>Matches of the pattern will be represented as {@link Match}.

-   * 

-   * <p>Original source:

-   * <code><pre>

-   * pattern VLSUnaryNegation(term: VLSUnaryNegation){

-   *    VLSUnaryNegation(term);

-   * }

-   * </pre></code>

-   * 

-   * @see Match

-   * @see VLSUnaryNegation

-   * 

-   */

-  public static class Matcher extends BaseMatcher<VLSUnaryNegation.Match> {

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    public static VLSUnaryNegation.Matcher on(final ViatraQueryEngine engine) {

-      // check if matcher already exists

-      Matcher matcher = engine.getExistingMatcher(querySpecification());

-      if (matcher == null) {

-          matcher = (Matcher)engine.getMatcher(querySpecification());

-      }

-      return matcher;

-    }

-    

-    /**

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * @return an initialized matcher

-     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.

-     * 

-     */

-    public static VLSUnaryNegation.Matcher create() {

-      return new Matcher();

-    }

-    

-    private final static int POSITION_TERM = 0;

-    

-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSUnaryNegation.Matcher.class);

-    

-    /**

-     * Initializes the pattern matcher within an existing VIATRA Query engine.

-     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.

-     * 

-     * @param engine the existing VIATRA Query engine in which this matcher will be created.

-     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation

-     * 

-     */

-    private Matcher() {

-      super(querySpecification());

-    }

-    

-    /**

-     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return matches represented as a Match object.

-     * 

-     */

-    public Collection<VLSUnaryNegation.Match> getAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm}).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.

-     * </p>

-     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.

-     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.

-     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a stream of matches represented as a Match object.

-     * 

-     */

-    public Stream<VLSUnaryNegation.Match> streamAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation pTerm) {

-      return rawStreamAllMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return a match represented as a Match object, or null if no match is found.

-     * 

-     */

-    public Optional<VLSUnaryNegation.Match> getOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation pTerm) {

-      return rawGetOneArbitraryMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,

-     * under any possible substitution of the unspecified parameters (if any).

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return true if the input is a valid (partial) match of the pattern.

-     * 

-     */

-    public boolean hasMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation pTerm) {

-      return rawHasMatch(new Object[]{pTerm});

-    }

-    

-    /**

-     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the number of pattern matches found.

-     * 

-     */

-    public int countMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation pTerm) {

-      return rawCountMatches(new Object[]{pTerm});

-    }

-    

-    /**

-     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.

-     * Neither determinism nor randomness of selection is guaranteed.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @param processor the action that will process the selected match.

-     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked

-     * 

-     */

-    public boolean forOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation pTerm, final Consumer<? super VLSUnaryNegation.Match> processor) {

-      return rawForOneArbitraryMatch(new Object[]{pTerm}, processor);

-    }

-    

-    /**

-     * Returns a new (partial) match.

-     * This can be used e.g. to call the matcher with a partial match.

-     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.

-     * @param pTerm the fixed value of pattern parameter term, or null if not bound.

-     * @return the (partial) match object.

-     * 

-     */

-    public VLSUnaryNegation.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation pTerm) {

-      return VLSUnaryNegation.Match.newMatch(pTerm);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    protected Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation> rawStreamAllValuesOfterm(final Object[] parameters) {

-      return rawStreamAllValues(POSITION_TERM, parameters).map(ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation.class::cast);

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Set<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation> getAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray()).collect(Collectors.toSet());

-    }

-    

-    /**

-     * Retrieve the set of values that occur in matches for term.

-     * @return the Set of all values or empty set if there are no matches

-     * 

-     */

-    public Stream<ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation> streamAllValuesOfterm() {

-      return rawStreamAllValuesOfterm(emptyArray());

-    }

-    

-    @Override

-    protected VLSUnaryNegation.Match tupleToMatch(final Tuple t) {

-      try {

-          return VLSUnaryNegation.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation) t.get(POSITION_TERM));

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in tuple not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSUnaryNegation.Match arrayToMatch(final Object[] match) {

-      try {

-          return VLSUnaryNegation.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    @Override

-    protected VLSUnaryNegation.Match arrayToMatchMutable(final Object[] match) {

-      try {

-          return VLSUnaryNegation.Match.newMutableMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation) match[POSITION_TERM]);

-      } catch(ClassCastException e) {

-          LOGGER.error("Element(s) in array not properly typed!",e);

-          return null;

-      }

-    }

-    

-    /**

-     * @return the singleton instance of the query specification of this pattern

-     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-     * 

-     */

-    public static IQuerySpecification<VLSUnaryNegation.Matcher> querySpecification() {

-      return VLSUnaryNegation.instance();

-    }

-  }

-  

-  private VLSUnaryNegation() {

-    super(GeneratedPQuery.INSTANCE);

-  }

-  

-  /**

-   * @return the singleton instance of the query specification

-   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded

-   * 

-   */

-  public static VLSUnaryNegation instance() {

-    try{

-        return LazyHolder.INSTANCE;

-    } catch (ExceptionInInitializerError err) {

-        throw processInitializerError(err);

-    }

-  }

-  

-  @Override

-  protected VLSUnaryNegation.Matcher instantiate(final ViatraQueryEngine engine) {

-    return VLSUnaryNegation.Matcher.on(engine);

-  }

-  

-  @Override

-  public VLSUnaryNegation.Matcher instantiate() {

-    return VLSUnaryNegation.Matcher.create();

-  }

-  

-  @Override

-  public VLSUnaryNegation.Match newEmptyMatch() {

-    return VLSUnaryNegation.Match.newEmptyMatch();

-  }

-  

-  @Override

-  public VLSUnaryNegation.Match newMatch(final Object... parameters) {

-    return VLSUnaryNegation.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation) parameters[0]);

-  }

-  

-  /**

-   * Inner class allowing the singleton instance of {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUnaryNegation (visibility: PUBLIC, simpleName: VLSUnaryNegation, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUnaryNegation, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 

-   *     <b>not</b> at the class load time of the outer class, 

-   *     but rather at the first call to {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUnaryNegation (visibility: PUBLIC, simpleName: VLSUnaryNegation, identifier: ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUnaryNegation, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.queries) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.

-   * 

-   * <p> This workaround is required e.g. to support recursion.

-   * 

-   */

-  private static class LazyHolder {

-    private final static VLSUnaryNegation INSTANCE = new VLSUnaryNegation();

-    

-    /**

-     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.

-     * This initialization order is required to support indirect recursion.

-     * 

-     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.

-     * 

-     */

-    private final static Object STATIC_INITIALIZER = ensureInitialized();

-    

-    public static Object ensureInitialized() {

-      INSTANCE.ensureInitializedInternal();

-      return null;

-    }

-  }

-  

-  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {

-    private final static VLSUnaryNegation.GeneratedPQuery INSTANCE = new GeneratedPQuery();

-    

-    private final PParameter parameter_term = new PParameter("term", "ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSUnaryNegation")), PParameterDirection.INOUT);

-    

-    private final List<PParameter> parameters = Arrays.asList(parameter_term);

-    

-    private GeneratedPQuery() {

-      super(PVisibility.PUBLIC);

-    }

-    

-    @Override

-    public String getFullyQualifiedName() {

-      return "ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUnaryNegation";

-    }

-    

-    @Override

-    public List<String> getParameterNames() {

-      return Arrays.asList("term");

-    }

-    

-    @Override

-    public List<PParameter> getParameters() {

-      return parameters;

-    }

-    

-    @Override

-    public Set<PBody> doGetContainedBodies() {

-      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));

-      Set<PBody> bodies = new LinkedHashSet<>();

-      {

-          PBody body = new PBody(this);

-          PVariable var_term = body.getOrCreateVariableByName("term");

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSUnaryNegation")));

-          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(

-             new ExportedParameter(body, var_term, parameter_term)

-          ));

-          //    VLSUnaryNegation(term)

-          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSUnaryNegation")));

-          bodies.add(body);

-      }

-      return bodies;

-    }

-  }

-}

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VampireQueries.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VampireQueries.java
deleted file mode 100644
index e3518cd6..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.queries/src-gen/ca/mcgill/ecse/dslreasoner/vampire/queries/VampireQueries.java
+++ /dev/null
@@ -1,174 +0,0 @@
-/**

- * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.queries/src/ca/mcgill/ecse/dslreasoner/vampire/queries/vampireQueries.vql

- */

-package ca.mcgill.ecse.dslreasoner.vampire.queries;

-

-import ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnd;

-import ca.mcgill.ecse.dslreasoner.vampire.queries.VLSAnnotation;

-import ca.mcgill.ecse.dslreasoner.vampire.queries.VLSComment;

-import ca.mcgill.ecse.dslreasoner.vampire.queries.VLSEquivalent;

-import ca.mcgill.ecse.dslreasoner.vampire.queries.VLSExistentialQuantifier;

-import ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFofFormula;

-import ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunction;

-import ca.mcgill.ecse.dslreasoner.vampire.queries.VLSFunctionFof;

-import ca.mcgill.ecse.dslreasoner.vampire.queries.VLSInequality;

-import ca.mcgill.ecse.dslreasoner.vampire.queries.VLSOr;

-import ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUnaryNegation;

-import ca.mcgill.ecse.dslreasoner.vampire.queries.VLSUniversalQuantifier;

-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedPatternGroup;

-

-/**

- * A pattern group formed of all public patterns defined in vampireQueries.vql.

- * 

- * <p>Use the static instance as any {@link interface org.eclipse.viatra.query.runtime.api.IQueryGroup}, to conveniently prepare

- * a VIATRA Query engine for matching all patterns originally defined in file vampireQueries.vql,

- * in order to achieve better performance than one-by-one on-demand matcher initialization.

- * 

- * <p> From package ca.mcgill.ecse.dslreasoner.vampire.queries, the group contains the definition of the following patterns: <ul>

- * <li>VLSComment</li>

- * <li>VLSFofFormula</li>

- * <li>VLSAnnotation</li>

- * <li>VLSOr</li>

- * <li>VLSAnd</li>

- * <li>VLSEquivalent</li>

- * <li>VLSFunction</li>

- * <li>VLSExistentialQuantifier</li>

- * <li>VLSUniversalQuantifier</li>

- * <li>VLSUnaryNegation</li>

- * <li>VLSInequality</li>

- * <li>VLSFunctionFof</li>

- * </ul>

- * 

- * @see IQueryGroup

- * 

- */

-@SuppressWarnings("all")

-public final class VampireQueries extends BaseGeneratedPatternGroup {

-  /**

-   * Access the pattern group.

-   * 

-   * @return the singleton instance of the group

-   * @throws ViatraQueryRuntimeException if there was an error loading the generated code of pattern specifications

-   * 

-   */

-  public static VampireQueries instance() {

-    if (INSTANCE == null) {

-        INSTANCE = new VampireQueries();

-    }

-    return INSTANCE;

-  }

-  

-  private static VampireQueries INSTANCE;

-  

-  private VampireQueries() {

-    querySpecifications.add(VLSComment.instance());

-    querySpecifications.add(VLSFofFormula.instance());

-    querySpecifications.add(VLSAnnotation.instance());

-    querySpecifications.add(VLSOr.instance());

-    querySpecifications.add(VLSAnd.instance());

-    querySpecifications.add(VLSEquivalent.instance());

-    querySpecifications.add(VLSFunction.instance());

-    querySpecifications.add(VLSExistentialQuantifier.instance());

-    querySpecifications.add(VLSUniversalQuantifier.instance());

-    querySpecifications.add(VLSUnaryNegation.instance());

-    querySpecifications.add(VLSInequality.instance());

-    querySpecifications.add(VLSFunctionFof.instance());

-  }

-  

-  public VLSComment getVLSComment() {

-    return VLSComment.instance();

-  }

-  

-  public VLSComment.Matcher getVLSComment(final ViatraQueryEngine engine) {

-    return VLSComment.Matcher.on(engine);

-  }

-  

-  public VLSFofFormula getVLSFofFormula() {

-    return VLSFofFormula.instance();

-  }

-  

-  public VLSFofFormula.Matcher getVLSFofFormula(final ViatraQueryEngine engine) {

-    return VLSFofFormula.Matcher.on(engine);

-  }

-  

-  public VLSAnnotation getVLSAnnotation() {

-    return VLSAnnotation.instance();

-  }

-  

-  public VLSAnnotation.Matcher getVLSAnnotation(final ViatraQueryEngine engine) {

-    return VLSAnnotation.Matcher.on(engine);

-  }

-  

-  public VLSOr getVLSOr() {

-    return VLSOr.instance();

-  }

-  

-  public VLSOr.Matcher getVLSOr(final ViatraQueryEngine engine) {

-    return VLSOr.Matcher.on(engine);

-  }

-  

-  public VLSAnd getVLSAnd() {

-    return VLSAnd.instance();

-  }

-  

-  public VLSAnd.Matcher getVLSAnd(final ViatraQueryEngine engine) {

-    return VLSAnd.Matcher.on(engine);

-  }

-  

-  public VLSEquivalent getVLSEquivalent() {

-    return VLSEquivalent.instance();

-  }

-  

-  public VLSEquivalent.Matcher getVLSEquivalent(final ViatraQueryEngine engine) {

-    return VLSEquivalent.Matcher.on(engine);

-  }

-  

-  public VLSFunction getVLSFunction() {

-    return VLSFunction.instance();

-  }

-  

-  public VLSFunction.Matcher getVLSFunction(final ViatraQueryEngine engine) {

-    return VLSFunction.Matcher.on(engine);

-  }

-  

-  public VLSExistentialQuantifier getVLSExistentialQuantifier() {

-    return VLSExistentialQuantifier.instance();

-  }

-  

-  public VLSExistentialQuantifier.Matcher getVLSExistentialQuantifier(final ViatraQueryEngine engine) {

-    return VLSExistentialQuantifier.Matcher.on(engine);

-  }

-  

-  public VLSUniversalQuantifier getVLSUniversalQuantifier() {

-    return VLSUniversalQuantifier.instance();

-  }

-  

-  public VLSUniversalQuantifier.Matcher getVLSUniversalQuantifier(final ViatraQueryEngine engine) {

-    return VLSUniversalQuantifier.Matcher.on(engine);

-  }

-  

-  public VLSUnaryNegation getVLSUnaryNegation() {

-    return VLSUnaryNegation.instance();

-  }

-  

-  public VLSUnaryNegation.Matcher getVLSUnaryNegation(final ViatraQueryEngine engine) {

-    return VLSUnaryNegation.Matcher.on(engine);

-  }

-  

-  public VLSInequality getVLSInequality() {

-    return VLSInequality.instance();

-  }

-  

-  public VLSInequality.Matcher getVLSInequality(final ViatraQueryEngine engine) {

-    return VLSInequality.Matcher.on(engine);

-  }

-  

-  public VLSFunctionFof getVLSFunctionFof() {

-    return VLSFunctionFof.instance();

-  }

-  

-  public VLSFunctionFof.Matcher getVLSFunctionFof(final ViatraQueryEngine engine) {

-    return VLSFunctionFof.Matcher.on(engine);

-  }

-}

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/.gitignore b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/.gitignore
index ae3c1726..8d2cfe73 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/.gitignore
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/.gitignore
@@ -1 +1,3 @@
 /bin/
+/src-gen/
+/xtend-gen/
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_ContainmentMapper.xtend b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_ContainmentMapper.xtend
index 0820f47d..ff5a192e 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_ContainmentMapper.xtend
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_ContainmentMapper.xtend
@@ -81,6 +81,14 @@ class Logic2VampireLanguageMapper_ContainmentMapper {
                         val fromType = (l.parameters.get(0) as ComplexTypeReference).referred as Type

                         val toType = (l.parameters.get(1) as ComplexTypeReference).referred as Type

 

+                        val listForAnd = newArrayList

+//                      listForAnd.add(support.duplicate(fromType.lookup(trace.type2Predicate), varB))

+                        listForAnd.add(support.duplicate((l as RelationDeclaration).lookup(trace.rel2Predicate), varList))

+//                      listForAnd.add(createVLSInequality => [

+//                              it.left = support.duplicate(varA)

+//                              it.right = support.duplicate(varB)

+//                      ])

+

                         val relFormula = createVLSFofFormula => [

                                 it.name = support.toIDMultiple("containment", relName)

                                 it.fofRole = "axiom"

@@ -91,11 +99,7 @@ class Logic2VampireLanguageMapper_ContainmentMapper {
                                                 it.left = support.duplicate(toType.lookup(trace.type2Predicate), varA)

                                                 it.right = createVLSExistentialQuantifier => [

                                                         it.variables += support.duplicate(varB)

-                                                        it.operand = createVLSAnd => [

-                                                                it.left = support.duplicate(fromType.lookup(trace.type2Predicate), varB)

-                                                                it.right = support.duplicate((l as RelationDeclaration).lookup(trace.rel2Predicate),

-                                                                        varList)

-                                                        ]

+                                                        it.operand = support.unfoldAnd(listForAnd)

                                                 ]

 

                                                 createVLSEquality => [

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_TypeMapperTrace_FilteredTypes.xtend b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_TypeMapperTrace_FilteredTypes.xtend
deleted file mode 100644
index aba47edb..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_TypeMapperTrace_FilteredTypes.xtend
+++ /dev/null
@@ -1,18 +0,0 @@
-package ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder
-
-import ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction
-import ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSTerm
-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement
-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
-import java.util.HashMap
-import java.util.Map
-
-class Logic2VampireLanguageMapper_TypeMapperTrace_FilteredTypes implements Logic2VampireLanguageMapper_TypeMapperTrace{
-        
-//      public var VLSFofFormula objectSuperClass
-        public val Map<Type, VLSFunction> type2Predicate = new HashMap;
-        public val Map<DefinedElement, VLSFunction> element2Predicate = new HashMap
-        public val Map<Type, VLSTerm> type2PossibleNot = new HashMap
-        public val Map<Type, VLSTerm> type2And = new HashMap
-
-}
\ No newline at end of file
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/.VampireAnalyzerConfiguration.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/.VampireAnalyzerConfiguration.xtendbin
index b86e8068..be554f99 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/.VampireAnalyzerConfiguration.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/.VampireAnalyzerConfiguration.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/.VampireSolver.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/.VampireSolver.xtendbin
index 8e50f399..0ee9b884 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/.VampireSolver.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/.VampireSolver.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper.xtendbin
index 99ba52b8..8e96ba14 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapperTrace.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapperTrace.xtendbin
index 0210a300..ee720e29 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapperTrace.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapperTrace.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_ConstantMapper.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_ConstantMapper.xtendbin
index 7b01a284..528da797 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_ConstantMapper.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_ConstantMapper.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_ContainmentMapper.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_ContainmentMapper.xtendbin
index 9f455fdd..a1204329 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_ContainmentMapper.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_ContainmentMapper.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_RelationMapper.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_RelationMapper.xtendbin
index 0b91349d..3413fc3f 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_RelationMapper.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_RelationMapper.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_ScopeMapper.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_ScopeMapper.xtendbin
index 07e249ce..a53a998a 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_ScopeMapper.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_ScopeMapper.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_Support.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_Support.xtendbin
index 115249ba..f265f6a3 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_Support.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_Support.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_TypeMapper.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_TypeMapper.xtendbin
index 2e86d0c7..efde8350 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_TypeMapper.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_TypeMapper.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_TypeMapperTrace_FilteredTypes.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_TypeMapperTrace_FilteredTypes.xtendbin
deleted file mode 100644
index e870dabc..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_TypeMapperTrace_FilteredTypes.xtendbin
+++ /dev/null
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_TypeMapper_FilteredTypes.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_TypeMapper_FilteredTypes.xtendbin
deleted file mode 100644
index ed198ef6..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Logic2VampireLanguageMapper_TypeMapper_FilteredTypes.xtendbin
+++ /dev/null
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Vampire2LogicMapper.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Vampire2LogicMapper.xtendbin
index cf8e4acd..2cabecc8 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Vampire2LogicMapper.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Vampire2LogicMapper.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.VampireHandler.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.VampireHandler.xtendbin
index 07d5b7b4..57844580 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.VampireHandler.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.VampireHandler.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.VampireModelInterpretation_TypeInterpretation.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.VampireModelInterpretation_TypeInterpretation.xtendbin
index 983108a2..24898f59 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.VampireModelInterpretation_TypeInterpretation.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.VampireModelInterpretation_TypeInterpretation.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.VampireModelInterpretation_TypeInterpretation_FilteredTypes.xtendbin b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.VampireModelInterpretation_TypeInterpretation_FilteredTypes.xtendbin
index 4442cdea..a9589e7e 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.VampireModelInterpretation_TypeInterpretation_FilteredTypes.xtendbin
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.VampireModelInterpretation_TypeInterpretation_FilteredTypes.xtendbin
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_ContainmentMapper.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_ContainmentMapper.java
index da0e5615..8c0ae38d 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_ContainmentMapper.java
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_ContainmentMapper.java
@@ -3,7 +3,6 @@ package ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder;
 import ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder.Logic2VampireLanguageMapper;

 import ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder.Logic2VampireLanguageMapperTrace;

 import ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder.Logic2VampireLanguageMapper_Support;

-import ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd;

 import ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSConstant;

 import ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquality;

 import ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent;

@@ -118,6 +117,8 @@ public class Logic2VampireLanguageMapper_ContainmentMapper {
         TypeReference _get_1 = l_1.getParameters().get(1);

         Type _referred_1 = ((ComplexTypeReference) _get_1).getReferred();

         final Type toType = ((Type) _referred_1);

+        final ArrayList<VLSFunction> listForAnd = CollectionLiterals.<VLSFunction>newArrayList();

+        listForAnd.add(this.support.duplicate(CollectionsUtil.<RelationDeclaration, VLSFunction>lookup(((RelationDeclaration) l_1), trace.rel2Predicate), varList));

         VLSFofFormula _createVLSFofFormula_1 = this.factory.createVLSFofFormula();

         final Procedure1<VLSFofFormula> _function_3 = (VLSFofFormula it) -> {

           it.setName(this.support.toIDMultiple("containment", relName));

@@ -135,13 +136,7 @@ public class Logic2VampireLanguageMapper_ContainmentMapper {
                 EList<VLSVariable> _variables_1 = it_3.getVariables();

                 VLSVariable _duplicate_1 = this.support.duplicate(varB);

                 _variables_1.add(_duplicate_1);

-                VLSAnd _createVLSAnd = this.factory.createVLSAnd();

-                final Procedure1<VLSAnd> _function_7 = (VLSAnd it_4) -> {

-                  it_4.setLeft(this.support.duplicate(CollectionsUtil.<Type, VLSFunction>lookup(fromType, trace.type2Predicate), varB));

-                  it_4.setRight(this.support.duplicate(CollectionsUtil.<RelationDeclaration, VLSFunction>lookup(((RelationDeclaration) l_1), trace.rel2Predicate), varList));

-                };

-                VLSAnd _doubleArrow = ObjectExtensions.<VLSAnd>operator_doubleArrow(_createVLSAnd, _function_7);

-                it_3.setOperand(_doubleArrow);

+                it_3.setOperand(this.support.unfoldAnd(listForAnd));

               };

               VLSExistentialQuantifier _doubleArrow = ObjectExtensions.<VLSExistentialQuantifier>operator_doubleArrow(_createVLSExistentialQuantifier, _function_6);

               it_2.setRight(_doubleArrow);

diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_TypeMapperTrace_FilteredTypes.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_TypeMapperTrace_FilteredTypes.java
deleted file mode 100644
index f7c6cb70..00000000
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_TypeMapperTrace_FilteredTypes.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder;

-

-import ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder.Logic2VampireLanguageMapper_TypeMapperTrace;

-import ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction;

-import ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSTerm;

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement;

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type;

-import java.util.HashMap;

-import java.util.Map;

-

-@SuppressWarnings("all")

-public class Logic2VampireLanguageMapper_TypeMapperTrace_FilteredTypes implements Logic2VampireLanguageMapper_TypeMapperTrace {

-  public final Map<Type, VLSFunction> type2Predicate = new HashMap<Type, VLSFunction>();

-  

-  public final Map<DefinedElement, VLSFunction> element2Predicate = new HashMap<DefinedElement, VLSFunction>();

-  

-  public final Map<Type, VLSTerm> type2PossibleNot = new HashMap<Type, VLSTerm>();

-  

-  public final Map<Type, VLSTerm> type2And = new HashMap<Type, VLSTerm>();

-}

diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/metamodels/fam.aird b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/metamodels/fam.aird
new file mode 100644
index 00000000..75ed2fbb
--- /dev/null
+++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/metamodels/fam.aird
@@ -0,0 +1,633 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<xmi:XMI xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:description="http://www.eclipse.org/sirius/description/1.1.0" xmlns:description_1="http://www.eclipse.org/sirius/diagram/description/1.1.0" xmlns:diagram="http://www.eclipse.org/sirius/diagram/1.1.0" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" xmlns:notation="http://www.eclipse.org/gmf/runtime/1.0.2/notation" xmlns:style="http://www.eclipse.org/sirius/diagram/description/style/1.1.0" xmlns:viewpoint="http://www.eclipse.org/sirius/1.1.0" xsi:schemaLocation="http://www.eclipse.org/sirius/description/1.1.0 http://www.eclipse.org/sirius/1.1.0#//description http://www.eclipse.org/sirius/diagram/description/1.1.0 http://www.eclipse.org/sirius/diagram/1.1.0#//description http://www.eclipse.org/sirius/diagram/description/style/1.1.0 http://www.eclipse.org/sirius/diagram/1.1.0#//description/style">

+  <viewpoint:DAnalysis uid="_WMDXMD6wEemlzLOTmNfcSQ" selectedViews="_W6M2oD6wEemlzLOTmNfcSQ _W6fKgD6wEemlzLOTmNfcSQ _W6kqED6wEemlzLOTmNfcSQ _W6l4MD6wEemlzLOTmNfcSQ" version="14.1.0.201810161215">

+    <semanticResources>fam.ecore</semanticResources>

+    <semanticResources>fam.genmodel</semanticResources>

+    <ownedViews xmi:type="viewpoint:DView" uid="_W6M2oD6wEemlzLOTmNfcSQ">

+      <viewpoint xmi:type="description:Viewpoint" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']"/>

+      <ownedRepresentationDescriptors xmi:type="viewpoint:DRepresentationDescriptor" uid="_Xa8zQT6wEemlzLOTmNfcSQ" name="fam class diagram" repPath="#_XZL4sD6wEemlzLOTmNfcSQ">

+        <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>

+        <target xmi:type="ecore:EPackage" href="fam.ecore#/"/>

+      </ownedRepresentationDescriptors>

+    </ownedViews>

+    <ownedViews xmi:type="viewpoint:DView" uid="_W6fKgD6wEemlzLOTmNfcSQ">

+      <viewpoint xmi:type="description:Viewpoint" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Review']"/>

+    </ownedViews>

+    <ownedViews xmi:type="viewpoint:DView" uid="_W6kqED6wEemlzLOTmNfcSQ">

+      <viewpoint xmi:type="description:Viewpoint" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']"/>

+    </ownedViews>

+    <ownedViews xmi:type="viewpoint:DView" uid="_W6l4MD6wEemlzLOTmNfcSQ">

+      <viewpoint xmi:type="description:Viewpoint" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Generation']"/>

+    </ownedViews>

+  </viewpoint:DAnalysis>

+  <diagram:DSemanticDiagram uid="_XZL4sD6wEemlzLOTmNfcSQ" name="fam class diagram">

+    <ownedAnnotationEntries xmi:type="description:AnnotationEntry" uid="_XazCQD6wEemlzLOTmNfcSQ" source="DANNOTATION_CUSTOMIZATION_KEY">

+      <data xmi:type="diagram:ComputedStyleDescriptionRegistry" uid="_XazCQT6wEemlzLOTmNfcSQ">

+        <computedStyleDescriptions xmi:type="style:BundledImageDescription" xmi:id="_YLs6yT6wEemlzLOTmNfcSQ" labelExpression="service:render" labelAlignment="LEFT" tooltipExpression="service:renderTooltip" sizeComputationExpression="1">

+          <borderColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>

+          <labelFormat>bold</labelFormat>

+          <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='dark_blue']"/>

+          <color xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>

+        </computedStyleDescriptions>

+        <computedStyleDescriptions xmi:type="style:EdgeStyleDescription" xmi:id="_YL_1sT6wEemlzLOTmNfcSQ" routingStyle="manhattan">

+          <strokeColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='blue']"/>

+          <centerLabelStyleDescription xmi:type="style:CenterLabelStyleDescription" xmi:id="_YL_1sj6wEemlzLOTmNfcSQ" showIcon="false" labelExpression="service:render">

+            <labelFormat>bold</labelFormat>

+            <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='dark_blue']"/>

+          </centerLabelStyleDescription>

+          <endLabelStyleDescription xmi:type="style:EndLabelStyleDescription" xmi:id="_YL_1sz6wEemlzLOTmNfcSQ" labelSize="6" showIcon="false" labelExpression="service:eKeysLabel">

+            <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='dark_blue']"/>

+          </endLabelStyleDescription>

+        </computedStyleDescriptions>

+        <computedStyleDescriptions xmi:type="style:EdgeStyleDescription" xmi:id="_YMDgFz6wEemlzLOTmNfcSQ" sourceArrow="FillDiamond" routingStyle="manhattan">

+          <strokeColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>

+          <centerLabelStyleDescription xmi:type="style:CenterLabelStyleDescription" xmi:id="_YMDgGD6wEemlzLOTmNfcSQ" showIcon="false" labelExpression="service:render">

+            <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>

+          </centerLabelStyleDescription>

+          <endLabelStyleDescription xmi:type="style:EndLabelStyleDescription" xmi:id="_YMDgGT6wEemlzLOTmNfcSQ" labelSize="6" showIcon="false" labelExpression="service:eKeysLabel">

+            <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='dark_blue']"/>

+          </endLabelStyleDescription>

+        </computedStyleDescriptions>

+        <computedStyleDescriptions xmi:type="style:EdgeStyleDescription" xmi:id="_YMNRJD6wEemlzLOTmNfcSQ" sourceArrow="InputArrow" targetArrow="FillDiamond" routingStyle="manhattan">

+          <strokeColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>

+          <beginLabelStyleDescription xmi:type="style:BeginLabelStyleDescription" xmi:id="_YMNRJT6wEemlzLOTmNfcSQ" showIcon="false" labelExpression="service:renderEOpposite">

+            <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>

+          </beginLabelStyleDescription>

+          <endLabelStyleDescription xmi:type="style:EndLabelStyleDescription" xmi:id="_YMNRJj6wEemlzLOTmNfcSQ" showIcon="false" labelExpression="service:render">

+            <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>

+          </endLabelStyleDescription>

+        </computedStyleDescriptions>

+        <computedStyleDescriptions xmi:type="style:EdgeStyleDescription" xmi:id="_YMNRNT6wEemlzLOTmNfcSQ" sourceArrow="FillDiamond" routingStyle="manhattan">

+          <strokeColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>

+          <beginLabelStyleDescription xmi:type="style:BeginLabelStyleDescription" xmi:id="_YMNRNj6wEemlzLOTmNfcSQ" showIcon="false" labelExpression="service:renderEOpposite">

+            <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>

+          </beginLabelStyleDescription>

+          <endLabelStyleDescription xmi:type="style:EndLabelStyleDescription" xmi:id="_YMNRNz6wEemlzLOTmNfcSQ" showIcon="false" labelExpression="service:render">

+            <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>

+          </endLabelStyleDescription>

+        </computedStyleDescriptions>

+        <computedStyleDescriptions xmi:type="style:EdgeStyleDescription" xmi:id="_YMNRTT6wEemlzLOTmNfcSQ" sourceArrow="InputArrow" routingStyle="manhattan">

+          <strokeColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>

+          <beginLabelStyleDescription xmi:type="style:BeginLabelStyleDescription" xmi:id="_YMNRTj6wEemlzLOTmNfcSQ" showIcon="false" labelExpression="service:renderEOpposite">

+            <labelFormat>bold</labelFormat>

+            <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>

+          </beginLabelStyleDescription>

+          <endLabelStyleDescription xmi:type="style:EndLabelStyleDescription" xmi:id="_YMNRTz6wEemlzLOTmNfcSQ" showIcon="false" labelExpression="service:render">

+            <labelFormat>bold</labelFormat>

+            <labelColor xmi:type="description:SystemColor" href="environment:/viewpoint#//@systemColors/@entries[name='black']"/>

+          </endLabelStyleDescription>

+        </computedStyleDescriptions>

+      </data>

+    </ownedAnnotationEntries>

+    <ownedAnnotationEntries xmi:type="description:AnnotationEntry" uid="_XcDmgD6wEemlzLOTmNfcSQ" source="GMF_DIAGRAMS">

+      <data xmi:type="notation:Diagram" xmi:id="_XcDmgT6wEemlzLOTmNfcSQ" type="Sirius" element="_XZL4sD6wEemlzLOTmNfcSQ" measurementUnit="Pixel">

+        <children xmi:type="notation:Node" xmi:id="_YMXCEz6wEemlzLOTmNfcSQ" type="2003" element="_YLGd0D6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YMXCFj6wEemlzLOTmNfcSQ" type="5007"/>

+          <children xmi:type="notation:Node" xmi:id="_YMgMAD6wEemlzLOTmNfcSQ" type="7004">

+            <styles xmi:type="notation:SortingStyle" xmi:id="_YMgMAT6wEemlzLOTmNfcSQ"/>

+            <styles xmi:type="notation:FilteringStyle" xmi:id="_YMgMAj6wEemlzLOTmNfcSQ"/>

+          </children>

+          <styles xmi:type="notation:ShapeStyle" xmi:id="_YMXCFD6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8" italic="true"/>

+          <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YMXCFT6wEemlzLOTmNfcSQ" x="444" y="324"/>

+        </children>

+        <children xmi:type="notation:Node" xmi:id="_YMgMAz6wEemlzLOTmNfcSQ" type="2003" element="_YLQO0j6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YMgMBj6wEemlzLOTmNfcSQ" type="5007"/>

+          <children xmi:type="notation:Node" xmi:id="_YMgMBz6wEemlzLOTmNfcSQ" type="7004">

+            <styles xmi:type="notation:SortingStyle" xmi:id="_YMgMCD6wEemlzLOTmNfcSQ"/>

+            <styles xmi:type="notation:FilteringStyle" xmi:id="_YMgMCT6wEemlzLOTmNfcSQ"/>

+          </children>

+          <styles xmi:type="notation:ShapeStyle" xmi:id="_YMgMBD6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+          <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YMgMBT6wEemlzLOTmNfcSQ" x="264" y="156"/>

+        </children>

+        <children xmi:type="notation:Node" xmi:id="_YMgMCj6wEemlzLOTmNfcSQ" type="2003" element="_YLQO1T6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YMgMDT6wEemlzLOTmNfcSQ" type="5007"/>

+          <children xmi:type="notation:Node" xmi:id="_YMgMDj6wEemlzLOTmNfcSQ" type="7004">

+            <children xmi:type="notation:Node" xmi:id="_YMp9Dj6wEemlzLOTmNfcSQ" type="3010" element="_YLs6yD6wEemlzLOTmNfcSQ">

+              <styles xmi:type="notation:FontStyle" xmi:id="_YMp9Dz6wEemlzLOTmNfcSQ" fontColor="7490599" fontName="Segoe UI" fontHeight="8" bold="true"/>

+              <layoutConstraint xmi:type="notation:Location" xmi:id="_YMp9ED6wEemlzLOTmNfcSQ"/>

+            </children>

+            <styles xmi:type="notation:SortingStyle" xmi:id="_YMgMDz6wEemlzLOTmNfcSQ"/>

+            <styles xmi:type="notation:FilteringStyle" xmi:id="_YMgMED6wEemlzLOTmNfcSQ"/>

+          </children>

+          <styles xmi:type="notation:ShapeStyle" xmi:id="_YMgMCz6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+          <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YMgMDD6wEemlzLOTmNfcSQ" x="456" y="456"/>

+        </children>

+        <children xmi:type="notation:Node" xmi:id="_YMgMET6wEemlzLOTmNfcSQ" type="2003" element="_YLQO2D6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YMgMFD6wEemlzLOTmNfcSQ" type="5007"/>

+          <children xmi:type="notation:Node" xmi:id="_YMgMFT6wEemlzLOTmNfcSQ" type="7004">

+            <styles xmi:type="notation:SortingStyle" xmi:id="_YMgMFj6wEemlzLOTmNfcSQ"/>

+            <styles xmi:type="notation:FilteringStyle" xmi:id="_YMgMFz6wEemlzLOTmNfcSQ"/>

+          </children>

+          <styles xmi:type="notation:ShapeStyle" xmi:id="_YMgMEj6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+          <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YMgMEz6wEemlzLOTmNfcSQ" x="684" y="72"/>

+        </children>

+        <children xmi:type="notation:Node" xmi:id="_YMgMGD6wEemlzLOTmNfcSQ" type="2003" element="_YLQO2z6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YMgMGz6wEemlzLOTmNfcSQ" type="5007"/>

+          <children xmi:type="notation:Node" xmi:id="_YMgMHD6wEemlzLOTmNfcSQ" type="7004">

+            <styles xmi:type="notation:SortingStyle" xmi:id="_YMgMHT6wEemlzLOTmNfcSQ"/>

+            <styles xmi:type="notation:FilteringStyle" xmi:id="_YMgMHj6wEemlzLOTmNfcSQ"/>

+          </children>

+          <styles xmi:type="notation:ShapeStyle" xmi:id="_YMgMGT6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+          <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YMgMGj6wEemlzLOTmNfcSQ" x="1104" y="324"/>

+        </children>

+        <children xmi:type="notation:Node" xmi:id="_YMgMHz6wEemlzLOTmNfcSQ" type="2003" element="_YLZYwT6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YMgMIj6wEemlzLOTmNfcSQ" type="5007"/>

+          <children xmi:type="notation:Node" xmi:id="_YMgMIz6wEemlzLOTmNfcSQ" type="7004">

+            <styles xmi:type="notation:SortingStyle" xmi:id="_YMgMJD6wEemlzLOTmNfcSQ"/>

+            <styles xmi:type="notation:FilteringStyle" xmi:id="_YMgMJT6wEemlzLOTmNfcSQ"/>

+          </children>

+          <styles xmi:type="notation:ShapeStyle" xmi:id="_YMgMID6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+          <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YMgMIT6wEemlzLOTmNfcSQ" x="828" y="156"/>

+        </children>

+        <children xmi:type="notation:Node" xmi:id="_YMgMJj6wEemlzLOTmNfcSQ" type="2003" element="_YLZYxD6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YMgMKT6wEemlzLOTmNfcSQ" type="5007"/>

+          <children xmi:type="notation:Node" xmi:id="_YMgMKj6wEemlzLOTmNfcSQ" type="7004">

+            <styles xmi:type="notation:SortingStyle" xmi:id="_YMgMKz6wEemlzLOTmNfcSQ"/>

+            <styles xmi:type="notation:FilteringStyle" xmi:id="_YMgMLD6wEemlzLOTmNfcSQ"/>

+          </children>

+          <styles xmi:type="notation:ShapeStyle" xmi:id="_YMgMJz6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+          <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YMgMKD6wEemlzLOTmNfcSQ" x="1200" y="156"/>

+        </children>

+        <children xmi:type="notation:Node" xmi:id="_YMgMLT6wEemlzLOTmNfcSQ" type="2003" element="_YLZYxz6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YMgMMD6wEemlzLOTmNfcSQ" type="5007"/>

+          <children xmi:type="notation:Node" xmi:id="_YMgMMT6wEemlzLOTmNfcSQ" type="7004">

+            <styles xmi:type="notation:SortingStyle" xmi:id="_YMgMMj6wEemlzLOTmNfcSQ"/>

+            <styles xmi:type="notation:FilteringStyle" xmi:id="_YMgMMz6wEemlzLOTmNfcSQ"/>

+          </children>

+          <styles xmi:type="notation:ShapeStyle" xmi:id="_YMgMLj6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+          <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YMgMLz6wEemlzLOTmNfcSQ" x="1008" y="156"/>

+        </children>

+        <children xmi:type="notation:Node" xmi:id="_YMp9AD6wEemlzLOTmNfcSQ" type="2003" element="_YLZYyj6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YMp9Az6wEemlzLOTmNfcSQ" type="5007"/>

+          <children xmi:type="notation:Node" xmi:id="_YMp9BD6wEemlzLOTmNfcSQ" type="7004">

+            <styles xmi:type="notation:SortingStyle" xmi:id="_YMp9BT6wEemlzLOTmNfcSQ"/>

+            <styles xmi:type="notation:FilteringStyle" xmi:id="_YMp9Bj6wEemlzLOTmNfcSQ"/>

+          </children>

+          <styles xmi:type="notation:ShapeStyle" xmi:id="_YMp9AT6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8" italic="true"/>

+          <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YMp9Aj6wEemlzLOTmNfcSQ" x="1068" y="-36"/>

+        </children>

+        <children xmi:type="notation:Node" xmi:id="_YMp9Bz6wEemlzLOTmNfcSQ" type="2003" element="_YLZYzT6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YMp9Cj6wEemlzLOTmNfcSQ" type="5007"/>

+          <children xmi:type="notation:Node" xmi:id="_YMp9Cz6wEemlzLOTmNfcSQ" type="7004">

+            <children xmi:type="notation:Node" xmi:id="_YMp9ET6wEemlzLOTmNfcSQ" type="3010" element="_YL2Esj6wEemlzLOTmNfcSQ">

+              <styles xmi:type="notation:FontStyle" xmi:id="_YMp9Ej6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+              <layoutConstraint xmi:type="notation:Location" xmi:id="_YMp9Ez6wEemlzLOTmNfcSQ"/>

+            </children>

+            <children xmi:type="notation:Node" xmi:id="_YMp9FD6wEemlzLOTmNfcSQ" type="3010" element="_YL2EtD6wEemlzLOTmNfcSQ">

+              <styles xmi:type="notation:FontStyle" xmi:id="_YMp9FT6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+              <layoutConstraint xmi:type="notation:Location" xmi:id="_YMp9Fj6wEemlzLOTmNfcSQ"/>

+            </children>

+            <children xmi:type="notation:Node" xmi:id="_YMp9Fz6wEemlzLOTmNfcSQ" type="3010" element="_YL2Etj6wEemlzLOTmNfcSQ">

+              <styles xmi:type="notation:FontStyle" xmi:id="_YMp9GD6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+              <layoutConstraint xmi:type="notation:Location" xmi:id="_YMp9GT6wEemlzLOTmNfcSQ"/>

+            </children>

+            <styles xmi:type="notation:SortingStyle" xmi:id="_YMp9DD6wEemlzLOTmNfcSQ"/>

+            <styles xmi:type="notation:FilteringStyle" xmi:id="_YMp9DT6wEemlzLOTmNfcSQ"/>

+          </children>

+          <styles xmi:type="notation:ShapeStyle" xmi:id="_YMp9CD6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+          <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YMp9CT6wEemlzLOTmNfcSQ" x="252"/>

+        </children>

+        <styles xmi:type="notation:DiagramStyle" xmi:id="_XcDmgj6wEemlzLOTmNfcSQ"/>

+        <edges xmi:type="notation:Edge" xmi:id="_YNBJYD6wEemlzLOTmNfcSQ" type="4001" element="_YL_1sD6wEemlzLOTmNfcSQ" source="_YMXCEz6wEemlzLOTmNfcSQ" target="_YMgMAz6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YNBJZD6wEemlzLOTmNfcSQ" type="6001">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNBJZT6wEemlzLOTmNfcSQ" x="32" y="48"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNBJZj6wEemlzLOTmNfcSQ" type="6002">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNBJZz6wEemlzLOTmNfcSQ" x="-11" y="10"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNKTUD6wEemlzLOTmNfcSQ" type="6003">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNKTUT6wEemlzLOTmNfcSQ" x="-18" y="10"/>

+          </children>

+          <styles xmi:type="notation:ConnectorStyle" xmi:id="_YNBJYT6wEemlzLOTmNfcSQ" routing="Rectilinear"/>

+          <styles xmi:type="notation:FontStyle" xmi:id="_YNBJYj6wEemlzLOTmNfcSQ" fontColor="7490599" fontName="Segoe UI" fontHeight="8"/>

+          <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_YNBJYz6wEemlzLOTmNfcSQ" points="[-59, -37, 95, 131]$[-74, -37, 80, 131]$[-74, -119, 80, 49]"/>

+          <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNUEUD6wEemlzLOTmNfcSQ" id="(0.5,0.5)"/>

+          <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNUEUT6wEemlzLOTmNfcSQ" id="(0.5,0.5)"/>

+        </edges>

+        <edges xmi:type="notation:Edge" xmi:id="_YNUEUj6wEemlzLOTmNfcSQ" type="4001" element="_YMDgFj6wEemlzLOTmNfcSQ" source="_YMgMAz6wEemlzLOTmNfcSQ" target="_YMXCEz6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YNUEVj6wEemlzLOTmNfcSQ" type="6001">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNUEVz6wEemlzLOTmNfcSQ" x="27" y="46"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNUEWD6wEemlzLOTmNfcSQ" type="6002">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNUEWT6wEemlzLOTmNfcSQ" x="18" y="10"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNUEWj6wEemlzLOTmNfcSQ" type="6003">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNUEWz6wEemlzLOTmNfcSQ" x="10" y="-11"/>

+          </children>

+          <styles xmi:type="notation:ConnectorStyle" xmi:id="_YNUEUz6wEemlzLOTmNfcSQ" routing="Rectilinear"/>

+          <styles xmi:type="notation:FontStyle" xmi:id="_YNUEVD6wEemlzLOTmNfcSQ" fontColor="7490599" fontName="Segoe UI" fontHeight="8"/>

+          <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_YNUEVT6wEemlzLOTmNfcSQ" points="[80, 49, -74, -119]$[80, 131, -74, -37]$[95, 131, -59, -37]"/>

+          <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNUEXD6wEemlzLOTmNfcSQ" id="(0.5,0.5)"/>

+          <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNUEXT6wEemlzLOTmNfcSQ" id="(0.5,0.5)"/>

+        </edges>

+        <edges xmi:type="notation:Edge" xmi:id="_YNUEXj6wEemlzLOTmNfcSQ" type="4001" element="_YMDgID6wEemlzLOTmNfcSQ" source="_YMgMCj6wEemlzLOTmNfcSQ" target="_YMXCEz6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YNUEYj6wEemlzLOTmNfcSQ" type="6001">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNUEYz6wEemlzLOTmNfcSQ" y="-10"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNUEZD6wEemlzLOTmNfcSQ" type="6002">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNUEZT6wEemlzLOTmNfcSQ" y="10"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNUEZj6wEemlzLOTmNfcSQ" type="6003">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNUEZz6wEemlzLOTmNfcSQ" y="10"/>

+          </children>

+          <styles xmi:type="notation:ConnectorStyle" xmi:id="_YNUEXz6wEemlzLOTmNfcSQ" routing="Tree"/>

+          <styles xmi:type="notation:FontStyle" xmi:id="_YNUEYD6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+          <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_YNUEYT6wEemlzLOTmNfcSQ" points="[0, -98, 0, 144]$[0, -122, 0, 120]$[58, -122, 58, 120]$[58, -144, 58, 98]"/>

+          <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNd1UD6wEemlzLOTmNfcSQ" id="(0.5,1.0)"/>

+          <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNd1UT6wEemlzLOTmNfcSQ" id="(0.5,0.0)"/>

+        </edges>

+        <edges xmi:type="notation:Edge" xmi:id="_YNd1Uj6wEemlzLOTmNfcSQ" type="4001" element="_YMNRFT6wEemlzLOTmNfcSQ" source="_YMgMLT6wEemlzLOTmNfcSQ" target="_YMp9AD6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YNd1Vj6wEemlzLOTmNfcSQ" type="6001">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1Vz6wEemlzLOTmNfcSQ" y="-10"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNd1WD6wEemlzLOTmNfcSQ" type="6002">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1WT6wEemlzLOTmNfcSQ" y="10"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNd1Wj6wEemlzLOTmNfcSQ" type="6003">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1Wz6wEemlzLOTmNfcSQ" y="10"/>

+          </children>

+          <styles xmi:type="notation:ConnectorStyle" xmi:id="_YNd1Uz6wEemlzLOTmNfcSQ" routing="Tree"/>

+          <styles xmi:type="notation:FontStyle" xmi:id="_YNd1VD6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+          <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_YNd1VT6wEemlzLOTmNfcSQ" points="[0, 0, -60, 94]$[0, 10, -60, 104]$[49, 10, -11, 104]$[49, -94, -11, 0]"/>

+          <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNd1XD6wEemlzLOTmNfcSQ" id="(0.5,0.0)"/>

+          <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNd1XT6wEemlzLOTmNfcSQ" id="(0.5,1.0)"/>

+        </edges>

+        <edges xmi:type="notation:Edge" xmi:id="_YNd1Xj6wEemlzLOTmNfcSQ" type="4001" element="_YMNRHD6wEemlzLOTmNfcSQ" source="_YMgMJj6wEemlzLOTmNfcSQ" target="_YMp9AD6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YNd1Yj6wEemlzLOTmNfcSQ" type="6001">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1Yz6wEemlzLOTmNfcSQ" y="-10"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNd1ZD6wEemlzLOTmNfcSQ" type="6002">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1ZT6wEemlzLOTmNfcSQ" y="10"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNd1Zj6wEemlzLOTmNfcSQ" type="6003">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1Zz6wEemlzLOTmNfcSQ" y="10"/>

+          </children>

+          <styles xmi:type="notation:ConnectorStyle" xmi:id="_YNd1Xz6wEemlzLOTmNfcSQ" routing="Tree"/>

+          <styles xmi:type="notation:FontStyle" xmi:id="_YNd1YD6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+          <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_YNd1YT6wEemlzLOTmNfcSQ" points="[0, 0, 132, 94]$[0, 10, 132, 104]$[-143, 10, -11, 104]$[-143, -94, -11, 0]"/>

+          <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNd1aD6wEemlzLOTmNfcSQ" id="(0.5,0.0)"/>

+          <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNd1aT6wEemlzLOTmNfcSQ" id="(0.5,1.0)"/>

+        </edges>

+        <edges xmi:type="notation:Edge" xmi:id="_YNd1aj6wEemlzLOTmNfcSQ" type="4001" element="_YMNRIz6wEemlzLOTmNfcSQ" source="_YMXCEz6wEemlzLOTmNfcSQ" target="_YMgMCj6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YNd1bj6wEemlzLOTmNfcSQ" type="6001">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1bz6wEemlzLOTmNfcSQ" x="-1" y="10"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNd1cD6wEemlzLOTmNfcSQ" type="6002">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1cT6wEemlzLOTmNfcSQ" x="-4" y="-10"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNd1cj6wEemlzLOTmNfcSQ" type="6003">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1cz6wEemlzLOTmNfcSQ" x="-14" y="-44"/>

+          </children>

+          <styles xmi:type="notation:ConnectorStyle" xmi:id="_YNd1az6wEemlzLOTmNfcSQ" routing="Rectilinear"/>

+          <styles xmi:type="notation:FontStyle" xmi:id="_YNd1bD6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+          <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_YNd1bT6wEemlzLOTmNfcSQ" points="[-59, 1, -100, -131]$[-107, 1, -148, -131]$[-107, 133, -148, 1]$[-47, 133, -88, 1]"/>

+          <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNd1dD6wEemlzLOTmNfcSQ" id="(0.5,0.5)"/>

+          <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNd1dT6wEemlzLOTmNfcSQ" id="(0.5,0.5)"/>

+        </edges>

+        <edges xmi:type="notation:Edge" xmi:id="_YNd1dj6wEemlzLOTmNfcSQ" type="4001" element="_YMNRLT6wEemlzLOTmNfcSQ" source="_YMgMGD6wEemlzLOTmNfcSQ" target="_YMgMLT6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YNd1ej6wEemlzLOTmNfcSQ" type="6001">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1ez6wEemlzLOTmNfcSQ" x="10"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNd1fD6wEemlzLOTmNfcSQ" type="6002">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1fT6wEemlzLOTmNfcSQ" x="27" y="-18"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNd1fj6wEemlzLOTmNfcSQ" type="6003">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1fz6wEemlzLOTmNfcSQ" x="-10"/>

+          </children>

+          <styles xmi:type="notation:ConnectorStyle" xmi:id="_YNd1dz6wEemlzLOTmNfcSQ" routing="Rectilinear"/>

+          <styles xmi:type="notation:FontStyle" xmi:id="_YNd1eD6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+          <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_YNd1eT6wEemlzLOTmNfcSQ" points="[-59, 48, 37, 118]$[-96, 48, 0, 118]$[-96, -70, 0, 0]"/>

+          <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNd1gD6wEemlzLOTmNfcSQ" id="(0.5,0.0)"/>

+          <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNd1gT6wEemlzLOTmNfcSQ" id="(0.5,1.0)"/>

+        </edges>

+        <edges xmi:type="notation:Edge" xmi:id="_YNd1gj6wEemlzLOTmNfcSQ" type="4001" element="_YMNRND6wEemlzLOTmNfcSQ" source="_YMgMHz6wEemlzLOTmNfcSQ" target="_YMp9AD6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YNd1hj6wEemlzLOTmNfcSQ" type="6001">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1hz6wEemlzLOTmNfcSQ" x="13" y="18"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNd1iD6wEemlzLOTmNfcSQ" type="6002">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1iT6wEemlzLOTmNfcSQ" x="-32" y="10"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNd1ij6wEemlzLOTmNfcSQ" type="6003">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1iz6wEemlzLOTmNfcSQ" y="10"/>

+          </children>

+          <styles xmi:type="notation:ConnectorStyle" xmi:id="_YNd1gz6wEemlzLOTmNfcSQ" routing="Rectilinear"/>

+          <styles xmi:type="notation:FontStyle" xmi:id="_YNd1hD6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+          <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_YNd1hT6wEemlzLOTmNfcSQ" points="[30, -49, -209, 143]$[30, -205, -209, -13]$[180, -205, -59, -13]"/>

+          <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNd1jD6wEemlzLOTmNfcSQ" id="(0.5,0.5)"/>

+          <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNd1jT6wEemlzLOTmNfcSQ" id="(0.5,0.5)"/>

+        </edges>

+        <edges xmi:type="notation:Edge" xmi:id="_YNd1jj6wEemlzLOTmNfcSQ" type="4001" element="_YMNRPj6wEemlzLOTmNfcSQ" source="_YMgMET6wEemlzLOTmNfcSQ" target="_YMp9AD6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YNd1kj6wEemlzLOTmNfcSQ" type="6001">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1kz6wEemlzLOTmNfcSQ" x="-43" y="-10"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNd1lD6wEemlzLOTmNfcSQ" type="6002">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1lT6wEemlzLOTmNfcSQ" x="-18" y="17"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNd1lj6wEemlzLOTmNfcSQ" type="6003">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1lz6wEemlzLOTmNfcSQ" x="-18" y="10"/>

+          </children>

+          <styles xmi:type="notation:ConnectorStyle" xmi:id="_YNd1jz6wEemlzLOTmNfcSQ" routing="Rectilinear"/>

+          <styles xmi:type="notation:FontStyle" xmi:id="_YNd1kD6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+          <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_YNd1kT6wEemlzLOTmNfcSQ" points="[0, 0, -384, 10]$[0, -36, -384, -26]$[325, -36, -59, -26]"/>

+          <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNd1mD6wEemlzLOTmNfcSQ" id="(0.5,0.0)"/>

+          <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNd1mT6wEemlzLOTmNfcSQ" id="(0.5,1.0)"/>

+        </edges>

+        <edges xmi:type="notation:Edge" xmi:id="_YNd1mj6wEemlzLOTmNfcSQ" type="4001" element="_YMNRRT6wEemlzLOTmNfcSQ" source="_YMXCEz6wEemlzLOTmNfcSQ" target="_YMgMHz6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YNd1nj6wEemlzLOTmNfcSQ" type="6001">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1nz6wEemlzLOTmNfcSQ" y="-10"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNd1oD6wEemlzLOTmNfcSQ" type="6002">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1oT6wEemlzLOTmNfcSQ" y="10"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNd1oj6wEemlzLOTmNfcSQ" type="6003">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNd1oz6wEemlzLOTmNfcSQ" y="10"/>

+          </children>

+          <styles xmi:type="notation:ConnectorStyle" xmi:id="_YNd1mz6wEemlzLOTmNfcSQ" routing="Rectilinear"/>

+          <styles xmi:type="notation:FontStyle" xmi:id="_YNd1nD6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8"/>

+          <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_YNd1nT6wEemlzLOTmNfcSQ" points="[0, -50, -390, 110]$[390, -110, 0, 50]"/>

+          <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNd1pD6wEemlzLOTmNfcSQ" id="(0.5,0.5)"/>

+          <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNd1pT6wEemlzLOTmNfcSQ" id="(0.5,0.5)"/>

+        </edges>

+        <edges xmi:type="notation:Edge" xmi:id="_YNm_QD6wEemlzLOTmNfcSQ" type="4001" element="_YMNRTD6wEemlzLOTmNfcSQ" source="_YMgMGD6wEemlzLOTmNfcSQ" target="_YMgMJj6wEemlzLOTmNfcSQ">

+          <children xmi:type="notation:Node" xmi:id="_YNm_RD6wEemlzLOTmNfcSQ" type="6001">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNm_RT6wEemlzLOTmNfcSQ" x="10"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNm_Rj6wEemlzLOTmNfcSQ" type="6002">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNm_Rz6wEemlzLOTmNfcSQ" y="10"/>

+          </children>

+          <children xmi:type="notation:Node" xmi:id="_YNm_SD6wEemlzLOTmNfcSQ" type="6003">

+            <layoutConstraint xmi:type="notation:Bounds" xmi:id="_YNm_ST6wEemlzLOTmNfcSQ" y="10"/>

+          </children>

+          <styles xmi:type="notation:ConnectorStyle" xmi:id="_YNm_QT6wEemlzLOTmNfcSQ" routing="Rectilinear"/>

+          <styles xmi:type="notation:FontStyle" xmi:id="_YNm_Qj6wEemlzLOTmNfcSQ" fontName="Segoe UI" fontHeight="8" bold="true"/>

+          <bendpoints xmi:type="notation:RelativeBendpoints" xmi:id="_YNm_Qz6wEemlzLOTmNfcSQ" points="[59, 60, -37, 130]$[96, 60, 0, 130]$[96, -70, 0, 0]"/>

+          <sourceAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNm_Sj6wEemlzLOTmNfcSQ" id="(0.5,0.0)"/>

+          <targetAnchor xmi:type="notation:IdentityAnchor" xmi:id="_YNm_Sz6wEemlzLOTmNfcSQ" id="(0.5,1.0)"/>

+        </edges>

+      </data>

+    </ownedAnnotationEntries>

+    <ownedDiagramElements xmi:type="diagram:DNodeList" uid="_YLGd0D6wEemlzLOTmNfcSQ" name="FunctionalElement" tooltipText="" outgoingEdges="_YL_1sD6wEemlzLOTmNfcSQ _YMNRIz6wEemlzLOTmNfcSQ _YMNRRT6wEemlzLOTmNfcSQ" incomingEdges="_YMDgFj6wEemlzLOTmNfcSQ _YMDgID6wEemlzLOTmNfcSQ" width="12" height="10">

+      <target xmi:type="ecore:EClass" href="fam.ecore#//FunctionalElement"/>

+      <semanticElements xmi:type="ecore:EClass" href="fam.ecore#//FunctionalElement"/>

+      <ownedStyle xmi:type="diagram:FlatContainerStyle" uid="_YLQO0D6wEemlzLOTmNfcSQ" iconPath="/org.eclipse.emf.ecoretools.design/icons/full/obj16/EClass_abstract.gif" borderSize="1" borderSizeComputationExpression="1" borderColor="125,125,125" backgroundStyle="Liquid" foregroundColor="228,228,228">

+        <labelFormat>italic</labelFormat>

+        <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@conditionnalStyles.1/@style"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DNodeList" uid="_YLQO0j6wEemlzLOTmNfcSQ" name="FunctionalArchitectureModel" tooltipText="" outgoingEdges="_YMDgFj6wEemlzLOTmNfcSQ" incomingEdges="_YL_1sD6wEemlzLOTmNfcSQ" width="12" height="10">

+      <target xmi:type="ecore:EClass" href="fam.ecore#//FunctionalArchitectureModel"/>

+      <semanticElements xmi:type="ecore:EClass" href="fam.ecore#//FunctionalArchitectureModel"/>

+      <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>

+      <arrangeConstraints>KEEP_SIZE</arrangeConstraints>

+      <arrangeConstraints>KEEP_RATIO</arrangeConstraints>

+      <ownedStyle xmi:type="diagram:FlatContainerStyle" uid="_YLQO0z6wEemlzLOTmNfcSQ" borderSize="1" borderSizeComputationExpression="1" backgroundStyle="Liquid" foregroundColor="255,252,216">

+        <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DNodeList" uid="_YLQO1T6wEemlzLOTmNfcSQ" name="Function" tooltipText="" outgoingEdges="_YMDgID6wEemlzLOTmNfcSQ" incomingEdges="_YMNRIz6wEemlzLOTmNfcSQ" width="12" height="10">

+      <target xmi:type="ecore:EClass" href="fam.ecore#//Function"/>

+      <semanticElements xmi:type="ecore:EClass" href="fam.ecore#//Function"/>

+      <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>

+      <arrangeConstraints>KEEP_SIZE</arrangeConstraints>

+      <arrangeConstraints>KEEP_RATIO</arrangeConstraints>

+      <ownedStyle xmi:type="diagram:FlatContainerStyle" uid="_YLQO1j6wEemlzLOTmNfcSQ" borderSize="1" borderSizeComputationExpression="1" backgroundStyle="Liquid" foregroundColor="255,252,216">

+        <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>

+      <ownedElements xmi:type="diagram:DNodeListElement" uid="_YLs6yD6wEemlzLOTmNfcSQ" name="/type : FunctionType = Root" tooltipText="">

+        <target xmi:type="ecore:EAttribute" href="fam.ecore#//Function/type"/>

+        <semanticElements xmi:type="ecore:EAttribute" href="fam.ecore#//Function/type"/>

+        <ownedStyle xmi:type="diagram:BundledImage" uid="_YLs6yj6wEemlzLOTmNfcSQ" labelColor="39,76,114" labelAlignment="LEFT" description="_YLs6yT6wEemlzLOTmNfcSQ">

+          <labelFormat>bold</labelFormat>

+        </ownedStyle>

+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@subNodeMappings[name='EC%20EAttribute']"/>

+      </ownedElements>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DNodeList" uid="_YLQO2D6wEemlzLOTmNfcSQ" name="FAMTerminator" tooltipText="" outgoingEdges="_YMNRPj6wEemlzLOTmNfcSQ" width="12" height="10">

+      <target xmi:type="ecore:EClass" href="fam.ecore#//FAMTerminator"/>

+      <semanticElements xmi:type="ecore:EClass" href="fam.ecore#//FAMTerminator"/>

+      <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>

+      <arrangeConstraints>KEEP_SIZE</arrangeConstraints>

+      <arrangeConstraints>KEEP_RATIO</arrangeConstraints>

+      <ownedStyle xmi:type="diagram:FlatContainerStyle" uid="_YLQO2T6wEemlzLOTmNfcSQ" borderSize="1" borderSizeComputationExpression="1" backgroundStyle="Liquid" foregroundColor="255,252,216">

+        <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DNodeList" uid="_YLQO2z6wEemlzLOTmNfcSQ" name="InformationLink" tooltipText="" outgoingEdges="_YMNRLT6wEemlzLOTmNfcSQ _YMNRTD6wEemlzLOTmNfcSQ" width="12" height="10">

+      <target xmi:type="ecore:EClass" href="fam.ecore#//InformationLink"/>

+      <semanticElements xmi:type="ecore:EClass" href="fam.ecore#//InformationLink"/>

+      <ownedStyle xmi:type="diagram:FlatContainerStyle" uid="_YLQO3D6wEemlzLOTmNfcSQ" borderSize="1" borderSizeComputationExpression="1" backgroundStyle="Liquid" foregroundColor="255,252,216">

+        <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DNodeList" uid="_YLZYwT6wEemlzLOTmNfcSQ" name="FunctionalInterface" tooltipText="" outgoingEdges="_YMNRND6wEemlzLOTmNfcSQ" incomingEdges="_YMNRRT6wEemlzLOTmNfcSQ" width="12" height="10">

+      <target xmi:type="ecore:EClass" href="fam.ecore#//FunctionalInterface"/>

+      <semanticElements xmi:type="ecore:EClass" href="fam.ecore#//FunctionalInterface"/>

+      <ownedStyle xmi:type="diagram:FlatContainerStyle" uid="_YLZYwj6wEemlzLOTmNfcSQ" borderSize="1" borderSizeComputationExpression="1" backgroundStyle="Liquid" foregroundColor="255,252,216">

+        <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DNodeList" uid="_YLZYxD6wEemlzLOTmNfcSQ" name="FunctionalInput" tooltipText="" outgoingEdges="_YMNRHD6wEemlzLOTmNfcSQ" incomingEdges="_YMNRTD6wEemlzLOTmNfcSQ" width="12" height="10">

+      <target xmi:type="ecore:EClass" href="fam.ecore#//FunctionalInput"/>

+      <semanticElements xmi:type="ecore:EClass" href="fam.ecore#//FunctionalInput"/>

+      <ownedStyle xmi:type="diagram:FlatContainerStyle" uid="_YLZYxT6wEemlzLOTmNfcSQ" borderSize="1" borderSizeComputationExpression="1" backgroundStyle="Liquid" foregroundColor="255,252,216">

+        <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DNodeList" uid="_YLZYxz6wEemlzLOTmNfcSQ" name="FunctionalOutput" tooltipText="" outgoingEdges="_YMNRFT6wEemlzLOTmNfcSQ" incomingEdges="_YMNRLT6wEemlzLOTmNfcSQ" width="12" height="10">

+      <target xmi:type="ecore:EClass" href="fam.ecore#//FunctionalOutput"/>

+      <semanticElements xmi:type="ecore:EClass" href="fam.ecore#//FunctionalOutput"/>

+      <ownedStyle xmi:type="diagram:FlatContainerStyle" uid="_YLZYyD6wEemlzLOTmNfcSQ" borderSize="1" borderSizeComputationExpression="1" backgroundStyle="Liquid" foregroundColor="255,252,216">

+        <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@style"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DNodeList" uid="_YLZYyj6wEemlzLOTmNfcSQ" name="FunctionalData" tooltipText="" incomingEdges="_YMNRFT6wEemlzLOTmNfcSQ _YMNRHD6wEemlzLOTmNfcSQ _YMNRND6wEemlzLOTmNfcSQ _YMNRPj6wEemlzLOTmNfcSQ" width="12" height="10">

+      <target xmi:type="ecore:EClass" href="fam.ecore#//FunctionalData"/>

+      <semanticElements xmi:type="ecore:EClass" href="fam.ecore#//FunctionalData"/>

+      <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>

+      <arrangeConstraints>KEEP_SIZE</arrangeConstraints>

+      <arrangeConstraints>KEEP_RATIO</arrangeConstraints>

+      <ownedStyle xmi:type="diagram:FlatContainerStyle" uid="_YLZYyz6wEemlzLOTmNfcSQ" iconPath="/org.eclipse.emf.ecoretools.design/icons/full/obj16/EClass_abstract.gif" borderSize="1" borderSizeComputationExpression="1" borderColor="125,125,125" backgroundStyle="Liquid" foregroundColor="228,228,228">

+        <labelFormat>italic</labelFormat>

+        <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']/@conditionnalStyles.1/@style"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EClass']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DNodeList" uid="_YLZYzT6wEemlzLOTmNfcSQ" name="FunctionType" tooltipText="" width="12" height="10">

+      <target xmi:type="ecore:EEnum" href="fam.ecore#//FunctionType"/>

+      <semanticElements xmi:type="ecore:EEnum" href="fam.ecore#//FunctionType"/>

+      <arrangeConstraints>KEEP_LOCATION</arrangeConstraints>

+      <arrangeConstraints>KEEP_SIZE</arrangeConstraints>

+      <arrangeConstraints>KEEP_RATIO</arrangeConstraints>

+      <ownedStyle xmi:type="diagram:FlatContainerStyle" uid="_YLZYzj6wEemlzLOTmNfcSQ" borderSize="1" borderSizeComputationExpression="1" borderColor="125,125,125" backgroundStyle="Liquid" foregroundColor="221,236,202">

+        <description xmi:type="style:FlatContainerStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EEnum']/@style"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:ContainerMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EEnum']"/>

+      <ownedElements xmi:type="diagram:DNodeListElement" uid="_YL2Esj6wEemlzLOTmNfcSQ" name="Root" tooltipText="">

+        <target xmi:type="ecore:EEnumLiteral" href="fam.ecore#//FunctionType/Root"/>

+        <semanticElements xmi:type="ecore:EEnumLiteral" href="fam.ecore#//FunctionType/Root"/>

+        <ownedStyle xmi:type="diagram:BundledImage" uid="_YL2Esz6wEemlzLOTmNfcSQ" labelAlignment="LEFT">

+          <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EEnum']/@subNodeMappings[name='EC%20EEnumLiteral']/@style"/>

+        </ownedStyle>

+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EEnum']/@subNodeMappings[name='EC%20EEnumLiteral']"/>

+      </ownedElements>

+      <ownedElements xmi:type="diagram:DNodeListElement" uid="_YL2EtD6wEemlzLOTmNfcSQ" name="Intermediate" tooltipText="">

+        <target xmi:type="ecore:EEnumLiteral" href="fam.ecore#//FunctionType/Intermediate"/>

+        <semanticElements xmi:type="ecore:EEnumLiteral" href="fam.ecore#//FunctionType/Intermediate"/>

+        <ownedStyle xmi:type="diagram:BundledImage" uid="_YL2EtT6wEemlzLOTmNfcSQ" labelAlignment="LEFT">

+          <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EEnum']/@subNodeMappings[name='EC%20EEnumLiteral']/@style"/>

+        </ownedStyle>

+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EEnum']/@subNodeMappings[name='EC%20EEnumLiteral']"/>

+      </ownedElements>

+      <ownedElements xmi:type="diagram:DNodeListElement" uid="_YL2Etj6wEemlzLOTmNfcSQ" name="Leaf" tooltipText="">

+        <target xmi:type="ecore:EEnumLiteral" href="fam.ecore#//FunctionType/Leaf"/>

+        <semanticElements xmi:type="ecore:EEnumLiteral" href="fam.ecore#//FunctionType/Leaf"/>

+        <ownedStyle xmi:type="diagram:BundledImage" uid="_YL2Etz6wEemlzLOTmNfcSQ" labelAlignment="LEFT">

+          <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EEnum']/@subNodeMappings[name='EC%20EEnumLiteral']/@style"/>

+        </ownedStyle>

+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EEnum']/@subNodeMappings[name='EC%20EEnumLiteral']"/>

+      </ownedElements>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DEdge" uid="_YL_1sD6wEemlzLOTmNfcSQ" name="[1..1] /model" sourceNode="_YLGd0D6wEemlzLOTmNfcSQ" targetNode="_YLQO0j6wEemlzLOTmNfcSQ">

+      <target xmi:type="ecore:EReference" href="fam.ecore#//FunctionalElement/model"/>

+      <semanticElements xmi:type="ecore:EReference" href="fam.ecore#//FunctionalElement/model"/>

+      <ownedStyle xmi:type="diagram:EdgeStyle" uid="_YMDgED6wEemlzLOTmNfcSQ" description="_YL_1sT6wEemlzLOTmNfcSQ" routingStyle="manhattan" strokeColor="114,159,207">

+        <centerLabelStyle xmi:type="diagram:CenterLabelStyle" uid="_YMDgEj6wEemlzLOTmNfcSQ" showIcon="false" labelColor="39,76,114">

+          <customFeatures>labelSize</customFeatures>

+          <labelFormat>bold</labelFormat>

+        </centerLabelStyle>

+        <endLabelStyle xmi:type="diagram:EndLabelStyle" uid="_YMDgET6wEemlzLOTmNfcSQ" showIcon="false" labelColor="39,76,114">

+          <customFeatures>labelSize</customFeatures>

+        </endLabelStyle>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC_EReference']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DEdge" uid="_YMDgFj6wEemlzLOTmNfcSQ" name="[0..*] rootElements" sourceNode="_YLQO0j6wEemlzLOTmNfcSQ" targetNode="_YLGd0D6wEemlzLOTmNfcSQ">

+      <target xmi:type="ecore:EReference" href="fam.ecore#//FunctionalArchitectureModel/rootElements"/>

+      <semanticElements xmi:type="ecore:EReference" href="fam.ecore#//FunctionalArchitectureModel/rootElements"/>

+      <ownedStyle xmi:type="diagram:EdgeStyle" uid="_YMDgGj6wEemlzLOTmNfcSQ" description="_YMDgFz6wEemlzLOTmNfcSQ" sourceArrow="FillDiamond" routingStyle="manhattan" strokeColor="0,0,0">

+        <centerLabelStyle xmi:type="diagram:CenterLabelStyle" uid="_YMDgHD6wEemlzLOTmNfcSQ" showIcon="false">

+          <customFeatures>labelSize</customFeatures>

+        </centerLabelStyle>

+        <endLabelStyle xmi:type="diagram:EndLabelStyle" uid="_YMDgGz6wEemlzLOTmNfcSQ" showIcon="false" labelColor="39,76,114">

+          <customFeatures>labelSize</customFeatures>

+        </endLabelStyle>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC_EReference']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DEdge" uid="_YMDgID6wEemlzLOTmNfcSQ" sourceNode="_YLQO1T6wEemlzLOTmNfcSQ" targetNode="_YLGd0D6wEemlzLOTmNfcSQ">

+      <target xmi:type="ecore:EClass" href="fam.ecore#//Function"/>

+      <semanticElements xmi:type="ecore:EClass" href="fam.ecore#//Function"/>

+      <ownedStyle xmi:type="diagram:EdgeStyle" uid="_YMDgIT6wEemlzLOTmNfcSQ" targetArrow="InputClosedArrow" routingStyle="tree">

+        <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>

+        <beginLabelStyle xmi:type="diagram:BeginLabelStyle" uid="_YMNRED6wEemlzLOTmNfcSQ" showIcon="false">

+          <labelFormat>italic</labelFormat>

+        </beginLabelStyle>

+        <centerLabelStyle xmi:type="diagram:CenterLabelStyle" uid="_YMNRET6wEemlzLOTmNfcSQ" showIcon="false"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DEdge" uid="_YMNRFT6wEemlzLOTmNfcSQ" sourceNode="_YLZYxz6wEemlzLOTmNfcSQ" targetNode="_YLZYyj6wEemlzLOTmNfcSQ">

+      <target xmi:type="ecore:EClass" href="fam.ecore#//FunctionalOutput"/>

+      <semanticElements xmi:type="ecore:EClass" href="fam.ecore#//FunctionalOutput"/>

+      <ownedStyle xmi:type="diagram:EdgeStyle" uid="_YMNRFj6wEemlzLOTmNfcSQ" targetArrow="InputClosedArrow" routingStyle="tree">

+        <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>

+        <beginLabelStyle xmi:type="diagram:BeginLabelStyle" uid="_YMNRFz6wEemlzLOTmNfcSQ" showIcon="false">

+          <labelFormat>italic</labelFormat>

+        </beginLabelStyle>

+        <centerLabelStyle xmi:type="diagram:CenterLabelStyle" uid="_YMNRGD6wEemlzLOTmNfcSQ" showIcon="false"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DEdge" uid="_YMNRHD6wEemlzLOTmNfcSQ" sourceNode="_YLZYxD6wEemlzLOTmNfcSQ" targetNode="_YLZYyj6wEemlzLOTmNfcSQ">

+      <target xmi:type="ecore:EClass" href="fam.ecore#//FunctionalInput"/>

+      <semanticElements xmi:type="ecore:EClass" href="fam.ecore#//FunctionalInput"/>

+      <ownedStyle xmi:type="diagram:EdgeStyle" uid="_YMNRHT6wEemlzLOTmNfcSQ" targetArrow="InputClosedArrow" routingStyle="tree">

+        <description xmi:type="style:EdgeStyleDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']/@style"/>

+        <beginLabelStyle xmi:type="diagram:BeginLabelStyle" uid="_YMNRHj6wEemlzLOTmNfcSQ" showIcon="false">

+          <labelFormat>italic</labelFormat>

+        </beginLabelStyle>

+        <centerLabelStyle xmi:type="diagram:CenterLabelStyle" uid="_YMNRHz6wEemlzLOTmNfcSQ" showIcon="false"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='EC%20ESupertypes']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DEdge" uid="_YMNRIz6wEemlzLOTmNfcSQ" sourceNode="_YLGd0D6wEemlzLOTmNfcSQ" targetNode="_YLQO1T6wEemlzLOTmNfcSQ" beginLabel="[0..*] subElements" endLabel="[0..1] parent">

+      <target xmi:type="ecore:EReference" href="fam.ecore#//FunctionalElement/parent"/>

+      <semanticElements xmi:type="ecore:EReference" href="fam.ecore#//FunctionalElement/parent"/>

+      <semanticElements xmi:type="ecore:EReference" href="fam.ecore#//Function/subElements"/>

+      <ownedStyle xmi:type="diagram:EdgeStyle" uid="_YMNRJz6wEemlzLOTmNfcSQ" description="_YMNRJD6wEemlzLOTmNfcSQ" sourceArrow="InputArrow" targetArrow="FillDiamond" routingStyle="manhattan" strokeColor="0,0,0">

+        <beginLabelStyle xmi:type="diagram:BeginLabelStyle" uid="_YMNRKD6wEemlzLOTmNfcSQ" showIcon="false"/>

+        <endLabelStyle xmi:type="diagram:EndLabelStyle" uid="_YMNRKT6wEemlzLOTmNfcSQ" showIcon="false"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='Bi-directional%20EC_EReference%20']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DEdge" uid="_YMNRLT6wEemlzLOTmNfcSQ" sourceNode="_YLQO2z6wEemlzLOTmNfcSQ" targetNode="_YLZYxz6wEemlzLOTmNfcSQ" beginLabel="[0..*] outgoingLinks" endLabel="[0..1] from">

+      <target xmi:type="ecore:EReference" href="fam.ecore#//InformationLink/from"/>

+      <semanticElements xmi:type="ecore:EReference" href="fam.ecore#//InformationLink/from"/>

+      <semanticElements xmi:type="ecore:EReference" href="fam.ecore#//FunctionalOutput/outgoingLinks"/>

+      <ownedStyle xmi:type="diagram:EdgeStyle" uid="_YMNRLj6wEemlzLOTmNfcSQ" description="_YMNRJD6wEemlzLOTmNfcSQ" sourceArrow="InputArrow" targetArrow="FillDiamond" routingStyle="manhattan" strokeColor="0,0,0">

+        <beginLabelStyle xmi:type="diagram:BeginLabelStyle" uid="_YMNRLz6wEemlzLOTmNfcSQ" showIcon="false"/>

+        <endLabelStyle xmi:type="diagram:EndLabelStyle" uid="_YMNRMD6wEemlzLOTmNfcSQ" showIcon="false"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='Bi-directional%20EC_EReference%20']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DEdge" uid="_YMNRND6wEemlzLOTmNfcSQ" sourceNode="_YLZYwT6wEemlzLOTmNfcSQ" targetNode="_YLZYyj6wEemlzLOTmNfcSQ" beginLabel="[0..1] interface" endLabel="[0..*] data">

+      <target xmi:type="ecore:EReference" href="fam.ecore#//FunctionalInterface/data"/>

+      <semanticElements xmi:type="ecore:EReference" href="fam.ecore#//FunctionalInterface/data"/>

+      <semanticElements xmi:type="ecore:EReference" href="fam.ecore#//FunctionalData/interface"/>

+      <ownedStyle xmi:type="diagram:EdgeStyle" uid="_YMNROD6wEemlzLOTmNfcSQ" description="_YMNRNT6wEemlzLOTmNfcSQ" sourceArrow="FillDiamond" routingStyle="manhattan" strokeColor="0,0,0">

+        <beginLabelStyle xmi:type="diagram:BeginLabelStyle" uid="_YMNROT6wEemlzLOTmNfcSQ" showIcon="false"/>

+        <endLabelStyle xmi:type="diagram:EndLabelStyle" uid="_YMNROj6wEemlzLOTmNfcSQ" showIcon="false"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='Bi-directional%20EC_EReference%20']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DEdge" uid="_YMNRPj6wEemlzLOTmNfcSQ" sourceNode="_YLQO2D6wEemlzLOTmNfcSQ" targetNode="_YLZYyj6wEemlzLOTmNfcSQ" beginLabel="[0..1] terminator" endLabel="[0..1] data">

+      <target xmi:type="ecore:EReference" href="fam.ecore#//FAMTerminator/data"/>

+      <semanticElements xmi:type="ecore:EReference" href="fam.ecore#//FAMTerminator/data"/>

+      <semanticElements xmi:type="ecore:EReference" href="fam.ecore#//FunctionalData/terminator"/>

+      <ownedStyle xmi:type="diagram:EdgeStyle" uid="_YMNRPz6wEemlzLOTmNfcSQ" description="_YMNRJD6wEemlzLOTmNfcSQ" sourceArrow="InputArrow" targetArrow="FillDiamond" routingStyle="manhattan" strokeColor="0,0,0">

+        <beginLabelStyle xmi:type="diagram:BeginLabelStyle" uid="_YMNRQD6wEemlzLOTmNfcSQ" showIcon="false"/>

+        <endLabelStyle xmi:type="diagram:EndLabelStyle" uid="_YMNRQT6wEemlzLOTmNfcSQ" showIcon="false"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='Bi-directional%20EC_EReference%20']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DEdge" uid="_YMNRRT6wEemlzLOTmNfcSQ" sourceNode="_YLGd0D6wEemlzLOTmNfcSQ" targetNode="_YLZYwT6wEemlzLOTmNfcSQ" beginLabel="[0..1] element" endLabel="[0..1] interface">

+      <target xmi:type="ecore:EReference" href="fam.ecore#//FunctionalElement/interface"/>

+      <semanticElements xmi:type="ecore:EReference" href="fam.ecore#//FunctionalInterface/element"/>

+      <semanticElements xmi:type="ecore:EReference" href="fam.ecore#//FunctionalElement/interface"/>

+      <ownedStyle xmi:type="diagram:EdgeStyle" uid="_YMNRRj6wEemlzLOTmNfcSQ" description="_YMNRNT6wEemlzLOTmNfcSQ" sourceArrow="FillDiamond" routingStyle="manhattan" strokeColor="0,0,0">

+        <beginLabelStyle xmi:type="diagram:BeginLabelStyle" uid="_YMNRRz6wEemlzLOTmNfcSQ" showIcon="false"/>

+        <endLabelStyle xmi:type="diagram:EndLabelStyle" uid="_YMNRSD6wEemlzLOTmNfcSQ" showIcon="false"/>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='Bi-directional%20EC_EReference%20']"/>

+    </ownedDiagramElements>

+    <ownedDiagramElements xmi:type="diagram:DEdge" uid="_YMNRTD6wEemlzLOTmNfcSQ" sourceNode="_YLQO2z6wEemlzLOTmNfcSQ" targetNode="_YLZYxD6wEemlzLOTmNfcSQ" beginLabel="[0..*] IncomingLinks" endLabel="[1..1] to">

+      <target xmi:type="ecore:EReference" href="fam.ecore#//InformationLink/to"/>

+      <semanticElements xmi:type="ecore:EReference" href="fam.ecore#//FunctionalInput/IncomingLinks"/>

+      <semanticElements xmi:type="ecore:EReference" href="fam.ecore#//InformationLink/to"/>

+      <ownedStyle xmi:type="diagram:EdgeStyle" uid="_YMNRUD6wEemlzLOTmNfcSQ" description="_YMNRTT6wEemlzLOTmNfcSQ" sourceArrow="InputArrow" routingStyle="manhattan" strokeColor="0,0,0">

+        <beginLabelStyle xmi:type="diagram:BeginLabelStyle" uid="_YMNRUT6wEemlzLOTmNfcSQ" showIcon="false">

+          <labelFormat>bold</labelFormat>

+        </beginLabelStyle>

+        <endLabelStyle xmi:type="diagram:EndLabelStyle" uid="_YMNRUj6wEemlzLOTmNfcSQ" showIcon="false">

+          <labelFormat>bold</labelFormat>

+        </endLabelStyle>

+      </ownedStyle>

+      <actualMapping xmi:type="description_1:EdgeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@edgeMappings[name='Bi-directional%20EC_EReference%20']"/>

+    </ownedDiagramElements>

+    <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>

+    <filterVariableHistory xmi:type="diagram:FilterVariableHistory" uid="_XZsPAD6wEemlzLOTmNfcSQ"/>

+    <activatedLayers xmi:type="description_1:Layer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer"/>

+    <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Package']"/>

+    <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@additionalLayers[name='Validation']"/>

+    <activatedLayers xmi:type="description_1:AdditionalLayer" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Archetype']/@ownedRepresentationExtensions[name='Entities%20With%20Archetypes']/@layers[name='Archetypes']"/>

+    <target xmi:type="ecore:EPackage" href="fam.ecore#/"/>

+  </diagram:DSemanticDiagram>

+</xmi:XMI>

diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/plugin.xml b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/plugin.xml
index 28ea4798..a2a573fc 100644
--- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/plugin.xml
+++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/plugin.xml
@@ -23,6 +23,8 @@
   <extension id="ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries.FamPatterns" point="org.eclipse.viatra.query.runtime.queryspecification">

     <group group="org.eclipse.viatra.query.runtime.extensibility.SingletonExtensionFactory:ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries.FamPatterns" id="ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries.FamPatterns">

       <query-specification fqn="ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries.terminatorAndInformation"/>

+      <query-specification fqn="ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries.rootElements"/>

+      <query-specification fqn="ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries.parent"/>

     </group>

   </extension>

   <extension id="ca.mcgill.ecse.dslreasoner.standalone.test.filesystem.queries.FileSystemPatterns" point="org.eclipse.viatra.query.runtime.queryspecification">

diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/queries/ca/mcgill/ecse/dslreasoner/standalone/test/fam/queries/famPatterns.vql b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/queries/ca/mcgill/ecse/dslreasoner/standalone/test/fam/queries/famPatterns.vql
index 1c6a545e..7e0db222 100644
--- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/queries/ca/mcgill/ecse/dslreasoner/standalone/test/fam/queries/famPatterns.vql
+++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/queries/ca/mcgill/ecse/dslreasoner/standalone/test/fam/queries/famPatterns.vql
@@ -25,7 +25,7 @@ pattern type(This : Function, Target : FunctionType) = {
         find parent(_Child, This);

         Target == FunctionType::Intermediate;

 }

-

+*/

 pattern rootElements(Model: FunctionalArchitectureModel, Root : Function) = {

         FunctionalArchitectureModel.rootElements(Model, Root);

 }

@@ -33,7 +33,7 @@ pattern rootElements(Model: FunctionalArchitectureModel, Root : Function) = {
 pattern parent(Func : Function, Par : Function) = {

         Function.parent(Func, Par);

 }

-

+/*

 @QueryBasedFeature 

 pattern model(This:FunctionalElement, Target: FunctionalArchitectureModel) {

         FunctionalElement(This);

diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/queries/ca/mcgill/ecse/dslreasoner/standalone/test/fam/queries/famSPatterns.vql b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/queries/ca/mcgill/ecse/dslreasoner/standalone/test/fam/queries/famSPatterns.vql
deleted file mode 100644
index 307b0f9c..00000000
--- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/queries/ca/mcgill/ecse/dslreasoner/standalone/test/fam/queries/famSPatterns.vql
+++ /dev/null
@@ -1,13 +0,0 @@
-package ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries

-

-//import epackage "http://www.inf.mit.bme.hu/viatrasolver/example/fam"

-import epackage "FamMetamodel"

-

-@Constraint(message="terminatorAndInformation", severity="error", key={T})

-pattern terminatorAndInformation(T : FAMTerminator, I : InformationLink) = {

-        FunctionalOutput.outgoingLinks(Out,I);

-        FunctionalOutput.terminator(Out,T); 

-} or {

-        InformationLink.to(I,In);

-        FunctionalInput.terminator(In,T);

-}
\ No newline at end of file
diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/.gitignore b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/.gitignore
index ae3c1726..7d818ce2 100644
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/.gitignore
+++ b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/.gitignore
@@ -1 +1,4 @@
 /bin/
+/xtend-gen/
+/src-gen/
+/output/*
diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/output/FAMTest/vampireProblem.tptp b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/output/FAMTest/vampireProblem.tptp
index 3109ccc2..5c3ef527 100644
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/output/FAMTest/vampireProblem.tptp
+++ b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/output/FAMTest/vampireProblem.tptp
@@ -5,13 +5,13 @@ fof ( enumScope_FunctionType_Intermediate , axiom , ! [ A ] : ( A = eo2 <=> e_In
 fof ( enumScope_FunctionType_Leaf , axiom , ! [ A ] : ( A = eo3 <=> e_Leaf_FunctionType ( A ) ) ) .

 fof ( inheritanceHierarchyHandler , axiom , ! [ A ] : ( object ( A ) <=> ( ( t_FAMTerminator ( A ) & ( ~ t_FunctionalData ( A ) & ( ~ t_FunctionalInterface ( A ) & ( ~ t_Function ( A ) & ( ~ t_InformationLink ( A ) & ( ~ t_FunctionalElement ( A ) & ( ~ t_FunctionalArchitectureModel ( A ) & ( ~ t_FunctionType ( A ) & ( ~ t_FunctionalInput ( A ) & ~ t_FunctionalOutput ( A ) ) ) ) ) ) ) ) ) ) | ( ( ~ t_FAMTerminator ( A ) & ( ~ t_FunctionalData ( A ) & ( t_FunctionalInterface ( A ) & ( ~ t_Function ( A ) & ( ~ t_InformationLink ( A ) & ( ~ t_FunctionalElement ( A ) & ( ~ t_FunctionalArchitectureModel ( A ) & ( ~ t_FunctionType ( A ) & ( ~ t_FunctionalInput ( A ) & ~ t_FunctionalOutput ( A ) ) ) ) ) ) ) ) ) ) | ( ( ~ t_FAMTerminator ( A ) & ( ~ t_FunctionalData ( A ) & ( ~ t_FunctionalInterface ( A ) & ( t_Function ( A ) & ( ~ t_InformationLink ( A ) & ( t_FunctionalElement ( A ) & ( ~ t_FunctionalArchitectureModel ( A ) & ( ~ t_FunctionType ( A ) & ( ~ t_FunctionalInput ( A ) & ~ t_FunctionalOutput ( A ) ) ) ) ) ) ) ) ) ) | ( ( ~ t_FAMTerminator ( A ) & ( ~ t_FunctionalData ( A ) & ( ~ t_FunctionalInterface ( A ) & ( ~ t_Function ( A ) & ( t_InformationLink ( A ) & ( ~ t_FunctionalElement ( A ) & ( ~ t_FunctionalArchitectureModel ( A ) & ( ~ t_FunctionType ( A ) & ( ~ t_FunctionalInput ( A ) & ~ t_FunctionalOutput ( A ) ) ) ) ) ) ) ) ) ) | ( ( ~ t_FAMTerminator ( A ) & ( ~ t_FunctionalData ( A ) & ( ~ t_FunctionalInterface ( A ) & ( ~ t_Function ( A ) & ( ~ t_InformationLink ( A ) & ( ~ t_FunctionalElement ( A ) & ( t_FunctionalArchitectureModel ( A ) & ( ~ t_FunctionType ( A ) & ( ~ t_FunctionalInput ( A ) & ~ t_FunctionalOutput ( A ) ) ) ) ) ) ) ) ) ) | ( ( ~ t_FAMTerminator ( A ) & ( ~ t_FunctionalData ( A ) & ( ~ t_FunctionalInterface ( A ) & ( ~ t_Function ( A ) & ( ~ t_InformationLink ( A ) & ( ~ t_FunctionalElement ( A ) & ( ~ t_FunctionalArchitectureModel ( A ) & ( t_FunctionType ( A ) & ( ~ t_FunctionalInput ( A ) & ~ t_FunctionalOutput ( A ) ) ) ) ) ) ) ) ) ) | ( ( ~ t_FAMTerminator ( A ) & ( t_FunctionalData ( A ) & ( ~ t_FunctionalInterface ( A ) & ( ~ t_Function ( A ) & ( ~ t_InformationLink ( A ) & ( ~ t_FunctionalElement ( A ) & ( ~ t_FunctionalArchitectureModel ( A ) & ( ~ t_FunctionType ( A ) & ( t_FunctionalInput ( A ) & ~ t_FunctionalOutput ( A ) ) ) ) ) ) ) ) ) ) | ( ~ t_FAMTerminator ( A ) & ( t_FunctionalData ( A ) & ( ~ t_FunctionalInterface ( A ) & ( ~ t_Function ( A ) & ( ~ t_InformationLink ( A ) & ( ~ t_FunctionalElement ( A ) & ( ~ t_FunctionalArchitectureModel ( A ) & ( ~ t_FunctionType ( A ) & ( ~ t_FunctionalInput ( A ) & t_FunctionalOutput ( A ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .

 fof ( typeScope_min_object , axiom , ! [ A ] : ( ( A = o1 | ( A = o2 | ( A = o3 | ( A = o4 | ( A = o5 | ( A = o6 | ( A = eo1 | ( A = eo2 | A = eo3 ) ) ) ) ) ) ) ) => object ( A ) ) ) .

-fof ( typeScope_max_object , axiom , ! [ A ] : ( object ( A ) => ( A = eo1 | ( A = eo2 | ( A = eo3 | ( A = o1 | ( A = o2 | ( A = o3 | ( A = o4 | ( A = o5 | ( A = o6 | ( A = o7 | A = o8 ) ) ) ) ) ) ) ) ) ) ) ) .

+fof ( typeScope_max_object , axiom , ! [ A ] : ( object ( A ) => ( A = eo1 | ( A = eo2 | ( A = eo3 | ( A = o1 | ( A = o2 | ( A = o3 | ( A = o4 | ( A = o5 | ( A = o6 | ( A = o7 | ( A = o8 | ( A = o9 | ( A = o10 | ( A = o11 | ( A = o12 | ( A = o13 | ( A = o14 | ( A = o15 | ( A = o16 | ( A = o17 | ( A = o18 | ( A = o19 | ( A = o20 | ( A = o21 | ( A = o22 | ( A = o23 | ( A = o24 | ( A = o25 | ( A = o26 | ( A = o27 | ( A = o28 | ( A = o29 | ( A = o30 | ( A = o31 | ( A = o32 | ( A = o33 | ( A = o34 | ( A = o35 | ( A = o36 | ( A = o37 | ( A = o38 | ( A = o39 | A = o40 ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .

 fof ( typeScope_min_t_FunctionalInterface , axiom , ! [ A ] : ( ( A = o2 | A = o3 ) => ( t_FunctionalInterface ( A ) & object ( A ) ) ) ) .

 fof ( typeScope_min_t_Function , axiom , ! [ A ] : ( A = o4 => ( t_Function ( A ) & object ( A ) ) ) ) .

 fof ( typeScope_min_t_FunctionalOutput , axiom , ! [ A ] : ( ( A = o5 | ( A = o6 | A = o7 ) ) => ( t_FunctionalOutput ( A ) & object ( A ) ) ) ) .

-fof ( typeScope_max_t_Function , axiom , ! [ A ] : ( ( t_Function ( A ) & object ( A ) ) => ( A = o4 | A = o8 ) ) ) .

+fof ( typeScope_max_t_Function , axiom , ! [ A ] : ( ( t_Function ( A ) & object ( A ) ) => ( A = o4 | ( A = o8 | ( A = o9 | ( A = o10 | A = o11 ) ) ) ) ) ) .

 fof ( typeScope_max_t_FunctionalOutput , axiom , ! [ A ] : ( ( t_FunctionalOutput ( A ) & object ( A ) ) => ( A = o5 | ( A = o6 | ( A = o7 | A = o8 ) ) ) ) ) .

-fof ( typeUniqueness , axiom , eo1 != eo2 & ( eo1 != eo3 & ( eo2 != eo3 & ( eo1 != o1 & ( eo2 != o1 & ( eo3 != o1 & ( eo1 != o2 & ( eo2 != o2 & ( eo3 != o2 & ( o1 != o2 & ( eo1 != o3 & ( eo2 != o3 & ( eo3 != o3 & ( o1 != o3 & ( o2 != o3 & ( eo1 != o4 & ( eo2 != o4 & ( eo3 != o4 & ( o1 != o4 & ( o2 != o4 & ( o3 != o4 & ( eo1 != o5 & ( eo2 != o5 & ( eo3 != o5 & ( o1 != o5 & ( o2 != o5 & ( o3 != o5 & ( o4 != o5 & ( eo1 != o6 & ( eo2 != o6 & ( eo3 != o6 & ( o1 != o6 & ( o2 != o6 & ( o3 != o6 & ( o4 != o6 & ( o5 != o6 & ( eo1 != o7 & ( eo2 != o7 & ( eo3 != o7 & ( o1 != o7 & ( o2 != o7 & ( o3 != o7 & ( o4 != o7 & ( o5 != o7 & ( o6 != o7 & ( eo1 != o8 & ( eo2 != o8 & ( eo3 != o8 & ( o1 != o8 & ( o2 != o8 & ( o3 != o8 & ( o4 != o8 & ( o5 != o8 & ( o6 != o8 & o7 != o8 ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .

+fof ( typeUniqueness , axiom , eo1 != eo2 & ( eo1 != eo3 & ( eo2 != eo3 & ( eo1 != o1 & ( eo2 != o1 & ( eo3 != o1 & ( eo1 != o2 & ( eo2 != o2 & ( eo3 != o2 & ( o1 != o2 & ( eo1 != o3 & ( eo2 != o3 & ( eo3 != o3 & ( o1 != o3 & ( o2 != o3 & ( eo1 != o4 & ( eo2 != o4 & ( eo3 != o4 & ( o1 != o4 & ( o2 != o4 & ( o3 != o4 & ( eo1 != o5 & ( eo2 != o5 & ( eo3 != o5 & ( o1 != o5 & ( o2 != o5 & ( o3 != o5 & ( o4 != o5 & ( eo1 != o6 & ( eo2 != o6 & ( eo3 != o6 & ( o1 != o6 & ( o2 != o6 & ( o3 != o6 & ( o4 != o6 & ( o5 != o6 & ( eo1 != o7 & ( eo2 != o7 & ( eo3 != o7 & ( o1 != o7 & ( o2 != o7 & ( o3 != o7 & ( o4 != o7 & ( o5 != o7 & ( o6 != o7 & ( eo1 != o8 & ( eo2 != o8 & ( eo3 != o8 & ( o1 != o8 & ( o2 != o8 & ( o3 != o8 & ( o4 != o8 & ( o5 != o8 & ( o6 != o8 & ( o7 != o8 & ( eo1 != o9 & ( eo2 != o9 & ( eo3 != o9 & ( o1 != o9 & ( o2 != o9 & ( o3 != o9 & ( o4 != o9 & ( o5 != o9 & ( o6 != o9 & ( o7 != o9 & ( o8 != o9 & ( eo1 != o10 & ( eo2 != o10 & ( eo3 != o10 & ( o1 != o10 & ( o2 != o10 & ( o3 != o10 & ( o4 != o10 & ( o5 != o10 & ( o6 != o10 & ( o7 != o10 & ( o8 != o10 & ( o9 != o10 & ( eo1 != o11 & ( eo2 != o11 & ( eo3 != o11 & ( o1 != o11 & ( o2 != o11 & ( o3 != o11 & ( o4 != o11 & ( o5 != o11 & ( o6 != o11 & ( o7 != o11 & ( o8 != o11 & ( o9 != o11 & ( o10 != o11 & ( eo1 != o12 & ( eo2 != o12 & ( eo3 != o12 & ( o1 != o12 & ( o2 != o12 & ( o3 != o12 & ( o4 != o12 & ( o5 != o12 & ( o6 != o12 & ( o7 != o12 & ( o8 != o12 & ( o9 != o12 & ( o10 != o12 & ( o11 != o12 & ( eo1 != o13 & ( eo2 != o13 & ( eo3 != o13 & ( o1 != o13 & ( o2 != o13 & ( o3 != o13 & ( o4 != o13 & ( o5 != o13 & ( o6 != o13 & ( o7 != o13 & ( o8 != o13 & ( o9 != o13 & ( o10 != o13 & ( o11 != o13 & ( o12 != o13 & ( eo1 != o14 & ( eo2 != o14 & ( eo3 != o14 & ( o1 != o14 & ( o2 != o14 & ( o3 != o14 & ( o4 != o14 & ( o5 != o14 & ( o6 != o14 & ( o7 != o14 & ( o8 != o14 & ( o9 != o14 & ( o10 != o14 & ( o11 != o14 & ( o12 != o14 & ( o13 != o14 & ( eo1 != o15 & ( eo2 != o15 & ( eo3 != o15 & ( o1 != o15 & ( o2 != o15 & ( o3 != o15 & ( o4 != o15 & ( o5 != o15 & ( o6 != o15 & ( o7 != o15 & ( o8 != o15 & ( o9 != o15 & ( o10 != o15 & ( o11 != o15 & ( o12 != o15 & ( o13 != o15 & ( o14 != o15 & ( eo1 != o16 & ( eo2 != o16 & ( eo3 != o16 & ( o1 != o16 & ( o2 != o16 & ( o3 != o16 & ( o4 != o16 & ( o5 != o16 & ( o6 != o16 & ( o7 != o16 & ( o8 != o16 & ( o9 != o16 & ( o10 != o16 & ( o11 != o16 & ( o12 != o16 & ( o13 != o16 & ( o14 != o16 & ( o15 != o16 & ( eo1 != o17 & ( eo2 != o17 & ( eo3 != o17 & ( o1 != o17 & ( o2 != o17 & ( o3 != o17 & ( o4 != o17 & ( o5 != o17 & ( o6 != o17 & ( o7 != o17 & ( o8 != o17 & ( o9 != o17 & ( o10 != o17 & ( o11 != o17 & ( o12 != o17 & ( o13 != o17 & ( o14 != o17 & ( o15 != o17 & ( o16 != o17 & ( eo1 != o18 & ( eo2 != o18 & ( eo3 != o18 & ( o1 != o18 & ( o2 != o18 & ( o3 != o18 & ( o4 != o18 & ( o5 != o18 & ( o6 != o18 & ( o7 != o18 & ( o8 != o18 & ( o9 != o18 & ( o10 != o18 & ( o11 != o18 & ( o12 != o18 & ( o13 != o18 & ( o14 != o18 & ( o15 != o18 & ( o16 != o18 & ( o17 != o18 & ( eo1 != o19 & ( eo2 != o19 & ( eo3 != o19 & ( o1 != o19 & ( o2 != o19 & ( o3 != o19 & ( o4 != o19 & ( o5 != o19 & ( o6 != o19 & ( o7 != o19 & ( o8 != o19 & ( o9 != o19 & ( o10 != o19 & ( o11 != o19 & ( o12 != o19 & ( o13 != o19 & ( o14 != o19 & ( o15 != o19 & ( o16 != o19 & ( o17 != o19 & ( o18 != o19 & ( eo1 != o20 & ( eo2 != o20 & ( eo3 != o20 & ( o1 != o20 & ( o2 != o20 & ( o3 != o20 & ( o4 != o20 & ( o5 != o20 & ( o6 != o20 & ( o7 != o20 & ( o8 != o20 & ( o9 != o20 & ( o10 != o20 & ( o11 != o20 & ( o12 != o20 & ( o13 != o20 & ( o14 != o20 & ( o15 != o20 & ( o16 != o20 & ( o17 != o20 & ( o18 != o20 & ( o19 != o20 & ( eo1 != o21 & ( eo2 != o21 & ( eo3 != o21 & ( o1 != o21 & ( o2 != o21 & ( o3 != o21 & ( o4 != o21 & ( o5 != o21 & ( o6 != o21 & ( o7 != o21 & ( o8 != o21 & ( o9 != o21 & ( o10 != o21 & ( o11 != o21 & ( o12 != o21 & ( o13 != o21 & ( o14 != o21 & ( o15 != o21 & ( o16 != o21 & ( o17 != o21 & ( o18 != o21 & ( o19 != o21 & ( o20 != o21 & ( eo1 != o22 & ( eo2 != o22 & ( eo3 != o22 & ( o1 != o22 & ( o2 != o22 & ( o3 != o22 & ( o4 != o22 & ( o5 != o22 & ( o6 != o22 & ( o7 != o22 & ( o8 != o22 & ( o9 != o22 & ( o10 != o22 & ( o11 != o22 & ( o12 != o22 & ( o13 != o22 & ( o14 != o22 & ( o15 != o22 & ( o16 != o22 & ( o17 != o22 & ( o18 != o22 & ( o19 != o22 & ( o20 != o22 & ( o21 != o22 & ( eo1 != o23 & ( eo2 != o23 & ( eo3 != o23 & ( o1 != o23 & ( o2 != o23 & ( o3 != o23 & ( o4 != o23 & ( o5 != o23 & ( o6 != o23 & ( o7 != o23 & ( o8 != o23 & ( o9 != o23 & ( o10 != o23 & ( o11 != o23 & ( o12 != o23 & ( o13 != o23 & ( o14 != o23 & ( o15 != o23 & ( o16 != o23 & ( o17 != o23 & ( o18 != o23 & ( o19 != o23 & ( o20 != o23 & ( o21 != o23 & ( o22 != o23 & ( eo1 != o24 & ( eo2 != o24 & ( eo3 != o24 & ( o1 != o24 & ( o2 != o24 & ( o3 != o24 & ( o4 != o24 & ( o5 != o24 & ( o6 != o24 & ( o7 != o24 & ( o8 != o24 & ( o9 != o24 & ( o10 != o24 & ( o11 != o24 & ( o12 != o24 & ( o13 != o24 & ( o14 != o24 & ( o15 != o24 & ( o16 != o24 & ( o17 != o24 & ( o18 != o24 & ( o19 != o24 & ( o20 != o24 & ( o21 != o24 & ( o22 != o24 & ( o23 != o24 & ( eo1 != o25 & ( eo2 != o25 & ( eo3 != o25 & ( o1 != o25 & ( o2 != o25 & ( o3 != o25 & ( o4 != o25 & ( o5 != o25 & ( o6 != o25 & ( o7 != o25 & ( o8 != o25 & ( o9 != o25 & ( o10 != o25 & ( o11 != o25 & ( o12 != o25 & ( o13 != o25 & ( o14 != o25 & ( o15 != o25 & ( o16 != o25 & ( o17 != o25 & ( o18 != o25 & ( o19 != o25 & ( o20 != o25 & ( o21 != o25 & ( o22 != o25 & ( o23 != o25 & ( o24 != o25 & ( eo1 != o26 & ( eo2 != o26 & ( eo3 != o26 & ( o1 != o26 & ( o2 != o26 & ( o3 != o26 & ( o4 != o26 & ( o5 != o26 & ( o6 != o26 & ( o7 != o26 & ( o8 != o26 & ( o9 != o26 & ( o10 != o26 & ( o11 != o26 & ( o12 != o26 & ( o13 != o26 & ( o14 != o26 & ( o15 != o26 & ( o16 != o26 & ( o17 != o26 & ( o18 != o26 & ( o19 != o26 & ( o20 != o26 & ( o21 != o26 & ( o22 != o26 & ( o23 != o26 & ( o24 != o26 & ( o25 != o26 & ( eo1 != o27 & ( eo2 != o27 & ( eo3 != o27 & ( o1 != o27 & ( o2 != o27 & ( o3 != o27 & ( o4 != o27 & ( o5 != o27 & ( o6 != o27 & ( o7 != o27 & ( o8 != o27 & ( o9 != o27 & ( o10 != o27 & ( o11 != o27 & ( o12 != o27 & ( o13 != o27 & ( o14 != o27 & ( o15 != o27 & ( o16 != o27 & ( o17 != o27 & ( o18 != o27 & ( o19 != o27 & ( o20 != o27 & ( o21 != o27 & ( o22 != o27 & ( o23 != o27 & ( o24 != o27 & ( o25 != o27 & ( o26 != o27 & ( eo1 != o28 & ( eo2 != o28 & ( eo3 != o28 & ( o1 != o28 & ( o2 != o28 & ( o3 != o28 & ( o4 != o28 & ( o5 != o28 & ( o6 != o28 & ( o7 != o28 & ( o8 != o28 & ( o9 != o28 & ( o10 != o28 & ( o11 != o28 & ( o12 != o28 & ( o13 != o28 & ( o14 != o28 & ( o15 != o28 & ( o16 != o28 & ( o17 != o28 & ( o18 != o28 & ( o19 != o28 & ( o20 != o28 & ( o21 != o28 & ( o22 != o28 & ( o23 != o28 & ( o24 != o28 & ( o25 != o28 & ( o26 != o28 & ( o27 != o28 & ( eo1 != o29 & ( eo2 != o29 & ( eo3 != o29 & ( o1 != o29 & ( o2 != o29 & ( o3 != o29 & ( o4 != o29 & ( o5 != o29 & ( o6 != o29 & ( o7 != o29 & ( o8 != o29 & ( o9 != o29 & ( o10 != o29 & ( o11 != o29 & ( o12 != o29 & ( o13 != o29 & ( o14 != o29 & ( o15 != o29 & ( o16 != o29 & ( o17 != o29 & ( o18 != o29 & ( o19 != o29 & ( o20 != o29 & ( o21 != o29 & ( o22 != o29 & ( o23 != o29 & ( o24 != o29 & ( o25 != o29 & ( o26 != o29 & ( o27 != o29 & ( o28 != o29 & ( eo1 != o30 & ( eo2 != o30 & ( eo3 != o30 & ( o1 != o30 & ( o2 != o30 & ( o3 != o30 & ( o4 != o30 & ( o5 != o30 & ( o6 != o30 & ( o7 != o30 & ( o8 != o30 & ( o9 != o30 & ( o10 != o30 & ( o11 != o30 & ( o12 != o30 & ( o13 != o30 & ( o14 != o30 & ( o15 != o30 & ( o16 != o30 & ( o17 != o30 & ( o18 != o30 & ( o19 != o30 & ( o20 != o30 & ( o21 != o30 & ( o22 != o30 & ( o23 != o30 & ( o24 != o30 & ( o25 != o30 & ( o26 != o30 & ( o27 != o30 & ( o28 != o30 & ( o29 != o30 & ( eo1 != o31 & ( eo2 != o31 & ( eo3 != o31 & ( o1 != o31 & ( o2 != o31 & ( o3 != o31 & ( o4 != o31 & ( o5 != o31 & ( o6 != o31 & ( o7 != o31 & ( o8 != o31 & ( o9 != o31 & ( o10 != o31 & ( o11 != o31 & ( o12 != o31 & ( o13 != o31 & ( o14 != o31 & ( o15 != o31 & ( o16 != o31 & ( o17 != o31 & ( o18 != o31 & ( o19 != o31 & ( o20 != o31 & ( o21 != o31 & ( o22 != o31 & ( o23 != o31 & ( o24 != o31 & ( o25 != o31 & ( o26 != o31 & ( o27 != o31 & ( o28 != o31 & ( o29 != o31 & ( o30 != o31 & ( eo1 != o32 & ( eo2 != o32 & ( eo3 != o32 & ( o1 != o32 & ( o2 != o32 & ( o3 != o32 & ( o4 != o32 & ( o5 != o32 & ( o6 != o32 & ( o7 != o32 & ( o8 != o32 & ( o9 != o32 & ( o10 != o32 & ( o11 != o32 & ( o12 != o32 & ( o13 != o32 & ( o14 != o32 & ( o15 != o32 & ( o16 != o32 & ( o17 != o32 & ( o18 != o32 & ( o19 != o32 & ( o20 != o32 & ( o21 != o32 & ( o22 != o32 & ( o23 != o32 & ( o24 != o32 & ( o25 != o32 & ( o26 != o32 & ( o27 != o32 & ( o28 != o32 & ( o29 != o32 & ( o30 != o32 & ( o31 != o32 & ( eo1 != o33 & ( eo2 != o33 & ( eo3 != o33 & ( o1 != o33 & ( o2 != o33 & ( o3 != o33 & ( o4 != o33 & ( o5 != o33 & ( o6 != o33 & ( o7 != o33 & ( o8 != o33 & ( o9 != o33 & ( o10 != o33 & ( o11 != o33 & ( o12 != o33 & ( o13 != o33 & ( o14 != o33 & ( o15 != o33 & ( o16 != o33 & ( o17 != o33 & ( o18 != o33 & ( o19 != o33 & ( o20 != o33 & ( o21 != o33 & ( o22 != o33 & ( o23 != o33 & ( o24 != o33 & ( o25 != o33 & ( o26 != o33 & ( o27 != o33 & ( o28 != o33 & ( o29 != o33 & ( o30 != o33 & ( o31 != o33 & ( o32 != o33 & ( eo1 != o34 & ( eo2 != o34 & ( eo3 != o34 & ( o1 != o34 & ( o2 != o34 & ( o3 != o34 & ( o4 != o34 & ( o5 != o34 & ( o6 != o34 & ( o7 != o34 & ( o8 != o34 & ( o9 != o34 & ( o10 != o34 & ( o11 != o34 & ( o12 != o34 & ( o13 != o34 & ( o14 != o34 & ( o15 != o34 & ( o16 != o34 & ( o17 != o34 & ( o18 != o34 & ( o19 != o34 & ( o20 != o34 & ( o21 != o34 & ( o22 != o34 & ( o23 != o34 & ( o24 != o34 & ( o25 != o34 & ( o26 != o34 & ( o27 != o34 & ( o28 != o34 & ( o29 != o34 & ( o30 != o34 & ( o31 != o34 & ( o32 != o34 & ( o33 != o34 & ( eo1 != o35 & ( eo2 != o35 & ( eo3 != o35 & ( o1 != o35 & ( o2 != o35 & ( o3 != o35 & ( o4 != o35 & ( o5 != o35 & ( o6 != o35 & ( o7 != o35 & ( o8 != o35 & ( o9 != o35 & ( o10 != o35 & ( o11 != o35 & ( o12 != o35 & ( o13 != o35 & ( o14 != o35 & ( o15 != o35 & ( o16 != o35 & ( o17 != o35 & ( o18 != o35 & ( o19 != o35 & ( o20 != o35 & ( o21 != o35 & ( o22 != o35 & ( o23 != o35 & ( o24 != o35 & ( o25 != o35 & ( o26 != o35 & ( o27 != o35 & ( o28 != o35 & ( o29 != o35 & ( o30 != o35 & ( o31 != o35 & ( o32 != o35 & ( o33 != o35 & ( o34 != o35 & ( eo1 != o36 & ( eo2 != o36 & ( eo3 != o36 & ( o1 != o36 & ( o2 != o36 & ( o3 != o36 & ( o4 != o36 & ( o5 != o36 & ( o6 != o36 & ( o7 != o36 & ( o8 != o36 & ( o9 != o36 & ( o10 != o36 & ( o11 != o36 & ( o12 != o36 & ( o13 != o36 & ( o14 != o36 & ( o15 != o36 & ( o16 != o36 & ( o17 != o36 & ( o18 != o36 & ( o19 != o36 & ( o20 != o36 & ( o21 != o36 & ( o22 != o36 & ( o23 != o36 & ( o24 != o36 & ( o25 != o36 & ( o26 != o36 & ( o27 != o36 & ( o28 != o36 & ( o29 != o36 & ( o30 != o36 & ( o31 != o36 & ( o32 != o36 & ( o33 != o36 & ( o34 != o36 & ( o35 != o36 & ( eo1 != o37 & ( eo2 != o37 & ( eo3 != o37 & ( o1 != o37 & ( o2 != o37 & ( o3 != o37 & ( o4 != o37 & ( o5 != o37 & ( o6 != o37 & ( o7 != o37 & ( o8 != o37 & ( o9 != o37 & ( o10 != o37 & ( o11 != o37 & ( o12 != o37 & ( o13 != o37 & ( o14 != o37 & ( o15 != o37 & ( o16 != o37 & ( o17 != o37 & ( o18 != o37 & ( o19 != o37 & ( o20 != o37 & ( o21 != o37 & ( o22 != o37 & ( o23 != o37 & ( o24 != o37 & ( o25 != o37 & ( o26 != o37 & ( o27 != o37 & ( o28 != o37 & ( o29 != o37 & ( o30 != o37 & ( o31 != o37 & ( o32 != o37 & ( o33 != o37 & ( o34 != o37 & ( o35 != o37 & ( o36 != o37 & ( eo1 != o38 & ( eo2 != o38 & ( eo3 != o38 & ( o1 != o38 & ( o2 != o38 & ( o3 != o38 & ( o4 != o38 & ( o5 != o38 & ( o6 != o38 & ( o7 != o38 & ( o8 != o38 & ( o9 != o38 & ( o10 != o38 & ( o11 != o38 & ( o12 != o38 & ( o13 != o38 & ( o14 != o38 & ( o15 != o38 & ( o16 != o38 & ( o17 != o38 & ( o18 != o38 & ( o19 != o38 & ( o20 != o38 & ( o21 != o38 & ( o22 != o38 & ( o23 != o38 & ( o24 != o38 & ( o25 != o38 & ( o26 != o38 & ( o27 != o38 & ( o28 != o38 & ( o29 != o38 & ( o30 != o38 & ( o31 != o38 & ( o32 != o38 & ( o33 != o38 & ( o34 != o38 & ( o35 != o38 & ( o36 != o38 & ( o37 != o38 & ( eo1 != o39 & ( eo2 != o39 & ( eo3 != o39 & ( o1 != o39 & ( o2 != o39 & ( o3 != o39 & ( o4 != o39 & ( o5 != o39 & ( o6 != o39 & ( o7 != o39 & ( o8 != o39 & ( o9 != o39 & ( o10 != o39 & ( o11 != o39 & ( o12 != o39 & ( o13 != o39 & ( o14 != o39 & ( o15 != o39 & ( o16 != o39 & ( o17 != o39 & ( o18 != o39 & ( o19 != o39 & ( o20 != o39 & ( o21 != o39 & ( o22 != o39 & ( o23 != o39 & ( o24 != o39 & ( o25 != o39 & ( o26 != o39 & ( o27 != o39 & ( o28 != o39 & ( o29 != o39 & ( o30 != o39 & ( o31 != o39 & ( o32 != o39 & ( o33 != o39 & ( o34 != o39 & ( o35 != o39 & ( o36 != o39 & ( o37 != o39 & ( o38 != o39 & ( eo1 != o40 & ( eo2 != o40 & ( eo3 != o40 & ( o1 != o40 & ( o2 != o40 & ( o3 != o40 & ( o4 != o40 & ( o5 != o40 & ( o6 != o40 & ( o7 != o40 & ( o8 != o40 & ( o9 != o40 & ( o10 != o40 & ( o11 != o40 & ( o12 != o40 & ( o13 != o40 & ( o14 != o40 & ( o15 != o40 & ( o16 != o40 & ( o17 != o40 & ( o18 != o40 & ( o19 != o40 & ( o20 != o40 & ( o21 != o40 & ( o22 != o40 & ( o23 != o40 & ( o24 != o40 & ( o25 != o40 & ( o26 != o40 & ( o27 != o40 & ( o28 != o40 & ( o29 != o40 & ( o30 != o40 & ( o31 != o40 & ( o32 != o40 & ( o33 != o40 & ( o34 != o40 & ( o35 != o40 & ( o36 != o40 & ( o37 != o40 & ( o38 != o40 & o39 != o40 ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) .

 fof ( compliance_interface_FunctionalElement , axiom , ! [ V_0 , V_1 ] : ( r_interface_FunctionalElement ( V_0 , V_1 ) => ( t_FunctionalElement ( V_0 ) & t_FunctionalInterface ( V_1 ) ) ) ) .

 fof ( compliance_model_FunctionalElement , axiom , ! [ V_0 , V_1 ] : ( r_model_FunctionalElement ( V_0 , V_1 ) => ( t_FunctionalElement ( V_0 ) & t_FunctionalArchitectureModel ( V_1 ) ) ) ) .

 fof ( compliance_parent_FunctionalElement , axiom , ! [ V_0 , V_1 ] : ( r_parent_FunctionalElement ( V_0 , V_1 ) => ( t_FunctionalElement ( V_0 ) & t_Function ( V_1 ) ) ) ) .

@@ -28,12 +28,16 @@ fof ( compliance_terminator_FunctionalData , axiom , ! [ V_0 , V_1 ] : ( r_termi
 fof ( compliance_interface_FunctionalData , axiom , ! [ V_0 , V_1 ] : ( r_interface_FunctionalData ( V_0 , V_1 ) => ( t_FunctionalData ( V_0 ) & t_FunctionalInterface ( V_1 ) ) ) ) .

 fof ( compliance_type_Function , axiom , ! [ V_0 , V_1 ] : ( r_type_Function ( V_0 , V_1 ) => ( t_Function ( V_0 ) & t_FunctionType ( V_1 ) ) ) ) .

 fof ( containment_topLevel_t_FunctionalArchitectureModel , axiom , ! [ A ] : ( t_FunctionalArchitectureModel ( A ) <=> A = o1 ) ) .

-fof ( containment_r_interface_FunctionalElement , axiom , ! [ A ] : ( t_FunctionalInterface ( A ) => ? [ B ] : ( t_FunctionalElement ( B ) & r_interface_FunctionalElement ( B , A ) ) ) ) .

-fof ( containment_r_rootElements_FunctionalArchitectureModel , axiom , ! [ A ] : ( t_FunctionalElement ( A ) => ? [ B ] : ( t_FunctionalArchitectureModel ( B ) & r_rootElements_FunctionalArchitectureModel ( B , A ) ) ) ) .

-fof ( containment_r_subElements_Function , axiom , ! [ A ] : ( t_FunctionalElement ( A ) => ? [ B ] : ( t_Function ( B ) & r_subElements_Function ( B , A ) ) ) ) .

-fof ( containment_r_data_FunctionalInterface , axiom , ! [ A ] : ( t_FunctionalData ( A ) => ? [ B ] : ( t_FunctionalInterface ( B ) & r_data_FunctionalInterface ( B , A ) ) ) ) .

-fof ( containment_r_outgoingLinks_FunctionalOutput , axiom , ! [ A ] : ( t_InformationLink ( A ) => ? [ B ] : ( t_FunctionalOutput ( B ) & r_outgoingLinks_FunctionalOutput ( B , A ) ) ) ) .

-fof ( containment_r_terminator_FunctionalData , axiom , ! [ A ] : ( t_FAMTerminator ( A ) => ? [ B ] : ( t_FunctionalData ( B ) & r_terminator_FunctionalData ( B , A ) ) ) ) .

+

+

+fof ( containment_r_interface_FunctionalElement , axiom , ! [ A ] : ( t_FunctionalInterface ( A ) => ? [ B ] : r_interface_FunctionalElement ( B , A ) ) ) .

+fof ( containment_r_rootElements_FunctionalArchitectureModel , axiom , ! [ A ] : ( t_FunctionalElement ( A ) => ? [ B ] : r_rootElements_FunctionalArchitectureModel ( B , A ) ) ) .

+fof ( containment_r_subElements_Function , axiom , ! [ A ] : ( t_FunctionalElement ( A ) => ? [ B ] : r_subElements_Function ( B , A ) ) ) .

+fof ( containment_r_data_FunctionalInterface , axiom , ! [ A ] : ( t_FunctionalData ( A ) => ? [ B ] : r_data_FunctionalInterface ( B , A ) ) ) .

+fof ( containment_r_outgoingLinks_FunctionalOutput , axiom , ! [ A ] : ( t_InformationLink ( A ) => ? [ B ] : r_outgoingLinks_FunctionalOutput ( B , A ) ) ) .

+fof ( containment_r_terminator_FunctionalData , axiom , ! [ A ] : ( t_FAMTerminator ( A ) => ? [ B ] : r_terminator_FunctionalData ( B , A ) ) ) .

+

+

 fof ( upperMultiplicity_interface_FunctionalElement , axiom , ! [ V_src , V_trg_1 , V_trg_2 ] : ( ( t_FunctionalElement ( V_src ) & ( t_FunctionalInterface ( V_trg_1 ) & t_FunctionalInterface ( V_trg_2 ) ) ) => ( ( r_interface_FunctionalElement ( V_src , V_trg_1 ) & r_interface_FunctionalElement ( V_src , V_trg_2 ) ) => ~ V_trg_1 != V_trg_2 ) ) ) .

 fof ( lowerMultiplicity_model_FunctionalElement , axiom , ! [ V_src ] : ( t_FunctionalElement ( V_src ) => ? [ V_trg_1 ] : ( t_FunctionalArchitectureModel ( V_trg_1 ) & r_model_FunctionalElement ( V_src , V_trg_1 ) ) ) ) .

 fof ( upperMultiplicity_model_FunctionalElement , axiom , ! [ V_src , V_trg_1 , V_trg_2 ] : ( ( t_FunctionalElement ( V_src ) & ( t_FunctionalArchitectureModel ( V_trg_1 ) & t_FunctionalArchitectureModel ( V_trg_2 ) ) ) => ( ( r_model_FunctionalElement ( V_src , V_trg_1 ) & r_model_FunctionalElement ( V_src , V_trg_2 ) ) => ~ V_trg_1 != V_trg_2 ) ) ) .

diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/output/VampireTest/vampireProblem.tptp b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/output/VampireTest/vampireProblem.tptp
deleted file mode 100644
index 4c368859..00000000
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/output/VampireTest/vampireProblem.tptp
+++ /dev/null
@@ -1,7 +0,0 @@
-% This is an initial Test Comment

-fof ( typeDef_oldRPS , axiom , ! [ A ] : ( t_oldRPS ( A ) <=> ( e_Rock_oldRPS ( A ) | ( e_Paper_oldRPS ( A ) | e_Scissor_oldRPS ( A ) ) ) ) ) .

-fof ( hierarchyHandler , axiom , ! [ A ] : ( object ( A ) <=> t_oldRPS ( A ) ) ) .

-fof ( typeScope , axiom , ! [ A ] : ( object ( A ) <=> ( A = o1 | ( A = o2 | ( A = o3 | A = o4 ) ) ) ) ) .

-fof ( typeUniqueness , axiom , o1 != o2 & ( o1 != o3 & ( o2 != o3 & ( o1 != o4 & ( o2 != o4 & o3 != o4 ) ) ) ) ) .

-fof ( compliance_beats2 , axiom , ! [ Var_0 , Var_1 ] : ( rel_beats2 ( Var_0 , Var_1 ) => ( t_oldRPS ( Var_0 ) & t_oldRPS ( Var_1 ) ) ) ) .

-fof ( assertion1 , axiom , ! [ Var_x ] : ( t_oldRPS ( Var_x ) => ? [ Var_y ] : ( t_oldRPS ( Var_y ) & ( rel_beats2 ( Var_x , Var_y ) & ( Var_x != Var_y & ~ rel_beats2 ( Var_y , Var_x ) ) ) ) ) ) .

diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/src/ca/mcgill/ecse/dslreasoner/vampire/icse/GeneralTest.xtend b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/src/ca/mcgill/ecse/dslreasoner/vampire/icse/GeneralTest.xtend
index 86c9092a..1559ee3f 100644
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/src/ca/mcgill/ecse/dslreasoner/vampire/icse/GeneralTest.xtend
+++ b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/src/ca/mcgill/ecse/dslreasoner/vampire/icse/GeneralTest.xtend
@@ -4,11 +4,11 @@ import ca.mcgill.ecse.dslreasoner.vampire.reasoner.VampireSolver
 import ca.mcgill.ecse.dslreasoner.vampire.reasoner.VampireSolverConfiguration

 import ca.mcgill.ecse.dslreasoner.vampireLanguage.VampireLanguageFactory

 import functionalarchitecture.Function

+import functionalarchitecture.FunctionalInterface

+import functionalarchitecture.FunctionalOutput

 import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic

 import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2LogicConfiguration

-import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace

 import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor

-import hu.bme.mit.inf.dslreasoner.logic.model.builder.DocumentationLevel

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicReasoner

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type

 import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.LogicResult

@@ -30,8 +30,7 @@ import org.eclipse.emf.ecore.EReference
 import org.eclipse.emf.ecore.resource.Resource

 import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl

 import org.eclipse.viatra.query.runtime.api.IQueryGroup

-import org.eclipse.emf.ecore.EClassifier

-import functionalarchitecture.FunctionalOutput

+import hu.bme.mit.inf.dslreasoner.logic.model.builder.DocumentationLevel

 

 class GeneralTest {

         def static String createAndSolveProblem(EcoreMetamodelDescriptor metamodel, List<EObject> partialModel,

@@ -67,7 +66,7 @@ class GeneralTest {
                         list2MapMin.get(Function.simpleName)

                 ), 1)

                 typeMapMin.put(ecore2Logic.TypeofEClass(modelGenerationProblem.trace, 

-                        list2MapMin.get(functionalarchitecture.FunctionalInterface.simpleName)

+                        list2MapMin.get(FunctionalInterface.simpleName)

                 ), 2)

                 typeMapMin.put(ecore2Logic.TypeofEClass(modelGenerationProblem.trace, 

                         list2MapMin.get(FunctionalOutput.simpleName)

@@ -80,7 +79,7 @@ class GeneralTest {
                 ), 5)

                 typeMapMax.put(ecore2Logic.TypeofEClass(

                         modelGenerationProblem.trace,

-                        list2MapMax.get(functionalarchitecture.FunctionalInterface.simpleName)

+                        list2MapMax.get(FunctionalInterface.simpleName)

                 ), 2)

                 typeMapMax.put(ecore2Logic.TypeofEClass(

                         modelGenerationProblem.trace,

@@ -92,7 +91,7 @@ class GeneralTest {
                         // add configuration things, in config file first

                         it.documentationLevel = DocumentationLevel::FULL

                         it.typeScopes.minNewElements = 6

-                        it.typeScopes.maxNewElements = 8

+                        it.typeScopes.maxNewElements = 40

                         it.typeScopes.minNewElementsByType = typeMapMin

                         it.typeScopes.maxNewElementsByType = typeMapMax

                 ]

diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/src/ca/mcgill/ecse/dslreasoner/vampire/icseTests/FAMTest.xtend b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/src/ca/mcgill/ecse/dslreasoner/vampire/icseTests/FAMTest.xtend
deleted file mode 100644
index a8b4dcfb..00000000
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/src/ca/mcgill/ecse/dslreasoner/vampire/icseTests/FAMTest.xtend
+++ /dev/null
@@ -1,103 +0,0 @@
-package ca.mcgill.ecse.dslreasoner.vampire.test

-

-import ca.mcgill.ecse.dslreasoner.vampire.reasoner.VampireSolver

-import ca.mcgill.ecse.dslreasoner.vampire.reasoner.VampireSolverConfiguration

-import functionalarchitecture.FunctionalarchitecturePackage

-import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic

-import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2LogicConfiguration

-import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor

-import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicReasoner

-import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.LogicResult

-import hu.bme.mit.inf.dslreasoner.logic2ecore.Logic2Ecore

-import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2Logic

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.InstanceModel2Logic

-import hu.bme.mit.inf.dslreasoner.workspace.FileSystemWorkspace

-import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace

-import java.util.List

-import org.eclipse.emf.ecore.EAttribute

-import org.eclipse.emf.ecore.EClass

-import org.eclipse.emf.ecore.EEnum

-import org.eclipse.emf.ecore.EEnumLiteral

-import org.eclipse.emf.ecore.EObject

-import org.eclipse.emf.ecore.EReference

-import org.eclipse.emf.ecore.resource.Resource

-import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl

-

-class DslTest {

-        def static void main(String[] args) {

-                val inputs = new FileSystemWorkspace('''initialModels/''', "")

-                val workspace = new FileSystemWorkspace('''outputDslModels/''', "")

-                workspace.initAndClear

-

-                println("Input and output workspaces are created")

-

-                val metamodel = loadMetamodel()

-                val partialModel = loadPartialModel(inputs)

-//              val queries = loadQueries(metamodel)

-

-                println("DSL loaded")

-                

-                val Ecore2Logic ecore2Logic = new Ecore2Logic

-                val Logic2Ecore logic2Ecore = new Logic2Ecore(ecore2Logic)

-                val Viatra2Logic viatra2Logic = new Viatra2Logic(ecore2Logic)

-                val InstanceModel2Logic instanceModel2Logic = new InstanceModel2Logic

-                

-                val modelGenerationProblem = ecore2Logic.transformMetamodel(metamodel,new Ecore2LogicConfiguration())

-//              val modelExtensionProblem = instanceModel2Logic.transform(modelGenerationProblem,partialModel)

-//              val validModelExtensionProblem = viatra2Logic.transformQueries(queries,modelGenerationProblem,new Viatra2LogicConfiguration)

-                

-                val logicProblem = modelGenerationProblem.output

-//              val logicProblem = modelExtensionProblem.output

-//              val logicProblem = validModelExtensionProblem.output

-                

-                

-                println("Problem created")

-                

-                var LogicResult solution

-                var LogicReasoner reasoner

-                //*

-                reasoner = new VampireSolver

-                val vampireConfig = new VampireSolverConfiguration => [

-                        //add configuration things, in config file first

-                        it.writeToFile = false

-                ]

-                

-                solution = reasoner.solve(logicProblem, vampireConfig,  workspace)

-                

-                println("Problem solved")

-                

-                

-        }

-

-        def private static loadMetamodel() {

-                //FAM

-                val pckg = FunctionalarchitecturePackage.eINSTANCE

-                val List<EClass> classes = pckg.EClassifiers.filter(EClass).toList

-                val List<EEnum> enums = pckg.EClassifiers.filter(EEnum).toList

-                val List<EEnumLiteral> literals = enums.map[getELiterals].flatten.toList

-                val List<EReference> references = classes.map[getEReferences].flatten.toList

-                val List<EAttribute> attributes = classes.map[getEAttributes].flatten.toList

-                return new EcoreMetamodelDescriptor(classes,#{},false,enums,literals,references,attributes)

-        }

-

-        def private static loadPartialModel(ReasonerWorkspace inputs) {

-                Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("*", new XMIResourceFactoryImpl());

-                inputs.readModel(EObject,"FunctionalArchitectureModel.xmi").eResource.allContents.toList

-//              inputs.readModel(EObject,"FAM.xmi").eResource.allContents.toList

-        }

-

-//      def private static loadQueries(EcoreMetamodelDescriptor metamodel) {

-//              val i = hu.bme.mit.inf.dslreasoner.domains.transima.fam.patterns.Pattern.instance

-//              val patterns = i.specifications.toList

-//              val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name== "Constraint"]].toSet

-//              val derivedFeatures = new LinkedHashMap

-//              derivedFeatures.put(i.type,metamodel.attributes.filter[it.name == "type"].head)

-//              derivedFeatures.put(i.model,metamodel.references.filter[it.name == "model"].head)

-//              val res = new ViatraQuerySetDescriptor(

-//                      patterns,

-//                      wfPatterns,

-//                      derivedFeatures

-//              )

-//              return res

-//      }

-}

diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.EcoreTest.xtendbin b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.EcoreTest.xtendbin
index 57fe8c2d..99a457d4 100644
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.EcoreTest.xtendbin
+++ b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.EcoreTest.xtendbin
diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.FAMTest.xtendbin b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.FAMTest.xtendbin
index 41284af1..e8451eb9 100644
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.FAMTest.xtendbin
+++ b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.FAMTest.xtendbin
diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.FileSystemTest.xtendbin b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.FileSystemTest.xtendbin
index 36f2c6e1..73c6ab49 100644
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.FileSystemTest.xtendbin
+++ b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.FileSystemTest.xtendbin
diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.GeneralTest.xtendbin b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.GeneralTest.xtendbin
index ce6042ea..b6cabaa6 100644
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.GeneralTest.xtendbin
+++ b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.GeneralTest.xtendbin
diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.YakinduTest.xtendbin b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.YakinduTest.xtendbin
index 270ac043..ae6fb160 100644
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.YakinduTest.xtendbin
+++ b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/.YakinduTest.xtendbin
diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/GeneralTest.java b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/GeneralTest.java
index 13a0e74a..80cec4b9 100644
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/GeneralTest.java
+++ b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icse/GeneralTest.java
@@ -108,7 +108,7 @@ public class GeneralTest {
         final Procedure1<VampireSolverConfiguration> _function_2 = (VampireSolverConfiguration it) -> {

           it.documentationLevel = DocumentationLevel.FULL;

           it.typeScopes.minNewElements = 6;

-          it.typeScopes.maxNewElements = 8;

+          it.typeScopes.maxNewElements = 40;

           it.typeScopes.minNewElementsByType = typeMapMin;

           it.typeScopes.maxNewElementsByType = typeMapMax;

         };

diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icseTest/.gitignore b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icseTest/.gitignore
deleted file mode 100644
index f3e21798..00000000
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/icseTest/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-/.FAMTest.java._trace
diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/.DslTest.xtendbin b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/.DslTest.xtendbin
deleted file mode 100644
index 59f57d8b..00000000
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/.DslTest.xtendbin
+++ /dev/null
diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/.MedicalSystem.xtendbin b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/.MedicalSystem.xtendbin
index 693ee01d..6cae3219 100644
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/.MedicalSystem.xtendbin
+++ b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/.MedicalSystem.xtendbin
diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/.SimpleRun.xtendbin b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/.SimpleRun.xtendbin
index 7e61c0ef..22dda149 100644
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/.SimpleRun.xtendbin
+++ b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/.SimpleRun.xtendbin
diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/.VampireTest.xtendbin b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/.VampireTest.xtendbin
index 8a554a42..857ee2e7 100644
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/.VampireTest.xtendbin
+++ b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/.VampireTest.xtendbin
diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/FAMTest.java b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/FAMTest.java
deleted file mode 100644
index 7b4849e1..00000000
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/test/FAMTest.java
+++ /dev/null
@@ -1,111 +0,0 @@
-package ca.mcgill.ecse.dslreasoner.vampire.test;

-

-import ca.mcgill.ecse.dslreasoner.vampire.reasoner.VampireSolver;

-import ca.mcgill.ecse.dslreasoner.vampire.reasoner.VampireSolverConfiguration;

-import com.google.common.collect.Iterables;

-import functionalarchitecture.FunctionalarchitecturePackage;

-import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic;

-import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2LogicConfiguration;

-import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace;

-import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor;

-import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicReasoner;

-import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput;

-import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem;

-import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.LogicResult;

-import hu.bme.mit.inf.dslreasoner.logic2ecore.Logic2Ecore;

-import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2Logic;

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.InstanceModel2Logic;

-import hu.bme.mit.inf.dslreasoner.workspace.FileSystemWorkspace;

-import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace;

-import java.util.Collections;

-import java.util.List;

-import java.util.Map;

-import org.eclipse.emf.common.util.EList;

-import org.eclipse.emf.ecore.EAttribute;

-import org.eclipse.emf.ecore.EClass;

-import org.eclipse.emf.ecore.EEnum;

-import org.eclipse.emf.ecore.EEnumLiteral;

-import org.eclipse.emf.ecore.EObject;

-import org.eclipse.emf.ecore.EReference;

-import org.eclipse.emf.ecore.resource.Resource;

-import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;

-import org.eclipse.xtend2.lib.StringConcatenation;

-import org.eclipse.xtext.xbase.lib.CollectionLiterals;

-import org.eclipse.xtext.xbase.lib.Exceptions;

-import org.eclipse.xtext.xbase.lib.Functions.Function1;

-import org.eclipse.xtext.xbase.lib.InputOutput;

-import org.eclipse.xtext.xbase.lib.IterableExtensions;

-import org.eclipse.xtext.xbase.lib.IteratorExtensions;

-import org.eclipse.xtext.xbase.lib.ListExtensions;

-import org.eclipse.xtext.xbase.lib.ObjectExtensions;

-import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;

-

-@SuppressWarnings("all")

-public class DslTest {

-  public static void main(final String[] args) {

-    try {

-      StringConcatenation _builder = new StringConcatenation();

-      _builder.append("initialModels/");

-      final FileSystemWorkspace inputs = new FileSystemWorkspace(_builder.toString(), "");

-      StringConcatenation _builder_1 = new StringConcatenation();

-      _builder_1.append("outputDslModels/");

-      final FileSystemWorkspace workspace = new FileSystemWorkspace(_builder_1.toString(), "");

-      workspace.initAndClear();

-      InputOutput.<String>println("Input and output workspaces are created");

-      final EcoreMetamodelDescriptor metamodel = DslTest.loadMetamodel();

-      final List<EObject> partialModel = DslTest.loadPartialModel(inputs);

-      InputOutput.<String>println("DSL loaded");

-      final Ecore2Logic ecore2Logic = new Ecore2Logic();

-      final Logic2Ecore logic2Ecore = new Logic2Ecore(ecore2Logic);

-      final Viatra2Logic viatra2Logic = new Viatra2Logic(ecore2Logic);

-      final InstanceModel2Logic instanceModel2Logic = new InstanceModel2Logic();

-      Ecore2LogicConfiguration _ecore2LogicConfiguration = new Ecore2LogicConfiguration();

-      final TracedOutput<LogicProblem, Ecore2Logic_Trace> modelGenerationProblem = ecore2Logic.transformMetamodel(metamodel, _ecore2LogicConfiguration);

-      final LogicProblem logicProblem = modelGenerationProblem.getOutput();

-      InputOutput.<String>println("Problem created");

-      LogicResult solution = null;

-      LogicReasoner reasoner = null;

-      VampireSolver _vampireSolver = new VampireSolver();

-      reasoner = _vampireSolver;

-      VampireSolverConfiguration _vampireSolverConfiguration = new VampireSolverConfiguration();

-      final Procedure1<VampireSolverConfiguration> _function = (VampireSolverConfiguration it) -> {

-        it.writeToFile = false;

-      };

-      final VampireSolverConfiguration vampireConfig = ObjectExtensions.<VampireSolverConfiguration>operator_doubleArrow(_vampireSolverConfiguration, _function);

-      solution = reasoner.solve(logicProblem, vampireConfig, workspace);

-      InputOutput.<String>println("Problem solved");

-    } catch (Throwable _e) {

-      throw Exceptions.sneakyThrow(_e);

-    }

-  }

-  

-  private static EcoreMetamodelDescriptor loadMetamodel() {

-    final FunctionalarchitecturePackage pckg = FunctionalarchitecturePackage.eINSTANCE;

-    final List<EClass> classes = IterableExtensions.<EClass>toList(Iterables.<EClass>filter(pckg.getEClassifiers(), EClass.class));

-    final List<EEnum> enums = IterableExtensions.<EEnum>toList(Iterables.<EEnum>filter(pckg.getEClassifiers(), EEnum.class));

-    final Function1<EEnum, EList<EEnumLiteral>> _function = (EEnum it) -> {

-      return it.getELiterals();

-    };

-    final List<EEnumLiteral> literals = IterableExtensions.<EEnumLiteral>toList(Iterables.<EEnumLiteral>concat(ListExtensions.<EEnum, EList<EEnumLiteral>>map(enums, _function)));

-    final Function1<EClass, EList<EReference>> _function_1 = (EClass it) -> {

-      return it.getEReferences();

-    };

-    final List<EReference> references = IterableExtensions.<EReference>toList(Iterables.<EReference>concat(ListExtensions.<EClass, EList<EReference>>map(classes, _function_1)));

-    final Function1<EClass, EList<EAttribute>> _function_2 = (EClass it) -> {

-      return it.getEAttributes();

-    };

-    final List<EAttribute> attributes = IterableExtensions.<EAttribute>toList(Iterables.<EAttribute>concat(ListExtensions.<EClass, EList<EAttribute>>map(classes, _function_2)));

-    return new EcoreMetamodelDescriptor(classes, Collections.<EClass>unmodifiableSet(CollectionLiterals.<EClass>newHashSet()), false, enums, literals, references, attributes);

-  }

-  

-  private static List<EObject> loadPartialModel(final ReasonerWorkspace inputs) {

-    List<EObject> _xblockexpression = null;

-    {

-      Map<String, Object> _extensionToFactoryMap = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap();

-      XMIResourceFactoryImpl _xMIResourceFactoryImpl = new XMIResourceFactoryImpl();

-      _extensionToFactoryMap.put("*", _xMIResourceFactoryImpl);

-      _xblockexpression = IteratorExtensions.<EObject>toList(inputs.<EObject>readModel(EObject.class, "FunctionalArchitectureModel.xmi").eResource().getAllContents());

-    }

-    return _xblockexpression;

-  }

-}

diff --git a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/hu/bme/mit/inf/dslreasoner/run/.gitignore b/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/hu/bme/mit/inf/dslreasoner/run/.gitignore
deleted file mode 100644
index 2c8a0d43..00000000
--- a/Tests/ca.mcgill.ecse.dslreasoner.vampire.test/xtend-gen/hu/bme/mit/inf/dslreasoner/run/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-/.SimpleRun.java._trace
-/.MedicalSystem.java._trace
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.application.FAMTest/.classpath b/Tests/hu.bme.mit.inf.dslreasoner.application.FAMTest/.classpath
index 1c96fe2f..2b46fc9b 100644
--- a/Tests/hu.bme.mit.inf.dslreasoner.application.FAMTest/.classpath
+++ b/Tests/hu.bme.mit.inf.dslreasoner.application.FAMTest/.classpath
@@ -4,5 +4,6 @@
         <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>

         <classpathentry kind="src" path="src"/>

         <classpathentry kind="src" path="xtend-gen"/>

+        <classpathentry kind="src" path="src-gen/"/>

         <classpathentry kind="output" path="bin"/>

 </classpath>

diff --git a/Tests/hu.bme.mit.inf.dslreasoner.application.FAMTest/META-INF/MANIFEST.MF b/Tests/hu.bme.mit.inf.dslreasoner.application.FAMTest/META-INF/MANIFEST.MF
index 4e3222f9..d32b92ce 100644
--- a/Tests/hu.bme.mit.inf.dslreasoner.application.FAMTest/META-INF/MANIFEST.MF
+++ b/Tests/hu.bme.mit.inf.dslreasoner.application.FAMTest/META-INF/MANIFEST.MF
@@ -1,15 +1,14 @@
-Manifest-Version: 1.0

-Bundle-ManifestVersion: 2

-Bundle-Name: FAMTest

-Bundle-SymbolicName: hu.bme.mit.inf.dslreasoner.application.FAMTest;singleton:=true

-Bundle-Version: 1.0.0.qualifier

-Automatic-Module-Name: hu.bme.mit.inf.dslreasoner.application.FAMTest

-Bundle-RequiredExecutionEnvironment: JavaSE-1.8

-Require-Bundle: com.google.guava,

- org.eclipse.xtext.xbase.lib,

- org.eclipse.xtend.lib,

- org.eclipse.xtend.lib.macro,

- hu.bme.mit.inf.dslreasoner.application;bundle-version="1.0.0",

- org.junit;bundle-version="4.12.0",

- org.eclipse.collections;bundle-version="7.1.1"

-

+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: FAMTest
+Bundle-SymbolicName: hu.bme.mit.inf.dslreasoner.application.FAMTest;singleton:=true
+Bundle-Version: 1.0.0.qualifier
+Require-Bundle: com.google.guava,
+  org.eclipse.xtext.xbase.lib,
+  org.eclipse.xtend.lib,
+  org.eclipse.xtend.lib.macro,
+  hu.bme.mit.inf.dslreasoner.application;bundle-version="1.0.0",
+  org.junit;bundle-version="4.12.0",
+  org.eclipse.collections;bundle-version="7.1.1"
+Automatic-Module-Name: hu.bme.mit.inf.dslreasoner.application.FAMTest
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.application.FAMTest/build.properties b/Tests/hu.bme.mit.inf.dslreasoner.application.FAMTest/build.properties
index 41eb6ade..aed85a48 100644
--- a/Tests/hu.bme.mit.inf.dslreasoner.application.FAMTest/build.properties
+++ b/Tests/hu.bme.mit.inf.dslreasoner.application.FAMTest/build.properties
@@ -1,4 +1,5 @@
-source.. = src/

-output.. = bin/

 bin.includes = META-INF/,\

                .

+source.. = src/,\

+           src-gen/

+output.. = bin/