45 files changed, 7171 insertions, 71 deletions
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/.classpath b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/.classpath
index a1e0140b..2a126610 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/.classpath
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/.classpath
@@ -5,5 +5,6 @@
        <classpathentry kind="src" path="src"/>
        <classpathentry kind="src" path="xtend-gen"/>
        <classpathentry kind="src" path="queries"/>
+        <classpathentry kind="src" path="src-gen"/>
        <classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/META-INF/MANIFEST.MF b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/META-INF/MANIFEST.MF
index 2eb4f151..63d39592 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/META-INF/MANIFEST.MF
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/META-INF/MANIFEST.MF
@@ -1,17 +1,17 @@
-Manifest-Version: 1.0
+Manifest-Version: 1.0
-Bundle-ManifestVersion: 2
+Bundle-ManifestVersion: 2
-Bundle-Name: Reasoner
+Bundle-Name: Reasoner
-Bundle-SymbolicName: ca.mcgill.ecse.dslreasoner.vampire.reasoner;singleton:=true
+Bundle-SymbolicName: ca.mcgill.ecse.dslreasoner.vampire.reasoner;singleton:=true
-Bundle-Version: 1.0.0.qualifier
+Bundle-Version: 1.0.0.qualifier
-Automatic-Module-Name: ca.mcgill.ecse.dslreasoner.vampire.reasoner
+Export-Package: ca.mcgill.ecse.dslreasoner.vampire.reasoner,
-Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+  ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder,
-Require-Bundle: org.eclipse.xtend.lib,
+  ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries
- hu.bme.mit.inf.dslreasoner.logic.model;bundle-version="1.0.0",
+Require-Bundle: org.eclipse.xtend.lib,
- hu.bme.mit.inf.dslreasoner.ecore2logic;bundle-version="1.0.0",
+  hu.bme.mit.inf.dslreasoner.logic.model;bundle-version="1.0.0",
- ca.mcgill.ecse.dslreasoner.vampire.language;bundle-version="1.0.0",
+  hu.bme.mit.inf.dslreasoner.ecore2logic;bundle-version="1.0.0",
- org.eclipse.viatra.query.runtime;bundle-version="2.1.0",
+  ca.mcgill.ecse.dslreasoner.vampire.language;bundle-version="1.0.0",
- org.eclipse.viatra.query.runtime.base.itc;bundle-version="2.1.0"
+  org.eclipse.viatra.query.runtime;bundle-version="2.1.0",
-Export-Package: ca.mcgill.ecse.dslreasoner.vampire.reasoner,
+  org.eclipse.viatra.query.runtime.base.itc;bundle-version="2.1.0",
- ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder
+  org.apache.log4j;bundle-version="1.2.15"
- 
+Automatic-Module-Name: ca.mcgill.ecse.dslreasoner.vampire.reasoner
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/plugin.xml b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/plugin.xml
new file mode 100644
index 00000000..b2d1db97
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/plugin.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?><plugin>
+  <extension id="ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VampireQueries" point="org.eclipse.viatra.query.runtime.queryspecification">
+    <group group="org.eclipse.viatra.query.runtime.extensibility.SingletonExtensionFactory:ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VampireQueries" id="ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VampireQueries">
+      <query-specification fqn="ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSComment"/>
+      <query-specification fqn="ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSFofFormula"/>
+      <query-specification fqn="ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSAnnotation"/>
+      <query-specification fqn="ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSOr"/>
+      <query-specification fqn="ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSAnd"/>
+      <query-specification fqn="ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSEquivalent"/>
+      <query-specification fqn="ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSFunction"/>
+      <query-specification fqn="ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSExistentialQuantifier"/>
+      <query-specification fqn="ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSUniversalQuantifier"/>
+      <query-specification fqn="ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSUnaryNegation"/>
+      <query-specification fqn="ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSInequality"/>
+      <query-specification fqn="ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSFunctionFof"/>
+    </group>
+  </extension>
+</plugin>
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/queries/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/vampireQueries.vql b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/queries/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/vampireQueries.vql
new file mode 100644
index 00000000..2db380e4
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/queries/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/vampireQueries.vql
@@ -0,0 +1,57 @@
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries
+import "http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage"
+pattern VLSComment(term: VLSComment){
+        VLSComment(term);
+}
+pattern VLSFofFormula(term: VLSFofFormula){
+        VLSFofFormula(term);
+}
+pattern VLSAnnotation(term: VLSAnnotation){
+        VLSAnnotation(term);
+}
+//VLSFormula
+pattern VLSOr(term: VLSOr){
+        VLSOr(term);
+}
+pattern VLSAnd(term: VLSAnd){
+        VLSAnd(term);
+}
+pattern VLSEquivalent(term: VLSEquivalent){
+        VLSEquivalent(term);
+}
+pattern VLSFunction(term: VLSFunction){
+        VLSFunction(term);
+}
+pattern VLSExistentialQuantifier(term: VLSExistentialQuantifier){
+        VLSExistentialQuantifier(term);
+}
+pattern VLSUniversalQuantifier(term: VLSUniversalQuantifier){
+        VLSUniversalQuantifier(term);
+}
+pattern VLSUnaryNegation(term: VLSUnaryNegation){
+        VLSUnaryNegation(term);
+}
+pattern VLSInequality(term: VLSInequality){
+        VLSInequality(term);
+}
+pattern VLSFunctionFof(term: VLSFunctionFof){
+        VLSFunctionFof(term);
+}
+//pattern VLSFofTerm(term: VLSFofTerm){
+//      VLSFofTerm(term);
+//}
+\ No newline at end of file
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/.gitignore b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/.gitignore
new file mode 100644
index 00000000..f30ede2c
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/.gitignore
@@ -0,0 +1,13 @@
+/.VLSComment.java._trace
+/.VLSAnd.java._trace
+/.VLSAnnotation.java._trace
+/.VLSEquivalent.java._trace
+/.VLSExistentialQuantifier.java._trace
+/.VLSFofFormula.java._trace
+/.VLSFunction.java._trace
+/.VLSFunctionFof.java._trace
+/.VLSInequality.java._trace
+/.VLSOr.java._trace
+/.VLSUnaryNegation.java._trace
+/.VLSUniversalQuantifier.java._trace
+/.VampireQueries.java._trace
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSAnd.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSAnd.java
new file mode 100644
index 00000000..68bebb93
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSAnd.java
@@ -0,0 +1,533 @@
+/**
+ * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.reasoner/queries/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/vampireQueries.vql
+ */
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner.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.reasoner.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.reasoner.queries.VLSAnd (visibility: PUBLIC, simpleName: VLSAnd, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSAnd, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.queries.VLSAnd (visibility: PUBLIC, simpleName: VLSAnd, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSAnd, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSAnnotation.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSAnnotation.java
new file mode 100644
index 00000000..c7d691f9
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSAnnotation.java
@@ -0,0 +1,533 @@
+/**
+ * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.reasoner/queries/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/vampireQueries.vql
+ */
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner.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.reasoner.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.reasoner.queries.VLSAnnotation (visibility: PUBLIC, simpleName: VLSAnnotation, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSAnnotation, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.queries.VLSAnnotation (visibility: PUBLIC, simpleName: VLSAnnotation, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSAnnotation, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSComment.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSComment.java
new file mode 100644
index 00000000..534f0b0b
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSComment.java
@@ -0,0 +1,533 @@
+/**
+ * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.reasoner/queries/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/vampireQueries.vql
+ */
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner.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.reasoner.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.reasoner.queries.VLSComment (visibility: PUBLIC, simpleName: VLSComment, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSComment, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.queries.VLSComment (visibility: PUBLIC, simpleName: VLSComment, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSComment, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSEquivalent.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSEquivalent.java
new file mode 100644
index 00000000..e8e1475f
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSEquivalent.java
@@ -0,0 +1,533 @@
+/**
+ * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.reasoner/queries/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/vampireQueries.vql
+ */
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner.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.reasoner.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.reasoner.queries.VLSEquivalent (visibility: PUBLIC, simpleName: VLSEquivalent, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSEquivalent, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.queries.VLSEquivalent (visibility: PUBLIC, simpleName: VLSEquivalent, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSEquivalent, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSExistentialQuantifier.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSExistentialQuantifier.java
new file mode 100644
index 00000000..1d9c93b1
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSExistentialQuantifier.java
@@ -0,0 +1,533 @@
+/**
+ * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.reasoner/queries/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/vampireQueries.vql
+ */
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner.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.reasoner.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.reasoner.queries.VLSExistentialQuantifier (visibility: PUBLIC, simpleName: VLSExistentialQuantifier, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSExistentialQuantifier, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.queries.VLSExistentialQuantifier (visibility: PUBLIC, simpleName: VLSExistentialQuantifier, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSExistentialQuantifier, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSFofFormula.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSFofFormula.java
new file mode 100644
index 00000000..e35ffaa2
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSFofFormula.java
@@ -0,0 +1,533 @@
+/**
+ * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.reasoner/queries/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/vampireQueries.vql
+ */
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner.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.reasoner.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.reasoner.queries.VLSFofFormula (visibility: PUBLIC, simpleName: VLSFofFormula, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSFofFormula, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.queries.VLSFofFormula (visibility: PUBLIC, simpleName: VLSFofFormula, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSFofFormula, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSFunction.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSFunction.java
new file mode 100644
index 00000000..47097005
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSFunction.java
@@ -0,0 +1,533 @@
+/**
+ * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.reasoner/queries/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/vampireQueries.vql
+ */
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner.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.reasoner.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.reasoner.queries.VLSFunction (visibility: PUBLIC, simpleName: VLSFunction, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSFunction, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.queries.VLSFunction (visibility: PUBLIC, simpleName: VLSFunction, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSFunction, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSFunctionFof.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSFunctionFof.java
new file mode 100644
index 00000000..5a88b0b4
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSFunctionFof.java
@@ -0,0 +1,533 @@
+/**
+ * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.reasoner/queries/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/vampireQueries.vql
+ */
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner.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.reasoner.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.reasoner.queries.VLSFunctionFof (visibility: PUBLIC, simpleName: VLSFunctionFof, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSFunctionFof, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.queries.VLSFunctionFof (visibility: PUBLIC, simpleName: VLSFunctionFof, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSFunctionFof, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSInequality.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSInequality.java
new file mode 100644
index 00000000..71c4bc61
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSInequality.java
@@ -0,0 +1,533 @@
+/**
+ * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.reasoner/queries/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/vampireQueries.vql
+ */
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner.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.reasoner.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.reasoner.queries.VLSInequality (visibility: PUBLIC, simpleName: VLSInequality, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSInequality, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.queries.VLSInequality (visibility: PUBLIC, simpleName: VLSInequality, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSInequality, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSOr.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSOr.java
new file mode 100644
index 00000000..fcbbd7cc
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSOr.java
@@ -0,0 +1,535 @@
+/**
+ * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.reasoner/queries/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/vampireQueries.vql
+ */
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.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>
+ *         //VLSFormula
+ *         pattern VLSOr(term: VLSOr){
+ *              VLSOr(term);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matcher> {
+  /**
+   * Pattern-specific match representation of the ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSOr 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.VLSOr fTerm;
+    
+    private static List<String> parameterNames = makeImmutableList("term");
+    
+    private Match(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr 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.VLSOr 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.VLSOr) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setTerm(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fTerm = pTerm;
+    }
+    
+    @Override
+    public String patternName() {
+      return "ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSOr";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return VLSOr.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fTerm};
+    }
+    
+    @Override
+    public VLSOr.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 VLSOr.Match)) {
+          VLSOr.Match other = (VLSOr.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 VLSOr specification() {
+      return VLSOr.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 VLSOr.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 VLSOr.Match newMutableMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr 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 VLSOr.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm) {
+      return new Immutable(pTerm);
+    }
+    
+    private static final class Mutable extends VLSOr.Match {
+      Mutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm) {
+        super(pTerm);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends VLSOr.Match {
+      Immutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm) {
+        super(pTerm);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSOr 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>
+   * //VLSFormula
+   * pattern VLSOr(term: VLSOr){
+   *    VLSOr(term);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see VLSOr
+   * 
+   */
+  public static class Matcher extends BaseMatcher<VLSOr.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 VLSOr.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 VLSOr.Matcher create() {
+      return new Matcher();
+    }
+    
+    private final static int POSITION_TERM = 0;
+    
+    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSOr.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<VLSOr.Match> getAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr 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<VLSOr.Match> streamAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr 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<VLSOr.Match> getOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr 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.VLSOr 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.VLSOr 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.VLSOr pTerm, final Consumer<? super VLSOr.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 VLSOr.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr pTerm) {
+      return VLSOr.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.VLSOr> rawStreamAllValuesOfterm(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_TERM, parameters).map(ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr.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.VLSOr> 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.VLSOr> streamAllValuesOfterm() {
+      return rawStreamAllValuesOfterm(emptyArray());
+    }
+    
+    @Override
+    protected VLSOr.Match tupleToMatch(final Tuple t) {
+      try {
+          return VLSOr.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr) t.get(POSITION_TERM));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected VLSOr.Match arrayToMatch(final Object[] match) {
+      try {
+          return VLSOr.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr) match[POSITION_TERM]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected VLSOr.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return VLSOr.Match.newMutableMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr) 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<VLSOr.Matcher> querySpecification() {
+      return VLSOr.instance();
+    }
+  }
+  
+  private VLSOr() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static VLSOr instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected VLSOr.Matcher instantiate(final ViatraQueryEngine engine) {
+    return VLSOr.Matcher.on(engine);
+  }
+  
+  @Override
+  public VLSOr.Matcher instantiate() {
+    return VLSOr.Matcher.create();
+  }
+  
+  @Override
+  public VLSOr.Match newEmptyMatch() {
+    return VLSOr.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public VLSOr.Match newMatch(final Object... parameters) {
+    return VLSOr.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSOr (visibility: PUBLIC, simpleName: VLSOr, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSOr, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.queries.VLSOr (visibility: PUBLIC, simpleName: VLSOr, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSOr, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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 VLSOr INSTANCE = new VLSOr();
+    
+    /**
+     * 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 VLSOr.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 List<PParameter> parameters = Arrays.asList(parameter_term);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSOr";
+    }
+    
+    @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", "VLSOr")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_term, parameter_term)
+          ));
+          //    VLSOr(term)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSOr")));
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSUnaryNegation.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSUnaryNegation.java
new file mode 100644
index 00000000..5763bf4d
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSUnaryNegation.java
@@ -0,0 +1,533 @@
+/**
+ * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.reasoner/queries/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/vampireQueries.vql
+ */
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner.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.reasoner.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.reasoner.queries.VLSUnaryNegation (visibility: PUBLIC, simpleName: VLSUnaryNegation, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSUnaryNegation, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.queries.VLSUnaryNegation (visibility: PUBLIC, simpleName: VLSUnaryNegation, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSUnaryNegation, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSUniversalQuantifier.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSUniversalQuantifier.java
new file mode 100644
index 00000000..a0ce1383
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VLSUniversalQuantifier.java
@@ -0,0 +1,533 @@
+/**
+ * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.reasoner/queries/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/vampireQueries.vql
+ */
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.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 VLSUniversalQuantifier(term: VLSUniversalQuantifier){
+ *              VLSUniversalQuantifier(term);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecification<VLSUniversalQuantifier.Matcher> {
+  /**
+   * Pattern-specific match representation of the ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSUniversalQuantifier 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.VLSUniversalQuantifier fTerm;
+    
+    private static List<String> parameterNames = makeImmutableList("term");
+    
+    private Match(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier 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.VLSUniversalQuantifier 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.VLSUniversalQuantifier) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setTerm(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fTerm = pTerm;
+    }
+    
+    @Override
+    public String patternName() {
+      return "ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSUniversalQuantifier";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return VLSUniversalQuantifier.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fTerm};
+    }
+    
+    @Override
+    public VLSUniversalQuantifier.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 VLSUniversalQuantifier.Match)) {
+          VLSUniversalQuantifier.Match other = (VLSUniversalQuantifier.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 VLSUniversalQuantifier specification() {
+      return VLSUniversalQuantifier.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 VLSUniversalQuantifier.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 VLSUniversalQuantifier.Match newMutableMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier 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 VLSUniversalQuantifier.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm) {
+      return new Immutable(pTerm);
+    }
+    
+    private static final class Mutable extends VLSUniversalQuantifier.Match {
+      Mutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm) {
+        super(pTerm);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends VLSUniversalQuantifier.Match {
+      Immutable(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm) {
+        super(pTerm);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSUniversalQuantifier 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 VLSUniversalQuantifier(term: VLSUniversalQuantifier){
+   *    VLSUniversalQuantifier(term);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see VLSUniversalQuantifier
+   * 
+   */
+  public static class Matcher extends BaseMatcher<VLSUniversalQuantifier.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 VLSUniversalQuantifier.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 VLSUniversalQuantifier.Matcher create() {
+      return new Matcher();
+    }
+    
+    private final static int POSITION_TERM = 0;
+    
+    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSUniversalQuantifier.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<VLSUniversalQuantifier.Match> getAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier 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<VLSUniversalQuantifier.Match> streamAllMatches(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier 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<VLSUniversalQuantifier.Match> getOneArbitraryMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier 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.VLSUniversalQuantifier 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.VLSUniversalQuantifier 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.VLSUniversalQuantifier pTerm, final Consumer<? super VLSUniversalQuantifier.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 VLSUniversalQuantifier.Match newMatch(final ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier pTerm) {
+      return VLSUniversalQuantifier.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.VLSUniversalQuantifier> rawStreamAllValuesOfterm(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_TERM, parameters).map(ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier.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.VLSUniversalQuantifier> 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.VLSUniversalQuantifier> streamAllValuesOfterm() {
+      return rawStreamAllValuesOfterm(emptyArray());
+    }
+    
+    @Override
+    protected VLSUniversalQuantifier.Match tupleToMatch(final Tuple t) {
+      try {
+          return VLSUniversalQuantifier.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier) t.get(POSITION_TERM));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected VLSUniversalQuantifier.Match arrayToMatch(final Object[] match) {
+      try {
+          return VLSUniversalQuantifier.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier) match[POSITION_TERM]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected VLSUniversalQuantifier.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return VLSUniversalQuantifier.Match.newMutableMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier) 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<VLSUniversalQuantifier.Matcher> querySpecification() {
+      return VLSUniversalQuantifier.instance();
+    }
+  }
+  
+  private VLSUniversalQuantifier() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static VLSUniversalQuantifier instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected VLSUniversalQuantifier.Matcher instantiate(final ViatraQueryEngine engine) {
+    return VLSUniversalQuantifier.Matcher.on(engine);
+  }
+  
+  @Override
+  public VLSUniversalQuantifier.Matcher instantiate() {
+    return VLSUniversalQuantifier.Matcher.create();
+  }
+  
+  @Override
+  public VLSUniversalQuantifier.Match newEmptyMatch() {
+    return VLSUniversalQuantifier.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public VLSUniversalQuantifier.Match newMatch(final Object... parameters) {
+    return VLSUniversalQuantifier.Match.newMatch((ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link JvmGenericType: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSUniversalQuantifier (visibility: PUBLIC, simpleName: VLSUniversalQuantifier, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSUniversalQuantifier, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.queries.VLSUniversalQuantifier (visibility: PUBLIC, simpleName: VLSUniversalQuantifier, identifier: ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSUniversalQuantifier, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ca.mcgill.ecse.dslreasoner.vampire.reasoner.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 VLSUniversalQuantifier INSTANCE = new VLSUniversalQuantifier();
+    
+    /**
+     * 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 VLSUniversalQuantifier.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 List<PParameter> parameters = Arrays.asList(parameter_term);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSUniversalQuantifier";
+    }
+    
+    @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", "VLSUniversalQuantifier")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_term, parameter_term)
+          ));
+          //    VLSUniversalQuantifier(term)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_term), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSUniversalQuantifier")));
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VampireQueries.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VampireQueries.java
new file mode 100644
index 00000000..2366250b
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/VampireQueries.java
@@ -0,0 +1,174 @@
+/**
+ * Generated from platform:/resource/ca.mcgill.ecse.dslreasoner.vampire.reasoner/queries/ca/mcgill/ecse/dslreasoner/vampire/reasoner/queries/vampireQueries.vql
+ */
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries;
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSAnd;
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSAnnotation;
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSComment;
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSEquivalent;
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSExistentialQuantifier;
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSFofFormula;
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSFunction;
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSFunctionFof;
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSInequality;
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSOr;
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.queries.VLSUnaryNegation;
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.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.reasoner.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/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/VampireSolver.xtend b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/VampireSolver.xtend
index 64484b88..cbe53bff 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/VampireSolver.xtend
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/VampireSolver.xtend
@@ -1,18 +1,18 @@
 package ca.mcgill.ecse.dslreasoner.vampire.reasoner
+import ca.mcgill.ecse.dslreasoner.VampireLanguageStandaloneSetup
 import ca.mcgill.ecse.dslreasoner.VampireLanguageStandaloneSetupGenerated
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder.Logic2VampireLanguageMapper
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder.Logic2VampireLanguageMapper_TypeMapper_FilteredTypes
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder.Vampire2LogicMapper
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder.VampireHandler
+import ca.mcgill.ecse.dslreasoner.vampireLanguage.VampireLanguagePackage
 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicReasoner
 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicReasonerException
 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicSolverConfiguration
 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
 import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.ModelResult
-import ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder.Logic2VampireLanguageMapper
-import ca.mcgill.ecse.dslreasoner.vampireLanguage.VampireLanguagePackage
 import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace
-import java.io.PrintWriter
-import ca.mcgill.ecse.dslreasoner.VampireLanguageStandaloneSetup
-import ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder.Logic2VampireLanguageMapper_TypeMapper
-import ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder.Logic2VampireLanguageMapper_TypeMapper_FilteredTypes
 class VampireSolver extends LogicReasoner{
        
@@ -23,14 +23,14 @@ class VampireSolver extends LogicReasoner{
        }
        
         val Logic2VampireLanguageMapper forwardMapper = new Logic2VampireLanguageMapper(new Logic2VampireLanguageMapper_TypeMapper_FilteredTypes)
-//       //not for now
+         val Vampire2LogicMapper backwardMapper = new Vampire2LogicMapper
-//       val VampireHandler handler = new VampireHandler
+         val VampireHandler handler = new VampireHandler
-//       val Vampire2LogicMapper backwardMapper = new Vampire2LogicMapper
         
-         val fileName = "problem.tptp"
         
-         override solve(LogicProblem problem, LogicSolverConfiguration configuration, ReasonerWorkspace workspace) throws LogicReasonerException {
+         val fileName = "vampireProblem.tptp"
-                val vampireConfig = configuration.asConfig
+         
+         override solve(LogicProblem problem, LogicSolverConfiguration config, ReasonerWorkspace workspace) throws LogicReasonerException {
+                val vampireConfig = config.asConfig
                
                // Start: Logic -> Vampire mapping
                val transformationStart = System.currentTimeMillis
@@ -41,36 +41,38 @@ class VampireSolver extends LogicReasoner{
                
                var String fileURI = null;
                var String vampireCode = null;
+                vampireCode = workspace.writeModelToString(vampireProblem,fileName)
                if(vampireConfig.writeToFile) {
                        fileURI = workspace.writeModel(vampireProblem,fileName).toFileString
-                } else {
+                }
-                        vampireCode = workspace.writeModelToString(vampireProblem,fileName)
+                
-                } 
+                //Result as String
+                                
                val transformationTime = System.currentTimeMillis - transformationStart
                // Finish: Logic -> Vampire mapping
                
-                //Creates a file containing the tptp code after transformation
+                                
-                val out = new PrintWriter("output/files/vampireCode.tptp")
+                /*        
-                out.println(vampireCode)
-                out.close()
-                
-                
-                /*      
-                 * not for now -> Start: Solving Alloy problem
-                 *  
                // Start: Solving Alloy problem
                val solverStart = System.currentTimeMillis
-                val result2 = handler.callSolver(alloyProblem,workspace,alloyConfig,fileURI,alloyCode)
+                //Calling Solver (Currently Manually)
-                val logicResult = backwardMapper.transformOutput(problem,configuration.solutionScope.numberOfRequiredSolution,result2,forwardTrace,transformationTime)
+                val result2 = handler.callSolver(vampireProblem,workspace,vampireConfig,vampireCode)
+//              val result2 = null
+                //TODO
+                //Backwards Mapper
+                val logicResult = backwardMapper.transformOutput(problem,config.solutionScope.numberOfRequiredSolution,result2,forwardTrace,transformationTime)
+                
                val solverFinish = System.currentTimeMillis-solverStart
                // Finish: Solving Alloy problem
                                
                if(vampireConfig.writeToFile) workspace.deactivateModel(fileName)
                
                return logicResult
-                */
                
+                /*/
                return null // for now
+                //*/
        }
        
        def asConfig(LogicSolverConfiguration configuration){
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper.xtend b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper.xtend
index 9b316210..cd48a032 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper.xtend
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper.xtend
@@ -55,7 +55,7 @@ class Logic2VampireLanguageMapper {
        }
        public def TracedOutput<VampireModel, Logic2VampireLanguageMapperTrace> transformProblem(LogicProblem problem,
-                VampireSolverConfiguration configuration) {
+                VampireSolverConfiguration config) {
                // create model bases
                // TODO
                val initialComment = createVLSComment => [
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_TypeMapper_FilteredTypes.xtend b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_TypeMapper_FilteredTypes.xtend
index 01c4f5af..41e2137c 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_TypeMapper_FilteredTypes.xtend
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper_TypeMapper_FilteredTypes.xtend
@@ -97,6 +97,7 @@ class Logic2VampireLanguageMapper_TypeMapper_FilteredTypes implements Logic2Vamp
                }
                // 5. create fof function that is an or with all the elements in map
+                // Do this only if there are more than 1 type
                val hierarch = createVLSFofFormula => [
                        it.name = "hierarchyHandler"
                        it.fofRole = "axiom"
@@ -115,6 +116,7 @@ class Logic2VampireLanguageMapper_TypeMapper_FilteredTypes implements Logic2Vamp
                ]
                trace.specification.formulas += hierarch
        }
        def boolean dfsSupertypeCheck(Type type, Type type2) {
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Vampire2LogicMapper.xtend b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Vampire2LogicMapper.xtend
new file mode 100644
index 00000000..5cb0198e
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Vampire2LogicMapper.xtend
@@ -0,0 +1,66 @@
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
+import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.LogicresultFactory
+class Vampire2LogicMapper {
+        val extension LogicresultFactory resultFactory = LogicresultFactory.eINSTANCE
+        
+        public def transformOutput(LogicProblem problem, int requiredNumberOfSolution, VampireSolutionModel vampireSolution, Logic2VampireLanguageMapperTrace trace, long transformationTime) {
+                val models = vampireSolution.aswers.map[it.key].toList
+                
+                if(!monitoredAlloySolution.finishedBeforeTimeout) {
+                        return createInsuficientResourcesResult => [
+                                it.problem = problem
+                                it.representation += models
+                                it.trace = trace
+                                it.statistics = transformStatistics(monitoredAlloySolution,transformationTime)
+                        ]
+                } else {
+                        if(models.last.satisfiable || requiredNumberOfSolution == -1) {
+                                return createModelResult => [
+                                        it.problem = problem
+                                        it.representation += models
+                                        it.trace = trace
+                                        it.statistics = transformStatistics(monitoredAlloySolution,transformationTime)
+                                ]
+                        } else {
+                                return createInconsistencyResult => [
+                                        it.problem = problem
+                                        it.representation += models
+                                        it.trace = trace
+                                        it.statistics = transformStatistics(monitoredAlloySolution,transformationTime)
+                                ]
+                        }
+                }
+        }
+        
+        def transformStatistics(MonitoredAlloySolution solution, long transformationTime) {
+                createStatistics => [
+                        it.transformationTime = transformationTime as int
+                        for(solutionIndex : 0..<solution.aswers.size) {
+                                val solutionTime = solution.aswers.get(solutionIndex).value
+                                 it.entries+= createIntStatisticEntry => [
+                                        it.name = '''Answer«solutionIndex»Time'''
+                                        it.value = solutionTime.intValue
+                                ]
+                        }
+                        it.entries+= createIntStatisticEntry => [
+                                it.name = "Alloy2KodKodTransformationTime"
+                                it.value = solution.kodkodTime as int
+                        ]
+                        it.entries+= createIntStatisticEntry => [
+                                it.name = "Alloy2KodKodTransformationTime"
+                                it.value = solution.kodkodTime as int
+                        ]
+                        it.entries+= createStringStatisticEntry => [
+                                it.name = "warnings"
+                                it.value = '''[«FOR warning : solution.warnings SEPARATOR ","»«warning»«ENDFOR»]'''
+                        ]
+                ]
+        }
+        
+        def sum(Iterable<Long> ints) {
+                ints.reduce[p1, p2|p1+p2]
+        }
+}
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/VampireHandler.xtend b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/VampireHandler.xtend
new file mode 100644
index 00000000..aefa1a7e
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/VampireHandler.xtend
@@ -0,0 +1,214 @@
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.VampireBackendSolver
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.VampireSolverConfiguration
+import ca.mcgill.ecse.dslreasoner.vampireLanguage.VampireModel
+import com.google.common.util.concurrent.SimpleTimeLimiter
+import com.google.common.util.concurrent.UncheckedTimeoutException
+import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicSolverConfiguration
+import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.LinkedList
+import java.util.List
+import java.util.Map
+import java.util.concurrent.Callable
+import java.util.concurrent.TimeUnit
+import org.eclipse.emf.common.command.Command
+import org.eclipse.xtend.lib.annotations.Data
+class VampireSolverException extends Exception{
+        new(String s) { super(s) }
+        new(String s, Exception e) { super(s,e) }
+        new(String s, List<String> errors, Exception e) {
+                super(s + '\n' + errors.join('\n'), e)
+        }
+}
+@Data class VampireSolutionModel{
+//      List<String> warnings
+//      List<String> debugs
+//      long kodkodTime
+//      val List<Pair<A4Solution, Long>> aswers
+//      val boolean finishedBeforeTimeout
+}
+class VampireHandler {
+        //val fileName = "problem.als"
+        
+        public def callSolver(VampireModel problem, ReasonerWorkspace workspace, VampireSolverConfiguration configuration,String vampireCode) {
+                /*
+                //Prepare
+                val warnings = new LinkedList<String>
+                val debugs = new LinkedList<String>
+                val runtime = new ArrayList<Long>
+                val reporter = new A4Reporter() {
+                        override debug(String message) { debugs += message }
+                        override resultSAT (Object command, long solvingTime, Object solution) { runtime += solvingTime }
+                        override resultUNSAT (Object command, long solvingTime, Object solution) { runtime += solvingTime }
+                        override warning(ErrorWarning msg) { warnings += msg.message }
+                }
+                
+                val options = new A4Options() => [
+                        it.symmetry = configuration.symmetry
+                        it.noOverflow = true
+                        it.solver = getSolver(configuration.getSolver, configuration)
+                        if(configuration.getSolver.externalSolver) {
+                                it.solverDirectory = configuration.solverPath
+                        }
+                        //it.inferPartialInstance
+                        //it.tempDirectory = CommonPlugin.resolve(workspace.workspaceURI).toFileString
+                ]
+                
+                // Transform
+                var Command command = null;
+                var CompModule compModule = null
+                
+                // Start: Alloy -> Kodkod
+                val kodkodTransformStart = System.currentTimeMillis();
+                try {
+                        compModule = CompUtil.parseEverything_fromString(reporter,alloyCode)
+                        if(compModule.allCommands.size != 1)
+                                throw new UnsupportedOperationException('''Alloy files with multiple commands are not supported!''')
+                        command = compModule.allCommands.head
+                } catch (Err e){
+                        throw new AlloySolverException(e.message,warnings,e)
+                }
+                val kodkodTransformFinish = System.currentTimeMillis - kodkodTransformStart
+                // Finish: Alloy -> Kodkod
+                
+                val limiter = new SimpleTimeLimiter
+                val callable = new AlloyCallerWithTimeout(warnings,debugs,reporter,options,command,compModule,configuration)
+                var List<Pair<A4Solution, Long>> answers
+                var boolean finished
+                if(configuration.runtimeLimit == LogicSolverConfiguration::Unlimited) {
+                        answers = callable.call
+                        finished = true
+                } else {
+                        try{
+                                answers = limiter.callWithTimeout(callable,configuration.runtimeLimit,TimeUnit.SECONDS,true)
+                                finished = true
+                        } catch (UncheckedTimeoutException e) {
+                                answers = callable.partialAnswers
+                                finished = false
+                        }
+                }
+                new MonitoredAlloySolution(warnings,debugs,kodkodTransformFinish,answers,finished)
+                */
+        }
+        /*
+        val static Map<SolverConfiguration, SatSolver> previousSolverConfigurations = new HashMap
+        def getSolverConfiguration(AlloyBackendSolver backedSolver, String path, String[] options) {
+                val config = new SolverConfiguration(backedSolver,path,options)
+                if(previousSolverConfigurations.containsKey(config)) {
+                        return previousSolverConfigurations.get(config)
+                } else {
+                        val id ='''DSLReasoner_Alloy_«previousSolverConfigurations.size»_«backedSolver»'''
+                        val newSolver = A4Options.SatSolver.make(id,id,path,options)
+                        previousSolverConfigurations.put(config,newSolver)
+                        return newSolver
+                }
+        }
+        
+        def getSolver(AlloyBackendSolver backedSolver, AlloySolverConfiguration configuration) {
+                switch(backedSolver){
+                        case BerkMinPIPE: return A4Options.SatSolver.BerkMinPIPE
+                        case SpearPIPE: return A4Options.SatSolver.SpearPIPE
+                        case MiniSatJNI: return A4Options.SatSolver.MiniSatJNI
+                        case MiniSatProverJNI: return A4Options.SatSolver.MiniSatProverJNI
+                        case LingelingJNI: return A4Options.SatSolver.LingelingJNI
+                        case PLingelingJNI: return getSolverConfiguration(backedSolver,configuration.solverPath,null)
+                        case GlucoseJNI: return A4Options.SatSolver.GlucoseJNI
+                        case CryptoMiniSatJNI: return A4Options.SatSolver.CryptoMiniSatJNI
+                        case SAT4J: return A4Options.SatSolver.SAT4J
+                        case CNF: return A4Options.SatSolver.CNF
+                        case KodKod: return A4Options.SatSolver.KK
+                }
+        }
+        
+        def isExternalSolver(AlloyBackendSolver backedSolver) {
+                return !(backedSolver == AlloyBackendSolver.SAT4J)
+        }
+*/
+}
+/*
+class VampireCallerWithTimeout implements Callable<List<Pair<A4Solution,Long>>>{
+        
+        val List<String> warnings
+        val List<String> debugs
+        val A4Reporter reporter
+        val A4Options options
+        
+        val Command command
+        val CompModule compModule
+        val AlloySolverConfiguration configuration
+        
+        val List<Pair<A4Solution,Long>> answers = new LinkedList()
+        
+        new(List<String> warnings,
+                List<String> debugs,
+                A4Reporter reporter,
+                A4Options options,
+                Command command,
+                CompModule compModule,
+                AlloySolverConfiguration configuration)
+        {
+                this.warnings = warnings
+                this.debugs = debugs
+                this.reporter = reporter
+                this.options = options
+                this.command = command
+                this.compModule = compModule
+                this.configuration = configuration
+        }
+        
+        override call() throws Exception {
+                val startTime = System.currentTimeMillis
+                
+                // Start: Execute
+                var A4Solution lastAnswer = null
+                try {
+                        if(!configuration.progressMonitor.isCancelled) {
+                                do{
+                                        if(lastAnswer == null) {
+                                                lastAnswer = TranslateAlloyToKodkod.execute_command(reporter,compModule.allSigs,command,options)
+                                        } else {
+                                                lastAnswer = lastAnswer.next
+                                        }
+                                        configuration.progressMonitor.workedBackwardTransformation(configuration.solutionScope.numberOfRequiredSolution)
+                                        
+                                        val runtime = System.currentTimeMillis -startTime
+                                        synchronized(this) {
+                                                answers += (lastAnswer->runtime)
+                                        }
+                                } while(lastAnswer.satisfiable != false && !hasEnoughSolution(answers) && !configuration.progressMonitor.isCancelled)
+                                
+                        }
+                }catch(Exception e) {
+                        warnings +=e.message
+                }
+                // Finish: execute
+                return answers
+        }
+        
+        def hasEnoughSolution(List<?> answers) {
+                if(configuration.solutionScope.numberOfRequiredSolution < 0) return false
+                else return answers.size() == configuration.solutionScope.numberOfRequiredSolution
+        }
+        
+        public def getPartialAnswers() {
+                return answers
+        }
+}
+/*
+@Data class SolverConfiguration {
+        VampireBackendSolver backendSolver
+        String path
+        String[] options
+}
+*/
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 b9a5c4e7..462a940b 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
Binary files differ
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 a9926cdc..d8b8ca61 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
Binary files differ
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/.gitignore b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/.gitignore
index 9efd2ac5..70f60102 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/.gitignore
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/.gitignore
@@ -2,3 +2,9 @@
 /.TypeMappingTechnique.java._trace
 /.VampireBackendSolver.java._trace
 /.VampireSolverConfiguration.java._trace
+/.VampireAnalyzerConfiguration.xtendbin
+/.VampireSolver.xtendbin
+/TypeMappingTechnique.java
+/VampireBackendSolver.java
+/VampireSolver.java
+/VampireSolverConfiguration.java
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/VampireSolver.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/VampireSolver.java
index 81cae109..e1a1ca6e 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/VampireSolver.java
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/VampireSolver.java
@@ -6,6 +6,8 @@ import ca.mcgill.ecse.dslreasoner.vampire.reasoner.VampireSolverConfiguration;
 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_TypeMapper_FilteredTypes;
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder.Vampire2LogicMapper;
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder.VampireHandler;
 import ca.mcgill.ecse.dslreasoner.vampireLanguage.VampireLanguagePackage;
 import ca.mcgill.ecse.dslreasoner.vampireLanguage.VampireModel;
 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicModelInterpretation;
@@ -17,10 +19,8 @@ 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.logic.model.logicresult.ModelResult;
 import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace;
-import java.io.PrintWriter;
 import java.util.List;
 import org.eclipse.xtend2.lib.StringConcatenation;
-import org.eclipse.xtext.xbase.lib.Exceptions;
 @SuppressWarnings("all")
 public class VampireSolver extends LogicReasoner {
@@ -32,32 +32,28 @@ public class VampireSolver extends LogicReasoner {
  
  private final Logic2VampireLanguageMapper forwardMapper = new Logic2VampireLanguageMapper(new Logic2VampireLanguageMapper_TypeMapper_FilteredTypes());
  
-  private final String fileName = "problem.tptp";
+  private final Vampire2LogicMapper backwardMapper = new Vampire2LogicMapper();
+  
+  private final VampireHandler handler = new VampireHandler();
+  
+  private final String fileName = "vampireProblem.tptp";
  
  @Override
-  public LogicResult solve(final LogicProblem problem, final LogicSolverConfiguration configuration, final ReasonerWorkspace workspace) throws LogicReasonerException {
+  public LogicResult solve(final LogicProblem problem, final LogicSolverConfiguration config, final ReasonerWorkspace workspace) throws LogicReasonerException {
-    try {
+    final VampireSolverConfiguration vampireConfig = this.asConfig(config);
-      final VampireSolverConfiguration vampireConfig = this.asConfig(configuration);
+    final long transformationStart = System.currentTimeMillis();
-      final long transformationStart = System.currentTimeMillis();
+    final TracedOutput<VampireModel, Logic2VampireLanguageMapperTrace> result = this.forwardMapper.transformProblem(problem, vampireConfig);
-      final TracedOutput<VampireModel, Logic2VampireLanguageMapperTrace> result = this.forwardMapper.transformProblem(problem, vampireConfig);
+    final VampireModel vampireProblem = result.getOutput();
-      final VampireModel vampireProblem = result.getOutput();
+    final Logic2VampireLanguageMapperTrace forwardTrace = result.getTrace();
-      final Logic2VampireLanguageMapperTrace forwardTrace = result.getTrace();
+    String fileURI = null;
-      String fileURI = null;
+    String vampireCode = null;
-      String vampireCode = null;
+    vampireCode = workspace.writeModelToString(vampireProblem, this.fileName);
-      if (vampireConfig.writeToFile) {
+    if (vampireConfig.writeToFile) {
-        fileURI = workspace.writeModel(vampireProblem, this.fileName).toFileString();
+      fileURI = workspace.writeModel(vampireProblem, this.fileName).toFileString();
-      } else {
-        vampireCode = workspace.writeModelToString(vampireProblem, this.fileName);
-      }
-      long _currentTimeMillis = System.currentTimeMillis();
-      final long transformationTime = (_currentTimeMillis - transformationStart);
-      final PrintWriter out = new PrintWriter("output/files/vampireCode.tptp");
-      out.println(vampireCode);
-      out.close();
-      return null;
-    } catch (Throwable _e) {
-      throw Exceptions.sneakyThrow(_e);
    }
+    long _currentTimeMillis = System.currentTimeMillis();
+    final long transformationTime = (_currentTimeMillis - transformationStart);
+    return null;
  }
  
  public VampireSolverConfiguration asConfig(final LogicSolverConfiguration configuration) {
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 e4083dc1..d248b361 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
Binary files differ
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 bbda5634..d747e8ab 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
Binary files differ
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 6c3f3a91..4dc095c0 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
Binary files differ
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 9da7459d..9a948c6f 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
Binary files differ
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 89400bab..4ef4809b 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
Binary files differ
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 6113caa7..0f4acafe 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
Binary files differ
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
index d5504038..7d6865bb 100644
--- 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
Binary files differ
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
index 3586a020..6db26bf7 100644
--- 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
Binary files differ
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
new file mode 100644
index 00000000..8c96afa7
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.Vampire2LogicMapper.xtendbin
Binary files differ
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
new file mode 100644
index 00000000..2427721d
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.VampireHandler.xtendbin
Binary files differ
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 16b681bb..d2c93ab4 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
Binary files differ
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 c2f817a5..28c5d0f7 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
Binary files differ
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.gitignore b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.gitignore
index d27ff186..3d29fb07 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.gitignore
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/.gitignore
@@ -9,3 +9,31 @@
 /.Logic2VampireLanguageMapper_TypeMapper_FilteredTypes.java._trace
 /.Logic2VampireLanguageMapper_Support.java._trace
 /.Logic2VampireLanguageMapper_RelationMapper.java._trace
+/.Logic2VampireLanguageMapper.xtendbin
+/.Logic2VampireLanguageMapperTrace.xtendbin
+/.Logic2VampireLanguageMapper_ConstantMapper.xtendbin
+/.Logic2VampireLanguageMapper_RelationMapper.xtendbin
+/.Logic2VampireLanguageMapper_Support.xtendbin
+/.Logic2VampireLanguageMapper_TypeMapper.xtendbin
+/.Logic2VampireLanguageMapper_TypeMapperTrace_FilteredTypes.xtendbin
+/.Logic2VampireLanguageMapper_TypeMapper_FilteredTypes.xtendbin
+/.VampireModelInterpretation_TypeInterpretation.xtendbin
+/.VampireModelInterpretation_TypeInterpretation_FilteredTypes.xtendbin
+/Logic2VampireLanguageMapper.java
+/Logic2VampireLanguageMapperTrace.java
+/Logic2VampireLanguageMapper_ConstantMapper.java
+/Logic2VampireLanguageMapper_RelationMapper.java
+/Logic2VampireLanguageMapper_Support.java
+/Logic2VampireLanguageMapper_TypeMapper.java
+/Logic2VampireLanguageMapper_TypeMapperTrace.java
+/Logic2VampireLanguageMapper_TypeMapperTrace_FilteredTypes.java
+/Logic2VampireLanguageMapper_TypeMapper_FilteredTypes.java
+/VampireModelInterpretation_TypeInterpretation.java
+/VampireModelInterpretation_TypeInterpretation_FilteredTypes.java
+/.Vampire2LogicMapper.java._trace
+/.VampireHandler.java._trace
+/.MonitoredVampireSolution.java._trace
+/.SolverConfiguration.java._trace
+/.VampireSolverException.java._trace
+/.VampireSolutionModel.java._trace
+/.VampireCallerWithTimeout.java._trace
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper.java
index b2dd06ef..a1d80e58 100644
--- a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper.java
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Logic2VampireLanguageMapper.java
@@ -90,7 +90,7 @@ public class Logic2VampireLanguageMapper {
    this.typeMapper = typeMapper;
  }
  
-  public TracedOutput<VampireModel, Logic2VampireLanguageMapperTrace> transformProblem(final LogicProblem problem, final VampireSolverConfiguration configuration) {
+  public TracedOutput<VampireModel, Logic2VampireLanguageMapperTrace> transformProblem(final LogicProblem problem, final VampireSolverConfiguration config) {
    VLSComment _createVLSComment = this.factory.createVLSComment();
    final Procedure1<VLSComment> _function = (VLSComment it) -> {
      it.setComment("This is an initial Test Comment");
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Vampire2LogicMapper.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Vampire2LogicMapper.java
new file mode 100644
index 00000000..f4380894
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/Vampire2LogicMapper.java
@@ -0,0 +1,59 @@
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder;
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder.Logic2VampireLanguageMapperTrace;
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder.VampireSolutionModel;
+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.logic.model.logicresult.LogicresultFactory;
+import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.Statistics;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function2;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+@SuppressWarnings("all")
+public class Vampire2LogicMapper {
+  @Extension
+  private final LogicresultFactory resultFactory = LogicresultFactory.eINSTANCE;
+  
+  public LogicResult transformOutput(final LogicProblem problem, final int requiredNumberOfSolution, final VampireSolutionModel vampireSolution, final Logic2VampireLanguageMapperTrace trace, final long transformationTime) {
+    throw new Error("Unresolved compilation problems:"
+      + "\nThe method or field aswers is undefined for the type VampireSolutionModel"
+      + "\nThe method or field key is undefined for the type Object"
+      + "\nThe method or field monitoredAlloySolution is undefined"
+      + "\nThe method or field monitoredAlloySolution is undefined"
+      + "\nThe method or field monitoredAlloySolution is undefined"
+      + "\nThe method or field monitoredAlloySolution is undefined"
+      + "\nThe method transformStatistics(MonitoredAlloySolution, long) from the type Vampire2LogicMapper refers to the missing type MonitoredAlloySolution"
+      + "\nThe method transformStatistics(MonitoredAlloySolution, long) from the type Vampire2LogicMapper refers to the missing type MonitoredAlloySolution"
+      + "\nThe method transformStatistics(MonitoredAlloySolution, long) from the type Vampire2LogicMapper refers to the missing type MonitoredAlloySolution"
+      + "\nmap cannot be resolved"
+      + "\ntoList cannot be resolved"
+      + "\nfinishedBeforeTimeout cannot be resolved"
+      + "\n! cannot be resolved"
+      + "\nlast cannot be resolved"
+      + "\nsatisfiable cannot be resolved"
+      + "\n|| cannot be resolved");
+  }
+  
+  public Statistics transformStatistics(final /* MonitoredAlloySolution */Object solution, final long transformationTime) {
+    throw new Error("Unresolved compilation problems:"
+      + "\nCannot cast from Object to int"
+      + "\nCannot cast from Object to int"
+      + "\naswers cannot be resolved"
+      + "\nsize cannot be resolved"
+      + "\naswers cannot be resolved"
+      + "\nget cannot be resolved"
+      + "\nvalue cannot be resolved"
+      + "\nintValue cannot be resolved"
+      + "\nkodkodTime cannot be resolved"
+      + "\nkodkodTime cannot be resolved"
+      + "\nwarnings cannot be resolved");
+  }
+  
+  public Long sum(final Iterable<Long> ints) {
+    final Function2<Long, Long, Long> _function = (Long p1, Long p2) -> {
+      return Long.valueOf(((p1).longValue() + (p2).longValue()));
+    };
+    return IterableExtensions.<Long>reduce(ints, _function);
+  }
+}
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/VampireHandler.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/VampireHandler.java
new file mode 100644
index 00000000..1cac2633
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/VampireHandler.java
@@ -0,0 +1,12 @@
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder;
+import ca.mcgill.ecse.dslreasoner.vampire.reasoner.VampireSolverConfiguration;
+import ca.mcgill.ecse.dslreasoner.vampireLanguage.VampireModel;
+import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace;
+@SuppressWarnings("all")
+public class VampireHandler {
+  public Object callSolver(final VampireModel problem, final ReasonerWorkspace workspace, final VampireSolverConfiguration configuration, final String vampireCode) {
+    return null;
+  }
+}
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/VampireSolutionModel.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/VampireSolutionModel.java
new file mode 100644
index 00000000..c665b9a6
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/VampireSolutionModel.java
@@ -0,0 +1,35 @@
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder;
+import org.eclipse.xtend.lib.annotations.Data;
+import org.eclipse.xtext.xbase.lib.Pure;
+import org.eclipse.xtext.xbase.lib.util.ToStringBuilder;
+@Data
+@SuppressWarnings("all")
+public class VampireSolutionModel {
+  @Override
+  @Pure
+  public int hashCode() {
+    int result = 1;
+    return result;
+  }
+  
+  @Override
+  @Pure
+  public boolean equals(final Object obj) {
+    if (this == obj)
+      return true;
+    if (obj == null)
+      return false;
+    if (getClass() != obj.getClass())
+      return false;
+    return true;
+  }
+  
+  @Override
+  @Pure
+  public String toString() {
+    ToStringBuilder b = new ToStringBuilder(this);
+    return b.toString();
+  }
+}
diff --git a/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/VampireSolverException.java b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/VampireSolverException.java
new file mode 100644
index 00000000..b96df82a
--- /dev/null
+++ b/Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/xtend-gen/ca/mcgill/ecse/dslreasoner/vampire/reasoner/builder/VampireSolverException.java
@@ -0,0 +1,19 @@
+package ca.mcgill.ecse.dslreasoner.vampire.reasoner.builder;
+import java.util.List;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+@SuppressWarnings("all")
+public class VampireSolverException extends Exception {
+  public VampireSolverException(final String s) {
+    super(s);
+  }
+  
+  public VampireSolverException(final String s, final Exception e) {
+    super(s, e);
+  }
+  
+  public VampireSolverException(final String s, final List<String> errors, final Exception e) {
+    super(((s + "\n") + IterableExtensions.join(errors, "\n")), e);
+  }
+}