diff --git a/plugins/org.eclipse.qvtd.compiler/META-INF/MANIFEST.MF b/plugins/org.eclipse.qvtd.compiler/META-INF/MANIFEST.MF
index 397f303..3f3ed1f 100644
--- a/plugins/org.eclipse.qvtd.compiler/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.qvtd.compiler/META-INF/MANIFEST.MF
@@ -32,6 +32,7 @@
  org.eclipse.qvtd.compiler.internal.qvts2qvts.merger,
  org.eclipse.qvtd.compiler.internal.qvts2qvts.partitioner,
  org.eclipse.qvtd.compiler.internal.qvts2qvts.splitter,
+ org.eclipse.qvtd.compiler.internal.qvts2qvts.utilities,
  org.eclipse.qvtd.compiler.internal.qvtu2qvtm,
  org.eclipse.qvtd.compiler.internal.templates.model,
  org.eclipse.qvtd.compiler.internal.utilities
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/AbstractRegion2Mapping.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/AbstractRegion2Mapping.java
index 9773f2b..ed7ac3e 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/AbstractRegion2Mapping.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/AbstractRegion2Mapping.java
@@ -50,6 +50,7 @@
 import org.eclipse.qvtd.pivot.qvtimperative.MappingParameter;
 import org.eclipse.qvtd.pivot.qvtimperative.MappingParameterBinding;
 import org.eclipse.qvtd.pivot.qvtimperative.utilities.QVTimperativeHelper;
+import org.eclipse.qvtd.pivot.qvtschedule.BasicMappingRegion;
 import org.eclipse.qvtd.pivot.qvtschedule.Node;
 import org.eclipse.qvtd.pivot.qvtschedule.NodeConnection;
 import org.eclipse.qvtd.pivot.qvtschedule.Region;
@@ -60,7 +61,9 @@
 	protected final @NonNull QVTs2QVTiVisitor visitor;
 	protected final @NonNull QVTimperativeHelper helper;
 	protected final @NonNull Region region;
+	@SuppressWarnings("unused")private final @NonNull String regionName;
 	protected final @NonNull Mapping mapping;
+	@SuppressWarnings("unused")private final @NonNull String mappingName;
 
 	/**
 	 * Mapping from QVTm expression to Schedule Node.
@@ -86,9 +89,14 @@
 		this.visitor = visitor;
 		this.helper = new QVTimperativeHelper(visitor.getEnvironmentFactory());
 		this.region = region;
-		String name = region.getSymbolName();
-		assert name != null;
-		this.mapping = helper.createMapping(name);
+		this.regionName = RegionUtil.getName(region);
+		String mappingName = region.getSymbolName();
+		assert mappingName != null;
+		this.mapping = helper.createMapping(mappingName);
+		this.mappingName = mappingName;
+		if (region instanceof BasicMappingRegion) {
+			this.mapping.setIsAbstract(((BasicMappingRegion)region).getReferredMapping().isIsAbstract());
+		}
 		this.names = new HashSet<@NonNull String>(visitor.getReservedNames());
 		for (@NonNull Node node : RegionUtil.getOwnedNodes(region)) {
 			for (TypedElement typedElement : node.getTypedElements()) {
@@ -144,6 +152,10 @@
 		}
 	}
 
+	public @NonNull MappingCall createMappingCall(@NonNull List<@NonNull MappingParameterBinding> mappingParameterBindings) {
+		return helper.createMappingCall(getMapping(), mappingParameterBindings);
+	}
+
 	protected @NonNull CallExp createOclAsTypeCallExp(@NonNull OCLExpression asSource, @NonNull Type asType) {
 		ScheduleManager scheduleManager = RegionUtil.getScheduleManager(getRegion());
 		CompleteClass completeClass = scheduleManager.getEnvironmentFactory().getCompleteModel().getCompleteClass(asType);
@@ -151,8 +163,6 @@
 		return helper.createOperationCallExp(asSource, "oclAsType", asTypeExp);
 	}
 
-	public abstract void createSchedulingStatements();
-
 	protected int getCollectionDepth(@NonNull Type type) {
 		if (type instanceof CollectionType) {
 			Type elementType = ((CollectionType)type).getElementType();
@@ -279,12 +289,11 @@
 		return false;
 	}
 
+	public abstract void synthesizeCallStatements();
+	public abstract void synthesizeLocalStatements();
+
 	@Override
 	public String toString() {
 		return mapping.toString();
 	}
-
-	public @NonNull MappingCall createMappingCall(@NonNull List<@NonNull MappingParameterBinding> mappingParameterBindings) {
-		return helper.createMappingCall(getMapping(), mappingParameterBindings);
-	}
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/BasicRegion2Mapping.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/BasicRegion2Mapping.java
index 9a465c5..0ad9f4b 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/BasicRegion2Mapping.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/BasicRegion2Mapping.java
@@ -13,7 +13,6 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -30,6 +29,7 @@
 import org.eclipse.ocl.pivot.CollectionLiteralPart;
 import org.eclipse.ocl.pivot.CollectionRange;
 import org.eclipse.ocl.pivot.CollectionType;
+import org.eclipse.ocl.pivot.CompleteClass;
 import org.eclipse.ocl.pivot.EnumLiteralExp;
 import org.eclipse.ocl.pivot.IfExp;
 import org.eclipse.ocl.pivot.IterateExp;
@@ -71,6 +71,7 @@
 import org.eclipse.qvtd.compiler.internal.qvtm2qvts.ScheduleManager;
 import org.eclipse.qvtd.compiler.internal.qvts2qvts.ClassDatumAnalysis;
 import org.eclipse.qvtd.compiler.internal.qvts2qvts.RegionAnalysis;
+import org.eclipse.qvtd.compiler.internal.qvts2qvts.utilities.ReachabilityForest;
 import org.eclipse.qvtd.pivot.qvtbase.Function;
 import org.eclipse.qvtd.pivot.qvtbase.Transformation;
 import org.eclipse.qvtd.pivot.qvtbase.TypedModel;
@@ -105,6 +106,7 @@
 import org.eclipse.qvtd.pivot.qvtschedule.Region;
 import org.eclipse.qvtd.pivot.qvtschedule.Role;
 import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleConstants;
+import org.eclipse.qvtd.pivot.qvtschedule.utilities.QVTscheduleUtil;
 
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
@@ -117,19 +119,8 @@
 	 * to build a linear edge traversal schedule in which unconditional checks that may fail appear
 	 * as early as possible.
 	 */
