fix merging issue

15 files changed, 2702 insertions, 0 deletions

diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.CloseTrainsObjectiveHint.xtendbin b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.CloseTrainsObjectiveHint.xtendbin
new file mode 100644
index 00000000..87975792
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.CloseTrainsObjectiveHint.xtendbin
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.EndOfSidingObjectiveHint.xtendbin b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.EndOfSidingObjectiveHint.xtendbin
new file mode 100644
index 00000000..f243e180
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.EndOfSidingObjectiveHint.xtendbin
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.MisalignedTurnoutObjectiveHint.xtendbin b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.MisalignedTurnoutObjectiveHint.xtendbin
new file mode 100644
index 00000000..cdef4dc7
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.MisalignedTurnoutObjectiveHint.xtendbin
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3ModelGenerator.xtendbin b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3ModelGenerator.xtendbin
new file mode 100644
index 00000000..759ac9e4
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3ModelGenerator.xtendbin
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3TypeScopeHint.xtendbin b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3TypeScopeHint.xtendbin
new file mode 100644
index 00000000..386baeda
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3TypeScopeHint.xtendbin
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3UnitPropagationGenerator.xtendbin b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3UnitPropagationGenerator.xtendbin
new file mode 100644
index 00000000..79059b7f
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3UnitPropagationGenerator.xtendbin
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.TrainLocationsObjectiveHint.xtendbin b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.TrainLocationsObjectiveHint.xtendbin
new file mode 100644
index 00000000..3c3a380e
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.TrainLocationsObjectiveHint.xtendbin
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.gitignore b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.gitignore
new file mode 100644
index 00000000..1a7df1d9
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.gitignore
@@ -0,0 +1,13 @@
+/.Modes3ModelGenerator.java._trace
+/.Modes3UnitPropagationGenerator.java._trace
+/.Modes3TypeScopeHint.java._trace
+/.Modes3TypeScopeHint.xtendbin
+/.Modes3UnitPropagationGenerator.xtendbin
+/Modes3TypeScopeHint.java
+/.Modes3ModelGenerator.xtendbin
+/Modes3ModelGenerator.java
+/Modes3UnitPropagationGenerator.java
+/.CloseTrainsObjectiveHint.java._trace
+/.TrainLocationsObjectiveHint.java._trace
+/.MisalignedTurnoutObjectiveHint.java._trace
+/.EndOfSidingObjectiveHint.java._trace
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/CloseTrainsObjectiveHint.java b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/CloseTrainsObjectiveHint.java
new file mode 100644
index 00000000..babfa7e1
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/CloseTrainsObjectiveHint.java
@@ -0,0 +1,279 @@
+package modes3.run;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.ImmutableList;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.Dimension;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ExtendedLinearExpressionBuilder;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ExtendedLinearExpressionBuilderFactory;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedronExtensionOperator;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.CostElementMatch;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.CostElementMatchers;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.CostObjectiveHint;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import modes3.Modes3Package;
+import modes3.queries.CloseTrains_step_2;
+import modes3.queries.CloseTrains_step_3;
+import modes3.queries.CloseTrains_step_4;
+import modes3.queries.CloseTrains_step_5;
+import modes3.queries.CloseTrains_step_6;
+import modes3.queries.CloseTrains_step_7;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+
+@SuppressWarnings("all")
+public class CloseTrainsObjectiveHint extends CostObjectiveHint {
+  private final Type segmentType;
+  
+  private final Type trainType;
+  
+  public CloseTrainsObjectiveHint(@Extension final Ecore2Logic ecore2Logic, final Ecore2Logic_Trace ecore2LogicTrace) {
+    @Extension
+    final Modes3Package Modes3Package = modes3.Modes3Package.eINSTANCE;
+    this.segmentType = ecore2Logic.TypeofEClass(ecore2LogicTrace, Modes3Package.getSegment());
+    this.trainType = ecore2Logic.TypeofEClass(ecore2LogicTrace, Modes3Package.getTrain());
+  }
+  
+  @Override
+  public boolean isExact() {
+    return true;
+  }
+  
+  @Override
+  public PolyhedronExtensionOperator createPolyhedronExtensionOperator(final Map<String, CostElementMatchers> costElementMatchers) {
+    PolyhedronExtensionOperator _xblockexpression = null;
+    {
+      final CostElementMatchers step2 = costElementMatchers.get(CloseTrains_step_2.instance().getFullyQualifiedName());
+      final CostElementMatchers step3 = costElementMatchers.get(CloseTrains_step_3.instance().getFullyQualifiedName());
+      final CostElementMatchers step4 = costElementMatchers.get(CloseTrains_step_4.instance().getFullyQualifiedName());
+      final CostElementMatchers step5 = costElementMatchers.get(CloseTrains_step_5.instance().getFullyQualifiedName());
+      final CostElementMatchers step6 = costElementMatchers.get(CloseTrains_step_6.instance().getFullyQualifiedName());
+      final CostElementMatchers step7 = costElementMatchers.get(CloseTrains_step_7.instance().getFullyQualifiedName());
+      final PolyhedronExtensionOperator _function = (ExtendedLinearExpressionBuilderFactory it) -> {
+        final ExtendedLinearExpressionBuilder objectiveBuilder = it.createBuilder();
+        ImmutableList<CostElementMatch> _matches = step2.getMatches();
+        for (final CostElementMatch m : _matches) {
+          {
+            final Dimension dimension = it.getDimension(m.getMatch());
+            objectiveBuilder.add(step2.getWeight(), dimension);
+            dimension.tightenLowerBound(Integer.valueOf(0));
+            boolean _isMulti = m.isMulti();
+            if (_isMulti) {
+              it.createBuilder().add(1, dimension).add((-1), this.trainType).build().assertEqualsTo(0);
+            } else {
+              dimension.tightenUpperBound(Integer.valueOf(1));
+              boolean _isMust = m.isMust();
+              if (_isMust) {
+                dimension.tightenLowerBound(Integer.valueOf(1));
+              }
+            }
+          }
+        }
+        final ImmutableList<CostElementMatch> step3Matches = step3.getMatches();
+        for (final CostElementMatch m_1 : step3Matches) {
+          {
+            final Dimension dimension = it.getDimension(m_1.getMatch());
+            objectiveBuilder.add(step3.getWeight(), dimension);
+            dimension.tightenLowerBound(Integer.valueOf(0));
+            boolean _isMulti = m_1.isMulti();
+            boolean _not = (!_isMulti);
+            if (_not) {
+              dimension.tightenUpperBound(Integer.valueOf(1));
+              boolean _isMust = m_1.isMust();
+              if (_isMust) {
+                dimension.tightenLowerBound(Integer.valueOf(1));
+              }
+            }
+          }
+        }
+        final Function1<CostElementMatch, IPatternMatch> _function_1 = (CostElementMatch it_1) -> {
+          return step2.projectMayMatch(it_1.getMatch(), 2);
+        };
+        Set<Map.Entry<IPatternMatch, List<CostElementMatch>>> _entrySet = IterableExtensions.<IPatternMatch, CostElementMatch>groupBy(step3Matches, _function_1).entrySet();
+        for (final Map.Entry<IPatternMatch, List<CostElementMatch>> pair : _entrySet) {
+          {
+            final ExtendedLinearExpressionBuilder multiplicityBuilder = it.createBuilder();
+            List<CostElementMatch> _value = pair.getValue();
+            for (final CostElementMatch m_2 : _value) {
+              multiplicityBuilder.add(1, m_2.getMatch());
+            }
+            multiplicityBuilder.add((-1), pair.getKey());
+            multiplicityBuilder.build().assertEqualsTo(0);
+          }
+        }
+        CloseTrainsObjectiveHint.boundLimit(it, step3Matches, 2, this.trainType, 1);
+        CloseTrainsObjectiveHint.boundLimit(it, step3Matches, 3, this.segmentType, 1);
+        final ImmutableList<CostElementMatch> step4Matches = step4.getMatches();
+        for (final CostElementMatch m_2 : step4Matches) {
+          {
+            final Dimension dimension = it.getDimension(m_2.getMatch());
+            objectiveBuilder.add(step4.getWeight(), dimension);
+            dimension.tightenLowerBound(Integer.valueOf(0));
+            boolean _isMulti = m_2.isMulti();
+            boolean _not = (!_isMulti);
+            if (_not) {
+              dimension.tightenUpperBound(Integer.valueOf(1));
+              boolean _isMust = m_2.isMust();
+              if (_isMust) {
+                dimension.tightenLowerBound(Integer.valueOf(1));
+              }
+            }
+          }
+        }
+        final Function1<CostElementMatch, IPatternMatch> _function_2 = (CostElementMatch it_1) -> {
+          return step3.projectMayMatch(it_1.getMatch(), 2, 3);
+        };
+        Set<Map.Entry<IPatternMatch, List<CostElementMatch>>> _entrySet_1 = IterableExtensions.<IPatternMatch, CostElementMatch>groupBy(step4Matches, _function_2).entrySet();
+        for (final Map.Entry<IPatternMatch, List<CostElementMatch>> pair_1 : _entrySet_1) {
+          {
+            final ExtendedLinearExpressionBuilder multiplicityBuilder = it.createBuilder();
+            List<CostElementMatch> _value = pair_1.getValue();
+            for (final CostElementMatch m_3 : _value) {
+              multiplicityBuilder.add(1, m_3.getMatch());
+            }
+            multiplicityBuilder.add((-2), pair_1.getKey());
+            multiplicityBuilder.build().tightenUpperBound(Integer.valueOf(0));
+          }
+        }
+        CloseTrainsObjectiveHint.boundLimit(it, step4Matches, 2, this.trainType, 2);
+        CloseTrainsObjectiveHint.boundLimit(it, step4Matches, 3, this.segmentType, 2);
+        CloseTrainsObjectiveHint.boundLimit(it, step4Matches, 4, this.segmentType, 2);
+        final ImmutableList<CostElementMatch> step5Matches = step5.getMatches();
+        for (final CostElementMatch m_3 : step5Matches) {
+          {
+            final Dimension dimension = it.getDimension(m_3.getMatch());
+            objectiveBuilder.add(step5.getWeight(), dimension);
+            dimension.tightenLowerBound(Integer.valueOf(0));
+            boolean _isMulti = m_3.isMulti();
+            boolean _not = (!_isMulti);
+            if (_not) {
+              dimension.tightenUpperBound(Integer.valueOf(1));
+              boolean _isMust = m_3.isMust();
+              if (_isMust) {
+                dimension.tightenLowerBound(Integer.valueOf(1));
+              }
+            }
+          }
+        }
+        final Function1<CostElementMatch, IPatternMatch> _function_3 = (CostElementMatch it_1) -> {
+          return step4.projectMayMatch(it_1.getMatch(), 2, 3, 4);
+        };
+        Set<Map.Entry<IPatternMatch, List<CostElementMatch>>> _entrySet_2 = IterableExtensions.<IPatternMatch, CostElementMatch>groupBy(step5Matches, _function_3).entrySet();
+        for (final Map.Entry<IPatternMatch, List<CostElementMatch>> pair_2 : _entrySet_2) {
+          {
+            final ExtendedLinearExpressionBuilder multiplicityBuilder = it.createBuilder();
+            List<CostElementMatch> _value = pair_2.getValue();
+            for (final CostElementMatch m_4 : _value) {
+              multiplicityBuilder.add(1, m_4.getMatch());
+            }
+            multiplicityBuilder.add((-2), pair_2.getKey());
+            multiplicityBuilder.build().tightenUpperBound(Integer.valueOf(0));
+          }
+        }
+        CloseTrainsObjectiveHint.boundLimit(it, step5Matches, 2, this.trainType, 4);
+        CloseTrainsObjectiveHint.boundLimit(it, step5Matches, 3, this.segmentType, 4);
+        CloseTrainsObjectiveHint.boundLimit(it, step5Matches, 4, this.segmentType, 4);
+        CloseTrainsObjectiveHint.boundLimit(it, step5Matches, 5, this.segmentType, 4);
+        final ImmutableList<CostElementMatch> step6Matches = step6.getMatches();
+        for (final CostElementMatch m_4 : step6Matches) {
+          {
+            final Dimension dimension = it.getDimension(m_4.getMatch());
+            objectiveBuilder.add(step6.getWeight(), dimension);
+            dimension.tightenLowerBound(Integer.valueOf(0));
+            boolean _isMulti = m_4.isMulti();
+            if (_isMulti) {
+              Object _get = m_4.getMatch().get(3);
+              Object _get_1 = m_4.getMatch().get(5);
+              boolean _equals = Objects.equal(_get, _get_1);
+              if (_equals) {
+                it.createBuilder().add(2, m_4.getMatch()).add((-1), step5.projectMayMatch(m_4.getMatch(), 2, 3, 4, 5)).build().assertEqualsTo(0);
+              } else {
+                it.createBuilder().add(1, m_4.getMatch()).add((-1), step5.projectMayMatch(m_4.getMatch(), 2, 3, 4, 5)).build().assertEqualsTo(0);
+              }
+            } else {
+              dimension.tightenUpperBound(Integer.valueOf(1));
+              boolean _isMust = m_4.isMust();
+              if (_isMust) {
+                dimension.tightenLowerBound(Integer.valueOf(1));
+              }
+            }
+          }
+        }
+        CloseTrainsObjectiveHint.boundLimit(it, step6Matches, 2, this.trainType, 2);
+        CloseTrainsObjectiveHint.boundLimit(it, step6Matches, 3, this.segmentType, 2);
+        CloseTrainsObjectiveHint.boundLimit(it, step6Matches, 4, this.segmentType, 2);
+        CloseTrainsObjectiveHint.boundLimit(it, step6Matches, 5, this.segmentType, 2);
+        final ImmutableList<CostElementMatch> step7Matches = step7.getMatches();
+        for (final CostElementMatch m_5 : step7Matches) {
+          {
+            final Dimension dimension = it.getDimension(m_5.getMatch());
+            objectiveBuilder.add(step7.getWeight(), dimension);
+            dimension.tightenLowerBound(Integer.valueOf(0));
+            boolean _isMulti = m_5.isMulti();
+            boolean _not = (!_isMulti);
+            if (_not) {
+              dimension.tightenUpperBound(Integer.valueOf(1));
+              boolean _isMust = m_5.isMust();
+              if (_isMust) {
+                dimension.tightenLowerBound(Integer.valueOf(1));
+              }
+            }
+          }
+        }
+        final Function1<CostElementMatch, IPatternMatch> _function_4 = (CostElementMatch it_1) -> {
+          return step6.projectMayMatch(it_1.getMatch(), 2, 3, 4, 5);
+        };
+        Set<Map.Entry<IPatternMatch, List<CostElementMatch>>> _entrySet_3 = IterableExtensions.<IPatternMatch, CostElementMatch>groupBy(step7Matches, _function_4).entrySet();
+        for (final Map.Entry<IPatternMatch, List<CostElementMatch>> pair_3 : _entrySet_3) {
+          {
+            final ExtendedLinearExpressionBuilder multiplicityBuilder = it.createBuilder();
+            List<CostElementMatch> _value = pair_3.getValue();
+            for (final CostElementMatch m_6 : _value) {
+              multiplicityBuilder.add(1, m_6.getMatch());
+            }
+            multiplicityBuilder.add((-1), pair_3.getKey());
+            multiplicityBuilder.build().tightenUpperBound(Integer.valueOf(0));
+          }
+        }
+        CloseTrainsObjectiveHint.boundLimit(it, step7Matches, 2, this.trainType, 2);
+        CloseTrainsObjectiveHint.boundLimit(it, step7Matches, 3, this.segmentType, 2);
+        CloseTrainsObjectiveHint.boundLimit(it, step7Matches, 4, this.segmentType, 2);
+        CloseTrainsObjectiveHint.boundLimit(it, step7Matches, 5, this.segmentType, 2);
+        CloseTrainsObjectiveHint.boundLimit(it, step7Matches, 6, this.trainType, 2);
+        this.buildWithBounds(objectiveBuilder);
+      };
+      _xblockexpression = _function;
+    }
+    return _xblockexpression;
+  }
+  
+  private static void boundLimit(@Extension final ExtendedLinearExpressionBuilderFactory factory, final Collection<CostElementMatch> matches, final int index, final Type type, final int count) {
+    final Function1<CostElementMatch, Object> _function = (CostElementMatch it) -> {
+      return it.getMatch().get(index);
+    };
+    Set<Map.Entry<Object, List<CostElementMatch>>> _entrySet = IterableExtensions.<Object, CostElementMatch>groupBy(matches, _function).entrySet();
+    for (final Map.Entry<Object, List<CostElementMatch>> pair : _entrySet) {
+      {
+        final ExtendedLinearExpressionBuilder multiplicityBuilder = factory.createBuilder();
+        List<CostElementMatch> _value = pair.getValue();
+        for (final CostElementMatch m : _value) {
+          multiplicityBuilder.add(1, m.getMatch());
+        }
+        boolean _isMulti = CostElementMatchers.isMulti(pair.getKey());
+        if (_isMulti) {
+          multiplicityBuilder.add((-count), type);
+          multiplicityBuilder.build().tightenUpperBound(Integer.valueOf(0));
+        } else {
+          multiplicityBuilder.build().tightenUpperBound(Integer.valueOf(count));
+        }
+      }
+    }
+  }
+}
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/EndOfSidingObjectiveHint.java b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/EndOfSidingObjectiveHint.java
new file mode 100644
index 00000000..77c513e1
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/EndOfSidingObjectiveHint.java
@@ -0,0 +1,193 @@
+package modes3.run;
+
+import com.google.common.collect.ImmutableList;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.Dimension;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ExtendedLinearExpressionBuilder;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ExtendedLinearExpressionBuilderFactory;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedronExtensionOperator;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.CostElementMatch;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.CostElementMatchers;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.CostObjectiveHint;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import modes3.Modes3Package;
+import modes3.queries.EndOfSiding_step_2;
+import modes3.queries.EndOfSiding_step_3;
+import modes3.queries.EndOfSiding_step_4;
+import modes3.queries.EndOfSiding_step_5;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+
+@SuppressWarnings("all")
+public class EndOfSidingObjectiveHint extends CostObjectiveHint {
+  private final Type segmentType;
+  
+  private final Type trainType;
+  
+  public EndOfSidingObjectiveHint(@Extension final Ecore2Logic ecore2Logic, final Ecore2Logic_Trace ecore2LogicTrace) {
+    @Extension
+    final Modes3Package Modes3Package = modes3.Modes3Package.eINSTANCE;
+    this.segmentType = ecore2Logic.TypeofEClass(ecore2LogicTrace, Modes3Package.getSegment());
+    this.trainType = ecore2Logic.TypeofEClass(ecore2LogicTrace, Modes3Package.getTrain());
+  }
+  
+  @Override
+  public boolean isExact() {
+    return true;
+  }
+  
+  @Override
+  public PolyhedronExtensionOperator createPolyhedronExtensionOperator(final Map<String, CostElementMatchers> costElementMatchers) {
+    PolyhedronExtensionOperator _xblockexpression = null;
+    {
+      final CostElementMatchers step2 = costElementMatchers.get(EndOfSiding_step_2.instance().getFullyQualifiedName());
+      final CostElementMatchers step3 = costElementMatchers.get(EndOfSiding_step_3.instance().getFullyQualifiedName());
+      final CostElementMatchers step4 = costElementMatchers.get(EndOfSiding_step_4.instance().getFullyQualifiedName());
+      final CostElementMatchers step5 = costElementMatchers.get(EndOfSiding_step_5.instance().getFullyQualifiedName());
+      final PolyhedronExtensionOperator _function = (ExtendedLinearExpressionBuilderFactory it) -> {
+        final ExtendedLinearExpressionBuilder objectiveBuilder = it.createBuilder();
+        ImmutableList<CostElementMatch> _matches = step2.getMatches();
+        for (final CostElementMatch m : _matches) {
+          {
+            final Dimension dimension = it.getDimension(m.getMatch());
+            objectiveBuilder.add(step2.getWeight(), dimension);
+            dimension.tightenLowerBound(Integer.valueOf(0));
+            boolean _isMulti = m.isMulti();
+            if (_isMulti) {
+              it.createBuilder().add(1, dimension).add((-1), this.trainType).build().assertEqualsTo(0);
+            } else {
+              dimension.tightenUpperBound(Integer.valueOf(1));
+              boolean _isMust = m.isMust();
+              if (_isMust) {
+                dimension.tightenLowerBound(Integer.valueOf(1));
+              }
+            }
+          }
+        }
+        final ImmutableList<CostElementMatch> step3Matches = step3.getMatches();
+        for (final CostElementMatch m_1 : step3Matches) {
+          {
+            final Dimension dimension = it.getDimension(m_1.getMatch());
+            objectiveBuilder.add(step3.getWeight(), dimension);
+            dimension.tightenLowerBound(Integer.valueOf(0));
+            boolean _isMulti = m_1.isMulti();
+            boolean _not = (!_isMulti);
+            if (_not) {
+              dimension.tightenUpperBound(Integer.valueOf(1));
+              boolean _isMust = m_1.isMust();
+              if (_isMust) {
+                dimension.tightenLowerBound(Integer.valueOf(1));
+              }
+            }
+          }
+        }
+        final Function1<CostElementMatch, IPatternMatch> _function_1 = (CostElementMatch it_1) -> {
+          return step2.projectMayMatch(it_1.getMatch(), 2);
+        };
+        Set<Map.Entry<IPatternMatch, List<CostElementMatch>>> _entrySet = IterableExtensions.<IPatternMatch, CostElementMatch>groupBy(step3Matches, _function_1).entrySet();
+        for (final Map.Entry<IPatternMatch, List<CostElementMatch>> pair : _entrySet) {
+          {
+            final ExtendedLinearExpressionBuilder multiplicityBuilder = it.createBuilder();
+            List<CostElementMatch> _value = pair.getValue();
+            for (final CostElementMatch m_2 : _value) {
+              multiplicityBuilder.add(1, m_2.getMatch());
+            }
+            multiplicityBuilder.add((-1), pair.getKey());
+            multiplicityBuilder.build().assertEqualsTo(0);
+          }
+        }
+        EndOfSidingObjectiveHint.boundLimit(it, step3Matches, 2, this.trainType, 1);
+        EndOfSidingObjectiveHint.boundLimit(it, step3Matches, 3, this.segmentType, 1);
+        final ImmutableList<CostElementMatch> step4Matches = step4.getMatches();
+        for (final CostElementMatch m_2 : step4Matches) {
+          {
+            final Dimension dimension = it.getDimension(m_2.getMatch());
+            objectiveBuilder.add(step4.getWeight(), dimension);
+            dimension.tightenLowerBound(Integer.valueOf(0));
+            boolean _isMulti = m_2.isMulti();
+            boolean _not = (!_isMulti);
+            if (_not) {
+              dimension.tightenUpperBound(Integer.valueOf(1));
+              boolean _isMust = m_2.isMust();
+              if (_isMust) {
+                dimension.tightenLowerBound(Integer.valueOf(1));
+              }
+            }
+          }
+        }
+        final Function1<CostElementMatch, IPatternMatch> _function_2 = (CostElementMatch it_1) -> {
+          return step3.projectMayMatch(it_1.getMatch(), 2, 3);
+        };
+        Set<Map.Entry<IPatternMatch, List<CostElementMatch>>> _entrySet_1 = IterableExtensions.<IPatternMatch, CostElementMatch>groupBy(step4Matches, _function_2).entrySet();
+        for (final Map.Entry<IPatternMatch, List<CostElementMatch>> pair_1 : _entrySet_1) {
+          {
+            final ExtendedLinearExpressionBuilder multiplicityBuilder = it.createBuilder();
+            List<CostElementMatch> _value = pair_1.getValue();
+            for (final CostElementMatch m_3 : _value) {
+              multiplicityBuilder.add(1, m_3.getMatch());
+            }
+            multiplicityBuilder.add((-2), pair_1.getKey());
+            multiplicityBuilder.build().tightenUpperBound(Integer.valueOf(0));
+          }
+        }
+        EndOfSidingObjectiveHint.boundLimit(it, step4Matches, 2, this.trainType, 2);
+        EndOfSidingObjectiveHint.boundLimit(it, step4Matches, 3, this.segmentType, 2);
+        EndOfSidingObjectiveHint.boundLimit(it, step4Matches, 4, this.segmentType, 2);
+        final ImmutableList<CostElementMatch> step5Matches = step5.getMatches();
+        for (final CostElementMatch m_3 : step5Matches) {
+          {
+            final Dimension dimension = it.getDimension(m_3.getMatch());
+            objectiveBuilder.add(step5.getWeight(), dimension);
+            dimension.tightenLowerBound(Integer.valueOf(0));
+            boolean _isMulti = m_3.isMulti();
+            boolean _not = (!_isMulti);
+            if (_not) {
+              dimension.tightenUpperBound(Integer.valueOf(1));
+              boolean _isMust = m_3.isMust();
+              if (_isMust) {
+                dimension.tightenLowerBound(Integer.valueOf(1));
+              }
+            }
+            it.createBuilder().add(1, m_3.getMatch()).add((-1), step4.projectMayMatch(m_3.getMatch(), 2, 3, 4)).build().tightenUpperBound(Integer.valueOf(0));
+          }
+        }
+        EndOfSidingObjectiveHint.boundLimit(it, step5Matches, 2, this.trainType, 1);
+        EndOfSidingObjectiveHint.boundLimit(it, step5Matches, 3, this.segmentType, 2);
+        EndOfSidingObjectiveHint.boundLimit(it, step5Matches, 4, this.segmentType, 1);
+        this.buildWithBounds(objectiveBuilder);
+      };
+      _xblockexpression = _function;
+    }
+    return _xblockexpression;
+  }
+  
+  private static void boundLimit(@Extension final ExtendedLinearExpressionBuilderFactory factory, final Collection<CostElementMatch> matches, final int index, final Type type, final int count) {
+    final Function1<CostElementMatch, Object> _function = (CostElementMatch it) -> {
+      return it.getMatch().get(index);
+    };
+    Set<Map.Entry<Object, List<CostElementMatch>>> _entrySet = IterableExtensions.<Object, CostElementMatch>groupBy(matches, _function).entrySet();
+    for (final Map.Entry<Object, List<CostElementMatch>> pair : _entrySet) {
+      {
+        final ExtendedLinearExpressionBuilder multiplicityBuilder = factory.createBuilder();
+        List<CostElementMatch> _value = pair.getValue();
+        for (final CostElementMatch m : _value) {
+          multiplicityBuilder.add(1, m.getMatch());
+        }
+        boolean _isMulti = CostElementMatchers.isMulti(pair.getKey());
+        if (_isMulti) {
+          multiplicityBuilder.add((-count), type);
+          multiplicityBuilder.build().tightenUpperBound(Integer.valueOf(0));
+        } else {
+          multiplicityBuilder.build().tightenUpperBound(Integer.valueOf(count));
+        }
+      }
+    }
+  }
+}
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/MisalignedTurnoutObjectiveHint.java b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/MisalignedTurnoutObjectiveHint.java
new file mode 100644
index 00000000..835a6559
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/MisalignedTurnoutObjectiveHint.java
@@ -0,0 +1,195 @@
+package modes3.run;
+
+import com.google.common.collect.ImmutableList;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.Dimension;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ExtendedLinearExpressionBuilder;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ExtendedLinearExpressionBuilderFactory;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedronExtensionOperator;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.CostElementMatch;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.CostElementMatchers;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.CostObjectiveHint;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import modes3.Modes3Package;
+import modes3.queries.MisalignedTurnout_step_2;
+import modes3.queries.MisalignedTurnout_step_3;
+import modes3.queries.MisalignedTurnout_step_4;
+import modes3.queries.MisalignedTurnout_step_5;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+
+@SuppressWarnings("all")
+public class MisalignedTurnoutObjectiveHint extends CostObjectiveHint {
+  private final Type segmentType;
+  
+  private final Type turnoutType;
+  
+  private final Type trainType;
+  
+  public MisalignedTurnoutObjectiveHint(@Extension final Ecore2Logic ecore2Logic, final Ecore2Logic_Trace ecore2LogicTrace) {
+    @Extension
+    final Modes3Package Modes3Package = modes3.Modes3Package.eINSTANCE;
+    this.segmentType = ecore2Logic.TypeofEClass(ecore2LogicTrace, Modes3Package.getSegment());
+    this.turnoutType = ecore2Logic.TypeofEClass(ecore2LogicTrace, Modes3Package.getTurnout());
+    this.trainType = ecore2Logic.TypeofEClass(ecore2LogicTrace, Modes3Package.getTrain());
+  }
+  
+  @Override
+  public boolean isExact() {
+    return true;
+  }
+  
+  @Override
+  public PolyhedronExtensionOperator createPolyhedronExtensionOperator(final Map<String, CostElementMatchers> costElementMatchers) {
+    PolyhedronExtensionOperator _xblockexpression = null;
+    {
+      final CostElementMatchers step2 = costElementMatchers.get(MisalignedTurnout_step_2.instance().getFullyQualifiedName());
+      final CostElementMatchers step3 = costElementMatchers.get(MisalignedTurnout_step_3.instance().getFullyQualifiedName());
+      final CostElementMatchers step4 = costElementMatchers.get(MisalignedTurnout_step_4.instance().getFullyQualifiedName());
+      final CostElementMatchers step5 = costElementMatchers.get(MisalignedTurnout_step_5.instance().getFullyQualifiedName());
+      final PolyhedronExtensionOperator _function = (ExtendedLinearExpressionBuilderFactory it) -> {
+        final ExtendedLinearExpressionBuilder objectiveBuilder = it.createBuilder();
+        ImmutableList<CostElementMatch> _matches = step2.getMatches();
+        for (final CostElementMatch m : _matches) {
+          {
+            final Dimension dimension = it.getDimension(m.getMatch());
+            objectiveBuilder.add(step2.getWeight(), dimension);
+            dimension.tightenLowerBound(Integer.valueOf(0));
+            boolean _isMulti = m.isMulti();
+            if (_isMulti) {
+              it.createBuilder().add(1, dimension).add((-1), this.turnoutType).build().assertEqualsTo(0);
+            } else {
+              dimension.tightenUpperBound(Integer.valueOf(1));
+              boolean _isMust = m.isMust();
+              if (_isMust) {
+                dimension.tightenLowerBound(Integer.valueOf(1));
+              }
+            }
+          }
+        }
+        final ImmutableList<CostElementMatch> step3Matches = step3.getMatches();
+        for (final CostElementMatch m_1 : step3Matches) {
+          {
+            final Dimension dimension = it.getDimension(m_1.getMatch());
+            objectiveBuilder.add(step3.getWeight(), dimension);
+            dimension.tightenLowerBound(Integer.valueOf(0));
+            boolean _isMulti = m_1.isMulti();
+            boolean _not = (!_isMulti);
+            if (_not) {
+              dimension.tightenUpperBound(Integer.valueOf(1));
+              boolean _isMust = m_1.isMust();
+              if (_isMust) {
+                dimension.tightenLowerBound(Integer.valueOf(1));
+              }
+            }
+          }
+        }
+        final Function1<CostElementMatch, IPatternMatch> _function_1 = (CostElementMatch it_1) -> {
+          return step2.projectMayMatch(it_1.getMatch(), 2);
+        };
+        Set<Map.Entry<IPatternMatch, List<CostElementMatch>>> _entrySet = IterableExtensions.<IPatternMatch, CostElementMatch>groupBy(step3Matches, _function_1).entrySet();
+        for (final Map.Entry<IPatternMatch, List<CostElementMatch>> pair : _entrySet) {
+          {
+            final ExtendedLinearExpressionBuilder multiplicityBuilder = it.createBuilder();
+            List<CostElementMatch> _value = pair.getValue();
+            for (final CostElementMatch m_2 : _value) {
+              multiplicityBuilder.add(1, m_2.getMatch());
+            }
+            multiplicityBuilder.add((-1), pair.getKey());
+            multiplicityBuilder.build().tightenUpperBound(Integer.valueOf(0));
+          }
+        }
+        MisalignedTurnoutObjectiveHint.boundLimit(it, step3Matches, 2, this.turnoutType, 1);
+        MisalignedTurnoutObjectiveHint.boundLimit(it, step3Matches, 3, this.segmentType, 2);
+        final ImmutableList<CostElementMatch> step4Matches = step4.getMatches();
+        for (final CostElementMatch m_2 : step4Matches) {
+          {
+            final Dimension dimension = it.getDimension(m_2.getMatch());
+            objectiveBuilder.add(step4.getWeight(), dimension);
+            dimension.tightenLowerBound(Integer.valueOf(0));
+            boolean _isMulti = m_2.isMulti();
+            boolean _not = (!_isMulti);
+            if (_not) {
+              dimension.tightenUpperBound(Integer.valueOf(1));
+              boolean _isMust = m_2.isMust();
+              if (_isMust) {
+                dimension.tightenLowerBound(Integer.valueOf(1));
+              }
+            }
+            it.createBuilder().add(1, m_2.getMatch()).add((-1), step3.projectMayMatch(m_2.getMatch(), 2, 3)).build().tightenUpperBound(Integer.valueOf(0));
+          }
+        }
+        MisalignedTurnoutObjectiveHint.boundLimit(it, step4Matches, 2, this.turnoutType, 1);
+        MisalignedTurnoutObjectiveHint.boundLimit(it, step4Matches, 3, this.segmentType, 2);
+        final ImmutableList<CostElementMatch> step5Matches = step5.getMatches();
+        for (final CostElementMatch m_3 : step5Matches) {
+          {
+            final Dimension dimension = it.getDimension(m_3.getMatch());
+            objectiveBuilder.add(step5.getWeight(), dimension);
+            dimension.tightenLowerBound(Integer.valueOf(0));
+            boolean _isMulti = m_3.isMulti();
+            boolean _not = (!_isMulti);
+            if (_not) {
+              dimension.tightenUpperBound(Integer.valueOf(1));
+              boolean _isMust = m_3.isMust();
+              if (_isMust) {
+                dimension.tightenLowerBound(Integer.valueOf(1));
+              }
+            }
+          }
+        }
+        final Function1<CostElementMatch, IPatternMatch> _function_2 = (CostElementMatch it_1) -> {
+          return step4.projectMayMatch(it_1.getMatch(), 2, 3);
+        };
+        Set<Map.Entry<IPatternMatch, List<CostElementMatch>>> _entrySet_1 = IterableExtensions.<IPatternMatch, CostElementMatch>groupBy(step5Matches, _function_2).entrySet();
+        for (final Map.Entry<IPatternMatch, List<CostElementMatch>> pair_1 : _entrySet_1) {
+          {
+            final ExtendedLinearExpressionBuilder multiplicityBuilder = it.createBuilder();
+            List<CostElementMatch> _value = pair_1.getValue();
+            for (final CostElementMatch m_4 : _value) {
+              multiplicityBuilder.add(1, m_4.getMatch());
+            }
+            multiplicityBuilder.add((-1), pair_1.getKey());
+            multiplicityBuilder.build().tightenUpperBound(Integer.valueOf(0));
+          }
+        }
+        MisalignedTurnoutObjectiveHint.boundLimit(it, step5Matches, 2, this.turnoutType, 1);
+        MisalignedTurnoutObjectiveHint.boundLimit(it, step5Matches, 3, this.segmentType, 2);
+        MisalignedTurnoutObjectiveHint.boundLimit(it, step5Matches, 4, this.trainType, 2);
+        this.buildWithBounds(objectiveBuilder);
+      };
+      _xblockexpression = _function;
+    }
+    return _xblockexpression;
+  }
+  
+  private static void boundLimit(@Extension final ExtendedLinearExpressionBuilderFactory factory, final Collection<CostElementMatch> matches, final int index, final Type type, final int count) {
+    final Function1<CostElementMatch, Object> _function = (CostElementMatch it) -> {
+      return it.getMatch().get(index);
+    };
+    Set<Map.Entry<Object, List<CostElementMatch>>> _entrySet = IterableExtensions.<Object, CostElementMatch>groupBy(matches, _function).entrySet();
+    for (final Map.Entry<Object, List<CostElementMatch>> pair : _entrySet) {
+      {
+        final ExtendedLinearExpressionBuilder multiplicityBuilder = factory.createBuilder();
+        List<CostElementMatch> _value = pair.getValue();
+        for (final CostElementMatch m : _value) {
+          multiplicityBuilder.add(1, m.getMatch());
+        }
+        boolean _isMulti = CostElementMatchers.isMulti(pair.getKey());
+        if (_isMulti) {
+          multiplicityBuilder.add((-count), type);
+          multiplicityBuilder.build().tightenUpperBound(Integer.valueOf(0));
+        } else {
+          multiplicityBuilder.build().tightenUpperBound(Integer.valueOf(count));
+        }
+      }
+    }
+  }
+}
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/Modes3ModelGenerator.java b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/Modes3ModelGenerator.java
new file mode 100644
index 00000000..16db7053
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/Modes3ModelGenerator.java
@@ -0,0 +1,598 @@
+package modes3.run;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.EReferenceMapper_RelationsOverTypes_Trace;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2LogicConfiguration;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.Ecore2logicannotationsFactory;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.Ecore2logicannotationsPackage;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion;
+import hu.bme.mit.inf.dslreasoner.logic.model.builder.DocumentationLevel;
+import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicModelInterpretation;
+import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder;
+import hu.bme.mit.inf.dslreasoner.logic.model.builder.SolutionScope;
+import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput;
+import hu.bme.mit.inf.dslreasoner.logic.model.builder.TypeScopes;
+import hu.bme.mit.inf.dslreasoner.logic.model.builder.VariableContext;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Assertion;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Iff;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguagePackage;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.SymbolicValue;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TermDescription;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Variable;
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.Annotation;
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem;
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicproblemPackage;
+import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.LogicResult;
+import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.ModelResult;
+import hu.bme.mit.inf.dslreasoner.logic2ecore.Logic2Ecore;
+import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2Logic;
+import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2LogicConfiguration;
+import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2LogicTrace;
+import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor;
+import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.Viatra2LogicAnnotationsPackage;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeInferenceMethod;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedralScopePropagatorConstraints;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedralScopePropagatorSolver;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ScopePropagatorStrategy;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.InstanceModel2Logic;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.RelationLink;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretation2Gml;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretationVisualisation;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.CostObjectiveConfiguration;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.CostObjectiveElementConfiguration;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.DebugConfiguration;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.StateCoderStrategy;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasoner;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.PartialModelAsLogicInterpretation;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ObjectiveKind;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ObjectiveThreshold;
+import hu.bme.mit.inf.dslreasoner.visualisation.pi2graphviz.GraphvizVisualiser;
+import hu.bme.mit.inf.dslreasoner.workspace.FileSystemWorkspace;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Predicate;
+import modes3.Modes3Factory;
+import modes3.Modes3ModelRoot;
+import modes3.Modes3Package;
+import modes3.queries.CloseTrains_step_2;
+import modes3.queries.CloseTrains_step_3;
+import modes3.queries.CloseTrains_step_4;
+import modes3.queries.CloseTrains_step_5;
+import modes3.queries.CloseTrains_step_6;
+import modes3.queries.CloseTrains_step_7;
+import modes3.queries.EndOfSiding_step_2;
+import modes3.queries.EndOfSiding_step_3;
+import modes3.queries.EndOfSiding_step_4;
+import modes3.queries.EndOfSiding_step_5;
+import modes3.queries.MisalignedTurnout_step_2;
+import modes3.queries.MisalignedTurnout_step_3;
+import modes3.queries.MisalignedTurnout_step_4;
+import modes3.queries.MisalignedTurnout_step_5;
+import modes3.queries.Modes3Queries;
+import modes3.queries.TrainLocations_step_2;
+import modes3.queries.TrainLocations_step_3;
+import modes3.run.CloseTrainsObjectiveHint;
+import modes3.run.EndOfSidingObjectiveHint;
+import modes3.run.MisalignedTurnoutObjectiveHint;
+import modes3.run.Modes3TypeScopeHint;
+import modes3.run.Modes3UnitPropagationGenerator;
+import modes3.run.TrainLocationsObjectiveHint;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.TreeIterator;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EEnum;
+import org.eclipse.emf.ecore.EEnumLiteral;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
+import org.eclipse.viatra.query.patternlanguage.emf.EMFPatternLanguageStandaloneSetup;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngineOptions;
+import org.eclipse.viatra.query.runtime.localsearch.matcher.integration.LocalSearchEMFBackendFactory;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.rete.matcher.ReteBackendFactory;
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Exceptions;
+import org.eclipse.xtext.xbase.lib.ExclusiveRange;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.InputOutput;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ObjectExtensions;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@FinalFieldsConstructor
+@SuppressWarnings("all")
+public class Modes3ModelGenerator {
+  private enum MonitoringQuery {
+    closeTrains,
+    
+    trainLocations,
+    
+    endOfSiding,
+    
+    misalignedTurnout;
+  }
+  
+  private final Modes3ModelGenerator.MonitoringQuery monitoringQuery;
+  
+  private final int modelSize;
+  
+  private final Ecore2Logic ecore2Logic = new Ecore2Logic();
+  
+  private final InstanceModel2Logic instanceModel2Logic = new InstanceModel2Logic();
+  
+  private final Viatra2Logic viatra2Logic = new Viatra2Logic(this.ecore2Logic);
+  
+  private final ViatraReasoner solver = new ViatraReasoner();
+  
+  @Extension
+  private final LogicProblemBuilder _logicProblemBuilder = new LogicProblemBuilder();
+  
+  public URI generate() {
+    try {
+      URI _xblockexpression = null;
+      {
+        final EcoreMetamodelDescriptor metamodel = Modes3ModelGenerator.createMetamodelDescriptor();
+        Ecore2LogicConfiguration _ecore2LogicConfiguration = new Ecore2LogicConfiguration();
+        final TracedOutput<LogicProblem, Ecore2Logic_Trace> metamodelLogic = this.ecore2Logic.transformMetamodel(metamodel, _ecore2LogicConfiguration);
+        final Type segment = this.ecore2Logic.TypeofEClass(metamodelLogic.getTrace(), Modes3Package.eINSTANCE.getSegment());
+        final RelationDeclaration connectedTo = this.ecore2Logic.relationOfReference(metamodelLogic.getTrace(), 
+          Modes3Package.eINSTANCE.getSegment_ConnectedTo());
+        final RelationDeclaration connectedToIndicator = ((EReferenceMapper_RelationsOverTypes_Trace) metamodelLogic.getTrace().referenceMapperTrace).indicators.get(
+          Modes3Package.eINSTANCE.getSegment_ConnectedTo());
+        StringConcatenation _builder = new StringConcatenation();
+        _builder.append("oppositeReference ");
+        String _name = connectedTo.getName();
+        _builder.append(_name);
+        _builder.append(" ");
+        String _name_1 = connectedTo.getName();
+        _builder.append(_name_1);
+        final Function1<VariableContext, TermDescription> _function = (VariableContext it) -> {
+          Iff _xblockexpression_1 = null;
+          {
+            StringConcatenation _builder_1 = new StringConcatenation();
+            _builder_1.append("src");
+            final Variable src = it.addVar(_builder_1, segment);
+            StringConcatenation _builder_2 = new StringConcatenation();
+            _builder_2.append("trg");
+            final Variable trg = it.addVar(_builder_2, segment);
+            SymbolicValue _call = this._logicProblemBuilder.call(connectedToIndicator, src, trg);
+            SymbolicValue _call_1 = this._logicProblemBuilder.call(connectedToIndicator, trg, src);
+            _xblockexpression_1 = this._logicProblemBuilder.operator_spaceship(_call, _call_1);
+          }
+          return _xblockexpression_1;
+        };
+        final Assertion inverseAssertion = this._logicProblemBuilder.Assertion(_builder, 
+          this._logicProblemBuilder.Forall(_function));
+        EList<Assertion> _assertions = metamodelLogic.getOutput().getAssertions();
+        _assertions.add(inverseAssertion);
+        InverseRelationAssertion _createInverseRelationAssertion = Ecore2logicannotationsFactory.eINSTANCE.createInverseRelationAssertion();
+        final Procedure1<InverseRelationAssertion> _function_1 = (InverseRelationAssertion it) -> {
+          it.setTarget(inverseAssertion);
+          it.setInverseA(connectedTo);
+          it.setInverseB(connectedTo);
+        };
+        final InverseRelationAssertion inverseAnnotation = ObjectExtensions.<InverseRelationAssertion>operator_doubleArrow(_createInverseRelationAssertion, _function_1);
+        EList<Annotation> _annotations = metamodelLogic.getOutput().getAnnotations();
+        _annotations.add(inverseAnnotation);
+        final List<EObject> initialModel = Modes3ModelGenerator.loadInitialModel();
+        final TracedOutput<LogicProblem, Ecore2Logic_Trace> initialModelLogic = this.instanceModel2Logic.transform(metamodelLogic, initialModel);
+        final ViatraQuerySetDescriptor queries = this.loadQueries();
+        Viatra2LogicConfiguration _viatra2LogicConfiguration = new Viatra2LogicConfiguration();
+        final TracedOutput<LogicProblem, Viatra2LogicTrace> logic = this.viatra2Logic.transformQueries(queries, initialModelLogic, _viatra2LogicConfiguration);
+        ViatraReasonerConfiguration _viatraReasonerConfiguration = new ViatraReasonerConfiguration();
+        final Procedure1<ViatraReasonerConfiguration> _function_2 = (ViatraReasonerConfiguration it) -> {
+          it.runtimeLimit = 3600;
+          final Procedure1<TypeScopes> _function_3 = (TypeScopes it_1) -> {
+            it_1.minNewElements = this.modelSize;
+            it_1.maxNewElements = this.modelSize;
+            final Procedure1<Map<Type, Integer>> _function_4 = (Map<Type, Integer> it_2) -> {
+            };
+            ObjectExtensions.<Map<Type, Integer>>operator_doubleArrow(
+              it_1.minNewElementsByType, _function_4);
+            final Procedure1<Map<Type, Integer>> _function_5 = (Map<Type, Integer> it_2) -> {
+              it_2.put(this.ecore2Logic.TypeofEClass(metamodelLogic.getTrace(), Modes3Package.eINSTANCE.getTrain()), Integer.valueOf((this.modelSize / 5)));
+              it_2.put(this.ecore2Logic.TypeofEClass(metamodelLogic.getTrace(), Modes3Package.eINSTANCE.getTurnout()), Integer.valueOf((this.modelSize / 5)));
+              it_2.put(this.ecore2Logic.TypeofEClass(metamodelLogic.getTrace(), Modes3Package.eINSTANCE.getSimpleSegment()), Integer.valueOf(((3 * this.modelSize) / 5)));
+            };
+            ObjectExtensions.<Map<Type, Integer>>operator_doubleArrow(
+              it_1.maxNewElementsByType, _function_5);
+          };
+          ObjectExtensions.<TypeScopes>operator_doubleArrow(
+            it.typeScopes, _function_3);
+          final Procedure1<SolutionScope> _function_4 = (SolutionScope it_1) -> {
+            it_1.numberOfRequiredSolutions = 1;
+          };
+          ObjectExtensions.<SolutionScope>operator_doubleArrow(
+            it.solutionScope, _function_4);
+          CostObjectiveConfiguration _objective = this.getObjective(this.ecore2Logic, metamodelLogic.getTrace());
+          it.costObjectives.add(_objective);
+          it.scopeWeight = 6;
+          it.nameNewElements = false;
+          it.typeInferenceMethod = TypeInferenceMethod.PreliminaryAnalysis;
+          it.stateCoderStrategy = StateCoderStrategy.PairwiseNeighbourhood;
+          ScopePropagatorStrategy.Polyhedral _polyhedral = new ScopePropagatorStrategy.Polyhedral(
+            PolyhedralScopePropagatorConstraints.Relational, PolyhedralScopePropagatorSolver.Clp);
+          it.scopePropagatorStrategy = _polyhedral;
+          Ecore2Logic_Trace _trace = metamodelLogic.getTrace();
+          Modes3TypeScopeHint _modes3TypeScopeHint = new Modes3TypeScopeHint(this.ecore2Logic, _trace);
+          it.hints.add(_modes3TypeScopeHint);
+          Ecore2Logic_Trace _trace_1 = metamodelLogic.getTrace();
+          Modes3UnitPropagationGenerator _modes3UnitPropagationGenerator = new Modes3UnitPropagationGenerator(this.ecore2Logic, _trace_1);
+          it.unitPropagationPatternGenerators.add(_modes3UnitPropagationGenerator);
+          final Procedure1<DebugConfiguration> _function_5 = (DebugConfiguration it_1) -> {
+            GraphvizVisualiser _graphvizVisualiser = new GraphvizVisualiser();
+            it_1.partialInterpretatioVisualiser = _graphvizVisualiser;
+          };
+          ObjectExtensions.<DebugConfiguration>operator_doubleArrow(
+            it.debugConfiguration, _function_5);
+          it.documentationLevel = DocumentationLevel.NORMAL;
+        };
+        final ViatraReasonerConfiguration config = ObjectExtensions.<ViatraReasonerConfiguration>operator_doubleArrow(_viatraReasonerConfiguration, _function_2);
+        final FileSystemWorkspace workspace = new FileSystemWorkspace("output/", "");
+        workspace.writeModel(logic.getOutput(), "problem.logicproblem");
+        final LogicResult solution = this.solver.solve(logic.getOutput(), config, workspace);
+        URI _xifexpression = null;
+        if ((solution instanceof ModelResult)) {
+          InputOutput.<String>println("Saving generated solutions");
+          final Logic2Ecore logic2Ecore = new Logic2Ecore(this.ecore2Logic);
+          final List<? extends LogicModelInterpretation> interpretations = this.solver.getInterpretations(((ModelResult)solution));
+          int _size = interpretations.size();
+          ExclusiveRange _doubleDotLessThan = new ExclusiveRange(0, _size, true);
+          for (final Integer representationIndex : _doubleDotLessThan) {
+            {
+              final LogicModelInterpretation interpretation = interpretations.get((representationIndex).intValue());
+              final int representationNumber = ((representationIndex).intValue() + 1);
+              if ((interpretation instanceof PartialModelAsLogicInterpretation)) {
+                final PartialInterpretation representation = ((PartialModelAsLogicInterpretation)interpretation).getPartialInterpretation();
+                StringConcatenation _builder_1 = new StringConcatenation();
+                _builder_1.append("solution");
+                _builder_1.append(representationNumber);
+                _builder_1.append(".partialinterpretation");
+                workspace.writeModel(representation, _builder_1.toString());
+                final PartialInterpretation2Gml partialInterpretation2GML = new PartialInterpretation2Gml();
+                final String gml = partialInterpretation2GML.transform(representation);
+                StringConcatenation _builder_2 = new StringConcatenation();
+                _builder_2.append("solution");
+                _builder_2.append(representationNumber);
+                _builder_2.append(".gml");
+                workspace.writeText(_builder_2.toString(), gml);
+                final EObject model = logic2Ecore.transformInterpretation(interpretation, metamodelLogic.getTrace());
+                final TreeIterator<EObject> iterator = model.eAllContents();
+                int id = 0;
+                while (iterator.hasNext()) {
+                  {
+                    final EObject obj = iterator.next();
+                    final Function1<EAttribute, Boolean> _function_3 = (EAttribute it) -> {
+                      String _name_2 = it.getName();
+                      return Boolean.valueOf(Objects.equal(_name_2, "id"));
+                    };
+                    final EAttribute idFeature = IterableExtensions.<EAttribute>findFirst(obj.eClass().getEAllAttributes(), _function_3);
+                    if ((idFeature != null)) {
+                      obj.eSet(idFeature, Integer.valueOf(id));
+                      id++;
+                    }
+                  }
+                }
+                StringConcatenation _builder_3 = new StringConcatenation();
+                _builder_3.append("solution");
+                _builder_3.append(representationNumber);
+                _builder_3.append(".modes3");
+                workspace.writeModel(model, _builder_3.toString());
+                int _size_1 = representation.getNewElements().size();
+                boolean _lessThan = (_size_1 < 160);
+                if (_lessThan) {
+                  final Function1<Type, Boolean> _function_3 = (Type it) -> {
+                    String _name_2 = it.getName();
+                    return Boolean.valueOf(Objects.equal(_name_2, "Modes3ModelRoot class DefinedPart"));
+                  };
+                  Type _findFirst = IterableExtensions.<Type>findFirst(representation.getProblem().getTypes(), _function_3);
+                  final TypeDefinition rootType = ((TypeDefinition) _findFirst);
+                  final Function1<PartialComplexTypeInterpretation, Boolean> _function_4 = (PartialComplexTypeInterpretation it) -> {
+                    String _name_2 = it.getInterpretationOf().getName();
+                    return Boolean.valueOf(Objects.equal(_name_2, "Modes3ModelRoot class"));
+                  };
+                  final PartialComplexTypeInterpretation rootIntepretation = IterableExtensions.<PartialComplexTypeInterpretation>findFirst(Iterables.<PartialComplexTypeInterpretation>filter(representation.getPartialtypeinterpratation(), 
+                    PartialComplexTypeInterpretation.class), _function_4);
+                  rootIntepretation.getElements().removeAll(rootType.getElements());
+                  representation.getProblem().getElements().removeAll(rootType.getElements());
+                  EList<PartialRelationInterpretation> _partialrelationinterpretation = representation.getPartialrelationinterpretation();
+                  for (final PartialRelationInterpretation relationInterpretation : _partialrelationinterpretation) {
+                    final Predicate<RelationLink> _function_5 = (RelationLink link) -> {
+                      boolean _xifexpression_1 = false;
+                      if ((link instanceof BinaryElementRelationLink)) {
+                        _xifexpression_1 = (rootType.getElements().contains(((BinaryElementRelationLink)link).getParam1()) || 
+                          rootType.getElements().contains(((BinaryElementRelationLink)link).getParam2()));
+                      } else {
+                        _xifexpression_1 = false;
+                      }
+                      return _xifexpression_1;
+                    };
+                    relationInterpretation.getRelationlinks().removeIf(_function_5);
+                  }
+                  rootType.getElements().clear();
+                  final GraphvizVisualiser visualiser = new GraphvizVisualiser();
+                  final PartialInterpretationVisualisation visualisation = visualiser.visualiseConcretization(representation);
+                  StringConcatenation _builder_4 = new StringConcatenation();
+                  _builder_4.append("solution");
+                  _builder_4.append(representationNumber);
+                  _builder_4.append(".png");
+                  visualisation.writeToFile(workspace, _builder_4.toString());
+                }
+              } else {
+                StringConcatenation _builder_5 = new StringConcatenation();
+                _builder_5.append("solution");
+                _builder_5.append(representationNumber);
+                _builder_5.append(".txt");
+                workspace.writeText(_builder_5.toString(), interpretation.toString());
+              }
+            }
+          }
+        } else {
+          URI _xblockexpression_1 = null;
+          {
+            InputOutput.<String>println("Failed to solve problem");
+            final LogicProblem partial = logic.getOutput();
+            _xblockexpression_1 = workspace.writeModel(partial, "solution.partialinterpretation");
+          }
+          _xifexpression = _xblockexpression_1;
+        }
+        _xblockexpression = _xifexpression;
+      }
+      return _xblockexpression;
+    } catch (Throwable _e) {
+      throw Exceptions.sneakyThrow(_e);
+    }
+  }
+  
+  public static EcoreMetamodelDescriptor createMetamodelDescriptor() {
+    EcoreMetamodelDescriptor _xblockexpression = null;
+    {
+      final ImmutableList<EClass> eClasses = ImmutableList.<EClass>copyOf(Iterables.<EClass>filter(Modes3Package.eINSTANCE.getEClassifiers(), EClass.class));
+      Set<EClass> _emptySet = CollectionLiterals.<EClass>emptySet();
+      List<EEnum> _emptyList = CollectionLiterals.<EEnum>emptyList();
+      List<EEnumLiteral> _emptyList_1 = CollectionLiterals.<EEnumLiteral>emptyList();
+      final Function1<EClass, EList<EReference>> _function = (EClass it) -> {
+        return it.getEReferences();
+      };
+      ImmutableList<EReference> _copyOf = ImmutableList.<EReference>copyOf(IterableExtensions.<EClass, EReference>flatMap(eClasses, _function));
+      List<EAttribute> _emptyList_2 = CollectionLiterals.<EAttribute>emptyList();
+      _xblockexpression = new EcoreMetamodelDescriptor(eClasses, _emptySet, 
+        false, _emptyList, _emptyList_1, _copyOf, _emptyList_2);
+    }
+    return _xblockexpression;
+  }
+  
+  public static List<EObject> loadInitialModel() {
+    Modes3ModelRoot _createModes3ModelRoot = Modes3Factory.eINSTANCE.createModes3ModelRoot();
+    return Collections.<EObject>unmodifiableList(CollectionLiterals.<EObject>newArrayList(_createModes3ModelRoot));
+  }
+  
+  public ViatraQuerySetDescriptor loadQueries() {
+    ViatraQuerySetDescriptor _xblockexpression = null;
+    {
+      final ImmutableList.Builder<IQuerySpecification<?>> patternsBuilder = ImmutableList.<IQuerySpecification<?>>builder();
+      patternsBuilder.addAll(Modes3Queries.instance().getSpecifications());
+      final ImmutableList<IQuerySpecification<?>> patterns = patternsBuilder.build();
+      final Function1<IQuerySpecification<?>, Boolean> _function = (IQuerySpecification<?> pattern) -> {
+        final Function1<PAnnotation, Boolean> _function_1 = (PAnnotation it) -> {
+          String _name = it.getName();
+          return Boolean.valueOf(Objects.equal(_name, "Constraint"));
+        };
+        return Boolean.valueOf(IterableExtensions.<PAnnotation>exists(pattern.getAllAnnotations(), _function_1));
+      };
+      final ImmutableSet<IQuerySpecification<?>> validationPatterns = ImmutableSet.<IQuerySpecification<?>>copyOf(IterableExtensions.<IQuerySpecification<?>>filter(patterns, _function));
+      Map<IQuerySpecification<?>, EStructuralFeature> _emptyMap = CollectionLiterals.<IQuerySpecification<?>, EStructuralFeature>emptyMap();
+      _xblockexpression = new ViatraQuerySetDescriptor(patterns, validationPatterns, _emptyMap);
+    }
+    return _xblockexpression;
+  }
+  
+  public CostObjectiveConfiguration getObjective(final Ecore2Logic ecore2Logic, final Ecore2Logic_Trace ecore2LogicTrace) {
+    CostObjectiveConfiguration _costObjectiveConfiguration = new CostObjectiveConfiguration();
+    final Procedure1<CostObjectiveConfiguration> _function = (CostObjectiveConfiguration it) -> {
+      final Modes3ModelGenerator.MonitoringQuery monitoringQuery = this.monitoringQuery;
+      if (monitoringQuery != null) {
+        switch (monitoringQuery) {
+          case closeTrains:
+            CostObjectiveElementConfiguration _costObjectiveElementConfiguration = new CostObjectiveElementConfiguration();
+            final Procedure1<CostObjectiveElementConfiguration> _function_1 = (CostObjectiveElementConfiguration it_1) -> {
+              it_1.patternQualifiedName = CloseTrains_step_2.instance().getFullyQualifiedName();
+              it_1.weight = ((14 + 53) + 11);
+            };
+            CostObjectiveElementConfiguration _doubleArrow = ObjectExtensions.<CostObjectiveElementConfiguration>operator_doubleArrow(_costObjectiveElementConfiguration, _function_1);
+            it.elements.add(_doubleArrow);
+            CostObjectiveElementConfiguration _costObjectiveElementConfiguration_1 = new CostObjectiveElementConfiguration();
+            final Procedure1<CostObjectiveElementConfiguration> _function_2 = (CostObjectiveElementConfiguration it_1) -> {
+              it_1.patternQualifiedName = CloseTrains_step_3.instance().getFullyQualifiedName();
+              it_1.weight = (21 + 14);
+            };
+            CostObjectiveElementConfiguration _doubleArrow_1 = ObjectExtensions.<CostObjectiveElementConfiguration>operator_doubleArrow(_costObjectiveElementConfiguration_1, _function_2);
+            it.elements.add(_doubleArrow_1);
+            CostObjectiveElementConfiguration _costObjectiveElementConfiguration_2 = new CostObjectiveElementConfiguration();
+            final Procedure1<CostObjectiveElementConfiguration> _function_3 = (CostObjectiveElementConfiguration it_1) -> {
+              it_1.patternQualifiedName = CloseTrains_step_4.instance().getFullyQualifiedName();
+              it_1.weight = (((14 + 44) + 14) + 9);
+            };
+            CostObjectiveElementConfiguration _doubleArrow_2 = ObjectExtensions.<CostObjectiveElementConfiguration>operator_doubleArrow(_costObjectiveElementConfiguration_2, _function_3);
+            it.elements.add(_doubleArrow_2);
+            CostObjectiveElementConfiguration _costObjectiveElementConfiguration_3 = new CostObjectiveElementConfiguration();
+            final Procedure1<CostObjectiveElementConfiguration> _function_4 = (CostObjectiveElementConfiguration it_1) -> {
+              it_1.patternQualifiedName = CloseTrains_step_5.instance().getFullyQualifiedName();
+              it_1.weight = ((14 + 41) + 11);
+            };
+            CostObjectiveElementConfiguration _doubleArrow_3 = ObjectExtensions.<CostObjectiveElementConfiguration>operator_doubleArrow(_costObjectiveElementConfiguration_3, _function_4);
+            it.elements.add(_doubleArrow_3);
+            CostObjectiveElementConfiguration _costObjectiveElementConfiguration_4 = new CostObjectiveElementConfiguration();
+            final Procedure1<CostObjectiveElementConfiguration> _function_5 = (CostObjectiveElementConfiguration it_1) -> {
+              it_1.patternQualifiedName = CloseTrains_step_6.instance().getFullyQualifiedName();
+              it_1.weight = 27;
+            };
+            CostObjectiveElementConfiguration _doubleArrow_4 = ObjectExtensions.<CostObjectiveElementConfiguration>operator_doubleArrow(_costObjectiveElementConfiguration_4, _function_5);
+            it.elements.add(_doubleArrow_4);
+            CostObjectiveElementConfiguration _costObjectiveElementConfiguration_5 = new CostObjectiveElementConfiguration();
+            final Procedure1<CostObjectiveElementConfiguration> _function_6 = (CostObjectiveElementConfiguration it_1) -> {
+              it_1.patternQualifiedName = CloseTrains_step_7.instance().getFullyQualifiedName();
+              it_1.weight = 48;
+            };
+            CostObjectiveElementConfiguration _doubleArrow_5 = ObjectExtensions.<CostObjectiveElementConfiguration>operator_doubleArrow(_costObjectiveElementConfiguration_5, _function_6);
+            it.elements.add(_doubleArrow_5);
+            CloseTrainsObjectiveHint _closeTrainsObjectiveHint = new CloseTrainsObjectiveHint(ecore2Logic, ecore2LogicTrace);
+            it.hint = _closeTrainsObjectiveHint;
+            break;
+          case trainLocations:
+            CostObjectiveElementConfiguration _costObjectiveElementConfiguration_6 = new CostObjectiveElementConfiguration();
+            final Procedure1<CostObjectiveElementConfiguration> _function_7 = (CostObjectiveElementConfiguration it_1) -> {
+              it_1.patternQualifiedName = TrainLocations_step_2.instance().getFullyQualifiedName();
+              it_1.weight = ((14 + 53) + 11);
+            };
+            CostObjectiveElementConfiguration _doubleArrow_6 = ObjectExtensions.<CostObjectiveElementConfiguration>operator_doubleArrow(_costObjectiveElementConfiguration_6, _function_7);
+            it.elements.add(_doubleArrow_6);
+            CostObjectiveElementConfiguration _costObjectiveElementConfiguration_7 = new CostObjectiveElementConfiguration();
+            final Procedure1<CostObjectiveElementConfiguration> _function_8 = (CostObjectiveElementConfiguration it_1) -> {
+              it_1.patternQualifiedName = TrainLocations_step_3.instance().getFullyQualifiedName();
+              it_1.weight = 48;
+            };
+            CostObjectiveElementConfiguration _doubleArrow_7 = ObjectExtensions.<CostObjectiveElementConfiguration>operator_doubleArrow(_costObjectiveElementConfiguration_7, _function_8);
+            it.elements.add(_doubleArrow_7);
+            TrainLocationsObjectiveHint _trainLocationsObjectiveHint = new TrainLocationsObjectiveHint(ecore2Logic, ecore2LogicTrace);
+            it.hint = _trainLocationsObjectiveHint;
+            break;
+          case misalignedTurnout:
+            CostObjectiveElementConfiguration _costObjectiveElementConfiguration_8 = new CostObjectiveElementConfiguration();
+            final Procedure1<CostObjectiveElementConfiguration> _function_9 = (CostObjectiveElementConfiguration it_1) -> {
+              it_1.patternQualifiedName = MisalignedTurnout_step_2.instance().getFullyQualifiedName();
+              it_1.weight = ((14 + 53) + 11);
+            };
+            CostObjectiveElementConfiguration _doubleArrow_8 = ObjectExtensions.<CostObjectiveElementConfiguration>operator_doubleArrow(_costObjectiveElementConfiguration_8, _function_9);
+            it.elements.add(_doubleArrow_8);
+            CostObjectiveElementConfiguration _costObjectiveElementConfiguration_9 = new CostObjectiveElementConfiguration();
+            final Procedure1<CostObjectiveElementConfiguration> _function_10 = (CostObjectiveElementConfiguration it_1) -> {
+              it_1.patternQualifiedName = MisalignedTurnout_step_3.instance().getFullyQualifiedName();
+              it_1.weight = 108;
+            };
+            CostObjectiveElementConfiguration _doubleArrow_9 = ObjectExtensions.<CostObjectiveElementConfiguration>operator_doubleArrow(_costObjectiveElementConfiguration_9, _function_10);
+            it.elements.add(_doubleArrow_9);
+            CostObjectiveElementConfiguration _costObjectiveElementConfiguration_10 = new CostObjectiveElementConfiguration();
+            final Procedure1<CostObjectiveElementConfiguration> _function_11 = (CostObjectiveElementConfiguration it_1) -> {
+              it_1.patternQualifiedName = MisalignedTurnout_step_4.instance().getFullyQualifiedName();
+              it_1.weight = 27;
+            };
+            CostObjectiveElementConfiguration _doubleArrow_10 = ObjectExtensions.<CostObjectiveElementConfiguration>operator_doubleArrow(_costObjectiveElementConfiguration_10, _function_11);
+            it.elements.add(_doubleArrow_10);
+            CostObjectiveElementConfiguration _costObjectiveElementConfiguration_11 = new CostObjectiveElementConfiguration();
+            final Procedure1<CostObjectiveElementConfiguration> _function_12 = (CostObjectiveElementConfiguration it_1) -> {
+              it_1.patternQualifiedName = MisalignedTurnout_step_5.instance().getFullyQualifiedName();
+              it_1.weight = 48;
+            };
+            CostObjectiveElementConfiguration _doubleArrow_11 = ObjectExtensions.<CostObjectiveElementConfiguration>operator_doubleArrow(_costObjectiveElementConfiguration_11, _function_12);
+            it.elements.add(_doubleArrow_11);
+            MisalignedTurnoutObjectiveHint _misalignedTurnoutObjectiveHint = new MisalignedTurnoutObjectiveHint(ecore2Logic, ecore2LogicTrace);
+            it.hint = _misalignedTurnoutObjectiveHint;
+            break;
+          case endOfSiding:
+            CostObjectiveElementConfiguration _costObjectiveElementConfiguration_12 = new CostObjectiveElementConfiguration();
+            final Procedure1<CostObjectiveElementConfiguration> _function_13 = (CostObjectiveElementConfiguration it_1) -> {
+              it_1.patternQualifiedName = EndOfSiding_step_2.instance().getFullyQualifiedName();
+              it_1.weight = ((14 + 53) + 11);
+            };
+            CostObjectiveElementConfiguration _doubleArrow_12 = ObjectExtensions.<CostObjectiveElementConfiguration>operator_doubleArrow(_costObjectiveElementConfiguration_12, _function_13);
+            it.elements.add(_doubleArrow_12);
+            CostObjectiveElementConfiguration _costObjectiveElementConfiguration_13 = new CostObjectiveElementConfiguration();
+            final Procedure1<CostObjectiveElementConfiguration> _function_14 = (CostObjectiveElementConfiguration it_1) -> {
+              it_1.patternQualifiedName = EndOfSiding_step_3.instance().getFullyQualifiedName();
+              it_1.weight = (21 + 14);
+            };
+            CostObjectiveElementConfiguration _doubleArrow_13 = ObjectExtensions.<CostObjectiveElementConfiguration>operator_doubleArrow(_costObjectiveElementConfiguration_13, _function_14);
+            it.elements.add(_doubleArrow_13);
+            CostObjectiveElementConfiguration _costObjectiveElementConfiguration_14 = new CostObjectiveElementConfiguration();
+            final Procedure1<CostObjectiveElementConfiguration> _function_15 = (CostObjectiveElementConfiguration it_1) -> {
+              it_1.patternQualifiedName = EndOfSiding_step_4.instance().getFullyQualifiedName();
+              it_1.weight = (((((((14 + 35) + 21) + 15) + 14) + 21) + 15) + 11);
+            };
+            CostObjectiveElementConfiguration _doubleArrow_14 = ObjectExtensions.<CostObjectiveElementConfiguration>operator_doubleArrow(_costObjectiveElementConfiguration_14, _function_15);
+            it.elements.add(_doubleArrow_14);
+            CostObjectiveElementConfiguration _costObjectiveElementConfiguration_15 = new CostObjectiveElementConfiguration();
+            final Procedure1<CostObjectiveElementConfiguration> _function_16 = (CostObjectiveElementConfiguration it_1) -> {
+              it_1.patternQualifiedName = EndOfSiding_step_5.instance().getFullyQualifiedName();
+              it_1.weight = 48;
+            };
+            CostObjectiveElementConfiguration _doubleArrow_15 = ObjectExtensions.<CostObjectiveElementConfiguration>operator_doubleArrow(_costObjectiveElementConfiguration_15, _function_16);
+            it.elements.add(_doubleArrow_15);
+            EndOfSidingObjectiveHint _endOfSidingObjectiveHint = new EndOfSidingObjectiveHint(ecore2Logic, ecore2LogicTrace);
+            it.hint = _endOfSidingObjectiveHint;
+            break;
+          default:
+            throw new IllegalArgumentException(("Unknown monitoring query: " + this.monitoringQuery));
+        }
+      } else {
+        throw new IllegalArgumentException(("Unknown monitoring query: " + this.monitoringQuery));
+      }
+      it.kind = ObjectiveKind.HIGHER_IS_BETTER;
+      it.threshold = ObjectiveThreshold.NO_THRESHOLD;
+      it.findExtremum = true;
+    };
+    return ObjectExtensions.<CostObjectiveConfiguration>operator_doubleArrow(_costObjectiveConfiguration, _function);
+  }
+  
+  public static Object init() {
+    Object _xblockexpression = null;
+    {
+      EMFPatternLanguageStandaloneSetup.doSetup();
+      ViatraQueryEngineOptions.setSystemDefaultBackends(ReteBackendFactory.INSTANCE, ReteBackendFactory.INSTANCE, 
+        LocalSearchEMFBackendFactory.INSTANCE);
+      LogiclanguagePackage.eINSTANCE.getClass();
+      LogicproblemPackage.eINSTANCE.getClass();
+      PartialinterpretationPackage.eINSTANCE.getClass();
+      Ecore2logicannotationsPackage.eINSTANCE.getClass();
+      Viatra2LogicAnnotationsPackage.eINSTANCE.getClass();
+      Map<String, Object> _extensionToFactoryMap = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap();
+      XMIResourceFactoryImpl _xMIResourceFactoryImpl = new XMIResourceFactoryImpl();
+      _xblockexpression = _extensionToFactoryMap.put("*", _xMIResourceFactoryImpl);
+    }
+    return _xblockexpression;
+  }
+  
+  public static void main(final String[] args) {
+    int _length = args.length;
+    boolean _notEquals = (_length != 2);
+    if (_notEquals) {
+      System.err.println("Usage: <query> <model size>");
+    }
+    final Modes3ModelGenerator.MonitoringQuery monitoringQuery = Modes3ModelGenerator.MonitoringQuery.valueOf(args[0]);
+    final int modelSize = Integer.parseInt(args[1]);
+    Modes3ModelGenerator.init();
+    final Modes3ModelGenerator generator = new Modes3ModelGenerator(monitoringQuery, modelSize);
+    generator.generate();
+  }
+  
+  public Modes3ModelGenerator(final Modes3ModelGenerator.MonitoringQuery monitoringQuery, final int modelSize) {
+    super();
+    this.monitoringQuery = monitoringQuery;
+    this.modelSize = modelSize;
+  }
+}
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/Modes3TypeScopeHint.java b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/Modes3TypeScopeHint.java
new file mode 100644
index 00000000..adb69760
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/Modes3TypeScopeHint.java
@@ -0,0 +1,133 @@
+package modes3.run;
+
+import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.LinearBoundedExpression;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.LinearTypeConstraintHint;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.LinearTypeExpressionBuilderFactory;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.RelationConstraintUpdater;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.PatternGenerator;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation;
+import java.util.Iterator;
+import java.util.Map;
+import modes3.Modes3Package;
+import modes3.queries.Adjacent;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.Extension;
+
+@SuppressWarnings("all")
+public class Modes3TypeScopeHint implements LinearTypeConstraintHint {
+  private static final String TURNOUT_NEIGHBOR_COUNT = "turnoutNeighborCount";
+  
+  private final Type segmentType;
+  
+  private final Type turnoutType;
+  
+  public Modes3TypeScopeHint(@Extension final Ecore2Logic ecore2Logic, final Ecore2Logic_Trace ecore2LogicTrace) {
+    @Extension
+    final Modes3Package Modes3Package = modes3.Modes3Package.eINSTANCE;
+    this.segmentType = ecore2Logic.TypeofEClass(ecore2LogicTrace, Modes3Package.getSegment());
+    this.turnoutType = ecore2Logic.TypeofEClass(ecore2LogicTrace, Modes3Package.getTurnout());
+  }
+  
+  @Override
+  public CharSequence getAdditionalPatterns(@Extension final PatternGenerator patternGenerator, final Map<String, PQuery> fqnToPQuery) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("\t");
+    _builder.append("pattern ");
+    _builder.append(Modes3TypeScopeHint.TURNOUT_NEIGHBOR_COUNT, "\t");
+    _builder.append("_helper(problem: LogicProblem, interpretation: PartialInterpretation, source: DefinedElement, target: DefinedElement) {");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t\t");
+    _builder.append("find interpretation(problem, interpretation);");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("find mustExist(problem, interpretation, source);");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("find mustExist(problem, interpretation, target);");
+    _builder.newLine();
+    _builder.append("\t\t");
+    CharSequence _referInstanceOf = patternGenerator.getTypeIndexer().referInstanceOf(this.turnoutType, Modality.MUST, "source");
+    _builder.append(_referInstanceOf, "\t\t");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t\t");
+    CharSequence _referInstanceOf_1 = patternGenerator.getTypeIndexer().referInstanceOf(this.segmentType, Modality.MUST, "target");
+    _builder.append(_referInstanceOf_1, "\t\t");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t\t");
+    CharSequence _referPattern = patternGenerator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Adjacent.instance().getFullyQualifiedName()), new String[] { "source", "target" }, Modality.MUST, true, false);
+    _builder.append(_referPattern, "\t\t");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t");
+    _builder.append("}");
+    _builder.newLine();
+    _builder.newLine();
+    _builder.append("\t");
+    _builder.append("pattern ");
+    _builder.append(Modes3TypeScopeHint.TURNOUT_NEIGHBOR_COUNT, "\t");
+    _builder.append("(problem: LogicProblem, interpretation: PartialInterpretation, element: DefinedElement, N) {");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t\t");
+    _builder.append("find interpretation(problem, interpretation);");
+    _builder.newLine();
+    _builder.append("\t\t");
+    _builder.append("find mustExist(problem, interpretation, element);");
+    _builder.newLine();
+    _builder.append("\t\t");
+    CharSequence _referInstanceOf_2 = patternGenerator.getTypeIndexer().referInstanceOf(this.turnoutType, Modality.MUST, "element");
+    _builder.append(_referInstanceOf_2, "\t\t");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t\t");
+    _builder.append("N == count find ");
+    _builder.append(Modes3TypeScopeHint.TURNOUT_NEIGHBOR_COUNT, "\t\t");
+    _builder.append("_helper(problem, interpretation, element, _);");
+    _builder.newLineIfNotEmpty();
+    _builder.append("\t");
+    _builder.append("}");
+    _builder.newLine();
+    return _builder;
+  }
+  
+  @Override
+  public RelationConstraintUpdater createConstraintUpdater(final LinearTypeExpressionBuilderFactory builderFactory) {
+    final ViatraQueryMatcher<? extends IPatternMatch> turnoutNeighborCountMatcher = builderFactory.createMatcher(Modes3TypeScopeHint.TURNOUT_NEIGHBOR_COUNT);
+    final LinearBoundedExpression newNeighbors = builderFactory.createBuilder().add(1, this.segmentType).build();
+    final RelationConstraintUpdater _function = (PartialInterpretation partialInterpretation) -> {
+      final int requiredNeighbbors = Modes3TypeScopeHint.getRemainingCount(turnoutNeighborCountMatcher, partialInterpretation, 3);
+      newNeighbors.tightenLowerBound(Integer.valueOf(requiredNeighbbors));
+    };
+    return _function;
+  }
+  
+  private static <T extends IPatternMatch> int getRemainingCount(final ViatraQueryMatcher<T> matcher, final PartialInterpretation partialInterpretation, final int capacity) {
+    int _xblockexpression = (int) 0;
+    {
+      final T partialMatch = matcher.newEmptyMatch();
+      partialMatch.set(0, partialInterpretation.getProblem());
+      partialMatch.set(1, partialInterpretation);
+      final Iterator<T> iterator = matcher.streamAllMatches(partialMatch).iterator();
+      int max = 0;
+      while (iterator.hasNext()) {
+        {
+          final T match = iterator.next();
+          Object _get = match.get(3);
+          final int n = ((Integer) _get).intValue();
+          if ((n < capacity)) {
+            final int required = (capacity - n);
+            if ((max < required)) {
+              max = required;
+            }
+          }
+        }
+      }
+      _xblockexpression = max;
+    }
+    return _xblockexpression;
+  }
+}
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/Modes3UnitPropagationGenerator.java b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/Modes3UnitPropagationGenerator.java
new file mode 100644
index 00000000..5c5f82c5
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/Modes3UnitPropagationGenerator.java
@@ -0,0 +1,1174 @@
+package modes3.run;
+
+import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.PatternGenerator;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.UnitPropagationPatternGenerator;
+import java.util.Collections;
+import java.util.Map;
+import modes3.Modes3Package;
+import modes3.queries.Adjacent;
+import modes3.queries.Output;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery;
+import org.eclipse.xtend2.lib.StringConcatenationClient;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Pair;
+
+@SuppressWarnings("all")
+public class Modes3UnitPropagationGenerator implements UnitPropagationPatternGenerator {
+  private static final String MUST_NOT_CONNECTED_TO = "mustNotConnectedTo";
+  
+  private static final String MUST_NOT_STRAIGHT = "mustNotStraight";
+  
+  private static final String MUST_NOT_DIVERGENT = "mustNotDivergent";
+  
+  private static final String MUST_CONNECTED_TO = "mustConnectedTo";
+  
+  private static final String MUST_STRAIGHT = "mustStraight";
+  
+  private static final String MUST_DIVERGENT = "mustDivergent";
+  
+  private final Type segmentType;
+  
+  private final Type simpleSegmentType;
+  
+  private final Type turnoutType;
+  
+  private final Relation connectedToRelation;
+  
+  private final Relation straightRelation;
+  
+  private final Relation divergentRelation;
+  
+  public Modes3UnitPropagationGenerator(@Extension final Ecore2Logic ecore2Logic, final Ecore2Logic_Trace ecore2LogicTrace) {
+    @Extension
+    final Modes3Package Modes3Package = modes3.Modes3Package.eINSTANCE;
+    this.segmentType = ecore2Logic.TypeofEClass(ecore2LogicTrace, Modes3Package.getSegment());
+    this.simpleSegmentType = ecore2Logic.TypeofEClass(ecore2LogicTrace, Modes3Package.getSimpleSegment());
+    this.turnoutType = ecore2Logic.TypeofEClass(ecore2LogicTrace, Modes3Package.getTurnout());
+    this.connectedToRelation = ecore2Logic.relationOfReference(ecore2LogicTrace, Modes3Package.getSegment_ConnectedTo());
+    this.straightRelation = ecore2Logic.relationOfReference(ecore2LogicTrace, Modes3Package.getTurnout_Straight());
+    this.divergentRelation = ecore2Logic.relationOfReference(ecore2LogicTrace, Modes3Package.getTurnout_Divergent());
+  }
+  
+  @Override
+  public Map<Relation, String> getMustPatterns() {
+    Pair<Relation, String> _mappedTo = Pair.<Relation, String>of(this.connectedToRelation, Modes3UnitPropagationGenerator.MUST_CONNECTED_TO);
+    Pair<Relation, String> _mappedTo_1 = Pair.<Relation, String>of(this.straightRelation, Modes3UnitPropagationGenerator.MUST_STRAIGHT);
+    Pair<Relation, String> _mappedTo_2 = Pair.<Relation, String>of(this.divergentRelation, Modes3UnitPropagationGenerator.MUST_DIVERGENT);
+    return Collections.<Relation, String>unmodifiableMap(CollectionLiterals.<Relation, String>newHashMap(_mappedTo, _mappedTo_1, _mappedTo_2));
+  }
+  
+  @Override
+  public Map<Relation, String> getMustNotPatterns() {
+    Pair<Relation, String> _mappedTo = Pair.<Relation, String>of(this.connectedToRelation, Modes3UnitPropagationGenerator.MUST_NOT_CONNECTED_TO);
+    Pair<Relation, String> _mappedTo_1 = Pair.<Relation, String>of(this.straightRelation, Modes3UnitPropagationGenerator.MUST_NOT_STRAIGHT);
+    Pair<Relation, String> _mappedTo_2 = Pair.<Relation, String>of(this.divergentRelation, Modes3UnitPropagationGenerator.MUST_NOT_DIVERGENT);
+    return Collections.<Relation, String>unmodifiableMap(CollectionLiterals.<Relation, String>newHashMap(_mappedTo, _mappedTo_1, _mappedTo_2));
+  }
+  
+  @Override
+  public StringConcatenationClient getAdditionalPatterns(@Extension final PatternGenerator generator, final Map<String, PQuery> fqnToPQuery) {
+    StringConcatenationClient _xblockexpression = null;
+    {
+      StringConcatenationClient _client = new StringConcatenationClient() {
+        @Override
+        protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) {
+          _builder.append("problem: LogicProblem, interpretation: PartialInterpretation,");
+          _builder.newLine();
+          _builder.append("source: DefinedElement, target: DefinedElement");
+          _builder.newLine();
+        }
+      };
+      final StringConcatenationClient parameters = _client;
+      StringConcatenationClient _client_1 = new StringConcatenationClient() {
+        @Override
+        protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) {
+          _builder.append("find interpretation(problem, interpretation);");
+          _builder.newLine();
+          _builder.append("find mustExist(problem, interpretation, source);");
+          _builder.newLine();
+          _builder.append("find mustExist(problem, interpretation, target);");
+          _builder.newLine();
+        }
+      };
+      final StringConcatenationClient commonMustParameterConstraints = _client_1;
+      StringConcatenationClient _client_2 = new StringConcatenationClient() {
+        @Override
+        protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) {
+          _builder.append("find interpretation(problem, interpretation);");
+          _builder.newLine();
+          _builder.append("find mayExist(problem, interpretation, source);");
+          _builder.newLine();
+          _builder.append("find mayExist(problem, interpretation, target);");
+          _builder.newLine();
+        }
+      };
+      final StringConcatenationClient commonMayParameterConstraints = _client_2;
+      StringConcatenationClient _client_3 = new StringConcatenationClient() {
+        @Override
+        protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) {
+          _builder.append("pattern mayInput(");
+          _builder.append(parameters);
+          _builder.append(") {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append(commonMayParameterConstraints, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MAY, "target");
+          _builder.append(_referInstanceOf, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referPattern = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Adjacent.instance().getFullyQualifiedName()), new String[] { "target", "source" }, Modality.MAY, true, false);
+          _builder.append(_referPattern, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("neg ");
+          CharSequence _referRelation = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "target", "source", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("neg ");
+          CharSequence _referRelation_1 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "target", "source", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_1, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern multipleMayInput(problem: LogicProblem, interpretation: PartialInterpretation,");
+          _builder.newLine();
+          _builder.append("\t\t\t");
+          _builder.append("target: DefinedElement) {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find interpretation(problem, interpretation);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, target);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find mayInput(problem, interpretaton, source1, target);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find mayInput(problem, interpretaton, source2, target);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("neg find mustEquivalent(problem, interpretation, source1, source2);");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern multipleMayStraight(problem: LogicProblem, interpretation: PartialInterpretation,");
+          _builder.newLine();
+          _builder.append("\t\t\t");
+          _builder.append("source: DefinedElement) {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find interpretation(problem, interpretation);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, source);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_1 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MAY, "source");
+          _builder.append(_referInstanceOf_1, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referRelation_2 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "source", "target1", Modality.MAY, fqnToPQuery);
+          _builder.append(_referRelation_2, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referRelation_3 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "source", "target2", Modality.MAY, fqnToPQuery);
+          _builder.append(_referRelation_3, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("neg find mustEquivalent(problem, interpretation, target1, target2);");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern multipleMayDivergent(problem: LogicProblem, interpretation: PartialInterpretation,");
+          _builder.newLine();
+          _builder.append("\t\t\t");
+          _builder.append("source: DefinedElement) {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find interpretation(problem, interpretation);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, source);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_2 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MAY, "source");
+          _builder.append(_referInstanceOf_2, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referRelation_4 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "source", "target1", Modality.MAY, fqnToPQuery);
+          _builder.append(_referRelation_4, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referRelation_5 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "source", "target2", Modality.MAY, fqnToPQuery);
+          _builder.append(_referRelation_5, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("neg find mustEquivalent(problem, interpretation, target1, target2);");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern ");
+          _builder.append(Modes3UnitPropagationGenerator.MUST_CONNECTED_TO);
+          _builder.append("(");
+          _builder.append(parameters);
+          _builder.append(") {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append(commonMustParameterConstraints, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_3 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MAY, "target");
+          _builder.append(_referInstanceOf_3, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find mayInput(problem, interpretaton, source, target);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("neg find multipleMayInput(problem, interpretaton, target);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referRelation_6 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "source", "target", Modality.MAY, fqnToPQuery);
+          _builder.append(_referRelation_6, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("neg ");
+          CharSequence _referRelation_7 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "source", "target", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_7, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("neg ");
+          CharSequence _referRelation_8 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "source", "target", Modality.MAY, fqnToPQuery);
+          _builder.append(_referRelation_8, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("neg ");
+          CharSequence _referRelation_9 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "source", "target", Modality.MAY, fqnToPQuery);
+          _builder.append(_referRelation_9, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern ");
+          _builder.append(Modes3UnitPropagationGenerator.MUST_STRAIGHT);
+          _builder.append("(");
+          _builder.append(parameters);
+          _builder.append(") {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append(commonMustParameterConstraints, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("neg ");
+          CharSequence _referRelation_10 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "source", "_", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_10, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("neg find multipleMayStraight(problem, interpretation, source);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referRelation_11 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "source", "target", Modality.MAY, fqnToPQuery);
+          _builder.append(_referRelation_11, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("neg ");
+          CharSequence _referRelation_12 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "source", "target", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_12, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("} or {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append(commonMustParameterConstraints, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_4 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MAY, "target");
+          _builder.append(_referInstanceOf_4, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find mayInput(problem, interpretaton, source, target);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("neg find multipleMayInput(problem, interpretaton, target);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("neg ");
+          CharSequence _referRelation_13 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "source", "target", Modality.MAY, fqnToPQuery);
+          _builder.append(_referRelation_13, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referRelation_14 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "source", "target", Modality.MAY, fqnToPQuery);
+          _builder.append(_referRelation_14, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("neg ");
+          CharSequence _referRelation_15 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "source", "target", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_15, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("neg ");
+          CharSequence _referRelation_16 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "source", "target", Modality.MAY, fqnToPQuery);
+          _builder.append(_referRelation_16, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern ");
+          _builder.append(Modes3UnitPropagationGenerator.MUST_DIVERGENT);
+          _builder.append("(");
+          _builder.append(parameters);
+          _builder.append(") {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append(commonMustParameterConstraints, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("neg ");
+          CharSequence _referRelation_17 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "source", "_", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_17, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("neg find multipleMayDivergent(problem, interpretation, source);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referRelation_18 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "source", "target", Modality.MAY, fqnToPQuery);
+          _builder.append(_referRelation_18, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("neg ");
+          CharSequence _referRelation_19 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "source", "target", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_19, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("} or {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append(commonMustParameterConstraints, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_5 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MAY, "target");
+          _builder.append(_referInstanceOf_5, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find mayInput(problem, interpretaton, source, target);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("neg find multipleMayInput(problem, interpretaton, target);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("neg ");
+          CharSequence _referRelation_20 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "source", "target", Modality.MAY, fqnToPQuery);
+          _builder.append(_referRelation_20, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("neg ");
+          CharSequence _referRelation_21 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "source", "target", Modality.MAY, fqnToPQuery);
+          _builder.append(_referRelation_21, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referRelation_22 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "source", "target", Modality.MAY, fqnToPQuery);
+          _builder.append(_referRelation_22, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("neg ");
+          CharSequence _referRelation_23 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "source", "target", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_23, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern turnoutOutput_must_to_true_by_straight(");
+          _builder.append(parameters);
+          _builder.append(", T : DefinedElement, S : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append(commonMayParameterConstraints, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_6 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MAY, "source");
+          _builder.append(_referInstanceOf_6, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_7 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MAY, "target");
+          _builder.append(_referInstanceOf_7, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("T == source;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("S == target;");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern turnoutOutput_must_to_true_by_divergent(");
+          _builder.append(parameters);
+          _builder.append(", T : DefinedElement, S : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append(commonMayParameterConstraints, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_8 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MAY, "source");
+          _builder.append(_referInstanceOf_8, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_9 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MAY, "target");
+          _builder.append(_referInstanceOf_9, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("T == source;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("S == target;");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern output_must_to_true_by_connectedTo(");
+          _builder.append(parameters);
+          _builder.append(", S1 : DefinedElement, S2 : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append(commonMayParameterConstraints, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_10 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MAY, "source");
+          _builder.append(_referInstanceOf_10, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_11 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MAY, "target");
+          _builder.append(_referInstanceOf_11, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("S1 == source;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("S2 == target;");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern output_must_to_true_by_straight(");
+          _builder.append(parameters);
+          _builder.append(", S1 : DefinedElement, S2 : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find turnoutOutput_must_to_true_by_straight(problem, interpretation, source, target, S1, S2);");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern output_must_to_true_by_divergent(");
+          _builder.append(parameters);
+          _builder.append(", S1 : DefinedElement, S2 : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find turnoutOutput_must_to_true_by_divergent(problem, interpretation, source, target, S1, S2);");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern adjacent_must_to_true_by_connectedTo(");
+          _builder.append(parameters);
+          _builder.append(", S1 : DefinedElement, S2 : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find output_must_to_true_by_connectedTo(problem, interpretation, source, target, S1, S2);");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern adjacent_must_to_true_by_straight(");
+          _builder.append(parameters);
+          _builder.append(", S1 : DefinedElement, S2 : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find output_must_to_true_by_straight(problem, interpretation, source, target, S1, S2);");
+          _builder.newLine();
+          _builder.append("} or {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find turnoutOutput_must_to_true_by_straight(problem, interpretation, source, target, S2, S1);");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern adjacent_must_to_true_by_divergent(");
+          _builder.append(parameters);
+          _builder.append(", S1 : DefinedElement, S2 : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find output_must_to_true_by_divergent(problem, interpretation, source, target, S1, S2);");
+          _builder.newLine();
+          _builder.append("} or {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find turnoutOutput_must_to_true_by_divergent(problem, interpretation, source, target, S2, S1);");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern connectedToReflexive_must_to_true_by_connectedTo(");
+          _builder.append(parameters);
+          _builder.append(", S : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, source);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_12 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "source");
+          _builder.append(_referInstanceOf_12, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("S == source;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("S == target;");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern outputReflexive_must_to_true_by_straight(");
+          _builder.append(parameters);
+          _builder.append(", T : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find turnoutOutput_must_to_true_by_straight(problem, interpretation, source, target, T, T);");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern outputReflexive_must_to_true_by_divergent(");
+          _builder.append(parameters);
+          _builder.append(", T : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find turnoutOutput_must_to_true_by_divergent(problem, interpretation, source, target, T, T);");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern turnoutOutputsAreSame_must_to_true_by_straight(");
+          _builder.append(parameters);
+          _builder.append(", T : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append(commonMayParameterConstraints, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_13 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MAY, "source");
+          _builder.append(_referInstanceOf_13, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_14 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MAY, "target");
+          _builder.append(_referInstanceOf_14, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("T == source;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("S == target;");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referRelation_24 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "T", "S", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_24, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern turnoutOutputsAreSame_must_to_true_by_divergent(");
+          _builder.append(parameters);
+          _builder.append(", T : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append(commonMayParameterConstraints, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_15 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MAY, "source");
+          _builder.append(_referInstanceOf_15, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_16 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MAY, "target");
+          _builder.append(_referInstanceOf_16, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("T == source;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("S == target;");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referRelation_25 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "T", "S", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_25, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern tooManyInputsOfSegment_must_to_true_by_connectedTo(");
+          _builder.append(parameters);
+          _builder.append(", S : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, S);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_17 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.simpleSegmentType, Modality.MUST, "S");
+          _builder.append(_referInstanceOf_17, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find output_must_to_true_by_connectedTo(problem, interpretation, source, target, I1, S);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referPattern_1 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Output.instance().getFullyQualifiedName()), new String[] { "I2", "S" }, Modality.MUST, true, false);
+          _builder.append(_referPattern_1, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referPattern_2 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Output.instance().getFullyQualifiedName()), new String[] { "I3", "S" }, Modality.MUST, true, false);
+          _builder.append(_referPattern_2, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("I1 != I2;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I1 != I3;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I2 != I3;");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern tooManyInputsOfSegment_must_to_true_by_straight(");
+          _builder.append(parameters);
+          _builder.append(", S : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, S);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_18 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.simpleSegmentType, Modality.MUST, "S");
+          _builder.append(_referInstanceOf_18, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find output_must_to_true_by_straight(problem, interpretation, source, target, I1, S);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referPattern_3 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Output.instance().getFullyQualifiedName()), new String[] { "I2", "S" }, Modality.MUST, true, false);
+          _builder.append(_referPattern_3, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referPattern_4 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Output.instance().getFullyQualifiedName()), new String[] { "I3", "S" }, Modality.MUST, true, false);
+          _builder.append(_referPattern_4, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("I1 != I2;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I1 != I3;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I2 != I3;");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern tooManyInputsOfSegment_must_to_true_by_divergent(");
+          _builder.append(parameters);
+          _builder.append(", S : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, S);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_19 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.simpleSegmentType, Modality.MUST, "S");
+          _builder.append(_referInstanceOf_19, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find output_must_to_true_by_divergent(problem, interpretation, source, target, I1, S);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referPattern_5 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Output.instance().getFullyQualifiedName()), new String[] { "I2", "S" }, Modality.MUST, true, false);
+          _builder.append(_referPattern_5, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referPattern_6 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Output.instance().getFullyQualifiedName()), new String[] { "I3", "S" }, Modality.MUST, true, false);
+          _builder.append(_referPattern_6, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("I1 != I2;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I1 != I3;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I2 != I3;");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern turnoutConnectedToBothOutputs_must_to_true_by_connectedTo(");
+          _builder.append(parameters);
+          _builder.append(", T : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append(commonMayParameterConstraints, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, Straight);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, Divergent);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_20 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MAY, "source");
+          _builder.append(_referInstanceOf_20, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_21 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MAY, "target");
+          _builder.append(_referInstanceOf_21, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_22 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "Straight");
+          _builder.append(_referInstanceOf_22, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_23 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "Divergent");
+          _builder.append(_referInstanceOf_23, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referRelation_26 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "T", "Straight", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_26, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referRelation_27 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "T", "Divergent", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_27, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("T == source;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("Straight == target;");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referRelation_28 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "T", "Divergent", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_28, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("} or {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append(commonMayParameterConstraints, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, Straight);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, Divergent);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_24 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MAY, "source");
+          _builder.append(_referInstanceOf_24, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_25 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MAY, "target");
+          _builder.append(_referInstanceOf_25, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_26 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "Straight");
+          _builder.append(_referInstanceOf_26, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_27 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "Divergent");
+          _builder.append(_referInstanceOf_27, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referRelation_29 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "T", "Straight", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_29, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referRelation_30 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "T", "Divergent", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_30, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referRelation_31 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "T", "Straight", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_31, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("T == source;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("Straight == target;");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern turnoutConnectedToBothOutputs_must_to_true_by_straight(");
+          _builder.append(parameters);
+          _builder.append(", T : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append(commonMayParameterConstraints, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, Straight);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, Divergent);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_28 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MAY, "source");
+          _builder.append(_referInstanceOf_28, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_29 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MAY, "target");
+          _builder.append(_referInstanceOf_29, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_30 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "Straight");
+          _builder.append(_referInstanceOf_30, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_31 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "Divergent");
+          _builder.append(_referInstanceOf_31, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("T == source;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("Straight == target;");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referRelation_32 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "T", "Divergent", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_32, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referRelation_33 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "T", "Straight", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_33, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referRelation_34 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "T", "Divergent", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_34, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern turnoutConnectedToBothOutputs_must_to_true_by_divergent(");
+          _builder.append(parameters);
+          _builder.append(", T : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append(commonMayParameterConstraints, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, Straight);");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, Divergent);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_32 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MAY, "source");
+          _builder.append(_referInstanceOf_32, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_33 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MAY, "target");
+          _builder.append(_referInstanceOf_33, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_34 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "Straight");
+          _builder.append(_referInstanceOf_34, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_35 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "Divergent");
+          _builder.append(_referInstanceOf_35, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referRelation_35 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "T", "Straight", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_35, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("T == source;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("Divergent == target;");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referRelation_36 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "T", "Straight", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_36, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referRelation_37 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "T", "Divergent", Modality.MUST, fqnToPQuery);
+          _builder.append(_referRelation_37, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern tooManyInputsOfTurnout_must_to_true_by_connectedTo(");
+          _builder.append(parameters);
+          _builder.append(", T : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, S);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_36 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MUST, "S");
+          _builder.append(_referInstanceOf_36, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find adjacent_must_to_true_by_connectedTo(problem, interpretation, source, target, I1, S);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referPattern_7 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Adjacent.instance().getFullyQualifiedName()), new String[] { "I2", "S" }, Modality.MUST, true, false);
+          _builder.append(_referPattern_7, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referPattern_8 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Adjacent.instance().getFullyQualifiedName()), new String[] { "I3", "S" }, Modality.MUST, true, false);
+          _builder.append(_referPattern_8, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referPattern_9 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Adjacent.instance().getFullyQualifiedName()), new String[] { "I4", "S" }, Modality.MUST, true, false);
+          _builder.append(_referPattern_9, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("I1 != I2;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I1 != I3;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I1 != I4;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I2 != I3;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I2 != I4;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I3 != I4;");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern tooManyInputsOfTurnout_must_to_true_by_straight(");
+          _builder.append(parameters);
+          _builder.append(", T : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, S);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_37 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MUST, "S");
+          _builder.append(_referInstanceOf_37, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find adjacent_must_to_true_by_straight(problem, interpretation, source, target, I1, S);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referPattern_10 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Adjacent.instance().getFullyQualifiedName()), new String[] { "I2", "S" }, Modality.MUST, true, false);
+          _builder.append(_referPattern_10, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referPattern_11 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Adjacent.instance().getFullyQualifiedName()), new String[] { "I3", "S" }, Modality.MUST, true, false);
+          _builder.append(_referPattern_11, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referPattern_12 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Adjacent.instance().getFullyQualifiedName()), new String[] { "I4", "S" }, Modality.MUST, true, false);
+          _builder.append(_referPattern_12, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("I1 != I2;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I1 != I3;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I1 != I4;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I2 != I3;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I2 != I4;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I3 != I4;");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern tooManyInputsOfTurnout_must_to_true_by_divergent(");
+          _builder.append(parameters);
+          _builder.append(", T : DefinedElement) {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find mustExist(problem, interpretation, S);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referInstanceOf_38 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MUST, "S");
+          _builder.append(_referInstanceOf_38, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find adjacent_must_to_true_by_divergent(problem, interpretation, source, target, I1, S);");
+          _builder.newLine();
+          _builder.append("\t");
+          CharSequence _referPattern_13 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Adjacent.instance().getFullyQualifiedName()), new String[] { "I2", "S" }, Modality.MUST, true, false);
+          _builder.append(_referPattern_13, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referPattern_14 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Adjacent.instance().getFullyQualifiedName()), new String[] { "I3", "S" }, Modality.MUST, true, false);
+          _builder.append(_referPattern_14, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          CharSequence _referPattern_15 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Adjacent.instance().getFullyQualifiedName()), new String[] { "I4", "S" }, Modality.MUST, true, false);
+          _builder.append(_referPattern_15, "\t");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("I1 != I2;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I1 != I3;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I1 != I4;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I2 != I3;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I2 != I4;");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("I3 != I4;");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern ");
+          _builder.append(Modes3UnitPropagationGenerator.MUST_NOT_CONNECTED_TO);
+          _builder.append("_helper(");
+          _builder.append(parameters);
+          _builder.append(") {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find connectedToReflexive_must_to_true_by_connectedTo(problem, interpretation, source, target, _);");
+          _builder.newLine();
+          _builder.append("} or {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find tooManyInputsOfSegment_must_to_true_by_connectedTo(problem, interpretation, source, target, _);");
+          _builder.newLine();
+          _builder.append("} or {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find turnoutConnectedToBothOutputs_must_to_true_by_connectedTo(problem, interpretation, source, target, _);");
+          _builder.newLine();
+          _builder.append("} or {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find tooManyInputsOfTurnout_must_to_true_by_connectedTo(problem, interpretation, source, target, _);");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern ");
+          _builder.append(Modes3UnitPropagationGenerator.MUST_NOT_CONNECTED_TO);
+          _builder.append("(");
+          _builder.append(parameters);
+          _builder.append(") {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find ");
+          _builder.append(Modes3UnitPropagationGenerator.MUST_NOT_CONNECTED_TO, "\t");
+          _builder.append("_helper(problem, interpretation, source, target);");
+          _builder.newLineIfNotEmpty();
+          _builder.append("} or {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find ");
+          _builder.append(Modes3UnitPropagationGenerator.MUST_NOT_CONNECTED_TO, "\t");
+          _builder.append("_helper(problem, interpretation, target, source);");
+          _builder.newLineIfNotEmpty();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern ");
+          _builder.append(Modes3UnitPropagationGenerator.MUST_NOT_STRAIGHT);
+          _builder.append("(");
+          _builder.append(parameters);
+          _builder.append(") {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find outputReflexive_must_to_true_by_straight(problem, interpretation, source, target, _);");
+          _builder.newLine();
+          _builder.append("} or {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find turnoutOutputsAreSame_must_to_true_by_straight(problem, interpretation, source, target, _);");
+          _builder.newLine();
+          _builder.append("} or {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find tooManyInputsOfSegment_must_to_true_by_straight(problem, interpretation, source, target, _);");
+          _builder.newLine();
+          _builder.append("} or {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find turnoutConnectedToBothOutputs_must_to_true_by_straight(problem, interpretation, source, target, _);");
+          _builder.newLine();
+          _builder.append("} or {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find tooManyInputsOfTurnout_must_to_true_by_straight(problem, interpretation, source, target, _);");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+          _builder.newLine();
+          _builder.append("pattern ");
+          _builder.append(Modes3UnitPropagationGenerator.MUST_NOT_DIVERGENT);
+          _builder.append("(");
+          _builder.append(parameters);
+          _builder.append(") {");
+          _builder.newLineIfNotEmpty();
+          _builder.append("\t");
+          _builder.append("find outputReflexive_must_to_true_by_divergent(problem, interpretation, source, target, _);");
+          _builder.newLine();
+          _builder.append("} or {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find turnoutOutputsAreSame_must_to_true_by_divergent(problem, interpretation, source, target, _);");
+          _builder.newLine();
+          _builder.append("} or {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find tooManyInputsOfSegment_must_to_true_by_divergent(problem, interpretation, source, target, _);");
+          _builder.newLine();
+          _builder.append("} or {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find turnoutConnectedToBothOutputs_must_to_true_by_divergent(problem, interpretation, source, target, _);");
+          _builder.newLine();
+          _builder.append("} or {");
+          _builder.newLine();
+          _builder.append("\t");
+          _builder.append("find tooManyInputsOfTurnout_must_to_true_by_divergent(problem, interpretation, source, target, _);");
+          _builder.newLine();
+          _builder.append("}");
+          _builder.newLine();
+        }
+      };
+      _xblockexpression = _client_3;
+    }
+    return _xblockexpression;
+  }
+}
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/TrainLocationsObjectiveHint.java b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/TrainLocationsObjectiveHint.java
new file mode 100644
index 00000000..570f9deb
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/TrainLocationsObjectiveHint.java
@@ -0,0 +1,117 @@
+package modes3.run;
+
+import com.google.common.collect.ImmutableList;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic;
+import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.Dimension;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ExtendedLinearExpressionBuilder;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ExtendedLinearExpressionBuilderFactory;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedronExtensionOperator;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.CostElementMatch;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.CostElementMatchers;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.CostObjectiveHint;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import modes3.Modes3Package;
+import modes3.queries.TrainLocations_step_2;
+import modes3.queries.TrainLocations_step_3;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+
+@SuppressWarnings("all")
+public class TrainLocationsObjectiveHint extends CostObjectiveHint {
+  private final Type segmentType;
+  
+  private final Type trainType;
+  
+  public TrainLocationsObjectiveHint(@Extension final Ecore2Logic ecore2Logic, final Ecore2Logic_Trace ecore2LogicTrace) {
+    @Extension
+    final Modes3Package Modes3Package = modes3.Modes3Package.eINSTANCE;
+    this.segmentType = ecore2Logic.TypeofEClass(ecore2LogicTrace, Modes3Package.getSegment());
+    this.trainType = ecore2Logic.TypeofEClass(ecore2LogicTrace, Modes3Package.getTrain());
+  }
+  
+  @Override
+  public boolean isExact() {
+    return true;
+  }
+  
+  @Override
+  public PolyhedronExtensionOperator createPolyhedronExtensionOperator(final Map<String, CostElementMatchers> costElementMatchers) {
+    PolyhedronExtensionOperator _xblockexpression = null;
+    {
+      final CostElementMatchers step2 = costElementMatchers.get(TrainLocations_step_2.instance().getFullyQualifiedName());
+      final CostElementMatchers step3 = costElementMatchers.get(TrainLocations_step_3.instance().getFullyQualifiedName());
+      final PolyhedronExtensionOperator _function = (ExtendedLinearExpressionBuilderFactory it) -> {
+        final ExtendedLinearExpressionBuilder objectiveBuilder = it.createBuilder();
+        ImmutableList<CostElementMatch> _matches = step2.getMatches();
+        for (final CostElementMatch m : _matches) {
+          {
+            final Dimension dimension = it.getDimension(m.getMatch());
+            objectiveBuilder.add(step2.getWeight(), dimension);
+            dimension.tightenLowerBound(Integer.valueOf(0));
+            boolean _isMulti = m.isMulti();
+            if (_isMulti) {
+              it.createBuilder().add(1, dimension).add((-1), this.trainType).build().assertEqualsTo(0);
+            } else {
+              dimension.tightenUpperBound(Integer.valueOf(1));
+              boolean _isMust = m.isMust();
+              if (_isMust) {
+                dimension.tightenLowerBound(Integer.valueOf(1));
+              }
+            }
+          }
+        }
+        final ImmutableList<CostElementMatch> step3Matches = step3.getMatches();
+        for (final CostElementMatch m_1 : step3Matches) {
+          {
+            final Dimension dimension = it.getDimension(m_1.getMatch());
+            objectiveBuilder.add(step3.getWeight(), dimension);
+            dimension.tightenLowerBound(Integer.valueOf(0));
+            boolean _isMulti = m_1.isMulti();
+            boolean _not = (!_isMulti);
+            if (_not) {
+              dimension.tightenUpperBound(Integer.valueOf(1));
+              boolean _isMust = m_1.isMust();
+              if (_isMust) {
+                dimension.tightenLowerBound(Integer.valueOf(1));
+              }
+            }
+          }
+        }
+        TrainLocationsObjectiveHint.boundLimit(it, step3Matches, 2, this.trainType, 1);
+        TrainLocationsObjectiveHint.boundLimit(it, step3Matches, 3, this.segmentType, 1);
+        this.buildWithBounds(objectiveBuilder);
+      };
+      _xblockexpression = _function;
+    }
+    return _xblockexpression;
+  }
+  
+  private static void boundLimit(@Extension final ExtendedLinearExpressionBuilderFactory factory, final Collection<CostElementMatch> matches, final int index, final Type type, final int count) {
+    final Function1<CostElementMatch, Object> _function = (CostElementMatch it) -> {
+      return it.getMatch().get(index);
+    };
+    Set<Map.Entry<Object, List<CostElementMatch>>> _entrySet = IterableExtensions.<Object, CostElementMatch>groupBy(matches, _function).entrySet();
+    for (final Map.Entry<Object, List<CostElementMatch>> pair : _entrySet) {
+      {
+        final ExtendedLinearExpressionBuilder multiplicityBuilder = factory.createBuilder();
+        List<CostElementMatch> _value = pair.getValue();
+        for (final CostElementMatch m : _value) {
+          multiplicityBuilder.add(1, m.getMatch());
+        }
+        boolean _isMulti = CostElementMatchers.isMulti(pair.getKey());
+        if (_isMulti) {
+          multiplicityBuilder.add((-count), type);
+          multiplicityBuilder.build().tightenUpperBound(Integer.valueOf(0));
+        } else {
+          multiplicityBuilder.build().tightenUpperBound(Integer.valueOf(count));
+        }
+      }
+    }
+  }
+}