From 8ecc73c4f8cd83d0ae807a55223f38a9b00505a9 Mon Sep 17 00:00:00 2001
From: ArenBabikian <aren.babikian@mail.mcgill.ca>
Date: Sat, 6 Jun 2020 19:19:18 -0400
Subject: VAMPIRE: Rebase on Master

---
 .../vampire/reasoner/queries/VLSAnd.java           | 28 +++++++++++++++-------
 .../vampire/reasoner/queries/VLSAnnotation.java    | 28 +++++++++++++++-------
 .../vampire/reasoner/queries/VLSComment.java       | 28 +++++++++++++++-------
 .../vampire/reasoner/queries/VLSEquivalent.java    | 28 +++++++++++++++-------
 .../reasoner/queries/VLSExistentialQuantifier.java | 28 +++++++++++++++-------
 .../vampire/reasoner/queries/VLSFofFormula.java    | 28 +++++++++++++++-------
 .../vampire/reasoner/queries/VLSFunction.java      | 28 +++++++++++++++-------
 .../vampire/reasoner/queries/VLSFunctionFof.java   | 28 +++++++++++++++-------
 .../vampire/reasoner/queries/VLSInequality.java    | 28 +++++++++++++++-------
 .../vampire/reasoner/queries/VLSOr.java            | 28 +++++++++++++++-------
 .../vampire/reasoner/queries/VLSUnaryNegation.java | 28 +++++++++++++++-------
 .../reasoner/queries/VLSUniversalQuantifier.java   | 28 +++++++++++++++-------
 12 files changed, 228 insertions(+), 108 deletions(-)

(limited to 'Solvers/Vampire-Solver/ca.mcgill.ecse.dslreasoner.vampire.reasoner/src-gen/ca/mcgill')

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
index 68bebb93..553d455c 100644
--- 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
@@ -74,8 +74,18 @@ public final class VLSAnd extends BaseGeneratedEMFQuerySpecification<VLSAnd.Matc
     
     @Override
     public Object get(final String parameterName) {
-      if ("term".equals(parameterName)) return this.fTerm;
-      return null;
+      switch(parameterName) {
+          case "term": return this.fTerm;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fTerm;
+          default: return null;
+      }
     }
     
     public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnd getTerm() {
@@ -260,9 +270,9 @@ public final class VLSAnd extends BaseGeneratedEMFQuerySpecification<VLSAnd.Matc
       return new Matcher();
     }
     
-    private final static int POSITION_TERM = 0;
+    private static final int POSITION_TERM = 0;
     
