code for paperRealistic-Generation-SURE

46 files changed, 10355 insertions, 5 deletions

diff --git a/Domains/github-graph/bin/queries/.CheckAction.java._trace b/Domains/github-graph/bin/queries/.CheckAction.java._trace
new file mode 100644
index 00000000..fe2295bf
--- /dev/null
+++ b/Domains/github-graph/bin/queries/.CheckAction.java._trace
diff --git a/Domains/github-graph/bin/queries/.CheckUserAction.java._trace b/Domains/github-graph/bin/queries/.CheckUserAction.java._trace
new file mode 100644
index 00000000..a050dc45
--- /dev/null
+++ b/Domains/github-graph/bin/queries/.CheckUserAction.java._trace
diff --git a/Domains/github-graph/bin/queries/.Committer.java._trace b/Domains/github-graph/bin/queries/.Committer.java._trace
new file mode 100644
index 00000000..763f332c
--- /dev/null
+++ b/Domains/github-graph/bin/queries/.Committer.java._trace
diff --git a/Domains/github-graph/bin/queries/.ConsecutiveClosesWithoutReopen.java._trace b/Domains/github-graph/bin/queries/.ConsecutiveClosesWithoutReopen.java._trace
new file mode 100644
index 00000000..ab0463a3
--- /dev/null
+++ b/Domains/github-graph/bin/queries/.ConsecutiveClosesWithoutReopen.java._trace
diff --git a/Domains/github-graph/bin/queries/.ConsecutiveReopensWithoutClose.java._trace b/Domains/github-graph/bin/queries/.ConsecutiveReopensWithoutClose.java._trace
new file mode 100644
index 00000000..62ed7508
--- /dev/null
+++ b/Domains/github-graph/bin/queries/.ConsecutiveReopensWithoutClose.java._trace
diff --git a/Domains/github-graph/bin/queries/.ConsecutiveSubWithoutUnSub.java._trace b/Domains/github-graph/bin/queries/.ConsecutiveSubWithoutUnSub.java._trace
new file mode 100644
index 00000000..e1bbd189
--- /dev/null
+++ b/Domains/github-graph/bin/queries/.ConsecutiveSubWithoutUnSub.java._trace
diff --git a/Domains/github-graph/bin/queries/.ConsecutiveUnSubWithoutSub.java._trace b/Domains/github-graph/bin/queries/.ConsecutiveUnSubWithoutSub.java._trace
new file mode 100644
index 00000000..ebd0a1e3
--- /dev/null
+++ b/Domains/github-graph/bin/queries/.ConsecutiveUnSubWithoutSub.java._trace
diff --git a/Domains/github-graph/bin/queries/.EventUser.java._trace b/Domains/github-graph/bin/queries/.EventUser.java._trace
new file mode 100644
index 00000000..0fe22159
--- /dev/null
+++ b/Domains/github-graph/bin/queries/.EventUser.java._trace
diff --git a/Domains/github-graph/bin/queries/.IsClose.java._trace b/Domains/github-graph/bin/queries/.IsClose.java._trace
new file mode 100644
index 00000000..c3bb3738
--- /dev/null
+++ b/Domains/github-graph/bin/queries/.IsClose.java._trace
diff --git a/Domains/github-graph/bin/queries/.IsReopen.java._trace b/Domains/github-graph/bin/queries/.IsReopen.java._trace
new file mode 100644
index 00000000..592d4d12
--- /dev/null
+++ b/Domains/github-graph/bin/queries/.IsReopen.java._trace
diff --git a/Domains/github-graph/bin/queries/.IsSubscribe.java._trace b/Domains/github-graph/bin/queries/.IsSubscribe.java._trace
new file mode 100644
index 00000000..1b8a39fb
--- /dev/null
+++ b/Domains/github-graph/bin/queries/.IsSubscribe.java._trace
diff --git a/Domains/github-graph/bin/queries/.IsUnSubscribe.java._trace b/Domains/github-graph/bin/queries/.IsUnSubscribe.java._trace
new file mode 100644
index 00000000..21db9f95
--- /dev/null
+++ b/Domains/github-graph/bin/queries/.IsUnSubscribe.java._trace
diff --git a/Domains/github-graph/bin/queries/.NoCommitter.java._trace b/Domains/github-graph/bin/queries/.NoCommitter.java._trace
new file mode 100644
index 00000000..bfc00069
--- /dev/null
+++ b/Domains/github-graph/bin/queries/.NoCommitter.java._trace
diff --git a/Domains/github-graph/bin/queries/.NoUser.java._trace b/Domains/github-graph/bin/queries/.NoUser.java._trace
new file mode 100644
index 00000000..0ecef3e3
--- /dev/null
+++ b/Domains/github-graph/bin/queries/.NoUser.java._trace
diff --git a/Domains/github-graph/bin/queries/github.vql b/Domains/github-graph/bin/queries/github.vql
index 62853b3f..a8c68f0a 100644
--- a/Domains/github-graph/bin/queries/github.vql
+++ b/Domains/github-graph/bin/queries/github.vql
@@ -6,14 +6,126 @@ pattern directParent(a : Commit, b: Commit) {
 }
 
 @Constraint(key={a}, severity="error", message="error")