-	private class OldEdgeSchedule implements Comparator<@NonNull Edge>
+	private class OldEdgeSchedule
 	{
-		protected final @NonNull Region region;
-
-		private @NonNull Map<@NonNull Node, @NonNull Integer> node2depth;
-
-		private final @NonNull List<@NonNull Edge> oldUnconditionalEdges;
-
-		/**
-		 * All properties (and their opposites) that need to be checked for readiness before access.
-		 */
-		private final @Nullable Set<@NonNull Property> allCheckedProperties;
-
 		/**
 		 * The linear execution schedule for edges.
 		 */
@@ -141,16 +132,12 @@
 		private final @NonNull Set<@NonNull Edge> scheduledEdges = new HashSet<>();
 
 		/**
-		 * The edges (and their opposites) in edgeSchedule.
+		 * The nodes at the ends of the edges in edgeSchedule.
 		 */
 		private final @NonNull Set<@NonNull Node> scheduledNodes;
 
-		public OldEdgeSchedule(@NonNull Region region) {
-			this.region = region;
-			this.node2depth = computeDepths();
-			this.oldUnconditionalEdges = computeOldUnconditionalEdges();
-			this.allCheckedProperties = computeCheckedProperties();
-			this.scheduledNodes = Sets.newHashSet(RegionUtil.getHeadNodes(region));
+		public OldEdgeSchedule() {
+			this.scheduledNodes = Sets.newHashSet(RegionUtil.getHeadNodes(region));  // ?? leaf constants
 		}
 
 		private void addEdge(@NonNull Edge edge) {
@@ -176,21 +163,21 @@
 			if (scheduledNodes.add(targetNode)) {
 				Subexpression subexpression = node2subexpression.get(targetNode);
 				if (subexpression != null) {
-					for (@NonNull Node inputNode : subexpression.inputNodes) {
+					for (@NonNull Node inputNode : subexpression.unconditionalInputNodes) {
 						addNode(inputNode);
 					}
+					targetNode = subexpression.resultNode;
+					addNode(targetNode);
 				}
-				else {
-					Integer targetDepth = node2depth.get(targetNode);
-					assert targetDepth != null;
-					for (@NonNull Edge edge : RegionUtil.getIncomingEdges(targetNode)) {
-						if (edge.isOld()) {
-							Node sourceNode = RegionUtil.getSourceNode(edge);
-							Integer sourceDepth = node2depth.get(sourceNode);
-							assert sourceDepth != null;
-							if (sourceDepth < targetDepth) {
-								addEdge(edge);
-							}
+				Integer targetCost = reachabilityForest.getCost(targetNode);
+				assert targetCost != null;
+				for (@NonNull Edge edge : RegionUtil.getIncomingEdges(targetNode)) {
+					if (edge.isOld() && edge.isUnconditional()) {
+						Node sourceNode = RegionUtil.getSourceNode(edge);
+						Integer sourceCost = reachabilityForest.getCost(sourceNode);
+						assert sourceCost != null;
+						if (sourceCost < targetCost) {
+							addEdge(edge);
 						}
 					}
 				}
@@ -198,15 +185,17 @@
 		}
 
 		public void analyze() {
-			Set<@NonNull Edge> checkableEdges = computeCheckables();
-			int checkableSize = checkableEdges.size();
+			Set<@NonNull CheckedCondition> checkedConditions = computeCheckedConditions();
+			int checkableSize = checkedConditions.size();
 			if (checkableSize > 0) {
-				List<@NonNull Edge> sortedCheckableEdges = new ArrayList<>(checkableEdges);
+				List<@NonNull CheckedCondition> sortedCheckedConditions = new ArrayList<>(checkedConditions);
 				if (checkableSize > 1) {
-					Collections.sort(sortedCheckableEdges, this);
+					Collections.sort(sortedCheckedConditions);
 				}
-				for (@NonNull Edge checkableEdge : sortedCheckableEdges) {
-					addEdge(checkableEdge);
+				for (@NonNull CheckedCondition checkedCondition : sortedCheckedConditions) {
+					for (@NonNull Edge edge : checkedCondition.getEdges()) {
+						addEdge(edge);
+					}
 				}
 			}
 			for (@NonNull Edge edge : oldUnconditionalEdges) {
@@ -218,66 +207,84 @@
 			//			assert new HashSet<>(edgeSchedule).equals(new HashSet<>(oldEdges));
 		}
 
-		@Override
-		public int compare(@NonNull Edge e1, @NonNull Edge e2) {
-			Integer d1s = node2depth.get(RegionUtil.getSourceNode(e1));
-			Integer d1t = node2depth.get(RegionUtil.getTargetNode(e1));
-			Integer d2s = node2depth.get(RegionUtil.getSourceNode(e2));
-			Integer d2t = node2depth.get(RegionUtil.getTargetNode(e2));
-			assert (d1s != null) && (d1t != null) && (d2s != null) && (d2t != null);
-			int d1 = Math.max(d1s,  d1t);
-			int d2 = Math.max(d2s,  d2t);
-			if (d1 != d2) {
-				return d1 - d2;
-			}
-			if (d1s != d2s) {
-				return d1s - d2s;
-			}
-			return ClassUtil.safeCompareTo(e1.getDisplayName(), e2.getDisplayName());
-		}
-
 		/**
 		 * Return all old edges that require a check for readiness or consistency.
 		 */
-		private @NonNull Set<@NonNull Edge> computeCheckables() {
+		private @NonNull Set<@NonNull CheckedCondition> computeCheckedConditions() {
 			Set<@NonNull Property> allCheckedProperties2 = allCheckedProperties;
-			Set<@NonNull Edge> checkables = new HashSet<>();
+			Set<@NonNull CheckedCondition> checkedConditions = new HashSet<>();
+			Set<@NonNull NavigableEdge> checkedNavigableEdges = null;
 			for (@NonNull Edge edge : oldUnconditionalEdges) {
+				CheckedCondition checkedCondition = null;
 				if (edge instanceof CastEdge) {
-					checkables.add(edge);
+					checkedCondition = new CastEdgeCheckedCondition((CastEdge)edge);
 				}
 				else if (edge instanceof PredicateEdge) {
-					checkables.add(edge);
+					checkedCondition = new PredicateEdgeCheckedCondition((PredicateEdge)edge);
 				}
 				else if (edge instanceof NavigableEdge) {
+					NavigableEdge navigableEdge = (NavigableEdge)edge;
 					if (allCheckedProperties2 != null) {
-						Property property = ((NavigableEdge)edge).getProperty();
+						NavigableEdge primaryEdge = RegionUtil.getPrimaryEdge(navigableEdge);
+						Property property = primaryEdge.getProperty();
 						if (allCheckedProperties2.contains(property)) {
-							checkables.add(edge);
+							if (checkedNavigableEdges == null) {
+								checkedNavigableEdges = new HashSet<>();
+							}
+							if (checkedNavigableEdges.add(primaryEdge)) {
+								checkedCondition = new NavigableEdgeCheckedCondition(primaryEdge);
+							}
+						}
+					}
+					if (checkedCondition == null) {
+						Node targetNode = RegionUtil.getTargetNode(edge);
+						if (edge.isPredicated() && targetNode.isConstant()) {
+							checkedCondition = new ConstantTargetCheckedCondition((NavigableEdge)edge);
+						}
+						if ((checkedCondition == null) && edge.isOld()) {
+							Property property = QVTscheduleUtil.getProperty(navigableEdge);
+							CompleteClass edgeTargetCompleteClass = getMetamodelManager().getCompleteModel().getCompleteClass(QVTrelationUtil.getType(property));
+							Node sourceNode = RegionUtil.getSourceNode(edge);
+							Integer sourceCost = reachabilityForest.getCost(sourceNode);
+							Integer targetCost = reachabilityForest.getCost(targetNode);
+							assert (sourceCost != null) && (targetCost != null);
+							if (sourceCost < targetCost) {
+								CompleteClass targetNodeCompleteClass = targetNode.getCompleteClass();
+								if (!edgeTargetCompleteClass.conformsTo(targetNodeCompleteClass)) {
+									checkedCondition = new CastEdgeCheckedCondition(navigableEdge);
+								}
+							}
 						}
 					}
 				}
+				if (checkedCondition != null) {
+					checkedConditions.add(checkedCondition);
+				}
 			}
 			//
-			//	Double input nodes require a consistency check.
+			//	Multi-input nodes require a consistency check.
 			//
 			for (@NonNull Node node : RegionUtil.getOwnedNodes(region)) {
 				if (node.isOld() && node.isUnconditional()) {
-					Integer targetDepth = node2depth.get(node);
-					assert targetDepth != null;
+					Integer targetCost = reachabilityForest.getCost(node);
+					assert targetCost != null;
 					if (node.isOld()) {
 						Edge firstEdge = null;
+						MultipleEdgeCheckedCondition checkedCondition = null;
 						for (@NonNull Edge edge : RegionUtil.getIncomingEdges(node)) {
-							if (edge.isOld() && !edge.isExpression()) {
-								Integer sourceDepth = node2depth.get(RegionUtil.getSourceNode(edge));
-								assert sourceDepth != null;
-								if (sourceDepth <= targetDepth) {
+							if (edge.isOld() && !edge.isExpression()) {		// FIXME why exclude expression?
+								Integer sourceCost = reachabilityForest.getCost(RegionUtil.getSourceNode(edge));
+								assert sourceCost != null;
+								if (sourceCost <= targetCost) {
 									if (firstEdge == null) {
 										firstEdge = edge;
 									}
+									else if (checkedCondition == null){
+										checkedCondition = new MultipleEdgeCheckedCondition(firstEdge, edge);
+										checkedConditions.add(checkedCondition);
+									}
 									else {
-										checkables.add(firstEdge);
-										checkables.add(edge);
+										checkedCondition.addEdge(edge);
 									}
 								}
 							}
@@ -285,94 +292,7 @@
 					}
 				}
 			}
-			return checkables;
-		}
-
-		/**
-		 * Return all properties (and their opposites) that need checking for readiness prior to access.
-		 */
-		private @Nullable Set<@NonNull Property> computeCheckedProperties() {
-			//
-			// Better, we would not be pessimistic about input/output typedModel ambiguity in endogeneous
-			// mappings, but that incurs many typedModel accuracy issues.
-			//
-			Set<@NonNull Property> allCheckedProperties = null;
-			DomainUsage anyUsage = RegionUtil.getScheduleManager(region).getDomainAnalysis().getAnyUsage();
-			for (@NonNull TypedModel qvtmTypedModel : anyUsage.getTypedModels()) {
-				Iterable<@NonNull NavigableEdge> checkedEdges = RegionAnalysis.get(region).getCheckedEdges(qvtmTypedModel);
-				if (checkedEdges != null) {
-					for (NavigableEdge checkedEdge : checkedEdges) {
-						Property asProperty = RegionUtil.getProperty(checkedEdge);
-						if (allCheckedProperties == null) {
-							allCheckedProperties = new HashSet<>();
-						}
-						allCheckedProperties.add(asProperty);
-						Property asOppositeProperty = asProperty.getOpposite();
-						if (asOppositeProperty != null) {
-							allCheckedProperties.add(asOppositeProperty);
-						}
-					}
-				}
-			}
-			return allCheckedProperties;
-		}
-
-		/**
-		 * Return a map from each old node to the minimum edge distance from a head node.
-		 * @return
-		 */
-		private @NonNull Map<@NonNull Node, @NonNull Integer> computeDepths() {
-			// Successive depth candidate iteration works fine.
-			// A recursion has trouble with the forward/reverse edge pairs.
-			// A max-depth similarly has trouble with forward/reverse recursion.
-			Map<@NonNull Node, @NonNull Integer> node2minDepth = new HashMap<>();
-			Set<@NonNull Node> lowerDepthNodes = new HashSet<>();
-			Iterable<@NonNull Node> thisDepthNodes = RegionUtil.getHeadNodes(region);
-			for (int depth = 0; thisDepthNodes != null; depth++) {
-				Set<@NonNull Node> nextDepthNodes = null;
-				for (@NonNull Node node : thisDepthNodes) {
-					if (!node2minDepth.containsKey(node)) {
-						node2minDepth.put(node, depth);
-					}
-					for (@NonNull Edge edge : RegionUtil.getOutgoingEdges(node)) {
-						if (edge.isOld()) {
-							Node targetNode = RegionUtil.getTargetNode(edge);
-							if (!lowerDepthNodes.contains(targetNode)) {
-								if (nextDepthNodes == null) {
-									nextDepthNodes = new HashSet<>();
-								}
-								nextDepthNodes.add(targetNode);
-							}
-						}
-					}
-				}
-				for (@NonNull Node node : thisDepthNodes) {
-					lowerDepthNodes.add(node);
-				}
-				thisDepthNodes = nextDepthNodes;
-			}
-			for (@NonNull Node node : RegionUtil.getOwnedNodes(region)) {
-				if (node.isOld()) {
-					Integer depth = node2minDepth.get(node);
-					if (depth == null) {
-						assert node.isConstant();
-						node2minDepth.put(node, 0);
-					}
-				}
-			}
-			return node2minDepth;
-		}
-
-		private @NonNull List<@NonNull Edge> computeOldUnconditionalEdges() {
-			Set<@NonNull Edge> oldEdges = new HashSet<>();
-			for (@NonNull Edge edge : RegionUtil.getOwnedEdges(region)) {
-				if (edge.isOld() && edge.isUnconditional()) {
-					oldEdges.add(edge);
-				}
-			}
-			List<@NonNull Edge> sortedEdges = new ArrayList<>(oldEdges);
-			Collections.sort(sortedEdges, this);
-			return sortedEdges;
+			return checkedConditions;
 		}
 
 		private void createCastPredicates(@NonNull Node sourceNode, @NonNull VariableDeclaration sourceVariable) {
@@ -400,12 +320,7 @@
 			}
 		}
 
-		public @Nullable Set<@NonNull Property> getAllCheckedProperties() {
-			return allCheckedProperties;
-		}
-
 		public void synthesize() {
-			@SuppressWarnings("unused")String regionName = region.getName();
 			for (@NonNull Edge edge : edgeSchedule) {
 				assert edge.isUnconditional();
 				Node sourceNode = RegionUtil.getSourceNode(edge);
@@ -452,7 +367,7 @@
 					getSubexpressionDeclaration(targetNode);
 				}
 			}
-			List<@NonNull Subexpression> subexpressions = new ArrayList<>(node2subexpression.values());
+			List<@NonNull Subexpression> subexpressions = new ArrayList<>(resultNode2subexpression.values());
 			Collections.sort(subexpressions);
 			for (@NonNull Subexpression subexpression : subexpressions) {
 				if (!subexpression.resultNode.isNew() && subexpression.resultNode.isUnconditional()) {
@@ -921,16 +836,29 @@
 			}
 			TypedElement oldTypedElement = node.getTypedElements().iterator().next();
 			assert oldTypedElement != null;
-			if ((oldTypedElement instanceof Variable) && (((Variable)oldTypedElement).getOwnedInit() == null)) {
-				for (@NonNull Edge edge : RegionUtil.getIncomingEdges(node)) {
-					if (edge.isExpression() && QVTscheduleConstants.EQUALS_NAME.equals(edge.getName())) {
-						Node edgeSource = edge.getEdgeSource();
-						return create(edgeSource); //createBottomVariable(node, helper.createNullLiteralExp());		// FIXME is this possible?
+			if (oldTypedElement instanceof Variable) {
+				Variable variable = (Variable)oldTypedElement;
+				OCLExpression ownedInit = variable.getOwnedInit();
+				if (ownedInit == null) {
+					for (@NonNull Edge edge : RegionUtil.getIncomingEdges(node)) {
+						if (edge.isExpression() && QVTscheduleConstants.EQUALS_NAME.equals(edge.getName())) {
+							Node sourceNode = RegionUtil.getSourceNode(edge);
+							return create(sourceNode); //createBottomVariable(node, helper.createNullLiteralExp());		// FIXME is this possible?
+						}
+						else if (edge.isCast()) {
+							throw new UnsupportedOperationException();
+							//theVariable = createBottomVariable(node, helper.createNullLiteralExp());		// FIXME is this possible?
+						}
+						else if (edge.isNavigation()) {
+							Node sourceNode = RegionUtil.getSourceNode(edge);
+							OCLExpression sourceExpression = create(sourceNode);
+							Property referredProperty = RegionUtil.getProperty((NavigableEdge) edge);
+							return helper.createNavigationCallExp(sourceExpression, referredProperty);
+						}
 					}
-					else if (edge.isCast()) {
-						throw new UnsupportedOperationException();
-						//theVariable = createBottomVariable(node, helper.createNullLiteralExp());		// FIXME is this possible?
-					}
+				}
+				else {
+					return ownedInit.accept(this);
 				}
 			}
 			else {
@@ -948,16 +876,21 @@
 		private final @NonNull OperationNode resultNode;
 
 		/**
-		 * Externalnodes used within the subexpression
+		 * External nodes used within the subexpression
 		 */
 		private final @NonNull Set<@NonNull Node> inputNodes = new HashSet<>();
 
 		/**
+		 * External nodes used within the subexpression
+		 */
+		private final @NonNull Set<@NonNull Node> unconditionalInputNodes = new HashSet<>();
+
+		/**
 		 * Nodes within the subexpression
 		 */
 		private final @NonNull Set<@NonNull Node> contentNodes = new HashSet<>();
 
-		private @Nullable Integer depth = null;
+		private @Nullable Integer cost = null;
 
 		public Subexpression(@NonNull OperationNode resultNode) {
 			this.resultNode = resultNode;
@@ -971,8 +904,8 @@
 		@Override
 		public int compareTo(@NonNull Subexpression e2) {
 			Subexpression e1 = this;
-			int d1 = e1.getDepth();
-			int d2 = e2.getDepth();
+			int d1 = e1.getCost();
+			int d2 = e2.getCost();
 			if (d1 != d2) {
 				return d1 - d2;
 			}
@@ -981,26 +914,36 @@
 
 		private void computeSubexpressionContent(@NonNull Node node, @NonNull Set<@NonNull OperationNode> subexpressionResults) {
 			if (contentNodes.add(node)) {
+				node2subexpression.put(node, this);
 				for (@NonNull Edge edge : RegionUtil.getIncomingEdges(node)) {
 					//					if (edge.isUnconditional()) {
 					Node sourceNode = edge.getEdgeSource();
 					if (subexpressionResults.contains(sourceNode)) {
 						if (sourceNode.isOld() || (!edge.isSecondary() && resultNode.isNew())) {
 							inputNodes.add(sourceNode);
+							if (edge.isUnconditional() && sourceNode.isUnconditional()) {
+								unconditionalInputNodes.add(sourceNode);
+							}
+							//							edge2subexpression.put(edge, this);
 						}
 					}
 					else if (sourceNode.isExpression()) {
+						node2subexpression.put(sourceNode, this);
 						edge2subexpression.put(edge, this);
 						computeSubexpressionContent(sourceNode, subexpressionResults);
 					}
 					else if (!sourceNode.isUnconditional()) {
+						node2subexpression.put(sourceNode, this);
 						edge2subexpression.put(edge, this);
 						computeSubexpressionContent(sourceNode, subexpressionResults);
 					}
 					else {
 						if (sourceNode.isOld() || resultNode.isNew()) {
 							inputNodes.add(sourceNode);
-							edge2subexpression.put(edge, this);
+							if (edge.isUnconditional() && sourceNode.isUnconditional()) {
+								unconditionalInputNodes.add(sourceNode);
+							}
+							//							edge2subexpression.put(edge, this);
 						}
 					}
 					//					}
@@ -1008,19 +951,23 @@
 			}
 		}
 
-		public int getDepth() {
-			Integer depth2 = depth;
-			if (depth2 == null) {
-				int inputDepth = 0;
-				for (@NonNull Node inputNode : inputNodes) {
-					Subexpression inputSubexpression = node2subexpression.get(inputNode);
-					if (inputSubexpression != null) {
-						inputDepth = Math.max(inputDepth, inputSubexpression.getDepth()+1);
+		public int getCost() {
+			Integer cost2 = cost;
+			if (cost2 == null) {
+				cost2 = reachabilityForest.getCost(resultNode);
+				if (cost2 == null) {			// Can happen for REALIZED results
+					int inputCost = 0;
+					for (@NonNull Node inputNode : inputNodes) {
+						Subexpression inputSubexpression = resultNode2subexpression.get(inputNode);
+						if (inputSubexpression != null) {
+							inputCost = Math.max(inputCost, inputSubexpression.getCost()+1);
+						}
 					}
+					cost2 = inputCost;
 				}
-				depth = depth2 = inputDepth;
+				cost = cost2;
 			}
-			return depth2;
+			return cost2;
 		}
 		@Override
 		public @NonNull String toString() {
@@ -1029,9 +976,197 @@
 	}
 
 	/**
-	 * Map from each subexpression result to its contents.
+	 * A CheckedCondition identifies a possible micromapping failure mechanism. QVTi synthesis prioritises
+	 * easily computed CheckedConditions to minimize the wasted effort in computing failures.
 	 */
-	private final @NonNull Map<@NonNull OperationNode, @NonNull Subexpression> node2subexpression;
+	abstract class CheckedCondition implements Comparable<@NonNull CheckedCondition>
+	{
+		private int weight = -1;
+
+		protected void accumulateNodes(@NonNull Set<@NonNull Node> requiredNodes, @NonNull Edge edge) {
+			requiredNodes.addAll(getPrecedingNodes(RegionUtil.getSourceNode(edge)));
+			requiredNodes.addAll(getPrecedingNodes(RegionUtil.getTargetNode(edge)));
+		}
+
+		@Override
+		public int compareTo(@NonNull CheckedCondition that) {
+			int w1 = this.getWeight();
+			int w2 = that.getWeight();
+			return w1 - w2;
+		}
+
+		protected abstract int computeWeight();
+
+		public abstract @NonNull Iterable<@NonNull Edge> getEdges();
+
+		public int getWeight() {
+			if (weight < 0) {
+				weight = computeWeight();
+			}
+			return weight;
+		}
+
+		@Override
+		public @NonNull String toString() {
+			StringBuilder s = new StringBuilder();
+			s.append(getClass().getSimpleName());
+			s.append("(");
+			boolean isFirst = true;
+			for (@NonNull Edge edge : getEdges()) {
+				if (!isFirst) {
+					s.append(",");
+				}
+				s.append(edge.getDisplayName());
+				isFirst = false;
+			}
+			s.append(")");
+			return s.toString();
+		}
+
+	}
+
+	/**
+	 * A CastEdgeCheckedCondition identifies the failure when a source fails to compky with the required target type.
+	 */
+	class CastEdgeCheckedCondition extends CheckedCondition
+	{
+		private final @NonNull NavigableEdge castEdge;
+
+		public CastEdgeCheckedCondition(@NonNull NavigableEdge castEdge) {
+			this.castEdge = castEdge;
+		}
+
+		@Override
+		protected int computeWeight() {
+			Set<@NonNull Node> requiredNodes = new HashSet<>();
+			accumulateNodes(requiredNodes, castEdge);
+			return requiredNodes.size();
+		}
+
+		@Override
+		public @NonNull Iterable<@NonNull Edge> getEdges() {
+			return Collections.singletonList(castEdge);
+		}
+	}
+
+	/**
+	 * A ConstantTargetCheckedCondition identifies the failure when a computation fails to yield the required constant value.
+	 */
+	class ConstantTargetCheckedCondition extends CheckedCondition
+	{
+		private final @NonNull NavigableEdge predicateEdge;
+
+		public ConstantTargetCheckedCondition(@NonNull NavigableEdge predicateEdge) {
+			this.predicateEdge = predicateEdge;
+		}
+
+		@Override
+		protected int computeWeight() {
+			Set<@NonNull Node> requiredNodes = new HashSet<>();
+			requiredNodes.addAll(getPrecedingNodes(RegionUtil.getSourceNode(predicateEdge)));
+			return requiredNodes.size();
+		}
+
+		@Override
+		public @NonNull Iterable<@NonNull Edge> getEdges() {
+			return Collections.singletonList(predicateEdge);
+		}
+	}
+
+	/**
+	 * A MultipleEdgeCheckedCondition identifies the failure when two alternate navigation paths yield inconsistent results.
+	 */
+	class MultipleEdgeCheckedCondition extends CheckedCondition
+	{
+		private final @NonNull List<@NonNull Edge> edges = new ArrayList<>();
+
+		public MultipleEdgeCheckedCondition(@NonNull Edge firstEdge, @NonNull Edge secondEdge) {
+			addEdge(firstEdge);
+			addEdge(secondEdge);
+		}
+
+		public boolean addEdge(@NonNull Edge edge) {
+			return edges.add(edge);
+		}
+
+		@Override
+		protected int computeWeight() {
+			Set<@NonNull Node> requiredNodes = new HashSet<>();
+			for (@NonNull Edge edge : edges) {
+				accumulateNodes(requiredNodes, edge);
+			}
+			return requiredNodes.size();
+		}
+
+		@Override
+		public @NonNull Iterable<@NonNull Edge> getEdges() {
+			return edges;
+		}
+	}
+
+	/**
+	 * A NavigableEdgeCheckedCondition identifies the temporary failure that arises when
+	 * observing a property access to a not-yet assigned slot.
+	 */
+	class NavigableEdgeCheckedCondition extends CheckedCondition
+	{
+		private final @NonNull NavigableEdge navigableEdge;
+
+		public NavigableEdgeCheckedCondition(@NonNull NavigableEdge navigableEdge) {
+			this.navigableEdge = navigableEdge;
+		}
+
+		@Override
+		protected int computeWeight() {
+			Set<@NonNull Node> requiredNodes = new HashSet<>();
+			accumulateNodes(requiredNodes, navigableEdge);
+			return requiredNodes.size();
+		}
+
+		@Override
+		public @NonNull Iterable<@NonNull Edge> getEdges() {
+			return Collections.singletonList(navigableEdge);
+		}
+	}
+
+	/**
+	 * A PredicateEdgeCheckedCondition identifies the failure of a required consistent computation result.
+	 */
+	class PredicateEdgeCheckedCondition extends CheckedCondition
+	{
+		private final @NonNull PredicateEdge predicateEdge;
+
+		public PredicateEdgeCheckedCondition(@NonNull PredicateEdge predicateEdge) {
+			this.predicateEdge = predicateEdge;
+		}
+
+		@Override
+		protected int computeWeight() {
+			Set<@NonNull Node> requiredNodes = new HashSet<>();
+			accumulateNodes(requiredNodes, predicateEdge);
+			return requiredNodes.size();
+		}
+
+		@Override
+		public @NonNull Iterable<@NonNull Edge> getEdges() {
+			return Collections.singletonList(predicateEdge);
+		}
+	}
+
+	/**
+	 * Lazily computed closure of all preceding nodes, icluding the final node, of each node.
+	 */
+	private @Nullable Map<@NonNull Node, @NonNull Set<@NonNull Node>> node2precedingNodeClosure = null;
+
+	/**
+	 * Map from each subexpression result node to its contents.
+	 */
+	private final @NonNull Map<@NonNull OperationNode, @NonNull Subexpression> resultNode2subexpression;
+
+	/**
+	 * Map from each subexpression node to its contents.
+	 */
+	private final @NonNull Map<@NonNull Node, @NonNull Subexpression> node2subexpression = new HashMap<>();
 
 	/**
 	 * Map from each subexpression edge to its contents.
@@ -1039,6 +1174,18 @@
 	private final @NonNull Map<@NonNull Edge, @NonNull Subexpression> edge2subexpression = new HashMap<>();
 
 	/**
+	 * All properties (and their opposites) that need to be checked for readiness before access.
+	 */
+	private final @Nullable Set<@NonNull Property> allCheckedProperties;
+
+	/**
+	 * The unconditional old edges provide the pattern matching workload.
+	 * Once cost sorted the list is a sensible residual scheduling order after higher priority checked edges.
+	 * Conditional edges should be scheduled as a consequence of an invoking unconditional edge/node.
+	 */
+	private final @NonNull List<@NonNull Edge> oldUnconditionalEdges;
+
+	/**
 	 * The selected head from each head group that is actually passed. Other heads are computed.
 	 */
 	private final @NonNull List<@NonNull Node> headNodes = new ArrayList<>();
@@ -1053,27 +1200,70 @@
 	 */
 	private final @NonNull Map<@NonNull Node, @NonNull VariableDeclaration> node2variable = new HashMap<>();
 
+	/**
+	 * The mechanisms to reach required nodes.
+	 */
+	private final @NonNull ReachabilityForest reachabilityForest;
+
 	public BasicRegion2Mapping(@NonNull QVTs2QVTiVisitor visitor, @NonNull Region region) {
 		super(visitor, region);
-		@SuppressWarnings("unused")String name = region.getName();
-		this.node2subexpression = computeSubexpressions();
-
+		this.reachabilityForest = new ReachabilityForest(getReachabilityRootNodes(), getAvailableNavigableEdges());
+		this.resultNode2subexpression = computeSubexpressions();
 		//
-		//	Create the 'local' statements.
+		//	Gather the subexpression contents.
 		//
-		createHeadAndGuardNodeVariables();			// BLUE/CYAN guard/append nodes
-		OldEdgeSchedule oldSchedule = createNavigablePredicates();	// BLUE/CYAN navigable nodes and edges
-		createRealizedVariables();					// GREEN nodes
-		createPropertyAssignments();				// GREEN edges
-		createAddStatements();						// export to append nodes
-		createRealizedIncludesAssignments();
-		Set<@NonNull Property> allCheckedProperties = oldSchedule.getAllCheckedProperties();
-		if (allCheckedProperties != null) {
-			createObservedProperties(allCheckedProperties);					// wrap observable clauses around hazardous accesses
+		Set<@NonNull OperationNode> subexpressionResults = resultNode2subexpression.keySet();
+		for (@NonNull Subexpression subexpression : resultNode2subexpression.values()) {
+			subexpression.analyze(subexpressionResults);
 		}
+		this.allCheckedProperties = computeCheckedProperties();
+		this.oldUnconditionalEdges = computeOldUnconditionalEdges();
+	}
+	private @NonNull Iterable<@NonNull Node> getReachabilityRootNodes() {
 		//
-		//	The 'global' statements are created by createSchedulingStatements().
+		//	The zero-cost nodes are the head nodes ...
 		//
+		List<@NonNull Node> zeroCostNodes = Lists.newArrayList(RegionUtil.getHeadNodes(region));
+		//
+		//	... and the no-input constant nodes
+		//
+		for (@NonNull Node node : RegionUtil.getOwnedNodes(region)) {
+			if (node.isExplicitNull() || node.isOperation()) {
+				if (node.isConstant()) {
+					boolean hasNoComputationInputs = true;
+					for (@NonNull Edge edge : RegionUtil.getIncomingEdges(node)) {
+						if (edge.isComputation()) {
+							hasNoComputationInputs = false;
+							break;
+						}
+					}
+					if (hasNoComputationInputs) {
+						zeroCostNodes.add(node);
+					}
+				}
+			}
+		}
+		return zeroCostNodes;
+	}
+	/**
+	 * Return the navigable edges that may be used by to locate nodes by this partition.
+	 * The default implementation returns all old primary navigable edges
+	 * and all already realized navigable edges
+	 */
+	protected @NonNull Iterable<@NonNull NavigableEdge> getAvailableNavigableEdges() {
+		Set<@NonNull NavigableEdge> oldEdges = new HashSet<>();
+		for (@NonNull Edge edge : RegionUtil.getOwnedEdges(region)) {
+			if (edge.isOld() && edge.isNavigation() /*&& edge.isUnconditional()*/) {
+				Node sourceNode = RegionUtil.getSourceNode(edge);
+				Node targetNode = RegionUtil.getTargetNode(edge);
+				if (sourceNode.isOld() && targetNode.isOld()) {
+					oldEdges.add((NavigableEdge) edge);
+				}
+			}
+		}
+		//		List<@NonNull Edge> sortedEdges = new ArrayList<>(oldEdges);
+		//		Collections.sort(sortedEdges, reachabilityForest.getEdgeCostComparator());
+		return oldEdges;
 	}
 
 	public @Nullable VariableDeclaration basicGetVariable(@NonNull Node node) {
@@ -1081,55 +1271,103 @@
 	}
 
 	/**
+	 * Return all properties (and their opposites) that need checking for readiness prior to access.
+	 */
+	private @Nullable Set<@NonNull Property> computeCheckedProperties() {
+		//
+		// Better, we would not be pessimistic about input/output typedModel ambiguity in endogeneous
+		// mappings, but that incurs many typedModel accuracy issues.
+		//
+		Set<@NonNull Property> allCheckedProperties = null;
+		DomainUsage anyUsage = RegionUtil.getScheduleManager(region).getDomainAnalysis().getAnyUsage();
+		for (@NonNull TypedModel qvtmTypedModel : anyUsage.getTypedModels()) {
+			Iterable<@NonNull NavigableEdge> checkedEdges = RegionAnalysis.get(region).getCheckedEdges(qvtmTypedModel);
+			if (checkedEdges != null) {
+				for (@NonNull NavigableEdge checkedEdge : checkedEdges) {
+					Property asProperty = RegionUtil.getProperty(checkedEdge);
+					if (allCheckedProperties == null) {
+						allCheckedProperties = new HashSet<>();
+					}
+					allCheckedProperties.add(asProperty);
+					Property asOppositeProperty = asProperty.getOpposite();
+					if (asOppositeProperty != null) {
+						allCheckedProperties.add(asOppositeProperty);
+					}
+				}
+			}
+		}
+		return allCheckedProperties;
+	}
+
+	private @NonNull List<@NonNull Edge> computeOldUnconditionalEdges() {
+		Set<@NonNull Edge> oldEdges = new HashSet<>();
+		for (@NonNull Edge edge : RegionUtil.getOwnedEdges(region)) {
+			if (edge.isOld() && edge.isUnconditional()) {
+				Node sourceNode = RegionUtil.getSourceNode(edge);
+				Node targetNode = RegionUtil.getTargetNode(edge);
+				if (sourceNode.isOld() && targetNode.isOld()) {
+					oldEdges.add(edge);
+				}
+			}
+		}
+		List<@NonNull Edge> sortedEdges = new ArrayList<>(oldEdges);
+		Collections.sort(sortedEdges, reachabilityForest.getEdgeCostComparator());
+		return sortedEdges;
+	}
+
+	/**
 	 * Return all subexpressions and their content. A subexpression is an OperationNode whose value is consumed by
 	 * one (or more) PatternNodes or by two (or more) OperationNodes.
 	 */
 	private @NonNull Map<@NonNull OperationNode, @NonNull Subexpression> computeSubexpressions() {
-		Map<@NonNull OperationNode, @NonNull Subexpression> node2subexpression = new HashMap<>();
+		Map<@NonNull OperationNode, @NonNull Subexpression> resultNode2subexpression = new HashMap<>();
 		//
 		//	Identify the subexpression result nodes
 		//
 		for (@NonNull Node node : RegionUtil.getOwnedNodes(region)) {
 			if (node.isOperation() && node.isUnconditional()) {
 				OperationNode resultNode = (OperationNode) node;
-				Edge firstEdge = null;
-				boolean isSubexpression = false;
-				for (@NonNull Edge edge : RegionUtil.getIncomingEdges(node)) {
-					if (edge.isNew() && !edge.isSecondary()) {
-						Node edgeSource = edge.getSourceNode();
-						if (edgeSource.isPattern()) {
-							node2subexpression.put(resultNode, new Subexpression(resultNode));
-							isSubexpression = true;
-							break;
-						}
+				boolean isPrimitiveLiteralExp = false;
+				if (node.isConstant()) {
+					TypedElement oldTypedElement = node.getTypedElements().iterator().next();
+					assert oldTypedElement != null;
+					if (oldTypedElement instanceof PrimitiveLiteralExp) {
+						isPrimitiveLiteralExp = true;
 					}
 				}
-				if (!isSubexpression) {
-					for (@NonNull Edge edge : RegionUtil.getOutgoingEdges(node)) {
-						Node edgeTarget = edge.getTargetNode();
-						if (edgeTarget.isPattern() || edgeTarget.isTrue()) {
-							node2subexpression.put(resultNode, new Subexpression(resultNode));
-							break;
+				if (!isPrimitiveLiteralExp) {
+					Edge firstEdge = null;
+					boolean isSubexpression = false;
+					for (@NonNull Edge edge : RegionUtil.getIncomingEdges(node)) {
+						if (edge.isNew() && !edge.isSecondary()) {
+							Node edgeSource = edge.getSourceNode();
+							if (edgeSource.isPattern()) {
+								resultNode2subexpression.put(resultNode, new Subexpression(resultNode));
+								isSubexpression = true;
+								break;
+							}
 						}
-						if (firstEdge == null) {
-							firstEdge = edge;
-						}
-						else {
-							node2subexpression.put(resultNode, new Subexpression(resultNode));
-							break;
+					}
+					if (!isSubexpression) {
+						for (@NonNull Edge edge : RegionUtil.getOutgoingEdges(node)) {
+							Node edgeTarget = edge.getTargetNode();
+							if (edgeTarget.isPattern() || edgeTarget.isTrue()) {
+								resultNode2subexpression.put(resultNode, new Subexpression(resultNode));
+								break;
+							}
+							if (firstEdge == null) {
+								firstEdge = edge;
+							}
+							else {
+								resultNode2subexpression.put(resultNode, new Subexpression(resultNode));
+								break;
+							}
 						}
 					}
 				}
 			}
 		}
-		//
-		//	Gather the subexpression contents.
-		//
-		Set<@NonNull OperationNode> subexpressionResults = node2subexpression.keySet();
-		for (@NonNull Subexpression subexpression : node2subexpression.values()) {
-			subexpression.analyze(subexpressionResults);
-		}
-		return node2subexpression;
+		return resultNode2subexpression;
 	}
 
 	/**
@@ -1147,6 +1385,49 @@
 		}
 	}
 
+	private void createCallStatements(@NonNull Map<@NonNull Region, @NonNull Map<@NonNull Node, @NonNull Node>> calls) {
+		List<@NonNull MappingStatement> mappingStatements = new ArrayList<>();
+		Map<@NonNull LoopVariable, @NonNull OCLExpression> loopVariables = null;
+		for (Map.Entry<@NonNull Region, @NonNull Map<@NonNull Node, @NonNull Node>> entry : calls.entrySet()) {
+			@NonNull Region calledRegion = entry.getKey();
+			AbstractRegion2Mapping calledRegion2Mapping = visitor.getRegion2Mapping(calledRegion);
+			List<@NonNull MappingParameterBinding> mappingParameterBindings = new ArrayList<>();
+			for (Map.Entry<@NonNull Node, @NonNull Node> entry2 : entry.getValue().entrySet()) {
+				@NonNull Node sourceNode = entry2.getKey();
+				@NonNull Node targetNode = entry2.getValue();
+				OCLExpression sourceExpression = createVariableExp(sourceNode);
+				Type type = sourceExpression.getType();
+				if (type instanceof CollectionType) {
+					if (loopVariables == null) {
+						loopVariables = new HashMap<>();
+					}
+					Type elementType = ((CollectionType)type).getElementType();
+					assert elementType != null;
+					LoopVariable loopVariable = helper.createLoopVariable(getSafeName("loop" + loopVariables.size()), elementType);//, true, sourceExpression);
+					loopVariables.put(loopVariable, sourceExpression);
+					//					sourceExpression = PivotUtil.createVariableExp(loopVariable);
+					VariableDeclaration guardVariable = calledRegion2Mapping.getGuardVariable(targetNode);
+					mappingParameterBindings.add(helper.createLoopParameterBinding((GuardParameter) guardVariable, loopVariable));
+				}
+				else {
+					VariableDeclaration guardVariable = calledRegion2Mapping.getGuardVariable(targetNode);
+					mappingParameterBindings.add(helper.createSimpleParameterBinding((SimpleParameter) guardVariable, sourceExpression));
+				}
+			}
+			Collections.sort(mappingParameterBindings, QVTimperativeUtil.MappingParameterBindingComparator.INSTANCE);
+			MappingStatement mappingCallStatement = calledRegion2Mapping.createMappingCall(mappingParameterBindings);
+			if (loopVariables != null) {
+				for (Map.Entry<@NonNull LoopVariable, @NonNull OCLExpression> loopEntry : loopVariables.entrySet()) {
+					@NonNull LoopVariable loopVariable = loopEntry.getKey();
+					@NonNull OCLExpression loopSource = loopEntry.getValue();
+					mappingCallStatement = helper.createMappingLoop(loopSource, loopVariable, mappingCallStatement);
+				}
+			}
+			mappingStatements.add(mappingCallStatement);
+		}
+		mapping.getOwnedStatements().addAll(mappingStatements);
+	}
+
 	private @NonNull CheckStatement createCheckStatement(@NonNull OCLExpression booleanExpression) {
 		CheckStatement checkStatement = helper.createCheckStatement(booleanExpression);
 		mapping.getOwnedStatements().add(checkStatement);
@@ -1266,83 +1547,46 @@
 		createAppendParameters();
 	}
 
-	private void createMappingStatements(@NonNull Map<@NonNull Region, @NonNull Map<@NonNull Node, @NonNull Node>> calls) {
-		List<@NonNull MappingStatement> mappingStatements = new ArrayList<>();
-		Map<@NonNull LoopVariable, @NonNull OCLExpression> loopVariables = null;
-		for (Map.Entry<@NonNull Region, @NonNull Map<@NonNull Node, @NonNull Node>> entry : calls.entrySet()) {
-			@NonNull Region calledRegion = entry.getKey();
-			AbstractRegion2Mapping calledRegion2Mapping = visitor.getRegion2Mapping(calledRegion);
-			List<@NonNull MappingParameterBinding> mappingParameterBindings = new ArrayList<>();
-			for (Map.Entry<@NonNull Node, @NonNull Node> entry2 : entry.getValue().entrySet()) {
-				@NonNull Node sourceNode = entry2.getKey();
-				@NonNull Node targetNode = entry2.getValue();
-				OCLExpression sourceExpression = createVariableExp(sourceNode);
-				Type type = sourceExpression.getType();
-				if (type instanceof CollectionType) {
-					if (loopVariables == null) {
-						loopVariables = new HashMap<>();
+	private void createObservedProperties() {
+		Set<@NonNull Property> allCheckedProperties2 = allCheckedProperties;
+		if (allCheckedProperties2 != null) {
+			//
+			// Ideally we could install each observed property as it is actually used. But
+			// this needs to be coded in many places.
+			//
+			for (Statement asStatement : mapping.getOwnedStatements()) {
+				if (asStatement instanceof ObservableStatement) {
+					List<Property> observedProperties = ((ObservableStatement)asStatement).getObservedProperties();
+					for (EObject eObject : new TreeIterable(asStatement, false)) {
+						if (eObject instanceof PropertyCallExp) {
+							Property property = PivotUtil.getReferredProperty((PropertyCallExp) eObject);
+							if (allCheckedProperties2.contains(property) && !observedProperties.contains(property)) {
+								observedProperties.add(property);
+							}
+						}
+						else if (eObject instanceof OppositePropertyCallExp) {
+							Property property = PivotUtil.getReferredProperty((NavigationCallExp) eObject).getOpposite();
+							if (allCheckedProperties2.contains(property) && !observedProperties.contains(property)) {
+								observedProperties.add(property);
+							}
+						}
 					}
-					Type elementType = ((CollectionType)type).getElementType();
-					assert elementType != null;
-					LoopVariable loopVariable = helper.createLoopVariable(getSafeName("loop" + loopVariables.size()), elementType);//, true, sourceExpression);
-					loopVariables.put(loopVariable, sourceExpression);
-					//					sourceExpression = PivotUtil.createVariableExp(loopVariable);
-					VariableDeclaration guardVariable = calledRegion2Mapping.getGuardVariable(targetNode);
-					mappingParameterBindings.add(helper.createLoopParameterBinding((GuardParameter) guardVariable, loopVariable));
-				}
-				else {
-					VariableDeclaration guardVariable = calledRegion2Mapping.getGuardVariable(targetNode);
-					mappingParameterBindings.add(helper.createSimpleParameterBinding((SimpleParameter) guardVariable, sourceExpression));
 				}
 			}
-			Collections.sort(mappingParameterBindings, QVTimperativeUtil.MappingParameterBindingComparator.INSTANCE);
-			MappingStatement mappingCallStatement = calledRegion2Mapping.createMappingCall(mappingParameterBindings);
-			if (loopVariables != null) {
-				for (Map.Entry<@NonNull LoopVariable, @NonNull OCLExpression> loopEntry : loopVariables.entrySet()) {
-					@NonNull LoopVariable loopVariable = loopEntry.getKey();
-					@NonNull OCLExpression loopSource = loopEntry.getValue();
-					mappingCallStatement = helper.createMappingLoop(loopSource, loopVariable, mappingCallStatement);
-				}
-			}
-			mappingStatements.add(mappingCallStatement);
 		}
-		mapping.getOwnedStatements().addAll(mappingStatements);
 	}
 
 	/**
-	 * Recurse over the guard nodes and loaded/predicates region and convert the non-guard nodes to unrealized variables
-	 * and edges to predicates or initializations
+	 * Determine a traversal order for the old edges then synthesize the patttern matching statements.
 	 */
-	private @NonNull OldEdgeSchedule createNavigablePredicates() {
-		OldEdgeSchedule oldSchedule = new OldEdgeSchedule(region);
-		oldSchedule.analyze();
-		oldSchedule.synthesize();
-		return oldSchedule;
-	}
-
-	private void createObservedProperties(@NonNull Set<@NonNull Property> allCheckedProperties) {
-		//
-		// Ideally we could install each observed property as it is actually used. But
-		// this needs to be coded in many places.
-		//
-		for (Statement asStatement : mapping.getOwnedStatements()) {
-			if (asStatement instanceof ObservableStatement) {
-				List<Property> observedProperties = ((ObservableStatement)asStatement).getObservedProperties();
-				for (EObject eObject : new TreeIterable(asStatement, false)) {
-					if (eObject instanceof PropertyCallExp) {
-						Property property = PivotUtil.getReferredProperty((PropertyCallExp) eObject);
-						if (allCheckedProperties.contains(property) && !observedProperties.contains(property)) {
-							observedProperties.add(property);
-						}
-					}
-					else if (eObject instanceof OppositePropertyCallExp) {
-						Property property = PivotUtil.getReferredProperty((NavigationCallExp) eObject).getOpposite();
-						if (allCheckedProperties.contains(property) && !observedProperties.contains(property)) {
-							observedProperties.add(property);
-						}
-					}
-				}
-			}
+	private void createPatternMatch() {
+		if (mapping.isIsAbstract()) {
+			mapping.getOwnedStatements().add(createCheckStatement(helper.createBooleanLiteralExp(false)));	// FIXME add a message
+		}
+		else {
+			OldEdgeSchedule oldSchedule = new OldEdgeSchedule();
+			oldSchedule.analyze();
+			oldSchedule.synthesize();
 		}
 	}
 
@@ -1452,39 +1696,6 @@
 		}
 	}
 
-	@Override
-	public void createSchedulingStatements() {
-		Map<@NonNull Region, @NonNull Map<@NonNull Node, @NonNull Node>> calls = null;
-		for (@NonNull Region calledRegion : region.getCallableChildren()) {
-			if (calls == null) {
-				calls = new HashMap<>();
-			}
-			Map<@NonNull Node, @NonNull Node> source2target = calls.get(calledRegion);
-			if (source2target == null) {
-				source2target = new HashMap<>();
-				calls.put(calledRegion, source2target);
-			}
-			AbstractRegion2Mapping calledRegion2Mapping = visitor.getRegion2Mapping(calledRegion);
-			for (@NonNull Node calledGuardNode : calledRegion2Mapping.getGuardNodes()) {
-				for (@NonNull Node callingNode : calledGuardNode.getPassedBindingSources()) {
-					if (callingNode.getOwningRegion() == region) {
-						Node oldNode = source2target.put(callingNode, calledGuardNode);
-						assert oldNode == null;
-					}
-				}
-				for (@NonNull Node callingNode : calledGuardNode.getUsedBindingSources()) {
-					if (callingNode.getOwningRegion() == region) {
-						Node oldNode = source2target.put(callingNode, calledGuardNode);
-						assert oldNode == null;
-					}
-				}
-			}
-		}
-		if (calls != null) {
-			createMappingStatements(calls);
-		}
-	}
-
 	private @NonNull OCLExpression createVariableExp(@NonNull Node node) {
 		if (node.isExplicitNull()) {
 			return helper.createNullLiteralExp();
@@ -1507,6 +1718,24 @@
 		return (MappingParameter) variable;
 	}
 
+	public @NonNull Set<@NonNull Node> getPrecedingNodes(@NonNull Node targetNode) {
+		Map<@NonNull Node, @NonNull Set<@NonNull Node>> node2precedingNodeClosure2 = node2precedingNodeClosure;
+		if (node2precedingNodeClosure2 == null) {
+			node2precedingNodeClosure = node2precedingNodeClosure2 = new HashMap<>();
+		}
+		Set<@NonNull Node> precedingNodes = node2precedingNodeClosure2.get(targetNode);
+		if (precedingNodes == null) {
+			precedingNodes = new HashSet<>();
+			node2precedingNodeClosure2.put(targetNode, precedingNodes);
+			precedingNodes.add(targetNode);
+			for (@NonNull Node sourceNode : reachabilityForest.getPredecessors(targetNode)) {
+				precedingNodes.addAll(getPrecedingNodes(sourceNode));
+			}
+		}
+		assert precedingNodes.size() > 0;
+		return precedingNodes;
+	}
+
 	private @NonNull VariableDeclaration getSubexpressionDeclaration(@NonNull Node node) {
 		VariableDeclaration variable = node2variable.get(node);
 		if (variable == null) {
@@ -1535,6 +1764,15 @@
 		return variable; */
 	}
 
+	private boolean isHazardousWrite(@NonNull NavigableEdge edge) {
+		Node sourceNode = edge.getEdgeSource();
+		Property asProperty = edge.getProperty();
+		TypedModel typedModel = RegionUtil.getTypedModel(RegionUtil.getClassDatumAnalysis(sourceNode));
+		RegionAnalysis regionAnalysis = RegionAnalysis.get(region);
+		Iterable<@NonNull NavigableEdge> enforcedEdges = regionAnalysis.getEnforcedEdges(typedModel, asProperty);
+		return enforcedEdges != null;
+	}
+
 	private boolean isIfExp(@NonNull Node node) {
 		if (node.isExpression()) {
 			for (TypedElement typedElement : node.getTypedElements()) {
@@ -1545,24 +1783,6 @@
 		}
 		return false;
 	}
-
-	private boolean isHazardousWrite(@NonNull NavigableEdge edge) {
-		Node sourceNode = edge.getEdgeSource();
-		Property asProperty = edge.getProperty();
-		TypedModel typedModel = RegionUtil.getTypedModel(RegionUtil.getClassDatumAnalysis(sourceNode));
-		Iterable<@NonNull NavigableEdge> enforcedEdges = RegionAnalysis.get(region).getEnforcedEdges(typedModel);
-		if (enforcedEdges != null) {
-			Property asOppositeProperty = asProperty.getOpposite();
-			for (@NonNull NavigableEdge enforcedEdge : enforcedEdges) {
-				Property edgeProperty = enforcedEdge.getProperty();
-				if ((edgeProperty == asProperty) || (edgeProperty == asOppositeProperty)) {
-					return true;
-				}
-			}
-		}
-		return false;
-	}
-
 	@Override
 	public boolean isInfinite() {
 		if (region.getRecursionEdges().iterator().hasNext()) {		// FIXME unduly pessimistic
@@ -1613,6 +1833,53 @@
 	}
 
 	@Override
+	public void synthesizeCallStatements() {
+		Map<@NonNull Region, @NonNull Map<@NonNull Node, @NonNull Node>> calls = null;
+		for (@NonNull Region calledRegion : region.getCallableChildren()) {
+			if (calls == null) {
+				calls = new HashMap<>();
+			}
+			Map<@NonNull Node, @NonNull Node> source2target = calls.get(calledRegion);
+			if (source2target == null) {
+				source2target = new HashMap<>();
+				calls.put(calledRegion, source2target);
+			}
+			AbstractRegion2Mapping calledRegion2Mapping = visitor.getRegion2Mapping(calledRegion);
+			for (@NonNull Node calledGuardNode : calledRegion2Mapping.getGuardNodes()) {
+				for (@NonNull Node callingNode : calledGuardNode.getPassedBindingSources()) {
+					if (callingNode.getOwningRegion() == region) {
+						Node oldNode = source2target.put(callingNode, calledGuardNode);
+						assert oldNode == null;
+					}
+				}
+				for (@NonNull Node callingNode : calledGuardNode.getUsedBindingSources()) {
+					if (callingNode.getOwningRegion() == region) {
+						Node oldNode = source2target.put(callingNode, calledGuardNode);
+						assert oldNode == null;
+					}
+				}
+			}
+		}
+		if (calls != null) {
+			createCallStatements(calls);
+		}
+	}
+
+	/**
+	 * Create all the statements that support the local content of this micromapping.
+	 */
+	@Override
+	public void synthesizeLocalStatements() {
+		createHeadAndGuardNodeVariables();			// BLUE/CYAN guard/append nodes
+		createPatternMatch();						// BLUE/CYAN nodes and edges
+		createRealizedVariables();					// GREEN nodes
+		createPropertyAssignments();				// GREEN edges
+		createAddStatements();						// export to append nodes
+		createRealizedIncludesAssignments();
+		createObservedProperties();					// wrap observable clauses around hazardous accesses
+	}
+
+	@Override
 	public @NonNull String toString() {
 		return String.valueOf(region);
 	}
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/NavigationEdgeSorter.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/NavigationEdgeSorter.java
index 6447df8..e03429a 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/NavigationEdgeSorter.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/NavigationEdgeSorter.java
@@ -29,8 +29,8 @@
 import com.google.common.collect.Lists;
 
 /**
- * NavigationEdgeSorter supports ordering of a list of NavigationEdges  into least-dependent first order thereby ensuring
- * that unrealized variables are created and initualized for accessed realized attribute nodes before they are used.
+ * NavigationEdgeSorter supports ordering of a list of NavigationEdges into least-dependent first order thereby ensuring
+ * that unrealized variables are created and initialized for accessed realized attribute nodes before they are used.
  */
 public class NavigationEdgeSorter
 {
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/NavigationForestBuilder.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/NavigationForestBuilder.java
deleted file mode 100644
index 1db77cc..0000000
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/NavigationForestBuilder.java
+++ /dev/null
@@ -1,286 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2015, 2017 Willink Transformations and others.
- * All rights reserved.   This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *   E.D.Willink - Initial API and implementation
- *******************************************************************************/
-package org.eclipse.qvtd.compiler.internal.qvts2qvti;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
-import org.eclipse.ocl.pivot.utilities.NameUtil;
-import org.eclipse.qvtd.compiler.internal.qvtm2qvts.RegionUtil;
-import org.eclipse.qvtd.pivot.qvtschedule.Edge;
-import org.eclipse.qvtd.pivot.qvtschedule.NavigableEdge;
-import org.eclipse.qvtd.pivot.qvtschedule.Node;
-
-import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
-
-/**
- * A NavigationForestBuilder selects a forest of navigable edges to reach each navigable node from its heads.
- */
-class NavigationForestBuilder implements Comparator<@NonNull Edge>
-{
-	/**
-	 * The preferred non-secondary edges to be used in the tree.
-	 */
-	private final @NonNull Set<@NonNull Edge> forwardEdges = new HashSet<>();
-
-	/**
-	 * Edges that have no opposite.
-	 */
-	private final @NonNull Set<@NonNull NavigableEdge> manyToOneEdges = new HashSet<>();
-
-	/**
-	 * The edges that are traversed while locating each node and their depth in the traversal forest, 0 at edge sourced by root.
-	 */
-	private final @NonNull Map<@NonNull Edge, @NonNull Integer> traversedEdge2depth = new HashMap<>();
-
-	/**
-	 * The nodes that are traversed while locating each node and their depth in the traversal forest, 0 at root.
-	 */
-	//	private final @NonNull Map<@NonNull Node, @NonNull Integer> traversedNode2depth = new HashMap<>();
-
-	/**
-	 * The incoming edge for each node in the traversal forest, null at a root.
-	 */
-	private final @NonNull Map<@NonNull Node, @Nullable Edge> traversedNode2incomingEdge = new HashMap<>();
-
-	/**
-	 * The nodes that form the traversal forest.
-	 */
-	//	private final @NonNull Set<@NonNull Node> navigableNodes = new HashSet<>();
-
-	/**
-	 * The other edges that are traversed while traversing a primary operation input.
-	 */
-	private final @NonNull Set<@NonNull Edge> otherTraversedEdges = new HashSet<>();
-
-	/**
-	 * The edges that are not traversed while locating each node.
-	 */
-	private final @NonNull Set<@NonNull Edge> untraversedEdges = new HashSet<>();
-
-	public NavigationForestBuilder(@NonNull Iterable<@NonNull Node> rootNodes, @NonNull Iterable<@NonNull Edge> edges) {
-		for (@NonNull Node rootNode : rootNodes) {
-			traversedNode2incomingEdge.put(rootNode, null);
-		}
-		for (@NonNull Edge edge : edges) {
-			addEdge(edge);
-		}
-		//
-		//	Analyze the descendants of the roots to identify the most simply navigated forest.
-		//
-		analyze(traversedNode2incomingEdge.keySet());
-		//
-		//	Traverse the attributes too.
-		//
-		/*		for (@NonNull NavigationEdge edge : attributeEdges) {
-			Node targetNode = edge.getTarget();
-			if (!traversedNode2incomingEdge.containsKey(targetNode)) {
-				traversedNode2incomingEdge.put(targetNode, edge);
-			}
-			else {
-				untraversedEdges.add(edge);
-			}
-		} */
-		//
-		//	Identify the remaining untraversed edges that are not used to reach nodes and so must be reified as predicates to check nodes.
-		//
-		Set<@NonNull Edge> predicateEdges = Sets.newHashSet(forwardEdges);
-		for (@NonNull Edge traversedEdge : getTraversedEdges()) {
-			predicateEdges.remove(traversedEdge);
-			if (traversedEdge.isNavigation()) {
-				NavigableEdge oppositeEdge = ((NavigableEdge)traversedEdge).getOppositeEdge();
-				if (oppositeEdge != null) {
-					predicateEdges.remove(oppositeEdge);
-				}
-			}
-		}
-		predicateEdges.removeAll(otherTraversedEdges);
-		untraversedEdges.addAll(predicateEdges);
-	}
-
-	/**
-	 * Add a possible edge and end nodes categorizing a navigable edge as forward if it is a sole or primary edge,
-	 * reverse if it is a secondary edge.
-	 */
-	protected void addEdge(@NonNull Edge edge) {
-		if (edge.isRealized()) {}
-		else if (edge.isCast()) {}
-		else {
-			//			assert !edge.isExpression();
-			//			assert !edge.isComputation();
-			Node targetNode = edge.getEdgeTarget();
-			targetNode = RegionUtil.getCastTarget(targetNode);
-			if (!edge.isSecondary()) {
-				forwardEdges.add(edge);
-				if ((edge.getEdgeSource().isClass()) && (edge instanceof NavigableEdge)) {
-					NavigableEdge navigableEdge = (NavigableEdge)edge;
-					if (navigableEdge.getOppositeEdge() == null) {
-						manyToOneEdges.add((NavigableEdge)edge);
-					}
-				}
-			}
-		}
-	}
-
-	/**
-	 * Identify the forest from the given roots.
-	 */
-	public void analyze(@NonNull Iterable<@NonNull Node> rootNodes) {
-		Set<@NonNull Node> moreNodes = Sets.newHashSet(rootNodes);
-		//
-		//	Advance breadth first, one depth at a time, accumulating all edges that make one stage of progress.
-		//
-		for (int depth = 0; moreNodes.size() > 0; depth++) {
-			//
-			//	Select the forward edges that make progress.
-			//
-			Set<@NonNull Node> moreMoreNodes = new HashSet<>();
-			for (@NonNull Node sourceNode : moreNodes) {
-				//				traversedNode2depth.put(sourceNode, depth);
-				for (@NonNull Edge forwardEdge : RegionUtil.getOutgoingEdges(sourceNode)) {
-					if (forwardEdges.contains(forwardEdge)) {
-						Node targetNode = RegionUtil.getCastTarget(forwardEdge.getEdgeTarget());
-						if (forwardEdge.isNavigation()) {
-							if (!traversedNode2incomingEdge.containsKey(targetNode)) {
-								traversedNode2incomingEdge.put(targetNode, forwardEdge);
-								moreMoreNodes.add(targetNode);
-								traversedEdge2depth.put(forwardEdge, depth);
-							}
-						}
-						else if (forwardEdge.isExpression()) {
-							boolean allReady = true;
-							for (@NonNull Edge incomingEdge : RegionUtil.getIncomingEdges(targetNode)) {
-								if (incomingEdge.isExpression()) {
-									Node expressionSourceNode = incomingEdge.getSourceNode();
-									if (!traversedNode2incomingEdge.containsKey(expressionSourceNode)) {
-										allReady = false;
-										break;
-									}
-								}
-							}
-							if (allReady) {
-								for (@NonNull Edge incomingEdge : RegionUtil.getIncomingEdges(targetNode)) {
-									if (incomingEdge.isExpression()) {
-										traversedEdge2depth.put(incomingEdge, depth);
-										if (incomingEdge != forwardEdge) {
-											otherTraversedEdges.add(incomingEdge);
-										}
-									}
-								}
-								traversedNode2incomingEdge.put(targetNode, forwardEdge);
-								if (!targetNode.getOutgoingEdges().isEmpty()) {
-									moreMoreNodes.add(targetNode);
-								}
-							}
-						}
-						else {
-							assert false;
-						}
-					}
-				}
-			}
-			if (moreMoreNodes.isEmpty()) {
-				//
-				//	If no forward edge makes progress, select just one backward edge instead.
-				//
-				for (@NonNull Edge forwardEdge : forwardEdges) {		// FIXME maintain reducing list of possibles
-					if (forwardEdge instanceof NavigableEdge) {
-						NavigableEdge navigableForwardEdge = (NavigableEdge)forwardEdge;
-						@Nullable NavigableEdge backwardEdge = navigableForwardEdge.getOppositeEdge();
-						if (backwardEdge != null) {
-							Node sourceNode = backwardEdge.getEdgeSource();
-							if (traversedNode2incomingEdge.containsKey(sourceNode)) {
-								Node targetNode = backwardEdge.getEdgeTarget();
-								if (!traversedNode2incomingEdge.containsKey(targetNode)) {
-									traversedNode2incomingEdge.put(targetNode, backwardEdge);
-									moreMoreNodes.add(targetNode);
-									traversedEdge2depth.put(backwardEdge, depth);
-									break;
-								}
-							}
-						}
-					}
-				}
-				if (moreMoreNodes.isEmpty()) {
-					//
-					//	If no backward edge makes progress, select just one inverse edge instead.
-					//
-					for (@NonNull NavigableEdge manyToOneEdge : manyToOneEdges) {		// FIXME maintain reducing list of possibles
-						Node sourceNode = manyToOneEdge.getEdgeTarget();
-						if (traversedNode2incomingEdge.containsKey(sourceNode)) {
-							Node targetNode = manyToOneEdge.getEdgeSource();
-							if (!traversedNode2incomingEdge.containsKey(targetNode)) {
-								traversedNode2incomingEdge.put(targetNode, manyToOneEdge);
-								moreMoreNodes.add(targetNode);
-								traversedEdge2depth.put(manyToOneEdge, depth);
-								break;
-							}
-						}
-					}
-				}
-			}
-			moreNodes = moreMoreNodes;
-		}
-	}
-
-	/**
-	 *	Select the shallowest first then alphabetical ordering of the traversal edges of the forest.
-	 *
-	 * FIXME prioritize fallible predicate paths
-	 */
-	@Override
-	public int compare(@NonNull Edge o1, @NonNull Edge o2) {
-		Integer d1 = traversedEdge2depth.get(o1);
-		Integer d2 = traversedEdge2depth.get(o2);
-		assert (d1 != null) && (d2 != null);
-		if (d1 != d2) {
-			return d1 - d2;
-		}
-		String n1 = o1.getDisplayName();
-		String n2 = o2.getDisplayName();
-		return n1.compareTo(n2);
-	}
-
-	/**
-	 *	Return a shallowest first then alphabetical ordering of the traversal edges of the forest.
-	 */
-	public @NonNull List<@NonNull Edge> getForestNavigations() {
-		List<@NonNull Edge> forestNavigations = Lists.newArrayList(getTraversedEdges());
-		forestNavigations.removeAll(otherTraversedEdges);
-		Collections.sort(forestNavigations, this);
-		return forestNavigations;
-	}
-
-	/**
-	 *	Return an alphabetical ordering of the residual edges to be checked as predicates.
-	 */
-	public @NonNull List<@NonNull Edge> getGraphPredicates() {
-		List<@NonNull Edge> graphPredicateEdges = new ArrayList<>();
-		for (@NonNull Edge untraversedEdge : untraversedEdges) {
-			graphPredicateEdges.add(untraversedEdge);
-		}
-		Collections.sort(graphPredicateEdges, NameUtil.NAMEABLE_COMPARATOR);
-		return graphPredicateEdges;
-	}
-
-	protected @NonNull Iterable<@NonNull Edge> getTraversedEdges() {
-		return traversedEdge2depth.keySet();
-	}
-}
\ No newline at end of file
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/QVTs2QVTiVisitor.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/QVTs2QVTiVisitor.java
index 79ada5e..0dbe92a 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/QVTs2QVTiVisitor.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/QVTs2QVTiVisitor.java
@@ -194,6 +194,7 @@
 		else {
 			region2mapping = new BasicRegion2Mapping(this, region);
 		}
+		region2mapping.synthesizeLocalStatements();
 		region2region2mapping.put(region, region2mapping);
 		qvtiTransformation.getRule().add(region2mapping.getMapping());
 		region.accept(this);
@@ -456,7 +457,7 @@
 		for (@NonNull Region region : sortedRegions) {
 			//			if (!region.isConnectionRegion()) {
 			AbstractRegion2Mapping region2Mapping = getRegion2Mapping(region);
-			region2Mapping.createSchedulingStatements();
+			region2Mapping.synthesizeCallStatements();
 			//			}
 		}
 		// Mappings are in schedule index order.
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/RootRegion2Mapping.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/RootRegion2Mapping.java
index 753adc7..57386b8 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/RootRegion2Mapping.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvti/RootRegion2Mapping.java
@@ -66,21 +66,6 @@
 
 	public RootRegion2Mapping(@NonNull QVTs2QVTiVisitor visitor, @NonNull LoadingRegion region) {
 		super(visitor, region);
-		//
-		//	Create domains
-		//
-		Set<@NonNull ImperativeTypedModel> checkableTypedModels = new HashSet<>();
-		for (@NonNull Node node : RegionUtil.getOwnedNodes(region)) {
-			ClassDatum classDatum = node.getClassDatum();
-			org.eclipse.ocl.pivot.Class type = classDatum.getCompleteClass().getPrimaryClass();
-			if (!(type instanceof DataType) && !(type instanceof AnyType) && !(type instanceof VoidType) && !(type instanceof InvalidType)) {
-				TypedModel qvtmTypedModel = classDatum.getReferredTypedModel();
-				ImperativeTypedModel qvtiTypedModel = visitor.getQVTiTypedModel(qvtmTypedModel);
-				if (qvtiTypedModel != null) {
-					checkableTypedModels.add(qvtiTypedModel);
-				}
-			}
-		}
 	}
 
 	private @NonNull ConnectionVariable createRootConnectionVariable(@NonNull String name, boolean isStrict, @NonNull Type type, @Nullable OCLExpression initExpression) {
@@ -123,78 +108,6 @@
 	}
 
 	@Override
-	public void createSchedulingStatements() {
-		//		BottomPattern bottomPattern = mapping.getBottomPattern();
-		createRootConnectionVariables();
-		/*		//
-		//	Cache the children in a middle bottom pattern variable.
-		//
-		OCLExpression parentExpression = createVariableExp(headNode);
-		OCLExpression initExpression = PivotUtil.createNavigationCallExp(parentExpression, property);
-		Type asType = initExpression.getType();
-		if (!(asType instanceof CollectionType)) {
-			initExpression = createOclAsSetCallExp(initExpression);
-			asType = initExpression.getType();
-		}
-		assert asType != null;
-		Variable childrenVariable = PivotUtil.createVariable(getSafeName("allChildren"), asType, true, initExpression);
-		mapping.getBottomPattern().getVariable().add(childrenVariable); */
-		//
-		//	Create union assignments for connections.
-		//
-		//		if (connection2variable != null) {
-		/*			Operation asOperation = NameUtil.getNameable(visitor.getStandardLibrary().getCollectionType().getOwnedOperations(), "union");
-			for (Node node : region.getNodes()) {
-				if (node.isComposed()) {
-					for (InterRegionEdge edge : node.getOutgoingPassedBindingEdges()) {
-						Node connectionNode = edge.getTarget();
-						Region connectionRegion = connectionNode.getRegion();
-						Variable connectionVariable = connection2variable.get(connectionRegion);
-						if (connectionVariable != null) {
-							OCLExpression collection1 = helper.createVariableExp(connectionVariable);
-							OCLExpression collection2 = createSelectByKind(node);
-							OCLExpression union = createOperationCallExp(collection1, asOperation, collection2);
-							VariableAssignment variableAssignment = QVTcoreBaseFactory.eINSTANCE.createVariableAssignment();
-							variableAssignment.setTargetVariable(connectionVariable);
-							variableAssignment.setValue(union);
-							bottomPattern.getAssignment().add(variableAssignment);
-						}
-					}
-				}
-			}
-			bottomPattern.getVariable().addAll(connection2variable.values());
-//		} */
-		/*		ChainNode chain = visitor.getChain(region);
-		for (ChainNode child : chain.getChildren()) {
-			Region calledRegion = child.getRegion();
-			if (!calledRegion.isConnectionRegion()) {
-				mappingStatement = createCalls(mappingStatement, calledRegion);
-			}
-			else if (Iterables.isEmpty(child.getChildren())) {
-//				mappingStatement = createCalls(mappingStatement, calledRegion);
-			}
-			else {
-				assert calledRegion.isConnectionRegion();
-				assert !Iterables.isEmpty(child.getChildren());
-				for (ChainNode connectionChild : child.getChildren()) {
-					Region connectionedRegion = connectionChild.getRegion();
-					assert !connectionedRegion.isConnectionRegion();
-					mappingStatement = createCalls(mappingStatement, connectionedRegion);
-				}
-			}
-		} */
-		List<Statement> ownedStatements = mapping.getOwnedStatements();
-		for (@NonNull Region callableRegion : region.getCallableChildren()) {
-			if (isInstall(callableRegion)) {
-				ownedStatements.add(createInstall(callableRegion));
-			}
-			else {
-				ownedStatements.add(createCall(callableRegion, null));
-			}
-		}
-	}
-
-	@Override
 	protected @NonNull OCLExpression createSelectByKind(@NonNull Node resultNode) {
 		throw new UnsupportedOperationException();
 		/*refactored code inlined at call point -- ?? ok, but needs usage analysis
@@ -267,4 +180,95 @@
 		}
 		return true;
 	}
+
+	@Override
+	public void synthesizeCallStatements() {
+		//		BottomPattern bottomPattern = mapping.getBottomPattern();
+		createRootConnectionVariables();
+		/*		//
+			//	Cache the children in a middle bottom pattern variable.
+			//
+			OCLExpression parentExpression = createVariableExp(headNode);
+			OCLExpression initExpression = PivotUtil.createNavigationCallExp(parentExpression, property);
+			Type asType = initExpression.getType();
+			if (!(asType instanceof CollectionType)) {
+				initExpression = createOclAsSetCallExp(initExpression);
+				asType = initExpression.getType();
+			}
+			assert asType != null;
+			Variable childrenVariable = PivotUtil.createVariable(getSafeName("allChildren"), asType, true, initExpression);
+			mapping.getBottomPattern().getVariable().add(childrenVariable); */
+		//
+		//	Create union assignments for connections.
+		//
+		//		if (connection2variable != null) {
+		/*			Operation asOperation = NameUtil.getNameable(visitor.getStandardLibrary().getCollectionType().getOwnedOperations(), "union");
+				for (Node node : region.getNodes()) {
+					if (node.isComposed()) {
+						for (InterRegionEdge edge : node.getOutgoingPassedBindingEdges()) {
+							Node connectionNode = edge.getTarget();
+							Region connectionRegion = connectionNode.getRegion();
+							Variable connectionVariable = connection2variable.get(connectionRegion);
+							if (connectionVariable != null) {
+								OCLExpression collection1 = helper.createVariableExp(connectionVariable);
+								OCLExpression collection2 = createSelectByKind(node);
+								OCLExpression union = createOperationCallExp(collection1, asOperation, collection2);
+								VariableAssignment variableAssignment = QVTcoreBaseFactory.eINSTANCE.createVariableAssignment();
+								variableAssignment.setTargetVariable(connectionVariable);
+								variableAssignment.setValue(union);
+								bottomPattern.getAssignment().add(variableAssignment);
+							}
+						}
+					}
+				}
+				bottomPattern.getVariable().addAll(connection2variable.values());
+	//		} */
+		/*		ChainNode chain = visitor.getChain(region);
+			for (ChainNode child : chain.getChildren()) {
+				Region calledRegion = child.getRegion();
+				if (!calledRegion.isConnectionRegion()) {
+					mappingStatement = createCalls(mappingStatement, calledRegion);
+				}
+				else if (Iterables.isEmpty(child.getChildren())) {
+	//				mappingStatement = createCalls(mappingStatement, calledRegion);
+				}
+				else {
+					assert calledRegion.isConnectionRegion();
+					assert !Iterables.isEmpty(child.getChildren());
+					for (ChainNode connectionChild : child.getChildren()) {
+						Region connectionedRegion = connectionChild.getRegion();
+						assert !connectionedRegion.isConnectionRegion();
+						mappingStatement = createCalls(mappingStatement, connectionedRegion);
+					}
+				}
+			} */
+		List<Statement> ownedStatements = mapping.getOwnedStatements();
+		for (@NonNull Region callableRegion : region.getCallableChildren()) {
+			if (isInstall(callableRegion)) {
+				ownedStatements.add(createInstall(callableRegion));
+			}
+			else {
+				ownedStatements.add(createCall(callableRegion, null));
+			}
+		}
+	}
+
+	@Override
+	public void synthesizeLocalStatements() {
+		//
+		//	Create domains
+		//
+		Set<@NonNull ImperativeTypedModel> checkableTypedModels = new HashSet<>();
+		for (@NonNull Node node : RegionUtil.getOwnedNodes(region)) {
+			ClassDatum classDatum = node.getClassDatum();
+			org.eclipse.ocl.pivot.Class type = classDatum.getCompleteClass().getPrimaryClass();
+			if (!(type instanceof DataType) && !(type instanceof AnyType) && !(type instanceof VoidType) && !(type instanceof InvalidType)) {
+				TypedModel qvtmTypedModel = classDatum.getReferredTypedModel();
+				ImperativeTypedModel qvtiTypedModel = visitor.getQVTiTypedModel(qvtmTypedModel);
+				if (qvtiTypedModel != null) {
+					checkableTypedModels.add(qvtiTypedModel);
+				}
+			}
+		}
+	}
 }
\ No newline at end of file
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/utilities/ReachabilityForest.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/utilities/ReachabilityForest.java
new file mode 100644
index 0000000..fbaa3dc
--- /dev/null
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/utilities/ReachabilityForest.java
@@ -0,0 +1,320 @@
+/*******************************************************************************
+ * Copyright (c) 2015, 2017 Willink Transformations and others.
+ * All rights reserved.   This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *   E.D.Willink - Initial API and implementation
+ *******************************************************************************/
+package org.eclipse.qvtd.compiler.internal.qvts2qvts.utilities;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.ocl.pivot.utilities.ClassUtil;
+import org.eclipse.qvtd.compiler.internal.qvtm2qvts.RegionUtil;
+import org.eclipse.qvtd.pivot.qvtschedule.Edge;
+import org.eclipse.qvtd.pivot.qvtschedule.NavigableEdge;
+import org.eclipse.qvtd.pivot.qvtschedule.Node;
+import com.google.common.collect.Lists;
+
+/**
+ * The ReachabilityForest comprises a tree of preferred edge paths from each head/leaf-constant root node to the
+ * nodes that can be reached from them. It answers the question: what preceding nodes are necessary to ensure
+ * that a given node is reachable.
+ */
+public class ReachabilityForest
+{
+	private static final int FORWARD_NAVIGATION_COST = 1;
+	private static final int INVERSE_MANY_NAVIGATION_COST = 5;
+	private static final int INVERSE_NAVIGATION_COST = 3;
+	private static final int ITERATOR_COST = 1;
+	private static final int OPERATION_COST = 10;
+	private static final int RESULT_COST = 1;
+
+	/**
+	 * The preferred non-secondary edges to be used in the tree.
+	 */
+	private final @NonNull Set<@NonNull NavigableEdge> forwardEdges = new HashSet<>();
+
+	/**
+	 * Edges that have no opposite.
+	 */
+	private final @NonNull Set<@NonNull Edge> manyToOneEdges = new HashSet<>();
+
+	/**
+	 * The incoming edge for each node in the traversal forest, null at a root.
+	 */
+	private final @NonNull Map<@NonNull Node, @Nullable Edge> node2reachingEdge = new HashMap<>();
+
+	/**
+	 * The cost for each node from the root in the traversal forest, 0 at a root. The cost is equal
+	 * to the sum of the costs of each edge on the lowest cost path from the root.
+	 */
+	private @NonNull Map<@NonNull Node, @NonNull Integer> node2cost = new HashMap<>();
+
+	/**
+	 * Lazily created compartor to order nodes lowest cost first.
+	 */
+	private @Nullable Comparator<@NonNull Edge> edgeCostComparator = null;
+
+	/**
+	 * Lazily created compartor to order nodes lowest cost first.
+	 */
+	private @Nullable Comparator<@NonNull Node> nodeCostComparator = null;
+
+
+	/**
+	 * Construct the Reachability forest for the specified rootNodes using the availableNavigableEdges to locate
+	 * paths to further nodes and also any old computation edges.
+	 */
+	public ReachabilityForest(@NonNull Iterable<@NonNull Node> rootNodes, @NonNull Iterable<@NonNull NavigableEdge> availableNavigableEdges) {
+		for (@NonNull Node rootNode : rootNodes) {
+			node2reachingEdge.put(rootNode, null);
+		}
+		for (@NonNull NavigableEdge edge : availableNavigableEdges) {
+			addEdge(edge);
+		}
+		//
+		//	Analyze the descendants of the roots to identify the most simply navigated forest.
+		//
+		analyze(node2reachingEdge.keySet());
+	}
+
+	protected void addEdge(@NonNull NavigableEdge edge) {
+		if (!edge.isSecondary()) {
+			forwardEdges.add(edge);
+			if ((edge.getEdgeSource().isClass()) && (edge.getOppositeEdge() == null)) {
+				manyToOneEdges.add(edge);
+			}
+		}
+	}
+
+	/**
+	 * Identify the forest from the given roots.
+	 */
+	protected void analyze(@NonNull Iterable<@NonNull Node> rootNodes) {
+		List<@Nullable List<@NonNull Node>> costs2nodes = new ArrayList<>();
+		for (@NonNull Node rootNode : rootNodes) {
+			node2cost.put(rootNode, 0);
+		}
+		costs2nodes.add(Lists.newArrayList(rootNodes));
+		//
+		//	Advance breadth first, one cost at a time, accumulating all edges that make one stage of progress.
+		//
+		for (int thisCost = 0; thisCost < costs2nodes.size(); thisCost++) {
+			List<@NonNull Node> thisCostNodes = costs2nodes.get(thisCost);
+			if (thisCostNodes != null) {
+				//
+				//	Add the forward edges that make progress to moreMoreNodes and remember the
+				//	backward and inverse edges in case forward egdes alone are inadequate.
+				//
+				for (@NonNull Node sourceNode : thisCostNodes) {
+					assert node2cost.get(sourceNode) == thisCost;
+					for (@NonNull Edge edge : RegionUtil.getOutgoingEdges(sourceNode)) {
+						Node targetNode = edge.getEdgeTarget();
+						if (!node2reachingEdge.containsKey(targetNode)) {
+							Integer targetCost = node2cost.get(targetNode);
+							assert (targetCost == null) || (thisCost < targetCost);
+							if (edge.isNavigation()) {
+								NavigableEdge navigableEdge = (NavigableEdge) edge;
+								if (forwardEdges.contains(navigableEdge)) {
+									int nextCost = thisCost + FORWARD_NAVIGATION_COST;
+									if ((targetCost == null) || (nextCost < targetCost)) {
+										node2cost.put(targetNode, nextCost);
+										node2reachingEdge.put(targetNode, edge);
+										putCosts(costs2nodes, nextCost, targetNode);
+									}
+								}
+								else {
+									NavigableEdge oppositeEdge = navigableEdge.getOppositeEdge();
+									if (forwardEdges.contains(oppositeEdge)) {
+										int nextCost = thisCost + INVERSE_NAVIGATION_COST;
+										if ((targetCost == null) || (nextCost < targetCost)) {
+											node2cost.put(targetNode, nextCost);
+											node2reachingEdge.put(targetNode, oppositeEdge);
+											putCosts(costs2nodes, nextCost, targetNode);
+										}
+									}
+									else if (manyToOneEdges.contains(oppositeEdge)) {
+										int nextCost = thisCost + INVERSE_MANY_NAVIGATION_COST;
+										if ((targetCost == null) || (nextCost < targetCost)) {
+											node2cost.put(targetNode, nextCost);
+											node2reachingEdge.put(targetNode, oppositeEdge);
+											putCosts(costs2nodes, nextCost, targetNode);
+										}
+									}
+								}
+							}
+							else if (edge.isComputation() /*&& edge.isUnconditional()*/) {
+								int nextCost = thisCost + OPERATION_COST;
+								if (targetNode.isOperation()) {
+									for (@NonNull Edge incomingEdge : RegionUtil.getIncomingEdges(targetNode)) {
+										if (incomingEdge.isOld() && incomingEdge.isComputation()) {
+											Node node = RegionUtil.getSourceNode(incomingEdge);
+											Integer cost = node2cost.get(node);
+											if ((cost == null) || (cost > thisCost)) {
+												nextCost = -1;
+												break;
+											}
+										}
+									}
+								}
+								else if (targetNode.isIterator()) {
+									nextCost = thisCost + ITERATOR_COST;
+								}
+								else {
+									nextCost = thisCost + RESULT_COST;
+								}
+								if (nextCost > 0) {
+									if ((targetCost == null) || (nextCost < targetCost)) {
+										node2cost.put(targetNode, nextCost);
+										node2reachingEdge.put(targetNode, edge);
+										putCosts(costs2nodes, nextCost, targetNode);
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	public @Nullable Integer getCost(@NonNull Node node) {
+		return node2cost.get(node);
+	}
+
+	/**
+	 * Return a comparator to sort edges source cost first then target cost then alphabetically.
+	 */
+	public @NonNull Comparator<@NonNull Edge> getEdgeCostComparator() {
+		Comparator<@NonNull Edge> edgeCostComparator2 = edgeCostComparator;
+		if (edgeCostComparator2 == null) {
+			edgeCostComparator = edgeCostComparator2 = new Comparator<@NonNull Edge>()
+			{
+				@Override
+				public int compare(@NonNull Edge e1, @NonNull Edge e2) {
+					Integer d1s = node2cost.get(RegionUtil.getSourceNode(e1));
+					Integer d1t = node2cost.get(RegionUtil.getTargetNode(e1));
+					Integer d2s = node2cost.get(RegionUtil.getSourceNode(e2));
+					Integer d2t = node2cost.get(RegionUtil.getTargetNode(e2));
+					assert (d1s != null) && (d1t != null) && (d2s != null) && (d2t != null);
+					int d1 = Math.max(d1s,  d1t);
+					int d2 = Math.max(d2s,  d2t);
+					if (d1 != d2) {
+						return d1 - d2;
+					}
+					if (d1s != d2s) {
+						return d1s - d2s;
+					}
+					return ClassUtil.safeCompareTo(e1.getDisplayName(), e2.getDisplayName());
+				}
+			};
+		}
+		return edgeCostComparator2;
+	}
+
+	/**
+	 * Return a comparator to sort nodes cost first then alphabetically.
+	 */
+	public @NonNull Comparator<@NonNull Node> getNodeCostComparator() {
+		Comparator<@NonNull Node> nodeCostComparator2 = nodeCostComparator;
+		if (nodeCostComparator2 == null) {
+			nodeCostComparator = nodeCostComparator2 = new Comparator<@NonNull Node>()
+			{
+				@Override
+				public int compare(@NonNull Node o1, @NonNull Node o2) {
+					Integer c1 = node2cost.get(o1);
+					Integer c2 = node2cost.get(o2);
+					assert (c1 != null) && (c2 != null);
+					int diff = c1 - c2;
+					if (diff != 0) {
+						return diff;
+					}
+					return ClassUtil.safeCompareTo(o1.getName(), o2.getName());
+				}
+			};
+		}
+		return nodeCostComparator2;
+	}
+
+	public @NonNull Iterable<@NonNull Node> getPredecessors(@NonNull Node targetNode) {
+		Set<@NonNull Node> precedingNodes = new HashSet<@NonNull Node>();
+		getPredecessors(precedingNodes, targetNode);
+		precedingNodes.remove(targetNode);
+		return precedingNodes;
+	}
+	private void getPredecessors(@NonNull Set<@NonNull Node> precedingNodes, @NonNull Node targetNode) {
+		if (precedingNodes.add(targetNode)) {
+			if (targetNode.isOperation()) {
+				for (@NonNull Edge edge : RegionUtil.getIncomingEdges(targetNode)) {
+					//					assert edge.isUnconditional();
+					if (edge.isComputation()) {
+						getPredecessors(precedingNodes, edge.getEdgeSource());
+					}
+				}
+			}
+			else {
+				Edge parentEdge = getReachingEdge(targetNode);
+				if (parentEdge != null) {
+					Node sourceNode = parentEdge.getEdgeSource();
+					if (sourceNode == targetNode) {		// invert a backward edge
+						sourceNode = parentEdge.getEdgeTarget();
+					}
+					getPredecessors(precedingNodes, sourceNode);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Return the edge from the preceding reachable node to the given reachable node. Null if none.
+	 */
+	public @Nullable Edge getReachingEdge(@NonNull Node node) {
+		return node2reachingEdge.get(node);
+	}
+
+	private void putCosts(@NonNull List<@Nullable List<@NonNull Node>> costs2nodes, int cost, @NonNull Node node) {
+		while (costs2nodes.size() <= cost) {
+			costs2nodes.add(null);
+		}
+		List<@NonNull Node> nodes = costs2nodes.get(cost);
+		if (nodes == null) {
+			nodes = new ArrayList<>();
+			costs2nodes.set(cost, nodes);
+		}
+		if (!nodes.contains(node)) {
+			nodes.add(node);
+		}
+	}
+
+	@Override
+	public @NonNull String toString() {
+		Comparator<@NonNull Node> nodeComparator = getNodeCostComparator();
+		StringBuilder s = new StringBuilder();
+		List<@NonNull Node> nodes = new ArrayList<>(node2cost.keySet());
+		Collections.sort(nodes, nodeComparator);
+		for (@NonNull Node node : nodes) {
+			if (s.length() > 0) {
+				s.append("\n");
+			}
+			s.append(node2cost.get(node));
+			s.append(": ");
+			s.append(node.getName());
+			s.append(" : ");
+			s.append(node2reachingEdge.get(node));
+		}
+		return s.toString();
+	}
+}
\ No newline at end of file