-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSAnd.Matcher.class);
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSAnd.Matcher.class);
     
     /**
      * Initializes the pattern matcher within an existing VIATRA Query engine.
@@ -461,15 +471,15 @@ public final class VLSAnd extends BaseGeneratedEMFQuerySpecification<VLSAnd.Matc
   }
   
   /**
-   * 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 
+   * Inner class allowing the singleton instance of {@link VLSAnd} 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()}.
+   *     but rather at the first call to {@link VLSAnd#instance()}.
    * 
    * <p> This workaround is required e.g. to support recursion.
    * 
    */
   private static class LazyHolder {
-    private final static VLSAnd INSTANCE = new VLSAnd();
+    private static final VLSAnd INSTANCE = new VLSAnd();
     
     /**
      * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.
@@ -478,7 +488,7 @@ public final class VLSAnd extends BaseGeneratedEMFQuerySpecification<VLSAnd.Matc
      * <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();
+    private static final Object STATIC_INITIALIZER = ensureInitialized();
     
     public static Object ensureInitialized() {
       INSTANCE.ensureInitializedInternal();
@@ -487,7 +497,7 @@ public final class VLSAnd extends BaseGeneratedEMFQuerySpecification<VLSAnd.Matc
   }
   
   private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
-    private final static VLSAnd.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    private static final 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);
     
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
index c7d691f9..3096531d 100644
--- 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
@@ -74,8 +74,18 @@ public final class VLSAnnotation extends BaseGeneratedEMFQuerySpecification<VLSA
     
     @Override
     public Object get(final String parameterName) {
-      if ("term".equals(parameterName)) return this.fTerm;
-      return null;
+      switch(parameterName) {
+          case "term": return this.fTerm;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fTerm;
+          default: return null;
+      }
     }
     
     public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSAnnotation getTerm() {
@@ -260,9 +270,9 @@ public final class VLSAnnotation extends BaseGeneratedEMFQuerySpecification<VLSA
       return new Matcher();
     }
     
-    private final static int POSITION_TERM = 0;
+    private static final int POSITION_TERM = 0;
     
-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSAnnotation.Matcher.class);
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSAnnotation.Matcher.class);
     
     /**
      * Initializes the pattern matcher within an existing VIATRA Query engine.
@@ -461,15 +471,15 @@ public final class VLSAnnotation extends BaseGeneratedEMFQuerySpecification<VLSA
   }
   
   /**
-   * 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 
+   * Inner class allowing the singleton instance of {@link VLSAnnotation} 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()}.
+   *     but rather at the first call to {@link VLSAnnotation#instance()}.
    * 
    * <p> This workaround is required e.g. to support recursion.
    * 
    */
   private static class LazyHolder {
-    private final static VLSAnnotation INSTANCE = new VLSAnnotation();
+    private static final VLSAnnotation INSTANCE = new VLSAnnotation();
     
     /**
      * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.
@@ -478,7 +488,7 @@ public final class VLSAnnotation extends BaseGeneratedEMFQuerySpecification<VLSA
      * <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();
+    private static final Object STATIC_INITIALIZER = ensureInitialized();
     
     public static Object ensureInitialized() {
       INSTANCE.ensureInitializedInternal();
@@ -487,7 +497,7 @@ public final class VLSAnnotation extends BaseGeneratedEMFQuerySpecification<VLSA
   }
   
   private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
-    private final static VLSAnnotation.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    private static final 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);
     
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
index 534f0b0b..f2b34120 100644
--- 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
@@ -74,8 +74,18 @@ public final class VLSComment extends BaseGeneratedEMFQuerySpecification<VLSComm
     
     @Override
     public Object get(final String parameterName) {
-      if ("term".equals(parameterName)) return this.fTerm;
-      return null;
+      switch(parameterName) {
+          case "term": return this.fTerm;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fTerm;
+          default: return null;
+      }
     }
     
     public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSComment getTerm() {
@@ -260,9 +270,9 @@ public final class VLSComment extends BaseGeneratedEMFQuerySpecification<VLSComm
       return new Matcher();
     }
     
-    private final static int POSITION_TERM = 0;
+    private static final int POSITION_TERM = 0;
     
-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSComment.Matcher.class);
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSComment.Matcher.class);
     
     /**
      * Initializes the pattern matcher within an existing VIATRA Query engine.
@@ -461,15 +471,15 @@ public final class VLSComment extends BaseGeneratedEMFQuerySpecification<VLSComm
   }
   
   /**
-   * 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 
+   * Inner class allowing the singleton instance of {@link VLSComment} 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()}.
+   *     but rather at the first call to {@link VLSComment#instance()}.
    * 
    * <p> This workaround is required e.g. to support recursion.
    * 
    */
   private static class LazyHolder {
-    private final static VLSComment INSTANCE = new VLSComment();
+    private static final VLSComment INSTANCE = new VLSComment();
     
     /**
      * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.
@@ -478,7 +488,7 @@ public final class VLSComment extends BaseGeneratedEMFQuerySpecification<VLSComm
      * <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();
+    private static final Object STATIC_INITIALIZER = ensureInitialized();
     
     public static Object ensureInitialized() {
       INSTANCE.ensureInitializedInternal();
@@ -487,7 +497,7 @@ public final class VLSComment extends BaseGeneratedEMFQuerySpecification<VLSComm
   }
   
   private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
-    private final static VLSComment.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    private static final 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);
     
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
index e8e1475f..3ed03d34 100644
--- 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
@@ -74,8 +74,18 @@ public final class VLSEquivalent extends BaseGeneratedEMFQuerySpecification<VLSE
     
     @Override
     public Object get(final String parameterName) {
-      if ("term".equals(parameterName)) return this.fTerm;
-      return null;
+      switch(parameterName) {
+          case "term": return this.fTerm;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fTerm;
+          default: return null;
+      }
     }
     
     public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSEquivalent getTerm() {
@@ -260,9 +270,9 @@ public final class VLSEquivalent extends BaseGeneratedEMFQuerySpecification<VLSE
       return new Matcher();
     }
     
-    private final static int POSITION_TERM = 0;
+    private static final int POSITION_TERM = 0;
     
-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSEquivalent.Matcher.class);
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSEquivalent.Matcher.class);
     
     /**
      * Initializes the pattern matcher within an existing VIATRA Query engine.
@@ -461,15 +471,15 @@ public final class VLSEquivalent extends BaseGeneratedEMFQuerySpecification<VLSE
   }
   
   /**
-   * 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 
+   * Inner class allowing the singleton instance of {@link VLSEquivalent} 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()}.
+   *     but rather at the first call to {@link VLSEquivalent#instance()}.
    * 
    * <p> This workaround is required e.g. to support recursion.
    * 
    */
   private static class LazyHolder {
-    private final static VLSEquivalent INSTANCE = new VLSEquivalent();
+    private static final VLSEquivalent INSTANCE = new VLSEquivalent();
     
     /**
      * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.
@@ -478,7 +488,7 @@ public final class VLSEquivalent extends BaseGeneratedEMFQuerySpecification<VLSE
      * <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();
+    private static final Object STATIC_INITIALIZER = ensureInitialized();
     
     public static Object ensureInitialized() {
       INSTANCE.ensureInitializedInternal();
@@ -487,7 +497,7 @@ public final class VLSEquivalent extends BaseGeneratedEMFQuerySpecification<VLSE
   }
   
   private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
-    private final static VLSEquivalent.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    private static final 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);
     
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
index 1d9c93b1..643c2b60 100644
--- 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
@@ -74,8 +74,18 @@ public final class VLSExistentialQuantifier extends BaseGeneratedEMFQuerySpecifi
     
     @Override
     public Object get(final String parameterName) {
-      if ("term".equals(parameterName)) return this.fTerm;
-      return null;
+      switch(parameterName) {
+          case "term": return this.fTerm;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fTerm;
+          default: return null;
+      }
     }
     
     public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSExistentialQuantifier getTerm() {
@@ -260,9 +270,9 @@ public final class VLSExistentialQuantifier extends BaseGeneratedEMFQuerySpecifi
       return new Matcher();
     }
     
-    private final static int POSITION_TERM = 0;
+    private static final int POSITION_TERM = 0;
     
-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSExistentialQuantifier.Matcher.class);
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSExistentialQuantifier.Matcher.class);
     
     /**
      * Initializes the pattern matcher within an existing VIATRA Query engine.
@@ -461,15 +471,15 @@ public final class VLSExistentialQuantifier extends BaseGeneratedEMFQuerySpecifi
   }
   
   /**
-   * 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 
+   * Inner class allowing the singleton instance of {@link VLSExistentialQuantifier} 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()}.
+   *     but rather at the first call to {@link VLSExistentialQuantifier#instance()}.
    * 
    * <p> This workaround is required e.g. to support recursion.
    * 
    */
   private static class LazyHolder {
-    private final static VLSExistentialQuantifier INSTANCE = new VLSExistentialQuantifier();
+    private static final VLSExistentialQuantifier INSTANCE = new VLSExistentialQuantifier();
     
     /**
      * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.
@@ -478,7 +488,7 @@ public final class VLSExistentialQuantifier extends BaseGeneratedEMFQuerySpecifi
      * <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();
+    private static final Object STATIC_INITIALIZER = ensureInitialized();
     
     public static Object ensureInitialized() {
       INSTANCE.ensureInitializedInternal();
@@ -487,7 +497,7 @@ public final class VLSExistentialQuantifier extends BaseGeneratedEMFQuerySpecifi
   }
   
   private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
-    private final static VLSExistentialQuantifier.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    private static final 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);
     
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
index e35ffaa2..666795b5 100644
--- 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
@@ -74,8 +74,18 @@ public final class VLSFofFormula extends BaseGeneratedEMFQuerySpecification<VLSF
     
     @Override
     public Object get(final String parameterName) {
-      if ("term".equals(parameterName)) return this.fTerm;
-      return null;
+      switch(parameterName) {
+          case "term": return this.fTerm;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fTerm;
+          default: return null;
+      }
     }
     
     public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFofFormula getTerm() {
@@ -260,9 +270,9 @@ public final class VLSFofFormula extends BaseGeneratedEMFQuerySpecification<VLSF
       return new Matcher();
     }
     
-    private final static int POSITION_TERM = 0;
+    private static final int POSITION_TERM = 0;
     
-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSFofFormula.Matcher.class);
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSFofFormula.Matcher.class);
     
     /**
      * Initializes the pattern matcher within an existing VIATRA Query engine.
@@ -461,15 +471,15 @@ public final class VLSFofFormula extends BaseGeneratedEMFQuerySpecification<VLSF
   }
   
   /**
-   * 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 
+   * Inner class allowing the singleton instance of {@link VLSFofFormula} 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()}.
+   *     but rather at the first call to {@link VLSFofFormula#instance()}.
    * 
    * <p> This workaround is required e.g. to support recursion.
    * 
    */
   private static class LazyHolder {
-    private final static VLSFofFormula INSTANCE = new VLSFofFormula();
+    private static final VLSFofFormula INSTANCE = new VLSFofFormula();
     
     /**
      * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.
@@ -478,7 +488,7 @@ public final class VLSFofFormula extends BaseGeneratedEMFQuerySpecification<VLSF
      * <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();
+    private static final Object STATIC_INITIALIZER = ensureInitialized();
     
     public static Object ensureInitialized() {
       INSTANCE.ensureInitializedInternal();
@@ -487,7 +497,7 @@ public final class VLSFofFormula extends BaseGeneratedEMFQuerySpecification<VLSF
   }
   
   private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
-    private final static VLSFofFormula.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    private static final 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);
     
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
index 47097005..8fff7789 100644
--- 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
@@ -74,8 +74,18 @@ public final class VLSFunction extends BaseGeneratedEMFQuerySpecification<VLSFun
     
     @Override
     public Object get(final String parameterName) {
-      if ("term".equals(parameterName)) return this.fTerm;
-      return null;
+      switch(parameterName) {
+          case "term": return this.fTerm;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fTerm;
+          default: return null;
+      }
     }
     
     public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunction getTerm() {
@@ -260,9 +270,9 @@ public final class VLSFunction extends BaseGeneratedEMFQuerySpecification<VLSFun
       return new Matcher();
     }
     
-    private final static int POSITION_TERM = 0;
+    private static final int POSITION_TERM = 0;
     
-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSFunction.Matcher.class);
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSFunction.Matcher.class);
     
     /**
      * Initializes the pattern matcher within an existing VIATRA Query engine.
@@ -461,15 +471,15 @@ public final class VLSFunction extends BaseGeneratedEMFQuerySpecification<VLSFun
   }
   
   /**
-   * 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 
+   * Inner class allowing the singleton instance of {@link VLSFunction} 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()}.
+   *     but rather at the first call to {@link VLSFunction#instance()}.
    * 
    * <p> This workaround is required e.g. to support recursion.
    * 
    */
   private static class LazyHolder {
-    private final static VLSFunction INSTANCE = new VLSFunction();
+    private static final VLSFunction INSTANCE = new VLSFunction();
     
     /**
      * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.
@@ -478,7 +488,7 @@ public final class VLSFunction extends BaseGeneratedEMFQuerySpecification<VLSFun
      * <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();
+    private static final Object STATIC_INITIALIZER = ensureInitialized();
     
     public static Object ensureInitialized() {
       INSTANCE.ensureInitializedInternal();
@@ -487,7 +497,7 @@ public final class VLSFunction extends BaseGeneratedEMFQuerySpecification<VLSFun
   }
   
   private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
-    private final static VLSFunction.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    private static final 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);
     
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
index 0e82d459..e7a2295c 100644
--- 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
@@ -75,8 +75,18 @@ public final class VLSFunctionFof extends BaseGeneratedEMFQuerySpecification<VLS
     
     @Override
     public Object get(final String parameterName) {
-      if ("term".equals(parameterName)) return this.fTerm;
-      return null;
+      switch(parameterName) {
+          case "term": return this.fTerm;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fTerm;
+          default: return null;
+      }
     }
     
     public VLSFunctionAsTerm getTerm() {
@@ -261,9 +271,9 @@ public final class VLSFunctionFof extends BaseGeneratedEMFQuerySpecification<VLS
       return new Matcher();
     }
     
-    private final static int POSITION_TERM = 0;
+    private static final int POSITION_TERM = 0;
     
-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSFunctionFof.Matcher.class);
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSFunctionFof.Matcher.class);
     
     /**
      * Initializes the pattern matcher within an existing VIATRA Query engine.
@@ -462,15 +472,15 @@ public final class VLSFunctionFof extends BaseGeneratedEMFQuerySpecification<VLS
   }
   
   /**
-   * 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 
+   * Inner class allowing the singleton instance of {@link VLSFunctionFof} 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()}.
+   *     but rather at the first call to {@link VLSFunctionFof#instance()}.
    * 
    * <p> This workaround is required e.g. to support recursion.
    * 
    */
   private static class LazyHolder {
-    private final static VLSFunctionFof INSTANCE = new VLSFunctionFof();
+    private static final VLSFunctionFof INSTANCE = new VLSFunctionFof();
     
     /**
      * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.
@@ -479,7 +489,7 @@ public final class VLSFunctionFof extends BaseGeneratedEMFQuerySpecification<VLS
      * <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();
+    private static final Object STATIC_INITIALIZER = ensureInitialized();
     
     public static Object ensureInitialized() {
       INSTANCE.ensureInitializedInternal();
@@ -488,7 +498,7 @@ public final class VLSFunctionFof extends BaseGeneratedEMFQuerySpecification<VLS
   }
   
   private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
-    private final static VLSFunctionFof.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    private static final VLSFunctionFof.GeneratedPQuery INSTANCE = new GeneratedPQuery();
     
     private final PParameter parameter_term = new PParameter("term", "ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSFunctionAsTerm", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.mcgill.ca/ecse/dslreasoner/VampireLanguage", "VLSFunctionAsTerm")), PParameterDirection.INOUT);
     
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
index 71c4bc61..2a58e99c 100644
--- 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
@@ -74,8 +74,18 @@ public final class VLSInequality extends BaseGeneratedEMFQuerySpecification<VLSI
     
     @Override
     public Object get(final String parameterName) {
-      if ("term".equals(parameterName)) return this.fTerm;
-      return null;
+      switch(parameterName) {
+          case "term": return this.fTerm;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fTerm;
+          default: return null;
+      }
     }
     
     public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSInequality getTerm() {
@@ -260,9 +270,9 @@ public final class VLSInequality extends BaseGeneratedEMFQuerySpecification<VLSI
       return new Matcher();
     }
     
-    private final static int POSITION_TERM = 0;
+    private static final int POSITION_TERM = 0;
     
-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSInequality.Matcher.class);
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSInequality.Matcher.class);
     
     /**
      * Initializes the pattern matcher within an existing VIATRA Query engine.
@@ -461,15 +471,15 @@ public final class VLSInequality extends BaseGeneratedEMFQuerySpecification<VLSI
   }
   
   /**
-   * 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 
+   * Inner class allowing the singleton instance of {@link VLSInequality} 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()}.
+   *     but rather at the first call to {@link VLSInequality#instance()}.
    * 
    * <p> This workaround is required e.g. to support recursion.
    * 
    */
   private static class LazyHolder {
-    private final static VLSInequality INSTANCE = new VLSInequality();
+    private static final VLSInequality INSTANCE = new VLSInequality();
     
     /**
      * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.
@@ -478,7 +488,7 @@ public final class VLSInequality extends BaseGeneratedEMFQuerySpecification<VLSI
      * <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();
+    private static final Object STATIC_INITIALIZER = ensureInitialized();
     
     public static Object ensureInitialized() {
       INSTANCE.ensureInitializedInternal();
@@ -487,7 +497,7 @@ public final class VLSInequality extends BaseGeneratedEMFQuerySpecification<VLSI
   }
   
   private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
-    private final static VLSInequality.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    private static final 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);
     
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
index fcbbd7cc..f254b92c 100644
--- 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
@@ -75,8 +75,18 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
     
     @Override
     public Object get(final String parameterName) {
-      if ("term".equals(parameterName)) return this.fTerm;
-      return null;
+      switch(parameterName) {
+          case "term": return this.fTerm;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fTerm;
+          default: return null;
+      }
     }
     
     public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSOr getTerm() {
@@ -262,9 +272,9 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
       return new Matcher();
     }
     
-    private final static int POSITION_TERM = 0;
+    private static final int POSITION_TERM = 0;
     
-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSOr.Matcher.class);
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSOr.Matcher.class);
     
     /**
      * Initializes the pattern matcher within an existing VIATRA Query engine.
@@ -463,15 +473,15 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
   }
   
   /**
-   * 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 
+   * Inner class allowing the singleton instance of {@link VLSOr} 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()}.
+   *     but rather at the first call to {@link VLSOr#instance()}.
    * 
    * <p> This workaround is required e.g. to support recursion.
    * 
    */
   private static class LazyHolder {
-    private final static VLSOr INSTANCE = new VLSOr();
+    private static final VLSOr INSTANCE = new VLSOr();
     
     /**
      * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.
@@ -480,7 +490,7 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
      * <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();
+    private static final Object STATIC_INITIALIZER = ensureInitialized();
     
     public static Object ensureInitialized() {
       INSTANCE.ensureInitializedInternal();
@@ -489,7 +499,7 @@ public final class VLSOr extends BaseGeneratedEMFQuerySpecification<VLSOr.Matche
   }
   
   private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
-    private final static VLSOr.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    private static final 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);
     
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
index 5763bf4d..e8a1b315 100644
--- 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
@@ -74,8 +74,18 @@ public final class VLSUnaryNegation extends BaseGeneratedEMFQuerySpecification<V
     
     @Override
     public Object get(final String parameterName) {
-      if ("term".equals(parameterName)) return this.fTerm;
-      return null;
+      switch(parameterName) {
+          case "term": return this.fTerm;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fTerm;
+          default: return null;
+      }
     }
     
     public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUnaryNegation getTerm() {
@@ -260,9 +270,9 @@ public final class VLSUnaryNegation extends BaseGeneratedEMFQuerySpecification<V
       return new Matcher();
     }
     
-    private final static int POSITION_TERM = 0;
+    private static final int POSITION_TERM = 0;
     
-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSUnaryNegation.Matcher.class);
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSUnaryNegation.Matcher.class);
     
     /**
      * Initializes the pattern matcher within an existing VIATRA Query engine.
@@ -461,15 +471,15 @@ public final class VLSUnaryNegation extends BaseGeneratedEMFQuerySpecification<V
   }
   
   /**
-   * 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 
+   * Inner class allowing the singleton instance of {@link VLSUnaryNegation} 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()}.
+   *     but rather at the first call to {@link VLSUnaryNegation#instance()}.
    * 
    * <p> This workaround is required e.g. to support recursion.
    * 
    */
   private static class LazyHolder {
-    private final static VLSUnaryNegation INSTANCE = new VLSUnaryNegation();
+    private static final VLSUnaryNegation INSTANCE = new VLSUnaryNegation();
     
     /**
      * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.
@@ -478,7 +488,7 @@ public final class VLSUnaryNegation extends BaseGeneratedEMFQuerySpecification<V
      * <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();
+    private static final Object STATIC_INITIALIZER = ensureInitialized();
     
     public static Object ensureInitialized() {
       INSTANCE.ensureInitializedInternal();
@@ -487,7 +497,7 @@ public final class VLSUnaryNegation extends BaseGeneratedEMFQuerySpecification<V
   }
   
   private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
-    private final static VLSUnaryNegation.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    private static final 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);
     
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
index a0ce1383..39605b34 100644
--- 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
@@ -74,8 +74,18 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
     
     @Override
     public Object get(final String parameterName) {
-      if ("term".equals(parameterName)) return this.fTerm;
-      return null;
+      switch(parameterName) {
+          case "term": return this.fTerm;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fTerm;
+          default: return null;
+      }
     }
     
     public ca.mcgill.ecse.dslreasoner.vampireLanguage.VLSUniversalQuantifier getTerm() {
@@ -260,9 +270,9 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
       return new Matcher();
     }
     
-    private final static int POSITION_TERM = 0;
+    private static final int POSITION_TERM = 0;
     
-    private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSUniversalQuantifier.Matcher.class);
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(VLSUniversalQuantifier.Matcher.class);
     
     /**
      * Initializes the pattern matcher within an existing VIATRA Query engine.
@@ -461,15 +471,15 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
   }
   
   /**
-   * 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 
+   * Inner class allowing the singleton instance of {@link VLSUniversalQuantifier} 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()}.
+   *     but rather at the first call to {@link VLSUniversalQuantifier#instance()}.
    * 
    * <p> This workaround is required e.g. to support recursion.
    * 
    */
   private static class LazyHolder {
-    private final static VLSUniversalQuantifier INSTANCE = new VLSUniversalQuantifier();
+    private static final VLSUniversalQuantifier INSTANCE = new VLSUniversalQuantifier();
     
     /**
      * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.
@@ -478,7 +488,7 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
      * <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();
+    private static final Object STATIC_INITIALIZER = ensureInitialized();
     
     public static Object ensureInitialized() {
       INSTANCE.ensureInitializedInternal();
@@ -487,7 +497,7 @@ public final class VLSUniversalQuantifier extends BaseGeneratedEMFQuerySpecifica
   }
   
   private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
-    private final static VLSUniversalQuantifier.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    private static final 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);
     
-- 
cgit v1.2.3-70-g09d2