diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/AbstractRegion.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/AbstractRegion.java
index 45eacb0..14b5c5b 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/AbstractRegion.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/AbstractRegion.java
@@ -28,12 +28,10 @@
 import org.eclipse.ocl.pivot.TypedElement;
 import org.eclipse.ocl.pivot.VariableDeclaration;
 import org.eclipse.ocl.pivot.utilities.ClassUtil;
-import org.eclipse.ocl.pivot.utilities.NameUtil;
 import org.eclipse.ocl.pivot.utilities.StringUtil;
 import org.eclipse.qvtd.compiler.CompilerProblem;
 import org.eclipse.qvtd.compiler.internal.qvtp2qvts.analysis.ClassDatumAnalysis;
 import org.eclipse.qvtd.compiler.internal.qvts2qvti.QVTs2QVTiVisitor;
-import org.eclipse.qvtd.compiler.internal.qvts2qvts.Region2Depth;
 import org.eclipse.qvtd.compiler.internal.utilities.SymbolNameBuilder;
 import org.eclipse.qvtd.compiler.internal.utilities.ToDOT;
 import org.eclipse.qvtd.pivot.qvtbase.TypedModel;
@@ -536,188 +534,6 @@
 	}
 
 	@Override
-	public @Nullable Map<@NonNull Node, @NonNull Node> canMerge(@NonNull Region secondaryRegion, @NonNull Region2Depth region2depths, boolean isLateMerge) {
-		Map<@NonNull Node, @NonNull Node> secondaryNode2primaryNode = null;
-		Map<@NonNull CompleteClass, @NonNull List<@NonNull Node>> completeClass2node = getCompleteClass2Node();
-		//
-		//	Find the unambiguous head-node matches
-		//
-		List<@NonNull Node> secondaryHeadNodes = secondaryRegion.getHeadNodes();
-		if (secondaryHeadNodes.size() != 1) {
-			return null;
-		}
-		Node secondaryHeadNode = secondaryHeadNodes.get(0);
-		CompleteClass completeClass = secondaryHeadNode.getCompleteClass();
-		List<@NonNull Node> primaryNodes = completeClass2node.get(completeClass);
-		if (primaryNodes != null) {
-			Node primaryHeadNode = selectMergedHeadNode(secondaryHeadNode, primaryNodes);
-			if (primaryHeadNode == null) {
-				return null;
-			}
-			secondaryNode2primaryNode = new HashMap<>();
-			if ("if".equals(secondaryHeadNode.getName())) {
-				secondaryHeadNode.getName();
-			}
-			secondaryNode2primaryNode.put(secondaryHeadNode, primaryHeadNode);
-		}
-		if (secondaryNode2primaryNode == null) {
-			return null;
-		}
-		//
-		//	Validate the transitive navigation from the head nodes. All common navigation edges must have compatible node types.
-		//
-		if (!canMergeInternal(secondaryRegion, secondaryNode2primaryNode, region2depths, isLateMerge)) {
-			return null;
-		}
-		//FIXME Must be symmetrically mergeable; do tests before creating MergedRegion
-		//
-		//	Validate the true node predicate compatibility
-		//
-		Iterable<@NonNull Node> primaryTrueNodes = this.getTrueNodes();
-		Iterable<@NonNull Node> secondaryTrueNodes = secondaryRegion.getTrueNodes();
-		if (Iterables.size(primaryTrueNodes) != Iterables.size(secondaryTrueNodes)) {
-			return null;
-		}
-		for (@NonNull Node primaryTrueNode : primaryTrueNodes) {
-			boolean gotIt = false;
-			for (@NonNull Node secondaryTrueNode : secondaryTrueNodes) {
-				assert secondaryTrueNode != null;
-				Map<@NonNull Node, @NonNull Node> primary2secondary = new HashMap<>();
-				if (isEquivalent(primaryTrueNode, secondaryTrueNode, primary2secondary)) {	// FIXME use hashes
-					gotIt = true;
-					for (@NonNull Node primaryNode : primary2secondary.keySet()) {
-						Node equivalentNode = primary2secondary.get(primaryNode);
-						assert equivalentNode != null;
-						if ("if".equals(equivalentNode.getName())) {
-							equivalentNode.getName();
-						}
-						secondaryNode2primaryNode.put(equivalentNode, primaryNode);
-					}
-					break;
-				}
-			}
-			if (!gotIt) {
-				return null;
-			}
-		}
-		return secondaryNode2primaryNode;
-	}
-	private boolean canMergeInternal(@NonNull Region secondaryRegion, @NonNull Map<@NonNull Node, @NonNull Node> secondaryNode2primaryNode, @NonNull Region2Depth region2depths, boolean isLateMerge) {
-		Set<@NonNull Node> secondaryNodes = new HashSet<>(secondaryNode2primaryNode.keySet());
-		List<@NonNull Node> secondaryNodesList = new ArrayList<>(secondaryNodes);
-		for (int i = 0; i < secondaryNodesList.size(); i++) {
-			@NonNull Node secondarySourceNode = secondaryNodesList.get(i);
-			Node primarySourceNode = secondaryNode2primaryNode.get(secondarySourceNode);
-			if (primarySourceNode == null) {
-				if (secondarySourceNode.isPredicated()) {
-					return false;
-				}
-			}
-			for (@NonNull NavigableEdge secondaryEdge : secondarySourceNode.getNavigationEdges()) {
-				Node secondaryTargetNode = secondaryEdge.getTarget();
-				Node primaryTargetNode = null;
-				if (primarySourceNode != null) {
-					Edge primaryEdge = primarySourceNode.getNavigationEdge(secondaryEdge.getProperty());
-					if (primaryEdge != null) {
-						primaryTargetNode = primaryEdge.getTarget();
-						//						primaryTargetNode = primaryTargetNode.getCastEquivalentNode();
-						//						secondaryTargetNode = secondaryTargetNode.getCastEquivalentNode();
-						if (primaryTargetNode.getCompleteClass() != secondaryTargetNode.getCompleteClass()) {		// FIXME conforms
-							return false;
-						}
-						if (primaryTargetNode.isExplicitNull() != secondaryTargetNode.isExplicitNull()) {		// FIXME conforms
-							return false;
-						}
-					}
-					else {
-						if (secondaryEdge.isPredicated()) {
-							if (!isLateMerge) {		// FIXME must locate in ancestry; if present can merge, if not cannot
-								return false;
-							}
-							for (@SuppressWarnings("unused") Node secondaryOriginNode : secondaryTargetNode.getUsedBindingSources()) {
-								return false;
-							}
-						}
-					}
-				}
-				if (primaryTargetNode != null) {
-					Node primaryTargetNode2 = secondaryNode2primaryNode.get(secondaryTargetNode);
-					if (primaryTargetNode2 == null) {
-						if ("if".equals(secondaryTargetNode.getName())) {
-							secondaryTargetNode.getName();
-						}
-						secondaryNode2primaryNode.put(secondaryTargetNode, primaryTargetNode);
-					}
-				}
-				assert secondaryTargetNode != null;
-				if (secondaryNodes.add(secondaryTargetNode)) {
-					//					if (mergedTargetNode != null) {
-					//						if (!secondaryTargetNode.isAttributeNode()) {
-					secondaryNodesList.add(secondaryTargetNode);
-					//						}
-				}
-
-			}
-			if (!isLateMerge && (primarySourceNode != null)) {
-				for (@NonNull Edge secondaryEdge : secondarySourceNode.getComputationEdges()) {
-					Node secondaryTargetNode = secondaryEdge.getTarget();
-					Node primaryTargetNode = null;
-					for (@NonNull Edge primaryEdge : primarySourceNode.getComputationEdges()) {
-						if (ClassUtil.safeEquals(primaryEdge.getName(), secondaryEdge.getName())) {
-							primaryTargetNode = primaryEdge.getTarget();
-							if (isEquivalent(secondaryTargetNode, primaryTargetNode, secondaryNode2primaryNode)) {
-								secondaryNodesList.add(secondaryTargetNode);
-							}
-						}
-					}
-				}
-			}
-			/*
-
-					}
-					if (secondaryEdge instanceof NavigationEdge) {
-						Edge primaryEdge = primarySourceNode.getNavigationEdge(((NavigationEdge)secondaryEdge).getProperty());
-						if (primaryEdge != null) {
-							primaryTargetNode = primaryEdge.getTarget();
-//							primaryTargetNode = primaryTargetNode.getCastEquivalentNode();
-//							secondaryTargetNode = secondaryTargetNode.getCastEquivalentNode();
-							if (primaryTargetNode.getCompleteClass() != secondaryTargetNode.getCompleteClass()) {		// FIXME conforms
-								return false;
-							}
-						}
-						else {
-							if (secondaryEdge.isPredicated()) {
-								if (!isLateMerge) {		// FIXME must locate in ancestry; if present can merge, if not cannot
-									return false;
-								}
-								for (@SuppressWarnings("null")@NonNull Node secondaryOriginNode : secondaryTargetNode.getUsedBindingSources()) {
-									if (!region2depths.isAfter(secondaryOriginNode, this)) {
-										return false;
-									}
-								}
-							}
-						}
-					}
-					else {} // FIXME???
-				}
-				if (primaryTargetNode != null) {
-					Node primaryTargetNode2 = secondaryNode2primaryNode.get(secondaryTargetNode);
-					if (primaryTargetNode2 == null) {
-						secondaryNode2primaryNode.put(secondaryTargetNode, primaryTargetNode);
-					}
-					if (secondaryNodes.add(secondaryTargetNode)) {
-	//					if (mergedTargetNode != null) {
-						if (!secondaryTargetNode.isAttributeNode()) {
-							secondaryNodesList.add(secondaryTargetNode);
-						}
-					}
-				}
-			} */
-		}
-		return true;
-	}
-
-	@Override
 	public void checkIncomingConnections() {
 		/*		for (@NonNull Node node : getNodes()) {
 			NodeConnection incomingConnection = node.getIncomingConnection();
@@ -1599,22 +1415,6 @@
 		return "blue";
 	}
 
-	private @NonNull Map<@NonNull CompleteClass, @NonNull List<@NonNull Node>> getCompleteClass2Node() {
-		Map<@NonNull CompleteClass, @NonNull List<@NonNull Node>> completeClass2node = new HashMap<>();
-		for (@NonNull Node node : getNodes()) {
-			CompleteClass completeClass = node.getCompleteClass();
-			List<@NonNull Node> mergedNodes = completeClass2node.get(completeClass);
-			if (mergedNodes == null) {
-				mergedNodes = new ArrayList<>();
-				completeClass2node.put(completeClass, mergedNodes);
-			}
-			if (!mergedNodes.contains(node)) {
-				mergedNodes.add(node);
-			}
-		}
-		return completeClass2node;
-	}
-
 	@Override
 	public final @NonNull Iterable<@NonNull Node> getComposedNodes() {
 		return Iterables.filter(nodes, IsComposedNodePredicate.INSTANCE);
@@ -2093,42 +1893,6 @@
 		return false;
 	}
 
-	/**
-	 * Return true if the operation nodes for primaryNode and secondaryNode are equivalent
-	 * assigning equivalences to equivalentNodes.
-	 */
-	private boolean isEquivalent(@NonNull Node primaryNode, @NonNull Node secondaryNode, @NonNull Map<@NonNull Node, @NonNull Node> primary2secondary) {
-		Node node = primary2secondary.get(primaryNode);
-		if (node != null) {
-			return node == secondaryNode;
-		}
-		if (primaryNode.getNodeRole() != secondaryNode.getNodeRole()) {
-			return false;
-		}
-		if (!ClassUtil.safeEquals(primaryNode.getName(), secondaryNode.getName())) {		// FIXME stronger e.g. referredOperation
-			return false;
-		}
-		HashMap<@NonNull Node, @NonNull Node> nestedPrimary2secondary = new HashMap<>(primary2secondary);
-		nestedPrimary2secondary.put(primaryNode, secondaryNode);
-		for (@NonNull Edge primaryEdge : primaryNode.getArgumentEdges()) {
-			boolean gotIt = false;
-			for (@NonNull Edge secondaryEdge : secondaryNode.getArgumentEdges()) {
-				if (ClassUtil.safeEquals(primaryEdge.getName(), secondaryEdge.getName())) {
-					if (!isEquivalent(primaryEdge.getSource(), secondaryEdge.getSource(), nestedPrimary2secondary)) {
-						return false;
-					}
-					gotIt = true;
-					break;
-				}
-			}
-			if (!gotIt) {
-				return false;
-			}
-		}
-		primary2secondary.putAll(nestedPrimary2secondary);
-		return true;
-	}
-
 	@Override
 	public boolean isOperationRegion() {
 		return false;
@@ -2288,11 +2052,11 @@
 	}
 
 	public void resolveRecursion() {
-		Map<@NonNull CompleteClass, @NonNull List<@NonNull Node>> completeClass2node = getCompleteClass2Node();
+		Map<@NonNull CompleteClass, @NonNull List<@NonNull Node>> completeClass2nodes = RegionUtil.getCompleteClass2Nodes(this);
 		List<@NonNull Node> headNodes = getHeadNodes();
 		if (headNodes.size() == 1) {			// FIXME multi-heads
 			Node headNode = headNodes.get(0);
-			List<@NonNull Node> nodeList = completeClass2node.get(headNode.getCompleteClass());
+			List<@NonNull Node> nodeList = completeClass2nodes.get(headNode.getCompleteClass());
 			assert nodeList != null;
 			if (nodeList.size() > 1) {
 				for (@NonNull Node node : nodeList) {
@@ -2313,75 +2077,6 @@
 		}
 	}
 
-	/**
-	 * Chose the headNode from a group of peer nodes that has the most non-implicit properties targeting its peers.
-	 */
-	protected @NonNull Node selectBestHeadNode(@NonNull List<@NonNull Node> headNodes) {
-		int size = headNodes.size();
-		assert size >= 1;
-		if (size == 1) {
-			return headNodes.get(0);
-		}
-		Node bestHeadNode = null;
-		int bestNonImplicits = -1;
-		List<@NonNull Node> sortedHeadNodes = new ArrayList<>(headNodes);
-		Collections.sort(sortedHeadNodes, NameUtil.NAMEABLE_COMPARATOR);		// Stabilize order
-		for (@NonNull Node thisHeadNode : sortedHeadNodes) {
-			int nonImplicits = 0;
-			for (@NonNull Node thatHeadNode : sortedHeadNodes) {
-				for (@NonNull NavigableEdge edge : thisHeadNode.getNavigationEdges()) {
-					if (edge.getTarget() == thatHeadNode) {
-						Property property = edge.getProperty();
-						if (!property.isIsImplicit()) {
-							nonImplicits++;
-							break;
-						}
-					}
-				}
-			}
-			if (nonImplicits > bestNonImplicits) {
-				bestHeadNode = thisHeadNode;
-				bestNonImplicits = nonImplicits;
-			}
-		}
-		assert bestHeadNode != null;
-		return bestHeadNode;
-	}
-
-	private @Nullable Node selectMergedHeadNode(@NonNull Node headNode, @NonNull List<@NonNull Node> mergedNodes) {
-		if (mergedNodes.size() == 1) {
-			Node mergedNode = selectBestHeadNode(mergedNodes);
-			if (mergedNode.isIterator()) {
-				return null;
-			}
-			return mergedNode;
-		}
-		if (mergedNodes.size() == 0) {
-			return null;
-		}
-		Iterable<NavigableEdge> predicateEdges = headNode.getPredicateEdges();
-		//		if (predicateEdges == null) {
-		//			return null;
-		//		}
-		for (@NonNull Node mergedNode : mergedNodes) {
-			boolean ok = !mergedNode.isIterator();
-			if (ok) {
-				for (@NonNull NavigableEdge predicateEdge : predicateEdges) {
-					Property property = predicateEdge.getProperty();
-					Node navigation = mergedNode.getNavigationTarget(property);
-					if (navigation == null) {
-						ok = false;
-						break;
-					}
-				}
-			}
-			if (ok) {						// FIXME stronger checking
-				return mergedNode;
-			}
-		}
-		return null;
-	}
-
 	@Override
 	public void setInvokingRegion(@NonNull ScheduledRegion invokingRegion) {
 		this.invokingRegion  = invokingRegion;
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/QVTp2QVTs.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/QVTp2QVTs.java
index 3a79bae..0678cd6 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/QVTp2QVTs.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/QVTp2QVTs.java
@@ -37,6 +37,7 @@
 import org.eclipse.qvtd.compiler.ProblemHandler;
 import org.eclipse.qvtd.compiler.internal.qvtp2qvts.analysis.ClassDatumAnalysis;
 import org.eclipse.qvtd.compiler.internal.qvts2qvts.Region2Depth;
+import org.eclipse.qvtd.compiler.internal.qvts2qvts.merger.EarlyMerger;
 import org.eclipse.qvtd.pivot.qvtbase.Transformation;
 import org.eclipse.qvtd.pivot.qvtcore.Mapping;
 import org.eclipse.qvtd.pivot.schedule.ClassDatum;
@@ -140,10 +141,10 @@
 					for (@NonNull MappingRegion secondaryRegion : secondaryRegions) {
 						assert secondaryRegion != null;
 						if (residualInputRegions.contains(secondaryRegion)) {
-							Map<@NonNull Node, @NonNull Node> secondaryNode2primaryNode = mergedRegion.canMerge(secondaryRegion, region2depths, false);
+							Map<@NonNull Node, @NonNull Node> secondaryNode2primaryNode = EarlyMerger.canMerge(mergedRegion, secondaryRegion, region2depths, false);
 							if (secondaryNode2primaryNode != null) {
 								boolean isSharedHead = isSharedHead(mergedRegion, secondaryRegion);
-								if (!isSharedHead || (secondaryRegion.canMerge(mergedRegion, region2depths, false) != null)) {
+								if (!isSharedHead || (EarlyMerger.canMerge(secondaryRegion, mergedRegion, region2depths, false) != null)) {
 									residualInputRegions.remove(mergedRegion);
 									residualInputRegions.remove(secondaryRegion);
 									mergedRegion = RegionMerger.createMergedRegion(mergedRegion, secondaryRegion, secondaryNode2primaryNode);
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/Region.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/Region.java
index 489668d..2b9b85c 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/Region.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/Region.java
@@ -21,7 +21,6 @@
 import org.eclipse.ocl.pivot.VariableDeclaration;
 import org.eclipse.ocl.pivot.utilities.Nameable;
 import org.eclipse.qvtd.compiler.internal.qvtp2qvts.analysis.ClassDatumAnalysis;
-import org.eclipse.qvtd.compiler.internal.qvts2qvts.Region2Depth;
 import org.eclipse.qvtd.pivot.qvtbase.TypedModel;
 import org.eclipse.qvtd.pivot.qvtbase.graphs.GraphStringBuilder;
 import org.eclipse.qvtd.pivot.qvtbase.graphs.GraphStringBuilder.GraphNode;
@@ -38,7 +37,6 @@
 	void addVariableNode(@NonNull VariableDeclaration variable, @NonNull Node node);
 	void buildPredicatedNavigationEdgesIndex(@NonNull Map<@NonNull TypedModel, @NonNull Map<@NonNull Property, @NonNull List<@NonNull NavigableEdge>>> typedModel2property2predicatedEdges);
 	void buildRealizedNavigationEdgesIndex(@NonNull Map<@NonNull TypedModel, @NonNull Map<@NonNull Property, @NonNull List<@NonNull NavigableEdge>>> typedModel2property2realizedEdges);
-	@Nullable Map<@NonNull Node, @NonNull Node> canMerge(@NonNull Region secondaryRegion, @NonNull Region2Depth region2depths, boolean isLateMerge);
 	void checkIncomingConnections();
 	void computeCheckedOrEnforcedEdges(@NonNull Map<@NonNull TypedModel, @NonNull Map<@NonNull Property, @NonNull List<@NonNull NavigableEdge>>> typedModel2property2predicatedEdges,
 			@NonNull Map<@NonNull TypedModel, @NonNull Map<@NonNull Property, @NonNull List<@NonNull NavigableEdge>>> typedModel2property2realizedEdges);
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/RegionUtil.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/RegionUtil.java
index 99f50ab..06a1576 100644
--- a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/RegionUtil.java
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvtp2qvts/RegionUtil.java
@@ -10,6 +10,11 @@
  *******************************************************************************/
 package org.eclipse.qvtd.compiler.internal.qvtp2qvts;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
@@ -359,6 +364,22 @@
 		}
 	}
 
+	public static @NonNull Map<@NonNull CompleteClass, @NonNull List<@NonNull Node>> getCompleteClass2Nodes(@NonNull Region region) {
+		Map<@NonNull CompleteClass, @NonNull List<@NonNull Node>> completeClass2node = new HashMap<>();
+		for (@NonNull Node node : region.getNodes()) {
+			CompleteClass completeClass = node.getCompleteClass();
+			List<@NonNull Node> mergedNodes = completeClass2node.get(completeClass);
+			if (mergedNodes == null) {
+				mergedNodes = new ArrayList<>();
+				completeClass2node.put(completeClass, mergedNodes);
+			}
+			if (!mergedNodes.contains(node)) {
+				mergedNodes.add(node);
+			}
+		}
+		return completeClass2node;
+	}
+
 	public static Role.@NonNull Phase getOperationNodePhase(@NonNull Region region, @NonNull TypedElement typedElement, @NonNull Node... argNodes) {
 		boolean isLoaded = false;
 		boolean isPredicated = false;
diff --git a/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/merger/EarlyMerger.java b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/merger/EarlyMerger.java
new file mode 100644
index 0000000..5bf9ae9
--- /dev/null
+++ b/plugins/org.eclipse.qvtd.compiler/src/org/eclipse/qvtd/compiler/internal/qvts2qvts/merger/EarlyMerger.java
@@ -0,0 +1,323 @@
+/*******************************************************************************
+ * Copyright (c) 2016 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.merger;
+
+import java.util.ArrayList;
+import java.util.Collections;
+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.CompleteClass;
+import org.eclipse.ocl.pivot.Property;
+import org.eclipse.ocl.pivot.utilities.ClassUtil;
+import org.eclipse.ocl.pivot.utilities.NameUtil;
+import org.eclipse.qvtd.compiler.internal.qvtp2qvts.Edge;
+import org.eclipse.qvtd.compiler.internal.qvtp2qvts.NavigableEdge;
+import org.eclipse.qvtd.compiler.internal.qvtp2qvts.Node;
+import org.eclipse.qvtd.compiler.internal.qvtp2qvts.Region;
+import org.eclipse.qvtd.compiler.internal.qvtp2qvts.RegionUtil;
+import org.eclipse.qvtd.compiler.internal.qvts2qvts.Region2Depth;
+
+import com.google.common.collect.Iterables;
+
+public class EarlyMerger
+{
+	public static @Nullable Map<@NonNull Node, @NonNull Node> canMerge(@NonNull Region primaryRegion, @NonNull Region secondaryRegion, @NonNull Region2Depth region2depths, boolean isLateMerge) {
+		Map<@NonNull Node, @NonNull Node> secondaryNode2primaryNode = null;
+		Map<@NonNull CompleteClass, @NonNull List<@NonNull Node>> completeClass2nodes = RegionUtil.getCompleteClass2Nodes(primaryRegion);
+		//
+		//	Find the unambiguous head-node matches
+		//
+		List<@NonNull Node> secondaryHeadNodes = secondaryRegion.getHeadNodes();
+		if (secondaryHeadNodes.size() != 1) {
+			return null;
+		}
+		Node secondaryHeadNode = secondaryHeadNodes.get(0);
+		CompleteClass completeClass = secondaryHeadNode.getCompleteClass();
+		List<@NonNull Node> primaryNodes = completeClass2nodes.get(completeClass);
+		if (primaryNodes != null) {
+			Node primaryHeadNode = selectMergedHeadNode(secondaryHeadNode, primaryNodes);
+			if (primaryHeadNode == null) {
+				return null;
+			}
+			secondaryNode2primaryNode = new HashMap<>();
+			if ("if".equals(secondaryHeadNode.getName())) {
+				secondaryHeadNode.getName();
+			}
+			secondaryNode2primaryNode.put(secondaryHeadNode, primaryHeadNode);
+		}
+		if (secondaryNode2primaryNode == null) {
+			return null;
+		}
+		//
+		//	Validate the transitive navigation from the head nodes. All common navigation edges must have compatible node types.
+		//
+		if (!canMergeInternal(secondaryRegion, secondaryNode2primaryNode, region2depths, isLateMerge)) {
+			return null;
+		}
+		//FIXME Must be symmetrically mergeable; do tests before creating MergedRegion
+		//
+		//	Validate the true node predicate compatibility
+		//
+		Iterable<@NonNull Node> primaryTrueNodes = primaryRegion.getTrueNodes();
+		Iterable<@NonNull Node> secondaryTrueNodes = secondaryRegion.getTrueNodes();
+		if (Iterables.size(primaryTrueNodes) != Iterables.size(secondaryTrueNodes)) {
+			return null;
+		}
+		for (@NonNull Node primaryTrueNode : primaryTrueNodes) {
+			boolean gotIt = false;
+			for (@NonNull Node secondaryTrueNode : secondaryTrueNodes) {
+				assert secondaryTrueNode != null;
+				Map<@NonNull Node, @NonNull Node> primary2secondary = new HashMap<>();
+				if (isEquivalent(primaryTrueNode, secondaryTrueNode, primary2secondary)) {	// FIXME use hashes
+					gotIt = true;
+					for (@NonNull Node primaryNode : primary2secondary.keySet()) {
+						Node equivalentNode = primary2secondary.get(primaryNode);
+						assert equivalentNode != null;
+						if ("if".equals(equivalentNode.getName())) {
+							equivalentNode.getName();
+						}
+						secondaryNode2primaryNode.put(equivalentNode, primaryNode);
+					}
+					break;
+				}
+			}
+			if (!gotIt) {
+				return null;
+			}
+		}
+		return secondaryNode2primaryNode;
+	}
+	private static boolean canMergeInternal(@NonNull Region secondaryRegion, @NonNull Map<@NonNull Node, @NonNull Node> secondaryNode2primaryNode, @NonNull Region2Depth region2depths, boolean isLateMerge) {
+		Set<@NonNull Node> secondaryNodes = new HashSet<>(secondaryNode2primaryNode.keySet());
+		List<@NonNull Node> secondaryNodesList = new ArrayList<>(secondaryNodes);
+		for (int i = 0; i < secondaryNodesList.size(); i++) {
+			@NonNull Node secondarySourceNode = secondaryNodesList.get(i);
+			Node primarySourceNode = secondaryNode2primaryNode.get(secondarySourceNode);
+			if (primarySourceNode == null) {
+				if (secondarySourceNode.isPredicated()) {
+					return false;
+				}
+			}
+			for (@NonNull NavigableEdge secondaryEdge : secondarySourceNode.getNavigationEdges()) {
+				Node secondaryTargetNode = secondaryEdge.getTarget();
+				Node primaryTargetNode = null;
+				if (primarySourceNode != null) {
+					Edge primaryEdge = primarySourceNode.getNavigationEdge(secondaryEdge.getProperty());
+					if (primaryEdge != null) {
+						primaryTargetNode = primaryEdge.getTarget();
+						//						primaryTargetNode = primaryTargetNode.getCastEquivalentNode();
+						//						secondaryTargetNode = secondaryTargetNode.getCastEquivalentNode();
+						if (primaryTargetNode.getCompleteClass() != secondaryTargetNode.getCompleteClass()) {		// FIXME conforms
+							return false;
+						}
+						if (primaryTargetNode.isExplicitNull() != secondaryTargetNode.isExplicitNull()) {		// FIXME conforms
+							return false;
+						}
+					}
+					else {
+						if (secondaryEdge.isPredicated()) {
+							if (!isLateMerge) {		// FIXME must locate in ancestry; if present can merge, if not cannot
+								return false;
+							}
+							for (@SuppressWarnings("unused") Node secondaryOriginNode : secondaryTargetNode.getUsedBindingSources()) {
+								return false;
+							}
+						}
+					}
+				}
+				if (primaryTargetNode != null) {
+					Node primaryTargetNode2 = secondaryNode2primaryNode.get(secondaryTargetNode);
+					if (primaryTargetNode2 == null) {
+						if ("if".equals(secondaryTargetNode.getName())) {
+							secondaryTargetNode.getName();
+						}
+						secondaryNode2primaryNode.put(secondaryTargetNode, primaryTargetNode);
+					}
+				}
+				assert secondaryTargetNode != null;
+				if (secondaryNodes.add(secondaryTargetNode)) {
+					//					if (mergedTargetNode != null) {
+					//						if (!secondaryTargetNode.isAttributeNode()) {
+					secondaryNodesList.add(secondaryTargetNode);
+					//						}
+				}
+
+			}
+			if (!isLateMerge && (primarySourceNode != null)) {
+				for (@NonNull Edge secondaryEdge : secondarySourceNode.getComputationEdges()) {
+					Node secondaryTargetNode = secondaryEdge.getTarget();
+					Node primaryTargetNode = null;
+					for (@NonNull Edge primaryEdge : primarySourceNode.getComputationEdges()) {
+						if (ClassUtil.safeEquals(primaryEdge.getName(), secondaryEdge.getName())) {
+							primaryTargetNode = primaryEdge.getTarget();
+							if (isEquivalent(secondaryTargetNode, primaryTargetNode, secondaryNode2primaryNode)) {
+								secondaryNodesList.add(secondaryTargetNode);
+							}
+						}
+					}
+				}
+			}
+			/*
+
+					}
+					if (secondaryEdge instanceof NavigationEdge) {
+						Edge primaryEdge = primarySourceNode.getNavigationEdge(((NavigationEdge)secondaryEdge).getProperty());
+						if (primaryEdge != null) {
+							primaryTargetNode = primaryEdge.getTarget();
+//							primaryTargetNode = primaryTargetNode.getCastEquivalentNode();
+//							secondaryTargetNode = secondaryTargetNode.getCastEquivalentNode();
+							if (primaryTargetNode.getCompleteClass() != secondaryTargetNode.getCompleteClass()) {		// FIXME conforms
+								return false;
+							}
+						}
+						else {
+							if (secondaryEdge.isPredicated()) {
+								if (!isLateMerge) {		// FIXME must locate in ancestry; if present can merge, if not cannot
+									return false;
+								}
+								for (@SuppressWarnings("null")@NonNull Node secondaryOriginNode : secondaryTargetNode.getUsedBindingSources()) {
+									if (!region2depths.isAfter(secondaryOriginNode, this)) {
+										return false;
+									}
+								}
+							}
+						}
+					}
+					else {} // FIXME???
+				}
+				if (primaryTargetNode != null) {
+					Node primaryTargetNode2 = secondaryNode2primaryNode.get(secondaryTargetNode);
+					if (primaryTargetNode2 == null) {
+						secondaryNode2primaryNode.put(secondaryTargetNode, primaryTargetNode);
+					}
+					if (secondaryNodes.add(secondaryTargetNode)) {
+	//					if (mergedTargetNode != null) {
+						if (!secondaryTargetNode.isAttributeNode()) {
+							secondaryNodesList.add(secondaryTargetNode);
+						}
+					}
+				}
+			} */
+		}
+		return true;
+	}
+
+	/**
+	 * Return true if the operation nodes for primaryNode and secondaryNode are equivalent
+	 * assigning equivalences to equivalentNodes.
+	 */
+	private static boolean isEquivalent(@NonNull Node primaryNode, @NonNull Node secondaryNode, @NonNull Map<@NonNull Node, @NonNull Node> primary2secondary) {
+		Node node = primary2secondary.get(primaryNode);
+		if (node != null) {
+			return node == secondaryNode;
+		}
+		if (primaryNode.getNodeRole() != secondaryNode.getNodeRole()) {
+			return false;
+		}
+		if (!ClassUtil.safeEquals(primaryNode.getName(), secondaryNode.getName())) {		// FIXME stronger e.g. referredOperation
+			return false;
+		}
+		HashMap<@NonNull Node, @NonNull Node> nestedPrimary2secondary = new HashMap<>(primary2secondary);
+		nestedPrimary2secondary.put(primaryNode, secondaryNode);
+		for (@NonNull Edge primaryEdge : primaryNode.getArgumentEdges()) {
+			boolean gotIt = false;
+			for (@NonNull Edge secondaryEdge : secondaryNode.getArgumentEdges()) {
+				if (ClassUtil.safeEquals(primaryEdge.getName(), secondaryEdge.getName())) {
+					if (!isEquivalent(primaryEdge.getSource(), secondaryEdge.getSource(), nestedPrimary2secondary)) {
+						return false;
+					}
+					gotIt = true;
+					break;
+				}
+			}
+			if (!gotIt) {
+				return false;
+			}
+		}
+		primary2secondary.putAll(nestedPrimary2secondary);
+		return true;
+	}
+
+	/**
+	 * Chose the headNode from a group of peer nodes that has the most non-implicit properties targeting its peers.
+	 */
+	protected static @NonNull Node selectBestHeadNode(@NonNull List<@NonNull Node> headNodes) {
+		int size = headNodes.size();
+		assert size >= 1;
+		if (size == 1) {
+			return headNodes.get(0);
+		}
+		Node bestHeadNode = null;
+		int bestNonImplicits = -1;
+		List<@NonNull Node> sortedHeadNodes = new ArrayList<>(headNodes);
+		Collections.sort(sortedHeadNodes, NameUtil.NAMEABLE_COMPARATOR);		// Stabilize order
+		for (@NonNull Node thisHeadNode : sortedHeadNodes) {
+			int nonImplicits = 0;
+			for (@NonNull Node thatHeadNode : sortedHeadNodes) {
+				for (@NonNull NavigableEdge edge : thisHeadNode.getNavigationEdges()) {
+					if (edge.getTarget() == thatHeadNode) {
+						Property property = edge.getProperty();
+						if (!property.isIsImplicit()) {
+							nonImplicits++;
+							break;
+						}
+					}
+				}
+			}
+			if (nonImplicits > bestNonImplicits) {
+				bestHeadNode = thisHeadNode;
+				bestNonImplicits = nonImplicits;
+			}
+		}
+		assert bestHeadNode != null;
+		return bestHeadNode;
+	}
+
+	private static @Nullable Node selectMergedHeadNode(@NonNull Node headNode, @NonNull List<@NonNull Node> mergedNodes) {
+		if (mergedNodes.size() == 1) {
+			Node mergedNode = selectBestHeadNode(mergedNodes);
+			if (mergedNode.isIterator()) {
+				return null;
+			}
+			return mergedNode;
+		}
+		if (mergedNodes.size() == 0) {
+			return null;
+		}
+		Iterable<NavigableEdge> predicateEdges = headNode.getPredicateEdges();
+		//		if (predicateEdges == null) {
+		//			return null;
+		//		}
+		for (@NonNull Node mergedNode : mergedNodes) {
+			boolean ok = !mergedNode.isIterator();
+			if (ok) {
+				for (@NonNull NavigableEdge predicateEdge : predicateEdges) {
+					Property property = predicateEdge.getProperty();
+					Node navigation = mergedNode.getNavigationTarget(property);
+					if (navigation == null) {
+						ok = false;
+						break;
+					}
+				}
+			}
+			if (ok) {						// FIXME stronger checking
+				return mergedNode;
+			}
+		}
+		return null;
+	}
+}