-pattern loopInParent(a){
+pattern loopInParent(a: Commit){
  find directParent+(a,a);
 }
 
+pattern checkAction(i: Issue, e: IssueEvent, t: Action) {
+        Issue.issueevent(i, e);
+        IssueEvent.action(e, t);
+        a == t;
+}
+
+pattern checkUserAction(i: Issue, u: User, e: IssueEvent, t: Action) {
+        Issue.issueevent(i, e);
+        IssueEvent.user(e, u);
+        IssueEvent.action(e, a);
+        a == t;
+}
+
+pattern isReopen(i: Issue, e: IssueEvent) {
+        Issue.issueevent(i, e);
+        IssueEvent.action(e, a);
+        a == Action::REOPENED;
+}
+
+pattern isClose(i: Issue, e: IssueEvent) {
+        Issue.issueevent(i, e);
+        IssueEvent.action(e, a);
+        a == Action::CLOSED;
+}
+
+pattern isUnSubscribe(i: Issue, u: User, e: IssueEvent) {
+        Issue.issueevent(i, e);
+        IssueEvent.user(e, u);
+        IssueEvent.action(e, a);
+        a == Action::UNSUBSCRIBED;
+}
+
+pattern isSubscribe(i: Issue, u: User, e: IssueEvent) {
+        Issue.issueevent(i, e);
+        IssueEvent.user(e, u);
+        IssueEvent.action(e, a);
+        a == Action::SUBSCRIBED;
+}
+
+
+//pattern pullRequestOfIssue(i: Issue, pr: PullRequest) {
+//      Issue.pullrequest(i, pr);
+//}
+//
+//@Constraint(key={i}, severity="error", message="error")
+//pattern mergedIssueWithoutPr(i: Issue){
+//      find checkAction(i, _, Action::MERGED);
+//      neg find pullRequestOfIssue(i, _);
+//}
+
+@Constraint(key={i}, severity="error", message="error")
+pattern consecutiveClosesWithoutReopen(i: Issue) {
+        find checkAction(i, a1, Action::CLOSED);
+        find checkAction(i, a2, Action::CLOSED);
+        a1 != a2;
+        neg find isReopen(i, _);
+}
+
+
+@Constraint(key={i}, severity="error", message="error")
+pattern consecutiveReopensWithoutClose(i: Issue) {
+        find checkAction(i, a1, Action::REOPENED);
+        find checkAction(i, a2, Action::REOPENED);
+        a1 != a2;
+        neg find isClose(i, _);
+}
+
+@Constraint(key={i, u}, severity="error", message="error")
+pattern consecutiveSubWithoutUnSub(i: Issue, u: User) {
+        find checkUserAction(i, u, a1, Action::SUBSCRIBED);
+        find checkUserAction(i, u, a2, Action::SUBSCRIBED);
+        a1 != a2;
+        neg find isUnSubscribe(i, u, _);
+}
+
+@Constraint(key={i, u}, severity="error", message="error")
+pattern consecutiveUnSubWithoutSub(i: Issue, u: User) {
+        find checkUserAction(i, u, a1, Action::UNSUBSCRIBED);
+        find checkUserAction(i, u, a2, Action::UNSUBSCRIBED);
+        a1 != a2;
+        neg find isSubscribe(i, u, _);
+}
+
+//pattern actionWithIssue(i: IssueEvent, a: Action) {
+//      IssueEvent.action(i, a);
+//}
+//
+//@Constraint(key={i}, severity="error", message="error")
+//pattern issueEventNoAction(i: IssueEvent) {
+//      neg find actionWithIssue(i, _);
+//}
+
+
+pattern committer(c: Commit, u:User) {
+        Commit.committer(c, u);
+}
+
+pattern eventUser(e: IssueEvent, u:User){
+        IssueEvent.user(e, u);
+}
+
+@Constraint(key={c}, severity="error", message="error")
+pattern noCommitter(c: Commit) {
+        neg find committer(c, _);
+}
+
+@Constraint(key={e}, severity="error", message="error")
+pattern noUser(e: IssueEvent) {
+        neg find eventUser(e, _);
+}
+
+
 
 //1. issue with MERGED but no PullRequest
 //2. issue with 2 CLOSED events without a REOPENED event
 //3. issue with 2 REOPENED events without a CLOSED event
 //4. user-issue pair with 2 SUBSCRIBED events without an UNSUBSCRIBED event
 //5. user-issue pair with 2 UNSUBSCRIBED events without a SUBSCRIBED event
-//6. User MERGED/CLOSED/REOPENED issue without being a projectMember of the Project
\ No newline at end of file
+//6. User MERGED/CLOSED/REOPENED issue without being a projectMember of the Project (Not possible under this condition)
\ No newline at end of file
diff --git a/Domains/github-graph/model/github.ecore b/Domains/github-graph/model/github.ecore
index 012003bc..e3c32df0 100644
--- a/Domains/github-graph/model/github.ecore
+++ b/Domains/github-graph/model/github.ecore
@@ -59,7 +59,8 @@
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EClass" name="IssueEvent">
     <eStructuralFeatures xsi:type="ecore:EReference" name="user" lowerBound="1" eType="#//User"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="action" eType="#//Action"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="action" lowerBound="1"
+        eType="#//Action"/>
     <eStructuralFeatures xsi:type="ecore:EAttribute" name="created_at" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EDate"/>
     <eStructuralFeatures xsi:type="ecore:EAttribute" name="actor_url" lowerBound="1"
         eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
diff --git a/Domains/github-graph/plugin.xml b/Domains/github-graph/plugin.xml
index f207d788..98c96571 100644
--- a/Domains/github-graph/plugin.xml
+++ b/Domains/github-graph/plugin.xml
@@ -8,6 +8,20 @@
     <group group="org.eclipse.viatra.query.runtime.extensibility.SingletonExtensionFactory:queries.Github" id="queries.Github">
       <query-specification fqn="queries.directParent"/>
       <query-specification fqn="queries.loopInParent"/>
+      <query-specification fqn="queries.checkAction"/>
+      <query-specification fqn="queries.checkUserAction"/>
+      <query-specification fqn="queries.isReopen"/>
+      <query-specification fqn="queries.isClose"/>
+      <query-specification fqn="queries.isUnSubscribe"/>
+      <query-specification fqn="queries.isSubscribe"/>
+      <query-specification fqn="queries.consecutiveClosesWithoutReopen"/>
+      <query-specification fqn="queries.consecutiveReopensWithoutClose"/>
+      <query-specification fqn="queries.consecutiveSubWithoutUnSub"/>
+      <query-specification fqn="queries.consecutiveUnSubWithoutSub"/>
+      <query-specification fqn="queries.committer"/>
+      <query-specification fqn="queries.eventUser"/>
+      <query-specification fqn="queries.noCommitter"/>
+      <query-specification fqn="queries.noUser"/>
     </group>
   </extension>
 </plugin>
diff --git a/Domains/github-graph/queries/queries/github.vql b/Domains/github-graph/queries/queries/github.vql
index 62853b3f..a8c68f0a 100644
--- a/Domains/github-graph/queries/queries/github.vql
+++ b/Domains/github-graph/queries/queries/github.vql
@@ -6,14 +6,126 @@ pattern directParent(a : Commit, b: Commit) {
 }
 
 @Constraint(key={a}, severity="error", message="error")
-pattern loopInParent(a){
+pattern loopInParent(a: Commit){
  find directParent+(a,a);
 }
 
+pattern checkAction(i: Issue, e: IssueEvent, t: Action) {
+        Issue.issueevent(i, e);
+        IssueEvent.action(e, t);
+        a == t;
+}
+
+pattern checkUserAction(i: Issue, u: User, e: IssueEvent, t: Action) {
+        Issue.issueevent(i, e);
+        IssueEvent.user(e, u);
+        IssueEvent.action(e, a);
+        a == t;
+}
+
+pattern isReopen(i: Issue, e: IssueEvent) {
+        Issue.issueevent(i, e);
+        IssueEvent.action(e, a);
+        a == Action::REOPENED;
+}
+
+pattern isClose(i: Issue, e: IssueEvent) {
+        Issue.issueevent(i, e);
+        IssueEvent.action(e, a);
+        a == Action::CLOSED;
+}
+
+pattern isUnSubscribe(i: Issue, u: User, e: IssueEvent) {
+        Issue.issueevent(i, e);
+        IssueEvent.user(e, u);
+        IssueEvent.action(e, a);
+        a == Action::UNSUBSCRIBED;
+}
+
+pattern isSubscribe(i: Issue, u: User, e: IssueEvent) {
+        Issue.issueevent(i, e);
+        IssueEvent.user(e, u);
+        IssueEvent.action(e, a);
+        a == Action::SUBSCRIBED;
+}
+
+
+//pattern pullRequestOfIssue(i: Issue, pr: PullRequest) {
+//      Issue.pullrequest(i, pr);
+//}
+//
+//@Constraint(key={i}, severity="error", message="error")
+//pattern mergedIssueWithoutPr(i: Issue){
+//      find checkAction(i, _, Action::MERGED);
+//      neg find pullRequestOfIssue(i, _);
+//}
+
+@Constraint(key={i}, severity="error", message="error")
+pattern consecutiveClosesWithoutReopen(i: Issue) {
+        find checkAction(i, a1, Action::CLOSED);
+        find checkAction(i, a2, Action::CLOSED);
+        a1 != a2;
+        neg find isReopen(i, _);
+}
+
+
+@Constraint(key={i}, severity="error", message="error")
+pattern consecutiveReopensWithoutClose(i: Issue) {
+        find checkAction(i, a1, Action::REOPENED);
+        find checkAction(i, a2, Action::REOPENED);
+        a1 != a2;
+        neg find isClose(i, _);
+}
+
+@Constraint(key={i, u}, severity="error", message="error")
+pattern consecutiveSubWithoutUnSub(i: Issue, u: User) {
+        find checkUserAction(i, u, a1, Action::SUBSCRIBED);
+        find checkUserAction(i, u, a2, Action::SUBSCRIBED);
+        a1 != a2;
+        neg find isUnSubscribe(i, u, _);
+}
+
+@Constraint(key={i, u}, severity="error", message="error")
+pattern consecutiveUnSubWithoutSub(i: Issue, u: User) {
+        find checkUserAction(i, u, a1, Action::UNSUBSCRIBED);
+        find checkUserAction(i, u, a2, Action::UNSUBSCRIBED);
+        a1 != a2;
+        neg find isSubscribe(i, u, _);
+}
+
+//pattern actionWithIssue(i: IssueEvent, a: Action) {
+//      IssueEvent.action(i, a);
+//}
+//
+//@Constraint(key={i}, severity="error", message="error")
+//pattern issueEventNoAction(i: IssueEvent) {
+//      neg find actionWithIssue(i, _);
+//}
+
+
+pattern committer(c: Commit, u:User) {
+        Commit.committer(c, u);
+}
+
+pattern eventUser(e: IssueEvent, u:User){
+        IssueEvent.user(e, u);
+}
+
+@Constraint(key={c}, severity="error", message="error")
+pattern noCommitter(c: Commit) {
+        neg find committer(c, _);
+}
+
+@Constraint(key={e}, severity="error", message="error")
+pattern noUser(e: IssueEvent) {
+        neg find eventUser(e, _);
+}
+
+
 
 //1. issue with MERGED but no PullRequest
 //2. issue with 2 CLOSED events without a REOPENED event
 //3. issue with 2 REOPENED events without a CLOSED event
 //4. user-issue pair with 2 SUBSCRIBED events without an UNSUBSCRIBED event
 //5. user-issue pair with 2 UNSUBSCRIBED events without a SUBSCRIBED event
-//6. User MERGED/CLOSED/REOPENED issue without being a projectMember of the Project
\ No newline at end of file
+//6. User MERGED/CLOSED/REOPENED issue without being a projectMember of the Project (Not possible under this condition)
\ No newline at end of file
diff --git a/Domains/github-graph/src-gen/queries/.CheckAction.java._trace b/Domains/github-graph/src-gen/queries/.CheckAction.java._trace
new file mode 100644
index 00000000..fe2295bf
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/.CheckAction.java._trace
diff --git a/Domains/github-graph/src-gen/queries/.CheckUserAction.java._trace b/Domains/github-graph/src-gen/queries/.CheckUserAction.java._trace
new file mode 100644
index 00000000..a050dc45
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/.CheckUserAction.java._trace
diff --git a/Domains/github-graph/src-gen/queries/.Committer.java._trace b/Domains/github-graph/src-gen/queries/.Committer.java._trace
new file mode 100644
index 00000000..763f332c
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/.Committer.java._trace
diff --git a/Domains/github-graph/src-gen/queries/.ConsecutiveClosesWithoutReopen.java._trace b/Domains/github-graph/src-gen/queries/.ConsecutiveClosesWithoutReopen.java._trace
new file mode 100644
index 00000000..ab0463a3
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/.ConsecutiveClosesWithoutReopen.java._trace
diff --git a/Domains/github-graph/src-gen/queries/.ConsecutiveReopensWithoutClose.java._trace b/Domains/github-graph/src-gen/queries/.ConsecutiveReopensWithoutClose.java._trace
new file mode 100644
index 00000000..62ed7508
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/.ConsecutiveReopensWithoutClose.java._trace
diff --git a/Domains/github-graph/src-gen/queries/.ConsecutiveSubWithoutUnSub.java._trace b/Domains/github-graph/src-gen/queries/.ConsecutiveSubWithoutUnSub.java._trace
new file mode 100644
index 00000000..e1bbd189
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/.ConsecutiveSubWithoutUnSub.java._trace
diff --git a/Domains/github-graph/src-gen/queries/.ConsecutiveUnSubWithoutSub.java._trace b/Domains/github-graph/src-gen/queries/.ConsecutiveUnSubWithoutSub.java._trace
new file mode 100644
index 00000000..ebd0a1e3
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/.ConsecutiveUnSubWithoutSub.java._trace
diff --git a/Domains/github-graph/src-gen/queries/.EventUser.java._trace b/Domains/github-graph/src-gen/queries/.EventUser.java._trace
new file mode 100644
index 00000000..0fe22159
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/.EventUser.java._trace
diff --git a/Domains/github-graph/src-gen/queries/.IsClose.java._trace b/Domains/github-graph/src-gen/queries/.IsClose.java._trace
new file mode 100644
index 00000000..c3bb3738
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/.IsClose.java._trace
diff --git a/Domains/github-graph/src-gen/queries/.IsReopen.java._trace b/Domains/github-graph/src-gen/queries/.IsReopen.java._trace
new file mode 100644
index 00000000..592d4d12
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/.IsReopen.java._trace
diff --git a/Domains/github-graph/src-gen/queries/.IsSubscribe.java._trace b/Domains/github-graph/src-gen/queries/.IsSubscribe.java._trace
new file mode 100644
index 00000000..1b8a39fb
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/.IsSubscribe.java._trace
diff --git a/Domains/github-graph/src-gen/queries/.IsUnSubscribe.java._trace b/Domains/github-graph/src-gen/queries/.IsUnSubscribe.java._trace
new file mode 100644
index 00000000..21db9f95
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/.IsUnSubscribe.java._trace
diff --git a/Domains/github-graph/src-gen/queries/.NoCommitter.java._trace b/Domains/github-graph/src-gen/queries/.NoCommitter.java._trace
new file mode 100644
index 00000000..bfc00069
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/.NoCommitter.java._trace
diff --git a/Domains/github-graph/src-gen/queries/.NoUser.java._trace b/Domains/github-graph/src-gen/queries/.NoUser.java._trace
new file mode 100644
index 00000000..0ecef3e3
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/.NoUser.java._trace
diff --git a/Domains/github-graph/src-gen/queries/CheckAction.java b/Domains/github-graph/src-gen/queries/CheckAction.java
new file mode 100644
index 00000000..f3b48a51
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/CheckAction.java
@@ -0,0 +1,829 @@
+/**
+ * Generated from platform:/resource/github-graph/queries/queries/github.vql
+ */
+package queries;
+
+import github.Action;
+import github.Issue;
+import github.IssueEvent;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         pattern checkAction(i: Issue, e: IssueEvent, t: Action) {
+ *              Issue.issueevent(i, e);
+ *              IssueEvent.action(e, t);
+ *              a == t;
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class CheckAction extends BaseGeneratedEMFQuerySpecification<CheckAction.Matcher> {
+  /**
+   * Pattern-specific match representation of the queries.checkAction 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 Issue fI;
+    
+    private IssueEvent fE;
+    
+    private Action fT;
+    
+    private static List<String> parameterNames = makeImmutableList("i", "e", "t");
+    
+    private Match(final Issue pI, final IssueEvent pE, final Action pT) {
+      this.fI = pI;
+      this.fE = pE;
+      this.fT = pT;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "i": return this.fI;
+          case "e": return this.fE;
+          case "t": return this.fT;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fI;
+          case 1: return this.fE;
+          case 2: return this.fT;
+          default: return null;
+      }
+    }
+    
+    public Issue getI() {
+      return this.fI;
+    }
+    
+    public IssueEvent getE() {
+      return this.fE;
+    }
+    
+    public Action getT() {
+      return this.fT;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("i".equals(parameterName) ) {
+          this.fI = (Issue) newValue;
+          return true;
+      }
+      if ("e".equals(parameterName) ) {
+          this.fE = (IssueEvent) newValue;
+          return true;
+      }
+      if ("t".equals(parameterName) ) {
+          this.fT = (Action) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setI(final Issue pI) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fI = pI;
+    }
+    
+    public void setE(final IssueEvent pE) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fE = pE;
+    }
+    
+    public void setT(final Action pT) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fT = pT;
+    }
+    
+    @Override
+    public String patternName() {
+      return "queries.checkAction";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return CheckAction.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fI, fE, fT};
+    }
+    
+    @Override
+    public CheckAction.Match toImmutable() {
+      return isMutable() ? newMatch(fI, fE, fT) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"i\"=" + prettyPrintValue(fI) + ", ");
+      result.append("\"e\"=" + prettyPrintValue(fE) + ", ");
+      result.append("\"t\"=" + prettyPrintValue(fT));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fI, fE, fT);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof CheckAction.Match)) {
+          CheckAction.Match other = (CheckAction.Match) obj;
+          return Objects.equals(fI, other.fI) && Objects.equals(fE, other.fE) && Objects.equals(fT, other.fT);
+      } 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 CheckAction specification() {
+      return CheckAction.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 CheckAction.Match newEmptyMatch() {
+      return new Mutable(null, null, null);
+    }
+    
+    /**
+     * Returns a mutable (partial) match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static CheckAction.Match newMutableMatch(final Issue pI, final IssueEvent pE, final Action pT) {
+      return new Mutable(pI, pE, pT);
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static CheckAction.Match newMatch(final Issue pI, final IssueEvent pE, final Action pT) {
+      return new Immutable(pI, pE, pT);
+    }
+    
+    private static final class Mutable extends CheckAction.Match {
+      Mutable(final Issue pI, final IssueEvent pE, final Action pT) {
+        super(pI, pE, pT);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends CheckAction.Match {
+      Immutable(final Issue pI, final IssueEvent pE, final Action pT) {
+        super(pI, pE, pT);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the queries.checkAction 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 checkAction(i: Issue, e: IssueEvent, t: Action) {
+   *    Issue.issueevent(i, e);
+   *    IssueEvent.action(e, t);
+   *    a == t;
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see CheckAction
+   * 
+   */
+  public static class Matcher extends BaseMatcher<CheckAction.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 CheckAction.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 CheckAction.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_I = 0;
+    
+    private static final int POSITION_E = 1;
+    
+    private static final int POSITION_T = 2;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(CheckAction.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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<CheckAction.Match> getAllMatches(final Issue pI, final IssueEvent pE, final Action pT) {
+      return rawStreamAllMatches(new Object[]{pI, pE, pT}).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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<CheckAction.Match> streamAllMatches(final Issue pI, final IssueEvent pE, final Action pT) {
+      return rawStreamAllMatches(new Object[]{pI, pE, pT});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<CheckAction.Match> getOneArbitraryMatch(final Issue pI, final IssueEvent pE, final Action pT) {
+      return rawGetOneArbitraryMatch(new Object[]{pI, pE, pT});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Issue pI, final IssueEvent pE, final Action pT) {
+      return rawHasMatch(new Object[]{pI, pE, pT});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Issue pI, final IssueEvent pE, final Action pT) {
+      return rawCountMatches(new Object[]{pI, pE, pT});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, 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 Issue pI, final IssueEvent pE, final Action pT, final Consumer<? super CheckAction.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pI, pE, pT}, 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public CheckAction.Match newMatch(final Issue pI, final IssueEvent pE, final Action pT) {
+      return CheckAction.Match.newMatch(pI, pE, pT);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Issue> rawStreamAllValuesOfi(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_I, parameters).map(Issue.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi(final CheckAction.Match partialMatch) {
+      return rawStreamAllValuesOfi(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi(final IssueEvent pE, final Action pT) {
+      return rawStreamAllValuesOfi(new Object[]{null, pE, pT});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi(final CheckAction.Match partialMatch) {
+      return rawStreamAllValuesOfi(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi(final IssueEvent pE, final Action pT) {
+      return rawStreamAllValuesOfi(new Object[]{null, pE, pT}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<IssueEvent> rawStreamAllValuesOfe(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_E, parameters).map(IssueEvent.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe() {
+      return rawStreamAllValuesOfe(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe() {
+      return rawStreamAllValuesOfe(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe(final CheckAction.Match partialMatch) {
+      return rawStreamAllValuesOfe(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe(final Issue pI, final Action pT) {
+      return rawStreamAllValuesOfe(new Object[]{pI, null, pT});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe(final CheckAction.Match partialMatch) {
+      return rawStreamAllValuesOfe(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe(final Issue pI, final Action pT) {
+      return rawStreamAllValuesOfe(new Object[]{pI, null, pT}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for t.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Action> rawStreamAllValuesOft(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_T, parameters).map(Action.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for t.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Action> getAllValuesOft() {
+      return rawStreamAllValuesOft(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for t.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Action> streamAllValuesOft() {
+      return rawStreamAllValuesOft(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for t.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Action> streamAllValuesOft(final CheckAction.Match partialMatch) {
+      return rawStreamAllValuesOft(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for t.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Action> streamAllValuesOft(final Issue pI, final IssueEvent pE) {
+      return rawStreamAllValuesOft(new Object[]{pI, pE, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for t.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Action> getAllValuesOft(final CheckAction.Match partialMatch) {
+      return rawStreamAllValuesOft(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for t.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Action> getAllValuesOft(final Issue pI, final IssueEvent pE) {
+      return rawStreamAllValuesOft(new Object[]{pI, pE, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected CheckAction.Match tupleToMatch(final Tuple t) {
+      try {
+          return CheckAction.Match.newMatch((Issue) t.get(POSITION_I), (IssueEvent) t.get(POSITION_E), (Action) t.get(POSITION_T));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected CheckAction.Match arrayToMatch(final Object[] match) {
+      try {
+          return CheckAction.Match.newMatch((Issue) match[POSITION_I], (IssueEvent) match[POSITION_E], (Action) match[POSITION_T]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected CheckAction.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return CheckAction.Match.newMutableMatch((Issue) match[POSITION_I], (IssueEvent) match[POSITION_E], (Action) match[POSITION_T]);
+      } 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<CheckAction.Matcher> querySpecification() {
+      return CheckAction.instance();
+    }
+  }
+  
+  private CheckAction() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static CheckAction instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected CheckAction.Matcher instantiate(final ViatraQueryEngine engine) {
+    return CheckAction.Matcher.on(engine);
+  }
+  
+  @Override
+  public CheckAction.Matcher instantiate() {
+    return CheckAction.Matcher.create();
+  }
+  
+  @Override
+  public CheckAction.Match newEmptyMatch() {
+    return CheckAction.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public CheckAction.Match newMatch(final Object... parameters) {
+    return CheckAction.Match.newMatch((github.Issue) parameters[0], (github.IssueEvent) parameters[1], (github.Action) parameters[2]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link CheckAction} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link CheckAction#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final CheckAction INSTANCE = new CheckAction();
+    
+    /**
+     * 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 static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final CheckAction.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_i = new PParameter("i", "github.Issue", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "Issue")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_e = new PParameter("e", "github.IssueEvent", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "IssueEvent")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_t = new PParameter("t", "github.Action", new EDataTypeInSlotsKey((EDataType)getClassifierLiteralSafe("sure.ghtorrent.github", "Action")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_i, parameter_e, parameter_t);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "queries.checkAction";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("i","e","t");
+    }
+    
+    @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_i = body.getOrCreateVariableByName("i");
+          PVariable var_e = body.getOrCreateVariableByName("e");
+          PVariable var_t = body.getOrCreateVariableByName("t");
+          PVariable var_a = body.getOrCreateVariableByName("a");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Issue")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_t), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("sure.ghtorrent.github", "Action")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_i, parameter_i),
+             new ExportedParameter(body, var_e, parameter_e),
+             new ExportedParameter(body, var_t, parameter_t)
+          ));
+          //    Issue.issueevent(i, e)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Issue")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("sure.ghtorrent.github", "Issue", "issueevent")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          new Equality(body, var__virtual_0_, var_e);
+          //    IssueEvent.action(e, t)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("sure.ghtorrent.github", "IssueEvent", "action")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("sure.ghtorrent.github", "Action")));
+          new Equality(body, var__virtual_1_, var_t);
+          //    a == t
+          new Equality(body, var_a, var_t);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/github-graph/src-gen/queries/CheckUserAction.java b/Domains/github-graph/src-gen/queries/CheckUserAction.java
new file mode 100644
index 00000000..d26c0031
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/CheckUserAction.java
@@ -0,0 +1,946 @@
+/**
+ * Generated from platform:/resource/github-graph/queries/queries/github.vql
+ */
+package queries;
+
+import github.Action;
+import github.Issue;
+import github.IssueEvent;
+import github.User;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         pattern checkUserAction(i: Issue, u: User, e: IssueEvent, t: Action) {
+ *              Issue.issueevent(i, e);
+ *              IssueEvent.user(e, u);
+ *              IssueEvent.action(e, a);
+ *              a == t;
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class CheckUserAction extends BaseGeneratedEMFQuerySpecification<CheckUserAction.Matcher> {
+  /**
+   * Pattern-specific match representation of the queries.checkUserAction 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 Issue fI;
+    
+    private User fU;
+    
+    private IssueEvent fE;
+    
+    private Action fT;
+    
+    private static List<String> parameterNames = makeImmutableList("i", "u", "e", "t");
+    
+    private Match(final Issue pI, final User pU, final IssueEvent pE, final Action pT) {
+      this.fI = pI;
+      this.fU = pU;
+      this.fE = pE;
+      this.fT = pT;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "i": return this.fI;
+          case "u": return this.fU;
+          case "e": return this.fE;
+          case "t": return this.fT;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fI;
+          case 1: return this.fU;
+          case 2: return this.fE;
+          case 3: return this.fT;
+          default: return null;
+      }
+    }
+    
+    public Issue getI() {
+      return this.fI;
+    }
+    
+    public User getU() {
+      return this.fU;
+    }
+    
+    public IssueEvent getE() {
+      return this.fE;
+    }
+    
+    public Action getT() {
+      return this.fT;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("i".equals(parameterName) ) {
+          this.fI = (Issue) newValue;
+          return true;
+      }
+      if ("u".equals(parameterName) ) {
+          this.fU = (User) newValue;
+          return true;
+      }
+      if ("e".equals(parameterName) ) {
+          this.fE = (IssueEvent) newValue;
+          return true;
+      }
+      if ("t".equals(parameterName) ) {
+          this.fT = (Action) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setI(final Issue pI) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fI = pI;
+    }
+    
+    public void setU(final User pU) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fU = pU;
+    }
+    
+    public void setE(final IssueEvent pE) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fE = pE;
+    }
+    
+    public void setT(final Action pT) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fT = pT;
+    }
+    
+    @Override
+    public String patternName() {
+      return "queries.checkUserAction";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return CheckUserAction.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fI, fU, fE, fT};
+    }
+    
+    @Override
+    public CheckUserAction.Match toImmutable() {
+      return isMutable() ? newMatch(fI, fU, fE, fT) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"i\"=" + prettyPrintValue(fI) + ", ");
+      result.append("\"u\"=" + prettyPrintValue(fU) + ", ");
+      result.append("\"e\"=" + prettyPrintValue(fE) + ", ");
+      result.append("\"t\"=" + prettyPrintValue(fT));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fI, fU, fE, fT);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof CheckUserAction.Match)) {
+          CheckUserAction.Match other = (CheckUserAction.Match) obj;
+          return Objects.equals(fI, other.fI) && Objects.equals(fU, other.fU) && Objects.equals(fE, other.fE) && Objects.equals(fT, other.fT);
+      } 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 CheckUserAction specification() {
+      return CheckUserAction.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 CheckUserAction.Match newEmptyMatch() {
+      return new Mutable(null, null, null, null);
+    }
+    
+    /**
+     * Returns a mutable (partial) match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static CheckUserAction.Match newMutableMatch(final Issue pI, final User pU, final IssueEvent pE, final Action pT) {
+      return new Mutable(pI, pU, pE, pT);
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static CheckUserAction.Match newMatch(final Issue pI, final User pU, final IssueEvent pE, final Action pT) {
+      return new Immutable(pI, pU, pE, pT);
+    }
+    
+    private static final class Mutable extends CheckUserAction.Match {
+      Mutable(final Issue pI, final User pU, final IssueEvent pE, final Action pT) {
+        super(pI, pU, pE, pT);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends CheckUserAction.Match {
+      Immutable(final Issue pI, final User pU, final IssueEvent pE, final Action pT) {
+        super(pI, pU, pE, pT);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the queries.checkUserAction 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 checkUserAction(i: Issue, u: User, e: IssueEvent, t: Action) {
+   *    Issue.issueevent(i, e);
+   *    IssueEvent.user(e, u);
+   *    IssueEvent.action(e, a);
+   *    a == t;
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see CheckUserAction
+   * 
+   */
+  public static class Matcher extends BaseMatcher<CheckUserAction.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 CheckUserAction.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 CheckUserAction.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_I = 0;
+    
+    private static final int POSITION_U = 1;
+    
+    private static final int POSITION_E = 2;
+    
+    private static final int POSITION_T = 3;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(CheckUserAction.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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<CheckUserAction.Match> getAllMatches(final Issue pI, final User pU, final IssueEvent pE, final Action pT) {
+      return rawStreamAllMatches(new Object[]{pI, pU, pE, pT}).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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<CheckUserAction.Match> streamAllMatches(final Issue pI, final User pU, final IssueEvent pE, final Action pT) {
+      return rawStreamAllMatches(new Object[]{pI, pU, pE, pT});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<CheckUserAction.Match> getOneArbitraryMatch(final Issue pI, final User pU, final IssueEvent pE, final Action pT) {
+      return rawGetOneArbitraryMatch(new Object[]{pI, pU, pE, pT});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Issue pI, final User pU, final IssueEvent pE, final Action pT) {
+      return rawHasMatch(new Object[]{pI, pU, pE, pT});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Issue pI, final User pU, final IssueEvent pE, final Action pT) {
+      return rawCountMatches(new Object[]{pI, pU, pE, pT});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, 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 Issue pI, final User pU, final IssueEvent pE, final Action pT, final Consumer<? super CheckUserAction.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pI, pU, pE, pT}, 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pT the fixed value of pattern parameter t, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public CheckUserAction.Match newMatch(final Issue pI, final User pU, final IssueEvent pE, final Action pT) {
+      return CheckUserAction.Match.newMatch(pI, pU, pE, pT);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Issue> rawStreamAllValuesOfi(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_I, parameters).map(Issue.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi(final CheckUserAction.Match partialMatch) {
+      return rawStreamAllValuesOfi(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi(final User pU, final IssueEvent pE, final Action pT) {
+      return rawStreamAllValuesOfi(new Object[]{null, pU, pE, pT});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi(final CheckUserAction.Match partialMatch) {
+      return rawStreamAllValuesOfi(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi(final User pU, final IssueEvent pE, final Action pT) {
+      return rawStreamAllValuesOfi(new Object[]{null, pU, pE, pT}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<User> rawStreamAllValuesOfu(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_U, parameters).map(User.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu() {
+      return rawStreamAllValuesOfu(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu() {
+      return rawStreamAllValuesOfu(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu(final CheckUserAction.Match partialMatch) {
+      return rawStreamAllValuesOfu(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu(final Issue pI, final IssueEvent pE, final Action pT) {
+      return rawStreamAllValuesOfu(new Object[]{pI, null, pE, pT});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu(final CheckUserAction.Match partialMatch) {
+      return rawStreamAllValuesOfu(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu(final Issue pI, final IssueEvent pE, final Action pT) {
+      return rawStreamAllValuesOfu(new Object[]{pI, null, pE, pT}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<IssueEvent> rawStreamAllValuesOfe(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_E, parameters).map(IssueEvent.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe() {
+      return rawStreamAllValuesOfe(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe() {
+      return rawStreamAllValuesOfe(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe(final CheckUserAction.Match partialMatch) {
+      return rawStreamAllValuesOfe(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe(final Issue pI, final User pU, final Action pT) {
+      return rawStreamAllValuesOfe(new Object[]{pI, pU, null, pT});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe(final CheckUserAction.Match partialMatch) {
+      return rawStreamAllValuesOfe(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe(final Issue pI, final User pU, final Action pT) {
+      return rawStreamAllValuesOfe(new Object[]{pI, pU, null, pT}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for t.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Action> rawStreamAllValuesOft(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_T, parameters).map(Action.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for t.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Action> getAllValuesOft() {
+      return rawStreamAllValuesOft(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for t.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Action> streamAllValuesOft() {
+      return rawStreamAllValuesOft(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for t.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Action> streamAllValuesOft(final CheckUserAction.Match partialMatch) {
+      return rawStreamAllValuesOft(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for t.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Action> streamAllValuesOft(final Issue pI, final User pU, final IssueEvent pE) {
+      return rawStreamAllValuesOft(new Object[]{pI, pU, pE, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for t.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Action> getAllValuesOft(final CheckUserAction.Match partialMatch) {
+      return rawStreamAllValuesOft(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for t.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Action> getAllValuesOft(final Issue pI, final User pU, final IssueEvent pE) {
+      return rawStreamAllValuesOft(new Object[]{pI, pU, pE, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected CheckUserAction.Match tupleToMatch(final Tuple t) {
+      try {
+          return CheckUserAction.Match.newMatch((Issue) t.get(POSITION_I), (User) t.get(POSITION_U), (IssueEvent) t.get(POSITION_E), (Action) t.get(POSITION_T));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected CheckUserAction.Match arrayToMatch(final Object[] match) {
+      try {
+          return CheckUserAction.Match.newMatch((Issue) match[POSITION_I], (User) match[POSITION_U], (IssueEvent) match[POSITION_E], (Action) match[POSITION_T]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected CheckUserAction.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return CheckUserAction.Match.newMutableMatch((Issue) match[POSITION_I], (User) match[POSITION_U], (IssueEvent) match[POSITION_E], (Action) match[POSITION_T]);
+      } 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<CheckUserAction.Matcher> querySpecification() {
+      return CheckUserAction.instance();
+    }
+  }
+  
+  private CheckUserAction() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static CheckUserAction instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected CheckUserAction.Matcher instantiate(final ViatraQueryEngine engine) {
+    return CheckUserAction.Matcher.on(engine);
+  }
+  
+  @Override
+  public CheckUserAction.Matcher instantiate() {
+    return CheckUserAction.Matcher.create();
+  }
+  
+  @Override
+  public CheckUserAction.Match newEmptyMatch() {
+    return CheckUserAction.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public CheckUserAction.Match newMatch(final Object... parameters) {
+    return CheckUserAction.Match.newMatch((github.Issue) parameters[0], (github.User) parameters[1], (github.IssueEvent) parameters[2], (github.Action) parameters[3]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link CheckUserAction} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link CheckUserAction#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final CheckUserAction INSTANCE = new CheckUserAction();
+    
+    /**
+     * 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 static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final CheckUserAction.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_i = new PParameter("i", "github.Issue", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "Issue")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_u = new PParameter("u", "github.User", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "User")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_e = new PParameter("e", "github.IssueEvent", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "IssueEvent")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_t = new PParameter("t", "github.Action", new EDataTypeInSlotsKey((EDataType)getClassifierLiteralSafe("sure.ghtorrent.github", "Action")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_i, parameter_u, parameter_e, parameter_t);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "queries.checkUserAction";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("i","u","e","t");
+    }
+    
+    @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_i = body.getOrCreateVariableByName("i");
+          PVariable var_u = body.getOrCreateVariableByName("u");
+          PVariable var_e = body.getOrCreateVariableByName("e");
+          PVariable var_t = body.getOrCreateVariableByName("t");
+          PVariable var_a = body.getOrCreateVariableByName("a");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Issue")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_u), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "User")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_t), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("sure.ghtorrent.github", "Action")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_i, parameter_i),
+             new ExportedParameter(body, var_u, parameter_u),
+             new ExportedParameter(body, var_e, parameter_e),
+             new ExportedParameter(body, var_t, parameter_t)
+          ));
+          //    Issue.issueevent(i, e)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Issue")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("sure.ghtorrent.github", "Issue", "issueevent")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          new Equality(body, var__virtual_0_, var_e);
+          //    IssueEvent.user(e, u)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("sure.ghtorrent.github", "IssueEvent", "user")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "User")));
+          new Equality(body, var__virtual_1_, var_u);
+          //    IssueEvent.action(e, a)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e, var__virtual_2_), new EStructuralFeatureInstancesKey(getFeatureLiteral("sure.ghtorrent.github", "IssueEvent", "action")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_2_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("sure.ghtorrent.github", "Action")));
+          new Equality(body, var__virtual_2_, var_a);
+          //    a == t
+          new Equality(body, var_a, var_t);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/github-graph/src-gen/queries/Committer.java b/Domains/github-graph/src-gen/queries/Committer.java
new file mode 100644
index 00000000..1c6b588c
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/Committer.java
@@ -0,0 +1,725 @@
+/**
+ * Generated from platform:/resource/github-graph/queries/queries/github.vql
+ */
+package queries;
+
+import github.Commit;
+import github.User;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         //pattern actionWithIssue(i: IssueEvent, a: Action) {
+ *         //   IssueEvent.action(i, a);
+ *         //}
+ *         //
+ *         //{@literal @}Constraint(key={i}, severity="error", message="error")
+ *         //pattern issueEventNoAction(i: IssueEvent) {
+ *         //   neg find actionWithIssue(i, _);
+ *         //}
+ *         
+ *         
+ *         pattern committer(c: Commit, u:User) {
+ *              Commit.committer(c, u);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class Committer extends BaseGeneratedEMFQuerySpecification<Committer.Matcher> {
+  /**
+   * Pattern-specific match representation of the queries.committer 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 Commit fC;
+    
+    private User fU;
+    
+    private static List<String> parameterNames = makeImmutableList("c", "u");
+    
+    private Match(final Commit pC, final User pU) {
+      this.fC = pC;
+      this.fU = pU;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "c": return this.fC;
+          case "u": return this.fU;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fC;
+          case 1: return this.fU;
+          default: return null;
+      }
+    }
+    
+    public Commit getC() {
+      return this.fC;
+    }
+    
+    public User getU() {
+      return this.fU;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("c".equals(parameterName) ) {
+          this.fC = (Commit) newValue;
+          return true;
+      }
+      if ("u".equals(parameterName) ) {
+          this.fU = (User) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setC(final Commit pC) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fC = pC;
+    }
+    
+    public void setU(final User pU) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fU = pU;
+    }
+    
+    @Override
+    public String patternName() {
+      return "queries.committer";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return Committer.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fC, fU};
+    }
+    
+    @Override
+    public Committer.Match toImmutable() {
+      return isMutable() ? newMatch(fC, fU) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"c\"=" + prettyPrintValue(fC) + ", ");
+      result.append("\"u\"=" + prettyPrintValue(fU));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fC, fU);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof Committer.Match)) {
+          Committer.Match other = (Committer.Match) obj;
+          return Objects.equals(fC, other.fC) && Objects.equals(fU, other.fU);
+      } 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 Committer specification() {
+      return Committer.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 Committer.Match newEmptyMatch() {
+      return new Mutable(null, null);
+    }
+    
+    /**
+     * Returns a mutable (partial) match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @param pC the fixed value of pattern parameter c, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static Committer.Match newMutableMatch(final Commit pC, final User pU) {
+      return new Mutable(pC, pU);
+    }
+    
+    /**
+     * 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 pC the fixed value of pattern parameter c, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static Committer.Match newMatch(final Commit pC, final User pU) {
+      return new Immutable(pC, pU);
+    }
+    
+    private static final class Mutable extends Committer.Match {
+      Mutable(final Commit pC, final User pU) {
+        super(pC, pU);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends Committer.Match {
+      Immutable(final Commit pC, final User pU) {
+        super(pC, pU);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the queries.committer 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 actionWithIssue(i: IssueEvent, a: Action) {
+   * // IssueEvent.action(i, a);
+   * //}
+   * //
+   * //{@literal @}Constraint(key={i}, severity="error", message="error")
+   * //pattern issueEventNoAction(i: IssueEvent) {
+   * // neg find actionWithIssue(i, _);
+   * //}
+   * 
+   * 
+   * pattern committer(c: Commit, u:User) {
+   *    Commit.committer(c, u);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see Committer
+   * 
+   */
+  public static class Matcher extends BaseMatcher<Committer.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 Committer.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 Committer.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_C = 0;
+    
+    private static final int POSITION_U = 1;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(Committer.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 pC the fixed value of pattern parameter c, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<Committer.Match> getAllMatches(final Commit pC, final User pU) {
+      return rawStreamAllMatches(new Object[]{pC, pU}).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 pC the fixed value of pattern parameter c, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<Committer.Match> streamAllMatches(final Commit pC, final User pU) {
+      return rawStreamAllMatches(new Object[]{pC, pU});
+    }
+    
+    /**
+     * 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 pC the fixed value of pattern parameter c, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<Committer.Match> getOneArbitraryMatch(final Commit pC, final User pU) {
+      return rawGetOneArbitraryMatch(new Object[]{pC, pU});
+    }
+    
+    /**
+     * 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 pC the fixed value of pattern parameter c, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Commit pC, final User pU) {
+      return rawHasMatch(new Object[]{pC, pU});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pC the fixed value of pattern parameter c, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Commit pC, final User pU) {
+      return rawCountMatches(new Object[]{pC, pU});
+    }
+    
+    /**
+     * 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 pC the fixed value of pattern parameter c, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, 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 Commit pC, final User pU, final Consumer<? super Committer.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pC, pU}, 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 pC the fixed value of pattern parameter c, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public Committer.Match newMatch(final Commit pC, final User pU) {
+      return Committer.Match.newMatch(pC, pU);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for c.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Commit> rawStreamAllValuesOfc(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_C, parameters).map(Commit.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for c.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Commit> getAllValuesOfc() {
+      return rawStreamAllValuesOfc(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for c.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Commit> streamAllValuesOfc() {
+      return rawStreamAllValuesOfc(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for c.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Commit> streamAllValuesOfc(final Committer.Match partialMatch) {
+      return rawStreamAllValuesOfc(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for c.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Commit> streamAllValuesOfc(final User pU) {
+      return rawStreamAllValuesOfc(new Object[]{null, pU});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for c.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Commit> getAllValuesOfc(final Committer.Match partialMatch) {
+      return rawStreamAllValuesOfc(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for c.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Commit> getAllValuesOfc(final User pU) {
+      return rawStreamAllValuesOfc(new Object[]{null, pU}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<User> rawStreamAllValuesOfu(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_U, parameters).map(User.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu() {
+      return rawStreamAllValuesOfu(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu() {
+      return rawStreamAllValuesOfu(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu(final Committer.Match partialMatch) {
+      return rawStreamAllValuesOfu(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu(final Commit pC) {
+      return rawStreamAllValuesOfu(new Object[]{pC, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu(final Committer.Match partialMatch) {
+      return rawStreamAllValuesOfu(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu(final Commit pC) {
+      return rawStreamAllValuesOfu(new Object[]{pC, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected Committer.Match tupleToMatch(final Tuple t) {
+      try {
+          return Committer.Match.newMatch((Commit) t.get(POSITION_C), (User) t.get(POSITION_U));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected Committer.Match arrayToMatch(final Object[] match) {
+      try {
+          return Committer.Match.newMatch((Commit) match[POSITION_C], (User) match[POSITION_U]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected Committer.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return Committer.Match.newMutableMatch((Commit) match[POSITION_C], (User) match[POSITION_U]);
+      } 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<Committer.Matcher> querySpecification() {
+      return Committer.instance();
+    }
+  }
+  
+  private Committer() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static Committer instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected Committer.Matcher instantiate(final ViatraQueryEngine engine) {
+    return Committer.Matcher.on(engine);
+  }
+  
+  @Override
+  public Committer.Matcher instantiate() {
+    return Committer.Matcher.create();
+  }
+  
+  @Override
+  public Committer.Match newEmptyMatch() {
+    return Committer.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public Committer.Match newMatch(final Object... parameters) {
+    return Committer.Match.newMatch((github.Commit) parameters[0], (github.User) parameters[1]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link Committer} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link Committer#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final Committer INSTANCE = new Committer();
+    
+    /**
+     * 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 static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final Committer.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_c = new PParameter("c", "github.Commit", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "Commit")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_u = new PParameter("u", "github.User", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "User")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_c, parameter_u);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "queries.committer";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("c","u");
+    }
+    
+    @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_c = body.getOrCreateVariableByName("c");
+          PVariable var_u = body.getOrCreateVariableByName("u");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_c), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Commit")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_u), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "User")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_c, parameter_c),
+             new ExportedParameter(body, var_u, parameter_u)
+          ));
+          //    Commit.committer(c, u)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_c), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Commit")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_c, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("sure.ghtorrent.github", "Commit", "committer")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "User")));
+          new Equality(body, var__virtual_0_, var_u);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/github-graph/src-gen/queries/ConsecutiveClosesWithoutReopen.java b/Domains/github-graph/src-gen/queries/ConsecutiveClosesWithoutReopen.java
new file mode 100644
index 00000000..9072feaf
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/ConsecutiveClosesWithoutReopen.java
@@ -0,0 +1,602 @@
+/**
+ * Generated from platform:/resource/github-graph/queries/queries/github.vql
+ */
+package queries;
+
+import github.Issue;
+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.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+import queries.CheckAction;
+import queries.IsReopen;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         //pattern pullRequestOfIssue(i: Issue, pr: PullRequest) {
+ *         //   Issue.pullrequest(i, pr);
+ *         //}
+ *         //
+ *         //{@literal @}Constraint(key={i}, severity="error", message="error")
+ *         //pattern mergedIssueWithoutPr(i: Issue){
+ *         //   find checkAction(i, _, Action::MERGED);
+ *         //   neg find pullRequestOfIssue(i, _);
+ *         //}
+ *         
+ *         {@literal @}Constraint(key={i}, severity="error", message="error")
+ *         pattern consecutiveClosesWithoutReopen(i: Issue) {
+ *              find checkAction(i, a1, Action::CLOSED);
+ *              find checkAction(i, a2, Action::CLOSED);
+ *              a1 != a2;
+ *              neg find isReopen(i, _);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class ConsecutiveClosesWithoutReopen extends BaseGeneratedEMFQuerySpecification<ConsecutiveClosesWithoutReopen.Matcher> {
+  /**
+   * Pattern-specific match representation of the queries.consecutiveClosesWithoutReopen 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 Issue fI;
+    
+    private static List<String> parameterNames = makeImmutableList("i");
+    
+    private Match(final Issue pI) {
+      this.fI = pI;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "i": return this.fI;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fI;
+          default: return null;
+      }
+    }
+    
+    public Issue getI() {
+      return this.fI;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("i".equals(parameterName) ) {
+          this.fI = (Issue) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setI(final Issue pI) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fI = pI;
+    }
+    
+    @Override
+    public String patternName() {
+      return "queries.consecutiveClosesWithoutReopen";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return ConsecutiveClosesWithoutReopen.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fI};
+    }
+    
+    @Override
+    public ConsecutiveClosesWithoutReopen.Match toImmutable() {
+      return isMutable() ? newMatch(fI) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"i\"=" + prettyPrintValue(fI));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fI);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof ConsecutiveClosesWithoutReopen.Match)) {
+          ConsecutiveClosesWithoutReopen.Match other = (ConsecutiveClosesWithoutReopen.Match) obj;
+          return Objects.equals(fI, other.fI);
+      } 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 ConsecutiveClosesWithoutReopen specification() {
+      return ConsecutiveClosesWithoutReopen.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 ConsecutiveClosesWithoutReopen.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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static ConsecutiveClosesWithoutReopen.Match newMutableMatch(final Issue pI) {
+      return new Mutable(pI);
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static ConsecutiveClosesWithoutReopen.Match newMatch(final Issue pI) {
+      return new Immutable(pI);
+    }
+    
+    private static final class Mutable extends ConsecutiveClosesWithoutReopen.Match {
+      Mutable(final Issue pI) {
+        super(pI);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends ConsecutiveClosesWithoutReopen.Match {
+      Immutable(final Issue pI) {
+        super(pI);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the queries.consecutiveClosesWithoutReopen 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 pullRequestOfIssue(i: Issue, pr: PullRequest) {
+   * // Issue.pullrequest(i, pr);
+   * //}
+   * //
+   * //{@literal @}Constraint(key={i}, severity="error", message="error")
+   * //pattern mergedIssueWithoutPr(i: Issue){
+   * // find checkAction(i, _, Action::MERGED);
+   * // neg find pullRequestOfIssue(i, _);
+   * //}
+   * 
+   * {@literal @}Constraint(key={i}, severity="error", message="error")
+   * pattern consecutiveClosesWithoutReopen(i: Issue) {
+   *    find checkAction(i, a1, Action::CLOSED);
+   *    find checkAction(i, a2, Action::CLOSED);
+   *    a1 != a2;
+   *    neg find isReopen(i, _);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see ConsecutiveClosesWithoutReopen
+   * 
+   */
+  public static class Matcher extends BaseMatcher<ConsecutiveClosesWithoutReopen.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 ConsecutiveClosesWithoutReopen.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 ConsecutiveClosesWithoutReopen.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_I = 0;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(ConsecutiveClosesWithoutReopen.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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<ConsecutiveClosesWithoutReopen.Match> getAllMatches(final Issue pI) {
+      return rawStreamAllMatches(new Object[]{pI}).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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<ConsecutiveClosesWithoutReopen.Match> streamAllMatches(final Issue pI) {
+      return rawStreamAllMatches(new Object[]{pI});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<ConsecutiveClosesWithoutReopen.Match> getOneArbitraryMatch(final Issue pI) {
+      return rawGetOneArbitraryMatch(new Object[]{pI});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Issue pI) {
+      return rawHasMatch(new Object[]{pI});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Issue pI) {
+      return rawCountMatches(new Object[]{pI});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, 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 Issue pI, final Consumer<? super ConsecutiveClosesWithoutReopen.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pI}, 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public ConsecutiveClosesWithoutReopen.Match newMatch(final Issue pI) {
+      return ConsecutiveClosesWithoutReopen.Match.newMatch(pI);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Issue> rawStreamAllValuesOfi(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_I, parameters).map(Issue.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray());
+    }
+    
+    @Override
+    protected ConsecutiveClosesWithoutReopen.Match tupleToMatch(final Tuple t) {
+      try {
+          return ConsecutiveClosesWithoutReopen.Match.newMatch((Issue) t.get(POSITION_I));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected ConsecutiveClosesWithoutReopen.Match arrayToMatch(final Object[] match) {
+      try {
+          return ConsecutiveClosesWithoutReopen.Match.newMatch((Issue) match[POSITION_I]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected ConsecutiveClosesWithoutReopen.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return ConsecutiveClosesWithoutReopen.Match.newMutableMatch((Issue) match[POSITION_I]);
+      } 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<ConsecutiveClosesWithoutReopen.Matcher> querySpecification() {
+      return ConsecutiveClosesWithoutReopen.instance();
+    }
+  }
+  
+  private ConsecutiveClosesWithoutReopen() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static ConsecutiveClosesWithoutReopen instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected ConsecutiveClosesWithoutReopen.Matcher instantiate(final ViatraQueryEngine engine) {
+    return ConsecutiveClosesWithoutReopen.Matcher.on(engine);
+  }
+  
+  @Override
+  public ConsecutiveClosesWithoutReopen.Matcher instantiate() {
+    return ConsecutiveClosesWithoutReopen.Matcher.create();
+  }
+  
+  @Override
+  public ConsecutiveClosesWithoutReopen.Match newEmptyMatch() {
+    return ConsecutiveClosesWithoutReopen.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public ConsecutiveClosesWithoutReopen.Match newMatch(final Object... parameters) {
+    return ConsecutiveClosesWithoutReopen.Match.newMatch((github.Issue) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link ConsecutiveClosesWithoutReopen} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link ConsecutiveClosesWithoutReopen#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final ConsecutiveClosesWithoutReopen INSTANCE = new ConsecutiveClosesWithoutReopen();
+    
+    /**
+     * 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 static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final ConsecutiveClosesWithoutReopen.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_i = new PParameter("i", "github.Issue", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "Issue")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_i);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "queries.consecutiveClosesWithoutReopen";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("i");
+    }
+    
+    @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_i = body.getOrCreateVariableByName("i");
+          PVariable var_a1 = body.getOrCreateVariableByName("a1");
+          PVariable var_a2 = body.getOrCreateVariableByName("a2");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Issue")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_i, parameter_i)
+          ));
+          //    find checkAction(i, a1, Action::CLOSED)
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new ConstantValue(body, var__virtual_0_, getEnumLiteral("sure.ghtorrent.github", "Action", "CLOSED").getInstance());
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_i, var_a1, var__virtual_0_), CheckAction.instance().getInternalQueryRepresentation());
+          //    find checkAction(i, a2, Action::CLOSED)
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new ConstantValue(body, var__virtual_1_, getEnumLiteral("sure.ghtorrent.github", "Action", "CLOSED").getInstance());
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_i, var_a2, var__virtual_1_), CheckAction.instance().getInternalQueryRepresentation());
+          //    a1 != a2
+          new Inequality(body, var_a1, var_a2);
+          //    neg find isReopen(i, _)
+          new NegativePatternCall(body, Tuples.flatTupleOf(var_i, var___0_), IsReopen.instance().getInternalQueryRepresentation());
+          bodies.add(body);
+      }
+      {
+          PAnnotation annotation = new PAnnotation("Constraint");
+          annotation.addAttribute("key", Arrays.asList(new Object[] {
+                              new ParameterReference("i")
+                              }));
+          annotation.addAttribute("severity", "error");
+          annotation.addAttribute("message", "error");
+          addAnnotation(annotation);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/github-graph/src-gen/queries/ConsecutiveReopensWithoutClose.java b/Domains/github-graph/src-gen/queries/ConsecutiveReopensWithoutClose.java
new file mode 100644
index 00000000..992c1a72
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/ConsecutiveReopensWithoutClose.java
@@ -0,0 +1,582 @@
+/**
+ * Generated from platform:/resource/github-graph/queries/queries/github.vql
+ */
+package queries;
+
+import github.Issue;
+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.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+import queries.CheckAction;
+import queries.IsClose;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         {@literal @}Constraint(key={i}, severity="error", message="error")
+ *         pattern consecutiveReopensWithoutClose(i: Issue) {
+ *              find checkAction(i, a1, Action::REOPENED);
+ *              find checkAction(i, a2, Action::REOPENED);
+ *              a1 != a2;
+ *              neg find isClose(i, _);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class ConsecutiveReopensWithoutClose extends BaseGeneratedEMFQuerySpecification<ConsecutiveReopensWithoutClose.Matcher> {
+  /**
+   * Pattern-specific match representation of the queries.consecutiveReopensWithoutClose 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 Issue fI;
+    
+    private static List<String> parameterNames = makeImmutableList("i");
+    
+    private Match(final Issue pI) {
+      this.fI = pI;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "i": return this.fI;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fI;
+          default: return null;
+      }
+    }
+    
+    public Issue getI() {
+      return this.fI;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("i".equals(parameterName) ) {
+          this.fI = (Issue) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setI(final Issue pI) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fI = pI;
+    }
+    
+    @Override
+    public String patternName() {
+      return "queries.consecutiveReopensWithoutClose";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return ConsecutiveReopensWithoutClose.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fI};
+    }
+    
+    @Override
+    public ConsecutiveReopensWithoutClose.Match toImmutable() {
+      return isMutable() ? newMatch(fI) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"i\"=" + prettyPrintValue(fI));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fI);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof ConsecutiveReopensWithoutClose.Match)) {
+          ConsecutiveReopensWithoutClose.Match other = (ConsecutiveReopensWithoutClose.Match) obj;
+          return Objects.equals(fI, other.fI);
+      } 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 ConsecutiveReopensWithoutClose specification() {
+      return ConsecutiveReopensWithoutClose.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 ConsecutiveReopensWithoutClose.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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static ConsecutiveReopensWithoutClose.Match newMutableMatch(final Issue pI) {
+      return new Mutable(pI);
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static ConsecutiveReopensWithoutClose.Match newMatch(final Issue pI) {
+      return new Immutable(pI);
+    }
+    
+    private static final class Mutable extends ConsecutiveReopensWithoutClose.Match {
+      Mutable(final Issue pI) {
+        super(pI);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends ConsecutiveReopensWithoutClose.Match {
+      Immutable(final Issue pI) {
+        super(pI);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the queries.consecutiveReopensWithoutClose pattern,
+   * providing pattern-specific query methods.
+   * 
+   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+   * 
+   * <p>Matches of the pattern will be represented as {@link Match}.
+   * 
+   * <p>Original source:
+   * <code><pre>
+   * {@literal @}Constraint(key={i}, severity="error", message="error")
+   * pattern consecutiveReopensWithoutClose(i: Issue) {
+   *    find checkAction(i, a1, Action::REOPENED);
+   *    find checkAction(i, a2, Action::REOPENED);
+   *    a1 != a2;
+   *    neg find isClose(i, _);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see ConsecutiveReopensWithoutClose
+   * 
+   */
+  public static class Matcher extends BaseMatcher<ConsecutiveReopensWithoutClose.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 ConsecutiveReopensWithoutClose.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 ConsecutiveReopensWithoutClose.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_I = 0;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(ConsecutiveReopensWithoutClose.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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<ConsecutiveReopensWithoutClose.Match> getAllMatches(final Issue pI) {
+      return rawStreamAllMatches(new Object[]{pI}).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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<ConsecutiveReopensWithoutClose.Match> streamAllMatches(final Issue pI) {
+      return rawStreamAllMatches(new Object[]{pI});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<ConsecutiveReopensWithoutClose.Match> getOneArbitraryMatch(final Issue pI) {
+      return rawGetOneArbitraryMatch(new Object[]{pI});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Issue pI) {
+      return rawHasMatch(new Object[]{pI});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Issue pI) {
+      return rawCountMatches(new Object[]{pI});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, 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 Issue pI, final Consumer<? super ConsecutiveReopensWithoutClose.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pI}, 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public ConsecutiveReopensWithoutClose.Match newMatch(final Issue pI) {
+      return ConsecutiveReopensWithoutClose.Match.newMatch(pI);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Issue> rawStreamAllValuesOfi(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_I, parameters).map(Issue.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray());
+    }
+    
+    @Override
+    protected ConsecutiveReopensWithoutClose.Match tupleToMatch(final Tuple t) {
+      try {
+          return ConsecutiveReopensWithoutClose.Match.newMatch((Issue) t.get(POSITION_I));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected ConsecutiveReopensWithoutClose.Match arrayToMatch(final Object[] match) {
+      try {
+          return ConsecutiveReopensWithoutClose.Match.newMatch((Issue) match[POSITION_I]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected ConsecutiveReopensWithoutClose.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return ConsecutiveReopensWithoutClose.Match.newMutableMatch((Issue) match[POSITION_I]);
+      } 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<ConsecutiveReopensWithoutClose.Matcher> querySpecification() {
+      return ConsecutiveReopensWithoutClose.instance();
+    }
+  }
+  
+  private ConsecutiveReopensWithoutClose() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static ConsecutiveReopensWithoutClose instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected ConsecutiveReopensWithoutClose.Matcher instantiate(final ViatraQueryEngine engine) {
+    return ConsecutiveReopensWithoutClose.Matcher.on(engine);
+  }
+  
+  @Override
+  public ConsecutiveReopensWithoutClose.Matcher instantiate() {
+    return ConsecutiveReopensWithoutClose.Matcher.create();
+  }
+  
+  @Override
+  public ConsecutiveReopensWithoutClose.Match newEmptyMatch() {
+    return ConsecutiveReopensWithoutClose.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public ConsecutiveReopensWithoutClose.Match newMatch(final Object... parameters) {
+    return ConsecutiveReopensWithoutClose.Match.newMatch((github.Issue) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link ConsecutiveReopensWithoutClose} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link ConsecutiveReopensWithoutClose#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final ConsecutiveReopensWithoutClose INSTANCE = new ConsecutiveReopensWithoutClose();
+    
+    /**
+     * 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 static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final ConsecutiveReopensWithoutClose.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_i = new PParameter("i", "github.Issue", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "Issue")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_i);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "queries.consecutiveReopensWithoutClose";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("i");
+    }
+    
+    @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_i = body.getOrCreateVariableByName("i");
+          PVariable var_a1 = body.getOrCreateVariableByName("a1");
+          PVariable var_a2 = body.getOrCreateVariableByName("a2");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Issue")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_i, parameter_i)
+          ));
+          //    find checkAction(i, a1, Action::REOPENED)
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new ConstantValue(body, var__virtual_0_, getEnumLiteral("sure.ghtorrent.github", "Action", "REOPENED").getInstance());
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_i, var_a1, var__virtual_0_), CheckAction.instance().getInternalQueryRepresentation());
+          //    find checkAction(i, a2, Action::REOPENED)
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new ConstantValue(body, var__virtual_1_, getEnumLiteral("sure.ghtorrent.github", "Action", "REOPENED").getInstance());
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_i, var_a2, var__virtual_1_), CheckAction.instance().getInternalQueryRepresentation());
+          //    a1 != a2
+          new Inequality(body, var_a1, var_a2);
+          //    neg find isClose(i, _)
+          new NegativePatternCall(body, Tuples.flatTupleOf(var_i, var___0_), IsClose.instance().getInternalQueryRepresentation());
+          bodies.add(body);
+      }
+      {
+          PAnnotation annotation = new PAnnotation("Constraint");
+          annotation.addAttribute("key", Arrays.asList(new Object[] {
+                              new ParameterReference("i")
+                              }));
+          annotation.addAttribute("severity", "error");
+          annotation.addAttribute("message", "error");
+          addAnnotation(annotation);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/github-graph/src-gen/queries/ConsecutiveSubWithoutUnSub.java b/Domains/github-graph/src-gen/queries/ConsecutiveSubWithoutUnSub.java
new file mode 100644
index 00000000..a3820a80
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/ConsecutiveSubWithoutUnSub.java
@@ -0,0 +1,738 @@
+/**
+ * Generated from platform:/resource/github-graph/queries/queries/github.vql
+ */
+package queries;
+
+import github.Issue;
+import github.User;
+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.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+import queries.CheckUserAction;
+import queries.IsUnSubscribe;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         {@literal @}Constraint(key={i, u}, severity="error", message="error")
+ *         pattern consecutiveSubWithoutUnSub(i: Issue, u: User) {
+ *              find checkUserAction(i, u, a1, Action::SUBSCRIBED);
+ *              find checkUserAction(i, u, a2, Action::SUBSCRIBED);
+ *              a1 != a2;
+ *              neg find isUnSubscribe(i, u, _);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class ConsecutiveSubWithoutUnSub extends BaseGeneratedEMFQuerySpecification<ConsecutiveSubWithoutUnSub.Matcher> {
+  /**
+   * Pattern-specific match representation of the queries.consecutiveSubWithoutUnSub 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 Issue fI;
+    
+    private User fU;
+    
+    private static List<String> parameterNames = makeImmutableList("i", "u");
+    
+    private Match(final Issue pI, final User pU) {
+      this.fI = pI;
+      this.fU = pU;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "i": return this.fI;
+          case "u": return this.fU;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fI;
+          case 1: return this.fU;
+          default: return null;
+      }
+    }
+    
+    public Issue getI() {
+      return this.fI;
+    }
+    
+    public User getU() {
+      return this.fU;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("i".equals(parameterName) ) {
+          this.fI = (Issue) newValue;
+          return true;
+      }
+      if ("u".equals(parameterName) ) {
+          this.fU = (User) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setI(final Issue pI) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fI = pI;
+    }
+    
+    public void setU(final User pU) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fU = pU;
+    }
+    
+    @Override
+    public String patternName() {
+      return "queries.consecutiveSubWithoutUnSub";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return ConsecutiveSubWithoutUnSub.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fI, fU};
+    }
+    
+    @Override
+    public ConsecutiveSubWithoutUnSub.Match toImmutable() {
+      return isMutable() ? newMatch(fI, fU) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"i\"=" + prettyPrintValue(fI) + ", ");
+      result.append("\"u\"=" + prettyPrintValue(fU));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fI, fU);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof ConsecutiveSubWithoutUnSub.Match)) {
+          ConsecutiveSubWithoutUnSub.Match other = (ConsecutiveSubWithoutUnSub.Match) obj;
+          return Objects.equals(fI, other.fI) && Objects.equals(fU, other.fU);
+      } 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 ConsecutiveSubWithoutUnSub specification() {
+      return ConsecutiveSubWithoutUnSub.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 ConsecutiveSubWithoutUnSub.Match newEmptyMatch() {
+      return new Mutable(null, null);
+    }
+    
+    /**
+     * Returns a mutable (partial) match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static ConsecutiveSubWithoutUnSub.Match newMutableMatch(final Issue pI, final User pU) {
+      return new Mutable(pI, pU);
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static ConsecutiveSubWithoutUnSub.Match newMatch(final Issue pI, final User pU) {
+      return new Immutable(pI, pU);
+    }
+    
+    private static final class Mutable extends ConsecutiveSubWithoutUnSub.Match {
+      Mutable(final Issue pI, final User pU) {
+        super(pI, pU);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends ConsecutiveSubWithoutUnSub.Match {
+      Immutable(final Issue pI, final User pU) {
+        super(pI, pU);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the queries.consecutiveSubWithoutUnSub pattern,
+   * providing pattern-specific query methods.
+   * 
+   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+   * 
+   * <p>Matches of the pattern will be represented as {@link Match}.
+   * 
+   * <p>Original source:
+   * <code><pre>
+   * {@literal @}Constraint(key={i, u}, severity="error", message="error")
+   * pattern consecutiveSubWithoutUnSub(i: Issue, u: User) {
+   *    find checkUserAction(i, u, a1, Action::SUBSCRIBED);
+   *    find checkUserAction(i, u, a2, Action::SUBSCRIBED);
+   *    a1 != a2;
+   *    neg find isUnSubscribe(i, u, _);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see ConsecutiveSubWithoutUnSub
+   * 
+   */
+  public static class Matcher extends BaseMatcher<ConsecutiveSubWithoutUnSub.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 ConsecutiveSubWithoutUnSub.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 ConsecutiveSubWithoutUnSub.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_I = 0;
+    
+    private static final int POSITION_U = 1;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(ConsecutiveSubWithoutUnSub.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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<ConsecutiveSubWithoutUnSub.Match> getAllMatches(final Issue pI, final User pU) {
+      return rawStreamAllMatches(new Object[]{pI, pU}).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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<ConsecutiveSubWithoutUnSub.Match> streamAllMatches(final Issue pI, final User pU) {
+      return rawStreamAllMatches(new Object[]{pI, pU});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<ConsecutiveSubWithoutUnSub.Match> getOneArbitraryMatch(final Issue pI, final User pU) {
+      return rawGetOneArbitraryMatch(new Object[]{pI, pU});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Issue pI, final User pU) {
+      return rawHasMatch(new Object[]{pI, pU});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Issue pI, final User pU) {
+      return rawCountMatches(new Object[]{pI, pU});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, 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 Issue pI, final User pU, final Consumer<? super ConsecutiveSubWithoutUnSub.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pI, pU}, 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public ConsecutiveSubWithoutUnSub.Match newMatch(final Issue pI, final User pU) {
+      return ConsecutiveSubWithoutUnSub.Match.newMatch(pI, pU);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Issue> rawStreamAllValuesOfi(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_I, parameters).map(Issue.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi(final ConsecutiveSubWithoutUnSub.Match partialMatch) {
+      return rawStreamAllValuesOfi(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi(final User pU) {
+      return rawStreamAllValuesOfi(new Object[]{null, pU});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi(final ConsecutiveSubWithoutUnSub.Match partialMatch) {
+      return rawStreamAllValuesOfi(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi(final User pU) {
+      return rawStreamAllValuesOfi(new Object[]{null, pU}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<User> rawStreamAllValuesOfu(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_U, parameters).map(User.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu() {
+      return rawStreamAllValuesOfu(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu() {
+      return rawStreamAllValuesOfu(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu(final ConsecutiveSubWithoutUnSub.Match partialMatch) {
+      return rawStreamAllValuesOfu(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu(final Issue pI) {
+      return rawStreamAllValuesOfu(new Object[]{pI, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu(final ConsecutiveSubWithoutUnSub.Match partialMatch) {
+      return rawStreamAllValuesOfu(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu(final Issue pI) {
+      return rawStreamAllValuesOfu(new Object[]{pI, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected ConsecutiveSubWithoutUnSub.Match tupleToMatch(final Tuple t) {
+      try {
+          return ConsecutiveSubWithoutUnSub.Match.newMatch((Issue) t.get(POSITION_I), (User) t.get(POSITION_U));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected ConsecutiveSubWithoutUnSub.Match arrayToMatch(final Object[] match) {
+      try {
+          return ConsecutiveSubWithoutUnSub.Match.newMatch((Issue) match[POSITION_I], (User) match[POSITION_U]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected ConsecutiveSubWithoutUnSub.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return ConsecutiveSubWithoutUnSub.Match.newMutableMatch((Issue) match[POSITION_I], (User) match[POSITION_U]);
+      } 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<ConsecutiveSubWithoutUnSub.Matcher> querySpecification() {
+      return ConsecutiveSubWithoutUnSub.instance();
+    }
+  }
+  
+  private ConsecutiveSubWithoutUnSub() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static ConsecutiveSubWithoutUnSub instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected ConsecutiveSubWithoutUnSub.Matcher instantiate(final ViatraQueryEngine engine) {
+    return ConsecutiveSubWithoutUnSub.Matcher.on(engine);
+  }
+  
+  @Override
+  public ConsecutiveSubWithoutUnSub.Matcher instantiate() {
+    return ConsecutiveSubWithoutUnSub.Matcher.create();
+  }
+  
+  @Override
+  public ConsecutiveSubWithoutUnSub.Match newEmptyMatch() {
+    return ConsecutiveSubWithoutUnSub.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public ConsecutiveSubWithoutUnSub.Match newMatch(final Object... parameters) {
+    return ConsecutiveSubWithoutUnSub.Match.newMatch((github.Issue) parameters[0], (github.User) parameters[1]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link ConsecutiveSubWithoutUnSub} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link ConsecutiveSubWithoutUnSub#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final ConsecutiveSubWithoutUnSub INSTANCE = new ConsecutiveSubWithoutUnSub();
+    
+    /**
+     * 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 static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final ConsecutiveSubWithoutUnSub.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_i = new PParameter("i", "github.Issue", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "Issue")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_u = new PParameter("u", "github.User", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "User")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_i, parameter_u);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "queries.consecutiveSubWithoutUnSub";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("i","u");
+    }
+    
+    @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_i = body.getOrCreateVariableByName("i");
+          PVariable var_u = body.getOrCreateVariableByName("u");
+          PVariable var_a1 = body.getOrCreateVariableByName("a1");
+          PVariable var_a2 = body.getOrCreateVariableByName("a2");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Issue")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_u), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "User")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_i, parameter_i),
+             new ExportedParameter(body, var_u, parameter_u)
+          ));
+          //    find checkUserAction(i, u, a1, Action::SUBSCRIBED)
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new ConstantValue(body, var__virtual_0_, getEnumLiteral("sure.ghtorrent.github", "Action", "SUBSCRIBED").getInstance());
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_i, var_u, var_a1, var__virtual_0_), CheckUserAction.instance().getInternalQueryRepresentation());
+          //    find checkUserAction(i, u, a2, Action::SUBSCRIBED)
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new ConstantValue(body, var__virtual_1_, getEnumLiteral("sure.ghtorrent.github", "Action", "SUBSCRIBED").getInstance());
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_i, var_u, var_a2, var__virtual_1_), CheckUserAction.instance().getInternalQueryRepresentation());
+          //    a1 != a2
+          new Inequality(body, var_a1, var_a2);
+          //    neg find isUnSubscribe(i, u, _)
+          new NegativePatternCall(body, Tuples.flatTupleOf(var_i, var_u, var___0_), IsUnSubscribe.instance().getInternalQueryRepresentation());
+          bodies.add(body);
+      }
+      {
+          PAnnotation annotation = new PAnnotation("Constraint");
+          annotation.addAttribute("key", Arrays.asList(new Object[] {
+                              new ParameterReference("i"), 
+                              new ParameterReference("u")
+                              }));
+          annotation.addAttribute("severity", "error");
+          annotation.addAttribute("message", "error");
+          addAnnotation(annotation);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/github-graph/src-gen/queries/ConsecutiveUnSubWithoutSub.java b/Domains/github-graph/src-gen/queries/ConsecutiveUnSubWithoutSub.java
new file mode 100644
index 00000000..492e2c76
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/ConsecutiveUnSubWithoutSub.java
@@ -0,0 +1,738 @@
+/**
+ * Generated from platform:/resource/github-graph/queries/queries/github.vql
+ */
+package queries;
+
+import github.Issue;
+import github.User;
+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.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+import queries.CheckUserAction;
+import queries.IsSubscribe;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         {@literal @}Constraint(key={i, u}, severity="error", message="error")
+ *         pattern consecutiveUnSubWithoutSub(i: Issue, u: User) {
+ *              find checkUserAction(i, u, a1, Action::UNSUBSCRIBED);
+ *              find checkUserAction(i, u, a2, Action::UNSUBSCRIBED);
+ *              a1 != a2;
+ *              neg find isSubscribe(i, u, _);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class ConsecutiveUnSubWithoutSub extends BaseGeneratedEMFQuerySpecification<ConsecutiveUnSubWithoutSub.Matcher> {
+  /**
+   * Pattern-specific match representation of the queries.consecutiveUnSubWithoutSub 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 Issue fI;
+    
+    private User fU;
+    
+    private static List<String> parameterNames = makeImmutableList("i", "u");
+    
+    private Match(final Issue pI, final User pU) {
+      this.fI = pI;
+      this.fU = pU;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "i": return this.fI;
+          case "u": return this.fU;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fI;
+          case 1: return this.fU;
+          default: return null;
+      }
+    }
+    
+    public Issue getI() {
+      return this.fI;
+    }
+    
+    public User getU() {
+      return this.fU;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("i".equals(parameterName) ) {
+          this.fI = (Issue) newValue;
+          return true;
+      }
+      if ("u".equals(parameterName) ) {
+          this.fU = (User) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setI(final Issue pI) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fI = pI;
+    }
+    
+    public void setU(final User pU) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fU = pU;
+    }
+    
+    @Override
+    public String patternName() {
+      return "queries.consecutiveUnSubWithoutSub";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return ConsecutiveUnSubWithoutSub.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fI, fU};
+    }
+    
+    @Override
+    public ConsecutiveUnSubWithoutSub.Match toImmutable() {
+      return isMutable() ? newMatch(fI, fU) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"i\"=" + prettyPrintValue(fI) + ", ");
+      result.append("\"u\"=" + prettyPrintValue(fU));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fI, fU);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof ConsecutiveUnSubWithoutSub.Match)) {
+          ConsecutiveUnSubWithoutSub.Match other = (ConsecutiveUnSubWithoutSub.Match) obj;
+          return Objects.equals(fI, other.fI) && Objects.equals(fU, other.fU);
+      } 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 ConsecutiveUnSubWithoutSub specification() {
+      return ConsecutiveUnSubWithoutSub.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 ConsecutiveUnSubWithoutSub.Match newEmptyMatch() {
+      return new Mutable(null, null);
+    }
+    
+    /**
+     * Returns a mutable (partial) match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static ConsecutiveUnSubWithoutSub.Match newMutableMatch(final Issue pI, final User pU) {
+      return new Mutable(pI, pU);
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static ConsecutiveUnSubWithoutSub.Match newMatch(final Issue pI, final User pU) {
+      return new Immutable(pI, pU);
+    }
+    
+    private static final class Mutable extends ConsecutiveUnSubWithoutSub.Match {
+      Mutable(final Issue pI, final User pU) {
+        super(pI, pU);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends ConsecutiveUnSubWithoutSub.Match {
+      Immutable(final Issue pI, final User pU) {
+        super(pI, pU);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the queries.consecutiveUnSubWithoutSub pattern,
+   * providing pattern-specific query methods.
+   * 
+   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+   * 
+   * <p>Matches of the pattern will be represented as {@link Match}.
+   * 
+   * <p>Original source:
+   * <code><pre>
+   * {@literal @}Constraint(key={i, u}, severity="error", message="error")
+   * pattern consecutiveUnSubWithoutSub(i: Issue, u: User) {
+   *    find checkUserAction(i, u, a1, Action::UNSUBSCRIBED);
+   *    find checkUserAction(i, u, a2, Action::UNSUBSCRIBED);
+   *    a1 != a2;
+   *    neg find isSubscribe(i, u, _);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see ConsecutiveUnSubWithoutSub
+   * 
+   */
+  public static class Matcher extends BaseMatcher<ConsecutiveUnSubWithoutSub.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 ConsecutiveUnSubWithoutSub.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 ConsecutiveUnSubWithoutSub.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_I = 0;
+    
+    private static final int POSITION_U = 1;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(ConsecutiveUnSubWithoutSub.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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<ConsecutiveUnSubWithoutSub.Match> getAllMatches(final Issue pI, final User pU) {
+      return rawStreamAllMatches(new Object[]{pI, pU}).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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<ConsecutiveUnSubWithoutSub.Match> streamAllMatches(final Issue pI, final User pU) {
+      return rawStreamAllMatches(new Object[]{pI, pU});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<ConsecutiveUnSubWithoutSub.Match> getOneArbitraryMatch(final Issue pI, final User pU) {
+      return rawGetOneArbitraryMatch(new Object[]{pI, pU});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Issue pI, final User pU) {
+      return rawHasMatch(new Object[]{pI, pU});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Issue pI, final User pU) {
+      return rawCountMatches(new Object[]{pI, pU});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, 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 Issue pI, final User pU, final Consumer<? super ConsecutiveUnSubWithoutSub.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pI, pU}, 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public ConsecutiveUnSubWithoutSub.Match newMatch(final Issue pI, final User pU) {
+      return ConsecutiveUnSubWithoutSub.Match.newMatch(pI, pU);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Issue> rawStreamAllValuesOfi(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_I, parameters).map(Issue.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi(final ConsecutiveUnSubWithoutSub.Match partialMatch) {
+      return rawStreamAllValuesOfi(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi(final User pU) {
+      return rawStreamAllValuesOfi(new Object[]{null, pU});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi(final ConsecutiveUnSubWithoutSub.Match partialMatch) {
+      return rawStreamAllValuesOfi(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi(final User pU) {
+      return rawStreamAllValuesOfi(new Object[]{null, pU}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<User> rawStreamAllValuesOfu(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_U, parameters).map(User.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu() {
+      return rawStreamAllValuesOfu(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu() {
+      return rawStreamAllValuesOfu(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu(final ConsecutiveUnSubWithoutSub.Match partialMatch) {
+      return rawStreamAllValuesOfu(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu(final Issue pI) {
+      return rawStreamAllValuesOfu(new Object[]{pI, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu(final ConsecutiveUnSubWithoutSub.Match partialMatch) {
+      return rawStreamAllValuesOfu(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu(final Issue pI) {
+      return rawStreamAllValuesOfu(new Object[]{pI, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected ConsecutiveUnSubWithoutSub.Match tupleToMatch(final Tuple t) {
+      try {
+          return ConsecutiveUnSubWithoutSub.Match.newMatch((Issue) t.get(POSITION_I), (User) t.get(POSITION_U));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected ConsecutiveUnSubWithoutSub.Match arrayToMatch(final Object[] match) {
+      try {
+          return ConsecutiveUnSubWithoutSub.Match.newMatch((Issue) match[POSITION_I], (User) match[POSITION_U]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected ConsecutiveUnSubWithoutSub.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return ConsecutiveUnSubWithoutSub.Match.newMutableMatch((Issue) match[POSITION_I], (User) match[POSITION_U]);
+      } 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<ConsecutiveUnSubWithoutSub.Matcher> querySpecification() {
+      return ConsecutiveUnSubWithoutSub.instance();
+    }
+  }
+  
+  private ConsecutiveUnSubWithoutSub() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static ConsecutiveUnSubWithoutSub instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected ConsecutiveUnSubWithoutSub.Matcher instantiate(final ViatraQueryEngine engine) {
+    return ConsecutiveUnSubWithoutSub.Matcher.on(engine);
+  }
+  
+  @Override
+  public ConsecutiveUnSubWithoutSub.Matcher instantiate() {
+    return ConsecutiveUnSubWithoutSub.Matcher.create();
+  }
+  
+  @Override
+  public ConsecutiveUnSubWithoutSub.Match newEmptyMatch() {
+    return ConsecutiveUnSubWithoutSub.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public ConsecutiveUnSubWithoutSub.Match newMatch(final Object... parameters) {
+    return ConsecutiveUnSubWithoutSub.Match.newMatch((github.Issue) parameters[0], (github.User) parameters[1]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link ConsecutiveUnSubWithoutSub} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link ConsecutiveUnSubWithoutSub#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final ConsecutiveUnSubWithoutSub INSTANCE = new ConsecutiveUnSubWithoutSub();
+    
+    /**
+     * 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 static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final ConsecutiveUnSubWithoutSub.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_i = new PParameter("i", "github.Issue", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "Issue")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_u = new PParameter("u", "github.User", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "User")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_i, parameter_u);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "queries.consecutiveUnSubWithoutSub";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("i","u");
+    }
+    
+    @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_i = body.getOrCreateVariableByName("i");
+          PVariable var_u = body.getOrCreateVariableByName("u");
+          PVariable var_a1 = body.getOrCreateVariableByName("a1");
+          PVariable var_a2 = body.getOrCreateVariableByName("a2");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Issue")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_u), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "User")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_i, parameter_i),
+             new ExportedParameter(body, var_u, parameter_u)
+          ));
+          //    find checkUserAction(i, u, a1, Action::UNSUBSCRIBED)
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new ConstantValue(body, var__virtual_0_, getEnumLiteral("sure.ghtorrent.github", "Action", "UNSUBSCRIBED").getInstance());
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_i, var_u, var_a1, var__virtual_0_), CheckUserAction.instance().getInternalQueryRepresentation());
+          //    find checkUserAction(i, u, a2, Action::UNSUBSCRIBED)
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new ConstantValue(body, var__virtual_1_, getEnumLiteral("sure.ghtorrent.github", "Action", "UNSUBSCRIBED").getInstance());
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_i, var_u, var_a2, var__virtual_1_), CheckUserAction.instance().getInternalQueryRepresentation());
+          //    a1 != a2
+          new Inequality(body, var_a1, var_a2);
+          //    neg find isSubscribe(i, u, _)
+          new NegativePatternCall(body, Tuples.flatTupleOf(var_i, var_u, var___0_), IsSubscribe.instance().getInternalQueryRepresentation());
+          bodies.add(body);
+      }
+      {
+          PAnnotation annotation = new PAnnotation("Constraint");
+          annotation.addAttribute("key", Arrays.asList(new Object[] {
+                              new ParameterReference("i"), 
+                              new ParameterReference("u")
+                              }));
+          annotation.addAttribute("severity", "error");
+          annotation.addAttribute("message", "error");
+          addAnnotation(annotation);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/github-graph/src-gen/queries/EventUser.java b/Domains/github-graph/src-gen/queries/EventUser.java
new file mode 100644
index 00000000..6e075c24
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/EventUser.java
@@ -0,0 +1,705 @@
+/**
+ * Generated from platform:/resource/github-graph/queries/queries/github.vql
+ */
+package queries;
+
+import github.IssueEvent;
+import github.User;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         pattern eventUser(e: IssueEvent, u:User){
+ *              IssueEvent.user(e, u);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class EventUser extends BaseGeneratedEMFQuerySpecification<EventUser.Matcher> {
+  /**
+   * Pattern-specific match representation of the queries.eventUser 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 IssueEvent fE;
+    
+    private User fU;
+    
+    private static List<String> parameterNames = makeImmutableList("e", "u");
+    
+    private Match(final IssueEvent pE, final User pU) {
+      this.fE = pE;
+      this.fU = pU;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "e": return this.fE;
+          case "u": return this.fU;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fE;
+          case 1: return this.fU;
+          default: return null;
+      }
+    }
+    
+    public IssueEvent getE() {
+      return this.fE;
+    }
+    
+    public User getU() {
+      return this.fU;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("e".equals(parameterName) ) {
+          this.fE = (IssueEvent) newValue;
+          return true;
+      }
+      if ("u".equals(parameterName) ) {
+          this.fU = (User) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setE(final IssueEvent pE) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fE = pE;
+    }
+    
+    public void setU(final User pU) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fU = pU;
+    }
+    
+    @Override
+    public String patternName() {
+      return "queries.eventUser";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return EventUser.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fE, fU};
+    }
+    
+    @Override
+    public EventUser.Match toImmutable() {
+      return isMutable() ? newMatch(fE, fU) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"e\"=" + prettyPrintValue(fE) + ", ");
+      result.append("\"u\"=" + prettyPrintValue(fU));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fE, fU);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof EventUser.Match)) {
+          EventUser.Match other = (EventUser.Match) obj;
+          return Objects.equals(fE, other.fE) && Objects.equals(fU, other.fU);
+      } 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 EventUser specification() {
+      return EventUser.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 EventUser.Match newEmptyMatch() {
+      return new Mutable(null, null);
+    }
+    
+    /**
+     * Returns a mutable (partial) match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static EventUser.Match newMutableMatch(final IssueEvent pE, final User pU) {
+      return new Mutable(pE, pU);
+    }
+    
+    /**
+     * 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 pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static EventUser.Match newMatch(final IssueEvent pE, final User pU) {
+      return new Immutable(pE, pU);
+    }
+    
+    private static final class Mutable extends EventUser.Match {
+      Mutable(final IssueEvent pE, final User pU) {
+        super(pE, pU);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends EventUser.Match {
+      Immutable(final IssueEvent pE, final User pU) {
+        super(pE, pU);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the queries.eventUser 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 eventUser(e: IssueEvent, u:User){
+   *    IssueEvent.user(e, u);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see EventUser
+   * 
+   */
+  public static class Matcher extends BaseMatcher<EventUser.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 EventUser.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 EventUser.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_E = 0;
+    
+    private static final int POSITION_U = 1;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(EventUser.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 pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<EventUser.Match> getAllMatches(final IssueEvent pE, final User pU) {
+      return rawStreamAllMatches(new Object[]{pE, pU}).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 pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<EventUser.Match> streamAllMatches(final IssueEvent pE, final User pU) {
+      return rawStreamAllMatches(new Object[]{pE, pU});
+    }
+    
+    /**
+     * 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 pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<EventUser.Match> getOneArbitraryMatch(final IssueEvent pE, final User pU) {
+      return rawGetOneArbitraryMatch(new Object[]{pE, pU});
+    }
+    
+    /**
+     * 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 pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final IssueEvent pE, final User pU) {
+      return rawHasMatch(new Object[]{pE, pU});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final IssueEvent pE, final User pU) {
+      return rawCountMatches(new Object[]{pE, pU});
+    }
+    
+    /**
+     * 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 pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, 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 IssueEvent pE, final User pU, final Consumer<? super EventUser.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pE, pU}, 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 pE the fixed value of pattern parameter e, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public EventUser.Match newMatch(final IssueEvent pE, final User pU) {
+      return EventUser.Match.newMatch(pE, pU);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<IssueEvent> rawStreamAllValuesOfe(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_E, parameters).map(IssueEvent.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe() {
+      return rawStreamAllValuesOfe(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe() {
+      return rawStreamAllValuesOfe(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe(final EventUser.Match partialMatch) {
+      return rawStreamAllValuesOfe(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe(final User pU) {
+      return rawStreamAllValuesOfe(new Object[]{null, pU});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe(final EventUser.Match partialMatch) {
+      return rawStreamAllValuesOfe(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe(final User pU) {
+      return rawStreamAllValuesOfe(new Object[]{null, pU}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<User> rawStreamAllValuesOfu(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_U, parameters).map(User.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu() {
+      return rawStreamAllValuesOfu(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu() {
+      return rawStreamAllValuesOfu(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu(final EventUser.Match partialMatch) {
+      return rawStreamAllValuesOfu(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu(final IssueEvent pE) {
+      return rawStreamAllValuesOfu(new Object[]{pE, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu(final EventUser.Match partialMatch) {
+      return rawStreamAllValuesOfu(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu(final IssueEvent pE) {
+      return rawStreamAllValuesOfu(new Object[]{pE, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected EventUser.Match tupleToMatch(final Tuple t) {
+      try {
+          return EventUser.Match.newMatch((IssueEvent) t.get(POSITION_E), (User) t.get(POSITION_U));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected EventUser.Match arrayToMatch(final Object[] match) {
+      try {
+          return EventUser.Match.newMatch((IssueEvent) match[POSITION_E], (User) match[POSITION_U]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected EventUser.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return EventUser.Match.newMutableMatch((IssueEvent) match[POSITION_E], (User) match[POSITION_U]);
+      } 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<EventUser.Matcher> querySpecification() {
+      return EventUser.instance();
+    }
+  }
+  
+  private EventUser() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static EventUser instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected EventUser.Matcher instantiate(final ViatraQueryEngine engine) {
+    return EventUser.Matcher.on(engine);
+  }
+  
+  @Override
+  public EventUser.Matcher instantiate() {
+    return EventUser.Matcher.create();
+  }
+  
+  @Override
+  public EventUser.Match newEmptyMatch() {
+    return EventUser.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public EventUser.Match newMatch(final Object... parameters) {
+    return EventUser.Match.newMatch((github.IssueEvent) parameters[0], (github.User) parameters[1]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link EventUser} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link EventUser#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final EventUser INSTANCE = new EventUser();
+    
+    /**
+     * 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 static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final EventUser.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_e = new PParameter("e", "github.IssueEvent", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "IssueEvent")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_u = new PParameter("u", "github.User", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "User")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_e, parameter_u);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "queries.eventUser";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("e","u");
+    }
+    
+    @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_e = body.getOrCreateVariableByName("e");
+          PVariable var_u = body.getOrCreateVariableByName("u");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_u), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "User")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_e, parameter_e),
+             new ExportedParameter(body, var_u, parameter_u)
+          ));
+          //    IssueEvent.user(e, u)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("sure.ghtorrent.github", "IssueEvent", "user")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "User")));
+          new Equality(body, var__virtual_0_, var_u);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/github-graph/src-gen/queries/IsClose.java b/Domains/github-graph/src-gen/queries/IsClose.java
new file mode 100644
index 00000000..15732fc5
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/IsClose.java
@@ -0,0 +1,723 @@
+/**
+ * Generated from platform:/resource/github-graph/queries/queries/github.vql
+ */
+package queries;
+
+import github.Issue;
+import github.IssueEvent;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue;
+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 isClose(i: Issue, e: IssueEvent) {
+ *              Issue.issueevent(i, e);
+ *              IssueEvent.action(e, a);
+ *              a == Action::CLOSED;
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class IsClose extends BaseGeneratedEMFQuerySpecification<IsClose.Matcher> {
+  /**
+   * Pattern-specific match representation of the queries.isClose 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 Issue fI;
+    
+    private IssueEvent fE;
+    
+    private static List<String> parameterNames = makeImmutableList("i", "e");
+    
+    private Match(final Issue pI, final IssueEvent pE) {
+      this.fI = pI;
+      this.fE = pE;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "i": return this.fI;
+          case "e": return this.fE;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fI;
+          case 1: return this.fE;
+          default: return null;
+      }
+    }
+    
+    public Issue getI() {
+      return this.fI;
+    }
+    
+    public IssueEvent getE() {
+      return this.fE;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("i".equals(parameterName) ) {
+          this.fI = (Issue) newValue;
+          return true;
+      }
+      if ("e".equals(parameterName) ) {
+          this.fE = (IssueEvent) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setI(final Issue pI) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fI = pI;
+    }
+    
+    public void setE(final IssueEvent pE) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fE = pE;
+    }
+    
+    @Override
+    public String patternName() {
+      return "queries.isClose";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return IsClose.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fI, fE};
+    }
+    
+    @Override
+    public IsClose.Match toImmutable() {
+      return isMutable() ? newMatch(fI, fE) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"i\"=" + prettyPrintValue(fI) + ", ");
+      result.append("\"e\"=" + prettyPrintValue(fE));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fI, fE);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof IsClose.Match)) {
+          IsClose.Match other = (IsClose.Match) obj;
+          return Objects.equals(fI, other.fI) && Objects.equals(fE, other.fE);
+      } 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 IsClose specification() {
+      return IsClose.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 IsClose.Match newEmptyMatch() {
+      return new Mutable(null, null);
+    }
+    
+    /**
+     * Returns a mutable (partial) match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static IsClose.Match newMutableMatch(final Issue pI, final IssueEvent pE) {
+      return new Mutable(pI, pE);
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static IsClose.Match newMatch(final Issue pI, final IssueEvent pE) {
+      return new Immutable(pI, pE);
+    }
+    
+    private static final class Mutable extends IsClose.Match {
+      Mutable(final Issue pI, final IssueEvent pE) {
+        super(pI, pE);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends IsClose.Match {
+      Immutable(final Issue pI, final IssueEvent pE) {
+        super(pI, pE);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the queries.isClose 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 isClose(i: Issue, e: IssueEvent) {
+   *    Issue.issueevent(i, e);
+   *    IssueEvent.action(e, a);
+   *    a == Action::CLOSED;
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see IsClose
+   * 
+   */
+  public static class Matcher extends BaseMatcher<IsClose.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 IsClose.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 IsClose.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_I = 0;
+    
+    private static final int POSITION_E = 1;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(IsClose.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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<IsClose.Match> getAllMatches(final Issue pI, final IssueEvent pE) {
+      return rawStreamAllMatches(new Object[]{pI, pE}).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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<IsClose.Match> streamAllMatches(final Issue pI, final IssueEvent pE) {
+      return rawStreamAllMatches(new Object[]{pI, pE});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<IsClose.Match> getOneArbitraryMatch(final Issue pI, final IssueEvent pE) {
+      return rawGetOneArbitraryMatch(new Object[]{pI, pE});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Issue pI, final IssueEvent pE) {
+      return rawHasMatch(new Object[]{pI, pE});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Issue pI, final IssueEvent pE) {
+      return rawCountMatches(new Object[]{pI, pE});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, 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 Issue pI, final IssueEvent pE, final Consumer<? super IsClose.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pI, pE}, 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public IsClose.Match newMatch(final Issue pI, final IssueEvent pE) {
+      return IsClose.Match.newMatch(pI, pE);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Issue> rawStreamAllValuesOfi(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_I, parameters).map(Issue.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi(final IsClose.Match partialMatch) {
+      return rawStreamAllValuesOfi(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi(final IssueEvent pE) {
+      return rawStreamAllValuesOfi(new Object[]{null, pE});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi(final IsClose.Match partialMatch) {
+      return rawStreamAllValuesOfi(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi(final IssueEvent pE) {
+      return rawStreamAllValuesOfi(new Object[]{null, pE}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<IssueEvent> rawStreamAllValuesOfe(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_E, parameters).map(IssueEvent.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe() {
+      return rawStreamAllValuesOfe(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe() {
+      return rawStreamAllValuesOfe(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe(final IsClose.Match partialMatch) {
+      return rawStreamAllValuesOfe(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe(final Issue pI) {
+      return rawStreamAllValuesOfe(new Object[]{pI, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe(final IsClose.Match partialMatch) {
+      return rawStreamAllValuesOfe(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe(final Issue pI) {
+      return rawStreamAllValuesOfe(new Object[]{pI, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected IsClose.Match tupleToMatch(final Tuple t) {
+      try {
+          return IsClose.Match.newMatch((Issue) t.get(POSITION_I), (IssueEvent) t.get(POSITION_E));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected IsClose.Match arrayToMatch(final Object[] match) {
+      try {
+          return IsClose.Match.newMatch((Issue) match[POSITION_I], (IssueEvent) match[POSITION_E]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected IsClose.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return IsClose.Match.newMutableMatch((Issue) match[POSITION_I], (IssueEvent) match[POSITION_E]);
+      } 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<IsClose.Matcher> querySpecification() {
+      return IsClose.instance();
+    }
+  }
+  
+  private IsClose() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static IsClose instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected IsClose.Matcher instantiate(final ViatraQueryEngine engine) {
+    return IsClose.Matcher.on(engine);
+  }
+  
+  @Override
+  public IsClose.Matcher instantiate() {
+    return IsClose.Matcher.create();
+  }
+  
+  @Override
+  public IsClose.Match newEmptyMatch() {
+    return IsClose.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public IsClose.Match newMatch(final Object... parameters) {
+    return IsClose.Match.newMatch((github.Issue) parameters[0], (github.IssueEvent) parameters[1]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link IsClose} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link IsClose#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final IsClose INSTANCE = new IsClose();
+    
+    /**
+     * 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 static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final IsClose.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_i = new PParameter("i", "github.Issue", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "Issue")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_e = new PParameter("e", "github.IssueEvent", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "IssueEvent")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_i, parameter_e);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "queries.isClose";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("i","e");
+    }
+    
+    @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_i = body.getOrCreateVariableByName("i");
+          PVariable var_e = body.getOrCreateVariableByName("e");
+          PVariable var_a = body.getOrCreateVariableByName("a");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Issue")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_i, parameter_i),
+             new ExportedParameter(body, var_e, parameter_e)
+          ));
+          //    Issue.issueevent(i, e)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Issue")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("sure.ghtorrent.github", "Issue", "issueevent")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          new Equality(body, var__virtual_0_, var_e);
+          //    IssueEvent.action(e, a)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("sure.ghtorrent.github", "IssueEvent", "action")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("sure.ghtorrent.github", "Action")));
+          new Equality(body, var__virtual_1_, var_a);
+          //    a == Action::CLOSED
+          PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
+          new ConstantValue(body, var__virtual_2_, getEnumLiteral("sure.ghtorrent.github", "Action", "CLOSED").getInstance());
+          new Equality(body, var_a, var__virtual_2_);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/github-graph/src-gen/queries/IsReopen.java b/Domains/github-graph/src-gen/queries/IsReopen.java
new file mode 100644
index 00000000..32ae02c5
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/IsReopen.java
@@ -0,0 +1,723 @@
+/**
+ * Generated from platform:/resource/github-graph/queries/queries/github.vql
+ */
+package queries;
+
+import github.Issue;
+import github.IssueEvent;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue;
+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 isReopen(i: Issue, e: IssueEvent) {
+ *              Issue.issueevent(i, e);
+ *              IssueEvent.action(e, a);
+ *              a == Action::REOPENED;
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class IsReopen extends BaseGeneratedEMFQuerySpecification<IsReopen.Matcher> {
+  /**
+   * Pattern-specific match representation of the queries.isReopen 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 Issue fI;
+    
+    private IssueEvent fE;
+    
+    private static List<String> parameterNames = makeImmutableList("i", "e");
+    
+    private Match(final Issue pI, final IssueEvent pE) {
+      this.fI = pI;
+      this.fE = pE;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "i": return this.fI;
+          case "e": return this.fE;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fI;
+          case 1: return this.fE;
+          default: return null;
+      }
+    }
+    
+    public Issue getI() {
+      return this.fI;
+    }
+    
+    public IssueEvent getE() {
+      return this.fE;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("i".equals(parameterName) ) {
+          this.fI = (Issue) newValue;
+          return true;
+      }
+      if ("e".equals(parameterName) ) {
+          this.fE = (IssueEvent) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setI(final Issue pI) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fI = pI;
+    }
+    
+    public void setE(final IssueEvent pE) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fE = pE;
+    }
+    
+    @Override
+    public String patternName() {
+      return "queries.isReopen";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return IsReopen.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fI, fE};
+    }
+    
+    @Override
+    public IsReopen.Match toImmutable() {
+      return isMutable() ? newMatch(fI, fE) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"i\"=" + prettyPrintValue(fI) + ", ");
+      result.append("\"e\"=" + prettyPrintValue(fE));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fI, fE);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof IsReopen.Match)) {
+          IsReopen.Match other = (IsReopen.Match) obj;
+          return Objects.equals(fI, other.fI) && Objects.equals(fE, other.fE);
+      } 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 IsReopen specification() {
+      return IsReopen.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 IsReopen.Match newEmptyMatch() {
+      return new Mutable(null, null);
+    }
+    
+    /**
+     * Returns a mutable (partial) match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static IsReopen.Match newMutableMatch(final Issue pI, final IssueEvent pE) {
+      return new Mutable(pI, pE);
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static IsReopen.Match newMatch(final Issue pI, final IssueEvent pE) {
+      return new Immutable(pI, pE);
+    }
+    
+    private static final class Mutable extends IsReopen.Match {
+      Mutable(final Issue pI, final IssueEvent pE) {
+        super(pI, pE);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends IsReopen.Match {
+      Immutable(final Issue pI, final IssueEvent pE) {
+        super(pI, pE);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the queries.isReopen 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 isReopen(i: Issue, e: IssueEvent) {
+   *    Issue.issueevent(i, e);
+   *    IssueEvent.action(e, a);
+   *    a == Action::REOPENED;
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see IsReopen
+   * 
+   */
+  public static class Matcher extends BaseMatcher<IsReopen.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 IsReopen.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 IsReopen.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_I = 0;
+    
+    private static final int POSITION_E = 1;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(IsReopen.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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<IsReopen.Match> getAllMatches(final Issue pI, final IssueEvent pE) {
+      return rawStreamAllMatches(new Object[]{pI, pE}).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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<IsReopen.Match> streamAllMatches(final Issue pI, final IssueEvent pE) {
+      return rawStreamAllMatches(new Object[]{pI, pE});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<IsReopen.Match> getOneArbitraryMatch(final Issue pI, final IssueEvent pE) {
+      return rawGetOneArbitraryMatch(new Object[]{pI, pE});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Issue pI, final IssueEvent pE) {
+      return rawHasMatch(new Object[]{pI, pE});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Issue pI, final IssueEvent pE) {
+      return rawCountMatches(new Object[]{pI, pE});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, 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 Issue pI, final IssueEvent pE, final Consumer<? super IsReopen.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pI, pE}, 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public IsReopen.Match newMatch(final Issue pI, final IssueEvent pE) {
+      return IsReopen.Match.newMatch(pI, pE);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Issue> rawStreamAllValuesOfi(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_I, parameters).map(Issue.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi(final IsReopen.Match partialMatch) {
+      return rawStreamAllValuesOfi(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi(final IssueEvent pE) {
+      return rawStreamAllValuesOfi(new Object[]{null, pE});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi(final IsReopen.Match partialMatch) {
+      return rawStreamAllValuesOfi(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi(final IssueEvent pE) {
+      return rawStreamAllValuesOfi(new Object[]{null, pE}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<IssueEvent> rawStreamAllValuesOfe(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_E, parameters).map(IssueEvent.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe() {
+      return rawStreamAllValuesOfe(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe() {
+      return rawStreamAllValuesOfe(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe(final IsReopen.Match partialMatch) {
+      return rawStreamAllValuesOfe(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe(final Issue pI) {
+      return rawStreamAllValuesOfe(new Object[]{pI, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe(final IsReopen.Match partialMatch) {
+      return rawStreamAllValuesOfe(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe(final Issue pI) {
+      return rawStreamAllValuesOfe(new Object[]{pI, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected IsReopen.Match tupleToMatch(final Tuple t) {
+      try {
+          return IsReopen.Match.newMatch((Issue) t.get(POSITION_I), (IssueEvent) t.get(POSITION_E));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected IsReopen.Match arrayToMatch(final Object[] match) {
+      try {
+          return IsReopen.Match.newMatch((Issue) match[POSITION_I], (IssueEvent) match[POSITION_E]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected IsReopen.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return IsReopen.Match.newMutableMatch((Issue) match[POSITION_I], (IssueEvent) match[POSITION_E]);
+      } 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<IsReopen.Matcher> querySpecification() {
+      return IsReopen.instance();
+    }
+  }
+  
+  private IsReopen() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static IsReopen instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected IsReopen.Matcher instantiate(final ViatraQueryEngine engine) {
+    return IsReopen.Matcher.on(engine);
+  }
+  
+  @Override
+  public IsReopen.Matcher instantiate() {
+    return IsReopen.Matcher.create();
+  }
+  
+  @Override
+  public IsReopen.Match newEmptyMatch() {
+    return IsReopen.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public IsReopen.Match newMatch(final Object... parameters) {
+    return IsReopen.Match.newMatch((github.Issue) parameters[0], (github.IssueEvent) parameters[1]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link IsReopen} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link IsReopen#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final IsReopen INSTANCE = new IsReopen();
+    
+    /**
+     * 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 static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final IsReopen.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_i = new PParameter("i", "github.Issue", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "Issue")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_e = new PParameter("e", "github.IssueEvent", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "IssueEvent")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_i, parameter_e);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "queries.isReopen";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("i","e");
+    }
+    
+    @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_i = body.getOrCreateVariableByName("i");
+          PVariable var_e = body.getOrCreateVariableByName("e");
+          PVariable var_a = body.getOrCreateVariableByName("a");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Issue")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_i, parameter_i),
+             new ExportedParameter(body, var_e, parameter_e)
+          ));
+          //    Issue.issueevent(i, e)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Issue")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("sure.ghtorrent.github", "Issue", "issueevent")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          new Equality(body, var__virtual_0_, var_e);
+          //    IssueEvent.action(e, a)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("sure.ghtorrent.github", "IssueEvent", "action")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("sure.ghtorrent.github", "Action")));
+          new Equality(body, var__virtual_1_, var_a);
+          //    a == Action::REOPENED
+          PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
+          new ConstantValue(body, var__virtual_2_, getEnumLiteral("sure.ghtorrent.github", "Action", "REOPENED").getInstance());
+          new Equality(body, var_a, var__virtual_2_);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/github-graph/src-gen/queries/IsSubscribe.java b/Domains/github-graph/src-gen/queries/IsSubscribe.java
new file mode 100644
index 00000000..6ef51558
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/IsSubscribe.java
@@ -0,0 +1,840 @@
+/**
+ * Generated from platform:/resource/github-graph/queries/queries/github.vql
+ */
+package queries;
+
+import github.Issue;
+import github.IssueEvent;
+import github.User;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue;
+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 isSubscribe(i: Issue, u: User, e: IssueEvent) {
+ *              Issue.issueevent(i, e);
+ *              IssueEvent.user(e, u);
+ *              IssueEvent.action(e, a);
+ *              a == Action::SUBSCRIBED;
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class IsSubscribe extends BaseGeneratedEMFQuerySpecification<IsSubscribe.Matcher> {
+  /**
+   * Pattern-specific match representation of the queries.isSubscribe 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 Issue fI;
+    
+    private User fU;
+    
+    private IssueEvent fE;
+    
+    private static List<String> parameterNames = makeImmutableList("i", "u", "e");
+    
+    private Match(final Issue pI, final User pU, final IssueEvent pE) {
+      this.fI = pI;
+      this.fU = pU;
+      this.fE = pE;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "i": return this.fI;
+          case "u": return this.fU;
+          case "e": return this.fE;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fI;
+          case 1: return this.fU;
+          case 2: return this.fE;
+          default: return null;
+      }
+    }
+    
+    public Issue getI() {
+      return this.fI;
+    }
+    
+    public User getU() {
+      return this.fU;
+    }
+    
+    public IssueEvent getE() {
+      return this.fE;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("i".equals(parameterName) ) {
+          this.fI = (Issue) newValue;
+          return true;
+      }
+      if ("u".equals(parameterName) ) {
+          this.fU = (User) newValue;
+          return true;
+      }
+      if ("e".equals(parameterName) ) {
+          this.fE = (IssueEvent) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setI(final Issue pI) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fI = pI;
+    }
+    
+    public void setU(final User pU) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fU = pU;
+    }
+    
+    public void setE(final IssueEvent pE) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fE = pE;
+    }
+    
+    @Override
+    public String patternName() {
+      return "queries.isSubscribe";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return IsSubscribe.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fI, fU, fE};
+    }
+    
+    @Override
+    public IsSubscribe.Match toImmutable() {
+      return isMutable() ? newMatch(fI, fU, fE) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"i\"=" + prettyPrintValue(fI) + ", ");
+      result.append("\"u\"=" + prettyPrintValue(fU) + ", ");
+      result.append("\"e\"=" + prettyPrintValue(fE));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fI, fU, fE);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof IsSubscribe.Match)) {
+          IsSubscribe.Match other = (IsSubscribe.Match) obj;
+          return Objects.equals(fI, other.fI) && Objects.equals(fU, other.fU) && Objects.equals(fE, other.fE);
+      } 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 IsSubscribe specification() {
+      return IsSubscribe.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 IsSubscribe.Match newEmptyMatch() {
+      return new Mutable(null, null, null);
+    }
+    
+    /**
+     * Returns a mutable (partial) match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static IsSubscribe.Match newMutableMatch(final Issue pI, final User pU, final IssueEvent pE) {
+      return new Mutable(pI, pU, pE);
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static IsSubscribe.Match newMatch(final Issue pI, final User pU, final IssueEvent pE) {
+      return new Immutable(pI, pU, pE);
+    }
+    
+    private static final class Mutable extends IsSubscribe.Match {
+      Mutable(final Issue pI, final User pU, final IssueEvent pE) {
+        super(pI, pU, pE);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends IsSubscribe.Match {
+      Immutable(final Issue pI, final User pU, final IssueEvent pE) {
+        super(pI, pU, pE);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the queries.isSubscribe 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 isSubscribe(i: Issue, u: User, e: IssueEvent) {
+   *    Issue.issueevent(i, e);
+   *    IssueEvent.user(e, u);
+   *    IssueEvent.action(e, a);
+   *    a == Action::SUBSCRIBED;
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see IsSubscribe
+   * 
+   */
+  public static class Matcher extends BaseMatcher<IsSubscribe.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 IsSubscribe.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 IsSubscribe.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_I = 0;
+    
+    private static final int POSITION_U = 1;
+    
+    private static final int POSITION_E = 2;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(IsSubscribe.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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<IsSubscribe.Match> getAllMatches(final Issue pI, final User pU, final IssueEvent pE) {
+      return rawStreamAllMatches(new Object[]{pI, pU, pE}).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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<IsSubscribe.Match> streamAllMatches(final Issue pI, final User pU, final IssueEvent pE) {
+      return rawStreamAllMatches(new Object[]{pI, pU, pE});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<IsSubscribe.Match> getOneArbitraryMatch(final Issue pI, final User pU, final IssueEvent pE) {
+      return rawGetOneArbitraryMatch(new Object[]{pI, pU, pE});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Issue pI, final User pU, final IssueEvent pE) {
+      return rawHasMatch(new Object[]{pI, pU, pE});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Issue pI, final User pU, final IssueEvent pE) {
+      return rawCountMatches(new Object[]{pI, pU, pE});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, 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 Issue pI, final User pU, final IssueEvent pE, final Consumer<? super IsSubscribe.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pI, pU, pE}, 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public IsSubscribe.Match newMatch(final Issue pI, final User pU, final IssueEvent pE) {
+      return IsSubscribe.Match.newMatch(pI, pU, pE);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Issue> rawStreamAllValuesOfi(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_I, parameters).map(Issue.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi(final IsSubscribe.Match partialMatch) {
+      return rawStreamAllValuesOfi(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi(final User pU, final IssueEvent pE) {
+      return rawStreamAllValuesOfi(new Object[]{null, pU, pE});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi(final IsSubscribe.Match partialMatch) {
+      return rawStreamAllValuesOfi(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi(final User pU, final IssueEvent pE) {
+      return rawStreamAllValuesOfi(new Object[]{null, pU, pE}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<User> rawStreamAllValuesOfu(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_U, parameters).map(User.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu() {
+      return rawStreamAllValuesOfu(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu() {
+      return rawStreamAllValuesOfu(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu(final IsSubscribe.Match partialMatch) {
+      return rawStreamAllValuesOfu(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu(final Issue pI, final IssueEvent pE) {
+      return rawStreamAllValuesOfu(new Object[]{pI, null, pE});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu(final IsSubscribe.Match partialMatch) {
+      return rawStreamAllValuesOfu(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu(final Issue pI, final IssueEvent pE) {
+      return rawStreamAllValuesOfu(new Object[]{pI, null, pE}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<IssueEvent> rawStreamAllValuesOfe(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_E, parameters).map(IssueEvent.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe() {
+      return rawStreamAllValuesOfe(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe() {
+      return rawStreamAllValuesOfe(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe(final IsSubscribe.Match partialMatch) {
+      return rawStreamAllValuesOfe(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe(final Issue pI, final User pU) {
+      return rawStreamAllValuesOfe(new Object[]{pI, pU, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe(final IsSubscribe.Match partialMatch) {
+      return rawStreamAllValuesOfe(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe(final Issue pI, final User pU) {
+      return rawStreamAllValuesOfe(new Object[]{pI, pU, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected IsSubscribe.Match tupleToMatch(final Tuple t) {
+      try {
+          return IsSubscribe.Match.newMatch((Issue) t.get(POSITION_I), (User) t.get(POSITION_U), (IssueEvent) t.get(POSITION_E));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected IsSubscribe.Match arrayToMatch(final Object[] match) {
+      try {
+          return IsSubscribe.Match.newMatch((Issue) match[POSITION_I], (User) match[POSITION_U], (IssueEvent) match[POSITION_E]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected IsSubscribe.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return IsSubscribe.Match.newMutableMatch((Issue) match[POSITION_I], (User) match[POSITION_U], (IssueEvent) match[POSITION_E]);
+      } 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<IsSubscribe.Matcher> querySpecification() {
+      return IsSubscribe.instance();
+    }
+  }
+  
+  private IsSubscribe() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static IsSubscribe instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected IsSubscribe.Matcher instantiate(final ViatraQueryEngine engine) {
+    return IsSubscribe.Matcher.on(engine);
+  }
+  
+  @Override
+  public IsSubscribe.Matcher instantiate() {
+    return IsSubscribe.Matcher.create();
+  }
+  
+  @Override
+  public IsSubscribe.Match newEmptyMatch() {
+    return IsSubscribe.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public IsSubscribe.Match newMatch(final Object... parameters) {
+    return IsSubscribe.Match.newMatch((github.Issue) parameters[0], (github.User) parameters[1], (github.IssueEvent) parameters[2]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link IsSubscribe} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link IsSubscribe#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final IsSubscribe INSTANCE = new IsSubscribe();
+    
+    /**
+     * 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 static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final IsSubscribe.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_i = new PParameter("i", "github.Issue", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "Issue")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_u = new PParameter("u", "github.User", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "User")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_e = new PParameter("e", "github.IssueEvent", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "IssueEvent")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_i, parameter_u, parameter_e);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "queries.isSubscribe";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("i","u","e");
+    }
+    
+    @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_i = body.getOrCreateVariableByName("i");
+          PVariable var_u = body.getOrCreateVariableByName("u");
+          PVariable var_e = body.getOrCreateVariableByName("e");
+          PVariable var_a = body.getOrCreateVariableByName("a");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Issue")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_u), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "User")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_i, parameter_i),
+             new ExportedParameter(body, var_u, parameter_u),
+             new ExportedParameter(body, var_e, parameter_e)
+          ));
+          //    Issue.issueevent(i, e)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Issue")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("sure.ghtorrent.github", "Issue", "issueevent")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          new Equality(body, var__virtual_0_, var_e);
+          //    IssueEvent.user(e, u)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("sure.ghtorrent.github", "IssueEvent", "user")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "User")));
+          new Equality(body, var__virtual_1_, var_u);
+          //    IssueEvent.action(e, a)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e, var__virtual_2_), new EStructuralFeatureInstancesKey(getFeatureLiteral("sure.ghtorrent.github", "IssueEvent", "action")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_2_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("sure.ghtorrent.github", "Action")));
+          new Equality(body, var__virtual_2_, var_a);
+          //    a == Action::SUBSCRIBED
+          PVariable var__virtual_3_ = body.getOrCreateVariableByName(".virtual{3}");
+          new ConstantValue(body, var__virtual_3_, getEnumLiteral("sure.ghtorrent.github", "Action", "SUBSCRIBED").getInstance());
+          new Equality(body, var_a, var__virtual_3_);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/github-graph/src-gen/queries/IsUnSubscribe.java b/Domains/github-graph/src-gen/queries/IsUnSubscribe.java
new file mode 100644
index 00000000..0e4e0a30
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/IsUnSubscribe.java
@@ -0,0 +1,840 @@
+/**
+ * Generated from platform:/resource/github-graph/queries/queries/github.vql
+ */
+package queries;
+
+import github.Issue;
+import github.IssueEvent;
+import github.User;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue;
+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 isUnSubscribe(i: Issue, u: User, e: IssueEvent) {
+ *              Issue.issueevent(i, e);
+ *              IssueEvent.user(e, u);
+ *              IssueEvent.action(e, a);
+ *              a == Action::UNSUBSCRIBED;
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class IsUnSubscribe extends BaseGeneratedEMFQuerySpecification<IsUnSubscribe.Matcher> {
+  /**
+   * Pattern-specific match representation of the queries.isUnSubscribe 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 Issue fI;
+    
+    private User fU;
+    
+    private IssueEvent fE;
+    
+    private static List<String> parameterNames = makeImmutableList("i", "u", "e");
+    
+    private Match(final Issue pI, final User pU, final IssueEvent pE) {
+      this.fI = pI;
+      this.fU = pU;
+      this.fE = pE;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "i": return this.fI;
+          case "u": return this.fU;
+          case "e": return this.fE;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fI;
+          case 1: return this.fU;
+          case 2: return this.fE;
+          default: return null;
+      }
+    }
+    
+    public Issue getI() {
+      return this.fI;
+    }
+    
+    public User getU() {
+      return this.fU;
+    }
+    
+    public IssueEvent getE() {
+      return this.fE;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("i".equals(parameterName) ) {
+          this.fI = (Issue) newValue;
+          return true;
+      }
+      if ("u".equals(parameterName) ) {
+          this.fU = (User) newValue;
+          return true;
+      }
+      if ("e".equals(parameterName) ) {
+          this.fE = (IssueEvent) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setI(final Issue pI) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fI = pI;
+    }
+    
+    public void setU(final User pU) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fU = pU;
+    }
+    
+    public void setE(final IssueEvent pE) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fE = pE;
+    }
+    
+    @Override
+    public String patternName() {
+      return "queries.isUnSubscribe";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return IsUnSubscribe.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fI, fU, fE};
+    }
+    
+    @Override
+    public IsUnSubscribe.Match toImmutable() {
+      return isMutable() ? newMatch(fI, fU, fE) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"i\"=" + prettyPrintValue(fI) + ", ");
+      result.append("\"u\"=" + prettyPrintValue(fU) + ", ");
+      result.append("\"e\"=" + prettyPrintValue(fE));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fI, fU, fE);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof IsUnSubscribe.Match)) {
+          IsUnSubscribe.Match other = (IsUnSubscribe.Match) obj;
+          return Objects.equals(fI, other.fI) && Objects.equals(fU, other.fU) && Objects.equals(fE, other.fE);
+      } 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 IsUnSubscribe specification() {
+      return IsUnSubscribe.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 IsUnSubscribe.Match newEmptyMatch() {
+      return new Mutable(null, null, null);
+    }
+    
+    /**
+     * Returns a mutable (partial) match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static IsUnSubscribe.Match newMutableMatch(final Issue pI, final User pU, final IssueEvent pE) {
+      return new Mutable(pI, pU, pE);
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static IsUnSubscribe.Match newMatch(final Issue pI, final User pU, final IssueEvent pE) {
+      return new Immutable(pI, pU, pE);
+    }
+    
+    private static final class Mutable extends IsUnSubscribe.Match {
+      Mutable(final Issue pI, final User pU, final IssueEvent pE) {
+        super(pI, pU, pE);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends IsUnSubscribe.Match {
+      Immutable(final Issue pI, final User pU, final IssueEvent pE) {
+        super(pI, pU, pE);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the queries.isUnSubscribe 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 isUnSubscribe(i: Issue, u: User, e: IssueEvent) {
+   *    Issue.issueevent(i, e);
+   *    IssueEvent.user(e, u);
+   *    IssueEvent.action(e, a);
+   *    a == Action::UNSUBSCRIBED;
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see IsUnSubscribe
+   * 
+   */
+  public static class Matcher extends BaseMatcher<IsUnSubscribe.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 IsUnSubscribe.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 IsUnSubscribe.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_I = 0;
+    
+    private static final int POSITION_U = 1;
+    
+    private static final int POSITION_E = 2;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(IsUnSubscribe.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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<IsUnSubscribe.Match> getAllMatches(final Issue pI, final User pU, final IssueEvent pE) {
+      return rawStreamAllMatches(new Object[]{pI, pU, pE}).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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<IsUnSubscribe.Match> streamAllMatches(final Issue pI, final User pU, final IssueEvent pE) {
+      return rawStreamAllMatches(new Object[]{pI, pU, pE});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<IsUnSubscribe.Match> getOneArbitraryMatch(final Issue pI, final User pU, final IssueEvent pE) {
+      return rawGetOneArbitraryMatch(new Object[]{pI, pU, pE});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Issue pI, final User pU, final IssueEvent pE) {
+      return rawHasMatch(new Object[]{pI, pU, pE});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Issue pI, final User pU, final IssueEvent pE) {
+      return rawCountMatches(new Object[]{pI, pU, pE});
+    }
+    
+    /**
+     * 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, 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 Issue pI, final User pU, final IssueEvent pE, final Consumer<? super IsUnSubscribe.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pI, pU, pE}, 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 pI the fixed value of pattern parameter i, or null if not bound.
+     * @param pU the fixed value of pattern parameter u, or null if not bound.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public IsUnSubscribe.Match newMatch(final Issue pI, final User pU, final IssueEvent pE) {
+      return IsUnSubscribe.Match.newMatch(pI, pU, pE);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Issue> rawStreamAllValuesOfi(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_I, parameters).map(Issue.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi() {
+      return rawStreamAllValuesOfi(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi(final IsUnSubscribe.Match partialMatch) {
+      return rawStreamAllValuesOfi(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Issue> streamAllValuesOfi(final User pU, final IssueEvent pE) {
+      return rawStreamAllValuesOfi(new Object[]{null, pU, pE});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi(final IsUnSubscribe.Match partialMatch) {
+      return rawStreamAllValuesOfi(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for i.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Issue> getAllValuesOfi(final User pU, final IssueEvent pE) {
+      return rawStreamAllValuesOfi(new Object[]{null, pU, pE}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<User> rawStreamAllValuesOfu(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_U, parameters).map(User.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu() {
+      return rawStreamAllValuesOfu(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu() {
+      return rawStreamAllValuesOfu(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu(final IsUnSubscribe.Match partialMatch) {
+      return rawStreamAllValuesOfu(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<User> streamAllValuesOfu(final Issue pI, final IssueEvent pE) {
+      return rawStreamAllValuesOfu(new Object[]{pI, null, pE});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu(final IsUnSubscribe.Match partialMatch) {
+      return rawStreamAllValuesOfu(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for u.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<User> getAllValuesOfu(final Issue pI, final IssueEvent pE) {
+      return rawStreamAllValuesOfu(new Object[]{pI, null, pE}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<IssueEvent> rawStreamAllValuesOfe(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_E, parameters).map(IssueEvent.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe() {
+      return rawStreamAllValuesOfe(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe() {
+      return rawStreamAllValuesOfe(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe(final IsUnSubscribe.Match partialMatch) {
+      return rawStreamAllValuesOfe(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe(final Issue pI, final User pU) {
+      return rawStreamAllValuesOfe(new Object[]{pI, pU, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe(final IsUnSubscribe.Match partialMatch) {
+      return rawStreamAllValuesOfe(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe(final Issue pI, final User pU) {
+      return rawStreamAllValuesOfe(new Object[]{pI, pU, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected IsUnSubscribe.Match tupleToMatch(final Tuple t) {
+      try {
+          return IsUnSubscribe.Match.newMatch((Issue) t.get(POSITION_I), (User) t.get(POSITION_U), (IssueEvent) t.get(POSITION_E));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected IsUnSubscribe.Match arrayToMatch(final Object[] match) {
+      try {
+          return IsUnSubscribe.Match.newMatch((Issue) match[POSITION_I], (User) match[POSITION_U], (IssueEvent) match[POSITION_E]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected IsUnSubscribe.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return IsUnSubscribe.Match.newMutableMatch((Issue) match[POSITION_I], (User) match[POSITION_U], (IssueEvent) match[POSITION_E]);
+      } 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<IsUnSubscribe.Matcher> querySpecification() {
+      return IsUnSubscribe.instance();
+    }
+  }
+  
+  private IsUnSubscribe() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static IsUnSubscribe instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected IsUnSubscribe.Matcher instantiate(final ViatraQueryEngine engine) {
+    return IsUnSubscribe.Matcher.on(engine);
+  }
+  
+  @Override
+  public IsUnSubscribe.Matcher instantiate() {
+    return IsUnSubscribe.Matcher.create();
+  }
+  
+  @Override
+  public IsUnSubscribe.Match newEmptyMatch() {
+    return IsUnSubscribe.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public IsUnSubscribe.Match newMatch(final Object... parameters) {
+    return IsUnSubscribe.Match.newMatch((github.Issue) parameters[0], (github.User) parameters[1], (github.IssueEvent) parameters[2]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link IsUnSubscribe} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link IsUnSubscribe#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final IsUnSubscribe INSTANCE = new IsUnSubscribe();
+    
+    /**
+     * 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 static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final IsUnSubscribe.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_i = new PParameter("i", "github.Issue", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "Issue")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_u = new PParameter("u", "github.User", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "User")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_e = new PParameter("e", "github.IssueEvent", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "IssueEvent")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_i, parameter_u, parameter_e);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "queries.isUnSubscribe";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("i","u","e");
+    }
+    
+    @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_i = body.getOrCreateVariableByName("i");
+          PVariable var_u = body.getOrCreateVariableByName("u");
+          PVariable var_e = body.getOrCreateVariableByName("e");
+          PVariable var_a = body.getOrCreateVariableByName("a");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Issue")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_u), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "User")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_i, parameter_i),
+             new ExportedParameter(body, var_u, parameter_u),
+             new ExportedParameter(body, var_e, parameter_e)
+          ));
+          //    Issue.issueevent(i, e)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Issue")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_i, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("sure.ghtorrent.github", "Issue", "issueevent")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          new Equality(body, var__virtual_0_, var_e);
+          //    IssueEvent.user(e, u)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("sure.ghtorrent.github", "IssueEvent", "user")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "User")));
+          new Equality(body, var__virtual_1_, var_u);
+          //    IssueEvent.action(e, a)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e, var__virtual_2_), new EStructuralFeatureInstancesKey(getFeatureLiteral("sure.ghtorrent.github", "IssueEvent", "action")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_2_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("sure.ghtorrent.github", "Action")));
+          new Equality(body, var__virtual_2_, var_a);
+          //    a == Action::UNSUBSCRIBED
+          PVariable var__virtual_3_ = body.getOrCreateVariableByName(".virtual{3}");
+          new ConstantValue(body, var__virtual_3_, getEnumLiteral("sure.ghtorrent.github", "Action", "UNSUBSCRIBED").getInstance());
+          new Equality(body, var_a, var__virtual_3_);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/github-graph/src-gen/queries/NoCommitter.java b/Domains/github-graph/src-gen/queries/NoCommitter.java
new file mode 100644
index 00000000..4a34d2cb
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/NoCommitter.java
@@ -0,0 +1,560 @@
+/**
+ * Generated from platform:/resource/github-graph/queries/queries/github.vql
+ */
+package queries;
+
+import github.Commit;
+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.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.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;
+import queries.Committer;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         {@literal @}Constraint(key={c}, severity="error", message="error")
+ *         pattern noCommitter(c: Commit) {
+ *              neg find committer(c, _);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class NoCommitter extends BaseGeneratedEMFQuerySpecification<NoCommitter.Matcher> {
+  /**
+   * Pattern-specific match representation of the queries.noCommitter 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 Commit fC;
+    
+    private static List<String> parameterNames = makeImmutableList("c");
+    
+    private Match(final Commit pC) {
+      this.fC = pC;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "c": return this.fC;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fC;
+          default: return null;
+      }
+    }
+    
+    public Commit getC() {
+      return this.fC;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("c".equals(parameterName) ) {
+          this.fC = (Commit) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setC(final Commit pC) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fC = pC;
+    }
+    
+    @Override
+    public String patternName() {
+      return "queries.noCommitter";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return NoCommitter.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fC};
+    }
+    
+    @Override
+    public NoCommitter.Match toImmutable() {
+      return isMutable() ? newMatch(fC) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"c\"=" + prettyPrintValue(fC));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fC);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof NoCommitter.Match)) {
+          NoCommitter.Match other = (NoCommitter.Match) obj;
+          return Objects.equals(fC, other.fC);
+      } 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 NoCommitter specification() {
+      return NoCommitter.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 NoCommitter.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 pC the fixed value of pattern parameter c, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static NoCommitter.Match newMutableMatch(final Commit pC) {
+      return new Mutable(pC);
+    }
+    
+    /**
+     * 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 pC the fixed value of pattern parameter c, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static NoCommitter.Match newMatch(final Commit pC) {
+      return new Immutable(pC);
+    }
+    
+    private static final class Mutable extends NoCommitter.Match {
+      Mutable(final Commit pC) {
+        super(pC);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends NoCommitter.Match {
+      Immutable(final Commit pC) {
+        super(pC);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the queries.noCommitter pattern,
+   * providing pattern-specific query methods.
+   * 
+   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+   * 
+   * <p>Matches of the pattern will be represented as {@link Match}.
+   * 
+   * <p>Original source:
+   * <code><pre>
+   * {@literal @}Constraint(key={c}, severity="error", message="error")
+   * pattern noCommitter(c: Commit) {
+   *    neg find committer(c, _);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see NoCommitter
+   * 
+   */
+  public static class Matcher extends BaseMatcher<NoCommitter.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 NoCommitter.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 NoCommitter.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_C = 0;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(NoCommitter.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 pC the fixed value of pattern parameter c, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<NoCommitter.Match> getAllMatches(final Commit pC) {
+      return rawStreamAllMatches(new Object[]{pC}).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 pC the fixed value of pattern parameter c, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<NoCommitter.Match> streamAllMatches(final Commit pC) {
+      return rawStreamAllMatches(new Object[]{pC});
+    }
+    
+    /**
+     * 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 pC the fixed value of pattern parameter c, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<NoCommitter.Match> getOneArbitraryMatch(final Commit pC) {
+      return rawGetOneArbitraryMatch(new Object[]{pC});
+    }
+    
+    /**
+     * 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 pC the fixed value of pattern parameter c, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Commit pC) {
+      return rawHasMatch(new Object[]{pC});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pC the fixed value of pattern parameter c, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Commit pC) {
+      return rawCountMatches(new Object[]{pC});
+    }
+    
+    /**
+     * 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 pC the fixed value of pattern parameter c, 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 Commit pC, final Consumer<? super NoCommitter.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pC}, 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 pC the fixed value of pattern parameter c, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public NoCommitter.Match newMatch(final Commit pC) {
+      return NoCommitter.Match.newMatch(pC);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for c.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Commit> rawStreamAllValuesOfc(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_C, parameters).map(Commit.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for c.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Commit> getAllValuesOfc() {
+      return rawStreamAllValuesOfc(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for c.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Commit> streamAllValuesOfc() {
+      return rawStreamAllValuesOfc(emptyArray());
+    }
+    
+    @Override
+    protected NoCommitter.Match tupleToMatch(final Tuple t) {
+      try {
+          return NoCommitter.Match.newMatch((Commit) t.get(POSITION_C));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected NoCommitter.Match arrayToMatch(final Object[] match) {
+      try {
+          return NoCommitter.Match.newMatch((Commit) match[POSITION_C]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected NoCommitter.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return NoCommitter.Match.newMutableMatch((Commit) match[POSITION_C]);
+      } 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<NoCommitter.Matcher> querySpecification() {
+      return NoCommitter.instance();
+    }
+  }
+  
+  private NoCommitter() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static NoCommitter instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected NoCommitter.Matcher instantiate(final ViatraQueryEngine engine) {
+    return NoCommitter.Matcher.on(engine);
+  }
+  
+  @Override
+  public NoCommitter.Matcher instantiate() {
+    return NoCommitter.Matcher.create();
+  }
+  
+  @Override
+  public NoCommitter.Match newEmptyMatch() {
+    return NoCommitter.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public NoCommitter.Match newMatch(final Object... parameters) {
+    return NoCommitter.Match.newMatch((github.Commit) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link NoCommitter} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link NoCommitter#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final NoCommitter INSTANCE = new NoCommitter();
+    
+    /**
+     * 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 static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final NoCommitter.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_c = new PParameter("c", "github.Commit", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "Commit")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_c);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "queries.noCommitter";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("c");
+    }
+    
+    @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_c = body.getOrCreateVariableByName("c");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_c), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "Commit")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_c, parameter_c)
+          ));
+          //    neg find committer(c, _)
+          new NegativePatternCall(body, Tuples.flatTupleOf(var_c, var___0_), Committer.instance().getInternalQueryRepresentation());
+          bodies.add(body);
+      }
+      {
+          PAnnotation annotation = new PAnnotation("Constraint");
+          annotation.addAttribute("key", Arrays.asList(new Object[] {
+                              new ParameterReference("c")
+                              }));
+          annotation.addAttribute("severity", "error");
+          annotation.addAttribute("message", "error");
+          addAnnotation(annotation);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/github-graph/src-gen/queries/NoUser.java b/Domains/github-graph/src-gen/queries/NoUser.java
new file mode 100644
index 00000000..293b5d56
--- /dev/null
+++ b/Domains/github-graph/src-gen/queries/NoUser.java
@@ -0,0 +1,560 @@
+/**
+ * Generated from platform:/resource/github-graph/queries/queries/github.vql
+ */
+package queries;
+
+import github.IssueEvent;
+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.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.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;
+import queries.EventUser;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         {@literal @}Constraint(key={e}, severity="error", message="error")
+ *         pattern noUser(e: IssueEvent) {
+ *              neg find eventUser(e, _);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class NoUser extends BaseGeneratedEMFQuerySpecification<NoUser.Matcher> {
+  /**
+   * Pattern-specific match representation of the queries.noUser 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 IssueEvent fE;
+    
+    private static List<String> parameterNames = makeImmutableList("e");
+    
+    private Match(final IssueEvent pE) {
+      this.fE = pE;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "e": return this.fE;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fE;
+          default: return null;
+      }
+    }
+    
+    public IssueEvent getE() {
+      return this.fE;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("e".equals(parameterName) ) {
+          this.fE = (IssueEvent) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setE(final IssueEvent pE) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fE = pE;
+    }
+    
+    @Override
+    public String patternName() {
+      return "queries.noUser";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return NoUser.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fE};
+    }
+    
+    @Override
+    public NoUser.Match toImmutable() {
+      return isMutable() ? newMatch(fE) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"e\"=" + prettyPrintValue(fE));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fE);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof NoUser.Match)) {
+          NoUser.Match other = (NoUser.Match) obj;
+          return Objects.equals(fE, other.fE);
+      } 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 NoUser specification() {
+      return NoUser.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 NoUser.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 pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static NoUser.Match newMutableMatch(final IssueEvent pE) {
+      return new Mutable(pE);
+    }
+    
+    /**
+     * 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 pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static NoUser.Match newMatch(final IssueEvent pE) {
+      return new Immutable(pE);
+    }
+    
+    private static final class Mutable extends NoUser.Match {
+      Mutable(final IssueEvent pE) {
+        super(pE);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends NoUser.Match {
+      Immutable(final IssueEvent pE) {
+        super(pE);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the queries.noUser pattern,
+   * providing pattern-specific query methods.
+   * 
+   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+   * 
+   * <p>Matches of the pattern will be represented as {@link Match}.
+   * 
+   * <p>Original source:
+   * <code><pre>
+   * {@literal @}Constraint(key={e}, severity="error", message="error")
+   * pattern noUser(e: IssueEvent) {
+   *    neg find eventUser(e, _);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see NoUser
+   * 
+   */
+  public static class Matcher extends BaseMatcher<NoUser.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 NoUser.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 NoUser.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_E = 0;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(NoUser.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 pE the fixed value of pattern parameter e, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<NoUser.Match> getAllMatches(final IssueEvent pE) {
+      return rawStreamAllMatches(new Object[]{pE}).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 pE the fixed value of pattern parameter e, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<NoUser.Match> streamAllMatches(final IssueEvent pE) {
+      return rawStreamAllMatches(new Object[]{pE});
+    }
+    
+    /**
+     * 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 pE the fixed value of pattern parameter e, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<NoUser.Match> getOneArbitraryMatch(final IssueEvent pE) {
+      return rawGetOneArbitraryMatch(new Object[]{pE});
+    }
+    
+    /**
+     * 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 pE the fixed value of pattern parameter e, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final IssueEvent pE) {
+      return rawHasMatch(new Object[]{pE});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final IssueEvent pE) {
+      return rawCountMatches(new Object[]{pE});
+    }
+    
+    /**
+     * 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 pE the fixed value of pattern parameter e, 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 IssueEvent pE, final Consumer<? super NoUser.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pE}, 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 pE the fixed value of pattern parameter e, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public NoUser.Match newMatch(final IssueEvent pE) {
+      return NoUser.Match.newMatch(pE);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<IssueEvent> rawStreamAllValuesOfe(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_E, parameters).map(IssueEvent.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<IssueEvent> getAllValuesOfe() {
+      return rawStreamAllValuesOfe(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for e.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<IssueEvent> streamAllValuesOfe() {
+      return rawStreamAllValuesOfe(emptyArray());
+    }
+    
+    @Override
+    protected NoUser.Match tupleToMatch(final Tuple t) {
+      try {
+          return NoUser.Match.newMatch((IssueEvent) t.get(POSITION_E));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected NoUser.Match arrayToMatch(final Object[] match) {
+      try {
+          return NoUser.Match.newMatch((IssueEvent) match[POSITION_E]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected NoUser.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return NoUser.Match.newMutableMatch((IssueEvent) match[POSITION_E]);
+      } 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<NoUser.Matcher> querySpecification() {
+      return NoUser.instance();
+    }
+  }
+  
+  private NoUser() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static NoUser instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected NoUser.Matcher instantiate(final ViatraQueryEngine engine) {
+    return NoUser.Matcher.on(engine);
+  }
+  
+  @Override
+  public NoUser.Matcher instantiate() {
+    return NoUser.Matcher.create();
+  }
+  
+  @Override
+  public NoUser.Match newEmptyMatch() {
+    return NoUser.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public NoUser.Match newMatch(final Object... parameters) {
+    return NoUser.Match.newMatch((github.IssueEvent) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link NoUser} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link NoUser#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final NoUser INSTANCE = new NoUser();
+    
+    /**
+     * 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 static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final NoUser.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_e = new PParameter("e", "github.IssueEvent", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("sure.ghtorrent.github", "IssueEvent")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_e);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "queries.noUser";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("e");
+    }
+    
+    @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_e = body.getOrCreateVariableByName("e");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_e), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("sure.ghtorrent.github", "IssueEvent")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_e, parameter_e)
+          ));
+          //    neg find eventUser(e, _)
+          new NegativePatternCall(body, Tuples.flatTupleOf(var_e, var___0_), EventUser.instance().getInternalQueryRepresentation());
+          bodies.add(body);
+      }
+      {
+          PAnnotation annotation = new PAnnotation("Constraint");
+          annotation.addAttribute("key", Arrays.asList(new Object[] {
+                              new ParameterReference("e")
+                              }));
+          annotation.addAttribute("severity", "error");
+          annotation.addAttribute("message", "error");
+          addAnnotation(annotation);
+      }
+      return bodies;
+    }
+  }
+}